@asterai/cli 0.4.0 → 0.6.0

package/README.md

@@ -20,7 +20,7 @@ $ npm install -g @asterai/cli
 $ asterai COMMAND
 running command...
 $ asterai (--version)
-@asterai/cli/0.4.0 linux-x64 node-v20.12.2
+@asterai/cli/0.6.0 darwin-arm64 node-v20.12.2
 $ asterai --help [COMMAND]
 USAGE
   $ asterai COMMAND
@@ -32,11 +32,10 @@ USAGE
 
 <!-- commands -->
 * [`asterai auth KEY`](#asterai-auth-key)
-* [`asterai build [INPUT]`](#asterai-build-input)
-* [`asterai codegen`](#asterai-codegen)
-* [`asterai deploy [INPUT]`](#asterai-deploy-input)
+* [`asterai deploy`](#asterai-deploy)
 * [`asterai help [COMMAND]`](#asterai-help-command)
 * [`asterai init [OUTDIR]`](#asterai-init-outdir)
+* [`asterai pkg [INPUT]`](#asterai-pkg-input)
 * [`asterai query`](#asterai-query)
 
 ## `asterai auth KEY`
@@ -54,111 +53,97 @@ EXAMPLES
   $ asterai auth
 ```
 
-_See code: [src/commands/auth.ts](https://github.com/asterai-io/asterai-sdk/blob/v0.4.0/src/commands/auth.ts)_
+_See code: [src/commands/auth.ts](https://github.com/asterai-io/asterai-sdk/blob/v0.6.0/src/commands/auth.ts)_
 
-## `asterai build [INPUT]`
+## `asterai deploy`
 
-compiles the plugin
+uploads a plugin to asterai
 
 ```
 USAGE
-  $ asterai build [INPUT] [-m <value>]
+  $ asterai deploy [-a <value>] [-e <value>] [-s] [--plugin <value>] [--pkg <value>]
 
 FLAGS
-  -m, --manifest=<value>  [default: plugin.asterai.proto] manifest path
+  -a, --agent=<value>     agent ID to immediately activate this plugin for
+  -e, --endpoint=<value>  [default: https://api.asterai.io]
+  -s, --staging
+      --pkg=<value>       [default: package.wasm] package WASM path
+      --plugin=<value>    [default: plugin.wasm] plugin WASM path
 
 DESCRIPTION
-  compiles the plugin
+  uploads a plugin to asterai
 
 EXAMPLES
-  $ asterai build
+  $ asterai deploy --app 66a46b12-b1a7-4b72-a64a-0e4fe21902b6
 ```
 
-_See code: [src/commands/build.ts](https://github.com/asterai-io/asterai-sdk/blob/v0.4.0/src/commands/build.ts)_
+_See code: [src/commands/deploy.ts](https://github.com/asterai-io/asterai-sdk/blob/v0.6.0/src/commands/deploy.ts)_
 
-## `asterai codegen`
+## `asterai help [COMMAND]`
 
-Generate code from the plugin manifest
+Display help for asterai.
 
 ```
 USAGE
-  $ asterai codegen [-m <value>] [-o <value>] [-a <value>] [-l <value>] [-s]
+  $ asterai help [COMMAND...] [-n]
+
+ARGUMENTS
+  COMMAND...  Command to show help for.
 
 FLAGS
-  -a, --appId=<value>      app id
-  -l, --language=<value>   [default: js] language of generated typings
-  -m, --manifest=<value>   [default: plugin.asterai.proto] manifest path
-  -o, --outputDir=<value>  [default: generated] output directory
-  -s, --staging            use staging endpoint
+  -n, --nested-commands  Include all nested commands in the output.
 
 DESCRIPTION
-  Generate code from the plugin manifest
-
-EXAMPLES
-  $ asterai codegen
+  Display help for asterai.
 ```
 
-_See code: [src/commands/codegen.ts](https://github.com/asterai-io/asterai-sdk/blob/v0.4.0/src/commands/codegen.ts)_
+_See code: [@oclif/plugin-help](https://github.com/oclif/plugin-help/blob/v6.2.0/src/commands/help.ts)_
 
-## `asterai deploy [INPUT]`
+## `asterai init [OUTDIR]`
 
-compiles and uploads the plugin to asterai
+Initialise a new plugin project
 
 ```
 USAGE
-  $ asterai deploy [INPUT] -a <value> [-m <value>] [-e <value>] [-s]
+  $ asterai init [OUTDIR] [--typescript] [--rust]
 
 FLAGS
-  -a, --app=<value>       (required) app ID to immediately configure this plugin with
-  -e, --endpoint=<value>  [default: https://api.asterai.io/app/plugin]
-  -m, --manifest=<value>  [default: plugin.asterai.proto] manifest path
-  -s, --staging
+  --rust        init a the plugin project in rust
+  --typescript  init a the plugin project in typescript
 
 DESCRIPTION
-  compiles and uploads the plugin to asterai
+  Initialise a new plugin project
 
 EXAMPLES
-  $ asterai deploy --app 66a46b12-b1a7-4b72-a64a-0e4fe21902b6
+  $ asterai init project-name
 ```
 
-_See code: [src/commands/deploy.ts](https://github.com/asterai-io/asterai-sdk/blob/v0.4.0/src/commands/deploy.ts)_
+_See code: [src/commands/init.ts](https://github.com/asterai-io/asterai-sdk/blob/v0.6.0/src/commands/init.ts)_
 
-## `asterai help [COMMAND]`
+## `asterai pkg [INPUT]`
 
-Display help for asterai.
+bundles the WIT into a binary WASM package
 
 ```
 USAGE
-  $ asterai help [COMMAND...] [-n]
+  $ asterai pkg [INPUT] [-o <value>] [-w <value>] [-e <value>]
 
 ARGUMENTS
-  COMMAND...  Command to show help for.
+  INPUT  [default: plugin.wit] path to the plugin's WIT file
 
 FLAGS
-  -n, --nested-commands  Include all nested commands in the output.
-
-DESCRIPTION
-  Display help for asterai.
-```
-
-_See code: [@oclif/plugin-help](https://github.com/oclif/plugin-help/blob/v6.0.22/src/commands/help.ts)_
-
-## `asterai init [OUTDIR]`
-
-Initialise a new plugin project
-
-```
-USAGE
-  $ asterai init [OUTDIR]
+  -e, --endpoint=<value>  [default: https://api.asterai.io]
+  -o, --output=<value>    [default: package.wasm] output file name for the binary WASM package
+  -w, --wit=<value>       [default: package.wit] output package converted to the WIT format
 
 DESCRIPTION
-  Initialise a new plugin project
+  bundles the WIT into a binary WASM package
 
 EXAMPLES
-  $ asterai init project-name
+  $ asterai pkg
 ```
 
-_See code: [src/commands/init.ts](https://github.com/asterai-io/asterai-sdk/blob/v0.4.0/src/commands/init.ts)_
+_See code: [src/commands/pkg.ts](https://github.com/asterai-io/asterai-sdk/blob/v0.6.0/src/commands/pkg.ts)_
 
 ## `asterai query`
 
@@ -181,5 +166,5 @@ EXAMPLES
   $ asterai query
 ```
 
-_See code: [src/commands/query.ts](https://github.com/asterai-io/asterai-sdk/blob/v0.4.0/src/commands/query.ts)_
+_See code: [src/commands/query.ts](https://github.com/asterai-io/asterai-sdk/blob/v0.6.0/src/commands/query.ts)_
 <!-- commandsstop -->

package/dist/commands/deploy.d.ts

@@ -1,16 +1,14 @@
 import { Command } from "@oclif/core";
 export default class Deploy extends Command {
-    static args: {
-        input: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
-    };
+    static args: {};
     static description: string;
     static examples: string[];
     static flags: {
-        app: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-        manifest: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        agent: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         endpoint: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         staging: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        plugin: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        pkg: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
     };
     run(): Promise<void>;
 }
-export declare const mergeProtoImports: (proto: string, protoPath: string, excludeSdk?: boolean, excludeSyntaxDefinition?: boolean, n?: number) => string;

package/dist/commands/deploy.js

@@ -1,59 +1,57 @@
-import { Args, Command, Flags } from "@oclif/core";
+import { Command, Flags } from "@oclif/core";
 import fs from "fs";
-import path from "path";
 import FormData from "form-data";
 import axios from "axios";
 import { getConfigValue } from "../config.js";
-import { build } from "./build.js";
-const PRODUCTION_ENDPOINT = "https://api.asterai.io/app/plugin";
-const STAGING_ENDPOINT = "https://staging.api.asterai.io/app/plugin";
+import { BASE_API_URL, BASE_API_URL_STAGING } from "../const.js";
+import path from "path";
+// If the input file doesn't exist, try looking into this dir.
+const RETRY_FIND_FILE_DIR = "build/";
 export default class Deploy extends Command {
-    static args = {
-        input: Args.string({
-            default: "plugin.ts",
-        }),
-    };
-    static description = "compiles and uploads the plugin to asterai";
+    static args = {};
+    static description = "uploads a plugin to asterai";
     static examples = [
         `<%= config.bin %> <%= command.id %> --app 66a46b12-b1a7-4b72-a64a-0e4fe21902b6`,
     ];
     static flags = {
-        app: Flags.string({
+        agent: Flags.string({
             char: "a",
-            description: "app ID to immediately configure this plugin with",
-            required: true,
-        }),
-        manifest: Flags.string({
-            char: "m",
-            description: "manifest path",
-            default: "plugin.asterai.proto",
+            description: "agent ID to immediately activate this plugin for",
+            required: false,
         }),
         endpoint: Flags.string({
             char: "e",
-            default: PRODUCTION_ENDPOINT,
+            default: BASE_API_URL,
         }),
         staging: Flags.boolean({
             char: "s",
         }),
+        plugin: Flags.string({
+            description: "plugin WASM path",
+            default: "plugin.wasm",
+        }),
+        pkg: Flags.string({
+            description: "package WASM path",
+            default: "package.wasm",
+        }),
     };
     async run() {
-        const { args, flags } = await this.parse(Deploy);
-        const output = await build(args, flags);
-        await deploy(output, flags);
+        const { flags } = await this.parse(Deploy);
+        await deploy(flags);
     }
 }
-const deploy = async (args, flags) => {
+const deploy = async (flags) => {
     const form = new FormData();
-    form.append("app_id", flags.app);
-    form.append("module", fs.readFileSync(args.outputFile));
-    const manifestString = fs.readFileSync(args.manifestPath, {
-        encoding: "utf8",
-    });
-    const mergedManifestString = mergeProtoImports(manifestString, args.manifestPath);
-    form.append("manifest", mergedManifestString);
-    const url = flags.staging ? STAGING_ENDPOINT : flags.endpoint;
+    if (flags.agent) {
+        form.append("agent_id", flags.agent);
+    }
+    const plugin = readFile(flags.plugin);
+    const pkg = readFile(flags.pkg);
+    form.append("plugin.wasm", plugin);
+    form.append("package.wasm", pkg);
+    const baseApiUrl = flags.staging ? BASE_API_URL_STAGING : flags.endpoint;
     await axios({
-        url,
+        url: `${baseApiUrl}/v1/plugin`,
         method: "put",
         data: form,
         headers: {
@@ -64,38 +62,17 @@ const deploy = async (args, flags) => {
         .then(() => console.log("done"))
         .catch(logRequestError);
 };
-export const mergeProtoImports = (proto, protoPath, excludeSdk = true, excludeSyntaxDefinition = true, n = 0) => {
-    let mergedManifestString = "";
-    const lines = proto.split("\n");
-    for (let line of lines) {
-        line = line.trim();
-        const isSyntaxLine = line.startsWith("syntax");
-        if (isSyntaxLine && (excludeSyntaxDefinition || n > 1)) {
-            continue;
-        }
-        const isImportLine = line.startsWith("import");
-        if (!isImportLine) {
-            mergedManifestString = `${mergedManifestString}\n${line}`;
-            continue;
-        }
-        const importLine = line.replaceAll("'", '"');
-        const pathStart = importLine.indexOf('"') + 1;
-        const pathEnd = importLine.lastIndexOf('"');
-        const pathRelative = importLine.substring(pathStart, pathEnd);
-        const isSdkImport = pathRelative.startsWith("node_modules/@asterai/sdk");
-        if (isSdkImport && excludeSdk) {
-            // Asterai protobuf definitions should not be uploaded
-            // as part of the plugin manifest.
-            continue;
-        }
-        const pathAbsolute = path.join(path.dirname(protoPath), pathRelative);
-        const importProto = fs.readFileSync(pathAbsolute, { encoding: "utf8" });
-        const importProtoMerged = mergeProtoImports(importProto, pathAbsolute, excludeSdk, excludeSyntaxDefinition, n + 1);
-        mergedManifestString = `${mergedManifestString}\n${importProtoMerged}`;
-    }
-    return mergedManifestString.trim();
-};
 const logRequestError = (e) => {
     const info = e.response?.data ?? e;
     console.log("request error:", info);
 };
+const readFile = (relativePath) => {
+    if (fs.existsSync(relativePath)) {
+        return fs.readFileSync(relativePath);
+    }
+    const retryPath = path.join(RETRY_FIND_FILE_DIR, relativePath);
+    if (fs.existsSync(retryPath)) {
+        return fs.readFileSync(retryPath);
+    }
+    throw new Error(`file not found: ${relativePath}`);
+};

package/dist/commands/init.d.ts

@@ -1,10 +1,17 @@
 import { Command } from "@oclif/core";
+export type InitFlags = {
+    rust?: boolean;
+    typescript?: boolean;
+};
 export default class Codegen extends Command {
     static args: {
         outDir: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
     };
     static description: string;
     static examples: string[];
-    static flags: {};
+    static flags: {
+        typescript: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        rust: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
     run(): Promise<void>;
 }

package/dist/commands/init.js

@@ -1,9 +1,10 @@
-import { Args, Command } from "@oclif/core";
+import { Args, Command, Flags } from "@oclif/core";
 import path from "path";
 import fs from "fs";
 import url from "url";
 const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
-const SOURCE_DIR = path.join(__dirname, "../../asterai-init-plugin");
+const SOURCE_DIR_TYPESCRIPT = path.join(__dirname, "../../init/typescript");
+const SOURCE_DIR_RUST = path.join(__dirname, "../../init/rust");
 export default class Codegen extends Command {
     static args = {
         outDir: Args.string({
@@ -12,10 +13,41 @@ export default class Codegen extends Command {
     };
     static description = "Initialise a new plugin project";
     static examples = [`<%= config.bin %> <%= command.id %> project-name`];
-    static flags = {};
+    static flags = {
+        typescript: Flags.boolean({
+            default: undefined,
+            description: "init a the plugin project in typescript",
+        }),
+        rust: Flags.boolean({
+            default: false,
+            description: "init a the plugin project in rust",
+        }),
+    };
     async run() {
-        const { args } = await this.parse(Codegen);
+        const { args, flags } = await this.parse(Codegen);
+        assertOneLanguageFlag([flags.typescript, flags.rust]);
         const outDir = path.resolve(args.outDir);
-        fs.cpSync(SOURCE_DIR, outDir, { recursive: true });
+        const sourceDir = getSourceDirByFlag(flags);
+        fs.cpSync(sourceDir, outDir, { recursive: true });
     }
 }
+const assertOneLanguageFlag = (flags) => {
+    const undefinedCount = flags.reduce((acc, curr) => (curr === undefined ? acc + 1 : acc), 0);
+    const trueCount = flags.reduce((acc, curr) => (curr ? acc + 1 : acc), 0);
+    if (trueCount === 0 && undefinedCount !== 1) {
+        throw new Error("one language flag must be set");
+    }
+    if (trueCount > 1) {
+        throw new Error("only one language flag can be set");
+    }
+};
+const getSourceDirByFlag = (flags) => {
+    if (flags.rust) {
+        return SOURCE_DIR_RUST;
+    }
+    // Typescript is the default option.
+    if (flags.typescript === true || flags.typescript === undefined) {
+        return SOURCE_DIR_TYPESCRIPT;
+    }
+    throw new Error("Invalid flags configuration.");
+};

package/dist/commands/pkg.d.ts

@@ -0,0 +1,27 @@
+import { Command } from "@oclif/core";
+export type PkgArgs = {
+    input: string;
+};
+export type PkgFlags = {
+    endpoint: string;
+    output: string;
+    wit?: string;
+};
+export type PkgOutput = {
+    outputFile: string;
+    witPath: string;
+};
+export default class Pkg extends Command {
+    static args: {
+        input: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        output: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        wit: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        endpoint: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}
+export declare const pkg: (args: PkgArgs, flags: PkgFlags) => Promise<PkgOutput>;

package/dist/commands/pkg.js

@@ -0,0 +1,98 @@
+import { Args, Command, Flags } from "@oclif/core";
+import path from "path";
+import fs from "fs/promises";
+import fsSync from "fs";
+import { BASE_API_URL } from "../const.js";
+import axios from "axios";
+import FormData from "form-data";
+import { getConfigValue } from "../config.js";
+export default class Pkg extends Command {
+    static args = {
+        input: Args.string({
+            default: "plugin.wit",
+            description: "path to the plugin's WIT file",
+        }),
+    };
+    static flags = {
+        output: Flags.string({
+            char: "o",
+            default: "package.wasm",
+            description: "output file name for the binary WASM package",
+        }),
+        wit: Flags.string({
+            char: "w",
+            default: "package.wit",
+            description: "output package converted to the WIT format",
+        }),
+        endpoint: Flags.string({
+            char: "e",
+            default: BASE_API_URL,
+        }),
+    };
+    static description = "bundles the WIT into a binary WASM package";
+    static examples = [`<%= config.bin %> <%= command.id %>`];
+    async run() {
+        const { args, flags } = await this.parse(Pkg);
+        await pkg(args, flags);
+    }
+}
+export const pkg = async (args, flags) => {
+    const witPath = path.resolve(args.input);
+    if (!fsSync.existsSync(witPath)) {
+        throw new Error(`WIT file not found at ${witPath}`);
+    }
+    const baseDir = path.dirname(witPath);
+    const outputFile = path.join(baseDir, flags.output);
+    const form = new FormData();
+    form.append("package.wit", await fs.readFile(witPath));
+    const response = await axios({
+        url: `${flags.endpoint}/v1/pkg`,
+        method: "post",
+        data: form,
+        headers: {
+            Authorization: getConfigValue("key"),
+            ...form.getHeaders(),
+        },
+        responseType: "arraybuffer",
+    }).catch(catchAxiosError);
+    validateResponseStatus(response.status);
+    await fs.writeFile(outputFile, Buffer.from(response.data), {
+        encoding: "binary",
+    });
+    if (flags.wit) {
+        await wasm2wit(flags.endpoint, outputFile, path.join(baseDir, flags.wit));
+    }
+    return {
+        outputFile,
+        witPath,
+    };
+};
+const wasm2wit = async (endpoint, inputFilePath, outputFilePath) => {
+    const form = new FormData();
+    form.append("package.wasm", await fs.readFile(inputFilePath));
+    const response = await axios({
+        url: `${endpoint}/v1/wasm2wit`,
+        method: "post",
+        data: form,
+        headers: {
+            Authorization: getConfigValue("key"),
+            ...form.getHeaders(),
+        },
+        responseType: "text",
+    });
+    validateResponseStatus(response.status);
+    await fs.writeFile(outputFilePath, response.data, { encoding: "utf8" });
+};
+const validateResponseStatus = (status) => {
+    if (status < 200 || status >= 300) {
+        throw new Error("request failed");
+    }
+};
+const catchAxiosError = (error) => {
+    const data = error.response?.data?.toString() ?? "";
+    if (axios.isAxiosError(error) && data.length > 0) {
+        const errorMessage = data.replace(/\\n/g, "\n");
+        throw new Error(`Request failed: ${errorMessage}`);
+    }
+    throw new Error("Request failed");
+};

package/dist/const.d.ts

@@ -0,0 +1,2 @@
+export declare const BASE_API_URL = "https://api.asterai.io";
+export declare const BASE_API_URL_STAGING = "https://staging.api.asterai.io";

package/dist/const.js

@@ -0,0 +1,2 @@
+export const BASE_API_URL = "https://api.asterai.io";
+export const BASE_API_URL_STAGING = "https://staging.api.asterai.io";

package/init/rust/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "plugin"
+# Note that this version does not matter for the plugin,
+# only the one in plugin.wit is used.
+version = "0.0.0"
+edition = "2021"
+publish = false
+
+[dependencies]
+wit-bindgen-rt = { version = "0.39.0", features = ["bitflags"] }
+
+[lib]
+crate-type = ["cdylib"]
+
+[profile.release]
+codegen-units = 1
+opt-level = "s"
+debug = false
+strip = true
+lto = true
+
+[package.metadata.component]
+package = "your-username:plugin"
+
+[package.metadata.component.dependencies]

package/init/rust/build.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+set -e
+mkdir -p wit
+asterai pkg -o wit/package.wasm -w wit/package.wit
+cargo component build --release

package/init/rust/deploy.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -e
+if [ -z "$1" ]; then
+  echo "Deploying without agent ID. Optionally, pass it: $0 <agent ID>"
+fi
+bash ./build.sh
+asterai deploy --pkg wit/package.wasm --plugin target/wasm32-wasip1/release/plugin.wasm -a "$1"

package/init/rust/plugin.wit

@@ -0,0 +1,10 @@
+package your-username:greeter@0.1.0;
+
+interface greeter {
+  greet: func(name: string);
+}
+
+world plugin {
+  import asterai:host/api@0.1.0;
+  export greeter;
+}