@vellumai/assistant 0.8.2 → 0.8.4

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/conversations.ts

@@ -2,10 +2,15 @@ import { existsSync, readFileSync } from "node:fs";
 
 import type { Command } from "commander";
 
-import { cliIpcCall, exitFromIpcResult } from "../../ipc/cli-client.js";
+import {
+  cliIpcCall,
+  exitCodeFromIpcResult,
+  exitFromIpcResult,
+} from "../../ipc/cli-client.js";
 import { registerCommand } from "../lib/register-command.js";
 import { timeAgo } from "../lib/time-ago.js";
 import { log } from "../logger.js";
+import { tryResolveConversationId } from "../utils/conversation-id.js";
 import { registerConversationsDeferCommand } from "./conversations-defer.js";
 import { registerConversationsImportCommand } from "./conversations-import.js";
 
@@ -14,6 +19,23 @@ type ConversationSeedMessage = {
   content: string;
 };
 
+type SlackDetachCliResult = {
+  detached: boolean;
+  channelId: string;
+  threadTs: string;
+  source: "explicit" | "conversation_binding";
+  conversationId?: string;
+};
+
+function outputSlackDetachError(message: string, json?: boolean): void {
+  if (json) {
+    process.stdout.write(JSON.stringify({ ok: false, error: message }) + "\n");
+  } else {
+    log.error(`Error: ${message}`);
+  }
+  process.exitCode = 1;
+}
+
 function readSeedMessages(
   contentFile?: string,
 ): ConversationSeedMessage[] | undefined {
@@ -318,6 +340,111 @@ Examples:
           },
         );
 
+      // -------------------------------------------------------------------
+      // slack
+      // -------------------------------------------------------------------
+
+      const slack = conversations
+        .command("slack")
+        .description("Manage Slack conversation bindings");
+
+      slack
+        .command("detach [conversationId]")
+        .alias("mute")
+        .description("Detach the assistant from a Slack thread")
+        .option("--channel <id>", "Slack channel ID")
+        .option("--thread <ts>", "Slack thread timestamp")
+        .option("--json", "Output result as JSON")
+        .addHelpText(
+          "after",
+          `
+Arguments:
+  conversationId   Optional conversation ID. Defaults to the current skill or
+                   tool conversation when available.
+
+Detaches the assistant from Socket Mode listening for the Slack thread bound
+to a conversation, or for explicit --channel and --thread identifiers.
+
+Examples:
+  $ assistant conversations slack detach
+  $ assistant conversations slack detach conv-123
+  $ assistant conversations slack mute --channel C123 --thread 1700000000.000100
+  $ assistant conversations slack detach --json`,
+        )
+        .action(
+          async (
+            conversationIdArg: string | undefined,
+            opts: { channel?: string; thread?: string; json?: boolean },
+          ) => {
+            const channelId = opts.channel?.trim();
+            const threadTs = opts.thread?.trim();
+            const hasExplicitSlackTarget =
+              opts.channel !== undefined || opts.thread !== undefined;
+            const body: Record<string, string> = {};
+
+            if (hasExplicitSlackTarget) {
+              if (!channelId || !threadTs) {
+                outputSlackDetachError(
+                  "Both --channel and --thread are required when using explicit Slack identifiers.",
+                  opts.json,
+                );
+                return;
+              }
+              body.channelId = channelId;
+              body.threadTs = threadTs;
+            } else {
+              const conversationId = tryResolveConversationId({
+                explicit: conversationIdArg,
+              });
+              if (!conversationId) {
+                outputSlackDetachError(
+                  "No conversation ID available. Pass a conversation ID, provide --channel and --thread, or run this command from a skill or bash tool context.",
+                  opts.json,
+                );
+                return;
+              }
+              body.conversationId = conversationId;
+            }
+
+            const result = await cliIpcCall<SlackDetachCliResult>(
+              "conversation_slack_detach_cli",
+              { body },
+            );
+
+            if (!result.ok) {
+              if (opts.json) {
+                process.stdout.write(
+                  JSON.stringify({
+                    ok: false,
+                    error: result.error ?? "Failed to detach Slack thread",
+                  }) + "\n",
+                );
+                process.exitCode = exitCodeFromIpcResult(result);
+                return;
+              }
+              return exitFromIpcResult(result);
+            }
+
+            const detach = result.result!;
+            if (opts.json) {
+              process.stdout.write(
+                JSON.stringify({ ok: true, result: detach }) + "\n",
+              );
+              return;
+            }
+
+            if (detach.detached) {
+              log.info(
+                `Detached Slack thread ${detach.threadTs} in channel ${detach.channelId} from assistant listening.`,
+              );
+            } else {
+              log.info(
+                `Slack thread ${detach.threadTs} in channel ${detach.channelId} was already detached from assistant listening.`,
+              );
+            }
+          },
+        );
+
       // -------------------------------------------------------------------
       // clear
       // -------------------------------------------------------------------