@vellumai/assistant 0.8.0 → 0.8.1

package/src/cli/commands/webhooks.ts

@@ -1,58 +1,29 @@
 /**
  * `assistant webhooks` — unified webhook URL management.
  *
- * Abstracts over the platform/self-hosted split so skills and setup flows
- * can get a callback URL in one command without branching on IS_PLATFORM,
- * loading the public-ingress skill, or calling `platform callback-routes
- * register` directly.
+ * Thin IPC wrapper that delegates webhook operations to the daemon.
  *
- * Platform-managed:  registers a callback route and returns the platform URL.
- * Self-hosted:       resolves ingress.publicBaseUrl and appends the path.
+ * Platform-managed:  daemon registers a callback route and returns the platform URL.
+ * Self-hosted:       daemon resolves ingress.publicBaseUrl and appends the path.
  */
 
 import type { Command } from "commander";
 
-import { getIsPlatform } from "../../config/env-registry.js";
-import { getConfig } from "../../config/loader.js";
-import {
-  registerCallbackRoute,
-  resolvePlatformCallbackRegistrationContext,
-} from "../../inbound/platform-callback-registration.js";
-import { getPublicBaseUrl } from "../../inbound/public-ingress-urls.js";
+import { cliIpcCall, exitFromIpcResult } from "../../ipc/cli-client.js";
+import { registerCommand } from "../lib/register-command.js";
 import { log } from "../logger.js";
 import { shouldOutputJson, writeOutput } from "../output.js";
 
-// ---------------------------------------------------------------------------
-// Type → path derivation
-// ---------------------------------------------------------------------------
-
-/**
- * Derive the webhook path from the type name.
- *
- * Convention: underscores become path separators, prefixed with `webhooks/`.
- *   telegram       → webhooks/telegram
- *   twilio_voice   → webhooks/twilio/voice
- *   twilio_status  → webhooks/twilio/status
- *   resend         → webhooks/resend
- *   oauth_callback → webhooks/oauth/callback
- */
-function deriveWebhookPath(type: string): string {
-  return `webhooks/${type.replace(/_/g, "/")}`;
-}
-
-// ---------------------------------------------------------------------------
-// Command registration
-// ---------------------------------------------------------------------------
-
 export function registerWebhooksCommand(program: Command): void {
-  const webhooks = program
-    .command("webhooks")
-    .description("Manage webhook callback URLs for external integrations")
-    .option("--json", "Machine-readable compact JSON output");
-
-  webhooks.addHelpText(
-    "after",
-    `
+  registerCommand(program, {
+    name: "webhooks",
+    transport: "ipc",
+    description: "Manage webhook callback URLs for external integrations",
+    build: (webhooks) => {
+      webhooks.option("--json", "Machine-readable compact JSON output");
+      webhooks.addHelpText(
+        "after",
+        `
 Resolves a stable callback URL that external services (Telegram, Twilio,
 email providers, OAuth) should use to reach this assistant.
 
@@ -73,20 +44,20 @@ Examples:
   $ assistant webhooks register resend --source "@bot_handle"
   $ assistant webhooks list
   $ assistant webhooks list --json`,
-  );
-
-  // ---------------------------------------------------------------------------
-  // webhooks register <type>
-  // ---------------------------------------------------------------------------
-
-  webhooks
-    .command("register <type>")
-    .description(
-      "Get a callback URL for a webhook type, registering with the platform if needed",
-    )
-    .addHelpText(
-      "after",
-      `
+      );
+
+      // -----------------------------------------------------------------------
+      // webhooks register <type>
+      // -----------------------------------------------------------------------
+
+      webhooks
+        .command("register <type>")
+        .description(
+          "Get a callback URL for a webhook type, registering with the platform if needed",
+        )
+        .addHelpText(
+          "after",
+          `
 Resolves a callback URL for the given webhook type. On platform-managed
 assistants (IS_PLATFORM=true), registers a callback route with the platform
 gateway and returns the stable external URL. On self-hosted assistants,
@@ -114,74 +85,49 @@ Examples:
   $ assistant webhooks register twilio_voice --json
   $ assistant webhooks register resend --json
   $ assistant webhooks register custom_provider --path webhooks/my-provider --json`,
-    )
-    .option("--path <path>", "Override the derived webhook path")
-    .option(
-      "--source <label>",
-      "Human-readable source label for admin display (e.g. bot handle, phone number)",
-    )
-    .action(
-      async (
-        type: string,
-        opts: { path?: string; source?: string },
-        cmd: Command,
-      ) => {
-        try {
-          const webhookPath = opts.path ?? deriveWebhookPath(type);
-
-          let callbackUrl: string;
-          let mode: "platform" | "self-hosted";
-
-          if (getIsPlatform()) {
-            // Platform-managed: register callback route
-            callbackUrl = await registerCallbackRoute(
-              webhookPath,
-              type,
-              opts.source,
-            );
-            mode = "platform";
-          } else {
-            // Self-hosted: use ingress.publicBaseUrl
-            const config = getConfig();
-            const baseUrl = getPublicBaseUrl(config);
-            callbackUrl = `${baseUrl}/${webhookPath}`;
-            mode = "self-hosted";
-          }
-
-          if (shouldOutputJson(cmd)) {
-            writeOutput(cmd, {
-              ok: true,
-              callbackUrl,
-              type,
-              path: webhookPath,
-              mode,
+        )
+        .option("--path <path>", "Override the derived webhook path")
+        .option(
+          "--source <label>",
+          "Human-readable source label for admin display (e.g. bot handle, phone number)",
+        )
+        .action(
+          async (
+            type: string,
+            opts: { path?: string; source?: string },
+            cmd: Command,
+          ) => {
+            const r = await cliIpcCall<{
+              callbackUrl: string;
+              type: string;
+              path: string;
+              mode: "platform" | "self-hosted";
+            }>("webhooks_register", {
+              body: {
+                type,
+                path: opts.path,
+                source: opts.source,
+              },
             });
-          } else {
-            // Plain mode: emit only the URL so callers can capture it with $()
-            process.stdout.write(callbackUrl + "\n");
-          }
-        } catch (err) {
-          const message = err instanceof Error ? err.message : String(err);
-          if (shouldOutputJson(cmd)) {
-            writeOutput(cmd, { ok: false, error: message });
-          } else {
-            log.error(message);
-          }
-          process.exitCode = 1;
-        }
-      },
-    );
-
-  // ---------------------------------------------------------------------------
-  // webhooks list
-  // ---------------------------------------------------------------------------
-
-  webhooks
-    .command("list")
-    .description("List registered webhook callback routes")
-    .addHelpText(
-      "after",
-      `
+            if (!r.ok) return exitFromIpcResult({ ok: false, error: r.error, statusCode: r.statusCode }, cmd);
+            if (shouldOutputJson(cmd)) {
+              writeOutput(cmd, { ok: true, ...r.result });
+            } else {
+              process.stdout.write(r.result!.callbackUrl + "\n");
+            }
+          },
+        );
+
+      // -----------------------------------------------------------------------
+      // webhooks list
+      // -----------------------------------------------------------------------
+
+      webhooks
+        .command("list")
+        .description("List registered webhook callback routes")
+        .addHelpText(
+          "after",
+          `
 Lists all webhook callback routes registered with the platform for this
 assistant. Only available when platform credentials are configured (either
 via IS_PLATFORM or 'assistant platform connect').
@@ -193,78 +139,38 @@ on demand.
 Examples:
   $ assistant webhooks list
   $ assistant webhooks list --json`,
-    )
-    .action(async (_opts: Record<string, unknown>, cmd: Command) => {
-      try {
-        const context = await resolvePlatformCallbackRegistrationContext();
-        if (!context.platformBaseUrl || !context.authHeader) {
-          const errorMsg =
-            "Self-hosted webhook listing coming soon. Use 'assistant webhooks register <type>' to resolve URLs on demand.";
-          if (shouldOutputJson(cmd)) {
-            writeOutput(cmd, { ok: false, error: errorMsg });
-          } else {
-            log.error(errorMsg);
-          }
-          process.exitCode = 1;
-          return;
-        }
-
-        const url = `${context.platformBaseUrl}/v1/internal/gateway/callback-routes/`;
-        const response = await fetch(url, {
-          method: "GET",
-          headers: {
-            Authorization: context.authHeader,
-            Accept: "application/json",
-          },
-          signal: AbortSignal.timeout(10_000),
-        });
-
-        if (!response.ok) {
-          const detail = await response.text().catch(() => "");
-          const errorMsg = `Failed to list webhook routes (HTTP ${response.status}): ${detail}`;
+        )
+        .action(async (_opts: Record<string, unknown>, cmd: Command) => {
+          const r = await cliIpcCall<{
+            routes: Array<{
+              id: string;
+              assistant_id: string;
+              type: string;
+              callback_path: string;
+              callback_url: string;
+              source_identifier: string | null;
+            }>;
+          }>("webhooks_list", {});
+          if (!r.ok) return exitFromIpcResult({ ok: false, error: r.error, statusCode: r.statusCode }, cmd);
           if (shouldOutputJson(cmd)) {
-            writeOutput(cmd, { ok: false, error: errorMsg });
+            writeOutput(cmd, { ok: true, routes: r.result!.routes });
           } else {
-            log.error(errorMsg);
-          }
-          process.exitCode = 1;
-          return;
-        }
-
-        const routes = (await response.json()) as Array<{
-          id: string;
-          assistant_id: string;
-          type: string;
-          callback_path: string;
-          callback_url: string;
-          source_identifier: string | null;
-        }>;
-
-        if (shouldOutputJson(cmd)) {
-          writeOutput(cmd, { ok: true, routes });
-        } else {
-          if (routes.length === 0) {
-            log.info("No webhook routes registered.");
-          } else {
-            log.info(`${routes.length} webhook route(s) registered:\n`);
-            for (const route of routes) {
-              log.info(`  Type:   ${route.type}`);
-              log.info(`  URL:    ${route.callback_url}`);
-              if (route.source_identifier) {
-                log.info(`  Source: ${route.source_identifier}`);
+            const routes = r.result!.routes;
+            if (routes.length === 0) {
+              log.info("No webhook routes registered.");
+            } else {
+              log.info(`${routes.length} webhook route(s) registered:\n`);
+              for (const route of routes) {
+                log.info(`  Type:   ${route.type}`);
+                log.info(`  URL:    ${route.callback_url}`);
+                if (route.source_identifier) {
+                  log.info(`  Source: ${route.source_identifier}`);
+                }
+                log.info("");
               }
-              log.info("");
             }
           }
-        }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        if (shouldOutputJson(cmd)) {
-          writeOutput(cmd, { ok: false, error: message });
-        } else {
-          log.error(message);
-        }
-        process.exitCode = 1;
-      }
-    });
+        });
+    },
+  });
 }

package/src/cli/lib/__tests__/register-command.test.ts

@@ -0,0 +1,85 @@
+import { describe, expect, test } from "bun:test";
+
+import { Command } from "commander";
+
+import { type CommandTransport, registerCommand } from "../register-command.js";
+
+describe("registerCommand", () => {
+  test("registers a command with the correct name and description", () => {
+    const parent = new Command();
+    const result = registerCommand(parent, {
+      name: "test-cmd",
+      transport: "ipc",
+      description: "A test command",
+      build: () => {},
+    });
+
+    expect(result.name()).toBe("test-cmd");
+    expect(result.description()).toBe("A test command");
+  });
+
+  test("calls build with the command instance", () => {
+    const parent = new Command();
+    let receivedCmd: Command | undefined;
+
+    registerCommand(parent, {
+      name: "my-cmd",
+      transport: "local",
+      description: "My command",
+      build: (cmd) => {
+        receivedCmd = cmd;
+      },
+    });
+
+    expect(receivedCmd).toBeDefined();
+    expect(receivedCmd!.name()).toBe("my-cmd");
+  });
+
+  test("returns the registered command", () => {
+    const parent = new Command();
+    const result = registerCommand(parent, {
+      name: "ret-cmd",
+      transport: "bootstrap",
+      description: "Return test",
+      build: () => {},
+    });
+
+    expect(result).toBeInstanceOf(Command);
+    expect(result.name()).toBe("ret-cmd");
+  });
+
+  test.each([
+    ["ipc" as CommandTransport],
+    ["local" as CommandTransport],
+    ["bootstrap" as CommandTransport],
+  ])("accepts transport value: %s", (transport) => {
+    const parent = new Command();
+    let buildCalled = false;
+
+    const result = registerCommand(parent, {
+      name: `cmd-${transport}`,
+      transport,
+      description: `Command with transport ${transport}`,
+      build: () => {
+        buildCalled = true;
+      },
+    });
+
+    expect(buildCalled).toBe(true);
+    expect(result.name()).toBe(`cmd-${transport}`);
+    expect(result.description()).toBe(`Command with transport ${transport}`);
+  });
+
+  test("attaches the command as a subcommand of parent", () => {
+    const parent = new Command("program");
+    registerCommand(parent, {
+      name: "sub",
+      transport: "ipc",
+      description: "Subcommand",
+      build: () => {},
+    });
+
+    const names = parent.commands.map((c) => c.name());
+    expect(names).toContain("sub");
+  });
+});

package/src/cli/lib/daemon-credential-client.ts

@@ -48,8 +48,8 @@ export async function setSecureKeyViaDaemon(
   value: string,
 ): Promise<SetSecureKeyResult> {
   const ipc = await cliIpcCall<{ success: boolean; error?: string }>(
-    "secrets/write",
-    { type, name, value },
+    "secrets_add",
+    { body: { type, name, value } },
   );
 
   if (ipc.ok && ipc.result?.success) {
@@ -109,9 +109,8 @@ export async function deleteSecureKeyViaDaemon(
   type: string,
   name: string,
 ): Promise<DeleteSecureKeyResult> {
-  const ipc = await cliIpcCall<{ success: boolean }>("secrets/delete", {
-    type,
-    name,
+  const ipc = await cliIpcCall<{ success: boolean }>("secrets_delete", {
+    body: { type, name },
   });
 
   if (ipc.ok && ipc.result?.success) {

package/src/cli/lib/nested-value.ts

@@ -0,0 +1,44 @@
+/**
+ * Dotted-path get/set helpers for the CLI.
+ *
+ * These two functions are byte-for-byte equivalent to the implementations in
+ * `config/loader.ts` (see `getNestedValue` / `setNestedValue` there). They
+ * are inlined here so the IPC-tagged `config` command can walk dotted paths
+ * without importing `config/loader.js`, which has module-level side effects
+ * (config cache, file watcher, etc.) inappropriate for the CLI process.
+ *
+ * Loader and CLI both call `setNestedValue("a.b.c", v)`-style helpers - if
+ * the behavior needs to change in one place, change it in both.
+ */
+
+export function getNestedValue(
+  obj: Record<string, unknown>,
+  path: string,
+): unknown {
+  const keys = path.split(".");
+  let current: unknown = obj;
+  for (const key of keys) {
+    if (current == null || typeof current !== "object") {
+      return undefined;
+    }
+    current = (current as Record<string, unknown>)[key];
+  }
+  return current;
+}
+
+export function setNestedValue(
+  obj: Record<string, unknown>,
+  path: string,
+  value: unknown,
+): void {
+  const keys = path.split(".");
+  let current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i]!;
+    if (current[key] == null || typeof current[key] !== "object") {
+      current[key] = {};
+    }
+    current = current[key] as Record<string, unknown>;
+  }
+  current[keys[keys.length - 1]!] = value;
+}

package/src/cli/lib/open-browser.ts

@@ -0,0 +1,36 @@
+/**
+ * CLI-side helper that opens a URL on the user's host machine.
+ *
+ * Writes an `open_url` event to the `signals/emit-event` file so that the
+ * daemon's ConfigWatcher picks it up and publishes it to connected clients
+ * (e.g. the Swift macOS app) via the assistant event hub.
+ *
+ * Uses only `node:` imports so it's safe for `ipc`-tagged CLI commands.
+ */
+
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+function getWorkspaceDir(): string {
+  return (
+    process.env.VELLUM_WORKSPACE_DIR ??
+    join(
+      process.env.HOME ?? process.env.USERPROFILE ?? "/tmp",
+      ".vellum",
+      "workspace",
+    )
+  );
+}
+
+export function openInHostBrowser(url: string): void {
+  try {
+    const signalsDir = join(getWorkspaceDir(), "signals");
+    mkdirSync(signalsDir, { recursive: true });
+    writeFileSync(
+      join(signalsDir, "emit-event"),
+      JSON.stringify({ type: "open_url", url }),
+    );
+  } catch {
+    // Best-effort — caller will display the URL as a fallback
+  }
+}

package/src/cli/lib/register-command.ts

@@ -0,0 +1,19 @@
+import type { Command } from "commander";
+
+export type CommandTransport = "ipc" | "local" | "bootstrap";
+
+interface RegisterCommandOpts {
+  name: string;
+  transport: CommandTransport;
+  description: string;
+  build: (cmd: Command) => void;
+}
+
+export function registerCommand(
+  parent: Command,
+  opts: RegisterCommandOpts,
+): Command {
+  const cmd = parent.command(opts.name).description(opts.description);
+  opts.build(cmd);
+  return cmd;
+}

package/src/cli/lib/time-ago.ts

@@ -0,0 +1,34 @@
+/**
+ * Relative-time formatter for CLI output.
+ *
+ * Pure function with no daemon-internal imports — safe for IPC-tagged commands.
+ */
+export function timeAgo(timestamp: number): string {
+  const seconds = Math.floor((Date.now() - timestamp) / 1000);
+  if (seconds < 60) return "just now";
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  if (days === 1) return "yesterday";
+  if (days < 14) return `${days}d ago`;
+  const weeks = Math.floor(days / 7);
+  if (weeks < 8) return `${weeks}w ago`;
+  const date = new Date(timestamp);
+  const months = [
+    "Jan",
+    "Feb",
+    "Mar",
+    "Apr",
+    "May",
+    "Jun",
+    "Jul",
+    "Aug",
+    "Sep",
+    "Oct",
+    "Nov",
+    "Dec",
+  ];
+  return `${months[date.getMonth()]} ${date.getDate()}`;
+}

package/src/cli/program.ts

@@ -10,12 +10,12 @@ import { APP_VERSION } from "../version.js";
 import { registerAttachmentCommand } from "./commands/attachment.js";
 import { registerAuditCommand } from "./commands/audit.js";
 import { registerAuthCommand } from "./commands/auth.js";
-import { registerAutonomyCommand } from "./commands/autonomy.js";
 import { registerAvatarCommand } from "./commands/avatar.js";
 import { registerBackupCommand } from "./commands/backup.js";
 import { registerBashCommand } from "./commands/bash.js";
 import { registerBrowserCommand } from "./commands/browser.js";
 import { registerCacheCommand } from "./commands/cache.js";
+import { registerChangelogCommand } from "./commands/changelog.js";
 import { registerChannelVerificationSessionsCommand } from "./commands/channel-verification-sessions.js";
 import { registerClientsCommand } from "./commands/clients.js";
 import { registerCompletionsCommand } from "./commands/completions.js";
@@ -32,7 +32,6 @@ import { registerImageGenerationCommand } from "./commands/image-generation.js";
 import { registerInferenceCommand } from "./commands/inference.js";
 import { registerKeysCommand } from "./commands/keys.js";
 import { registerMcpCommand } from "./commands/mcp.js";
-import { registerMemoryCommand } from "./commands/memory.js";
 import { registerMemoryV2Command } from "./commands/memory-v2.js";
 import { registerNotificationsCommand } from "./commands/notifications.js";
 import { registerOAuthCommand } from "./commands/oauth/index.js";
@@ -80,12 +79,12 @@ Examples:
   registerAttachmentCommand(program);
   registerAuditCommand(program);
   registerAuthCommand(program);
-  registerAutonomyCommand(program);
   registerAvatarCommand(program);
   registerBackupCommand(program);
   registerBashCommand(program);
   registerBrowserCommand(program);
   registerCacheCommand(program);
+  registerChangelogCommand(program);
   registerChannelVerificationSessionsCommand(program);
   registerClientsCommand(program);
   registerCompletionsCommand(program);
@@ -103,7 +102,6 @@ Examples:
   registerInferenceCommand(program);
   registerKeysCommand(program);
   registerMcpCommand(program);
-  registerMemoryCommand(program);
   registerMemoryV2Command(program);
   registerNotificationsCommand(program);
   registerOAuthCommand(program);