@vellumai/assistant 0.8.2 → 0.8.4

package/src/cli/{__tests__ → commands/__tests__}/notifications.test.ts

@@ -4,7 +4,7 @@ import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 // Test isolation: mock logger and IPC client
 // ---------------------------------------------------------------------------
 
-mock.module("../../util/logger.js", () => ({
+mock.module("../../../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
       get: () => () => {},
@@ -18,21 +18,43 @@ mock.module("../../util/logger.js", () => ({
 // Track cliIpcCall invocations and control responses
 const ipcCalls: Array<{ method: string; params?: Record<string, unknown> }> =
   [];
-let ipcResponse: { ok: boolean; result?: unknown; error?: string } = {
+let ipcResponse: {
+  ok: boolean;
+  result?: unknown;
+  error?: string;
+  statusCode?: number;
+} = {
   ok: true,
   result: {},
 };
 
-mock.module("../../ipc/cli-client.js", () => ({
+const exitCodeFromIpcResult = (r: { statusCode?: number }): number => {
+  if (r.statusCode === undefined) return 10;
+  if (r.statusCode >= 500) return 3;
+  if (r.statusCode >= 400) return 2;
+  return 1;
+};
+
+mock.module("../../../ipc/cli-client.js", () => ({
   cliIpcCall: async (method: string, params?: Record<string, unknown>) => {
     ipcCalls.push({ method, params });
     return ipcResponse;
   },
+  exitFromIpcResult: (r: {
+    ok: false;
+    error?: string;
+    statusCode?: number;
+  }) => {
+    process.stderr.write((r.error ?? "Unknown error") + "\n");
+    process.exitCode = exitCodeFromIpcResult(r);
+    return undefined as never;
+  },
+  exitCodeFromIpcResult,
 }));
 
 import { Command } from "commander";
 
-import { registerNotificationsCommand } from "../commands/notifications.js";
+import { registerNotificationsCommand } from "../notifications.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -40,6 +62,7 @@ import { registerNotificationsCommand } from "../commands/notifications.js";
 
 interface CommandResult {
   parsed: Record<string, unknown>;
+  stderr: string;
   exitCode: number;
 }
 
@@ -52,7 +75,9 @@ interface CommandResult {
  */
 async function runCommand(args: string[]): Promise<CommandResult> {
   const chunks: string[] = [];
+  const stderrChunks: string[] = [];
   const originalWrite = process.stdout.write;
+  const originalStderrWrite = process.stderr.write;
 
   process.exitCode = 0;
 
@@ -61,6 +86,11 @@ async function runCommand(args: string[]): Promise<CommandResult> {
     return true;
   }) as typeof process.stdout.write;
 
+  process.stderr.write = ((chunk: string | Buffer) => {
+    stderrChunks.push(typeof chunk === "string" ? chunk : chunk.toString());
+    return true;
+  }) as typeof process.stderr.write;
+
   try {
     const program = new Command();
     program.exitOverride();
@@ -76,6 +106,7 @@ async function runCommand(args: string[]): Promise<CommandResult> {
     // Commander throws on .exitOverride() for --help/errors; ignore
   } finally {
     process.stdout.write = originalWrite;
+    process.stderr.write = originalStderrWrite;
   }
 
   const exitCode = process.exitCode ?? 0;
@@ -87,7 +118,13 @@ async function runCommand(args: string[]): Promise<CommandResult> {
     ? (JSON.parse(firstLine) as Record<string, unknown>)
     : {};
 
-  return { parsed, exitCode };
+  return { parsed, stderr: stderrChunks.join(""), exitCode };
+}
+
+function lastSendBody(): Record<string, unknown> {
+  expect(ipcCalls).toHaveLength(1);
+  expect(ipcCalls[0].method).toBe("emit_notification_signal");
+  return ipcCalls[0].params?.body as Record<string, unknown>;
 }
 
 // ---------------------------------------------------------------------------
@@ -132,13 +169,10 @@ describe("notifications send", () => {
     expect(parsed.ok).toBe(true);
     expect(parsed.signalId).toBe("mock-id");
 
-    expect(ipcCalls).toHaveLength(1);
-    const call = ipcCalls[0];
-    expect(call.method).toBe("emit_notification_signal");
-    const callBody = call.params?.body as Record<string, unknown>;
-    expect(callBody?.sourceChannel).toBe("assistant_tool");
-    expect(callBody?.sourceEventName).toBe("user.send_notification");
-    const payload = callBody?.contextPayload as Record<string, unknown>;
+    const body = lastSendBody();
+    expect(body.sourceChannel).toBe("assistant_tool");
+    expect(body.sourceEventName).toBe("user.send_notification");
+    const payload = body.contextPayload as Record<string, unknown>;
     expect(payload.requestedMessage).toBe("Hello");
   });
 
@@ -160,9 +194,7 @@ describe("notifications send", () => {
     expect(exitCode).toBe(0);
     expect(parsed.ok).toBe(true);
 
-    expect(ipcCalls).toHaveLength(1);
-    const emitBody = ipcCalls[0].params?.body as Record<string, unknown>;
-    const hints = emitBody?.attentionHints as Record<string, unknown>;
+    const hints = lastSendBody().attentionHints as Record<string, unknown>;
     expect(hints.urgency).toBe("high");
     expect(hints.requiresAction).toBe(true);
     expect(hints.isAsyncBackground).toBe(true);
@@ -184,9 +216,7 @@ describe("notifications send", () => {
     expect(exitCode).toBe(0);
     expect(parsed.ok).toBe(true);
 
-    expect(ipcCalls).toHaveLength(1);
-    const dlBody = ipcCalls[0].params?.body as Record<string, unknown>;
-    const payload = dlBody?.contextPayload as Record<string, unknown>;
+    const payload = lastSendBody().contextPayload as Record<string, unknown>;
     expect(payload.preferredChannels).toEqual(["telegram", "slack"]);
   });
 
@@ -230,8 +260,8 @@ describe("notifications send", () => {
     expect(exitCode).toBe(0);
     expect(parsed.ok).toBe(true);
 
-    const callBody = ipcCalls[0].params?.body as Record<string, unknown>;
-    expect(callBody.conversationAffinityHint).toEqual({ vellum: "conv-123" });
+    const body = lastSendBody();
+    expect(body.conversationAffinityHint).toEqual({ vellum: "conv-123" });
   });
 
   test("send omits conversationAffinityHint when --conversation-id not passed", async () => {
@@ -245,8 +275,8 @@ describe("notifications send", () => {
       "Hi",
     ]);
 
-    const callBody = ipcCalls[0].params?.body as Record<string, unknown>;
-    expect(callBody.conversationAffinityHint).toBeUndefined();
+    const body = lastSendBody();
+    expect(body.conversationAffinityHint).toBeUndefined();
   });
 
   test("send rejects empty --conversation-id", async () => {
@@ -268,10 +298,35 @@ describe("notifications send", () => {
     expect(ipcCalls).toHaveLength(0);
   });
 
-  test("send surfaces IPC error response", async () => {
+  test("send surfaces IPC error response as JSON envelope in --json mode", async () => {
     ipcResponse = {
       ok: false,
-      error: "Daemon rejected the signal",
+      error: "Could not connect to assistant daemon. Is it running?",
+    };
+
+    const { parsed, stderr, exitCode } = await runCommand([
+      "send",
+      "--source-channel",
+      "assistant_tool",
+      "--source-event-name",
+      "user.send_notification",
+      "--message",
+      "Hello",
+    ]);
+
+    // Transport failure (no statusCode) maps to exit 10 per exitFromIpcResult.
+    expect(exitCode).toBe(10);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.error).toContain("Could not connect");
+    // --json mode keeps error on stdout envelope, not stderr.
+    expect(stderr).toBe("");
+  });
+
+  test("send maps daemon 4xx to exit 2 while preserving --json envelope", async () => {
+    ipcResponse = {
+      ok: false,
+      error: "Invalid signal payload",
+      statusCode: 422,
     };
 
     const { parsed, exitCode } = await runCommand([
@@ -284,9 +339,96 @@ describe("notifications send", () => {
       "Hello",
     ]);
 
-    expect(exitCode).toBe(1);
+    expect(exitCode).toBe(2);
     expect(parsed.ok).toBe(false);
-    expect(parsed.error).toBe("Daemon rejected the signal");
+    expect(parsed.error).toBe("Invalid signal payload");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// send — minimal-surface ergonomics (--urgent and source defaults)
+// ---------------------------------------------------------------------------
+
+describe("notifications send — minimal-surface ergonomics", () => {
+  test("--urgent maps to urgency=critical + requiresAction=true", async () => {
+    const { exitCode } = await runCommand([
+      "send",
+      "--message",
+      "Pager: prod is down",
+      "--urgent",
+    ]);
+
+    expect(exitCode).toBe(0);
+    const hints = lastSendBody().attentionHints as Record<string, unknown>;
+    expect(hints.urgency).toBe("critical");
+    expect(hints.requiresAction).toBe(true);
+  });
+
+  test("missing --source-channel defaults to 'assistant_tool'", async () => {
+    const { exitCode } = await runCommand(["send", "--message", "hello"]);
+
+    expect(exitCode).toBe(0);
+    const body = lastSendBody();
+    expect(body.sourceChannel).toBe("assistant_tool");
+    // The context payload echoes the source channel via requestedBySource.
+    const payload = body.contextPayload as Record<string, unknown>;
+    expect(payload.requestedBySource).toBe("assistant_tool");
+  });
+
+  test("missing --source-event-name defaults to 'assistant.share'", async () => {
+    const { exitCode } = await runCommand(["send", "--message", "hello"]);
+
+    expect(exitCode).toBe(0);
+    expect(lastSendBody().sourceEventName).toBe("assistant.share");
+  });
+
+  test("explicit --urgency high still overrides defaults when --urgent is absent", async () => {
+    const { exitCode } = await runCommand([
+      "send",
+      "--message",
+      "stand-up reminder",
+      "--urgency",
+      "high",
+    ]);
+
+    expect(exitCode).toBe(0);
+    const hints = lastSendBody().attentionHints as Record<string, unknown>;
+    expect(hints.urgency).toBe("high");
+    // Without --urgent or --requires-action, requiresAction stays at the new
+    // default of false.
+    expect(hints.requiresAction).toBe(false);
+  });
+
+  test("explicit --urgency wins even when --urgent is also passed (back-compat)", async () => {
+    const { exitCode } = await runCommand([
+      "send",
+      "--message",
+      "deploy complete",
+      "--urgent",
+      "--urgency",
+      "medium",
+    ]);
+
+    expect(exitCode).toBe(0);
+    const hints = lastSendBody().attentionHints as Record<string, unknown>;
+    expect(hints.urgency).toBe("medium");
+    // --urgent still flips requiresAction since no explicit flag was passed.
+    expect(hints.requiresAction).toBe(true);
+  });
+
+  test("explicit --no-requires-action wins even when --urgent is passed", async () => {
+    const { exitCode } = await runCommand([
+      "send",
+      "--message",
+      "fyi only",
+      "--urgent",
+      "--no-requires-action",
+    ]);
+
+    expect(exitCode).toBe(0);
+    const hints = lastSendBody().attentionHints as Record<string, unknown>;
+    expect(hints.urgency).toBe("critical");
+    expect(hints.requiresAction).toBe(false);
   });
 });
 
@@ -342,7 +484,9 @@ describe("notifications list", () => {
     expect(parsed.ok).toBe(true);
 
     expect(ipcCalls).toHaveLength(1);
-    expect((ipcCalls[0].params?.body as Record<string, unknown>)?.limit).toBe(5);
+    expect((ipcCalls[0].params?.body as Record<string, unknown>)?.limit).toBe(
+      5,
+    );
   });
 
   test("list passes --source-event-name to IPC", async () => {
@@ -371,8 +515,37 @@ describe("notifications list", () => {
 
     const { parsed, exitCode } = await runCommand(["list"]);
 
-    expect(exitCode).toBe(1);
+    // Transport failure (no statusCode) maps to exit 10 per exitCodeFromIpcResult.
+    expect(exitCode).toBe(10);
     expect(parsed.ok).toBe(false);
     expect(parsed.error).toContain("Could not connect");
   });
+
+  test("list maps daemon 4xx to exit 2", async () => {
+    ipcResponse = {
+      ok: false,
+      error: "Invalid limit",
+      statusCode: 400,
+    };
+
+    const { parsed, exitCode } = await runCommand(["list"]);
+
+    expect(exitCode).toBe(2);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.error).toBe("Invalid limit");
+  });
+
+  test("list maps daemon 5xx to exit 3", async () => {
+    ipcResponse = {
+      ok: false,
+      error: "Internal daemon error",
+      statusCode: 500,
+    };
+
+    const { parsed, exitCode } = await runCommand(["list"]);
+
+    expect(exitCode).toBe(3);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.error).toBe("Internal daemon error");
+  });
 });