@cargo-ai/cli 1.0.15 → 1.0.16

package/README.md

@@ -112,7 +112,8 @@ cargo-ai orchestration workflow --help
 | **system-of-record**     | System of record, client, logs                             | `cargo-ai system-of-record sor list`, `cargo-ai system-of-record log list --payload '{}'`                                     |
 | **user-management**      | Current user (no workspace context)                        | `cargo-ai user-management user get-current`                                                                                   |
 | **ai**                   | AI templates, agents, releases, chats, MCP, files          | `cargo-ai ai template list`, `cargo-ai ai agent list`, `cargo-ai ai file list`                                                |
-| **context**              | Context repository, files, and skills                      | `cargo-ai context skill list`, `cargo-ai context skill get --slug <slug>`, `cargo-ai context file list`                       |
+| **context**              | Context repository, runtime sandbox, and knowledge graph   | `cargo-ai context repository get`, `cargo-ai context runtime browse --path <path>`, `cargo-ai context graph get`              |
+| **hosting**              | Cargo Hosting apps (Vite SPAs), workers, and deployments   | `cargo-ai hosting app list`, `cargo-ai hosting worker list`, `cargo-ai hosting deployment list --payload '{}'`                |
 
 Commands that accept complex payloads use a `--payload <json>` option (e.g. `cargo-ai orchestration play create --payload '{"name":"My Play",...}'`). Use `--help` on any subcommand for options.
 

package/build/commands/connection/customIntegration.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "commander";
+import type { Api } from "../../api.js";
+export declare function registerCustomIntegrationCommands(parent: Command, getApi: () => Api): void;
+//# sourceMappingURL=customIntegration.d.ts.map

package/build/commands/connection/customIntegration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"customIntegration.d.ts","sourceRoot":"","sources":["../../../src/commands/connection/customIntegration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAGxC,wBAAgB,iCAAiC,CAC/C,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,MAAM,GAAG,GAChB,IAAI,CAqJN"}

package/build/commands/connection/customIntegration.js

@@ -0,0 +1,98 @@
+import { handleApiCall, outputJson } from "../runHandler.js";
+export function registerCustomIntegrationCommands(parent, getApi) {
+    const customIntegration = parent
+        .command("custom-integration")
+        .description("Manage custom integrations (external HTTP servers or worker-backed integrations)");
+    customIntegration
+        .command("list")
+        .description("List custom integrations in the current workspace")
+        .action(async () => {
+        const api = getApi();
+        const result = await handleApiCall(() => api.connection.customIntegration.list());
+        outputJson(result);
+    });
+    customIntegration
+        .command("get <uuid>")
+        .description("Get a custom integration by UUID")
+        .action(async (uuid) => {
+        const api = getApi();
+        const result = await handleApiCall(() => api.connection.customIntegration.get({ uuid }));
+        outputJson(result);
+    });
+    customIntegration
+        .command("create")
+        .description("Register a custom integration (kind=external for an externally hosted server, kind=worker for a Cargo Hosting worker)")
+        .requiredOption("--kind <kind>", 'Integration kind: "external" or "worker"')
+        .option("--base-url <url>", "Base URL of the externally hosted integration server (required when --kind external)")
+        .option("--worker-uuid <uuid>", "UUID of the Cargo Hosting worker that backs the integration (required when --kind worker)")
+        .addHelpText("after", `
+Examples:
+  $ cargo-ai connection custom-integration create --kind external --base-url https://abc123.ngrok.io
+  $ cargo-ai connection custom-integration create --kind worker --worker-uuid 11111111-2222-3333-4444-555555555555`)
+        .action(async (opts) => {
+        if (opts.kind !== "external" && opts.kind !== "worker") {
+            console.error(JSON.stringify({
+                error: `Invalid --kind "${opts.kind}". Expected "external" or "worker".`,
+            }));
+            process.exit(1);
+        }
+        if (opts.kind === "external" && opts.baseUrl === undefined) {
+            console.error(JSON.stringify({
+                error: "--base-url is required when --kind is external.",
+            }));
+            process.exit(1);
+        }
+        if (opts.kind === "worker" && opts.workerUuid === undefined) {
+            console.error(JSON.stringify({
+                error: "--worker-uuid is required when --kind is worker.",
+            }));
+            process.exit(1);
+        }
+        const api = getApi();
+        const result = await handleApiCall(() => opts.kind === "external"
+            ? api.connection.customIntegration.create({
+                kind: "external",
+                baseUrl: opts.baseUrl,
+            })
+            : api.connection.customIntegration.create({
+                kind: "worker",
+                workerUuid: opts.workerUuid,
+            }));
+        outputJson(result);
+    });
+    customIntegration
+        .command("update")
+        .description("Update a custom integration's base URL or worker (kind cannot change)")
+        .requiredOption("--uuid <uuid>", "Custom integration UUID")
+        .option("--base-url <url>", "New base URL (only valid when the integration was created with kind=external)")
+        .option("--worker-uuid <uuid>", "New worker UUID (only valid when the integration was created with kind=worker)")
+        .action(async (opts) => {
+        if (opts.baseUrl === undefined && opts.workerUuid === undefined) {
+            console.error(JSON.stringify({
+                error: "Provide at least one of --base-url or --worker-uuid.",
+            }));
+            process.exit(1);
+        }
+        if (opts.baseUrl !== undefined && opts.workerUuid !== undefined) {
+            console.error(JSON.stringify({
+                error: "--base-url and --worker-uuid are mutually exclusive.",
+            }));
+            process.exit(1);
+        }
+        const api = getApi();
+        const result = await handleApiCall(() => api.connection.customIntegration.update({
+            uuid: opts.uuid,
+            baseUrl: opts.baseUrl,
+            workerUuid: opts.workerUuid,
+        }));
+        outputJson(result);
+    });
+    customIntegration
+        .command("remove <uuid>")
+        .description("Remove a custom integration")
+        .action(async (uuid) => {
+        const api = getApi();
+        await handleApiCall(() => api.connection.customIntegration.remove(uuid));
+        outputJson({ ok: true });
+    });
+}

package/build/commands/connection/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/connection/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAKxC,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,MAAM,GAAG,GAChB,IAAI,CAQN"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/connection/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAMxC,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,MAAM,GAAG,GAChB,IAAI,CASN"}

package/build/commands/connection/index.js

@@ -1,4 +1,5 @@
 import { registerConnectorCommands } from "./connector.js";
+import { registerCustomIntegrationCommands } from "./customIntegration.js";
 import { registerIntegrationCommands } from "./integration.js";
 import { registerNativeIntegrationCommands } from "./nativeIntegration.js";
 export function registerConnectionCommands(parent, getApi) {
@@ -8,4 +9,5 @@ export function registerConnectionCommands(parent, getApi) {
     registerConnectorCommands(connection, getApi);
     registerIntegrationCommands(connection, getApi);
     registerNativeIntegrationCommands(connection, getApi);
+    registerCustomIntegrationCommands(connection, getApi);
 }

package/build/commands/context/{skill.d.ts → graph.d.ts}

@@ -1,4 +1,4 @@
 import type { Command } from "commander";
 import type { Api } from "../../api.js";
-export declare function registerSkillCommands(parent: Command, getApi: () => Api): void;
-//# sourceMappingURL=skill.d.ts.map
+export declare function registerGraphCommands(parent: Command, getApi: () => Api): void;
+//# sourceMappingURL=graph.d.ts.map

package/build/commands/context/graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../../src/commands/context/graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAGxC,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,MAAM,GAAG,GAChB,IAAI,CAeN"}

package/build/commands/context/graph.js

@@ -0,0 +1,14 @@
+import { handleApiCall, outputJson } from "../runHandler.js";
+export function registerGraphCommands(parent, getApi) {
+    const graph = parent
+        .command("graph")
+        .description("Inspect the context knowledge graph for the workspace");
+    graph
+        .command("get")
+        .description("Build (or load from cache) the knowledge graph of all markdown/MDX files in the context repo")
+        .action(async () => {
+        const api = getApi();
+        const result = await handleApiCall(() => api.context.graph.get());
+        outputJson(result);
+    });
+}

package/build/commands/context/index.js

@@ -1,11 +1,11 @@
-import { registerFileCommands } from "./file.js";
+import { registerGraphCommands } from "./graph.js";
 import { registerRepositoryCommands } from "./repository.js";
-import { registerSkillCommands } from "./skill.js";
+import { registerRuntimeCommands } from "./runtime.js";
 export function registerContextCommands(parent, getApi) {
     const context = parent
         .command("context")
-        .description("Context repository, files, and skills");
+        .description("Context repository and runtime sandbox operations");
     registerRepositoryCommands(context, getApi);
-    registerFileCommands(context, getApi);
-    registerSkillCommands(context, getApi);
+    registerRuntimeCommands(context, getApi);
+    registerGraphCommands(context, getApi);
 }

package/build/commands/context/runtime.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "commander";
+import type { Api } from "../../api.js";
+export declare function registerRuntimeCommands(parent: Command, getApi: () => Api): void;
+//# sourceMappingURL=runtime.d.ts.map

package/build/commands/context/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../src/commands/context/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAGxC,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,MAAM,GAAG,GAChB,IAAI,CAmIN"}

package/build/commands/context/runtime.js

@@ -0,0 +1,80 @@
+import { handleApiCall, outputJson } from "../runHandler.js";
+export function registerRuntimeCommands(parent, getApi) {
+    const runtime = parent
+        .command("runtime")
+        .description("Read, write, edit, browse, and execute against the workspace runtime sandbox");
+    runtime
+        .command("browse")
+        .description("List entries in the runtime sandbox")
+        .option("--path <path>", "Path to browse (omit to browse the root)")
+        .action(async (opts) => {
+        const api = getApi();
+        const result = await handleApiCall(() => api.context.runtime.browse({ path: opts.path }));
+        outputJson(result);
+    });
+    runtime
+        .command("read")
+        .description("Read a file from the runtime sandbox")
+        .requiredOption("--path <path>", "Path to the file")
+        .option("--start-line <line>", "1-indexed inclusive start line (defaults to first line)")
+        .option("--end-line <line>", "1-indexed inclusive end line (defaults to last line)")
+        .action(async (opts) => {
+        const api = getApi();
+        const startLine = opts.startLine !== undefined ? Number(opts.startLine) : undefined;
+        const endLine = opts.endLine !== undefined ? Number(opts.endLine) : undefined;
+        const result = await handleApiCall(() => api.context.runtime.read({
+            path: opts.path,
+            startLine,
+            endLine,
+        }));
+        outputJson(result);
+    });
+    runtime
+        .command("write")
+        .description("Write a file in the runtime sandbox and push to the default branch")
+        .requiredOption("--path <path>", "Path to the file")
+        .requiredOption("--content <content>", "File content")
+        .option("--commit-message <message>", "Commit message override")
+        .action(async (opts) => {
+        const api = getApi();
+        const result = await handleApiCall(() => api.context.runtime.write({
+            path: opts.path,
+            content: opts.content,
+            commitMessage: opts.commitMessage,
+        }));
+        outputJson(result);
+    });
+    runtime
+        .command("edit")
+        .description("Replace a single occurrence of oldString with newString and push to the default branch")
+        .requiredOption("--path <path>", "Path to the file")
+        .requiredOption("--old-string <old>", "Exact substring to replace (must occur once)")
+        .requiredOption("--new-string <new>", "Replacement string (may be empty to delete the match)")
+        .option("--commit-message <message>", "Commit message override")
+        .action(async (opts) => {
+        const api = getApi();
+        const result = await handleApiCall(() => api.context.runtime.edit({
+            path: opts.path,
+            oldString: opts.oldString,
+            newString: opts.newString,
+            commitMessage: opts.commitMessage,
+        }));
+        outputJson(result);
+    });
+    runtime
+        .command("execute")
+        .description("Run a shell command in the runtime sandbox (changes are NOT pushed to GitHub)")
+        .requiredOption("--command <command>", "Shell command to run")
+        .option("--args <json>", "JSON array of arguments")
+        .action(async (opts) => {
+        const api = getApi();
+        const args = opts.args !== undefined
+            ? JSON.parse(opts.args)
+            : undefined;
+        const result = await handleApiCall(() => api.context.runtime.execute({
+            command: opts.command,
+            args,
+        }));
+        outputJson(result);
+    });
+}

package/build/commands/{orchestration/log.d.ts → hosting/app.d.ts}

@@ -1,4 +1,4 @@
 import type { Command } from "commander";
 import type { Api } from "../../api.js";
-export declare function registerLogCommands(parent: Command, getApi: () => Api): void;
-//# sourceMappingURL=log.d.ts.map
+export declare function registerAppCommands(parent: Command, getApi: () => Api): void;
+//# sourceMappingURL=app.d.ts.map

package/build/commands/hosting/app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../../../src/commands/hosting/app.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAMxC,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,GAAG,IAAI,CAsO5E"}

package/build/commands/hosting/app.js

@@ -0,0 +1,190 @@
+import { promises as fs } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { handleApiCall, outputJson } from "../runHandler.js";
+import { copyDirectory, listTemplates } from "./templateUtils.js";
+const require = createRequire(import.meta.url);
+export function registerAppCommands(parent, getApi) {
+    const app = parent
+        .command("app")
+        .description("Manage Cargo Hosting apps (Vite SPAs served on *.cargo.app)");
+    app
+        .command("list")
+        .description("List apps in the current workspace")
+        .option("--folder-uuid <uuid>", "Filter by folder UUID")
+        .action(async (opts) => {
+        const api = getApi();
+        const result = await handleApiCall(() => api.hosting.app.list({
+            folderUuid: opts.folderUuid,
+        }));
+        outputJson(result);
+    });
+    app
+        .command("get <uuid>")
+        .description("Show details of a single app")
+        .action(async (uuid) => {
+        const api = getApi();
+        const result = await handleApiCall(() => api.hosting.app.get(uuid));
+        outputJson(result);
+    });
+    app
+        .command("create")
+        .description("Create a new app slot")
+        .requiredOption("--name <name>", "Display name for the app")
+        .requiredOption("--slug <slug>", "URL slug (must be globally unique within the hosting domain)")
+        .option("--folder-uuid <uuid>", "Optional folder UUID")
+        .action(async (opts) => {
+        const api = getApi();
+        const result = await handleApiCall(() => api.hosting.app.create({
+            name: opts.name,
+            slug: opts.slug,
+            folderUuid: opts.folderUuid,
+        }));
+        outputJson(result);
+    });
+    app
+        .command("update")
+        .description("Update an existing app (name, folder)")
+        .requiredOption("--uuid <uuid>", "App UUID")
+        .option("--name <name>", "New display name")
+        .option("--folder-uuid <uuid>", "New folder UUID (pass 'null' to move to the workspace root)")
+        .action(async (opts) => {
+        const api = getApi();
+        const result = await handleApiCall(() => api.hosting.app.update({
+            uuid: opts.uuid,
+            name: opts.name,
+            folderUuid: opts.folderUuid === "null" ? null : opts.folderUuid,
+        }));
+        outputJson(result);
+    });
+    app
+        .command("remove <uuid>")
+        .description("Remove an app (also removes its deployments)")
+        .action(async (uuid) => {
+        const api = getApi();
+        await handleApiCall(() => api.hosting.app.remove(uuid));
+        outputJson({ ok: true });
+    });
+    app
+        .command("env <appUuid>")
+        .description("Print the .env.local lines a local copy of the app needs (Cargo OAuth + workspace + app UUID + API URL).")
+        .option("--api-url <url>", "Override the API URL written to the .env (default: https://api.getcargo.io)")
+        .action(async (appUuid, opts) => {
+        const api = getApi();
+        const { app: resolvedApp } = await handleApiCall(() => api.hosting.app.get(appUuid));
+        const lines = [
+            "# Generated by `cargo-ai hosting app env`. Do not commit secrets.",
+            "VITE_CARGO_OAUTH_DOMAIN=<set-by-cargo-hosting-at-deploy-time>",
+            "VITE_CARGO_OAUTH_CLIENT_ID=<set-by-cargo-hosting-at-deploy-time>",
+            "VITE_CARGO_OAUTH_AUDIENCE=<set-by-cargo-hosting-at-deploy-time>",
+            `VITE_CARGO_API_URL=${opts.apiUrl !== undefined ? opts.apiUrl : "https://api.getcargo.io"}`,
+            `VITE_CARGO_WORKSPACE_UUID=${resolvedApp.workspaceUuid}`,
+            `VITE_CARGO_APP_UUID=${resolvedApp.uuid}`,
+            "VITE_CARGO_DEPLOYMENT_UUID=<set-by-cargo-hosting-at-deploy-time>",
+            "VITE_APP_BASE_PATH=/",
+            "",
+        ];
+        process.stdout.write(lines.join("\n"));
+    });
+    app
+        .command("init <directory>")
+        .description("Scaffold a new Cargo Hosting app locally from a template (Vite + @cargo-ai/app-sdk).")
+        .option("--template <slug>", "Template slug (default: blank)", "blank")
+        .option("--name <name>", "App name written into package.json (default: directory name)")
+        .option("--list-templates", "Print available templates and exit")
+        .action(async (directory, opts) => {
+        const templatesRoot = findTemplatesRoot();
+        if (opts.listTemplates === true) {
+            const slugs = await listTemplates(templatesRoot);
+            if (slugs.length === 0) {
+                console.error(JSON.stringify({ error: "No templates found", templatesRoot }));
+                process.exit(1);
+            }
+            console.log(JSON.stringify(slugs.map((slug) => ({
+                slug,
+                description: TEMPLATE_DESCRIPTIONS[slug] !== undefined
+                    ? TEMPLATE_DESCRIPTIONS[slug]
+                    : "",
+            })), null, 2));
+            return;
+        }
+        const templateDir = path.join(templatesRoot, opts.template);
+        try {
+            const stat = await fs.stat(templateDir);
+            if (stat.isDirectory() === false) {
+                throw new Error("Template path is not a directory");
+            }
+        }
+        catch {
+            const slugs = await listTemplates(templatesRoot);
+            console.error(JSON.stringify({
+                error: `Unknown template "${opts.template}"`,
+                available: slugs,
+            }));
+            process.exit(1);
+        }
+        const targetDir = path.resolve(directory);
+        try {
+            const stat = await fs.stat(targetDir);
+            if (stat.isDirectory() === true) {
+                const entries = await fs.readdir(targetDir);
+                if (entries.length > 0) {
+                    console.error(JSON.stringify({
+                        error: `Target directory ${targetDir} is not empty.`,
+                    }));
+                    process.exit(1);
+                }
+            }
+        }
+        catch {
+            // Target does not exist yet — that's fine.
+        }
+        const appName = opts.name !== undefined ? opts.name : path.basename(targetDir);
+        await copyDirectory(path.join(templatesRoot, opts.template), targetDir, [
+            { from: "__APP_NAME__", to: appName },
+            { from: "__TEMPLATE_SLUG__", to: opts.template },
+        ]);
+        console.log(JSON.stringify({
+            ok: true,
+            directory: targetDir,
+            template: opts.template,
+            name: appName,
+            nextSteps: [
+                `cd ${path.relative(process.cwd(), targetDir)}`,
+                "npm install",
+                "cargo-ai hosting app create --name '<App name>' --slug '<your-slug>'",
+                "cargo-ai hosting app env <appUuid> > .env.local",
+                "npm run dev",
+            ],
+        }, null, 2));
+    });
+}
+const TEMPLATE_DESCRIPTIONS = {
+    blank: "Minimal Vite + refine app with one route, getCargoEnv() + CargoWorkspaceBadge wired (use as a starting point).",
+    "territories-overview": "Read-only grid of revenue organization territories. Demonstrates useCargoApi() + react-query + the SDK shadcn primitives.",
+};
+const findTemplatesRoot = () => {
+    // The CLI is published as `@cargo-ai/cli`. Templates live in
+    // `@cargo-ai/app-sdk/templates`. Resolve via require so we work whether the
+    // user installed both packages globally or both came from the monorepo.
+    try {
+        const appSdkPackageJson = require.resolve("@cargo-ai/app-sdk/package.json");
+        return path.join(path.dirname(appSdkPackageJson), "templates");
+    }
+    catch {
+        const here = fileURLToPath(import.meta.url);
+        let cursor = path.dirname(here);
+        for (let i = 0; i < 6; i += 1) {
+            const candidate = path.join(cursor, "packages/app-sdk/templates");
+            try {
+                require("node:fs").accessSync(candidate);
+                return candidate;
+            }
+            catch {
+                cursor = path.dirname(cursor);
+            }
+        }
+        throw new Error("Could not locate @cargo-ai/app-sdk templates. Make sure @cargo-ai/app-sdk is installed alongside @cargo-ai/cli.");
+    }
+};

package/build/commands/hosting/deployment.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "commander";
+import type { Api } from "../../api.js";
+export declare function registerDeploymentCommands(parent: Command, getApi: () => Api): void;
+//# sourceMappingURL=deployment.d.ts.map

package/build/commands/hosting/deployment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deployment.d.ts","sourceRoot":"","sources":["../../../src/commands/hosting/deployment.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAGxC,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,MAAM,GAAG,GAChB,IAAI,CA6JN"}

package/build/commands/hosting/deployment.js

@@ -0,0 +1,125 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { handleApiCall, outputJson } from "../runHandler.js";
+export function registerDeploymentCommands(parent, getApi) {
+    const deployment = parent
+        .command("deployment")
+        .description("Inspect, create, and promote deployments");
+    deployment
+        .command("list")
+        .description("List deployments for a given app or worker")
+        .option("--app-uuid <uuid>", "App UUID")
+        .option("--worker-uuid <uuid>", "Worker UUID")
+        .action(async (opts) => {
+        if (opts.appUuid === undefined && opts.workerUuid === undefined) {
+            console.error(JSON.stringify({
+                error: "Either --app-uuid or --worker-uuid must be provided.",
+            }));
+            process.exit(1);
+        }
+        const api = getApi();
+        const result = await handleApiCall(() => api.hosting.deployment.list({
+            appUuid: opts.appUuid,
+            workerUuid: opts.workerUuid,
+        }));
+        outputJson(result);
+    });
+    deployment
+        .command("get <uuid>")
+        .description("Show a single deployment's status and metadata")
+        .action(async (uuid) => {
+        const api = getApi();
+        const result = await handleApiCall(() => api.hosting.deployment.get(uuid));
+        outputJson(result);
+    });
+    deployment
+        .command("get-promoted")
+        .description("Show the currently promoted deployment for an app or worker")
+        .option("--app-uuid <uuid>", "App UUID")
+        .option("--worker-uuid <uuid>", "Worker UUID")
+        .action(async (opts) => {
+        if (opts.appUuid === undefined && opts.workerUuid === undefined) {
+            console.error(JSON.stringify({
+                error: "Either --app-uuid or --worker-uuid must be provided.",
+            }));
+            process.exit(1);
+        }
+        const api = getApi();
+        const result = await handleApiCall(() => api.hosting.deployment.getPromoted({
+            appUuid: opts.appUuid,
+            workerUuid: opts.workerUuid,
+        }));
+        outputJson(result);
+    });
+    deployment
+        .command("create")
+        .description("Create a new deployment by uploading a local source directory. For apps the backend runs `npm ci && vite build` in a sandbox; for workers it bundles the entrypoint.")
+        .option("--app-uuid <uuid>", "App UUID (mutually exclusive with --worker-uuid)")
+        .option("--worker-uuid <uuid>", "Worker UUID (mutually exclusive with --app-uuid)")
+        .requiredOption("--source <dir>", "Path to the source directory (typically the package root, not dist/)")
+        .option("--ignore <list>", "Comma-separated names to ignore (default: node_modules,dist,build,.git,.next)", "node_modules,dist,build,.git,.next")
+        .action(async (opts) => {
+        if ((opts.appUuid === undefined && opts.workerUuid === undefined) ||
+            (opts.appUuid !== undefined && opts.workerUuid !== undefined)) {
+            console.error(JSON.stringify({
+                error: "Exactly one of --app-uuid or --worker-uuid must be provided.",
+            }));
+            process.exit(1);
+        }
+        const api = getApi();
+        const sourceDir = path.resolve(opts.source);
+        const ignore = new Set(opts.ignore.split(",").map((entry) => entry.trim()));
+        const files = await collectFiles(sourceDir, { ignore });
+        if (files.length === 0) {
+            console.error(JSON.stringify({
+                error: `No files to deploy under ${sourceDir}`,
+            }));
+            process.exit(1);
+        }
+        const payload = opts.appUuid !== undefined
+            ? { kind: "app", appUuid: opts.appUuid, files }
+            : {
+                kind: "worker",
+                workerUuid: opts.workerUuid,
+                files,
+            };
+        const result = await handleApiCall(() => api.hosting.deployment.create(payload));
+        outputJson({
+            ...result,
+            stats: { fileCount: files.length },
+        });
+    });
+    deployment
+        .command("promote")
+        .description("Promote a deployment to the live URL")
+        .requiredOption("--uuid <uuid>", "Deployment UUID to promote")
+        .action(async (opts) => {
+        const api = getApi();
+        const result = await handleApiCall(() => api.hosting.deployment.promote({
+            uuid: opts.uuid,
+        }));
+        outputJson(result);
+    });
+}
+const collectFiles = async (rootDir, options) => {
+    const results = [];
+    const walk = async (dir, relative) => {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (options.ignore.has(entry.name)) {
+                continue;
+            }
+            const absolute = path.join(dir, entry.name);
+            const rel = relative.length === 0 ? entry.name : `${relative}/${entry.name}`;
+            if (entry.isDirectory() === true) {
+                await walk(absolute, rel);
+            }
+            else if (entry.isFile() === true) {
+                const content = await fs.readFile(absolute, "utf-8");
+                results.push({ path: rel, content });
+            }
+        }
+    };
+    await walk(rootDir, "");
+    return results;
+};

package/build/commands/hosting/index.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "commander";
+import type { Api } from "../../api.js";
+export declare function registerHostingCommands(parent: Command, getApi: () => Api): void;
+//# sourceMappingURL=index.d.ts.map

package/build/commands/hosting/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/hosting/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAKxC,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,MAAM,GAAG,GAChB,IAAI,CAUN"}

package/build/commands/hosting/index.js

@@ -0,0 +1,11 @@
+import { registerAppCommands } from "./app.js";
+import { registerDeploymentCommands } from "./deployment.js";
+import { registerWorkerCommands } from "./worker.js";
+export function registerHostingCommands(parent, getApi) {
+    const hosting = parent
+        .command("hosting")
+        .description("Cargo Hosting: apps (Vite SPAs), workers (edge HTTP handlers), and deployments");
+    registerAppCommands(hosting, getApi);
+    registerWorkerCommands(hosting, getApi);
+    registerDeploymentCommands(hosting, getApi);
+}

package/build/commands/hosting/templateUtils.d.ts

@@ -0,0 +1,6 @@
+export declare const listTemplates: (root: string) => Promise<string[]>;
+export declare const copyDirectory: (src: string, dest: string, rename: {
+    from: string;
+    to: string;
+}[]) => Promise<void>;
+//# sourceMappingURL=templateUtils.d.ts.map

package/build/commands/hosting/templateUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"templateUtils.d.ts","sourceRoot":"","sources":["../../../src/commands/hosting/templateUtils.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,aAAa,SAAgB,MAAM,KAAG,QAAQ,MAAM,EAAE,CAUlE,CAAC;AAEF,eAAO,MAAM,aAAa,QACnB,MAAM,QACL,MAAM,UACJ;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,EAAE,KACrC,QAAQ,IAAI,CAmBd,CAAC"}

package/build/commands/hosting/templateUtils.js

@@ -0,0 +1,30 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+export const listTemplates = async (root) => {
+    try {
+        const entries = await fs.readdir(root, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isDirectory() === true)
+            .map((entry) => entry.name)
+            .filter((name) => name.startsWith("_") === false);
+    }
+    catch {
+        return [];
+    }
+};
+export const copyDirectory = async (src, dest, rename) => {
+    const entries = await fs.readdir(src, { withFileTypes: true });
+    await fs.mkdir(dest, { recursive: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory() === true) {
+            await copyDirectory(srcPath, destPath, rename);
+        }
+        else if (entry.isFile() === true) {
+            const raw = await fs.readFile(srcPath, "utf-8");
+            const replaced = rename.reduce((current, { from, to }) => current.split(from).join(to), raw);
+            await fs.writeFile(destPath, replaced, "utf-8");
+        }
+    }
+};

package/build/commands/hosting/worker.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "commander";
+import type { Api } from "../../api.js";
+export declare function registerWorkerCommands(parent: Command, getApi: () => Api): void;
+//# sourceMappingURL=worker.d.ts.map

package/build/commands/hosting/worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../../../src/commands/hosting/worker.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAMxC,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,MAAM,GAAG,GAChB,IAAI,CA8MN"}

package/build/commands/hosting/worker.js

@@ -0,0 +1,174 @@
+import { promises as fs } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { handleApiCall, outputJson } from "../runHandler.js";
+import { copyDirectory, listTemplates } from "./templateUtils.js";
+const require = createRequire(import.meta.url);
+export function registerWorkerCommands(parent, getApi) {
+    const worker = parent
+        .command("worker")
+        .description("Manage Cargo Hosting workers (serverless HTTP handlers running on the edge)");
+    worker
+        .command("list")
+        .description("List workers in the current workspace")
+        .option("--folder-uuid <uuid>", "Filter by folder UUID")
+        .action(async (opts) => {
+        const api = getApi();
+        const result = await handleApiCall(() => api.hosting.worker.list({
+            folderUuid: opts.folderUuid,
+        }));
+        outputJson(result);
+    });
+    worker
+        .command("get <uuid>")
+        .description("Show details of a single worker")
+        .action(async (uuid) => {
+        const api = getApi();
+        const result = await handleApiCall(() => api.hosting.worker.get(uuid));
+        outputJson(result);
+    });
+    worker
+        .command("create")
+        .description("Create a new worker slot")
+        .requiredOption("--name <name>", "Display name for the worker")
+        .requiredOption("--slug <slug>", "URL slug (must be globally unique within the hosting domain)")
+        .option("--folder-uuid <uuid>", "Optional folder UUID")
+        .action(async (opts) => {
+        const api = getApi();
+        const result = await handleApiCall(() => api.hosting.worker.create({
+            name: opts.name,
+            slug: opts.slug,
+            folderUuid: opts.folderUuid,
+        }));
+        outputJson(result);
+    });
+    worker
+        .command("update")
+        .description("Update an existing worker (name, folder)")
+        .requiredOption("--uuid <uuid>", "Worker UUID")
+        .option("--name <name>", "New display name")
+        .option("--folder-uuid <uuid>", "New folder UUID (pass 'null' to move to the workspace root)")
+        .action(async (opts) => {
+        const api = getApi();
+        const result = await handleApiCall(() => api.hosting.worker.update({
+            uuid: opts.uuid,
+            name: opts.name,
+            folderUuid: opts.folderUuid === "null" ? null : opts.folderUuid,
+        }));
+        outputJson(result);
+    });
+    worker
+        .command("remove <uuid>")
+        .description("Remove a worker (also removes its deployments)")
+        .action(async (uuid) => {
+        const api = getApi();
+        await handleApiCall(() => api.hosting.worker.remove(uuid));
+        outputJson({ ok: true });
+    });
+    worker
+        .command("init <directory>")
+        .description("Scaffold a new Cargo Hosting worker locally from a template (edge `fetch(request, env)` handler).")
+        .option("--template <slug>", "Template slug (default: blank)", "blank")
+        .option("--name <name>", "Worker name written into package.json (default: directory name)")
+        .option("--list-templates", "Print available templates and exit")
+        .action(async (directory, opts) => {
+        const templatesRoot = findWorkerTemplatesRoot();
+        if (opts.listTemplates === true) {
+            const slugs = await listTemplates(templatesRoot);
+            if (slugs.length === 0) {
+                console.error(JSON.stringify({ error: "No templates found", templatesRoot }));
+                process.exit(1);
+            }
+            console.log(JSON.stringify(slugs.map((slug) => ({
+                slug,
+                description: WORKER_TEMPLATE_DESCRIPTIONS[slug] !== undefined
+                    ? WORKER_TEMPLATE_DESCRIPTIONS[slug]
+                    : "",
+            })), null, 2));
+            return;
+        }
+        const templateDir = path.join(templatesRoot, opts.template);
+        try {
+            const stat = await fs.stat(templateDir);
+            if (stat.isDirectory() === false) {
+                throw new Error("Template path is not a directory");
+            }
+        }
+        catch {
+            const slugs = await listTemplates(templatesRoot);
+            console.error(JSON.stringify({
+                error: `Unknown template "${opts.template}"`,
+                available: slugs,
+            }));
+            process.exit(1);
+        }
+        const targetDir = path.resolve(directory);
+        try {
+            const stat = await fs.stat(targetDir);
+            if (stat.isDirectory() === true) {
+                const entries = await fs.readdir(targetDir);
+                if (entries.length > 0) {
+                    console.error(JSON.stringify({
+                        error: `Target directory ${targetDir} is not empty.`,
+                    }));
+                    process.exit(1);
+                }
+            }
+        }
+        catch {
+            // Target does not exist yet — that's fine.
+        }
+        const workerName = opts.name !== undefined ? opts.name : path.basename(targetDir);
+        await copyDirectory(templateDir, targetDir, [
+            { from: "__APP_NAME__", to: workerName },
+            { from: "__TEMPLATE_SLUG__", to: opts.template },
+        ]);
+        const nextSteps = [
+            `cd ${path.relative(process.cwd(), targetDir)}`,
+            "npm install",
+            `cargo-ai hosting worker create --name '${workerName}' --slug '<your-slug>'`,
+            "npm run build",
+            "cargo-ai hosting deployment create --worker-uuid <workerUuid> --source ./dist",
+            "cargo-ai hosting deployment promote --uuid <deploymentUuid>",
+        ];
+        if (opts.template === "custom-integration") {
+            nextSteps.push("cargo-ai connection custom-integration create --kind worker --worker-uuid <workerUuid>");
+        }
+        console.log(JSON.stringify({
+            ok: true,
+            directory: targetDir,
+            template: opts.template,
+            name: workerName,
+            nextSteps,
+        }, null, 2));
+    });
+}
+const WORKER_TEMPLATE_DESCRIPTIONS = {
+    blank: "Edge worker built on @cargo-ai/worker-sdk with automatic OpenAPI 3.1 spec at /openapi.json and Swagger UI at /docs.",
+    "custom-integration": "Cargo Custom Integration worker built on @cargo-ai/worker-sdk — manifest / actions / extractors / autocompletes / dynamic schemas with automatic /openapi.json.",
+};
+const findWorkerTemplatesRoot = () => {
+    // Worker templates live in `@cargo-ai/worker-sdk/templates`. Resolve via
+    // require so we work whether the user installed both packages globally or
+    // both came from the monorepo.
+    try {
+        const workerSdkPackageJson = require.resolve("@cargo-ai/worker-sdk/package.json");
+        return path.join(path.dirname(workerSdkPackageJson), "templates");
+    }
+    catch {
+        const here = fileURLToPath(import.meta.url);
+        let cursor = path.dirname(here);
+        for (let i = 0; i < 6; i += 1) {
+            const candidate = path.join(cursor, "packages/worker-sdk/templates");
+            try {
+                require("node:fs").accessSync(candidate);
+                return candidate;
+            }
+            catch {
+                cursor = path.dirname(cursor);
+            }
+        }
+        throw new Error("Could not locate @cargo-ai/worker-sdk templates. Make sure @cargo-ai/worker-sdk is installed alongside @cargo-ai/cli.");
+    }
+};

package/build/commands/orchestration/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/orchestration/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAexC,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,MAAM,GAAG,GAChB,IAAI,CAkBN"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/orchestration/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAgBxC,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,MAAM,GAAG,GAChB,IAAI,CAmBN"}

package/build/commands/orchestration/index.js

@@ -1,15 +1,16 @@
 import { registerActionCommands } from "./action.js";
 import { registerBatchCommands } from "./batch.js";
 import { registerDraftReleaseCommands } from "./draftRelease.js";
-import { registerLogCommands } from "./log.js";
 import { registerNodeCommands } from "./node.js";
 import { registerPlayCommands } from "./play.js";
 import { registerQueryCommands } from "./query.js";
 import { registerRecordCommands } from "./record.js";
 import { registerReleaseCommands } from "./release.js";
 import { registerRunCommands } from "./run.js";
+import { registerSpanCommands } from "./span.js";
 import { registerTemplateCommands } from "./template.js";
 import { registerToolCommands } from "./tool.js";
+import { registerTraceCommands } from "./trace.js";
 import { registerWorkflowCommands } from "./workflow.js";
 export function registerOrchestrationCommands(parent, getApi) {
     const orchestration = parent
@@ -20,7 +21,8 @@ export function registerOrchestrationCommands(parent, getApi) {
     registerPlayCommands(orchestration, getApi);
     registerRunCommands(orchestration, getApi);
     registerBatchCommands(orchestration, getApi);
-    registerLogCommands(orchestration, getApi);
+    registerSpanCommands(orchestration, getApi);
+    registerTraceCommands(orchestration, getApi);
     registerReleaseCommands(orchestration, getApi);
     registerDraftReleaseCommands(orchestration, getApi);
     registerToolCommands(orchestration, getApi);

package/build/commands/orchestration/query.js

@@ -8,12 +8,12 @@ export function registerQueryCommands(parent, getApi) {
         .description("Execute a read-only SQL query")
         .argument("<sql>", "SQL query string")
         .addHelpText("after", `
-Available tables: logs, runs, batches, records
+Available tables: spans, runs, batches, records
 
 Examples:
   $ cargo-ai orchestration query execute "SELECT count() FROM runs"
   $ cargo-ai orchestration query execute "SELECT status, count() FROM batches GROUP BY status"
-  $ cargo-ai orchestration query execute "SELECT * FROM logs ORDER BY execution_started_at DESC LIMIT 10"
+  $ cargo-ai orchestration query execute "SELECT * FROM spans ORDER BY execution_started_at DESC LIMIT 10"
   $ cargo-ai orchestration query execute "WITH recent AS (SELECT * FROM runs WHERE created_at > now() - INTERVAL 1 DAY) SELECT status, count() FROM recent GROUP BY status"`)
         .action(async (sql) => {
         const api = getApi();

package/build/commands/{context/file.d.ts → orchestration/span.d.ts}

@@ -1,4 +1,4 @@
 import type { Command } from "commander";
 import type { Api } from "../../api.js";
-export declare function registerFileCommands(parent: Command, getApi: () => Api): void;
-//# sourceMappingURL=file.d.ts.map
+export declare function registerSpanCommands(parent: Command, getApi: () => Api): void;
+//# sourceMappingURL=span.d.ts.map

package/build/commands/orchestration/span.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"span.d.ts","sourceRoot":"","sources":["../../../src/commands/orchestration/span.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAGxC,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,GAAG,IAAI,CAwO7E"}

package/build/commands/orchestration/{log.js → span.js}

@@ -1,9 +1,9 @@
 import { handleApiCall, outputJson } from "../runHandler.js";
-export function registerLogCommands(parent, getApi) {
-    const log = parent.command("log").description("Execution log operations");
-    log
+export function registerSpanCommands(parent, getApi) {
+    const span = parent.command("span").description("Execution span operations");
+    span
         .command("list")
-        .description("List execution logs")
+        .description("List execution spans")
         .option("--workflow-uuid <uuid>", "Workflow UUID (omit to include all workflows in the workspace)")
         .option("--batch-uuid <uuid>", "Batch UUID")
         .option("--run-uuid <uuid>", "Run UUID")
@@ -29,7 +29,7 @@ export function registerLogCommands(parent, getApi) {
         .option("--offset <n>", "Offset", "0")
         .action(async (opts) => {
         const api = getApi();
-        const result = await handleApiCall(() => api.orchestration.log.list({
+        const result = await handleApiCall(() => api.orchestration.span.list({
             workflowUuid: opts.workflowUuid,
             batchUuid: opts.batchUuid,
             runUuid: opts.runUuid,
@@ -62,9 +62,9 @@ export function registerLogCommands(parent, getApi) {
         }));
         outputJson(result);
     });
-    log
+    span
         .command("count")
-        .description("Count execution logs")
+        .description("Count execution spans")
         .option("--workflow-uuid <uuid>", "Workflow UUID (omit to include all workflows in the workspace)")
         .option("--batch-uuid <uuid>", "Batch UUID")
         .option("--run-uuid <uuid>", "Run UUID")
@@ -88,7 +88,7 @@ export function registerLogCommands(parent, getApi) {
         .option("--execution-started-before <date>", "Execution started on or before (ISO date)")
         .action(async (opts) => {
         const api = getApi();
-        const result = await handleApiCall(() => api.orchestration.log.count({
+        const result = await handleApiCall(() => api.orchestration.span.count({
             workflowUuid: opts.workflowUuid,
             batchUuid: opts.batchUuid,
             runUuid: opts.runUuid,

package/build/commands/orchestration/trace.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "commander";
+import type { Api } from "../../api.js";
+export declare function registerTraceCommands(parent: Command, getApi: () => Api): void;
+//# sourceMappingURL=trace.d.ts.map

package/build/commands/orchestration/trace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace.d.ts","sourceRoot":"","sources":["../../../src/commands/orchestration/trace.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAGxC,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,MAAM,GAAG,GAChB,IAAI,CAiHN"}

package/build/commands/orchestration/trace.js

@@ -0,0 +1,56 @@
+import { handleApiCall, outputJson } from "../runHandler.js";
+export function registerTraceCommands(parent, getApi) {
+    const trace = parent
+        .command("trace")
+        .description("Trace operations (per-execution aggregation across the run lineage)");
+    trace
+        .command("list")
+        .description("List traces (aggregated over their spans)")
+        .option("--workflow-uuid <uuid>", "Workflow UUID (omit to include all workflows in the workspace)")
+        .option("--statuses <list>", "Comma-separated trace statuses (pending, error, success)")
+        .requiredOption("--started-after <date>", "Trace's first span started after (ISO date)")
+        .option("--started-before <date>", "Trace's first span started on or before (ISO date)")
+        .option("--limit <n>", "Limit", "30")
+        .option("--offset <n>", "Offset", "0")
+        .action(async (opts) => {
+        const api = getApi();
+        const result = await handleApiCall(() => api.orchestration.trace.list({
+            workflowUuid: opts.workflowUuid,
+            statuses: opts.statuses !== undefined
+                ? opts.statuses.split(",").map((s) => s.trim())
+                : undefined,
+            startedAfter: opts.startedAfter,
+            startedBefore: opts.startedBefore,
+            limit: opts.limit !== undefined ? parseInt(opts.limit, 10) : undefined,
+            offset: opts.offset !== undefined ? parseInt(opts.offset, 10) : undefined,
+        }));
+        outputJson(result);
+    });
+    trace
+        .command("count")
+        .description("Count traces matching the filter")
+        .option("--workflow-uuid <uuid>", "Workflow UUID (omit to include all workflows in the workspace)")
+        .option("--statuses <list>", "Comma-separated trace statuses (pending, error, success)")
+        .requiredOption("--started-after <date>", "Trace's first span started after (ISO date)")
+        .option("--started-before <date>", "Trace's first span started on or before (ISO date)")
+        .action(async (opts) => {
+        const api = getApi();
+        const result = await handleApiCall(() => api.orchestration.trace.count({
+            workflowUuid: opts.workflowUuid,
+            statuses: opts.statuses !== undefined
+                ? opts.statuses.split(",").map((s) => s.trim())
+                : undefined,
+            startedAfter: opts.startedAfter,
+            startedBefore: opts.startedBefore,
+        }));
+        outputJson(result);
+    });
+    trace
+        .command("get <uuid>")
+        .description("Get a single trace by UUID")
+        .action(async (uuid) => {
+        const api = getApi();
+        const result = await handleApiCall(() => api.orchestration.trace.get(uuid));
+        outputJson(result);
+    });
+}

package/build/commands/storage/record.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"record.d.ts","sourceRoot":"","sources":["../../../src/commands/storage/record.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAGxC,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,MAAM,GAAG,GAChB,IAAI,CAwJN"}
+{"version":3,"file":"record.d.ts","sourceRoot":"","sources":["../../../src/commands/storage/record.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAGxC,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,MAAM,GAAG,GAChB,IAAI,CAsON"}

package/build/commands/storage/record.js

@@ -100,4 +100,55 @@ Example:
         }));
         outputJson({ ok: true });
     });
+    record
+        .command("create-bulk")
+        .description("Create multiple storage records in a single call")
+        .requiredOption("--model-uuid <uuid>", "Model UUID (string, required)")
+        .requiredOption("--records <json>", 'JSON array of record entries: [{ "data": { ... } }, ...]')
+        .addHelpText("after", `
+Example:
+  $ cargo-ai storage record create-bulk --model-uuid 550e8400-... \\
+      --records '[{"data":{"name":"Ada"}},{"data":{"name":"Lin"}}]'`)
+        .action(async (opts) => {
+        const api = getApi();
+        const result = await handleApiCall(() => api.storage.record.createBulk({
+            modelUuid: opts.modelUuid,
+            records: parseJson(opts.records, "--records"),
+        }));
+        outputJson(result);
+    });
+    record
+        .command("update-bulk")
+        .description("Update multiple storage records in a single call")
+        .requiredOption("--model-uuid <uuid>", "Model UUID (string, required)")
+        .requiredOption("--records <json>", 'JSON array of record entries: [{ "id": "rec_1", "data": { ... } }, ...]')
+        .addHelpText("after", `
+Example:
+  $ cargo-ai storage record update-bulk --model-uuid 550e8400-... \\
+      --records '[{"id":"rec_1","data":{"status":"done"}},{"id":"rec_2","data":{"status":"done"}}]'`)
+        .action(async (opts) => {
+        const api = getApi();
+        const result = await handleApiCall(() => api.storage.record.updateBulk({
+            modelUuid: opts.modelUuid,
+            records: parseJson(opts.records, "--records"),
+        }));
+        outputJson(result);
+    });
+    record
+        .command("remove-bulk")
+        .description("Remove multiple storage records in a single call")
+        .requiredOption("--model-uuid <uuid>", "Model UUID (string, required)")
+        .requiredOption("--ids <json>", 'JSON array of record IDs: ["rec_1", "rec_2", ...]')
+        .addHelpText("after", `
+Example:
+  $ cargo-ai storage record remove-bulk --model-uuid 550e8400-... \\
+      --ids '["rec_1","rec_2","rec_3"]'`)
+        .action(async (opts) => {
+        const api = getApi();
+        await handleApiCall(() => api.storage.record.removeBulk({
+            modelUuid: opts.modelUuid,
+            ids: parseJson(opts.ids, "--ids"),
+        }));
+        outputJson({ ok: true });
+    });
 }

package/build/index.js

@@ -8,6 +8,7 @@ import { registerBillingCommands } from "./commands/billing/index.js";
 import { registerConnectionCommands } from "./commands/connection/index.js";
 import { registerContextCommands } from "./commands/context/index.js";
 import { registerExpressionCommands } from "./commands/expression/index.js";
+import { registerHostingCommands } from "./commands/hosting/index.js";
 import { registerInitCommand } from "./commands/init.js";
 import { registerOrchestrationCommands } from "./commands/orchestration/index.js";
 import { registerRevenueOrganizationCommands } from "./commands/revenueOrganization/index.js";
@@ -65,6 +66,7 @@ registerExpressionCommands(program, getApi);
 registerSystemOfRecordIntegrationCommands(program, getApi);
 registerUserManagementCommands(program, getApi);
 registerAiCommands(program, getApi);
+registerHostingCommands(program, getApi);
 program.parseAsync().catch((err) => {
     failWith(err instanceof Error ? err.message : String(err));
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cargo-ai/cli",
-  "version": "1.0.15",
+  "version": "1.0.16",
   "private": false,
   "description": "Command-line interface for the Cargo API",
   "engines": {
@@ -28,8 +28,10 @@
     "format:check": "prettier --check ."
   },
   "dependencies": {
-    "commander": "^12.1.0",
-    "@cargo-ai/api": "^1.0.23"
+    "@cargo-ai/api": "^1.0.24",
+    "@cargo-ai/app-sdk": "^1.0.0",
+    "@cargo-ai/worker-sdk": "^1.0.0",
+    "commander": "^12.1.0"
   },
   "devDependencies": {
     "@cargo-ai/eslint-config": "*",

package/build/commands/context/file.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../../src/commands/context/file.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAGxC,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,GAAG,IAAI,CAqD7E"}

package/build/commands/context/file.js

@@ -1,39 +0,0 @@
-import { handleApiCall, outputJson } from "../runHandler.js";
-export function registerFileCommands(parent, getApi) {
-    const file = parent.command("file").description("Context file operations");
-    file
-        .command("browse")
-        .description("Browse files in the context repository")
-        .option("--path <path>", "Path to browse (omit for root)")
-        .action(async (opts) => {
-        const api = getApi();
-        const result = await handleApiCall(() => api.context.file.browse({ path: opts.path }));
-        outputJson(result);
-    });
-    file
-        .command("read")
-        .description("Read a file from the context repository")
-        .requiredOption("--path <path>", "Full path to the file")
-        .action(async (opts) => {
-        const api = getApi();
-        const result = await handleApiCall(() => api.context.file.read({ path: opts.path }));
-        outputJson(result);
-    });
-    file
-        .command("write")
-        .description("Write a file to the context repository")
-        .requiredOption("--path <path>", "Full path to the file")
-        .requiredOption("--content <content>", "Content to write")
-        .option("--commit-message <message>", "Commit message")
-        .option("--sha <sha>", "SHA of the existing file to update")
-        .action(async (opts) => {
-        const api = getApi();
-        const result = await handleApiCall(() => api.context.file.write({
-            path: opts.path,
-            content: opts.content,
-            commitMessage: opts.commitMessage,
-            sha: opts.sha,
-        }));
-        outputJson(result);
-    });
-}

package/build/commands/context/skill.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill.d.ts","sourceRoot":"","sources":["../../../src/commands/context/skill.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAGxC,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,MAAM,GAAG,GAChB,IAAI,CAuBN"}

package/build/commands/context/skill.js

@@ -1,21 +0,0 @@
-import { handleApiCall, outputJson } from "../runHandler.js";
-export function registerSkillCommands(parent, getApi) {
-    const skill = parent.command("skill").description("Context skill operations");
-    skill
-        .command("list")
-        .description("List all skills in the context repository")
-        .action(async () => {
-        const api = getApi();
-        const result = await handleApiCall(() => api.context.skill.list());
-        outputJson(result);
-    });
-    skill
-        .command("get")
-        .description("Get a skill by slug")
-        .requiredOption("--slug <slug>", "Skill slug (path in the repository)")
-        .action(async (opts) => {
-        const api = getApi();
-        const result = await handleApiCall(() => api.context.skill.get({ slug: opts.slug }));
-        outputJson(result);
-    });
-}

package/build/commands/orchestration/log.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../../../src/commands/orchestration/log.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAGxC,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,GAAG,IAAI,CAwO5E"}