@vellumai/assistant 0.10.9-staging.1 → 0.10.9-staging.2

package/src/cli/commands/platform/__tests__/status.test.ts

@@ -18,7 +18,6 @@ let mockResponse: unknown = {
     available: false,
     organizationId: null,
     userId: null,
-    velayTunnel: null,
   },
 };
 
@@ -63,7 +62,6 @@ describe("assistant platform status", () => {
         available: false,
         organizationId: null,
         userId: null,
-        velayTunnel: null,
       },
     };
     process.exitCode = 0;
@@ -81,7 +79,6 @@ describe("assistant platform status", () => {
         available: true,
         organizationId: "org-456",
         userId: "user-789",
-        velayTunnel: null,
       },
     };
 
@@ -116,93 +113,6 @@ describe("assistant platform status", () => {
     expect(parsed.available).toBe(true);
     expect(parsed.organizationId).toBe("org-456");
     expect(parsed.userId).toBe("user-789");
-    expect(parsed.velayTunnel).toBeNull();
-  });
-
-  test("velayTunnel connected with publicUrl is returned when gateway is live", async () => {
-    mockResponse = {
-      ok: true,
-      result: {
-        isPlatform: false,
-        baseUrl: "",
-        assistantId: "",
-        hasAssistantApiKey: false,
-        hasWebhookSecret: false,
-        available: false,
-        organizationId: null,
-        userId: null,
-        velayTunnel: {
-          connected: true,
-          publicUrl: "https://abc123.vellum.ai",
-        },
-      },
-    };
-
-    const program = buildProgram();
-    const stdoutChunks: string[] = [];
-    const origWrite = process.stdout.write.bind(process.stdout);
-    process.stdout.write = ((chunk: unknown) => {
-      stdoutChunks.push(typeof chunk === "string" ? chunk : String(chunk));
-      return true;
-    }) as typeof process.stdout.write;
-
-    try {
-      await program.parseAsync([
-        "node",
-        "assistant",
-        "platform",
-        "status",
-        "--json",
-      ]);
-    } finally {
-      process.stdout.write = origWrite;
-    }
-
-    const parsed = JSON.parse(stdoutChunks.join(""));
-    expect(parsed.velayTunnel).toEqual({
-      connected: true,
-      publicUrl: "https://abc123.vellum.ai",
-    });
-  });
-
-  test("velayTunnel disconnected when gateway reports no active connection", async () => {
-    mockResponse = {
-      ok: true,
-      result: {
-        isPlatform: false,
-        baseUrl: "",
-        assistantId: "",
-        hasAssistantApiKey: false,
-        hasWebhookSecret: false,
-        available: false,
-        organizationId: null,
-        userId: null,
-        velayTunnel: { connected: false, publicUrl: null },
-      },
-    };
-
-    const program = buildProgram();
-    const stdoutChunks: string[] = [];
-    const origWrite = process.stdout.write.bind(process.stdout);
-    process.stdout.write = ((chunk: unknown) => {
-      stdoutChunks.push(typeof chunk === "string" ? chunk : String(chunk));
-      return true;
-    }) as typeof process.stdout.write;
-
-    try {
-      await program.parseAsync([
-        "node",
-        "assistant",
-        "platform",
-        "status",
-        "--json",
-      ]);
-    } finally {
-      process.stdout.write = origWrite;
-    }
-
-    const parsed = JSON.parse(stdoutChunks.join(""));
-    expect(parsed.velayTunnel).toEqual({ connected: false, publicUrl: null });
   });
 
   test("plain text mode does not emit JSON to stdout", async () => {

package/src/cli/commands/platform/index.help.ts

@@ -58,8 +58,9 @@ Fields:
   available           Whether callback registration prerequisites are satisfied
   organizationId      The platform organization ID (from stored credentials)
   userId              The platform user ID (from stored credentials)
-  velayTunnel         Live Velay tunnel status from the gateway IPC socket
-                      (null when the gateway is not running)
+
+For the Velay tunnel state (only relevant for Twilio webhooks and live
+voice/audio), use 'assistant gateway status' instead.
 
 Examples:
   $ assistant platform status

package/src/cli/commands/platform/index.ts

@@ -24,7 +24,6 @@ interface PlatformStatusResult {
   available: boolean;
   organizationId: string | null;
   userId: string | null;
-  velayTunnel: { connected: boolean; publicUrl: string | null } | null;
 }
 
 interface PlatformCreditsResult {
@@ -87,14 +86,6 @@ export function registerPlatformCommand(program: Command): void {
               `Organization ID: ${result.organizationId || "(not set)"}`,
             );
             log.info(`User ID: ${result.userId || "(not set)"}`);
-            if (result.velayTunnel !== null) {
-              const tunnelState = result.velayTunnel.connected
-                ? `connected${result.velayTunnel.publicUrl ? ` (${result.velayTunnel.publicUrl})` : ""}`
-                : "disconnected";
-              log.info(`Velay tunnel: ${tunnelState}`);
-            } else {
-              log.info(`Velay tunnel: (gateway not running)`);
-            }
           }
         },
       );

package/src/cli/commands/routes.help.ts

@@ -8,8 +8,10 @@ export const routesHelp: CliCommandHelp = {
     "Manage user-defined authenticated HTTP route handlers under /x/*",
   helpText: `
 User-defined routes let you expose custom HTTP endpoints by dropping handler
-files into /workspace/routes/. Each file exports named HTTP method functions
-(GET, POST, etc.) and becomes reachable at /x/<path>.
+files into /workspace/routes/ (reachable at /x/<path>) or into a plugin's
+/workspace/plugins/<name>/routes/ (reachable in that plugin's namespace at
+/x/plugins/<name>/<path>). Each file exports named HTTP method functions
+(GET, POST, etc.).
 
 These routes require edge authentication — they are intended for
 assistant-internal or user-facing endpoints, not for unauthenticated provider
@@ -21,7 +23,8 @@ needed.
 Examples:
   $ assistant routes list
   $ assistant routes list --json
-  $ assistant routes inspect my-dashboard-api/submit`,
+  $ assistant routes inspect my-dashboard-api/submit
+  $ assistant routes inspect plugins/my-plugin/status`,
   subcommands: [
     {
       name: "list",
@@ -33,8 +36,9 @@ Examples:
         },
       ],
       helpText: `
-Scans /workspace/routes/ for handler files (.ts, .js) and displays the route
-path, exported HTTP methods, optional description, and file location.
+Scans /workspace/routes/ and each enabled plugin's /workspace/plugins/<name>/routes/
+for handler files (.ts, .js) and displays the route path, exported HTTP
+methods, optional description, and file location.
 
 Examples:
   $ assistant routes list
@@ -52,14 +56,16 @@ Examples:
       ],
       helpText: `
 Arguments:
-  path   Route path relative to /x/ (e.g. "my-dashboard-api/submit").
-         Do not include the /x/ prefix.
+  path   Route path relative to /x/ (e.g. "my-dashboard-api/submit" or
+         "plugins/my-plugin/status"). The /x/ prefix is optional, so a path
+         copied straight from 'routes list' works too.
 
 Loads the handler file and displays exported methods, description, file path,
 public URL, file size, and last modified time.
 
 Examples:
   $ assistant routes inspect my-dashboard-api/submit
+  $ assistant routes inspect plugins/my-plugin/status
   $ assistant routes inspect items --json`,
     },
   ],

package/src/cli/commands/routes.ts

@@ -68,7 +68,9 @@ export function registerRoutesCommand(program: Command): void {
         }
 
         if (discovered.length === 0) {
-          log.info("No route handlers found in /workspace/routes/.");
+          log.info(
+            "No route handlers found in /workspace/routes/ or /workspace/plugins/<name>/routes/.",
+          );
           log.info(
             "Create a .ts or .js file exporting named HTTP method functions (GET, POST, etc.).",
           );
@@ -108,7 +110,7 @@ export function registerRoutesCommand(program: Command): void {
             route.routePath.padEnd(routeWidth),
             formatMethods(route.methods).padEnd(methodsWidth),
             (route.description ?? "").padEnd(descWidth),
-            `routes/${route.filePath}`,
+            route.filePath,
           ].join("    ");
           log.info(`  ${cols}`);
         }
@@ -130,7 +132,7 @@ export function registerRoutesCommand(program: Command): void {
         async (routePath: string, opts: { json?: boolean }) => {
           const r = await cliIpcCall<{ route: InspectedRoute }>(
             "user_routes_inspect",
-            { path: routePath },
+            { body: { path: routePath } },
           );
           if (!r.ok) {
             if (opts.json) {

package/src/cli/commands/status.help.ts

@@ -5,4 +5,28 @@ import type { CliCommandHelp } from "../lib/cli-command-help.js";
 export const statusHelp: CliCommandHelp = {
   name: "status",
   description: "Show assistant version, workspace, and runtime health",
+  options: [
+    {
+      flags: "--json",
+      description: "Emit the status as machine-readable JSON",
+    },
+  ],
+  helpText: `
+Behavior:
+  Reports the running assistant's version, workspace path, and memory/disk
+  usage. When the assistant is unreachable, falls back to the installed CLI
+  version and whether the assistant socket is present.
+
+With --json, the same fields are emitted as a single JSON object:
+  - reachable:        whether the assistant answered the health check
+  - cliVersion:       the installed CLI version
+  - assistantVersion: the running assistant version (null when unreachable)
+  - versionStale:     true when the CLI and assistant versions differ
+  - workspace:        the workspace directory
+  - memory / disk:    usage in MB (null when unreachable)
+
+Examples:
+  $ assistant status
+  $ assistant status --json
+  $ assistant status --json | jq '.assistantVersion'`,
 };

package/src/cli/commands/status.ts

@@ -8,6 +8,7 @@ import { getWorkspaceDirDisplay } from "../../util/platform.js";
 import { APP_VERSION } from "../../version.js";
 import { applyCommandHelp } from "../lib/cli-command-help.js";
 import { registerCommand } from "../lib/register-command.js";
+import { shouldOutputJson, writeOutput } from "../output.js";
 import { statusHelp } from "./status.help.js";
 
 interface HealthResponse {
@@ -30,6 +31,7 @@ export function registerStatusCommand(program: Command): void {
       applyCommandHelp(cmd, statusHelp);
 
       cmd.action(async () => {
+        const json = shouldOutputJson(cmd);
         const result = await cliIpcCall<HealthResponse>("health");
 
         if (!result.ok) {
@@ -41,6 +43,19 @@ export function registerStatusCommand(program: Command): void {
             const socketPath = getAssistantSocketPath();
             const socketExists = existsSync(socketPath);
             const workspace = getWorkspaceDirDisplay();
+            if (json) {
+              writeOutput(cmd, {
+                reachable: false,
+                cliVersion: APP_VERSION,
+                assistantVersion: null,
+                versionStale: false,
+                running: socketExists,
+                workspace,
+                memory: null,
+                disk: null,
+              });
+              process.exit(0);
+            }
             // Daemon unreachable, so its runtime version is unknown; show the
             // installed CLI version so there's always one reliable number.
             process.stdout.write(`CLI Version: ${APP_VERSION}\n`);
@@ -62,6 +77,20 @@ export function registerStatusCommand(program: Command): void {
         const h = result.result;
         const workspace = getWorkspaceDirDisplay();
 
+        if (json) {
+          writeOutput(cmd, {
+            reachable: true,
+            cliVersion: APP_VERSION,
+            assistantVersion: h.version,
+            versionStale: h.version !== APP_VERSION,
+            running: true,
+            workspace,
+            memory: h.memory,
+            disk: h.disk,
+          });
+          return;
+        }
+
         // h.version is the running runtime; APP_VERSION is the installed CLI.
         // They drift mid-upgrade (CLI bumped, daemon not yet restarted).
         const runtimeVersion =

package/src/cli/lib/__tests__/global-json-option.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from "bun:test";
+
+import { Command } from "commander";
+
+import { registerGlobalJsonOption } from "../global-json-option.js";
+
+function hasJsonOption(cmd: Command): boolean {
+  return cmd.options.some((opt) => opt.long === "--json");
+}
+
+describe("registerGlobalJsonOption", () => {
+  it("adds --json to leaf commands (including nested leaves)", () => {
+    const program = new Command();
+    program.name("assistant");
+    const memory = program.command("memory");
+    const items = memory.command("items");
+    const list = items.command("list");
+    const status = program.command("status");
+
+    registerGlobalJsonOption(program);
+
+    expect(hasJsonOption(list)).toBe(true);
+    expect(hasJsonOption(status)).toBe(true);
+  });
+
+  it("does NOT add --json to group commands (would steal the flag from subcommands)", () => {
+    const program = new Command();
+    program.name("assistant");
+    const clients = program.command("clients");
+    const list = clients.command("list");
+
+    registerGlobalJsonOption(program);
+
+    // Commander consumes a recognized option at the outermost declaring
+    // command, so a group-level --json would swallow `clients list --json`
+    // before the leaf action reads it.
+    expect(hasJsonOption(clients)).toBe(false);
+    expect(hasJsonOption(list)).toBe(true);
+  });
+
+  it("keeps `<group> <leaf> --json` bound to the leaf's own opts", () => {
+    const program = new Command();
+    program.name("assistant").exitOverride();
+    const clients = program.command("clients");
+    let leafJson: unknown;
+    clients.command("list").action((opts: { json?: boolean }) => {
+      leafJson = opts.json;
+    });
+
+    registerGlobalJsonOption(program);
+
+    program.parse(["node", "assistant", "clients", "list", "--json"]);
+    expect(leafJson).toBe(true);
+  });
+
+  it("does not duplicate --json on a command that already declares it", () => {
+    const program = new Command();
+    program.name("assistant");
+    const sub = program.command("nodes");
+    sub.option("--json", "Machine-readable compact JSON output");
+
+    registerGlobalJsonOption(program);
+
+    const jsonOptions = sub.options.filter((opt) => opt.long === "--json");
+    expect(jsonOptions).toHaveLength(1);
+    // The original description is preserved, not overwritten.
+    expect(jsonOptions[0]!.description).toBe(
+      "Machine-readable compact JSON output",
+    );
+  });
+
+  it("leaves the root program without a --json option", () => {
+    const program = new Command();
+    program.name("assistant");
+    program.command("status");
+
+    registerGlobalJsonOption(program);
+
+    expect(hasJsonOption(program)).toBe(false);
+  });
+
+  it("makes --json parse without error on a command that lacked it", () => {
+    const program = new Command();
+    program.name("assistant").exitOverride();
+    let seenJson: unknown;
+    program.command("status").action((opts: { json?: boolean }) => {
+      seenJson = opts.json;
+    });
+
+    registerGlobalJsonOption(program);
+
+    expect(() =>
+      program.parse(["node", "assistant", "status", "--json"]),
+    ).not.toThrow();
+    expect(seenJson).toBe(true);
+  });
+});

package/src/cli/lib/__tests__/plugin-catalog-local.test.ts

@@ -37,6 +37,7 @@ describe("buildBundledPluginCatalog", () => {
       category: "productivity",
       homepage: "https://github.com/JuliusBrussee/caveman",
       license: "MIT",
+      icon: "🦴",
       source: {
         kind: "github",
         repo: "JuliusBrussee/caveman",

package/src/cli/lib/__tests__/plugin-fingerprint.test.ts

@@ -243,3 +243,34 @@ describe("computeContentHash", () => {
     expect(second).not.toBe(first);
   });
 });
+
+describe("generated app build output is excluded", () => {
+  test("apps/<app>/dist is not fingerprinted, so a build is never drift", () => {
+    // Installed source: an app with a src/ entry point (no dist yet).
+    write("apps/dash/src/main.tsx", "export default 1;");
+    write("hooks/stop.ts", "export default () => 1;");
+    const baseline = computeFingerprint(root);
+    expect(Object.keys(baseline.files)).toContain("apps/dash/src/main.tsx");
+
+    // The watcher later compiles src -> apps/dash/dist. That generated output
+    // must not surface as drift (added files) against the pinned commit.
+    write("apps/dash/dist/main.js", "console.log(1)");
+    write("apps/dash/dist/index.html", "<html></html>");
+    const cmp = compareFingerprint(root, baseline);
+    expect(cmp.clean).toBe(true);
+    expect(cmp.added).toEqual([]);
+
+    // A plugin's own top-level dist/ is still tracked (not an app build dir).
+    write("dist/bundle.js", "x");
+    expect(compareFingerprint(root, baseline).added).toEqual([
+      "dist/bundle.js",
+    ]);
+  });
+
+  test("content hash ignores apps/<app>/dist", () => {
+    write("apps/dash/src/main.tsx", "export default 1;");
+    const before = computeContentHash(root);
+    write("apps/dash/dist/main.js", "console.log(1)");
+    expect(computeContentHash(root)).toBe(before);
+  });
+});