@vellumai/assistant 0.5.12 → 0.5.14

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

@@ -0,0 +1,282 @@
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+const testDir = mkdtempSync(join(tmpdir(), "platform-status-test-"));
+
+// ---------------------------------------------------------------------------
+// Mock state
+// ---------------------------------------------------------------------------
+
+let mockGetSecureKeyViaDaemon: (
+  account: string,
+) => Promise<string | undefined> = async () => undefined;
+
+let mockResolvePlatformCallbackRegistrationContext: () => Promise<
+  Record<string, unknown>
+> = async () => ({
+  containerized: false,
+  platformBaseUrl: "",
+  assistantId: "",
+  hasInternalApiKey: false,
+  hasAssistantApiKey: false,
+  authHeader: null,
+  enabled: false,
+});
+
+// ---------------------------------------------------------------------------
+// Mocks
+// ---------------------------------------------------------------------------
+
+mock.module("../../../../inbound/platform-callback-registration.js", () => ({
+  resolvePlatformCallbackRegistrationContext: () =>
+    mockResolvePlatformCallbackRegistrationContext(),
+  registerCallbackRoute: async () => "",
+  shouldUsePlatformCallbacks: () => false,
+  resolveCallbackUrl: async () => "",
+}));
+
+mock.module("../../../lib/daemon-credential-client.js", () => ({
+  getSecureKeyViaDaemon: (account: string) =>
+    mockGetSecureKeyViaDaemon(account),
+  deleteSecureKeyViaDaemon: async () => "not-found" as const,
+  setSecureKeyViaDaemon: async () => false,
+  getProviderKeyViaDaemon: async () => undefined,
+  getSecureKeyResultViaDaemon: async () => ({
+    value: undefined,
+    unreachable: false,
+  }),
+}));
+
+mock.module("../../../../util/logger.js", () => ({
+  getLogger: () => ({
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    debug: () => {},
+  }),
+  getCliLogger: () => ({
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    debug: () => {},
+  }),
+  initLogger: () => {},
+  truncateForLog: (value: string, maxLen = 500) =>
+    value.length > maxLen ? value.slice(0, maxLen) + "..." : value,
+  pruneOldLogFiles: () => 0,
+}));
+
+mock.module("../../../../util/platform.js", () => ({
+  getRootDir: () => testDir,
+  getDataDir: () => join(testDir, "data"),
+  getWorkspaceSkillsDir: () => join(testDir, "skills"),
+  getWorkspaceDir: () => join(testDir, "workspace"),
+  getWorkspaceHooksDir: () => join(testDir, "workspace", "hooks"),
+  getWorkspaceConfigPath: () => join(testDir, "workspace", "config.json"),
+  getHooksDir: () => join(testDir, "hooks"),
+  getSignalsDir: () => join(testDir, "signals"),
+  getConversationsDir: () => join(testDir, "conversations"),
+  getEmbeddingModelsDir: () => join(testDir, "models"),
+  getSandboxRootDir: () => join(testDir, "sandbox"),
+  getSandboxWorkingDir: () => join(testDir, "sandbox", "work"),
+  getInterfacesDir: () => join(testDir, "interfaces"),
+  getSoundsDir: () => join(testDir, "sounds"),
+  getHistoryPath: () => join(testDir, "history"),
+  isMacOS: () => process.platform === "darwin",
+  isLinux: () => process.platform === "linux",
+  isWindows: () => process.platform === "win32",
+  getPlatformName: () => "linux",
+  getClipboardCommand: () => null,
+  resolveInstanceDataDir: () => undefined,
+  normalizeAssistantId: (id: string) => id,
+  getTCPPort: () => 0,
+  isTCPEnabled: () => false,
+  getTCPHost: () => "127.0.0.1",
+  isIOSPairingEnabled: () => false,
+  getPlatformTokenPath: () => join(testDir, "token"),
+  readPlatformToken: () => null,
+  getPidPath: () => join(testDir, "test.pid"),
+  getDbPath: () => join(testDir, "test.db"),
+  getLogPath: () => join(testDir, "test.log"),
+  getWorkspaceDirDisplay: () => testDir,
+  getWorkspacePromptPath: (file: string) => join(testDir, file),
+  getProtectedDir: () => join(testDir, "protected"),
+  getDeprecatedDir: () => join(testDir, "workspace", "deprecated"),
+  getExternalDir: () => join(testDir, "external"),
+  getBinDir: () => join(testDir, "bin"),
+  getDotEnvPath: () => join(testDir, ".env"),
+  getDaemonStderrLogPath: () => join(testDir, "daemon-stderr.log"),
+  getDaemonStartupLockPath: () => join(testDir, "daemon-startup.lock"),
+  getEmbedWorkerPidPath: () => join(testDir, "embed-worker.pid"),
+  ensureDataDir: () => {},
+}));
+
+mock.module("../../../../config/loader.js", () => ({
+  API_KEY_PROVIDERS: [] as const,
+  getConfig: () => ({
+    permissions: { mode: "workspace" },
+    skills: { load: { extraDirs: [] } },
+    sandbox: { enabled: true },
+  }),
+  loadConfig: () => ({}),
+  invalidateConfigCache: () => {},
+  saveConfig: () => {},
+  loadRawConfig: () => ({}),
+  saveRawConfig: () => {},
+  getNestedValue: () => undefined,
+  setNestedValue: () => {},
+  applyNestedDefaults: (config: unknown) => config,
+  deepMergeMissing: () => false,
+  deepMergeOverwrite: () => {},
+  mergeDefaultWorkspaceConfig: () => {},
+}));
+
+// ---------------------------------------------------------------------------
+// Import module under test (after mocks are registered)
+// ---------------------------------------------------------------------------
+
+const { buildCliProgram } = await import("../../../program.js");
+
+// ---------------------------------------------------------------------------
+// Test helper
+// ---------------------------------------------------------------------------
+
+async function runCommand(
+  args: string[],
+): Promise<{ stdout: string; exitCode: number }> {
+  const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+  const originalStderrWrite = process.stderr.write.bind(process.stderr);
+  const stdoutChunks: string[] = [];
+
+  process.stdout.write = ((chunk: unknown) => {
+    stdoutChunks.push(typeof chunk === "string" ? chunk : String(chunk));
+    return true;
+  }) as typeof process.stdout.write;
+
+  process.stderr.write = (() => true) as typeof process.stderr.write;
+
+  process.exitCode = 0;
+
+  try {
+    const program = buildCliProgram();
+    program.exitOverride();
+    program.configureOutput({
+      writeErr: () => {},
+      writeOut: (str: string) => stdoutChunks.push(str),
+    });
+    await program.parseAsync(["node", "assistant", ...args]);
+  } catch {
+    if (process.exitCode === 0) process.exitCode = 1;
+  } finally {
+    process.stdout.write = originalStdoutWrite;
+    process.stderr.write = originalStderrWrite;
+  }
+
+  const exitCode = process.exitCode ?? 0;
+  process.exitCode = 0;
+
+  return { exitCode, stdout: stdoutChunks.join("") };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("assistant platform status", () => {
+  beforeEach(() => {
+    mockGetSecureKeyViaDaemon = async () => undefined;
+    mockResolvePlatformCallbackRegistrationContext = async () => ({
+      containerized: false,
+      platformBaseUrl: "",
+      assistantId: "",
+      hasInternalApiKey: false,
+      hasAssistantApiKey: false,
+      authHeader: null,
+      enabled: false,
+    });
+    process.exitCode = 0;
+  });
+
+  test("connected platform returns full status with stored credentials", async () => {
+    /**
+     * When the assistant has stored platform credentials and a valid
+     * registration context, the status command should report connected
+     * with all context fields populated.
+     */
+
+    // GIVEN a containerized environment with platform configuration
+    mockResolvePlatformCallbackRegistrationContext = async () => ({
+      containerized: true,
+      platformBaseUrl: "https://platform.vellum.ai",
+      assistantId: "asst-abc-123",
+      hasInternalApiKey: true,
+      hasAssistantApiKey: true,
+      authHeader: "Bearer internal-key",
+      enabled: true,
+    });
+
+    // AND stored platform credentials exist
+    mockGetSecureKeyViaDaemon = async (account: string) => {
+      if (account === "credential/vellum/platform_base_url")
+        return "https://platform.vellum.ai";
+      if (account === "credential/vellum/assistant_api_key")
+        return "sk-test-key";
+      if (account === "credential/vellum/platform_organization_id")
+        return "org-456";
+      if (account === "credential/vellum/platform_user_id") return "user-789";
+      return undefined;
+    };
+
+    // WHEN the status command is run with --json
+    const { exitCode, stdout } = await runCommand([
+      "platform",
+      "status",
+      "--json",
+    ]);
+
+    // THEN the command succeeds
+    expect(exitCode).toBe(0);
+
+    // AND the output contains the expected status fields
+    const parsed = JSON.parse(stdout);
+    expect(parsed.containerized).toBe(true);
+    expect(parsed.baseUrl).toBe("https://platform.vellum.ai");
+    expect(parsed.assistantId).toBe("asst-abc-123");
+    expect(parsed.hasInternalApiKey).toBe(true);
+    expect(parsed.hasAssistantApiKey).toBe(true);
+    expect(parsed.available).toBe(true);
+    expect(parsed.connected).toBe(true);
+    expect(parsed.organizationId).toBe("org-456");
+    expect(parsed.userId).toBe("user-789");
+  });
+
+  test("plain text mode does not emit JSON to stdout", async () => {
+    /**
+     * Without --json, the status command should only produce log output
+     * (via the CLI logger) and NOT write JSON to stdout. Previously both
+     * JSON and plain text were emitted, duplicating the information.
+     */
+
+    // GIVEN a disconnected environment with no stored credentials
+    mockResolvePlatformCallbackRegistrationContext = async () => ({
+      containerized: false,
+      platformBaseUrl: "",
+      assistantId: "",
+      hasInternalApiKey: false,
+      hasAssistantApiKey: false,
+      authHeader: null,
+      enabled: false,
+    });
+
+    // WHEN the status command is run without --json
+    const { exitCode, stdout } = await runCommand(["platform", "status"]);
+
+    // THEN the command succeeds
+    expect(exitCode).toBe(0);
+
+    // AND stdout contains no JSON (writeOutput is skipped in plain text mode)
+    expect(stdout.trim()).toBe("");
+  });
+});

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

@@ -1,6 +1,10 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
 import type { Command } from "commander";
 
 import { credentialKey } from "../../../security/credential-key.js";
+import { getSignalsDir } from "../../../util/platform.js";
 import { getSecureKeyViaDaemon } from "../../lib/daemon-credential-client.js";
 import { getCliLogger } from "../../logger.js";
 import { shouldOutputJson, writeOutput } from "../../output.js";
@@ -32,8 +36,8 @@ export function registerPlatformConnectCommand(platform: Command): void {
     .addHelpText(
       "after",
       `
-Initiates a platform connection flow. Credentials are collected via a secure
-UI component rendered by the assistant client.
+Initiates a platform connection flow. Emits a signal for connected clients
+to show a platform login UI where the user can sign in and store credentials.
 
 Use 'assistant platform status' to check the current connection state and
 'assistant platform disconnect' to remove stored credentials.
@@ -83,15 +87,21 @@ Examples:
           return;
         }
 
-        // TODO: Send a UI component to collect credentials from the user
-        writeError(
-          "Platform connect UI component not yet implemented. " +
-            "Credentials will be collected via a secure client-side flow.",
+        // Emit a signal for the daemon to show the platform login UI
+        // on connected clients.
+        const signalsDir = getSignalsDir();
+        mkdirSync(signalsDir, { recursive: true });
+        writeFileSync(
+          join(signalsDir, "emit-event"),
+          JSON.stringify({ type: "show_platform_login" }),
         );
 
+        writeOutput(cmd, { ok: true, showPlatformLogin: true });
+
         if (!jsonMode) {
           log.info(
-            "Platform connect will be available once the client-side credential flow is implemented.",
+            "Showing the platform login screen on connected clients. " +
+              "Please complete the sign-in flow in the app.",
           );
         }
       } catch (err) {

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

@@ -1,6 +1,11 @@
+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 { getSignalsDir } from "../../../util/platform.js";
 import {
   deleteSecureKeyViaDaemon,
   getSecureKeyViaDaemon,
@@ -46,7 +51,17 @@ Examples:
 
       try {
         // ---------------------------------------------------------------
-        // 1. Check if connected
+        // 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 getSecureKeyViaDaemon(
           credentialKey(
@@ -70,7 +85,7 @@ Examples:
         }
 
         // ---------------------------------------------------------------
-        // 2. Delete all platform credentials
+        // 3. Delete all platform credentials
         // ---------------------------------------------------------------
         const keysToDelete = [
           CREDENTIAL_KEYS.baseUrl,
@@ -97,7 +112,17 @@ Examples:
         }
 
         // ---------------------------------------------------------------
-        // 3. Output result
+        // 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,

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

@@ -123,9 +123,9 @@ Examples:
           userId: userId || null,
         };
 
-        writeOutput(cmd, result);
-
-        if (!shouldOutputJson(cmd)) {
+        if (shouldOutputJson(cmd)) {
+          writeOutput(cmd, result);
+        } else {
           log.info(`Containerized: ${result.containerized}`);
           log.info(`Base URL: ${result.baseUrl || "(not set)"}`);
           log.info(`Assistant ID: ${result.assistantId || "(not set)"}`);