@vellumai/assistant 0.6.3 → 0.6.4

package/src/ipc/__tests__/cli-ipc.test.ts

@@ -0,0 +1,200 @@
+/**
+ * Tests for the `assistant conversations wake` CLI command.
+ *
+ * Mocks wakeAgentForOpportunity at the module boundary so the real
+ * CliIpcServer (with auto-registered routes) can be exercised end-to-end
+ * without spinning up the full daemon.
+ */
+
+import { afterEach, describe, expect, mock, test } from "bun:test";
+
+import { runAssistantCommandFull } from "../../cli/__tests__/run-assistant-command.js";
+import { CliIpcServer } from "../cli-server.js";
+
+// ---------------------------------------------------------------------------
+// Mock state
+// ---------------------------------------------------------------------------
+
+let mockWakeResult = { invoked: true, producedToolCalls: false };
+let mockWakeCalls: Array<{
+  conversationId: string;
+  hint: string;
+  source: string;
+}> = [];
+
+mock.module("../../runtime/agent-wake.js", () => ({
+  wakeAgentForOpportunity: async (opts: {
+    conversationId: string;
+    hint: string;
+    source: string;
+  }) => {
+    mockWakeCalls.push(opts);
+    return mockWakeResult;
+  },
+  registerDefaultWakeResolver: () => {},
+}));
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+let server: CliIpcServer | null = null;
+
+afterEach(() => {
+  server?.stop();
+  server = null;
+  mockWakeResult = { invoked: true, producedToolCalls: false };
+  mockWakeCalls = [];
+});
+
+async function startServer(): Promise<void> {
+  server = new CliIpcServer();
+  server.start();
+  await new Promise((resolve) => setTimeout(resolve, 50));
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("assistant conversations wake (CLI)", () => {
+  test("successful wake prints confirmation", async () => {
+    mockWakeResult = { invoked: true, producedToolCalls: true };
+    await startServer();
+    process.exitCode = 0;
+
+    const { stdout } = await runAssistantCommandFull(
+      "conversations",
+      "wake",
+      "conv-123",
+      "--hint",
+      "test hint",
+    );
+
+    expect(stdout).toContain("Wake produced output on conversation conv-123");
+    expect(process.exitCode).toBe(0);
+  });
+
+  test("wake invoked but no output", async () => {
+    mockWakeResult = { invoked: true, producedToolCalls: false };
+    await startServer();
+    process.exitCode = 0;
+
+    const { stdout } = await runAssistantCommandFull(
+      "conversations",
+      "wake",
+      "conv-456",
+      "--hint",
+      "quiet check",
+    );
+
+    expect(stdout).toContain("no output produced");
+    expect(process.exitCode).toBe(0);
+  });
+
+  test("--json outputs structured success", async () => {
+    mockWakeResult = { invoked: true, producedToolCalls: true };
+    await startServer();
+    process.exitCode = 0;
+
+    const { stdout } = await runAssistantCommandFull(
+      "conversations",
+      "wake",
+      "conv-789",
+      "--hint",
+      "json test",
+      "--json",
+    );
+
+    const parsed = JSON.parse(stdout.trim());
+    expect(parsed.ok).toBe(true);
+    expect(parsed.invoked).toBe(true);
+    expect(parsed.producedToolCalls).toBe(true);
+  });
+
+  test("--json outputs structured error when IPC fails", async () => {
+    // No server started — socket doesn't exist
+    process.exitCode = 0;
+
+    const { stdout } = await runAssistantCommandFull(
+      "conversations",
+      "wake",
+      "conv-nope",
+      "--hint",
+      "will fail",
+      "--json",
+    );
+
+    const parsed = JSON.parse(stdout.trim());
+    expect(parsed.ok).toBe(false);
+    expect(parsed.error).toBeDefined();
+    expect(process.exitCode).toBe(1);
+  });
+
+  test("conversation not found sets exit code 1", async () => {
+    mockWakeResult = { invoked: false, producedToolCalls: false };
+    await startServer();
+    process.exitCode = 0;
+
+    await runAssistantCommandFull(
+      "conversations",
+      "wake",
+      "nonexistent",
+      "--hint",
+      "test",
+    );
+
+    expect(process.exitCode).toBe(1);
+  });
+
+  test("IPC connection error sets exit code 1", async () => {
+    // No server started — socket doesn't exist
+    process.exitCode = 0;
+
+    await runAssistantCommandFull(
+      "conversations",
+      "wake",
+      "conv-nope",
+      "--hint",
+      "will fail",
+    );
+
+    expect(process.exitCode).toBe(1);
+  });
+
+  test("--source passes through to IPC handler", async () => {
+    mockWakeResult = { invoked: true, producedToolCalls: false };
+    await startServer();
+    process.exitCode = 0;
+
+    await runAssistantCommandFull(
+      "conversations",
+      "wake",
+      "conv-src",
+      "--hint",
+      "source test",
+      "--source",
+      "github-ci",
+    );
+
+    expect(mockWakeCalls).toHaveLength(1);
+    expect(mockWakeCalls[0].source).toBe("github-ci");
+  });
+
+  test("defaults source to cli when --source omitted", async () => {
+    mockWakeResult = { invoked: true, producedToolCalls: false };
+    await startServer();
+    process.exitCode = 0;
+
+    await runAssistantCommandFull(
+      "conversations",
+      "wake",
+      "conv-default",
+      "--hint",
+      "default source",
+    );
+
+    expect(mockWakeCalls).toHaveLength(1);
+    expect(mockWakeCalls[0].source).toBe("cli");
+  });
+});

package/src/ipc/cli-client.ts

@@ -0,0 +1,151 @@
+/**
+ * CLI IPC client for communicating with the assistant daemon.
+ *
+ * One-shot connect → call → disconnect over the CLI IPC socket.
+ * Returns a typed result object so callers can distinguish success
+ * from connection failures and method errors.
+ *
+ * The socket lives at `{workspaceDir}/assistant-cli.sock`.
+ */
+
+import { connect, type Socket } from "node:net";
+
+import { getLogger } from "../util/logger.js";
+import { getCliSocketPath } from "./cli-server.js";
+
+const log = getLogger("cli-ipc-client");
+
+// ---------------------------------------------------------------------------
+// Types (mirror cli-server.ts protocol)
+// ---------------------------------------------------------------------------
+
+type IpcRequest = {
+  id: string;
+  method: string;
+  params?: Record<string, unknown>;
+};
+
+type IpcResponse = {
+  id: string;
+  result?: unknown;
+  error?: string;
+};
+
+// ---------------------------------------------------------------------------
+// Client
+// ---------------------------------------------------------------------------
+
+const DEFAULT_CALL_TIMEOUT_MS = 60_000; // wake may take time (agent loop runs)
+const CONNECT_TIMEOUT_MS = 3_000;
+
+export interface CliIpcCallResult<T = unknown> {
+  ok: boolean;
+  result?: T;
+  error?: string;
+}
+
+/**
+ * One-shot IPC helper: connect to the daemon socket, call a method,
+ * return the result, disconnect.
+ *
+ * Returns a typed result object so callers can distinguish success from
+ * connection failures and method errors.
+ */
+export async function cliIpcCall<T = unknown>(
+  method: string,
+  params?: Record<string, unknown>,
+  options?: { timeoutMs?: number },
+): Promise<CliIpcCallResult<T>> {
+  const socketPath = getCliSocketPath();
+  const callTimeoutMs = options?.timeoutMs ?? DEFAULT_CALL_TIMEOUT_MS;
+
+  return new Promise<CliIpcCallResult<T>>((resolve) => {
+    let settled = false;
+    let callTimer: ReturnType<typeof setTimeout> | undefined;
+
+    const finish = (result: CliIpcCallResult<T>) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(connectTimer);
+      if (callTimer) clearTimeout(callTimer);
+      socket.destroy();
+      resolve(result);
+    };
+
+    const connectTimer = setTimeout(() => {
+      log.debug(
+        { method, socketPath, timeoutMs: CONNECT_TIMEOUT_MS },
+        "CLI IPC connect timed out",
+      );
+      finish({
+        ok: false,
+        error: "Could not connect to assistant daemon. Is it running?",
+      });
+    }, CONNECT_TIMEOUT_MS);
+
+    const socket: Socket = connect(socketPath);
+    socket.unref();
+
+    let buffer = "";
+    const reqId = crypto.randomUUID();
+
+    socket.on("connect", () => {
+      clearTimeout(connectTimer);
+      const req: IpcRequest = { id: reqId, method, params };
+      socket.write(JSON.stringify(req) + "\n");
+
+      callTimer = setTimeout(() => {
+        log.debug(
+          { method, socketPath, timeoutMs: callTimeoutMs },
+          "CLI IPC call timed out waiting for response",
+        );
+        finish({ ok: false, error: "Request timed out" });
+      }, callTimeoutMs);
+
+      socket.on("data", (chunk) => {
+        buffer += chunk.toString();
+        let newlineIdx: number;
+        while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
+          const line = buffer.slice(0, newlineIdx).trim();
+          buffer = buffer.slice(newlineIdx + 1);
+          if (!line) continue;
+
+          try {
+            const msg = JSON.parse(line) as IpcResponse;
+            if (msg.id === reqId) {
+              if (msg.error) {
+                finish({ ok: false, error: msg.error });
+              } else {
+                finish({ ok: true, result: msg.result as T });
+              }
+              return;
+            }
+          } catch {
+            // Ignore malformed lines
+          }
+        }
+      });
+    });
+
+    socket.on("error", (err) => {
+      const code = (err as NodeJS.ErrnoException).code;
+      log.debug({ err, code, method, socketPath }, "CLI IPC socket error");
+      finish({
+        ok: false,
+        error:
+          code === "ENOENT" || code === "ECONNREFUSED"
+            ? "Could not connect to assistant daemon. Is it running?"
+            : `Connection error: ${code ?? err.message}`,
+      });
+    });
+
+    socket.on("close", () => {
+      if (!settled) {
+        finish({
+          ok: false,
+          error: "Connection closed before response",
+        });
+      }
+    });
+  });
+}

package/src/ipc/cli-server.ts

@@ -0,0 +1,234 @@
+/**
+ * CLI IPC server — exposes daemon capabilities to CLI commands and external
+ * processes over a Unix domain socket.
+ *
+ * This is the preferred method of inter-process communication between the
+ * CLI and the daemon. File-based signals and the HTTP port are deprecated
+ * in favor of this IPC socket.
+ *
+ * Protocol: newline-delimited JSON over a Unix domain socket.
+ * - Request:  { "id": string, "method": string, "params"?: Record<string, unknown> }
+ * - Response: { "id": string, "result"?: unknown, "error"?: string }
+ *
+ * The socket lives at `{workspaceDir}/assistant-cli.sock` on the workspace
+ * volume so CLI commands running in the same container can connect to it.
+ */
+
+import { existsSync, unlinkSync } from "node:fs";
+import { createServer, type Server, type Socket } from "node:net";
+import { join } from "node:path";
+
+import { getLogger } from "../util/logger.js";
+import { getWorkspaceDir } from "../util/platform.js";
+import { cliIpcRoutes } from "./routes/index.js";
+
+const log = getLogger("cli-ipc-server");
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export type IpcRequest = {
+  id: string;
+  method: string;
+  params?: Record<string, unknown>;
+};
+
+export type IpcResponse = {
+  id: string;
+  result?: unknown;
+  error?: string;
+};
+
+export type IpcMethodHandler = (
+  params?: Record<string, unknown>,
+) => unknown | Promise<unknown>;
+
+/** A single IPC route definition — method name + handler function. */
+export type IpcRoute = {
+  method: string;
+  handler: IpcMethodHandler;
+};
+
+// ---------------------------------------------------------------------------
+// Server
+// ---------------------------------------------------------------------------
+
+export class CliIpcServer {
+  private server: Server | null = null;
+  private clients = new Set<Socket>();
+  private methods = new Map<string, IpcMethodHandler>();
+  private socketPath: string;
+
+  constructor() {
+    this.socketPath = getCliSocketPath();
+    for (const route of cliIpcRoutes) {
+      this.methods.set(route.method, route.handler);
+    }
+  }
+
+  /** Register an additional method handler after construction. */
+  registerMethod(method: string, handler: IpcMethodHandler): void {
+    this.methods.set(method, handler);
+  }
+
+  /** Start listening on the Unix domain socket. */
+  start(): void {
+    // Clean up stale socket file from a previous run
+    if (existsSync(this.socketPath)) {
+      try {
+        unlinkSync(this.socketPath);
+      } catch {
+        // Ignore — may already be gone
+      }
+    }
+
+    this.server = createServer((socket) => {
+      this.clients.add(socket);
+      log.debug("IPC client connected");
+
+      let buffer = "";
+
+      socket.on("data", (chunk) => {
+        buffer += chunk.toString();
+        let newlineIdx: number;
+        while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
+          const line = buffer.slice(0, newlineIdx).trim();
+          buffer = buffer.slice(newlineIdx + 1);
+          if (line) {
+            this.handleMessage(socket, line);
+          }
+        }
+      });
+
+      socket.on("close", () => {
+        this.clients.delete(socket);
+        log.debug("IPC client disconnected");
+      });
+
+      socket.on("error", (err) => {
+        log.warn({ err }, "IPC client socket error");
+        this.clients.delete(socket);
+      });
+    });
+
+    this.server.on("error", (err) => {
+      log.error({ err }, "CLI IPC server error");
+    });
+
+    this.server.listen(this.socketPath, () => {
+      log.info({ path: this.socketPath }, "CLI IPC server listening");
+    });
+  }
+
+  /** Stop the server and disconnect all clients. */
+  stop(): void {
+    for (const client of this.clients) {
+      if (!client.destroyed) client.destroy();
+    }
+    this.clients.clear();
+
+    if (this.server) {
+      this.server.close();
+      this.server = null;
+    }
+
+    if (existsSync(this.socketPath)) {
+      try {
+        unlinkSync(this.socketPath);
+      } catch {
+        // Ignore
+      }
+    }
+  }
+
+  /** Get the socket path (for diagnostics). */
+  getSocketPath(): string {
+    return this.socketPath;
+  }
+
+  // ── Internal ──────────────────────────────────────────────────────────
+
+  private handleMessage(socket: Socket, line: string): void {
+    let req: IpcRequest;
+    try {
+      req = JSON.parse(line) as IpcRequest;
+    } catch {
+      this.sendResponse(socket, {
+        id: "unknown",
+        error: "Invalid JSON",
+      });
+      return;
+    }
+
+    if (
+      !req ||
+      typeof req !== "object" ||
+      Array.isArray(req) ||
+      !req.id ||
+      !req.method
+    ) {
+      const id =
+        req &&
+        typeof req === "object" &&
+        !Array.isArray(req) &&
+        typeof req.id === "string"
+          ? req.id
+          : "unknown";
+      this.sendResponse(socket, {
+        id,
+        error: "Missing 'id' or 'method' field",
+      });
+      return;
+    }
+
+    const handler = this.methods.get(req.method);
+    if (!handler) {
+      this.sendResponse(socket, {
+        id: req.id,
+        error: `Unknown method: ${req.method}`,
+      });
+      return;
+    }
+
+    try {
+      const result = handler(req.params);
+      if (result instanceof Promise) {
+        result
+          .then((value) => {
+            this.sendResponse(socket, { id: req.id, result: value });
+          })
+          .catch((err) => {
+            log.warn({ err, method: req.method }, "IPC handler error");
+            this.sendResponse(socket, {
+              id: req.id,
+              error: String(err),
+            });
+          });
+      } else {
+        this.sendResponse(socket, { id: req.id, result });
+      }
+    } catch (err) {
+      log.warn({ err, method: req.method }, "IPC handler error");
+      this.sendResponse(socket, {
+        id: req.id,
+        error: String(err),
+      });
+    }
+  }
+
+  private sendResponse(socket: Socket, response: IpcResponse): void {
+    if (!socket.destroyed) {
+      socket.write(JSON.stringify(response) + "\n");
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+export function getCliSocketPath(): string {
+  return join(getWorkspaceDir(), "assistant-cli.sock");
+}
+