@vellumai/assistant 0.7.3 → 0.8.1

package/src/__tests__/conversation-surfaces-app-control.test.ts

@@ -11,6 +11,16 @@ import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 const sentMessages: unknown[] = [];
 let mockHasClient = true;
+// Default principal id used for both ctx.trustContext and clients in the
+// existing single-user tests. Tests that exercise cross-user behaviour
+// override this on individual clients and on the SurfaceConversationContext.
+const DEFAULT_PRINCIPAL = "user-1";
+type MockClient = {
+  clientId: string;
+  capabilities: string[];
+  actorPrincipalId?: string;
+};
+let mockHubClients: MockClient[] = [];
 
 mock.module("../runtime/assistant-event-hub.js", () => ({
   broadcastMessage: (msg: unknown) => sentMessages.push(msg),
@@ -19,6 +29,12 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
       cap === "host_app_control" && mockHasClient
         ? { id: "mock-client" }
         : null,
+    listClientsByCapability: (cap: string) =>
+      mockHubClients.filter((c) => c.capabilities.includes(cap)),
+    getClientById: (id: string) =>
+      mockHubClients.find((c) => c.clientId === id),
+    getActorPrincipalIdForClient: (id: string) =>
+      mockHubClients.find((c) => c.clientId === id)?.actorPrincipalId,
   },
 }));
 
@@ -56,9 +72,18 @@ function buildMockContext(
   setHostAppControlProxy?: (
     proxy: InstanceType<typeof HostAppControlProxy> | undefined,
   ) => void,
+  trustGuardianPrincipalId: string | null = DEFAULT_PRINCIPAL,
 ): SurfaceConversationContext {
   return {
     conversationId,
+    trustContext:
+      trustGuardianPrincipalId != null
+        ? {
+            sourceChannel: "vellum",
+            trustClass: "guardian",
+            guardianPrincipalId: trustGuardianPrincipalId,
+          }
+        : undefined,
     traceEmitter: { emit: () => {} },
     sendToClient: () => {},
     pendingSurfaceActions: new Map(),
@@ -86,11 +111,13 @@ describe("surfaceProxyResolver — app-control tool routing", () => {
   beforeEach(() => {
     sentMessages.length = 0;
     mockHasClient = true;
+    mockHubClients = [];
     _resetActiveAppControlSession();
   });
 
   afterEach(() => {
     _resetActiveAppControlSession();
+    mockHubClients = [];
   });
 
   // -------------------------------------------------------------------------
@@ -130,15 +157,18 @@ describe("surfaceProxyResolver — app-control tool routing", () => {
       proxy.dispose();
     });
 
-    test("returns isError for app_control_stop when no proxy is attached", async () => {
+    test("app_control_stop succeeds idempotently when no proxy is attached", async () => {
+      // Stop is local-only and runs BEFORE the isAvailable() gate so a
+      // disconnected client cannot strand the singleton lock. With no proxy
+      // attached at all, it must still succeed as a no-op without dispatching.
       const ctx = buildMockContext();
 
       const result = await surfaceProxyResolver(ctx, "app_control_stop", {
         tool: "stop",
       });
 
-      expect(result.isError).toBe(true);
-      expect(result.content).toContain("not available");
+      expect(result.isError).toBe(false);
+      expect(result.content.toLowerCase()).toContain("stopped");
       expect(sentMessages).toHaveLength(0);
     });
   });
@@ -325,4 +355,294 @@ describe("surfaceProxyResolver — app-control tool routing", () => {
       ownerProxy.dispose();
     });
   });
+
+  // -------------------------------------------------------------------------
+  // target_client_id validation — mirrors host_cu's targetClientId tests in
+  // cu-unified-flow.test.ts. The resolver validates the explicit target
+  // before recordAction-equivalents so an invalid or cross-user id never
+  // reaches the proxy.
+  // -------------------------------------------------------------------------
+
+  describe("target_client_id validation", () => {
+    test("returns fast error when target_client_id does not match any connected client", async () => {
+      mockHubClients = [
+        {
+          clientId: "client-a",
+          capabilities: ["host_app_control"],
+          actorPrincipalId: DEFAULT_PRINCIPAL,
+        },
+      ];
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctx = buildMockContext(proxy, "conv-1");
+      _setActiveAppControlSession({
+        conversationId: "conv-1",
+        app: "com.example.editor",
+      });
+
+      const result = await surfaceProxyResolver(ctx, "app_control_observe", {
+        app: "com.example.editor",
+        target_client_id: "missing-client",
+      });
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("missing-client");
+      expect(result.content).toContain("host_app_control");
+      // No envelope dispatched — fail-fast before request().
+      expect(sentMessages).toHaveLength(0);
+
+      proxy.dispose();
+    });
+
+    test("returns fast error when target_client_id points to a client without host_app_control capability", async () => {
+      mockHubClients = [
+        {
+          clientId: "wrong-cap-client",
+          capabilities: ["host_bash"], // not host_app_control
+          actorPrincipalId: DEFAULT_PRINCIPAL,
+        },
+      ];
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctx = buildMockContext(proxy, "conv-1");
+      _setActiveAppControlSession({
+        conversationId: "conv-1",
+        app: "com.example.editor",
+      });
+
+      const result = await surfaceProxyResolver(ctx, "app_control_observe", {
+        app: "com.example.editor",
+        target_client_id: "wrong-cap-client",
+      });
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("wrong-cap-client");
+      expect(result.content).toContain("does not support host_app_control");
+      expect(sentMessages).toHaveLength(0);
+
+      proxy.dispose();
+    });
+
+    test("dispatches with targetClientId when target_client_id is valid", async () => {
+      mockHubClients = [
+        {
+          clientId: "client-a",
+          capabilities: ["host_app_control"],
+          actorPrincipalId: DEFAULT_PRINCIPAL,
+        },
+        {
+          clientId: "client-b",
+          capabilities: ["host_app_control"],
+          actorPrincipalId: DEFAULT_PRINCIPAL,
+        },
+      ];
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctx = buildMockContext(proxy, "conv-1");
+      _setActiveAppControlSession({
+        conversationId: "conv-1",
+        app: "com.example.editor",
+      });
+
+      const resultPromise = surfaceProxyResolver(ctx, "app_control_observe", {
+        app: "com.example.editor",
+        target_client_id: "client-b",
+      });
+
+      // Exactly one envelope dispatched, addressed to client-b.
+      expect(sentMessages).toHaveLength(1);
+      const sent = sentMessages[0] as Record<string, unknown>;
+      expect(sent.type).toBe("host_app_control_request");
+      expect(sent.targetClientId).toBe("client-b");
+
+      proxy.resolve(sent.requestId as string, {
+        requestId: "ignored-by-proxy",
+        state: "running",
+      });
+      const result = await resultPromise;
+      expect(result.isError).toBe(false);
+
+      proxy.dispose();
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Multi-client ambiguity guard — when the LLM omits target_client_id and
+  // multiple same-user host_app_control clients are connected, the resolver
+  // must error rather than broadcast (one app-control session per client).
+  // -------------------------------------------------------------------------
+
+  describe("multi-client ambiguity guard", () => {
+    test("errors when multiple same-user clients connected and no target_client_id given", async () => {
+      mockHubClients = [
+        {
+          clientId: "client-a",
+          capabilities: ["host_app_control"],
+          actorPrincipalId: DEFAULT_PRINCIPAL,
+        },
+        {
+          clientId: "client-b",
+          capabilities: ["host_app_control"],
+          actorPrincipalId: DEFAULT_PRINCIPAL,
+        },
+      ];
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctx = buildMockContext(proxy, "conv-1");
+      _setActiveAppControlSession({
+        conversationId: "conv-1",
+        app: "com.example.editor",
+      });
+
+      const result = await surfaceProxyResolver(ctx, "app_control_observe", {
+        app: "com.example.editor",
+      });
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain(
+        "multiple clients support host_app_control",
+      );
+      expect(result.content).toContain("target_client_id");
+      // No envelope dispatched.
+      expect(sentMessages).toHaveLength(0);
+
+      proxy.dispose();
+    });
+
+    test("auto-resolves to the unique same-user client when cross-user clients are also present", async () => {
+      mockHubClients = [
+        {
+          clientId: "client-mine",
+          capabilities: ["host_app_control"],
+          actorPrincipalId: DEFAULT_PRINCIPAL,
+        },
+        {
+          clientId: "client-other",
+          capabilities: ["host_app_control"],
+          actorPrincipalId: "user-2",
+        },
+      ];
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctx = buildMockContext(proxy, "conv-1");
+      _setActiveAppControlSession({
+        conversationId: "conv-1",
+        app: "com.example.editor",
+      });
+
+      const resultPromise = surfaceProxyResolver(ctx, "app_control_observe", {
+        app: "com.example.editor",
+      });
+
+      // Resolver must explicitly target the same-user client to prevent the
+      // proxy from broadcasting the action across the cross-user client too.
+      expect(sentMessages).toHaveLength(1);
+      const sent = sentMessages[0] as Record<string, unknown>;
+      expect(sent.targetClientId).toBe("client-mine");
+
+      proxy.resolve(sent.requestId as string, {
+        requestId: "ignored-by-proxy",
+        state: "running",
+      });
+      const result = await resultPromise;
+      expect(result.isError).toBe(false);
+
+      proxy.dispose();
+    });
+
+    test("single same-user client with no target proceeds without forcing targetClientId", async () => {
+      mockHubClients = [
+        {
+          clientId: "only-client",
+          capabilities: ["host_app_control"],
+          actorPrincipalId: DEFAULT_PRINCIPAL,
+        },
+      ];
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctx = buildMockContext(proxy, "conv-1");
+      _setActiveAppControlSession({
+        conversationId: "conv-1",
+        app: "com.example.editor",
+      });
+
+      const resultPromise = surfaceProxyResolver(ctx, "app_control_observe", {
+        app: "com.example.editor",
+      });
+
+      expect(sentMessages).toHaveLength(1);
+      const sent = sentMessages[0] as Record<string, unknown>;
+      // No cross-user ambiguity → resolver leaves targetClientId undefined,
+      // letting the proxy use its existing single-client routing.
+      expect(sent.targetClientId).toBeUndefined();
+
+      proxy.resolve(sent.requestId as string, {
+        requestId: "ignored-by-proxy",
+        state: "running",
+      });
+      const result = await resultPromise;
+      expect(result.isError).toBe(false);
+
+      proxy.dispose();
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Same-user enforcement — even when target_client_id is provided, a
+  // cross-user client can never be addressed.
+  // -------------------------------------------------------------------------
+
+  describe("same-user enforcement", () => {
+    test("rejects targeted dispatch from a different actor principal", async () => {
+      mockHubClients = [
+        {
+          clientId: "other-user-client",
+          capabilities: ["host_app_control"],
+          actorPrincipalId: "user-2",
+        },
+      ];
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctx = buildMockContext(proxy, "conv-1");
+      _setActiveAppControlSession({
+        conversationId: "conv-1",
+        app: "com.example.editor",
+      });
+
+      const result = await surfaceProxyResolver(ctx, "app_control_observe", {
+        app: "com.example.editor",
+        target_client_id: "other-user-client",
+      });
+
+      expect(result.isError).toBe(true);
+      // No envelope dispatched.
+      expect(sentMessages).toHaveLength(0);
+
+      proxy.dispose();
+    });
+
+    test("rejects when the conversation has no source actor principal", async () => {
+      mockHubClients = [
+        {
+          clientId: "client-a",
+          capabilities: ["host_app_control"],
+          actorPrincipalId: DEFAULT_PRINCIPAL,
+        },
+      ];
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctx = buildMockContext(
+        proxy,
+        "conv-1",
+        undefined,
+        /* trustGuardianPrincipalId */ null,
+      );
+      _setActiveAppControlSession({
+        conversationId: "conv-1",
+        app: "com.example.editor",
+      });
+
+      const result = await surfaceProxyResolver(ctx, "app_control_observe", {
+        app: "com.example.editor",
+        target_client_id: "client-a",
+      });
+
+      expect(result.isError).toBe(true);
+      expect(sentMessages).toHaveLength(0);
+
+      proxy.dispose();
+    });
+  });
 });

package/src/__tests__/conversation-surfaces-data-persist.test.ts

@@ -1,5 +1,14 @@
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
+import type { ServerMessage } from "../daemon/message-protocol.js";
+
+const realEventHub = await import("../runtime/assistant-event-hub.js");
+
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  ...realEventHub,
+  broadcastMessage: (_msg: ServerMessage) => {},
+}));
+
 // Mock the persistence layer the surface helpers reach into so we can
 // observe writes without touching SQLite. We swap this out per test by
 // re-assigning the spies recorded on the closure below.
@@ -29,15 +38,16 @@ const {
   flushPendingSurfaceDataPersists,
   createSurfaceMutex,
   flushSurfaceDataPersist,
+  handleSurfaceAction,
   markSurfaceCompleted,
   scheduleSurfaceDataPersist,
+  showStandaloneSurface,
   surfaceProxyResolver,
 } = await import("../daemon/conversation-surfaces.js");
 
 import type { SurfaceConversationContext } from "../daemon/conversation-surfaces.js";
 import type {
   CardSurfaceData,
-  ServerMessage,
   SurfaceData,
   SurfaceType,
 } from "../daemon/message-protocol.js";
@@ -60,6 +70,8 @@ function makeContext(sent: ServerMessage[] = []): SurfaceConversationContext {
     accumulatedSurfaceState: new Map<string, Record<string, unknown>>(),
     surfaceActionRequestIds: new Set<string>(),
     currentTurnSurfaces: [],
+    pendingStandaloneSurfaces: new Map(),
+    recentlyCompletedStandaloneSurfaces: new Map(),
     isProcessing: () => false,
     enqueueMessage: () => ({ queued: false, requestId: "req-1" }),
     getQueueDepth: () => 0,
@@ -402,3 +414,63 @@ describe("ui_surface_update persistence", () => {
     cancelPendingSurfaceDataPersists("conv-other");
   });
 });
+
+describe("standalone surface DB persistence", () => {
+  let writes: Array<{ id: string; content: unknown }> = [];
+
+  beforeEach(() => {
+    writes = [];
+    updateMessageContentSpy = (id: string, content: string) => {
+      writes.push({ id, content: JSON.parse(content) });
+    };
+    getMessagesImpl = () => [];
+    cancelPendingSurfaceDataPersists();
+  });
+
+  afterEach(() => {
+    cancelPendingSurfaceDataPersists();
+  });
+
+  test("standalone surface action persists completed state to DB", async () => {
+    const ctx = makeContext();
+    const surfaceId = "standalone-persist-1";
+
+    seedRows([
+      {
+        id: "msg-standalone",
+        content: [
+          { type: "text", text: "confirm this" },
+          {
+            type: "ui_surface",
+            surfaceId,
+            surfaceType: "confirmation",
+            data: { message: "Proceed?" },
+          },
+        ],
+      },
+    ]);
+
+    const resultPromise = showStandaloneSurface(
+      ctx,
+      {
+        conversationId: "conv-persist-1",
+        surfaceType: "confirmation",
+        data: { message: "Proceed?" },
+        timeoutMs: 60_000,
+      },
+      surfaceId,
+    );
+
+    await handleSurfaceAction(ctx, surfaceId, "confirm", {});
+    const result = await resultPromise;
+    expect(result.status).toBe("submitted");
+
+    expect(writes.length).toBeGreaterThanOrEqual(1);
+    const finalBlocks = writes[writes.length - 1].content as Array<
+      Record<string, unknown>
+    >;
+    const surfaceBlock = finalBlocks.find((b) => b.type === "ui_surface")!;
+    expect(surfaceBlock.completed).toBe(true);
+    expect(surfaceBlock.completionSummary).toBe("Confirmed");
+  });
+});

package/src/__tests__/conversation-tool-setup-app-refresh.test.ts

@@ -264,6 +264,65 @@ describe("session-tool-setup app refresh side effects", () => {
       });
     });
 
+    test("canonicalizes create_app skill_execute alias before hooks run", async () => {
+      const ctx = makeCtx({ allowedToolNames: new Set(["app_create"]) });
+      const executor = makeFakeExecutor({
+        content: JSON.stringify({ id: "alias-app-1", name: "Alias App" }),
+        isError: false,
+      });
+
+      const toolFn = createToolExecutor(
+        executor as unknown as ToolExecutor,
+        noopPrompter,
+        noopSecretPrompter,
+        ctx,
+        noopLifecycleHandler,
+      );
+
+      await toolFn("skill_execute", {
+        tool: "create_app",
+        input: { name: "Alias App" },
+        activity: "Building app",
+      });
+
+      const calls = executor.execute.mock.calls as unknown[][];
+      expect(calls[0][0]).toBe("app_create");
+      expect(calls[0][1]).toEqual({ name: "Alias App" });
+      expect(broadcastSpy.mock.calls.length).toBeGreaterThanOrEqual(1);
+      expect((broadcastSpy.mock.calls as unknown[][])[0][0]).toEqual({
+        type: "app_files_changed",
+        appId: "alias-app-1",
+      });
+    });
+
+    test("preserves exact active create_app skill tool when app_create is also active", async () => {
+      const ctx = makeCtx({
+        allowedToolNames: new Set(["create_app", "app_create"]),
+      });
+      const executor = makeFakeExecutor({
+        content: JSON.stringify({ id: "custom-app-1", name: "Custom App" }),
+        isError: false,
+      });
+
+      const toolFn = createToolExecutor(
+        executor as unknown as ToolExecutor,
+        noopPrompter,
+        noopSecretPrompter,
+        ctx,
+        noopLifecycleHandler,
+      );
+
+      await toolFn("skill_execute", {
+        tool: "create_app",
+        input: { name: "Custom App" },
+        activity: "Running custom app tool",
+      });
+
+      const calls = executor.execute.mock.calls as unknown[][];
+      expect(calls[0][0]).toBe("create_app");
+      expect(broadcastSpy).not.toHaveBeenCalled();
+    });
+
     test("skips side effects when app_create result is an error", async () => {
       const ctx = makeCtx();
       const executor = makeFakeExecutor({ content: "Error", isError: true });

package/src/__tests__/conversation-workspace-injection.test.ts

@@ -1,14 +1,8 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { AgentEvent } from "../agent/loop.js";
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
 
-// This test exercises v1 conversation routing. The `memory-v2-enabled` flag
-// (registry default `true`) flips memory routing to v2 — disable it here so
-// the v1 paths under test stay active.
-_setOverridesForTesting({ "memory-v2-enabled": false });
-
 // ---------------------------------------------------------------------------
 // Track agent loop calls
 // ---------------------------------------------------------------------------
@@ -69,7 +63,7 @@ mock.module("../config/loader.js", () => ({
       pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
-    memory: { enabled: false },
+    memory: { enabled: false, v2: { enabled: false } },
     daemon: {
       startupSocketWaitMs: 5000,
       stopTimeoutMs: 5000,

package/src/__tests__/conversation-workspace-tool-tracking.test.ts

@@ -1,14 +1,8 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { AgentEvent } from "../agent/loop.js";
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
 
-// This test exercises v1 conversation routing. The `memory-v2-enabled` flag
-// (registry default `true`) flips memory routing to v2 — disable it here so
-// the v1 paths under test stay active.
-_setOverridesForTesting({ "memory-v2-enabled": false });
-
 // ---------------------------------------------------------------------------
 // Configurable agent loop behavior
 // ---------------------------------------------------------------------------
@@ -67,7 +61,7 @@ mock.module("../config/loader.js", () => ({
       pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
-    memory: { enabled: false },
+    memory: { enabled: false, v2: { enabled: false } },
     daemon: {
       startupSocketWaitMs: 5000,
       stopTimeoutMs: 5000,

package/src/__tests__/credential-security-invariants.test.ts

@@ -208,9 +208,11 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "config/bundled-skills/image-studio/tools/media-generate-image.ts", // image generation tool API key lookup
       "config/bundled-skills/media-processing/tools/analyze-keyframes.ts", // keyframe analysis tool API key lookup
       "providers/registry.ts", // provider registry API key lookup for initialization
+      "providers/inference/resolve-auth.ts", // provider_connection auth resolver (api_key path reads vault, mirrors registry.ts)
       "providers/provider-availability.ts", // provider availability API key check
       "media/image-credentials.ts", // shared image-gen credential resolver (provider API key lookup)
       "memory/embedding-backend.ts", // embedding backend API key lookup
+      "memory/llm-request-log-source-clickhouse.ts", // ClickHouse read source — lazy lookup of clickhouse:url + clickhouse:password + vellum:platform_assistant_id for self-scoped mirror reads
       "daemon/providers-setup.ts", // provider initialization API key lookup
       "workspace/migrations/006-services-config.ts", // services config migration reads provider API keys
       "workspace/migrations/018-rekey-compound-credential-keys.ts", // re-key compound credential storage keys
@@ -220,22 +222,19 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "daemon/lifecycle.ts", // CES client injection into secure-keys at startup
       "daemon/daemon-skill-host.ts", // SkillHost secureKeys facet adapter (delegates to getProviderKeyAsync)
       "runtime/routes/credential-prompt-routes.ts", // Route for secure credential prompt (stores secret via setSecureKeyAsync)
+      "runtime/routes/credential-routes.ts", // CLI credential management routes (CLI-migrated to IPC)
+      "runtime/routes/platform-routes.ts", // CLI platform connect/disconnect/status routes (CLI-migrated to IPC)
       "ipc/skill-routes/providers.ts", // host.providers.secureKeys.getProviderKey IPC route (out-of-process SkillHost companion)
       "daemon/external-plugins-bootstrap.ts", // reads credentials at plugin init (manifest.requiresCredential) via the CES-mediated getSecureKeyAsync path
       "inbound/platform-callback-registration.ts", // managed credential lookup for platform base URL, assistant ID, and API key
       "tts/providers/elevenlabs-provider.ts", // ElevenLabs TTS API key lookup
       "tts/providers/deepgram-provider.ts", // Deepgram TTS API key lookup
       "tts/providers/xai-provider.ts", // xAI TTS API key lookup
-      "meet/session-manager.ts", // Meet bot container provisioning (provider API key lookup for Deepgram/TTS)
       "credential-health/credential-health-service.ts", // credential health check reads access tokens for liveness pings
       "ipc/skill-routes/providers.ts", // skill IPC route exposes provider key lookup to hosted skills
-      "cli/commands/avatar.ts", // CLI avatar command credential lookup
-      "cli/commands/credentials.ts", // CLI credential management commands
+      "runtime/routes/avatar-routes.ts", // avatar generate route reads platform_base_url from credential store
       "cli/commands/keys.ts", // CLI provider key management
       "cli/commands/oauth/connect.ts", // CLI OAuth connect stored-secret verification
-      "cli/commands/platform/connect.ts", // CLI platform connect credential check
-      "cli/commands/platform/disconnect.ts", // CLI platform disconnect credential lookup
-      "cli/commands/platform/index.ts", // CLI platform status credential check
     ]);
 
     const thisDir = dirname(fileURLToPath(import.meta.url));