svamp-cli 0.2.175 → 0.2.177

package/bin/skills/loop/test/test-routine-engine.mjs

@@ -1,122 +0,0 @@
-#!/usr/bin/env node
-// Deterministic tests for routine-store + routine-runner (mock delivery, fake clock).
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { RoutineStore } from '../bin/routine-store.mjs';
-import { RoutineRunner } from '../bin/routine-runner.mjs';
-
-let pass = 0, fail = 0;
-function ok(c, m) { if (c) { pass++; console.log(`  ✓ ${m}`); } else { fail++; console.log(`  ✗ ${m}`); } }
-const D = (y, mo, d, h, mi) => new Date(y, mo - 1, d, h, mi, 0, 0);
-
-const dirs = [];
-function freshStore() { const dir = mkdtempSync(join(tmpdir(), 'routines-')); dirs.push(dir); return new RoutineStore(dir); }
-
-try {
-  console.log('store');
-  { const s = freshStore();
-    const r = s.save({ session_id: 's1', name: 'hook', trigger: { type: 'webhook' }, action: { kind: 'message', template: 'hi ${body.x}' } });
-    ok(r.id?.startsWith('rt_'), 'save assigns id');
-    ok(typeof r.trigger.key === 'string' && r.trigger.key.length > 10, 'webhook routine gets a capability key');
-    ok(s.get(r.id).name === 'hook', 'get round-trips');
-    ok(s.list().length === 1, 'list returns saved routine');
-    s.setEnabled(r.id, false); ok(s.get(r.id).enabled === false, 'setEnabled persists');
-    ok(s.remove(r.id) === true && s.list().length === 0, 'remove deletes'); }
-
-  console.log('resolveAction (templating)');
-  { const s = freshStore();
-    const runner = new RoutineRunner({ store: s, deliver: async () => {}, now: () => D(2026, 6, 10, 9, 0) });
-    const msg = s.save({ session_id: 's', name: 'm', trigger: { type: 'manual' }, action: { kind: 'message', template: 'PR ${body.pr}' } });
-    ok(runner.resolveAction(msg, { body: { pr: 7 } }).text === 'PR 7', 'message action templated');
-    const lp = s.save({ session_id: 's', name: 'l', trigger: { type: 'webhook' }, action: { kind: 'loop', task_template: 'fix ${body.issue}' } });
-    const r = runner.resolveAction(lp, { body: { issue: 'X' } });
-    ok(r.kind === 'loop' && r.task === 'fix X', 'loop action task templated'); }
-
-  console.log('schedule tick (fire once per minute)');
-  { const s = freshStore();
-    let clock = D(2026, 6, 10, 9, 5);
-    const calls = [];
-    const runner = new RoutineRunner({ store: s, deliver: async (c) => calls.push(c), now: () => clock });
-    s.save({ session_id: 's', name: 'poll', trigger: { type: 'schedule', cron: '*/5 * * * *' }, action: { kind: 'message', template: 'tick' } });
-    await runner.tick(D(2026, 6, 10, 9, 3)); ok(calls.length === 0, 'no fire at non-matching minute 9:03');
-    await runner.tick(D(2026, 6, 10, 9, 5)); ok(calls.length === 1, 'fires at matching minute 9:05');
-    await runner.tick(D(2026, 6, 10, 9, 5)); ok(calls.length === 1, 'does not double-fire same minute');
-    await runner.tick(D(2026, 6, 10, 9, 10)); ok(calls.length === 2, 'fires again next matching minute');
-    ok(s.list()[0].last_runs.length === 2, 'run history recorded'); }
-
-  console.log('overlap policy (concurrent in-flight guard)');
-  { const s = freshStore();
-    const calls = []; let release; const gate = new Promise((r) => { release = r; });
-    const runner = new RoutineRunner({ store: s, deliver: async () => { calls.push(1); await gate; } });
-    const r = s.save({ session_id: 's', name: 'l', overlap: 'skip', trigger: { type: 'manual' }, action: { kind: 'loop', task_template: 'go' } });
-    const p1 = runner.fire(s.get(r.id), {}, 'manual');          // enters deliver, holds active
-    await new Promise((res) => setTimeout(res, 10));
-    const res2 = await runner.fire(s.get(r.id), {}, 'manual');  // concurrent -> skipped
-    ok(res2.skipped === 'busy' && calls.length === 1, 'overlap=skip skips a concurrent fire');
-    release(); await p1;                                         // first delivery completes -> active cleared
-    const res3 = await runner.fire(s.get(r.id), {}, 'manual');
-    ok(res3.fired && calls.length === 2, 'fires again once the in-flight delivery completes (no permanent skip)'); }
-
-  console.log('webhook dispatch + key/method checks');
-  { const s = freshStore();
-    const calls = [];
-    const runner = new RoutineRunner({ store: s, deliver: async (c) => calls.push(c) });
-    const r = s.save({ session_id: 's', name: 'wh', trigger: { type: 'webhook', methods: ['POST'] }, action: { kind: 'message', template: 'got ${body.v}' } });
-    const key = s.get(r.id).trigger.key;
-    ok((await runner.webhook(r.id, { key: 'wrong', method: 'POST' })).status === 401, 'bad key -> 401');
-    ok((await runner.webhook(r.id, { key, method: 'GET' })).status === 405, 'disallowed method -> 405');
-    const good = await runner.webhook(r.id, { key, method: 'POST', body: { v: 42 } });
-    ok(good.status === 200 && good.resolved.text === 'got 42', 'good webhook delivers templated message');
-    s.setEnabled(r.id, false);
-    ok((await runner.webhook(r.id, { key, method: 'POST' })).status === 409, 'disabled -> 409'); }
-
-  console.log('catch-up missed schedule');
-  { const s = freshStore();
-    const calls = [];
-    const now = D(2026, 6, 10, 9, 30);
-    const runner = new RoutineRunner({ store: s, deliver: async (c) => calls.push(c), now: () => now });
-    s.save({ session_id: 's', name: 'daily', trigger: { type: 'schedule', cron: '0 9 * * *', missed: 'catchup', deadline_sec: 7200 }, action: { kind: 'message', template: 'good morning' } });
-    await runner.catchUp(D(2026, 6, 10, 8, 0), now); ok(calls.length === 1, 'catch-up fires the missed 09:00 run');
-    await runner.catchUp(D(2026, 6, 10, 8, 0), now); ok(calls.length === 1, 'catch-up does not re-fire once recorded'); }
-
-  console.log('daily cap');
-  { const s = freshStore(); const calls = []; const now = D(2026, 6, 10, 9, 0);
-    const runner = new RoutineRunner({ store: s, deliver: async (c) => calls.push(c), now: () => now });
-    const r = s.save({ session_id: 's', name: 'capped', daily_cap: 2, trigger: { type: 'manual' }, action: { kind: 'message', template: 'x' } });
-    await runner.fire(s.get(r.id), {}, 'manual');
-    await runner.fire(s.get(r.id), {}, 'manual');
-    const third = await runner.fire(s.get(r.id), {}, 'manual');
-    ok(calls.length === 2, 'daily_cap=2 delivers exactly twice');
-    ok(third.skipped === 'daily_cap', 'third fire skipped by daily cap'); }
-
-  console.log('fire-time public+loop guard (#8)');
-  { const s = freshStore(); const calls = [];
-    const runner = new RoutineRunner({ store: s, deliver: async () => calls.push(1) });
-    // hand-built (bypasses save validation, simulating a legacy/pre-guard stored routine)
-    const res = await runner.fire({ id: 'x', enabled: true, trigger: { type: 'webhook', public: true }, action: { kind: 'loop', task_template: 't' } }, {}, 'webhook');
-    ok(res.skipped?.includes('forbidden') && calls.length === 0, 'public webhook + loop action refused at fire time'); }
-
-  console.log('daily_cap under concurrency (#9 reserve-before-await)');
-  { const s = freshStore(); const calls = []; let release; const gate = new Promise((r) => { release = r; });
-    const runner = new RoutineRunner({ store: s, deliver: async () => { calls.push(1); await gate; } });
-    const r = s.save({ session_id: 's', name: 'cap', daily_cap: 2, trigger: { type: 'manual' }, action: { kind: 'message', template: 'x' } });
-    const fires = Promise.all([0, 1, 2, 3, 4].map(() => runner.fire(s.get(r.id), {}, 'manual')));
-    await new Promise((res) => setTimeout(res, 20));
-    release(); await fires;
-    ok(calls.length === 2, `5 concurrent fires respect daily_cap=2 (delivered ${calls.length})`); }
-
-  console.log('catch-up honors timezone (#10)');
-  { const s = freshStore();
-    const now = new Date('2026-06-10T13:30:00Z'); // 09:30 EDT
-    const calls = [];
-    const runner = new RoutineRunner({ store: s, deliver: async () => calls.push(1), now: () => now });
-    s.save({ session_id: 's', name: 'tzd', trigger: { type: 'schedule', cron: '0 9 * * *', tz: 'America/New_York', missed: 'catchup', deadline_sec: 7200 }, action: { kind: 'message', template: 'gm' } });
-    await runner.catchUp(new Date('2026-06-10T12:00:00Z'), now);
-    ok(calls.length === 1, 'catch-up fires the missed 09:00-America/New_York run (tz-aware)'); }
-
-  console.log(`\n${fail === 0 ? '✅' : '❌'} ${pass} passed, ${fail} failed`);
-  process.exit(fail === 0 ? 0 : 1);
-} finally {
-  for (const d of dirs) { try { rmSync(d, { recursive: true, force: true }); } catch {} }
-}

package/dist/commands-CkygtYMZ.mjs

@@ -1,223 +0,0 @@
-import { execFileSync } from 'node:child_process';
-import { randomUUID } from 'node:crypto';
-import { createServer } from 'node:http';
-import { R as RoutineStore, w as RoutineRunner } from './run-Buov6wz-.mjs';
-import 'os';
-import 'fs/promises';
-import 'fs';
-import 'path';
-import 'url';
-import 'child_process';
-import 'crypto';
-import 'node:fs';
-import 'util';
-import 'node:path';
-import 'node:events';
-import 'node:os';
-import '@agentclientprotocol/sdk';
-import '@modelcontextprotocol/sdk/client/index.js';
-import '@modelcontextprotocol/sdk/client/stdio.js';
-import '@modelcontextprotocol/sdk/types.js';
-import 'zod';
-import 'node:fs/promises';
-import 'node:util';
-
-function parseArgs(argv) {
-  const a = { _: [] };
-  for (let i = 0; i < argv.length; i++) {
-    const t = argv[i];
-    if (t.startsWith("--")) a[t.slice(2)] = argv[i + 1] && !argv[i + 1].startsWith("--") ? argv[++i] : true;
-    else a._.push(t);
-  }
-  return a;
-}
-function isSessionLive(sid) {
-  try {
-    const out = execFileSync("svamp", ["session", "list", "--json"], { stdio: ["ignore", "pipe", "ignore"], timeout: 15e3 }).toString();
-    const list = JSON.parse(out);
-    return Array.isArray(list) && list.some((s) => s?.sessionId === sid);
-  } catch {
-    return false;
-  }
-}
-async function cliDeliver({ routine, resolved }) {
-  if (resolved.kind === "verify") {
-    const dir = routine.dir;
-    if (!dir) {
-      console.error(`[trigger] skip ${routine.id || routine.name}: verify action has no dir`);
-      return { skipped: "verify: no dir" };
-    }
-    const target = routine.action.verify?.target_session || routine.session_id;
-    const reportTo = routine.action.verify?.report_to || routine.session_id;
-    if (!isSessionLive(reportTo)) {
-      console.error(`[trigger] skip ${routine.id || routine.name}: report session ${reportTo} not live (inbox is in-memory)`);
-      return { skipped: "verify: report session not live" };
-    }
-    let res;
-    try {
-      const out = execFileSync("svamp", ["issue", "pending"], { cwd: dir, encoding: "utf8" });
-      res = { verdict: "approved", guidance: out.trim() || "No pending issues.", criteria: "svamp issue pending" };
-    } catch (e) {
-      res = { verdict: "rework", guidance: (String(e?.stdout || "") + String(e?.stderr || "")).trim() || "Pending issues remain.", criteria: "svamp issue pending" };
-    }
-    const message = {
-      messageId: randomUUID(),
-      from: `watchdog:${routine.name || routine.id}`,
-      fromSession: target,
-      to: reportTo,
-      subject: `watchdog: ${res.verdict} \u2014 ${routine.name || routine.id}`,
-      body: `<supervision-verdict source="watchdog" session="${target}" verdict="${res.verdict}" judge="oracle" round="0">
-${res.guidance}
-Criteria: ${res.criteria || "(none)"}
-</supervision-verdict>`,
-      timestamp: Date.now(),
-      read: false,
-      urgency: "normal",
-      hopCount: 1
-    };
-    const { connectAndGetMachine } = await import('./commands-BssfhM-2.mjs');
-    const { server, machine } = await connectAndGetMachine();
-    try {
-      await machine.sessionRPC(reportTo, "sendInboxMessage", { message });
-    } finally {
-      await server.disconnect();
-    }
-    return;
-  }
-  if (routine.bind === "stateless") {
-    const dir = routine.dir;
-    if (!dir) {
-      console.error(`[routine] skip ${routine.id || routine.name}: stateless routine has no dir`);
-      return { skipped: "stateless: no dir" };
-    }
-    execFileSync("svamp", ["session", "query", dir, resolved.text || resolved.task || "run"], { stdio: "pipe" });
-    return;
-  }
-  const sid = routine.session_id;
-  if (!isSessionLive(sid)) {
-    console.error(`[routine] skip ${routine.id || routine.name}: session ${sid} is stopped/archived`);
-    return { skipped: "session stopped/archived" };
-  }
-  if (resolved.kind === "message") {
-    execFileSync("svamp", ["session", "send", sid, resolved.text || ""], { stdio: "pipe" });
-    return;
-  }
-  execFileSync("svamp", [
-    "session",
-    "send",
-    sid,
-    `Begin the loop (LOOP MODE). Task: ${resolved.task}. Iterate until the gate lets you stop.`
-  ], { stdio: "pipe" });
-}
-function buildRoutineFromArgs(a) {
-  const r = { session_id: a.session, name: a.name || "routine", overlap: a.overlap || "queue" };
-  if (a.schedule) r.trigger = { type: "schedule", cron: a.schedule, missed: a.missed || "skip", tz: a.tz };
-  else if (a.webhook || a.api) r.trigger = { type: a.api ? "api" : "webhook", methods: a.get ? ["GET"] : ["GET", "POST"], public: !!a.public };
-  else r.trigger = { type: "manual" };
-  if (a.verify) r.action = { kind: "verify", verify: { target_session: a["target-session"], report_to: a["report-to"] } };
-  else if (a.loop) r.action = { kind: "loop", task_template: a.task || "", loop: { dir: a.dir, oracle: a.oracle, evaluator: a.evaluator || "off" } };
-  else r.action = { kind: "message", template: a.message || a.task || "run" };
-  if (a.dir) r.dir = a.dir;
-  if (a.stateless) r.bind = "stateless";
-  return r;
-}
-async function routineCommand(args) {
-  const a = parseArgs(args);
-  const cmd = a._[0];
-  const store = new RoutineStore();
-  const runner = new RoutineRunner({ store, deliver: cliDeliver, log: console.error });
-  switch (cmd) {
-    case "add": {
-      if (!a.session) {
-        console.error("--session <id> required");
-        process.exit(1);
-      }
-      const r = store.save(buildRoutineFromArgs(a));
-      console.log(`\u2705 added trigger ${r.id} (${r.name}) source=${r.trigger.type} action=${r.action.kind} session=${r.session_id}`);
-      if (r.trigger.key) console.log(`   webhook key: ${r.trigger.key}`);
-      break;
-    }
-    case "list": {
-      const rs = store.list(typeof a.session === "string" ? a.session : void 0);
-      if (a.json) {
-        console.log(JSON.stringify(rs, null, 2));
-        break;
-      }
-      if (!rs.length) {
-        console.log("(no triggers)");
-        break;
-      }
-      for (const r of rs) console.log(`${r.enabled ? "\u25CF" : "\u25CB"} ${r.id}  ${r.name}  [${r.trigger.type}${r.trigger.cron ? " " + r.trigger.cron : ""}] -> ${r.action.kind}  ${r.bind === "stateless" ? `stateless(${r.dir || "?"})` : `session=${r.session_id}`}`);
-      break;
-    }
-    case "remove":
-      console.log(store.remove(a._[1]) ? `removed ${a._[1]}` : "not found");
-      break;
-    case "enable":
-      store.setEnabled(a._[1], true);
-      console.log(`enabled ${a._[1]}`);
-      break;
-    case "disable":
-      store.setEnabled(a._[1], false);
-      console.log(`disabled ${a._[1]}`);
-      break;
-    case "run-now":
-      console.log(JSON.stringify(await runner.runNow(a._[1], {}), null, 2));
-      break;
-    case "serve":
-      await serve(runner, Number(a.port) || 8722);
-      break;
-    default:
-      console.log(`usage: svamp trigger <add|list|remove|enable|disable|run-now|serve>   (alias: svamp routine)
-  add --session <id> --name <n> [--schedule "*/5 * * * *" [--missed catchup]] [--webhook|--api [--get] [--public]] [--stateless --dir <path>] (--message "..." | --loop --dir <path> --task "..." [--oracle "cmd"])
-  list [--session <id>] [--json]
-  serve [--port 8722]`);
-  }
-}
-async function serve(runner, port) {
-  await runner.catchUp(new Date(Date.now() - 24 * 3600 * 1e3), /* @__PURE__ */ new Date());
-  const timer = setInterval(() => {
-    runner.tick(/* @__PURE__ */ new Date()).catch((e) => console.error("tick error", e));
-  }, 2e4);
-  const server = createServer((req, res) => {
-    const u = new URL(req.url || "/", `http://localhost:${port}`);
-    if (u.pathname === "/" || u.pathname === "/health") {
-      res.writeHead(200).end("routines ok");
-      return;
-    }
-    const m = u.pathname.match(/^\/routine\/([\w.-]+)$/);
-    if (!m) {
-      res.writeHead(404).end("not found");
-      return;
-    }
-    const id = m[1];
-    const key = u.searchParams.get("key");
-    const query = Object.fromEntries(u.searchParams.entries());
-    let chunks = "";
-    req.on("data", (c) => {
-      chunks += c;
-      if (chunks.length > 1e6) req.destroy();
-    });
-    req.on("end", async () => {
-      let body = {};
-      try {
-        body = chunks ? JSON.parse(chunks) : {};
-      } catch {
-      }
-      const result = await runner.webhook(id, { key, method: req.method, body, query });
-      res.writeHead(result.status || 200, { "content-type": "application/json" }).end(JSON.stringify(result));
-    });
-  });
-  server.listen(port, () => {
-    console.log(`\u{1FA9D} trigger server on http://localhost:${port}`);
-    console.log(`   webhook URL: http://localhost:${port}/routine/<id>?key=<key>`);
-    console.log(`   expose:      svamp service expose triggers --port ${port}`);
-  });
-  process.on("SIGINT", () => {
-    clearInterval(timer);
-    server.close();
-    process.exit(0);
-  });
-}
-
-export { routineCommand };

package/dist/store-D2HNe-Kv.mjs

@@ -1,74 +0,0 @@
-import { existsSync, unlinkSync, readFileSync, readdirSync, mkdirSync, writeFileSync, renameSync } from 'node:fs';
-import { join } from 'node:path';
-import { parse, stringify } from 'yaml';
-
-function workflowsDir(projectRoot) {
-  return join(projectRoot, ".svamp", "workflows");
-}
-function workflowPath(projectRoot, name) {
-  return join(workflowsDir(projectRoot), `${name}.yaml`);
-}
-function parseWorkflow(content) {
-  try {
-    const o = parse(content);
-    if (!o || typeof o !== "object" || !o.name) return null;
-    const jobs = Array.isArray(o.jobs) ? o.jobs.map((j) => ({ run: String(j?.run ?? "") })).filter((j) => j.run) : [];
-    return { name: String(o.name), on: o.on && typeof o.on === "object" ? o.on : void 0, jobs, session: o.session ?? null };
-  } catch {
-    return null;
-  }
-}
-function serializeWorkflow(wf) {
-  const clean = { name: wf.name };
-  if (wf.session) clean.session = wf.session;
-  if (wf.on && Object.keys(wf.on).length) clean.on = wf.on;
-  clean.jobs = wf.jobs.map((j) => ({ run: j.run }));
-  return stringify(clean);
-}
-function listWorkflows(projectRoot) {
-  const dir = workflowsDir(projectRoot);
-  if (!existsSync(dir)) return [];
-  const out = [];
-  for (const name of readdirSync(dir)) {
-    if (!name.endsWith(".yaml") && !name.endsWith(".yml")) continue;
-    try {
-      const wf = parseWorkflow(readFileSync(join(dir, name), "utf-8"));
-      if (wf) out.push(wf);
-    } catch {
-    }
-  }
-  return out.sort((a, b) => a.name.localeCompare(b.name));
-}
-function getWorkflow(projectRoot, name) {
-  const p = workflowPath(projectRoot, name);
-  if (!existsSync(p)) return null;
-  try {
-    return parseWorkflow(readFileSync(p, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function rawWorkflow(projectRoot, name) {
-  const p = workflowPath(projectRoot, name);
-  return existsSync(p) ? readFileSync(p, "utf-8") : null;
-}
-function saveWorkflow(projectRoot, wf) {
-  const dir = workflowsDir(projectRoot);
-  mkdirSync(dir, { recursive: true });
-  const path = workflowPath(projectRoot, wf.name);
-  const tmp = `${path}.tmp-${process.pid}`;
-  writeFileSync(tmp, serializeWorkflow(wf));
-  renameSync(tmp, path);
-}
-function removeWorkflow(projectRoot, name) {
-  const p = workflowPath(projectRoot, name);
-  if (!existsSync(p)) return false;
-  try {
-    unlinkSync(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export { rawWorkflow as a, getWorkflow as g, listWorkflows as l, removeWorkflow as r, saveWorkflow as s };