nectar/kinode/packages/app_store/api/app_store:sys-v0.wit

interface downloads {
    //
    // download API as presented by download:app_store:sys-v0
    //

    use standard.{package-id};

    variant downloads {
        download(download-request),
        chunk(chunk-request),
        progress(progress-update),
        size(size-update),
    }

    record download-request {
        package-id: package-id,
        download-from: option<string>, // note, might be too much implicit complexity,
                                       // but: download-from received locally, is an instruction where to download-from
                                       // and if received from remote, is an instruction where to send, where the "download-from" came from.
        desired-version-hash: string,
    }

    record download-response {
        success: bool,
        error: option<string>,
    }

    record chunk-request {
        package-id: package-id,
        version-hash: string,
        offset: u64,
        length: u64,
    }

    record progress-update {
        package-id: package-id,
        version-hash: string,
        downloaded: u64,
        total: u64,
    }

    record size-update {
        package-id: package-id,
        size: u64,
    }
}

interface chain {
    //
    // on-chain API as presented by chain:app_store:sys-v0
    //

    use standard.{package-id};

    record on-chain-app {
        metadata-uri: string,
        metadata-hash: string,
        // this might be a thing internally, but could also just be fetched on demand
        // would negate them becoming outdated
        metadata: option<metadata-file>,
    }

    record metadata-file {
        package-name: string,
        publisher: string,
        current-version: string,
        mirrors: list<string>,
        code-hashes: list<tuple<string, string>>,
        license: option<string>,
        screenshots: option<list<string>>,
        wit-version: option<u32>,
        dependencies: option<list<string>>,
    }

    record get-app {
        app: package-id,
    }

    record get-app-response {
        app: on-chain-app,
    }

    // add variant
    // and these:
    // start-mirroring(package-id),
    // stop-mirroring(package-id),
    // start-auto-update(package-id),
    // stop-auto-update(package-id),

}

interface main {
    //
    // app store API as presented by main:app_store:sys-v0
    //

    use standard.{package-id};

    record onchain-metadata {
        name: option<string>,
        description: option<string>,
        image: option<string>,
        external-url: option<string>,
        animation-url: option<string>,
        properties: onchain-properties,
    }

    record onchain-properties {
        package-name: string,
        publisher: string,
        current-version: string,
        mirrors: list<string>,
        code-hashes: list<tuple<string, string>>,
        license: option<string>,
        screenshots: option<list<string>>,
        wit-version: option<u32>,
        dependencies: option<list<string>>,
    }

    variant request {
        remote(remote-request),
        local(local-request),
    }

    variant response {
        remote(remote-response),
        local(local-response),
    }

    variant remote-request {
        download(remote-download-request),
    }

    record remote-download-request {
        package-id: package-id,
        desired-version-hash: option<string>,
    }

    variant remote-response {
        download-approved,
        download-denied(reason),
    }

    variant reason {
        no-package,
        not-mirroring,
        hash-mismatch(hash-mismatch),
        file-not-found,
        worker-spawn-failed
    }

    record hash-mismatch {
        requested: string,
        have: string,
    }

    variant local-request {
        new-package(new-package-request),
        download(download-request),
        install(package-id),
        uninstall(package-id),
        start-mirroring(package-id),
        stop-mirroring(package-id),
        start-auto-update(package-id),
        stop-auto-update(package-id),
        rebuild-index,
        apis,
        get-api(package-id),
    }

    record new-package-request {
        package-id: package-id,
        metadata: onchain-metadata,
        mirror: bool,
    }

    record download-request {
        package-id: package-id,
        download-from: string,
        mirror: bool,
        auto-update: bool,
        desired-version-hash: option<string>,
    }

    variant local-response {
        new-package-response(new-package-response),
        download-response(download-response),
        install-response(install-response),
        uninstall-response(uninstall-response),
        mirror-response(mirror-response),
        auto-update-response(auto-update-response),
        rebuild-index-response(rebuild-index-response),
        apis-response(apis-response),
        get-api-response(get-api-response),
    }

    enum new-package-response {
        success,
        no-blob,
        install-failed,
        already-exists,
    }

    variant download-response {
        started,
        bad-response,
        denied(reason),
        already-exists,
        already-downloading,
    }

    enum install-response {
        success,
        failure, // TODO
    }

    enum uninstall-response {
        success,
        failure, // TODO
    }

    enum mirror-response {
        success,
        failure, // TODO
    }

    enum auto-update-response {
        success,
        failure, // TODO
    }

    enum rebuild-index-response {
        success,
        failure, // TODO
    }

    record apis-response {
        apis: list<package-id>,
    }

    // the API itself will be in response blob if success!
    enum get-api-response {
        success,
        failure, // TODO
    }
}

world app-store-sys-v0 {
    import main;
    import downloads;
    import chain;
    include process-v0;
}