@vellumai/assistant 0.8.2 → 0.8.3

package/src/cli/commands/plugins.ts

@@ -19,6 +19,10 @@ import {
 } from "../lib/install-from-github.js";
 import { listInstalledPlugins } from "../lib/list-installed-plugins.js";
 import { registerCommand } from "../lib/register-command.js";
+import {
+  InvalidSearchPatternError,
+  searchPlugins,
+} from "../lib/search-plugins.js";
 import {
   PluginNotInstalledError,
   uninstallPlugin,
@@ -42,6 +46,9 @@ Examples:
   $ assistant plugins install simple-memory --ref my-feature-branch
   $ assistant plugins list
   $ assistant plugins list --json
+  $ assistant plugins search memory
+  $ assistant plugins search "^simple"
+  $ assistant plugins search memory --json
   $ assistant plugins uninstall simple-memory`,
       );
 
@@ -134,6 +141,66 @@ Examples:
           );
         });
 
+      plugins
+        .command("search <query>")
+        .description(
+          "Search vellum-ai/vellum-assistant/experimental/plugins for plugin names matching <query> (case-insensitive regex)",
+        )
+        .option("--json", "Emit machine-readable JSON instead of a table")
+        .action(async (query: string, opts: { json?: boolean }) => {
+          try {
+            const result = await searchPlugins(
+              { query },
+              { fetch: globalThis.fetch.bind(globalThis) },
+            );
+
+            // Log on every success path — JSON output, empty results, and
+            // populated tables alike — so observability doesn't depend on
+            // which formatting branch the caller landed in.
+            log.info(
+              {
+                query: result.query,
+                ref: result.ref,
+                matchCount: result.matches.length,
+              },
+              "external plugin search",
+            );
+
+            if (opts.json) {
+              process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+              return;
+            }
+
+            if (result.matches.length === 0) {
+              console.log(`No plugins matched "${result.query}".`);
+              return;
+            }
+
+            const nameW = Math.max(
+              4,
+              ...result.matches.map((m) => m.name.length),
+            );
+            const pad = (s: string, w: number) => s + " ".repeat(w - s.length);
+            console.log(`${pad("NAME", nameW)}  PATH`);
+            for (const m of result.matches) {
+              console.log(`${pad(m.name, nameW)}  ${m.path}`);
+            }
+            console.log("");
+            console.log(
+              `${result.matches.length} match${result.matches.length === 1 ? "" : "es"} for "${result.query}".`,
+            );
+          } catch (err) {
+            if (err instanceof InvalidSearchPatternError) {
+              console.error(err.message);
+              process.exitCode = 1;
+              return;
+            }
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(`Plugin search failed: ${message}`);
+            process.exitCode = 1;
+          }
+        });
+
       plugins
         .command("uninstall <name>")
         .description("Remove a plugin from <workspaceDir>/plugins/<name>/")

package/src/cli/commands/schedules.ts

@@ -1,6 +1,7 @@
 import type { Command } from "commander";
 
 import { cliIpcCall, exitFromIpcResult } from "../../ipc/cli-client.js";
+import { confirmPrompt } from "../lib/confirm-prompt.js";
 import { registerCommand } from "../lib/register-command.js";
 import { log } from "../logger.js";
 import { writeOutput } from "../output.js";
@@ -60,18 +61,21 @@ export function registerSchedulesCommand(program: Command): void {
       schedules.addHelpText(
         "after",
         `
-Schedules are recurring or one-shot jobs run by the assistant daemon.
+Schedules are recurring or one-shot jobs run by the assistant.
 
 This CLI namespace is intentionally landing incrementally. Today it supports
-listing schedules, viewing recent run history, and manually executing a schedule
-one time; create, delete, enable/disable, and run inspection will follow as
-separate slices.
+listing schedules, viewing recent run history, enabling/disabling schedules,
+manually executing a schedule one time, and cancelling pending one-shot schedules;
+create, delete, and run inspection will follow as separate slices.
 
 Examples:
   $ assistant schedules list
   $ assistant schedules list --all
   $ assistant schedules runs <schedule-id>
   $ assistant schedules runs <schedule-id> --limit 25 --json
+  $ assistant schedules disable <schedule-id>
+  $ assistant schedules enable <schedule-id>
+  $ assistant schedules cancel <schedule-id>
   $ assistant schedules execute <schedule-id>`,
       );
 
@@ -203,7 +207,7 @@ Examples:
           "after",
           `
 Options:
-  --limit <count>   Max runs to return. The daemon clamps values to 1-100.
+  --limit <count>   Max runs to return. The assistant clamps values to 1-100.
   --json            Output the raw run list as compact JSON.
 
 Arguments:
@@ -307,6 +311,271 @@ Examples:
           },
         );
 
+      schedules
+        .command("create <name>")
+        .description("Create a new recurring schedule")
+        .requiredOption(
+          "-e, --expression <expr>",
+          "Cron or RRULE expression that schedules the fire times",
+        )
+        .requiredOption(
+          "-m, --message <text>",
+          "Message body sent to the assistant on each fire",
+        )
+        .option(
+          "-t, --timezone <tz>",
+          "IANA timezone for the expression (e.g. America/New_York)",
+        )
+        .option("--no-enabled", "Create the schedule in a disabled state")
+        .option("--json", "Machine-readable compact JSON output")
+        .addHelpText(
+          "after",
+          `
+Options:
+  -e, --expression <expr>   Cron (e.g. '*/30 * * * *') or RRULE expression.
+  -m, --message <text>      Message body sent on each fire.
+  -t, --timezone <tz>       IANA timezone applied to the expression.
+  --no-enabled              Create the schedule disabled. Defaults to enabled.
+  --json                    Output the updated schedule list as compact JSON.
+
+Arguments:
+  <name>   Display name for the schedule.
+
+Behavior:
+  Creates a recurring schedule in 'execute' mode. The IPC endpoint is
+  currently locked to execute mode; notify/script/wake schedules remain
+  reachable only through the in-assistant schedule_create LLM tool.
+
+Examples:
+  $ assistant schedules create "Heartbeat" \\
+      --expression '*/30 * * * *' \\
+      --message 'run heartbeat'
+  $ assistant schedules create "Morning summary" \\
+      --expression '0 9 * * MON-FRI' \\
+      --timezone America/New_York \\
+      --message 'write the morning summary'
+  $ assistant schedules create "Drafted" \\
+      --expression '0 0 * * *' \\
+      --message 'placeholder' \\
+      --no-enabled --json`,
+        )
+        .action(
+          async (
+            name: string,
+            opts: {
+              expression: string;
+              message: string;
+              timezone?: string;
+              enabled: boolean;
+              json?: boolean;
+            },
+            cmd: Command,
+          ) => {
+            const scheduleName = name.trim();
+            if (!scheduleName) {
+              const error = "name is required";
+              if (opts.json) {
+                writeOutput(cmd, { ok: false, error });
+              } else {
+                log.error(error);
+              }
+              process.exitCode = 1;
+              return;
+            }
+
+            const body: Record<string, unknown> = {
+              name: scheduleName,
+              expression: opts.expression,
+              message: opts.message,
+              enabled: opts.enabled,
+            };
+            if (opts.timezone != null) body.timezone = opts.timezone;
+
+            const result = await cliIpcCall<ListSchedulesResponse>(
+              "createSchedule",
+              { body },
+            );
+
+            if (!result.ok) return exitFromIpcResult(result, cmd);
+
+            const response = result.result ?? { schedules: [] };
+            if (opts.json) {
+              writeOutput(cmd, response);
+              return;
+            }
+
+            log.info(`Created schedule: ${scheduleName}`);
+          },
+        );
+
+      schedules
+        .command("enable <id>")
+        .description("Enable a schedule")
+        .option("--json", "Machine-readable compact JSON output")
+        .addHelpText(
+          "after",
+          `
+Options:
+  --json   Output the updated schedule list as compact JSON.
+
+Arguments:
+  <id>   Schedule ID (UUID) — run 'assistant schedules list --all' to find it.
+
+Behavior:
+  Enables the schedule so it can run on future matching times. This does not
+  execute the schedule immediately; use 'assistant schedules execute <id>' for
+  manual run-now behavior.
+
+Examples:
+  $ assistant schedules enable 9f2c4f3a-3f1a-41e4-88e7-abc123
+  $ assistant schedules enable 9f2c4f3a-3f1a-41e4-88e7-abc123 --json`,
+        )
+        .action(async (id: string, opts: { json?: boolean }, cmd: Command) => {
+          await toggleScheduleEnabled(id, true, opts, cmd);
+        });
+
+      schedules
+        .command("disable <id>")
+        .description("Disable a schedule")
+        .option("--json", "Machine-readable compact JSON output")
+        .addHelpText(
+          "after",
+          `
+Options:
+  --json   Output the updated schedule list as compact JSON.
+
+Arguments:
+  <id>   Schedule ID (UUID) — run 'assistant schedules list --all' to find it.
+
+Behavior:
+  Disables the schedule so future scheduled fires are skipped until it is
+  enabled again. Existing run history is preserved.
+
+Examples:
+  $ assistant schedules disable 9f2c4f3a-3f1a-41e4-88e7-abc123
+  $ assistant schedules disable 9f2c4f3a-3f1a-41e4-88e7-abc123 --json`,
+        )
+        .action(async (id: string, opts: { json?: boolean }, cmd: Command) => {
+          await toggleScheduleEnabled(id, false, opts, cmd);
+        });
+
+      schedules
+        .command("cancel <id>")
+        .description("Cancel a pending one-shot schedule")
+        .option("--json", "Machine-readable compact JSON output")
+        .addHelpText(
+          "after",
+          `
+Options:
+  --json   Output the updated schedule list as compact JSON.
+
+Arguments:
+  <id>   Schedule ID (UUID) — run 'assistant schedules list --all' to find
+         pending one-shot/deferred schedules.
+
+Behavior:
+  Cancels a pending one-shot schedule. Recurring schedules are not cancellable;
+  use 'assistant schedules disable <id>' to pause recurring schedules.
+
+Examples:
+  $ assistant schedules cancel 9f2c4f3a-3f1a-41e4-88e7-abc123
+  $ assistant schedules cancel 9f2c4f3a-3f1a-41e4-88e7-abc123 --json`,
+        )
+        .action(async (id: string, opts: { json?: boolean }, cmd: Command) => {
+          const scheduleId = id.trim();
+          const result = await cliIpcCall<ListSchedulesResponse>(
+            "cancelSchedule",
+            { pathParams: { id: scheduleId } },
+          );
+
+          if (!result.ok) return exitFromIpcResult(result, cmd);
+
+          const response = result.result ?? { schedules: [] };
+          if (opts.json) {
+            writeOutput(cmd, response);
+            return;
+          }
+
+          log.info(`Cancelled schedule: ${scheduleId}`);
+        });
+
+      schedules
+        .command("delete <id>")
+        .description("Permanently delete a schedule and its run history")
+        .option("--force", "Skip the confirmation prompt")
+        .option("--json", "Machine-readable compact JSON output")
+        .addHelpText(
+          "after",
+          `
+Options:
+  --force  Skip the destructive y/N confirmation prompt. Required when stdin
+           is not a TTY (e.g. in scripts and CI).
+  --json   Output the updated schedule list as compact JSON.
+
+Arguments:
+  <id>   Schedule ID (UUID) — run 'assistant schedules list --all' to find it.
+
+Behavior:
+  Permanently removes the schedule and its run history. This cannot be undone.
+  To temporarily pause a recurring schedule, use
+  'assistant schedules disable <id>' instead.
+
+Examples:
+  $ assistant schedules delete 9f2c4f3a-3f1a-41e4-88e7-abc123
+  $ assistant schedules delete 9f2c4f3a-3f1a-41e4-88e7-abc123 --force
+  $ assistant schedules delete 9f2c4f3a-3f1a-41e4-88e7-abc123 --force --json`,
+        )
+        .action(
+          async (
+            id: string,
+            opts: { force?: boolean; json?: boolean },
+            cmd: Command,
+          ) => {
+            const scheduleId = id.trim();
+            if (!scheduleId) {
+              const error = "Schedule ID is required";
+              if (opts.json) {
+                writeOutput(cmd, { ok: false, error });
+              } else {
+                log.error(error);
+              }
+              process.exitCode = 1;
+              return;
+            }
+
+            if (!opts.force) {
+              const decision = await confirmPrompt({
+                question: `Delete schedule "${scheduleId}"? [y/N] `,
+                isTTY: Boolean(process.stdin.isTTY),
+                refuseNonInteractiveMessage: `Refusing to delete schedule "${scheduleId}" non-interactively. Pass --force to confirm.`,
+              });
+              if (decision === "non-interactive") {
+                process.exitCode = 1;
+                return;
+              }
+              if (decision === "denied") {
+                log.info("Delete cancelled.");
+                return;
+              }
+            }
+
+            const result = await cliIpcCall<ListSchedulesResponse>(
+              "deleteSchedule",
+              { pathParams: { id: scheduleId } },
+            );
+
+            if (!result.ok) return exitFromIpcResult(result, cmd);
+
+            const response = result.result ?? { schedules: [] };
+            if (opts.json) {
+              writeOutput(cmd, response);
+              return;
+            }
+
+            log.info(`Deleted schedule: ${scheduleId}`);
+          },
+        );
+
       schedules
         .command("execute <id>")
         .description("Execute a schedule one time immediately")
@@ -368,6 +637,29 @@ Examples:
   });
 }
 
+async function toggleScheduleEnabled(
+  id: string,
+  enabled: boolean,
+  opts: { json?: boolean },
+  cmd: Command,
+): Promise<void> {
+  const scheduleId = id.trim();
+  const result = await cliIpcCall<ListSchedulesResponse>("toggleSchedule", {
+    pathParams: { id: scheduleId },
+    body: { enabled },
+  });
+
+  if (!result.ok) return exitFromIpcResult(result, cmd);
+
+  const response = result.result ?? { schedules: [] };
+  if (opts.json) {
+    writeOutput(cmd, response);
+    return;
+  }
+
+  log.info(`${enabled ? "Enabled" : "Disabled"} schedule: ${scheduleId}`);
+}
+
 function describeSchedule(schedule: ScheduleRecord): string {
   if (schedule.isOneShot) return "one-shot";
   const expression = schedule.description ?? schedule.expression ?? "—";

package/src/cli/lib/__tests__/search-plugins.test.ts

@@ -0,0 +1,261 @@
+/**
+ * Tests for {@link searchPlugins}.
+ *
+ * Network is replaced with an in-memory fixture passed via the `fetch`
+ * dependency — no globals are monkey-patched and no `--test-hook` exports
+ * leak into production code.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import {
+  type FetchLike,
+  InvalidSearchPatternError,
+  searchPlugins,
+} from "../search-plugins.js";
+
+/**
+ * Build a GitHub Contents API fixture from an in-memory directory listing.
+ *
+ * `entries` maps each name under `experimental/plugins/` to its `type`. The
+ * fixture answers GET requests against
+ *  - `https://api.github.com/repos/vellum-ai/vellum-assistant/contents/experimental/plugins...`
+ * and returns 500 for anything else (forces test bugs to surface loudly).
+ */
+function fixtureFetch(
+  entries: Record<string, "dir" | "file" | "symlink" | "submodule">,
+): FetchLike {
+  const PREFIX_API =
+    "https://api.github.com/repos/vellum-ai/vellum-assistant/contents/experimental/plugins";
+
+  return (async (input: RequestInfo | URL) => {
+    const url = typeof input === "string" ? input : input.toString();
+    if (!url.startsWith(PREFIX_API)) {
+      return new Response("unexpected url: " + url, { status: 500 });
+    }
+    const body = Object.entries(entries).map(([name, type]) => ({
+      name,
+      path: `experimental/plugins/${name}`,
+      type,
+      size: type === "file" ? 1 : 0,
+      download_url:
+        type === "file"
+          ? `https://raw.githubusercontent.com/vellum-ai/vellum-assistant/main/experimental/plugins/${name}`
+          : null,
+    }));
+    return new Response(JSON.stringify(body), {
+      status: 200,
+      headers: { "content-type": "application/json" },
+    });
+  }) as FetchLike;
+}
+
+describe("searchPlugins", () => {
+  test("matches the query as a case-insensitive regex against directory names", async () => {
+    const result = await searchPlugins(
+      { query: "memory" },
+      {
+        fetch: fixtureFetch({
+          "simple-memory": "dir",
+          "memory-graph": "dir",
+          "git-tools": "dir",
+        }),
+      },
+    );
+
+    expect(result.matches.map((m) => m.name)).toEqual([
+      "memory-graph",
+      "simple-memory",
+    ]);
+    expect(result.matches[0]!.path).toBe("experimental/plugins/memory-graph");
+    expect(result.query).toBe("memory");
+    expect(result.ref).toBe("main");
+  });
+
+  test("matches regardless of query casing (case-insensitive)", async () => {
+    const result = await searchPlugins(
+      { query: "MEMORY" },
+      { fetch: fixtureFetch({ "simple-memory": "dir" }) },
+    );
+    expect(result.matches.map((m) => m.name)).toEqual(["simple-memory"]);
+  });
+
+  test("anchored patterns work without escaping", async () => {
+    const result = await searchPlugins(
+      { query: "^memory-" },
+      {
+        fetch: fixtureFetch({
+          "memory-graph": "dir",
+          "simple-memory": "dir",
+        }),
+      },
+    );
+    expect(result.matches.map((m) => m.name)).toEqual(["memory-graph"]);
+  });
+
+  test("empty query matches all directories", async () => {
+    const result = await searchPlugins(
+      { query: "" },
+      {
+        fetch: fixtureFetch({
+          "simple-memory": "dir",
+          "memory-graph": "dir",
+          "git-tools": "dir",
+        }),
+      },
+    );
+    expect(result.matches.map((m) => m.name)).toEqual([
+      "git-tools",
+      "memory-graph",
+      "simple-memory",
+    ]);
+  });
+
+  test("skips entries that are not directories", async () => {
+    const result = await searchPlugins(
+      { query: "" },
+      {
+        fetch: fixtureFetch({
+          "simple-memory": "dir",
+          "README.md": "file",
+          "broken-symlink": "symlink",
+          "old-plugin": "submodule",
+        }),
+      },
+    );
+    expect(result.matches.map((m) => m.name)).toEqual(["simple-memory"]);
+  });
+
+  test("rejects invalid regex patterns up front (no network call)", async () => {
+    let fetchCalled = false;
+    const fetch: FetchLike = (async () => {
+      fetchCalled = true;
+      return new Response("", { status: 200 });
+    }) as FetchLike;
+
+    await expect(
+      searchPlugins({ query: "(unterminated" }, { fetch }),
+    ).rejects.toBeInstanceOf(InvalidSearchPatternError);
+    expect(fetchCalled).toBe(false);
+  });
+
+  test("empty result set on no matches", async () => {
+    const result = await searchPlugins(
+      { query: "nothing-matches" },
+      { fetch: fixtureFetch({ "simple-memory": "dir" }) },
+    );
+    expect(result.matches).toEqual([]);
+  });
+
+  test("respects `ref` option by forwarding to GitHub", async () => {
+    // The CLI does not surface a `--ref` flag (the source-path convention
+    // may change), but the underlying function keeps `ref` for test
+    // injection and future internal callers.
+    let seenRef: string | undefined;
+    const result = await searchPlugins(
+      { query: "memory", ref: "feat-branch" },
+      {
+        fetch: (async (input: RequestInfo | URL) => {
+          const url = typeof input === "string" ? input : input.toString();
+          const m = /[?&]ref=([^&]+)/.exec(url);
+          seenRef = m ? decodeURIComponent(m[1]!) : undefined;
+          return new Response(
+            JSON.stringify([
+              {
+                name: "simple-memory",
+                path: "experimental/plugins/simple-memory",
+                type: "dir",
+                size: 0,
+                download_url: null,
+              },
+            ]),
+            { status: 200, headers: { "content-type": "application/json" } },
+          );
+        }) as FetchLike,
+      },
+    );
+
+    expect(seenRef).toBe("feat-branch");
+    expect(result.ref).toBe("feat-branch");
+    expect(result.matches.map((m) => m.name)).toEqual(["simple-memory"]);
+  });
+
+  test("HTTP 5xx from GitHub propagates with the status code", async () => {
+    await expect(
+      searchPlugins(
+        { query: "memory" },
+        {
+          fetch: (async () =>
+            new Response("upstream broken", { status: 503 })) as FetchLike,
+        },
+      ),
+    ).rejects.toThrow(/HTTP 503/);
+  });
+
+  test("HTTP 403 (rate-limited / forbidden) surfaces as an error", async () => {
+    await expect(
+      searchPlugins(
+        { query: "memory" },
+        {
+          fetch: (async () =>
+            new Response("rate limit exceeded", { status: 403 })) as FetchLike,
+        },
+      ),
+    ).rejects.toThrow(/HTTP 403/);
+  });
+
+  test("404 on the plugins prefix surfaces as an error (not silently empty)", async () => {
+    // Distinct from `installPlugin`, where 404 on a specific plugin name is
+    // normal "not found". For the search, 404 on the prefix means the
+    // canonical source path itself is gone — that's an upstream problem
+    // worth surfacing, not a clean empty result.
+    await expect(
+      searchPlugins(
+        { query: "memory" },
+        {
+          fetch: (async () =>
+            new Response("not found", { status: 404 })) as FetchLike,
+        },
+      ),
+    ).rejects.toThrow(/HTTP 404/);
+  });
+
+  test("returns matches sorted by name", async () => {
+    const result = await searchPlugins(
+      { query: "" },
+      {
+        fetch: fixtureFetch({
+          "zeta-plugin": "dir",
+          "alpha-plugin": "dir",
+          "mu-plugin": "dir",
+        }),
+      },
+    );
+    expect(result.matches.map((m) => m.name)).toEqual([
+      "alpha-plugin",
+      "mu-plugin",
+      "zeta-plugin",
+    ]);
+  });
+
+  test("sends no Authorization header (canonical source is a public repo)", async () => {
+    let seenAuth: string | undefined;
+    let seenUserAgent: string | undefined;
+    await searchPlugins(
+      { query: "memory" },
+      {
+        fetch: (async (_input: RequestInfo | URL, init?: RequestInit) => {
+          const headers = init?.headers as Record<string, string> | undefined;
+          seenAuth = headers?.Authorization;
+          seenUserAgent = headers?.["User-Agent"];
+          return new Response("[]", {
+            status: 200,
+            headers: { "content-type": "application/json" },
+          });
+        }) as FetchLike,
+      },
+    );
+    expect(seenAuth).toBeUndefined();
+    expect(seenUserAgent).toBe("vellum-assistant-cli");
+  });
+});