@vellumai/assistant 0.8.0 → 0.8.2

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

@@ -1,22 +1,8 @@
-import { mkdirSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-
 import type { Command } from "commander";
 
-import { isPlatformRemote } from "../../../config/env-registry.js";
-import { credentialKey } from "../../../security/credential-key.js";
-import { getSecureKeyAsync } from "../../../security/secure-keys.js";
-import { getSignalsDir } from "../../../util/platform.js";
-import { deleteSecureKeyViaDaemon } from "../../lib/daemon-credential-client.js";
-import { getCliLogger } from "../../logger.js";
+import { cliIpcCall, exitFromIpcResult } from "../../../ipc/cli-client.js";
+import { log } from "../../logger.js";
 import { shouldOutputJson, writeOutput } from "../../output.js";
-import { CREDENTIAL_KEYS } from "./connect.js";
-
-const log = getCliLogger("cli");
-
-// ---------------------------------------------------------------------------
-// Command registration
-// ---------------------------------------------------------------------------
 
 export function registerPlatformDisconnectCommand(platform: Command): void {
   platform
@@ -40,103 +26,19 @@ Examples:
   $ assistant platform disconnect --json`,
     )
     .action(async (_opts: Record<string, unknown>, cmd: Command) => {
-      const jsonMode = shouldOutputJson(cmd);
-
-      const writeError = (error: string): void => {
-        writeOutput(cmd, { ok: false, error });
-        process.exitCode = 1;
-      };
-
-      try {
-        // ---------------------------------------------------------------
-        // 1. Reject if running inside a platform host
-        // ---------------------------------------------------------------
-        if (isPlatformRemote()) {
-          writeError(
-            "Cannot disconnect from the platform on a platform-hosted assistant.",
-          );
-          return;
-        }
-
-        // ---------------------------------------------------------------
-        // 2. Check if connected
-        // ---------------------------------------------------------------
-        const baseUrl = await getSecureKeyAsync(
-          credentialKey(
-            CREDENTIAL_KEYS.baseUrl.service,
-            CREDENTIAL_KEYS.baseUrl.field,
-          ),
+      const r = await cliIpcCall<{
+        disconnected: boolean;
+        previousBaseUrl: string | null;
+      }>("platform_disconnect", {});
+      if (!r.ok) return exitFromIpcResult({ ok: false, error: r.error, statusCode: r.statusCode }, cmd);
+
+      writeOutput(cmd, { ok: true, ...r.result });
+
+      if (!shouldOutputJson(cmd)) {
+        const prev = r.result?.previousBaseUrl;
+        log.info(
+          `Disconnected from platform${prev ? ` at ${prev}` : ""}`,
         );
-        const apiKey = await getSecureKeyAsync(
-          credentialKey(
-            CREDENTIAL_KEYS.apiKey.service,
-            CREDENTIAL_KEYS.apiKey.field,
-          ),
-        );
-
-        if (!baseUrl && !apiKey) {
-          writeError(
-            "Not connected to a platform. Nothing to disconnect.\n\n" +
-              "Run 'assistant platform status' to check connection state.",
-          );
-          return;
-        }
-
-        // ---------------------------------------------------------------
-        // 3. Delete all platform credentials
-        // ---------------------------------------------------------------
-        const keysToDelete = [
-          CREDENTIAL_KEYS.baseUrl,
-          CREDENTIAL_KEYS.apiKey,
-          CREDENTIAL_KEYS.assistantId,
-          CREDENTIAL_KEYS.organizationId,
-          CREDENTIAL_KEYS.userId,
-        ] as const;
-
-        const failedKeys: string[] = [];
-        for (const key of keysToDelete) {
-          const delResult = await deleteSecureKeyViaDaemon(
-            "credential",
-            `${key.service}:${key.field}`,
-          );
-          if (delResult.result === "error") {
-            const detail = delResult.error ? `: ${delResult.error}` : "";
-            failedKeys.push(`${key.service}:${key.field}${detail}`);
-          }
-        }
-
-        if (failedKeys.length > 0) {
-          writeError(`Failed to delete credentials: ${failedKeys.join("; ")}`);
-          return;
-        }
-
-        // ---------------------------------------------------------------
-        // 4. Notify connected clients
-        // ---------------------------------------------------------------
-        const signalsDir = getSignalsDir();
-        mkdirSync(signalsDir, { recursive: true });
-        writeFileSync(
-          join(signalsDir, "emit-event"),
-          JSON.stringify({ type: "platform_disconnected" }),
-        );
-
-        // ---------------------------------------------------------------
-        // 5. Output result
-        // ---------------------------------------------------------------
-        writeOutput(cmd, {
-          ok: true,
-          disconnected: true,
-          previousBaseUrl: baseUrl ?? null,
-        });
-
-        if (!jsonMode) {
-          log.info(
-            `Disconnected from platform${baseUrl ? ` at ${baseUrl}` : ""}`,
-          );
-        }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        writeError(message);
       }
     });
 }

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

@@ -1,26 +1,41 @@
+/**
+ * `assistant platform` — manage Vellum Platform integration.
+ *
+ * Thin IPC wrapper that delegates all platform operations to the daemon.
+ */
+
 import type { Command } from "commander";
 
-import {
-  registerCallbackRoute,
-  resolvePlatformCallbackRegistrationContext,
-} from "../../../inbound/platform-callback-registration.js";
-import { ipcGetVelayStatus } from "../../../ipc/gateway-client.js";
-import { credentialKey } from "../../../security/credential-key.js";
-import { getSecureKeyAsync } from "../../../security/secure-keys.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";
-import { CREDENTIAL_KEYS, registerPlatformConnectCommand } from "./connect.js";
+import { registerPlatformConnectCommand } from "./connect.js";
 import { registerPlatformDisconnectCommand } from "./disconnect.js";
 
+interface PlatformStatusResult {
+  isPlatform: boolean;
+  baseUrl: string;
+  assistantId: string;
+  hasAssistantApiKey: boolean;
+  hasWebhookSecret: boolean;
+  available: boolean;
+  organizationId: string | null;
+  userId: string | null;
+  velayTunnel: { connected: boolean; publicUrl: string | null } | null;
+}
+
 export function registerPlatformCommand(program: Command): void {
-  const platform = program
-    .command("platform")
-    .description("Manage Vellum Platform integration")
-    .option("--json", "Machine-readable compact JSON output");
-
-  platform.addHelpText(
-    "after",
-    `
+  registerCommand(program, {
+    name: "platform",
+    transport: "ipc",
+    description: "Manage Vellum Platform integration",
+    build: (platform) => {
+      platform.option("--json", "Machine-readable compact JSON output");
+
+      platform.addHelpText(
+        "after",
+        `
 The platform subsystem manages the connection to Vellum Platform. Use
 'connect', 'status', and 'disconnect' to manage platform credentials.
 Any assistant using the managed LLM proxy can use these commands.
@@ -35,29 +50,28 @@ Examples:
   $ assistant platform connect
   $ assistant platform disconnect
   $ assistant platform callback-routes register --path webhooks/telegram --type telegram --json`,
-  );
-
-  // ---------------------------------------------------------------------------
-  // connect — store platform credentials and validate the connection
-  // ---------------------------------------------------------------------------
-
-  registerPlatformConnectCommand(platform);
-
-  // ---------------------------------------------------------------------------
-  // status — deployment context and connection status combined
-  // ---------------------------------------------------------------------------
-
-  platform
-    .command("status")
-    .description(
-      "Show current platform deployment context and connection status",
-    )
-    .addHelpText(
-      "after",
-      `
+      );
+
+      // -----------------------------------------------------------------------
+      // connect
+      // -----------------------------------------------------------------------
+
+      registerPlatformConnectCommand(platform);
+
+      // -----------------------------------------------------------------------
+      // status
+      // -----------------------------------------------------------------------
+
+      platform
+        .command("status")
+        .description(
+          "Show current platform deployment context and connection status",
+        )
+        .addHelpText(
+          "after",
+          `
 Reads platform-related environment variables and stored credentials to report
-the current platform deployment context and connection state. Does not
-require the assistant to be running.
+the current platform deployment context and connection state.
 
 Fields:
   isPlatform          Whether IS_PLATFORM is set (boolean)
@@ -75,99 +89,61 @@ Fields:
 Examples:
   $ assistant platform status
   $ assistant platform status --json`,
-    )
-    .action(async (_opts: Record<string, unknown>, cmd: Command) => {
-      try {
-        const [context, velayTunnel] = await Promise.all([
-          resolvePlatformCallbackRegistrationContext(),
-          ipcGetVelayStatus().catch(() => null),
-        ]);
-
-        const organizationId =
-          (
-            await getSecureKeyAsync(
-              credentialKey(
-                CREDENTIAL_KEYS.organizationId.service,
-                CREDENTIAL_KEYS.organizationId.field,
-              ),
-            )
-          )?.trim() ?? "";
-        const userId =
-          (
-            await getSecureKeyAsync(
-              credentialKey(
-                CREDENTIAL_KEYS.userId.service,
-                CREDENTIAL_KEYS.userId.field,
-              ),
-            )
-          )?.trim() ?? "";
-
-        const hasWebhookSecret = !!(await getSecureKeyAsync(
-          credentialKey("vellum", "webhook_secret"),
-        ));
-
-        const result = {
-          isPlatform: context.isPlatform,
-          baseUrl: context.platformBaseUrl,
-          assistantId: context.assistantId,
-          hasAssistantApiKey: context.hasAssistantApiKey,
-          hasWebhookSecret,
-          available: context.enabled,
-          organizationId: organizationId || null,
-          userId: userId || null,
-          velayTunnel,
-        };
-
-        if (shouldOutputJson(cmd)) {
-          writeOutput(cmd, result);
-        } else {
-          log.info(`Platform: ${result.isPlatform}`);
-          log.info(`Base URL: ${result.baseUrl || "(not set)"}`);
-          log.info(`Assistant ID: ${result.assistantId || "(not set)"}`);
-          log.info(
-            `Assistant API key: ${result.hasAssistantApiKey ? "set" : "not set"}`,
+        )
+        .action(async (_opts: Record<string, unknown>, cmd: Command) => {
+          const r = await cliIpcCall<PlatformStatusResult>(
+            "platform_status",
+            {},
           );
-          log.info(
-            `Webhook secret: ${result.hasWebhookSecret ? "set" : "not set (run ensure-registration to provision)"}`,
-          );
-          log.info(
-            `Callback registration available: ${result.available ? "yes" : "no"}`,
-          );
-          log.info(`Organization ID: ${organizationId || "(not set)"}`);
-          log.info(`User ID: ${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}`);
+          if (!r.ok) return exitFromIpcResult({ ok: false, error: r.error, statusCode: r.statusCode }, cmd);
+
+          const result = r.result!;
+
+          if (shouldOutputJson(cmd)) {
+            writeOutput(cmd, result);
           } else {
-            log.info(`Velay tunnel: (gateway not running)`);
+            log.info(`Platform: ${result.isPlatform}`);
+            log.info(`Base URL: ${result.baseUrl || "(not set)"}`);
+            log.info(`Assistant ID: ${result.assistantId || "(not set)"}`);
+            log.info(
+              `Assistant API key: ${result.hasAssistantApiKey ? "set" : "not set"}`,
+            );
+            log.info(
+              `Webhook secret: ${result.hasWebhookSecret ? "set" : "not set (run ensure-registration to provision)"}`,
+            );
+            log.info(
+              `Callback registration available: ${result.available ? "yes" : "no"}`,
+            );
+            log.info(`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)`);
+            }
           }
-        }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        writeOutput(cmd, { ok: false, error: message });
-        process.exitCode = 1;
-      }
-    });
-
-  // ---------------------------------------------------------------------------
-  // disconnect — remove stored platform credentials
-  // ---------------------------------------------------------------------------
-
-  registerPlatformDisconnectCommand(platform);
-
-  // ---------------------------------------------------------------------------
-  // callback-routes
-  // ---------------------------------------------------------------------------
-
-  const callbackRoutes = platform
-    .command("callback-routes")
-    .description("Manage platform callback route registrations");
-
-  callbackRoutes.addHelpText(
-    "after",
-    `
+        });
+
+      // -----------------------------------------------------------------------
+      // disconnect
+      // -----------------------------------------------------------------------
+
+      registerPlatformDisconnectCommand(platform);
+
+      // -----------------------------------------------------------------------
+      // callback-routes
+      // -----------------------------------------------------------------------
+
+      const callbackRoutes = platform
+        .command("callback-routes")
+        .description("Manage platform callback route registrations");
+
+      callbackRoutes.addHelpText(
+        "after",
+        `
 Callback routes tell the platform gateway how to forward inbound provider
 webhooks to the correct assistant instance. Each route maps a callback path
 and type to a stable external URL that external services (Telegram, Twilio,
@@ -178,26 +154,26 @@ Examples:
   $ assistant platform callback-routes list --json
   $ assistant platform callback-routes register --path webhooks/telegram --type telegram --json
   $ assistant platform callback-routes register --path webhooks/twilio/voice --type twilio_voice --json`,
-  );
-
-  // ---------------------------------------------------------------------------
-  // callback-routes register
-  // ---------------------------------------------------------------------------
-
-  callbackRoutes
-    .command("register")
-    .description("Register a callback route with the platform gateway")
-    .requiredOption(
-      "--path <path>",
-      "Callback path (e.g. webhooks/telegram, webhooks/twilio/voice)",
-    )
-    .requiredOption(
-      "--type <type>",
-      "Route type identifier (e.g. telegram, twilio_voice, twilio_status, oauth)",
-    )
-    .addHelpText(
-      "after",
-      `
+      );
+
+      // -----------------------------------------------------------------------
+      // callback-routes register
+      // -----------------------------------------------------------------------
+
+      callbackRoutes
+        .command("register")
+        .description("Register a callback route with the platform gateway")
+        .requiredOption(
+          "--path <path>",
+          "Callback path (e.g. webhooks/telegram, webhooks/twilio/voice)",
+        )
+        .requiredOption(
+          "--type <type>",
+          "Route type identifier (e.g. telegram, twilio_voice, twilio_status, oauth)",
+        )
+        .addHelpText(
+          "after",
+          `
 Registers a callback route with the platform's internal gateway endpoint so
 the platform knows how to forward inbound provider webhooks to this
 platform-managed assistant instance.
@@ -224,49 +200,34 @@ stable callback URL that external services should use.
 Examples:
   $ assistant platform callback-routes register --path webhooks/telegram --type telegram --json
   $ assistant platform callback-routes register --path webhooks/twilio/voice --type twilio_voice --json`,
-    )
-    .action(async (opts: { path: string; type: string }, cmd: Command) => {
-      try {
-        const context = await resolvePlatformCallbackRegistrationContext();
-        if (!context.enabled) {
-          writeOutput(cmd, {
-            ok: false,
-            error:
-              "Platform callbacks not available — missing platform base URL, assistant ID, or API key. Run 'assistant platform connect' or ensure credentials are configured.",
+        )
+        .action(async (opts: { path: string; type: string }, cmd: Command) => {
+          const r = await cliIpcCall<{
+            callbackUrl: string;
+            callbackPath: string;
+            type: string;
+          }>("platform_callback_routes_register", {
+            body: { path: opts.path, type: opts.type },
           });
-          process.exitCode = 1;
-          return;
-        }
+          if (!r.ok) return exitFromIpcResult({ ok: false, error: r.error, statusCode: r.statusCode }, cmd);
 
-        const callbackUrl = await registerCallbackRoute(opts.path, opts.type);
+          writeOutput(cmd, { ok: true, ...r.result });
 
-        writeOutput(cmd, {
-          ok: true,
-          callbackUrl,
-          callbackPath: opts.path,
-          type: opts.type,
+          if (!shouldOutputJson(cmd)) {
+            log.info(`Callback route registered: ${r.result!.callbackUrl}`);
+          }
         });
 
-        if (!shouldOutputJson(cmd)) {
-          log.info(`Callback route registered: ${callbackUrl}`);
-        }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        writeOutput(cmd, { ok: false, error: message });
-        process.exitCode = 1;
-      }
-    });
-
-  // ---------------------------------------------------------------------------
-  // callback-routes list
-  // ---------------------------------------------------------------------------
-
-  callbackRoutes
-    .command("list")
-    .description("List registered callback routes for this assistant")
-    .addHelpText(
-      "after",
-      `
+      // -----------------------------------------------------------------------
+      // callback-routes list
+      // -----------------------------------------------------------------------
+
+      callbackRoutes
+        .command("list")
+        .description("List registered callback routes for this assistant")
+        .addHelpText(
+          "after",
+          `
 Lists all callback routes registered with the platform for this assistant.
 Shows the route type, callback URL, and path for each registered webhook.
 
@@ -276,67 +237,37 @@ ensure IS_PLATFORM and VELLUM_PLATFORM_URL are set and credentials are stored).
 Examples:
   $ assistant platform callback-routes list
   $ assistant platform callback-routes list --json`,
-    )
-    .action(async (_opts: Record<string, unknown>, cmd: Command) => {
-      try {
-        const context = await resolvePlatformCallbackRegistrationContext();
-        if (!context.platformBaseUrl || !context.authHeader) {
-          writeOutput(cmd, {
-            ok: false,
-            error:
-              "Platform credentials not available — run 'assistant platform connect' or set VELLUM_PLATFORM_URL",
-          });
-          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(() => "");
-          writeOutput(cmd, {
-            ok: false,
-            error: `Failed to list callback routes (HTTP ${response.status}): ${detail}`,
-          });
-          process.exitCode = 1;
-          return;
-        }
-
-        const routes = (await response.json()) as Array<{
-          id: string;
-          assistant_id: string;
-          type: string;
-          callback_path: string;
-          callback_url: string;
-        }>;
-
-        if (shouldOutputJson(cmd)) {
-          writeOutput(cmd, { ok: true, routes });
-        } else {
-          if (routes.length === 0) {
-            log.info("No callback routes registered.");
+        )
+        .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;
+            }>;
+          }>("platform_callback_routes_list", {});
+          if (!r.ok) return exitFromIpcResult({ ok: false, error: r.error, statusCode: r.statusCode }, cmd);
+
+          const routes = r.result!.routes;
+
+          if (shouldOutputJson(cmd)) {
+            writeOutput(cmd, { ok: true, routes });
           } else {
-            log.info(`${routes.length} callback route(s) registered:\n`);
-            for (const route of routes) {
-              log.info(`  Type: ${route.type}`);
-              log.info(`  URL:  ${route.callback_url}`);
-              log.info(`  Path: ${route.callback_path}`);
-              log.info("");
+            if (routes.length === 0) {
+              log.info("No callback routes registered.");
+            } else {
+              log.info(`${routes.length} callback route(s) registered:\n`);
+              for (const route of routes) {
+                log.info(`  Type: ${route.type}`);
+                log.info(`  URL:  ${route.callback_url}`);
+                log.info(`  Path: ${route.callback_path}`);
+                log.info("");
+              }
             }
           }
-        }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        writeOutput(cmd, { ok: false, error: message });
-        process.exitCode = 1;
-      }
-    });
+        });
+    },
+  });
 }