@vellumai/assistant 0.8.3 → 0.8.5

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__/domain-register.test.ts

@@ -204,4 +204,114 @@ describe("assistant domain register", () => {
     await runDomainCommand("domain", "register", "velly");
     expect(process.exitCode).not.toBe(0);
   });
+
+  test("--email-username is included in IPC body", async () => {
+    mockIpcCallFn = mock(() =>
+      Promise.resolve({
+        ok: true,
+        result: {
+          id: "550e8400-e29b-41d4-a716-446655440000",
+          domain: "velly.vellum.me",
+          status: "active",
+          verified: true,
+        },
+      }),
+    );
+
+    await runDomainCommand(
+      "domain",
+      "register",
+      "velly",
+      "--email-username",
+      "hello",
+    );
+
+    expect(mockIpcCallFn).toHaveBeenCalledWith("domain_register", {
+      body: { subdomain: "velly", email_username: "hello" },
+    });
+    expect(process.exitCode).toBe(0);
+  });
+
+  test("email error in response is surfaced as warning", async () => {
+    mockIpcCallFn = mock(() =>
+      Promise.resolve({
+        ok: true,
+        result: {
+          id: "550e8400-e29b-41d4-a716-446655440000",
+          domain: "velly.vellum.me",
+          status: "active",
+          verified: true,
+          email_error: {
+            detail: "MX records not ready",
+            code: "email_setup_failed",
+          },
+        },
+      }),
+    );
+
+    await runDomainCommand(
+      "domain",
+      "register",
+      "velly",
+      "--email-username",
+      "hello",
+    );
+
+    expect(process.exitCode).toBe(0);
+  });
+
+  test("--json includes email_error in output", async () => {
+    mockIpcCallFn = mock(() =>
+      Promise.resolve({
+        ok: true,
+        result: {
+          id: "550e8400-e29b-41d4-a716-446655440000",
+          domain: "velly.vellum.me",
+          status: "active",
+          verified: true,
+          email_error: {
+            detail: "MX records not ready",
+            code: "email_setup_failed",
+          },
+        },
+      }),
+    );
+
+    const output = await runDomainCommand(
+      "domain",
+      "--json",
+      "register",
+      "velly",
+      "--email-username",
+      "hello",
+    );
+
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.email_error).toEqual({
+      detail: "MX records not ready",
+      code: "email_setup_failed",
+    });
+    expect(process.exitCode).toBe(0);
+  });
+
+  test("without --email-username behavior is unchanged", async () => {
+    mockIpcCallFn = mock(() =>
+      Promise.resolve({
+        ok: true,
+        result: {
+          id: "550e8400-e29b-41d4-a716-446655440000",
+          domain: "velly.vellum.me",
+          status: "active",
+          verified: true,
+        },
+      }),
+    );
+
+    await runDomainCommand("domain", "register", "velly");
+
+    expect(mockIpcCallFn).toHaveBeenCalledWith("domain_register", {
+      body: { subdomain: "velly" },
+    });
+    expect(process.exitCode).toBe(0);
+  });
 });