@asterai/cli 0.4.0 → 0.5.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.5.0 linux-x64 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,74 +53,31 @@ 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.5.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
-
-DESCRIPTION
-  compiles the plugin
-
-EXAMPLES
-  $ asterai build
-```
-
-_See code: [src/commands/build.ts](https://github.com/asterai-io/asterai-sdk/blob/v0.4.0/src/commands/build.ts)_
-
-## `asterai codegen`
-
-Generate code from the plugin manifest
-
-```
-USAGE
-  $ asterai codegen [-m <value>] [-o <value>] [-a <value>] [-l <value>] [-s]
-
-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
-
-DESCRIPTION
-  Generate code from the plugin manifest
-
-EXAMPLES
-  $ asterai codegen
-```
-
-_See code: [src/commands/codegen.ts](https://github.com/asterai-io/asterai-sdk/blob/v0.4.0/src/commands/codegen.ts)_
-
-## `asterai deploy [INPUT]`
-
-compiles and uploads the plugin to asterai
-
-```
-USAGE
-  $ asterai deploy [INPUT] -a <value> [-m <value>] [-e <value>] [-s]
-
-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
+  -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 and uploads the plugin to asterai
+  uploads a plugin to asterai
 
 EXAMPLES
   $ asterai deploy --app 66a46b12-b1a7-4b72-a64a-0e4fe21902b6
 ```
 
-_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/deploy.ts](https://github.com/asterai-io/asterai-sdk/blob/v0.5.0/src/commands/deploy.ts)_
 
 ## `asterai help [COMMAND]`
 
@@ -158,7 +114,32 @@ EXAMPLES
   $ asterai init project-name
 ```
 
-_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/init.ts](https://github.com/asterai-io/asterai-sdk/blob/v0.5.0/src/commands/init.ts)_
+
+## `asterai pkg [INPUT]`
+
+bundles the WIT into a binary WASM package
+
+```
+USAGE
+  $ asterai pkg [INPUT] [-o <value>] [-w <value>] [-e <value>]
+
+ARGUMENTS
+  INPUT  [default: plugin.wit] path to the plugin's WIT file
+
+FLAGS
+  -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
+  bundles the WIT into a binary WASM package
+
+EXAMPLES
+  $ asterai pkg
+```
+
+_See code: [src/commands/pkg.ts](https://github.com/asterai-io/asterai-sdk/blob/v0.5.0/src/commands/pkg.ts)_
 
 ## `asterai query`
 
@@ -181,5 +162,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.5.0/src/commands/query.ts)_
 <!-- commandsstop -->

package/asterai-init-plugin/package.json

@@ -1,23 +1,26 @@
 {
   "name": "plugin",
-  "version": "1.0.0",
+  "version": "0.1.0",
   "description": "",
-  "author": "asterai",
-  "license": "MIT",
+  "author": "",
+  "license": "UNLICENSED",
+  "type": "module",
   "scripts": {
     "auth": "asterai auth",
-    "codegen": "asterai codegen",
-    "build": "asterai build",
+    "gen:pkg": "mkdirp build && asterai pkg -o build/package.wasm -w build/package.wit",
+    "gen:types": "jco guest-types build/package.wit -n plugin -o generated/",
+    "compile": "tsc",
+    "componentize": "jco componentize build/plugin.js -w build/package.wit -n plugin -o build/plugin.wasm",
+    "build": "run-s gen:pkg gen:types compile componentize",
     "deploy": "asterai deploy"
   },
-  "type": "module",
   "devDependencies": {
     "@asterai/cli": "latest",
     "@asterai/sdk": "latest",
-    "@asterai/as-proto": "latest",
-    "@asterai/as-proto-gen": "latest"
-  },
-  "peerDependencies": {
-    "assemblyscript": "0.27.27"
+    "@bytecodealliance/jco": "^1.9.1",
+    "@types/node": "^22.13.4",
+    "mkdirp": "^3.0.1",
+    "npm-run-all": "^4.1.5",
+    "typescript": "^5.7.3"
   }
 }

package/asterai-init-plugin/plugin.ts

@@ -1,35 +1,11 @@
-import { BinaryOperationInput } from "./generated/BinaryOperationInput";
-import { CalculationOutput } from "./generated/CalculationOutput";
-import { PluginContext } from "./generated/PluginContext";
-import { ProcessQueryOutput } from "./generated/ProcessQueryOutput";
-import { Log } from "@asterai/sdk";
+import { BinaryOperationInput } from "./generated/plugin";
+import * as asterai from "asterai:host/api@0.1.0";
 
-export function processQuery(input: PluginContext): ProcessQueryOutput {
-  Log.info(`math plugin received a query: ${input.query.content}`);
-  // This doesn't return any data, but protobuf requires functions
-  // to always have one input and one output exactly to ensure
-  // backward compatibility.
-  return new ProcessQueryOutput();
-}
-
-export function add(input: BinaryOperationInput): CalculationOutput {
+export const add = (input: BinaryOperationInput): number => {
   const result = input.a + input.b;
-  // CalculationOutput returns a system message.
-  // The `system_message` field is sent to the LLM.
-  return new CalculationOutput(`the result is ${result}`);
-}
-
-export function mul(input: BinaryOperationInput): CalculationOutput {
-  const result = input.a * input.b;
-  return new CalculationOutput(`the result is ${result}`);
-}
-
-export function div(input: BinaryOperationInput): CalculationOutput {
-  const result = input.a / input.b;
-  return new CalculationOutput(`the result is ${result}`);
-}
-
-export function pow(input: BinaryOperationInput): CalculationOutput {
-  const result = input.a ** input.b;
-  return new CalculationOutput(`the result is ${result}`);
-}
+  // Send the calculation result to the agent.
+  asterai.sendResponseToAgent(`the result is ${result}`);
+  // This result is not seen by the agent, but it can be consumed by
+  // other plugins calling this function.
+  return result;
+};

package/asterai-init-plugin/plugin.wit

@@ -0,0 +1,12 @@
+package example:math@0.1.0;
+
+world plugin {
+  import asterai:host/api@0.1.0;
+
+  export add: func(input: binary-operation-input) -> s32;
+
+  record binary-operation-input {
+    a: f64,
+    b: f64,
+  }
+}

package/asterai-init-plugin/tsconfig.json

@@ -1,4 +1,11 @@
 {
-  "extends": "assemblyscript/std/assembly.json",
-  "include": ["./**/*.ts"]
+  "include": ["./**/*.ts"],
+  "compilerOptions": {
+    "outDir": "build",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "paths": {
+      "asterai:host/api@0.1.0": ["./generated/interfaces/asterai-host-api.d.ts"]
+    }
+  }
 }

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/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/oclif.manifest.json

@@ -28,24 +28,49 @@
         "auth.js"
       ]
     },
-    "build": {
+    "deploy": {
       "aliases": [],
-      "args": {
-        "input": {
-          "default": "plugin.ts",
-          "name": "input"
-        }
-      },
-      "description": "compiles the plugin",
+      "args": {},
+      "description": "uploads a plugin to asterai",
       "examples": [
-        "<%= config.bin %> <%= command.id %>"
+        "<%= config.bin %> <%= command.id %> --app 66a46b12-b1a7-4b72-a64a-0e4fe21902b6"
       ],
       "flags": {
-        "manifest": {
-          "char": "m",
-          "description": "manifest path",
-          "name": "manifest",
-          "default": "plugin.asterai.proto",
+        "agent": {
+          "char": "a",
+          "description": "agent ID to immediately activate this plugin for",
+          "name": "agent",
+          "required": false,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "endpoint": {
+          "char": "e",
+          "name": "endpoint",
+          "default": "https://api.asterai.io",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "staging": {
+          "char": "s",
+          "name": "staging",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "plugin": {
+          "description": "plugin WASM path",
+          "name": "plugin",
+          "default": "plugin.wasm",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "pkg": {
+          "description": "package WASM path",
+          "name": "pkg",
+          "default": "package.wasm",
           "hasDynamicHelp": false,
           "multiple": false,
           "type": "option"
@@ -53,7 +78,7 @@
       },
       "hasDynamicHelp": false,
       "hiddenAliases": [],
-      "id": "build",
+      "id": "deploy",
       "pluginAlias": "@asterai/cli",
       "pluginName": "@asterai/cli",
       "pluginType": "core",
@@ -63,66 +88,25 @@
       "relativePath": [
         "dist",
         "commands",
-        "build.js"
+        "deploy.js"
       ]
     },
-    "codegen": {
+    "init": {
       "aliases": [],
-      "args": {},
-      "description": "Generate code from the plugin manifest",
-      "examples": [
-        "<%= config.bin %> <%= command.id %>"
-      ],
-      "flags": {
-        "manifest": {
-          "char": "m",
-          "description": "manifest path",
-          "name": "manifest",
-          "default": "plugin.asterai.proto",
-          "hasDynamicHelp": false,
-          "multiple": false,
-          "type": "option"
-        },
-        "outputDir": {
-          "char": "o",
-          "description": "output directory",
-          "name": "outputDir",
-          "default": "generated",
-          "hasDynamicHelp": false,
-          "multiple": false,
-          "type": "option"
-        },
-        "appId": {
-          "char": "a",
-          "description": "app id",
-          "name": "appId",
-          "required": false,
-          "hasDynamicHelp": false,
-          "multiple": false,
-          "type": "option"
-        },
-        "language": {
-          "char": "l",
-          "description": "language of generated typings",
-          "name": "language",
-          "required": false,
-          "default": "js",
-          "hasDynamicHelp": false,
-          "multiple": false,
-          "type": "option"
-        },
-        "staging": {
-          "char": "s",
-          "description": "use staging endpoint",
-          "name": "staging",
-          "required": false,
-          "allowNo": false,
-          "type": "boolean"
+      "args": {
+        "outDir": {
+          "default": "plugin",
+          "name": "outDir"
         }
       },
+      "description": "Initialise a new plugin project",
+      "examples": [
+        "<%= config.bin %> <%= command.id %> project-name"
+      ],
+      "flags": {},
       "hasDynamicHelp": false,
       "hiddenAliases": [],
-      "id": "codegen",
+      "id": "init",
       "pluginAlias": "@asterai/cli",
       "pluginName": "@asterai/cli",
       "pluginType": "core",
@@ -132,36 +116,37 @@
       "relativePath": [
         "dist",
         "commands",
-        "codegen.js"
+        "init.js"
       ]
     },
-    "deploy": {
+    "pkg": {
       "aliases": [],
       "args": {
         "input": {
-          "default": "plugin.ts",
+          "default": "plugin.wit",
+          "description": "path to the plugin's WIT file",
           "name": "input"
         }
       },
-      "description": "compiles and uploads the plugin to asterai",
+      "description": "bundles the WIT into a binary WASM package",
       "examples": [
-        "<%= config.bin %> <%= command.id %> --app 66a46b12-b1a7-4b72-a64a-0e4fe21902b6"
+        "<%= config.bin %> <%= command.id %>"
       ],
       "flags": {
-        "app": {
-          "char": "a",
-          "description": "app ID to immediately configure this plugin with",
-          "name": "app",
-          "required": true,
+        "output": {
+          "char": "o",
+          "description": "output file name for the binary WASM package",
+          "name": "output",
+          "default": "package.wasm",
           "hasDynamicHelp": false,
           "multiple": false,
           "type": "option"
         },
-        "manifest": {
-          "char": "m",
-          "description": "manifest path",
-          "name": "manifest",
-          "default": "plugin.asterai.proto",
+        "wit": {
+          "char": "w",
+          "description": "output package converted to the WIT format",
+          "name": "wit",
+          "default": "package.wit",
           "hasDynamicHelp": false,
           "multiple": false,
           "type": "option"
@@ -169,49 +154,15 @@
         "endpoint": {
           "char": "e",
           "name": "endpoint",
-          "default": "https://api.asterai.io/app/plugin",
+          "default": "https://api.asterai.io",
           "hasDynamicHelp": false,
           "multiple": false,
           "type": "option"
-        },
-        "staging": {
-          "char": "s",
-          "name": "staging",
-          "allowNo": false,
-          "type": "boolean"
         }
       },
       "hasDynamicHelp": false,
       "hiddenAliases": [],
-      "id": "deploy",
-      "pluginAlias": "@asterai/cli",
-      "pluginName": "@asterai/cli",
-      "pluginType": "core",
-      "strict": true,
-      "enableJsonFlag": false,
-      "isESM": true,
-      "relativePath": [
-        "dist",
-        "commands",
-        "deploy.js"
-      ]
-    },
-    "init": {
-      "aliases": [],
-      "args": {
-        "outDir": {
-          "default": "plugin",
-          "name": "outDir"
-        }
-      },
-      "description": "Initialise a new plugin project",
-      "examples": [
-        "<%= config.bin %> <%= command.id %> project-name"
-      ],
-      "flags": {},
-      "hasDynamicHelp": false,
-      "hiddenAliases": [],
-      "id": "init",
+      "id": "pkg",
       "pluginAlias": "@asterai/cli",
       "pluginName": "@asterai/cli",
       "pluginType": "core",
@@ -221,7 +172,7 @@
       "relativePath": [
         "dist",
         "commands",
-        "init.js"
+        "pkg.js"
       ]
     },
     "query": {
@@ -280,5 +231,5 @@
       ]
     }
   },
-  "version": "0.4.0"
+  "version": "0.5.0"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@asterai/cli",
   "description": "CLI for building and deploying asterai plugins",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "author": "asterai <support@asterai.io>",
   "repository": "asterai-io/asterai-sdk",
   "homepage": "https://github.com/asterai-io/asterai-sdk",

package/asterai-init-plugin/plugin.asterai.proto

@@ -1,22 +0,0 @@
-syntax = "proto3";
-import "node_modules/@asterai/sdk/protobuf/asterai.proto";
-
-service Math {
-  rpc processQuery(PluginContext) returns (ProcessQueryOutput);
-  rpc add(BinaryOperationInput) returns (CalculationOutput);
-  rpc mul(BinaryOperationInput) returns (CalculationOutput);
-  rpc div(BinaryOperationInput) returns (CalculationOutput);
-  rpc pow(BinaryOperationInput) returns (CalculationOutput);
-}
-
-message ProcessQueryOutput {}
-
-message BinaryOperationInput {
-  PluginContext context = 1;
-  double a = 2;
-  double b = 3;
-}
-
-message CalculationOutput {
-  string system_message = 1;
-}

package/dist/commands/build.d.ts

@@ -1,23 +0,0 @@
-import { Command } from "@oclif/core";
-export type BuildArgs = {
-    input: string;
-};
-export type BuildFlags = {
-    manifest: string;
-};
-export type BuildOutput = {
-    outputFile: string;
-    manifestPath: string;
-};
-export default class Build extends Command {
-    static args: {
-        input: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
-    };
-    static description: string;
-    static examples: string[];
-    static flags: {
-        manifest: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-    };
-    run(): Promise<void>;
-}
-export declare const build: (args: BuildArgs, flags: BuildFlags) => Promise<BuildOutput>;

package/dist/commands/build.js

@@ -1,139 +0,0 @@
-import { Args, Command, Flags } from "@oclif/core";
-import path from "path";
-import fs from "fs";
-import { compile } from "../compile.js";
-import Mustache from "mustache";
-import protobuf from "protobufjs";
-import { mergeProtoImports } from "./deploy.js";
-export default class Build extends Command {
-    static args = {
-        input: Args.string({
-            default: "plugin.ts",
-        }),
-    };
-    static description = "compiles the plugin";
-    static examples = [`<%= config.bin %> <%= command.id %>`];
-    static flags = {
-        manifest: Flags.string({
-            char: "m",
-            description: "manifest path",
-            default: "plugin.asterai.proto",
-        }),
-    };
-    async run() {
-        const { args, flags } = await this.parse(Build);
-        await build(args, flags);
-    }
-}
-export const build = async (args, flags) => {
-    const manifestPath = path.resolve(flags.manifest);
-    const inputFile = path.resolve(args.input);
-    if (!fs.existsSync(inputFile)) {
-        throw new Error(`input file not found (${args.input})`);
-    }
-    const inputFileName = path.parse(inputFile).name;
-    const baseDir = path.dirname(manifestPath);
-    const outDir = path.join(baseDir, "build");
-    const outputFile = path.join(outDir, `${inputFileName}.wasm`);
-    const libsDir = path.join(baseDir, "node_modules");
-    if (!fs.existsSync(libsDir)) {
-        throw new Error("no node_modules found in the plugin directory");
-    }
-    const proto = fs.readFileSync(manifestPath, { encoding: "utf8" });
-    const functionDescriptors = getPluginFunctionDescriptors(proto, manifestPath);
-    const inputFileContent = fs.readFileSync(inputFile, { encoding: "utf8" });
-    assertPluginCodeHasAllFunctionsFromManifest(inputFileContent, functionDescriptors);
-    const entryPointCode = generateEntryPointCode(functionDescriptors);
-    const mergedPluginCode = mergeInputPluginCodeWithEntrypoint(inputFileContent, entryPointCode);
-    const mergedTempFilePath = writeMergedPluginCodeTempFile(mergedPluginCode, path.parse(inputFile).dir, inputFileName);
-    const globalFile = path.join(libsDir, "@asterai/sdk/global.ts");
-    const options = {
-        inputFiles: [mergedTempFilePath, globalFile],
-        baseDir,
-        outputFile,
-        libs: libsDir,
-    };
-    try {
-        await compile(options);
-    }
-    finally {
-        fs.unlinkSync(mergedTempFilePath);
-    }
-    return {
-        manifestPath,
-        outputFile,
-    };
-};
-const getPluginFunctionDescriptors = (proto, protoPath) => {
-    const protoMerged = mergeProtoImports(proto, protoPath, false, false);
-    const result = protobuf.parse(protoMerged);
-    const namespace = result.root.resolveAll();
-    const objects = namespace.nestedArray;
-    const serviceObject = objects.find(o => o.methods !== undefined);
-    if (!serviceObject) {
-        throw new Error("no service found in plugin manifest");
-    }
-    const service = serviceObject;
-    return service.methodsArray.map(m => ({
-        functionName: m.name,
-        inputType: m.requestType,
-        outputType: m.responseType,
-    }));
-};
-const generateEntryPointCode = (functionDescriptors) => {
-    const importsCode = `
-    import { Protobuf } from "@asterai/as-proto/assembly";
-    import { readBufferFromPtr, writeBufferToPr } from "@asterai/sdk/buffer";
-  `;
-    let code = "\n// generated plugin entry points\n\n";
-    for (const functionDescriptor of functionDescriptors) {
-        const template = `
-      export function {{func}}_entry_point(ptr: u32): u32 {
-        const inputBuffer = readBufferFromPtr(ptr);
-        const input = Protobuf.decode<{{inpt}}>(
-          inputBuffer,
-          {{inpt}}.decode,
-        );
-        const output = {{func}}(input);
-        const outputBuffer = Protobuf.encode<{{outp}}>(
-          output,
-          {{outp}}.encode,
-        );
-        return writeBufferToPr(outputBuffer);
-      }
-    `;
-        const view = {
-            func: functionDescriptor.functionName,
-            inpt: functionDescriptor.inputType,
-            outp: functionDescriptor.outputType,
-        };
-        const functionEntryPoint = Mustache.render(template, view);
-        code = `${code}\n${functionEntryPoint}`;
-    }
-    return {
-        importsCode,
-        entryPointsCode: code,
-    };
-};
-const mergeInputPluginCodeWithEntrypoint = (pluginCode, entryPoint) => `${entryPoint.importsCode}\n${pluginCode}\n${entryPoint.entryPointsCode}`;
-const writeMergedPluginCodeTempFile = (source, inputFileDir, inputFileName) => {
-    const tempFileName = `.entrypoint.${inputFileName}.ts`;
-    const tempFilePath = path.join(inputFileDir, tempFileName);
-    fs.writeFileSync(tempFilePath, source, { encoding: "utf8" });
-    return tempFilePath;
-};
-/**
- * Throw an error if the plugin WASM source is missing a function from
- * the manifest.
- * The only purpose of this function is to let the user know about
- * the issue in a direct way.
- */
-const assertPluginCodeHasAllFunctionsFromManifest = (source, functionDescriptors) => {
-    for (const functionDescriptor of functionDescriptors) {
-        const includesFunction = source.includes(`function ${functionDescriptor.functionName}`);
-        if (!includesFunction) {
-            throw new Error(`function "${functionDescriptor.functionName}" was defined in plugin ` +
-                "manifest (.proto file) but is missing from plugin code");
-        }
-    }
-};

package/dist/commands/codegen.d.ts

@@ -1,22 +0,0 @@
-import { Command } from "@oclif/core";
-export type CodegenFlags = {
-    manifest: string;
-    outputDir: string;
-    appId?: string;
-    language?: string;
-    staging?: boolean;
-};
-export default class Codegen extends Command {
-    static args: {};
-    static description: string;
-    static examples: string[];
-    static flags: {
-        manifest: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-        outputDir: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-        appId: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-        language: 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>;
-    };
-    run(): Promise<void>;
-}
-export declare const codegen: (flags: CodegenFlags) => Promise<void>;

package/dist/commands/codegen.js

@@ -1,149 +0,0 @@
-import { Command, Flags } from "@oclif/core";
-import path from "path";
-import fs from "fs";
-import { execSync } from "node:child_process";
-import axios from "axios";
-import { getConfigValue } from "../config.js";
-import os from "os";
-// Relative path from the plugin root directory.
-const AS_PROTO_GEN_PATH = "./node_modules/.bin/as-proto-gen";
-const PRODUCTION_ENDPOINT_BASE_URL = "https://api.asterai.io";
-const STAGING_ENDPOINT_BASE_URL = "https://staging.api.asterai.io";
-export default class Codegen extends Command {
-    static args = {};
-    static description = "Generate code from the plugin manifest";
-    static examples = [`<%= config.bin %> <%= command.id %>`];
-    static flags = {
-        manifest: Flags.string({
-            char: "m",
-            description: "manifest path",
-            default: "plugin.asterai.proto",
-        }),
-        outputDir: Flags.string({
-            char: "o",
-            description: "output directory",
-            default: "generated",
-        }),
-        appId: Flags.string({
-            char: "a",
-            description: "app id",
-            required: false,
-        }),
-        language: Flags.string({
-            char: "l",
-            description: "language of generated typings",
-            required: false,
-            default: "js",
-        }),
-        staging: Flags.boolean({
-            char: "s",
-            description: "use staging endpoint",
-            required: false,
-            default: false,
-        }),
-    };
-    async run() {
-        const { flags } = await this.parse(Codegen);
-        codegen(flags);
-    }
-}
-export const codegen = (flags) => {
-    const manifestPath = path.resolve(flags.manifest);
-    const baseDir = path.dirname(manifestPath);
-    const outDir = path.join(baseDir, flags.outputDir);
-    if (!fs.existsSync(outDir)) {
-        fs.mkdirSync(outDir, { recursive: true });
-    }
-    else {
-        deleteOldGeneratedFiles(outDir);
-    }
-    if (flags.appId && flags.language) {
-        return generateClientTypings(outDir, flags.language, flags.appId, flags.staging ?? false);
-    }
-    return generateAssemblyScriptPluginTypings(flags, baseDir);
-};
-const generateAssemblyScriptPluginTypings = async (flags, baseDir) => {
-    const absoluteAsProtoGenPath = path.join(baseDir, AS_PROTO_GEN_PATH);
-    try {
-        execSync("protoc --version");
-    }
-    catch (e) {
-        console.error("No protoc binary found. " +
-            "Is protocol buffers installed on the system? " +
-            "Download protocol buffers here: https://protobuf.dev/downloads");
-        return;
-    }
-    try {
-        execSync("protoc " +
-            `--plugin='protoc-gen-as=${absoluteAsProtoGenPath}' ` +
-            `--experimental_allow_proto3_optional ` +
-            `--as_out='./${flags.outputDir}' ./${flags.manifest}`);
-    }
-    catch (e) {
-        console.error("Failed to generate protobuf types:", e);
-    }
-};
-const deleteOldGeneratedFiles = (outDir) => {
-    const oldFiles = fs.readdirSync(outDir);
-    for (const oldFile of oldFiles) {
-        const file = path.parse(oldFile);
-        if (file.ext !== ".ts") {
-            continue;
-        }
-        const deletePath = path.join(outDir, oldFile);
-        fs.unlinkSync(deletePath);
-    }
-};
-const generateClientTypings = async (outDir, language, appId, shouldUseStaging) => {
-    const manifestsResponse = await downloadEnabledPluginsManifests(appId, shouldUseStaging);
-    const asteraiProto = await fetchAsteraiProto();
-    const aggregatedManifest = aggregateManifests(manifestsResponse.manifests, asteraiProto);
-    const appPrefix = `app.${appId}`;
-    fs.writeFileSync(path.join(outDir, `${appPrefix}.proto`), aggregatedManifest.content);
-    if (language === "ts") {
-        console.log("generating TypeScript typings for plugin manifest...");
-        const jsOutput = `${appPrefix}.js`;
-        const dTsOutput = `${appPrefix}.d.ts`;
-        execSync(`
-      npx -p protobufjs-cli pbjs -t static --no-service ${aggregatedManifest.filePath} -o ${path.join(outDir, jsOutput)}
-    `);
-        execSync(`
-      npx -p protobufjs-cli pbts -o ${path.join(outDir, dTsOutput)} ${path.join(outDir, jsOutput)}
-    `);
-        fs.unlinkSync(aggregatedManifest.filePath);
-        console.log("Typings generated successfully.");
-    }
-    console.log("done.");
-};
-const fetchAsteraiProto = () => {
-    // TODO: fetch this from the local file system instead.
-    return axios
-        .get("https://unpkg.com/@asterai/sdk@latest/protobuf/asterai.proto")
-        .then(r => r.data);
-};
-const aggregateManifests = (manifests, asteraiProto) => {
-    let aggregatedManifest = `${asteraiProto}\n`;
-    const osTmpDir = os.tmpdir();
-    const aggregatedManifestPath = path.join(osTmpDir, "plugins.asterai.proto");
-    for (const manifest of manifests) {
-        aggregatedManifest += `${manifest.proto}\n`;
-    }
-    fs.writeFileSync(aggregatedManifestPath, aggregatedManifest);
-    return {
-        content: aggregatedManifest,
-        filePath: aggregatedManifestPath,
-    };
-};
-const downloadEnabledPluginsManifests = async (appId, shouldUseStaging) => {
-    const baseUrl = shouldUseStaging
-        ? STAGING_ENDPOINT_BASE_URL
-        : PRODUCTION_ENDPOINT_BASE_URL;
-    const response = await axios({
-        url: `${baseUrl}/app/${appId}/plugin/manifests`,
-        method: "GET",
-        headers: {
-            Authorization: getConfigValue("key"),
-        },
-    });
-    return response.data;
-};

package/dist/compile.d.ts

@@ -1,7 +0,0 @@
-export type CompileOptions = {
-    inputFiles: string[];
-    baseDir: string;
-    libs: string;
-    outputFile: string;
-};
-export declare const compile: (options: CompileOptions) => Promise<void>;

package/dist/compile.js

@@ -1,25 +0,0 @@
-import * as asc from "assemblyscript/asc";
-const COMPILER_OPTIONS = {
-    stdout: process.stdout,
-    stderr: process.stderr,
-};
-export const compile = async (options) => {
-    const args = [
-        "--exportRuntime",
-        "--runtime",
-        "stub",
-        ...options.inputFiles,
-        "--baseDir",
-        options.baseDir,
-        "--lib",
-        options.libs,
-        "--outFile",
-        options.outputFile,
-        "--optimize",
-        "--debug",
-    ];
-    const result = await asc.main(args, COMPILER_OPTIONS);
-    if (result.error) {
-        throw result.error;
-    }
-};