@vellumai/assistant 0.8.2 → 0.8.4

package/src/cli/commands/__tests__/conversations-slack.test.ts

@@ -0,0 +1,572 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { Command } from "commander";
+
+type IpcCall = {
+  method: string;
+  params?: Record<string, unknown>;
+};
+
+type GatewayCall = {
+  method: string;
+  params?: Record<string, unknown>;
+  timeoutMs?: number;
+};
+
+type SlackReplyCall = {
+  chatId: string;
+  text: string;
+  options?: Record<string, unknown>;
+};
+
+type MockBinding = {
+  conversationId: string;
+  sourceChannel: string;
+  externalChatId: string;
+  externalThreadId?: string | null;
+  createdAt: number;
+  updatedAt: number;
+};
+
+const cliIpcCalls: IpcCall[] = [];
+const gatewayCalls: GatewayCall[] = [];
+const slackReplyCalls: SlackReplyCall[] = [];
+const bindingCalls: string[] = [];
+
+let cliIpcResponse: {
+  ok: boolean;
+  result?: unknown;
+  error?: string;
+  statusCode?: number;
+} = { ok: true, result: {} };
+let gatewayResponse: unknown = {
+  detached: true,
+  channelId: "C123",
+  threadTs: "1700000000.000100",
+};
+let slackReplyError: Error | null = null;
+let mockBinding: MockBinding | null = null;
+
+mock.module("../../../ipc/cli-client.js", () => ({
+  cliIpcCall: async (method: string, params?: Record<string, unknown>) => {
+    cliIpcCalls.push({ method, params });
+    return cliIpcResponse;
+  },
+  cliIpcCallBinary: async () => cliIpcResponse,
+  cliIpcCallStream: async () => cliIpcResponse,
+  exitFromIpcResult: (result: { error?: string; statusCode?: number }) => {
+    process.stderr.write((result.error ?? "Unknown error") + "\n");
+    process.exitCode = exitCodeFromIpcResult(result);
+  },
+  exitCodeFromIpcResult,
+}));
+
+function exitCodeFromIpcResult(result: { statusCode?: number }): number {
+  if (result.statusCode === undefined) return 10;
+  if (result.statusCode >= 500) return 3;
+  if (result.statusCode >= 400) return 2;
+  return 1;
+}
+
+mock.module("../../../ipc/gateway-client.js", () => ({
+  ipcCall: async (
+    method: string,
+    params?: Record<string, unknown>,
+    timeoutMs?: number,
+  ) => {
+    gatewayCalls.push({ method, params, timeoutMs });
+    return gatewayResponse;
+  },
+}));
+
+mock.module("../../../messaging/providers/slack/send.js", () => ({
+  sendSlackReply: async (
+    chatId: string,
+    text: string,
+    options?: Record<string, unknown>,
+  ) => {
+    slackReplyCalls.push({ chatId, text, options });
+    if (slackReplyError) throw slackReplyError;
+    return { ok: true, ts: "1700000000.000200" };
+  },
+  sendSlackTypingIndicator: async () => "1700000000.000200",
+  sendSlackReaction: async () => {},
+  sendSlackAssistantThreadStatus: async () => {},
+  sendSlackAttachments: async () => ({
+    allFailed: false,
+    failureCount: 0,
+  }),
+}));
+
+mock.module("../../../memory/external-conversation-store.js", () => ({
+  upsertBinding: () => {},
+  upsertOutboundBinding: () => {},
+  updateExternalChatName: () => {},
+  getBindingByConversation: (conversationId: string) => {
+    bindingCalls.push(conversationId);
+    return mockBinding;
+  },
+  getBindingByChannelChat: () => null,
+  getBindingByChannelChatThread: () => null,
+  deleteBindingByChannelChat: () => {},
+  deleteBindingByChannelChatThread: () => {},
+  getBindingsForConversations: () => new Map(),
+}));
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () => ({
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    debug: () => {},
+  }),
+  getCliLogger: () => ({
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    debug: () => {},
+  }),
+}));
+
+const { registerConversationsCommand } = await import("../conversations.js");
+const { ROUTES: CONVERSATION_CLI_ROUTES } =
+  await import("../../../runtime/routes/conversation-cli-routes.js");
+
+const slackDetachRouteCandidate = CONVERSATION_CLI_ROUTES.find(
+  (route) => route.operationId === "conversation_slack_detach_cli",
+);
+
+if (!slackDetachRouteCandidate) {
+  throw new Error("conversation_slack_detach_cli route not registered");
+}
+const slackDetachRoute = slackDetachRouteCandidate;
+
+let savedConvId: string | undefined;
+let savedSkillContext: string | undefined;
+
+beforeEach(() => {
+  cliIpcCalls.length = 0;
+  gatewayCalls.length = 0;
+  slackReplyCalls.length = 0;
+  bindingCalls.length = 0;
+  cliIpcResponse = { ok: true, result: {} };
+  gatewayResponse = {
+    detached: true,
+    channelId: "C123",
+    threadTs: "1700000000.000100",
+  };
+  slackReplyError = null;
+  mockBinding = null;
+  process.exitCode = 0;
+
+  savedConvId = process.env.__CONVERSATION_ID;
+  savedSkillContext = process.env.__SKILL_CONTEXT_JSON;
+  delete process.env.__CONVERSATION_ID;
+  delete process.env.__SKILL_CONTEXT_JSON;
+});
+
+afterEach(() => {
+  if (savedConvId !== undefined) {
+    process.env.__CONVERSATION_ID = savedConvId;
+  } else {
+    delete process.env.__CONVERSATION_ID;
+  }
+
+  if (savedSkillContext !== undefined) {
+    process.env.__SKILL_CONTEXT_JSON = savedSkillContext;
+  } else {
+    delete process.env.__SKILL_CONTEXT_JSON;
+  }
+
+  process.exitCode = 0;
+});
+
+async function runCommand(
+  args: string[],
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+  const stdoutChunks: string[] = [];
+  const stderrChunks: string[] = [];
+  const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+  const originalStderrWrite = process.stderr.write.bind(process.stderr);
+
+  process.stdout.write = ((chunk: unknown) => {
+    stdoutChunks.push(typeof chunk === "string" ? chunk : String(chunk));
+    return true;
+  }) as typeof process.stdout.write;
+  process.stderr.write = ((chunk: unknown) => {
+    stderrChunks.push(typeof chunk === "string" ? chunk : String(chunk));
+    return true;
+  }) as typeof process.stderr.write;
+
+  try {
+    const program = new Command();
+    program.exitOverride();
+    program.configureOutput({ writeErr: () => {}, writeOut: () => {} });
+    registerConversationsCommand(program);
+    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 = Number(process.exitCode ?? 0);
+  process.exitCode = 0;
+  return {
+    stdout: stdoutChunks.join(""),
+    stderr: stderrChunks.join(""),
+    exitCode,
+  };
+}
+
+async function callSlackDetachRoute(body: Record<string, unknown>) {
+  return slackDetachRoute.handler({ body });
+}
+
+function makeBinding(overrides: Partial<MockBinding> = {}): MockBinding {
+  return {
+    conversationId: "conv-1",
+    sourceChannel: "slack",
+    externalChatId: "C123",
+    externalThreadId: "1700000000.000100",
+    createdAt: 1,
+    updatedAt: 2,
+    ...overrides,
+  };
+}
+
+async function expectRouteError(
+  body: Record<string, unknown>,
+  code: string,
+): Promise<void> {
+  try {
+    await callSlackDetachRoute(body);
+  } catch (err) {
+    expect((err as { code?: string }).code).toBe(code);
+    return;
+  }
+  throw new Error(`Expected route error ${code}`);
+}
+
+describe("conversation_slack_detach_cli route", () => {
+  test("detaches by explicit Slack identifiers without loading a binding", async () => {
+    const result = await callSlackDetachRoute({
+      channelId: "C123",
+      threadTs: "1700000000.000100",
+    });
+
+    expect(result).toEqual({
+      detached: true,
+      channelId: "C123",
+      threadTs: "1700000000.000100",
+      source: "explicit",
+    });
+    expect(bindingCalls).toHaveLength(0);
+    expect(gatewayCalls).toEqual([
+      {
+        method: "detach_slack_active_thread",
+        params: {
+          channelId: "C123",
+          threadTs: "1700000000.000100",
+        },
+        timeoutMs: 5000,
+      },
+    ]);
+    expect(slackReplyCalls).toEqual([
+      {
+        chatId: "C123",
+        text: "Muted this Slack thread. I won't respond to further replies here unless you mention me again.",
+        options: { threadTs: "1700000000.000100" },
+      },
+    ]);
+  });
+
+  test("resolves Slack identifiers from a conversation binding", async () => {
+    mockBinding = makeBinding();
+
+    const result = await callSlackDetachRoute({ conversationId: "conv-1" });
+
+    expect(result).toEqual({
+      detached: true,
+      channelId: "C123",
+      threadTs: "1700000000.000100",
+      source: "conversation_binding",
+      conversationId: "conv-1",
+    });
+    expect(bindingCalls).toEqual(["conv-1"]);
+    expect(gatewayCalls[0]).toMatchObject({
+      method: "detach_slack_active_thread",
+      params: {
+        channelId: "C123",
+        threadTs: "1700000000.000100",
+      },
+    });
+    expect(slackReplyCalls).toEqual([
+      {
+        chatId: "C123",
+        text: "Muted this Slack thread. I won't respond to further replies here unless you mention me again.",
+        options: { threadTs: "1700000000.000100" },
+      },
+    ]);
+  });
+
+  test("does not send a confirmation when the gateway reports no detach", async () => {
+    gatewayResponse = {
+      detached: false,
+      channelId: "C123",
+      threadTs: "1700000000.000100",
+    };
+
+    const result = await callSlackDetachRoute({
+      channelId: "C123",
+      threadTs: "1700000000.000100",
+    });
+
+    expect(result).toMatchObject({ detached: false });
+    expect(slackReplyCalls).toHaveLength(0);
+  });
+
+  test("returns NOT_FOUND when no conversation binding exists", async () => {
+    await expectRouteError({ conversationId: "conv-missing" }, "NOT_FOUND");
+    expect(gatewayCalls).toHaveLength(0);
+  });
+
+  test("rejects non-Slack conversation bindings", async () => {
+    mockBinding = makeBinding({ sourceChannel: "telegram" });
+
+    await expectRouteError({ conversationId: "conv-1" }, "BAD_REQUEST");
+    expect(gatewayCalls).toHaveLength(0);
+  });
+
+  test("rejects Slack bindings that are not thread-bound", async () => {
+    mockBinding = makeBinding({ externalThreadId: null });
+
+    await expectRouteError({ conversationId: "conv-1" }, "BAD_REQUEST");
+    expect(gatewayCalls).toHaveLength(0);
+  });
+
+  test("rejects malformed gateway responses", async () => {
+    gatewayResponse = { detached: true };
+
+    await expectRouteError(
+      { channelId: "C123", threadTs: "1700000000.000100" },
+      "BAD_GATEWAY",
+    );
+    expect(slackReplyCalls).toHaveLength(0);
+  });
+
+  test("reports a gateway error when the confirmation message cannot be sent", async () => {
+    slackReplyError = new Error("Slack bot token not configured");
+
+    await expectRouteError(
+      { channelId: "C123", threadTs: "1700000000.000100" },
+      "BAD_GATEWAY",
+    );
+    expect(gatewayCalls).toHaveLength(1);
+    expect(slackReplyCalls).toHaveLength(1);
+  });
+});
+
+describe("assistant conversations slack detach", () => {
+  test("detaches with explicit Slack identifiers", async () => {
+    cliIpcResponse = {
+      ok: true,
+      result: {
+        detached: true,
+        channelId: "C123",
+        threadTs: "1700000000.000100",
+        source: "explicit",
+      },
+    };
+
+    const { stdout, exitCode } = await runCommand([
+      "conversations",
+      "slack",
+      "detach",
+      "--channel",
+      "C123",
+      "--thread",
+      "1700000000.000100",
+      "--json",
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(JSON.parse(stdout)).toEqual({
+      ok: true,
+      result: {
+        detached: true,
+        channelId: "C123",
+        threadTs: "1700000000.000100",
+        source: "explicit",
+      },
+    });
+    expect(cliIpcCalls).toEqual([
+      {
+        method: "conversation_slack_detach_cli",
+        params: {
+          body: {
+            channelId: "C123",
+            threadTs: "1700000000.000100",
+          },
+        },
+      },
+    ]);
+  });
+
+  test("defaults to the current conversation when no Slack identifiers are provided", async () => {
+    process.env.__CONVERSATION_ID = "conv-env";
+    cliIpcResponse = {
+      ok: true,
+      result: {
+        detached: true,
+        channelId: "C123",
+        threadTs: "1700000000.000100",
+        source: "conversation_binding",
+        conversationId: "conv-env",
+      },
+    };
+
+    const { stdout, exitCode } = await runCommand([
+      "conversations",
+      "slack",
+      "detach",
+      "--json",
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(JSON.parse(stdout).result.conversationId).toBe("conv-env");
+    expect(cliIpcCalls[0]).toEqual({
+      method: "conversation_slack_detach_cli",
+      params: { body: { conversationId: "conv-env" } },
+    });
+  });
+
+  test("supports mute as an alias for detach", async () => {
+    cliIpcResponse = {
+      ok: true,
+      result: {
+        detached: false,
+        channelId: "C123",
+        threadTs: "1700000000.000100",
+        source: "explicit",
+      },
+    };
+
+    const { stdout, exitCode } = await runCommand([
+      "conversations",
+      "slack",
+      "mute",
+      "--channel",
+      "C123",
+      "--thread",
+      "1700000000.000100",
+      "--json",
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(JSON.parse(stdout).result.detached).toBe(false);
+    expect(cliIpcCalls[0].method).toBe("conversation_slack_detach_cli");
+  });
+
+  test("fails locally when no target can be resolved", async () => {
+    const { stdout, exitCode } = await runCommand([
+      "conversations",
+      "slack",
+      "detach",
+      "--json",
+    ]);
+
+    expect(exitCode).toBe(1);
+    expect(JSON.parse(stdout).ok).toBe(false);
+    expect(cliIpcCalls).toHaveLength(0);
+  });
+
+  test("fails locally when only one explicit Slack identifier is provided", async () => {
+    const { stdout, exitCode } = await runCommand([
+      "conversations",
+      "slack",
+      "detach",
+      "--channel",
+      "C123",
+      "--json",
+    ]);
+
+    expect(exitCode).toBe(1);
+    const parsed = JSON.parse(stdout);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.error).toContain("--channel");
+    expect(parsed.error).toContain("--thread");
+    expect(cliIpcCalls).toHaveLength(0);
+  });
+
+  test("fails locally when explicit Slack identifiers are empty", async () => {
+    process.env.__CONVERSATION_ID = "conv-env";
+
+    const { stdout, exitCode } = await runCommand([
+      "conversations",
+      "slack",
+      "detach",
+      "--channel",
+      "",
+      "--thread",
+      "   ",
+      "--json",
+    ]);
+
+    expect(exitCode).toBe(1);
+    const parsed = JSON.parse(stdout);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.error).toContain("--channel");
+    expect(parsed.error).toContain("--thread");
+    expect(cliIpcCalls).toHaveLength(0);
+  });
+
+  test("maps JSON IPC transport errors to the shared exit code", async () => {
+    cliIpcResponse = {
+      ok: false,
+      error: "Could not connect to assistant",
+    };
+
+    const { stdout, exitCode } = await runCommand([
+      "conversations",
+      "slack",
+      "detach",
+      "--channel",
+      "C123",
+      "--thread",
+      "1700000000.000100",
+      "--json",
+    ]);
+
+    expect(exitCode).toBe(10);
+    expect(JSON.parse(stdout)).toEqual({
+      ok: false,
+      error: "Could not connect to assistant",
+    });
+    expect(cliIpcCalls).toHaveLength(1);
+  });
+
+  test("maps JSON IPC 4xx errors to the shared exit code", async () => {
+    cliIpcResponse = {
+      ok: false,
+      error: "Conversation is not bound to a Slack thread",
+      statusCode: 400,
+    };
+
+    const { stdout, exitCode } = await runCommand([
+      "conversations",
+      "slack",
+      "detach",
+      "conv-1",
+      "--json",
+    ]);
+
+    expect(exitCode).toBe(2);
+    expect(JSON.parse(stdout)).toEqual({
+      ok: false,
+      error: "Conversation is not bound to a Slack thread",
+    });
+    expect(cliIpcCalls).toHaveLength(1);
+  });
+});

package/src/cli/commands/__tests__/memory-v2.test.ts

@@ -2,9 +2,9 @@
  * Tests for the `assistant memory v2` CLI subgroup.
  *
  * Validates:
- *   - Subcommand registration (reembed, reembed-skills, activation, validate)
- *     under `memory v2`. The `memory` parent is created by the v2 registrar
- *     itself; v1 had its own subcommands but those were retired.
+ *   - Subcommand registration (reembed, reembed-skills, activation, validate,
+ *     ema, simulate) under `memory v2`. The `memory` parent is created by the
+ *     v2 registrar itself; v1 had its own subcommands but those were retired.
  *   - Each mutating subcommand maps to the right `memory_v2_backfill` op.
  *   - `validate` calls `memory_v2_validate` and pretty-prints the report.
  *   - `reembed-skills` calls `memory_v2_reembed_skills` synchronously.
@@ -143,8 +143,10 @@ describe("subcommand registration", () => {
     const subcommandNames = v2!.commands.map((c) => c.name()).sort();
     expect(subcommandNames).toEqual([
       "activation",
+      "ema",
       "reembed",
       "reembed-skills",
+      "simulate",
       "validate",
     ]);
   });
@@ -158,6 +160,7 @@ describe("subcommand registration", () => {
     expect(help).toContain("reembed-skills");
     expect(help).toContain("activation");
     expect(help).toContain("validate");
+    expect(help).toContain("simulate");
     // Removed subcommands must not surface in help.
     expect(help).not.toContain("migrate");
     expect(help).not.toContain("explain");
@@ -307,9 +310,7 @@ describe("memory v2 validate", () => {
     expect(logOutput.some((line) => line.includes("Pages: 49"))).toBe(true);
     expect(logOutput.some((line) => line.includes("Edges: 166"))).toBe(true);
     expect(
-      logOutput.some((line) =>
-        line.includes("Missing edge endpoints: none"),
-      ),
+      logOutput.some((line) => line.includes("Missing edge endpoints: none")),
     ).toBe(true);
     expect(
       logOutput.some((line) => line.includes("Oversized pages: none")),
@@ -325,9 +326,7 @@ describe("memory v2 validate", () => {
       result: {
         pageCount: 10,
         edgeCount: 20,
-        missingEdgeEndpoints: [
-          { from: "people/alice", to: "people/missing" },
-        ],
+        missingEdgeEndpoints: [{ from: "people/alice", to: "people/missing" }],
         oversizedPages: [{ slug: "arcs/big-day", chars: 12345 }],
         parseFailures: [
           { slug: "people/broken", error: "missing frontmatter" },
@@ -342,9 +341,7 @@ describe("memory v2 validate", () => {
       true,
     );
     expect(logOutput.some((line) => line.includes("arcs/big-day"))).toBe(true);
-    expect(logOutput.some((line) => line.includes("people/broken"))).toBe(
-      true,
-    );
+    expect(logOutput.some((line) => line.includes("people/broken"))).toBe(true);
   });
 
   test("exits with code 1 on IPC failure", async () => {