@vellumai/assistant 0.4.43 → 0.4.45

package/src/__tests__/scaffold-managed-skill-tool.test.ts

@@ -18,15 +18,9 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-import { ScaffoldManagedSkillTool } from "../tools/skills/scaffold-managed.js";
+import { executeScaffoldManagedSkill } from "../tools/skills/scaffold-managed.js";
 import type { ToolContext } from "../tools/types.js";
 
-// Use internal class directly to avoid registry side effects
-
-const tool = new (ScaffoldManagedSkillTool as any)() as InstanceType<
-  typeof ScaffoldManagedSkillTool
->;
-
 function makeContext(): ToolContext {
   return {
     workingDir: "/tmp",
@@ -47,7 +41,7 @@ afterEach(() => {
 
 describe("scaffold_managed_skill tool", () => {
   test("creates a valid skill and index entry", async () => {
-    const result = await tool.execute(
+    const result = await executeScaffoldManagedSkill(
       {
         skill_id: "test-skill",
         name: "Test Skill",
@@ -76,7 +70,7 @@ describe("scaffold_managed_skill tool", () => {
   });
 
   test("rejects duplicate unless overwrite=true", async () => {
-    await tool.execute(
+    await executeScaffoldManagedSkill(
       {
         skill_id: "dupe",
         name: "Original",
@@ -86,7 +80,7 @@ describe("scaffold_managed_skill tool", () => {
       makeContext(),
     );
 
-    const result2 = await tool.execute(
+    const result2 = await executeScaffoldManagedSkill(
       {
         skill_id: "dupe",
         name: "Duplicate",
@@ -98,7 +92,7 @@ describe("scaffold_managed_skill tool", () => {
     expect(result2.isError).toBe(true);
     expect(result2.content).toContain("already exists");
 
-    const result3 = await tool.execute(
+    const result3 = await executeScaffoldManagedSkill(
       {
         skill_id: "dupe",
         name: "Overwritten",
@@ -120,13 +114,13 @@ describe("scaffold_managed_skill tool", () => {
     ];
 
     for (const input of cases) {
-      const result = await tool.execute(input, makeContext());
+      const result = await executeScaffoldManagedSkill(input, makeContext());
       expect(result.isError).toBe(true);
     }
   });
 
   test("sanitizes embedded newlines in name/description/emoji to prevent frontmatter injection", async () => {
-    const result = await tool.execute(
+    const result = await executeScaffoldManagedSkill(
       {
         skill_id: "inject-test",
         name: 'Test\ninjected_field: "evil"',
@@ -143,17 +137,20 @@ describe("scaffold_managed_skill tool", () => {
 
     // Newlines must not appear inside frontmatter values
     const frontmatter = content.split("---")[1];
-    const fmLines = frontmatter.split("\n").filter((l) => l.trim());
-    // Each frontmatter line must start with a known key -- no injected keys
+    // Only check top-level (non-indented) keys — nested YAML under metadata: is expected
+    const fmLines = frontmatter
+      .split("\n")
+      .filter((l) => l.trim() && !l.match(/^\s/));
+    // Each top-level frontmatter line must start with a known key -- no injected keys
     for (const line of fmLines) {
       expect(line).toMatch(
-        /^(name|description|emoji|user-invocable|disable-model-invocation|metadata):\s/,
+        /^(name|description|emoji|user-invocable|disable-model-invocation|metadata)(:\s|:$)/,
       );
     }
   });
 
   test("creates a skill with includes metadata", async () => {
-    const result = await tool.execute(
+    const result = await executeScaffoldManagedSkill(
       {
         skill_id: "parent-skill",
         name: "Parent",
@@ -167,11 +164,13 @@ describe("scaffold_managed_skill tool", () => {
     expect(result.isError).toBe(false);
     const skillFile = join(TEST_DIR, "skills", "parent-skill", "SKILL.md");
     const content = readFileSync(skillFile, "utf-8");
-    expect(content).toContain('"includes":["child-a","child-b"]');
+    expect(content).toContain("    includes:");
+    expect(content).toContain("      - child-a");
+    expect(content).toContain("      - child-b");
   });
 
   test("normalizes includes — trims and deduplicates", async () => {
-    const result = await tool.execute(
+    const result = await executeScaffoldManagedSkill(
       {
         skill_id: "norm-skill",
         name: "Normalized",
@@ -185,11 +184,13 @@ describe("scaffold_managed_skill tool", () => {
     expect(result.isError).toBe(false);
     const skillFile = join(TEST_DIR, "skills", "norm-skill", "SKILL.md");
     const content = readFileSync(skillFile, "utf-8");
-    expect(content).toContain('"includes":["child-a","child-b"]');
+    expect(content).toContain("    includes:");
+    expect(content).toContain("      - child-a");
+    expect(content).toContain("      - child-b");
   });
 
   test("rejects includes with non-string elements", async () => {
-    const result = await tool.execute(
+    const result = await executeScaffoldManagedSkill(
       {
         skill_id: "bad-includes",
         name: "Bad",
@@ -205,7 +206,7 @@ describe("scaffold_managed_skill tool", () => {
   });
 
   test("rejects includes with empty string elements", async () => {
-    const result = await tool.execute(
+    const result = await executeScaffoldManagedSkill(
       {
         skill_id: "empty-includes",
         name: "Empty",
@@ -221,7 +222,7 @@ describe("scaffold_managed_skill tool", () => {
   });
 
   test("rejects includes with whitespace-only elements", async () => {
-    const result = await tool.execute(
+    const result = await executeScaffoldManagedSkill(
       {
         skill_id: "ws-includes",
         name: "Whitespace",
@@ -237,7 +238,7 @@ describe("scaffold_managed_skill tool", () => {
   });
 
   test("omits includes when not provided", async () => {
-    const result = await tool.execute(
+    const result = await executeScaffoldManagedSkill(
       {
         skill_id: "no-includes",
         name: "Solo",
@@ -254,7 +255,7 @@ describe("scaffold_managed_skill tool", () => {
   });
 
   test("rejects invalid skill_id", async () => {
-    const result = await tool.execute(
+    const result = await executeScaffoldManagedSkill(
       {
         skill_id: "../escape",
         name: "Bad",
@@ -269,7 +270,7 @@ describe("scaffold_managed_skill tool", () => {
   });
 
   test("e2e: scaffold child then parent with includes, verify files and index", async () => {
-    const childResult = await tool.execute(
+    const childResult = await executeScaffoldManagedSkill(
       {
         skill_id: "e2e-child",
         name: "E2E Child",
@@ -280,7 +281,7 @@ describe("scaffold_managed_skill tool", () => {
     );
     expect(childResult.isError).toBe(false);
 
-    const parentResult = await tool.execute(
+    const parentResult = await executeScaffoldManagedSkill(
       {
         skill_id: "e2e-parent",
         name: "E2E Parent",
@@ -295,7 +296,8 @@ describe("scaffold_managed_skill tool", () => {
     const parentSkillFile = join(TEST_DIR, "skills", "e2e-parent", "SKILL.md");
     expect(existsSync(parentSkillFile)).toBe(true);
     const parentContent = readFileSync(parentSkillFile, "utf-8");
-    expect(parentContent).toContain('"includes":["e2e-child"]');
+    expect(parentContent).toContain("    includes:");
+    expect(parentContent).toContain("      - e2e-child");
 
     const indexContent = readFileSync(
       join(TEST_DIR, "skills", "SKILLS.md"),

package/src/__tests__/schedule-store.test.ts

@@ -11,7 +11,6 @@ mock.module("../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),
@@ -29,9 +28,14 @@ mock.module("../util/logger.js", () => ({
 
 import { getDb, initializeDb, resetDb } from "../memory/db.js";
 import {
+  cancelSchedule,
   claimDueSchedules,
+  completeOneShot,
   createSchedule,
+  describeCronExpression,
+  failOneShot,
   getSchedule,
+  listSchedules,
   updateSchedule,
 } from "../schedule/schedule-store.js";
 
@@ -569,3 +573,439 @@ describe("claimDueSchedules", () => {
     expect(second.length).toBe(0);
   });
 });
+
+// ── One-shot schedules ──────────────────────────────────────────────
+
+describe("createSchedule (one-shot)", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run("DELETE FROM cron_runs");
+    db.run("DELETE FROM cron_jobs");
+  });
+
+  test("creates a one-shot schedule with no expression", () => {
+    const fireAt = Date.now() + 60_000;
+    const job = createSchedule({
+      name: "Remind me",
+      message: "take out the trash",
+      nextRunAt: fireAt,
+    });
+
+    expect(job.expression).toBeNull();
+    expect(job.cronExpression).toBeNull();
+    expect(job.nextRunAt).toBe(fireAt);
+    expect(job.enabled).toBe(true);
+    expect(job.status).toBe("active");
+    expect(job.mode).toBe("execute");
+    expect(job.routingIntent).toBe("all_channels");
+    expect(job.routingHints).toEqual({});
+  });
+
+  test("creates a one-shot schedule with notify mode and routing", () => {
+    const fireAt = Date.now() + 60_000;
+    const hints = { preferredChannel: "slack", threadId: "abc123" };
+    const job = createSchedule({
+      name: "Notify me",
+      message: "meeting in 5",
+      nextRunAt: fireAt,
+      mode: "notify",
+      routingIntent: "single_channel",
+      routingHints: hints,
+    });
+
+    expect(job.mode).toBe("notify");
+    expect(job.routingIntent).toBe("single_channel");
+    expect(job.routingHints).toEqual(hints);
+    expect(job.expression).toBeNull();
+    expect(job.status).toBe("active");
+  });
+
+  test("rejects one-shot schedule without nextRunAt", () => {
+    expect(() =>
+      createSchedule({
+        name: "Bad one-shot",
+        message: "no time",
+      }),
+    ).toThrow("One-shot schedules (no expression) require nextRunAt");
+  });
+
+  test("one-shot schedule persists and round-trips correctly", () => {
+    const fireAt = Date.now() + 120_000;
+    const hints = { channel: "telegram" };
+    const job = createSchedule({
+      name: "Persist test",
+      message: "round trip",
+      nextRunAt: fireAt,
+      mode: "notify",
+      routingIntent: "multi_channel",
+      routingHints: hints,
+    });
+
+    const retrieved = getSchedule(job.id);
+    expect(retrieved).not.toBeNull();
+    expect(retrieved!.expression).toBeNull();
+    expect(retrieved!.cronExpression).toBeNull();
+    expect(retrieved!.nextRunAt).toBe(fireAt);
+    expect(retrieved!.mode).toBe("notify");
+    expect(retrieved!.routingIntent).toBe("multi_channel");
+    expect(retrieved!.routingHints).toEqual(hints);
+    expect(retrieved!.status).toBe("active");
+  });
+});
+
+// ── One-shot claiming ───────────────────────────────────────────────
+
+describe("claimDueSchedules (one-shot)", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run("DELETE FROM cron_runs");
+    db.run("DELETE FROM cron_jobs");
+  });
+
+  test("claims one-shot schedules whose nextRunAt <= now", () => {
+    const job = createSchedule({
+      name: "Due one-shot",
+      message: "fire now",
+      nextRunAt: Date.now() - 1000,
+    });
+
+    const claimed = claimDueSchedules(Date.now());
+    expect(claimed.length).toBe(1);
+    expect(claimed[0].id).toBe(job.id);
+    expect(claimed[0].expression).toBeNull();
+    expect(claimed[0].status).toBe("firing");
+  });
+
+  test("does not claim one-shot schedules that are not yet due", () => {
+    createSchedule({
+      name: "Future one-shot",
+      message: "not yet",
+      nextRunAt: Date.now() + 60_000,
+    });
+
+    const claimed = claimDueSchedules(Date.now());
+    expect(claimed.length).toBe(0);
+  });
+
+  test("does not double-claim one-shot schedules", () => {
+    createSchedule({
+      name: "Once only",
+      message: "no double",
+      nextRunAt: Date.now() - 1000,
+    });
+
+    const first = claimDueSchedules(Date.now());
+    expect(first.length).toBe(1);
+
+    // Second claim should find nothing since status is now 'firing'
+    const second = claimDueSchedules(Date.now());
+    expect(second.length).toBe(0);
+  });
+
+  test("claims both recurring and one-shot schedules in the same tick", () => {
+    const recurring = createSchedule({
+      name: "Recurring",
+      cronExpression: "* * * * *",
+      message: "recurring",
+      syntax: "cron",
+    });
+    getRawDb().run("UPDATE cron_jobs SET next_run_at = ? WHERE id = ?", [
+      Date.now() - 1000,
+      recurring.id,
+    ]);
+
+    createSchedule({
+      name: "One-shot",
+      message: "one-shot",
+      nextRunAt: Date.now() - 1000,
+    });
+
+    const claimed = claimDueSchedules(Date.now());
+    expect(claimed.length).toBe(2);
+    const expressions = claimed.map((c) => c.expression);
+    expect(expressions).toContain(null); // one-shot
+    expect(expressions.some(Boolean)).toBe(true); // recurring
+  });
+});
+
+// ── One-shot lifecycle (complete, fail, cancel) ─────────────────────
+
+describe("completeOneShot", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run("DELETE FROM cron_runs");
+    db.run("DELETE FROM cron_jobs");
+  });
+
+  test("transitions firing -> fired", () => {
+    const job = createSchedule({
+      name: "Complete me",
+      message: "done",
+      nextRunAt: Date.now() - 1000,
+    });
+
+    // Claim first to get to 'firing' state
+    claimDueSchedules(Date.now());
+
+    completeOneShot(job.id);
+
+    const retrieved = getSchedule(job.id);
+    expect(retrieved!.status).toBe("fired");
+    expect(retrieved!.enabled).toBe(false);
+  });
+
+  test("does not transition if not in firing state", () => {
+    const job = createSchedule({
+      name: "Not firing",
+      message: "still active",
+      nextRunAt: Date.now() + 60_000,
+    });
+
+    completeOneShot(job.id);
+
+    const retrieved = getSchedule(job.id);
+    expect(retrieved!.status).toBe("active"); // unchanged
+    expect(retrieved!.enabled).toBe(true);
+  });
+});
+
+describe("failOneShot", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run("DELETE FROM cron_runs");
+    db.run("DELETE FROM cron_jobs");
+  });
+
+  test("transitions firing -> active for retry", () => {
+    const job = createSchedule({
+      name: "Fail me",
+      message: "retry",
+      nextRunAt: Date.now() - 1000,
+    });
+
+    // Claim to get to 'firing'
+    claimDueSchedules(Date.now());
+
+    failOneShot(job.id);
+
+    const retrieved = getSchedule(job.id);
+    expect(retrieved!.status).toBe("active");
+    expect(retrieved!.enabled).toBe(true); // still enabled for retry
+  });
+
+  test("can be re-claimed after failing", () => {
+    const job = createSchedule({
+      name: "Retry",
+      message: "try again",
+      nextRunAt: Date.now() - 1000,
+    });
+
+    claimDueSchedules(Date.now());
+    failOneShot(job.id);
+
+    // Should be claimable again
+    const claimed = claimDueSchedules(Date.now());
+    expect(claimed.length).toBe(1);
+    expect(claimed[0].id).toBe(job.id);
+  });
+});
+
+describe("cancelSchedule", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run("DELETE FROM cron_runs");
+    db.run("DELETE FROM cron_jobs");
+  });
+
+  test("cancels an active one-shot schedule", () => {
+    const job = createSchedule({
+      name: "Cancel me",
+      message: "never fire",
+      nextRunAt: Date.now() + 60_000,
+    });
+
+    const result = cancelSchedule(job.id);
+    expect(result).toBe(true);
+
+    const retrieved = getSchedule(job.id);
+    expect(retrieved!.status).toBe("cancelled");
+    expect(retrieved!.enabled).toBe(false);
+  });
+
+  test("returns false for non-active schedule", () => {
+    const job = createSchedule({
+      name: "Already done",
+      message: "completed",
+      nextRunAt: Date.now() - 1000,
+    });
+
+    // Claim and complete it
+    claimDueSchedules(Date.now());
+    completeOneShot(job.id);
+
+    const result = cancelSchedule(job.id);
+    expect(result).toBe(false);
+  });
+
+  test("cancelled schedule is not claimable", () => {
+    const job = createSchedule({
+      name: "Cancelled",
+      message: "should not fire",
+      nextRunAt: Date.now() - 1000,
+    });
+
+    cancelSchedule(job.id);
+
+    const claimed = claimDueSchedules(Date.now());
+    expect(claimed.length).toBe(0);
+  });
+});
+
+// ── Routing and mode round-trip ─────────────────────────────────────
+
+describe("routing and mode fields", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run("DELETE FROM cron_runs");
+    db.run("DELETE FROM cron_jobs");
+  });
+
+  test("recurring schedule defaults to execute mode and all_channels", () => {
+    const job = createSchedule({
+      name: "Defaults",
+      cronExpression: "0 9 * * *",
+      message: "check defaults",
+      syntax: "cron",
+    });
+
+    expect(job.mode).toBe("execute");
+    expect(job.routingIntent).toBe("all_channels");
+    expect(job.routingHints).toEqual({});
+    expect(job.status).toBe("active");
+  });
+
+  test("routing hints round-trip through create/read", () => {
+    const hints = { channels: ["slack", "discord"], priority: 1 };
+    const job = createSchedule({
+      name: "Routed",
+      cronExpression: "0 9 * * *",
+      message: "routed msg",
+      syntax: "cron",
+      routingIntent: "multi_channel",
+      routingHints: hints,
+      mode: "notify",
+    });
+
+    const retrieved = getSchedule(job.id);
+    expect(retrieved!.routingIntent).toBe("multi_channel");
+    expect(retrieved!.routingHints).toEqual(hints);
+    expect(retrieved!.mode).toBe("notify");
+  });
+
+  test("routing hints round-trip through DB raw query", () => {
+    const hints = { target: "sms" };
+    const job = createSchedule({
+      name: "Raw round-trip",
+      message: "check raw",
+      nextRunAt: Date.now() + 60_000,
+      routingIntent: "single_channel",
+      routingHints: hints,
+    });
+
+    const raw = getRawDb()
+      .query(
+        "SELECT mode, routing_intent, routing_hints_json, status FROM cron_jobs WHERE id = ?",
+      )
+      .get(job.id) as {
+      mode: string;
+      routing_intent: string;
+      routing_hints_json: string;
+      status: string;
+    } | null;
+    expect(raw).not.toBeNull();
+    expect(raw!.mode).toBe("execute");
+    expect(raw!.routing_intent).toBe("single_channel");
+    expect(JSON.parse(raw!.routing_hints_json)).toEqual(hints);
+    expect(raw!.status).toBe("active");
+  });
+
+  test("updateSchedule updates mode and routing fields", () => {
+    const job = createSchedule({
+      name: "Update routing",
+      cronExpression: "0 9 * * *",
+      message: "update routing",
+      syntax: "cron",
+    });
+
+    const updated = updateSchedule(job.id, {
+      mode: "notify",
+      routingIntent: "single_channel",
+      routingHints: { channel: "telegram" },
+    });
+
+    expect(updated).not.toBeNull();
+    expect(updated!.mode).toBe("notify");
+    expect(updated!.routingIntent).toBe("single_channel");
+    expect(updated!.routingHints).toEqual({ channel: "telegram" });
+  });
+});
+
+// ── listSchedules filters ───────────────────────────────────────────
+
+describe("listSchedules filters", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run("DELETE FROM cron_runs");
+    db.run("DELETE FROM cron_jobs");
+  });
+
+  test("oneShotOnly filter returns only one-shot schedules", () => {
+    createSchedule({
+      name: "Recurring",
+      cronExpression: "0 9 * * *",
+      message: "recurring",
+      syntax: "cron",
+    });
+    createSchedule({
+      name: "One-shot",
+      message: "one-shot",
+      nextRunAt: Date.now() + 60_000,
+    });
+
+    const oneShots = listSchedules({ oneShotOnly: true });
+    expect(oneShots.length).toBe(1);
+    expect(oneShots[0].name).toBe("One-shot");
+    expect(oneShots[0].expression).toBeNull();
+  });
+
+  test("recurringOnly filter returns only recurring schedules", () => {
+    createSchedule({
+      name: "Recurring",
+      cronExpression: "0 9 * * *",
+      message: "recurring",
+      syntax: "cron",
+    });
+    createSchedule({
+      name: "One-shot",
+      message: "one-shot",
+      nextRunAt: Date.now() + 60_000,
+    });
+
+    const recurring = listSchedules({ recurringOnly: true });
+    expect(recurring.length).toBe(1);
+    expect(recurring[0].name).toBe("Recurring");
+    expect(recurring[0].expression).not.toBeNull();
+  });
+});
+
+// ── describeCronExpression ──────────────────────────────────────────
+
+describe("describeCronExpression", () => {
+  test("returns 'One-time' for null expression", () => {
+    expect(describeCronExpression(null)).toBe("One-time");
+  });
+
+  test("returns description for valid cron expression", () => {
+    expect(describeCronExpression("0 9 * * *")).toBe("Every day at 9:00 AM");
+  });
+});