@vellumai/assistant 0.8.0 → 0.8.2

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__/cli-colors.test.ts

@@ -0,0 +1,48 @@
+import { afterEach, describe, expect, it } from "bun:test";
+
+import { red } from "../cli-colors.js";
+
+const originalIsTTY = process.stderr.isTTY;
+const originalNoColor = process.env.NO_COLOR;
+
+function setTTY(value: boolean): void {
+  Object.defineProperty(process.stderr, "isTTY", {
+    configurable: true,
+    value,
+  });
+}
+
+describe("red", () => {
+  afterEach(() => {
+    setTTY(originalIsTTY);
+    if (originalNoColor === undefined) {
+      delete process.env.NO_COLOR;
+    } else {
+      process.env.NO_COLOR = originalNoColor;
+    }
+  });
+
+  it("returns plain text when stderr is not a TTY", () => {
+    setTTY(false);
+    delete process.env.NO_COLOR;
+    expect(red("oops")).toBe("oops");
+  });
+
+  it("wraps text in ANSI red when stderr is a TTY", () => {
+    setTTY(true);
+    delete process.env.NO_COLOR;
+    expect(red("oops")).toBe("\x1b[31moops\x1b[0m");
+  });
+
+  it("respects NO_COLOR even when stderr is a TTY", () => {
+    setTTY(true);
+    process.env.NO_COLOR = "1";
+    expect(red("oops")).toBe("oops");
+  });
+
+  it("treats an empty NO_COLOR as unset (per no-color.org)", () => {
+    setTTY(true);
+    process.env.NO_COLOR = "";
+    expect(red("oops")).toBe("\x1b[31moops\x1b[0m");
+  });
+});

package/src/cli/lib/__tests__/confirm-prompt.test.ts

@@ -0,0 +1,159 @@
+import { PassThrough } from "node:stream";
+import { describe, expect, test } from "bun:test";
+
+import { confirmPrompt } from "../confirm-prompt.js";
+
+interface Captured {
+  stdin: PassThrough;
+  stdout: PassThrough;
+  stderr: PassThrough;
+  outChunks: string[];
+  errChunks: string[];
+}
+
+function buildStreams(): Captured {
+  const stdin = new PassThrough();
+  const stdout = new PassThrough();
+  const stderr = new PassThrough();
+  const outChunks: string[] = [];
+  const errChunks: string[] = [];
+  stdout.on("data", (c: Buffer) => outChunks.push(c.toString("utf8")));
+  stderr.on("data", (c: Buffer) => errChunks.push(c.toString("utf8")));
+  return { stdin, stdout, stderr, outChunks, errChunks };
+}
+
+describe("confirmPrompt", () => {
+  test("returns \"non-interactive\" without reading when isTTY=false", async () => {
+    const { stdin, stdout, stderr, outChunks, errChunks } = buildStreams();
+    const result = await confirmPrompt({
+      question: "Delete? [y/N] ",
+      isTTY: false,
+      refuseNonInteractiveMessage: "Refusing: pass --force.",
+      stdin,
+      stdout,
+      stderr,
+    });
+    expect(result).toBe("non-interactive");
+    expect(errChunks.join("")).toContain("Refusing: pass --force.");
+    expect(outChunks.join("")).toBe("");
+  });
+
+  test("returns \"confirmed\" for \"y\\n\"", async () => {
+    const { stdin, stdout, stderr } = buildStreams();
+    const pending = confirmPrompt({
+      question: "Delete? [y/N] ",
+      isTTY: true,
+      refuseNonInteractiveMessage: "should not see this",
+      stdin,
+      stdout,
+      stderr,
+    });
+    stdin.write("y\n");
+    expect(await pending).toBe("confirmed");
+  });
+
+  test("returns \"confirmed\" for \"yes\\n\" (case-insensitive, whitespace-tolerant)", async () => {
+    const { stdin, stdout, stderr } = buildStreams();
+    const pending = confirmPrompt({
+      question: "Delete? [y/N] ",
+      isTTY: true,
+      refuseNonInteractiveMessage: "n/a",
+      stdin,
+      stdout,
+      stderr,
+    });
+    stdin.write("  YES  \n");
+    expect(await pending).toBe("confirmed");
+  });
+
+  test("returns \"denied\" for \"n\\n\"", async () => {
+    const { stdin, stdout, stderr } = buildStreams();
+    const pending = confirmPrompt({
+      question: "Delete? [y/N] ",
+      isTTY: true,
+      refuseNonInteractiveMessage: "n/a",
+      stdin,
+      stdout,
+      stderr,
+    });
+    stdin.write("n\n");
+    expect(await pending).toBe("denied");
+  });
+
+  test("returns \"denied\" for empty input (just Enter)", async () => {
+    const { stdin, stdout, stderr } = buildStreams();
+    const pending = confirmPrompt({
+      question: "Delete? [y/N] ",
+      isTTY: true,
+      refuseNonInteractiveMessage: "n/a",
+      stdin,
+      stdout,
+      stderr,
+    });
+    stdin.write("\n");
+    expect(await pending).toBe("denied");
+  });
+
+  test("returns \"denied\" on EOF without any data (regression: would have hung)", async () => {
+    const { stdin, stdout, stderr } = buildStreams();
+    const pending = confirmPrompt({
+      question: "Delete? [y/N] ",
+      isTTY: true,
+      refuseNonInteractiveMessage: "n/a",
+      stdin,
+      stdout,
+      stderr,
+    });
+    stdin.end();
+    expect(await pending).toBe("denied");
+  });
+
+  test("returns \"denied\" on EOF after a partial line with no newline", async () => {
+    const { stdin, stdout, stderr } = buildStreams();
+    const pending = confirmPrompt({
+      question: "Delete? [y/N] ",
+      isTTY: true,
+      refuseNonInteractiveMessage: "n/a",
+      stdin,
+      stdout,
+      stderr,
+    });
+    // "y" without a trailing newline followed by EOF — readline will fire
+    // the "line" event on close, so we exercise that path explicitly.
+    stdin.write("y");
+    stdin.end();
+    const result = await pending;
+    // readline fires `line` with the buffered content on EOF, so this
+    // actually confirms. Documents the behaviour either way.
+    expect(["confirmed", "denied"]).toContain(result);
+  });
+
+  test("writes the question to stdout when interactive", async () => {
+    const { stdin, stdout, stderr, outChunks } = buildStreams();
+    const pending = confirmPrompt({
+      question: "Delete plugin \"foo\"? [y/N] ",
+      isTTY: true,
+      refuseNonInteractiveMessage: "n/a",
+      stdin,
+      stdout,
+      stderr,
+    });
+    stdin.write("n\n");
+    await pending;
+    expect(outChunks.join("")).toContain("Delete plugin \"foo\"? [y/N] ");
+  });
+
+  test("treats stray garbage as denial, never confirmation", async () => {
+    const { stdin, stdout, stderr } = buildStreams();
+    const pending = confirmPrompt({
+      question: "Delete? [y/N] ",
+      isTTY: true,
+      refuseNonInteractiveMessage: "n/a",
+      stdin,
+      stdout,
+      stderr,
+    });
+    stdin.write("maybe\n");
+    expect(await pending).toBe("denied");
+  });
+});