@vellumai/assistant 0.8.2 → 0.8.3

package/src/cli/commands/__tests__/schedules.test.ts

@@ -99,6 +99,11 @@ describe("schedules command", () => {
     expect(schedules!.commands.map((command) => command.name())).toEqual([
       "list",
       "runs",
+      "create",
+      "enable",
+      "disable",
+      "cancel",
+      "delete",
       "execute",
     ]);
   });
@@ -361,6 +366,470 @@ describe("schedules runs", () => {
   });
 });
 
+describe("schedules create", () => {
+  test("calls createSchedule with the required fields", async () => {
+    mockIpcResult = { ok: true, result: { schedules: [] } };
+
+    const { exitCode } = await runCommand([
+      "schedules",
+      "create",
+      "Heartbeat",
+      "--expression",
+      "*/30 * * * *",
+      "--message",
+      "run heartbeat",
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(ipcCalls).toEqual([
+      {
+        method: "createSchedule",
+        params: {
+          body: {
+            name: "Heartbeat",
+            expression: "*/30 * * * *",
+            message: "run heartbeat",
+            enabled: true,
+          },
+        },
+      },
+    ]);
+    expect(logLines).toEqual(["Created schedule: Heartbeat"]);
+  });
+
+  test("passes --timezone through to the request body", async () => {
+    mockIpcResult = { ok: true, result: { schedules: [] } };
+
+    const { exitCode } = await runCommand([
+      "schedules",
+      "create",
+      "Morning",
+      "--expression",
+      "0 9 * * MON-FRI",
+      "--message",
+      "morning summary",
+      "--timezone",
+      "America/New_York",
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(ipcCalls).toEqual([
+      {
+        method: "createSchedule",
+        params: {
+          body: {
+            name: "Morning",
+            expression: "0 9 * * MON-FRI",
+            message: "morning summary",
+            enabled: true,
+            timezone: "America/New_York",
+          },
+        },
+      },
+    ]);
+  });
+
+  test("sends enabled:false when --no-enabled is set", async () => {
+    mockIpcResult = { ok: true, result: { schedules: [] } };
+
+    const { exitCode } = await runCommand([
+      "schedules",
+      "create",
+      "Drafted",
+      "--expression",
+      "0 0 * * *",
+      "--message",
+      "placeholder",
+      "--no-enabled",
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(ipcCalls).toEqual([
+      {
+        method: "createSchedule",
+        params: {
+          body: {
+            name: "Drafted",
+            expression: "0 0 * * *",
+            message: "placeholder",
+            enabled: false,
+          },
+        },
+      },
+    ]);
+  });
+
+  test("emits JSON when --json is set", async () => {
+    mockIpcResult = {
+      ok: true,
+      result: {
+        schedules: [
+          {
+            id: "new-schedule-id",
+            name: "Heartbeat",
+            enabled: true,
+            syntax: "cron",
+            expression: "*/30 * * * *",
+            cronExpression: "*/30 * * * *",
+            timezone: null,
+            message: "run heartbeat",
+            script: null,
+            nextRunAt: 1_778_800_000_000,
+            lastRunAt: null,
+            lastStatus: null,
+            retryCount: 0,
+            maxRetries: 3,
+            retryBackoffMs: 60_000,
+            description: "Every 30 minutes",
+            mode: "execute",
+            status: "active",
+            routingIntent: "all_channels",
+            reuseConversation: false,
+            wakeConversationId: null,
+            isOneShot: false,
+          },
+        ],
+      },
+    };
+
+    const { stdout, exitCode } = await runCommand([
+      "schedules",
+      "create",
+      "Heartbeat",
+      "--expression",
+      "*/30 * * * *",
+      "--message",
+      "run heartbeat",
+      "--json",
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(JSON.parse(stdout)).toEqual({
+      schedules: [expect.objectContaining({ id: "new-schedule-id" })],
+    });
+    expect(logLines).toEqual([]);
+  });
+
+  test("routes IPC failure through exitFromIpcResult", async () => {
+    mockIpcResult = {
+      ok: false,
+      error: "expression could not be parsed as cron or rrule",
+    };
+
+    const { exitCode } = await runCommand([
+      "schedules",
+      "create",
+      "Bad",
+      "--expression",
+      "not-a-cron",
+      "--message",
+      "noop",
+    ]);
+
+    expect(exitCode).toBe(10);
+    expect(exitFromIpcResultCalls).toEqual([mockIpcResult]);
+    expect(errorLines).toEqual([]);
+  });
+});
+
+describe("schedules enable/disable", () => {
+  test("enable calls toggleSchedule with enabled true", async () => {
+    mockIpcResult = { ok: true, result: { schedules: [] } };
+
+    const { exitCode } = await runCommand([
+      "schedules",
+      "enable",
+      "schedule-1",
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(ipcCalls).toEqual([
+      {
+        method: "toggleSchedule",
+        params: {
+          pathParams: { id: "schedule-1" },
+          body: { enabled: true },
+        },
+      },
+    ]);
+    expect(logLines).toEqual(["Enabled schedule: schedule-1"]);
+  });
+
+  test("disable calls toggleSchedule with enabled false", async () => {
+    mockIpcResult = { ok: true, result: { schedules: [] } };
+
+    const { exitCode } = await runCommand([
+      "schedules",
+      "disable",
+      "schedule-1",
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(ipcCalls).toEqual([
+      {
+        method: "toggleSchedule",
+        params: {
+          pathParams: { id: "schedule-1" },
+          body: { enabled: false },
+        },
+      },
+    ]);
+    expect(logLines).toEqual(["Disabled schedule: schedule-1"]);
+  });
+
+  test("emits JSON result when --json is set", async () => {
+    mockIpcResult = {
+      ok: true,
+      result: {
+        schedules: [
+          {
+            id: "schedule-1",
+            name: "Heartbeat",
+            enabled: false,
+            syntax: "cron",
+            expression: "*/30 * * * *",
+            cronExpression: "*/30 * * * *",
+            timezone: "UTC",
+            message: "run heartbeat",
+            script: null,
+            nextRunAt: 1_778_800_000_000,
+            lastRunAt: null,
+            lastStatus: "ok",
+            retryCount: 0,
+            maxRetries: 3,
+            retryBackoffMs: 60_000,
+            description: "Every 30 minutes",
+            mode: "execute",
+            status: "active",
+            routingIntent: "all_channels",
+            reuseConversation: false,
+            wakeConversationId: null,
+            isOneShot: false,
+          },
+        ],
+      },
+    };
+
+    const { stdout, exitCode } = await runCommand([
+      "schedules",
+      "disable",
+      "schedule-1",
+      "--json",
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(JSON.parse(stdout)).toEqual({
+      schedules: [
+        expect.objectContaining({ id: "schedule-1", enabled: false }),
+      ],
+    });
+    expect(logLines).toEqual([]);
+  });
+
+  test("routes IPC failure through exitFromIpcResult", async () => {
+    mockIpcResult = { ok: false, error: "Schedule not found" };
+
+    const { exitCode } = await runCommand([
+      "schedules",
+      "enable",
+      "missing-schedule",
+    ]);
+
+    expect(exitCode).toBe(10);
+    expect(exitFromIpcResultCalls).toEqual([mockIpcResult]);
+    expect(errorLines).toEqual([]);
+  });
+});
+
+describe("schedules cancel", () => {
+  test("calls cancelSchedule with the schedule ID path param", async () => {
+    mockIpcResult = { ok: true, result: { schedules: [] } };
+
+    const { exitCode } = await runCommand([
+      "schedules",
+      "cancel",
+      "schedule-1",
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(ipcCalls).toEqual([
+      {
+        method: "cancelSchedule",
+        params: { pathParams: { id: "schedule-1" } },
+      },
+    ]);
+    expect(logLines).toEqual(["Cancelled schedule: schedule-1"]);
+  });
+
+  test("emits JSON result when --json is set", async () => {
+    mockIpcResult = {
+      ok: true,
+      result: {
+        schedules: [
+          {
+            id: "remaining-schedule",
+            name: "Heartbeat",
+            enabled: true,
+            syntax: "cron",
+            expression: "*/30 * * * *",
+            cronExpression: "*/30 * * * *",
+            timezone: "UTC",
+            message: "run heartbeat",
+            script: null,
+            nextRunAt: 1_778_800_000_000,
+            lastRunAt: null,
+            lastStatus: "ok",
+            retryCount: 0,
+            maxRetries: 3,
+            retryBackoffMs: 60_000,
+            description: "Every 30 minutes",
+            mode: "execute",
+            status: "active",
+            routingIntent: "all_channels",
+            reuseConversation: false,
+            wakeConversationId: null,
+            isOneShot: false,
+          },
+        ],
+      },
+    };
+
+    const { stdout, exitCode } = await runCommand([
+      "schedules",
+      "cancel",
+      "schedule-1",
+      "--json",
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(JSON.parse(stdout)).toEqual({
+      schedules: [expect.objectContaining({ id: "remaining-schedule" })],
+    });
+    expect(logLines).toEqual([]);
+  });
+
+  test("routes IPC failure through exitFromIpcResult", async () => {
+    mockIpcResult = {
+      ok: false,
+      error: "Schedule not found or not cancellable",
+    };
+
+    const { exitCode } = await runCommand([
+      "schedules",
+      "cancel",
+      "missing-schedule",
+    ]);
+
+    expect(exitCode).toBe(10);
+    expect(exitFromIpcResultCalls).toEqual([mockIpcResult]);
+    expect(errorLines).toEqual([]);
+  });
+});
+
+describe("schedules delete", () => {
+  test("calls deleteSchedule with the schedule ID path param when --force is set", async () => {
+    mockIpcResult = { ok: true, result: { schedules: [] } };
+
+    const { exitCode } = await runCommand([
+      "schedules",
+      "delete",
+      "schedule-1",
+      "--force",
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(ipcCalls).toEqual([
+      {
+        method: "deleteSchedule",
+        params: { pathParams: { id: "schedule-1" } },
+      },
+    ]);
+    expect(logLines).toEqual(["Deleted schedule: schedule-1"]);
+  });
+
+  test("emits JSON result when --json is set with --force", async () => {
+    mockIpcResult = {
+      ok: true,
+      result: {
+        schedules: [
+          {
+            id: "remaining-schedule",
+            name: "Heartbeat",
+            enabled: true,
+            syntax: "cron",
+            expression: "*/30 * * * *",
+            cronExpression: "*/30 * * * *",
+            timezone: "UTC",
+            message: "run heartbeat",
+            script: null,
+            nextRunAt: 1_778_800_000_000,
+            lastRunAt: null,
+            lastStatus: "ok",
+            retryCount: 0,
+            maxRetries: 3,
+            retryBackoffMs: 60_000,
+            description: "Every 30 minutes",
+            mode: "execute",
+            status: "active",
+            routingIntent: "all_channels",
+            reuseConversation: false,
+            wakeConversationId: null,
+            isOneShot: false,
+          },
+        ],
+      },
+    };
+
+    const { stdout, exitCode } = await runCommand([
+      "schedules",
+      "delete",
+      "schedule-1",
+      "--force",
+      "--json",
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(JSON.parse(stdout)).toEqual({
+      schedules: [expect.objectContaining({ id: "remaining-schedule" })],
+    });
+    expect(logLines).toEqual([]);
+  });
+
+  test("routes IPC failure through exitFromIpcResult", async () => {
+    mockIpcResult = {
+      ok: false,
+      error: "Schedule not found",
+    };
+
+    const { exitCode } = await runCommand([
+      "schedules",
+      "delete",
+      "missing-schedule",
+      "--force",
+    ]);
+
+    expect(exitCode).toBe(10);
+    expect(exitFromIpcResultCalls).toEqual([mockIpcResult]);
+    expect(errorLines).toEqual([]);
+  });
+
+  test("refuses to delete non-interactively without --force", async () => {
+    // bun's test runner attaches a non-TTY stdin, so confirmPrompt takes the
+    // non-interactive branch and the IPC is never invoked. This locks in the
+    // safety guarantee that scripts must opt in via --force.
+    mockIpcResult = { ok: true, result: { schedules: [] } };
+
+    const { exitCode } = await runCommand([
+      "schedules",
+      "delete",
+      "schedule-1",
+    ]);
+
+    expect(exitCode).toBe(1);
+    expect(ipcCalls).toEqual([]);
+  });
+});
+
 describe("schedules execute", () => {
   test("calls runScheduleNow with the schedule ID path param", async () => {
     mockIpcResult = {

package/src/cli/commands/notifications.ts

@@ -1,6 +1,10 @@
 import type { Command } from "commander";
 
-import { cliIpcCall } from "../../ipc/cli-client.js";
+import {
+  cliIpcCall,
+  exitCodeFromIpcResult,
+  exitFromIpcResult,
+} from "../../ipc/cli-client.js";
 import { registerCommand } from "../lib/register-command.js";
 import { log } from "../logger.js";
 import { shouldOutputJson, writeOutput } from "../output.js";
@@ -26,11 +30,14 @@ source channel, event name, and attention hints. The decision engine evaluates
 whether and where to deliver the notification based on connected channels,
 urgency, and user preferences.
 
+Minimal usage: only --message is required. Add --urgent for a push + visual
+flag in the inbox. Source channel/event name fall back to assistant_tool /
+assistant.share when omitted.
+
 Examples:
-  $ assistant notifications send --source-channel assistant_tool --source-event-name user.send_notification --message "Build finished"
-  $ assistant notifications send --source-channel scheduler --source-event-name schedule.notify --message "Stand-up in 5 minutes" --urgency high
-  $ assistant notifications send --source-channel watcher --source-event-name watcher.notification --message "File changed" --no-requires-action --is-async-background
-  $ assistant notifications send --source-channel assistant_tool --source-event-name user.send_notification --message "Deploy complete" --preferred-channels vellum,telegram --json`,
+  $ assistant notifications send --message "Build finished"
+  $ assistant notifications send --message "Pager: prod is down" --urgent
+  $ assistant notifications send --message "Build green" --conversation-id 649c4645-3a6f-4ded-a713-504f02ca806b`,
       );
 
       // -------------------------------------------------------------------------
@@ -40,28 +47,33 @@ Examples:
       notifications
         .command("send")
         .description(
-          "Send a notification through the unified notification router",
+          "Send a notification through the unified notification router. Only --message is required; pass --urgent for a push + visual flag.",
         )
         .requiredOption(
+          "--message <message>",
+          "Notification message the user should receive",
+        )
+        .option(
+          "--urgent",
+          "Mark this notification as urgent (fires push + visual flag in inbox)",
+          false,
+        )
+        .option(
           "--source-channel <channel>",
-          "Source channel producing this notification",
+          "Source channel producing this notification (default: assistant_tool)",
         )
-        .requiredOption(
+        .option(
           "--source-event-name <name>",
-          "Event name for audit, routing, and dedupe grouping",
-        )
-        .requiredOption(
-          "--message <message>",
-          "Notification message the user should receive",
+          "Event name for audit, routing, and dedupe grouping (default: assistant.share)",
         )
         .option("--title <title>", "Optional notification title")
         .option(
           "--urgency <urgency>",
-          "Urgency hint: low, medium, high, critical (default: medium)",
+          "Urgency hint: low, medium, high, critical (default: low; use --urgent for critical)",
         )
         .option(
           "--requires-action",
-          "Whether the notification expects user action (default: true)",
+          "Whether the notification expects user action (default: false; use --urgent to force true)",
         )
         .option(
           "--no-requires-action",
@@ -111,15 +123,16 @@ Examples:
           "after",
           `
 Arguments:
-  --source-channel     One of the registered source channels (see "assistant notifications --help")
-  --source-event-name  One of the registered event names (see "assistant notifications --help")
   --message            The notification body text (required, must be non-empty)
+  --urgent             Shortcut that maps to urgency=critical + requires-action=true
 
 Behavioral notes:
   - The signal is emitted through the full notification pipeline: event store,
     decision engine, deterministic checks, and channel dispatch.
-  - --requires-action defaults to true; use --no-requires-action to disable.
-  - --urgency defaults to medium if not specified.
+  - --urgent overrides --urgency and --requires-action defaults so the signal
+    is treated as critical and requires user action. Explicit --urgency /
+    --requires-action flags still win for back-compat.
+  - Without --urgent, --urgency defaults to low and --requires-action to false.
   - --preferred-channels are hints only; the decision engine may override them.
   - --dedupe-key suppresses duplicate signals with the same key.
   - --conversation-id pins delivery to an existing vellum conversation
@@ -127,20 +140,20 @@ Behavioral notes:
     binding-based pairing for their external threads.
 
 Examples:
-  $ assistant notifications send --source-channel assistant_tool --source-event-name user.send_notification --message "Task complete"
-  $ assistant notifications send --source-channel scheduler --source-event-name schedule.notify --message "Meeting in 5 min" --urgency high --title "Reminder"
-  $ assistant notifications send --source-channel watcher --source-event-name watcher.notification --message "Detected change" --no-requires-action --is-async-background --json
-  $ assistant notifications send --source-channel assistant_tool --source-event-name user.send_notification --message "Build green" --conversation-id 649c4645-3a6f-4ded-a713-504f02ca806b`,
+  $ assistant notifications send --message "Task complete"
+  $ assistant notifications send --message "Pager: prod is down" --urgent
+  $ assistant notifications send --message "Build green" --conversation-id 649c4645-3a6f-4ded-a713-504f02ca806b`,
         )
         .action(
           async (
             opts: {
-              sourceChannel: string;
-              sourceEventName: string;
+              sourceChannel?: string;
+              sourceEventName?: string;
               message: string;
+              urgent: boolean;
               title?: string;
               urgency?: string;
-              requiresAction: boolean;
+              requiresAction?: boolean;
               isAsyncBackground: boolean;
               visibleInSourceNow: boolean;
               deadlineAt?: string;
@@ -153,6 +166,11 @@ Examples:
             cmd: Command,
           ) => {
             try {
+              // Apply defaults for optional source fields (minimal-surface
+              // ergonomics; explicit values from the CLI still win).
+              const sourceChannel = opts.sourceChannel ?? "assistant_tool";
+              const sourceEventName = opts.sourceEventName ?? "assistant.share";
+
               // Validate --message (keep basic validation for immediate CLI feedback)
               const message = opts.message.trim();
               if (message.length === 0) {
@@ -164,8 +182,15 @@ Examples:
                 return;
               }
 
+              // --urgent is a shortcut for urgency=critical + requiresAction=true.
+              // Explicit --urgency / --requires-action flags still win so the
+              // back-compat path keeps working during the deprecation window.
+              const urgentDefaults = opts.urgent
+                ? { urgency: "critical", requiresAction: true }
+                : { urgency: "low", requiresAction: false };
+
               // Validate --urgency
-              const urgency = opts.urgency ?? "medium";
+              const urgency = opts.urgency ?? urgentDefaults.urgency;
               if (
                 urgency !== "low" &&
                 urgency !== "medium" &&
@@ -179,6 +204,8 @@ Examples:
                 process.exitCode = 1;
                 return;
               }
+              const requiresAction =
+                opts.requiresAction ?? urgentDefaults.requiresAction;
 
               // Parse --deadline-at
               let deadlineAt: number | undefined;
@@ -241,11 +268,11 @@ Examples:
                 reason: string;
               }>("emit_notification_signal", {
                 body: {
-                  sourceChannel: opts.sourceChannel,
-                  sourceEventName: opts.sourceEventName,
+                  sourceChannel,
+                  sourceEventName,
                   sourceContextId,
                   attentionHints: {
-                    requiresAction: opts.requiresAction ?? true,
+                    requiresAction,
                     urgency,
                     deadlineAt,
                     isAsyncBackground: opts.isAsyncBackground ?? false,
@@ -253,7 +280,7 @@ Examples:
                   },
                   contextPayload: {
                     requestedMessage: message,
-                    requestedBySource: opts.sourceChannel,
+                    requestedBySource: sourceChannel,
                     ...(opts.title ? { requestedTitle: opts.title } : {}),
                     ...(preferredChannels?.length ? { preferredChannels } : {}),
                     ...(deepLinkMetadata ? { deepLinkMetadata } : {}),
@@ -267,9 +294,12 @@ Examples:
               });
 
               if (!result.ok) {
-                writeOutput(cmd, { ok: false, error: result.error });
-                process.exitCode = 1;
-                return;
+                if (shouldOutputJson(cmd)) {
+                  writeOutput(cmd, { ok: false, error: result.error });
+                  process.exitCode = exitCodeFromIpcResult(result);
+                  return;
+                }
+                return exitFromIpcResult(result);
               }
 
               const signal = result.result!;
@@ -382,7 +412,7 @@ Examples:
 
               if (!result.ok) {
                 writeOutput(cmd, { ok: false, error: result.error });
-                process.exitCode = 1;
+                process.exitCode = exitCodeFromIpcResult(result);
                 return;
               }