svamp-cli 0.2.98 → 0.2.101

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

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+// Deterministic tests for routine-core (cron, next-fire, templating, validation).
+import { parseCron, cronMatches, nextFire, renderTemplate, validateRoutine, inZone } from '../bin/routine-core.mjs';
+
+let pass = 0, fail = 0;
+function ok(c, m) { if (c) { pass++; console.log(`  ✓ ${m}`); } else { fail++; console.log(`  ✗ ${m}`); } }
+function throws(fn, m) { try { fn(); fail++; console.log(`  ✗ ${m} (did not throw)`); } catch { pass++; console.log(`  ✓ ${m}`); } }
+
+// Local-time Date helper (cron matches on local time).
+const D = (y, mo, d, h, mi) => new Date(y, mo - 1, d, h, mi, 0, 0);
+
+console.log('cron parsing');
+ok(parseCron('*/5 * * * *').minute.has(5), 'parses */5 minutes');
+throws(() => parseCron('* * * *'), 'rejects 4-field cron');
+throws(() => parseCron('99 * * * *'), 'rejects out-of-range value');
+
+console.log('cron matching');
+ok(cronMatches('*/5 * * * *', D(2026, 6, 10, 9, 5)), '*/5 matches minute 5');
+ok(!cronMatches('*/5 * * * *', D(2026, 6, 10, 9, 3)), '*/5 does not match minute 3');
+ok(cronMatches('0 9 * * *', D(2026, 6, 10, 9, 0)), '0 9 matches 09:00');
+ok(!cronMatches('0 9 * * *', D(2026, 6, 10, 10, 0)), '0 9 does not match 10:00');
+// 2026-06-10 is a Wednesday (dow 3); 2026-06-13 is Saturday (dow 6)
+ok(cronMatches('0 9 * * 1-5', D(2026, 6, 10, 9, 0)), 'weekday range matches Wednesday');
+ok(!cronMatches('0 9 * * 1-5', D(2026, 6, 13, 9, 0)), 'weekday range excludes Saturday');
+// dom+dow both restricted => OR semantics (match if EITHER matches)
+ok(cronMatches('0 0 10 * 5', D(2026, 6, 10, 0, 0)), 'dom OR dow: dom=10 matches even though dow!=Fri');
+ok(!cronMatches('0 0 13 * 5', D(2026, 6, 10, 0, 0)), 'dom OR dow: neither dom=13 nor dow=Fri matches');
+
+console.log('next-fire');
+{ const n = nextFire('*/5 * * * *', D(2026, 6, 10, 9, 2));
+  ok(n.getHours() === 9 && n.getMinutes() === 5, `next */5 after 09:02 is 09:05 (got ${n.getHours()}:${n.getMinutes()})`); }
+{ const n = nextFire('0 0 * * *', D(2026, 6, 10, 9, 2));
+  ok(n.getDate() === 11 && n.getHours() === 0 && n.getMinutes() === 0, 'next daily-midnight rolls to next day 00:00'); }
+
+console.log('timezone');
+{ const utc = new Date('2026-06-10T12:00:00Z'); // June → EDT (UTC-4) → 08:00 New York
+  ok(inZone(utc, 'America/New_York').getHours() === 8, 'inZone converts UTC to tz wall-clock');
+  ok(cronMatches('0 8 * * *', inZone(utc, 'America/New_York')), 'cron 0 8 matches in America/New_York'); }
+
+console.log('templating');
+ok(renderTemplate('PR #${body.pr} by ${body.user}', { body: { pr: 42, user: 'wei' } }) === 'PR #42 by wei', 'templates body fields');
+ok(renderTemplate('q=${query.q}', { query: { q: 'hi' } }) === 'q=hi', 'templates query fields');
+ok(renderTemplate('missing=[${body.nope}]', { body: {} }) === 'missing=[]', 'missing var -> empty');
+ok(renderTemplate('obj=${body.o}', { body: { o: { a: 1 } } }) === 'obj={"a":1}', 'object var -> JSON');
+
+console.log('validation');
+const good = { session_id: 's1', name: 'nightly', trigger: { type: 'schedule', cron: '0 2 * * *', missed: 'skip' }, action: { kind: 'message', template: 'go' }, overlap: 'queue' };
+ok(validateRoutine(good).length === 0, 'valid routine passes');
+ok(validateRoutine({ name: 'x', trigger: { type: 'schedule', cron: 'bad' }, action: { kind: 'message' } }).length >= 2, 'invalid routine collects errors');
+ok(validateRoutine({ session_id: 's', name: 'w', trigger: { type: 'webhook', key: 'k' }, action: { kind: 'loop', task_template: 'do ${body.x}' } }).length === 0, 'webhook+loop routine valid');
+ok(validateRoutine({ session_id: 's', name: 'w', trigger: { type: 'webhook', public: true }, action: { kind: 'loop', task_template: 'x' } }).some((e) => /public/.test(e)), 'public webhook + loop action rejected (unauth task injection)');
+
+console.log(`\n${fail === 0 ? '✅' : '❌'} ${pass} passed, ${fail} failed`);
+process.exit(fail === 0 ? 0 : 1);

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

@@ -0,0 +1,122 @@
+#!/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/{agentCommands-BULNvfKa.mjs → agentCommands-CAqLhLOH.mjs}

@@ -148,7 +148,7 @@ async function sessionBroadcast(action, args) {
   console.log(`Broadcast sent: ${action}`);
 }
 async function connectToMachineService() {
-  const { connectAndGetMachine } = await import('./commands-DIhhodx8.mjs');
+  const { connectAndGetMachine } = await import('./commands-CdxEOPUt.mjs');
   return connectAndGetMachine();
 }
 async function inboxSend(targetSessionId, opts) {
@@ -165,7 +165,7 @@ async function inboxSend(targetSessionId, opts) {
   }
   const { server, machine } = await connectToMachineService();
   try {
-    const { resolveSessionId } = await import('./commands-DIhhodx8.mjs');
+    const { resolveSessionId } = await import('./commands-CdxEOPUt.mjs');
     const sessions = await machine.listSessions();
     const match = resolveSessionId(sessions, targetSessionId);
     const fullTargetId = match.sessionId;

package/dist/{auth-BfDOBBPy.mjs → auth-CYA0e4mT.mjs}

@@ -1,4 +1,4 @@
-import { E as resolveModel } from './run-DxzG-3JD.mjs';
+import { E as resolveModel } from './run-CsMTSngP.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';

package/dist/{caddy-BMbX-mFX.mjs → caddy-CuTbE3NY.mjs}

@@ -39,19 +39,6 @@ function getCaddyDownloadUrl() {
   const ext = os === "win32" ? "zip" : "tar.gz";
   return `https://github.com/caddyserver/caddy/releases/download/v${CADDY_VERSION}/caddy_${CADDY_VERSION}_${osStr}_${archStr}.${ext}`;
 }
-function isCaddyAvailable() {
-  if (existsSync(CADDY_BIN)) return true;
-  try {
-    execSync("caddy version", { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getCaddyPath() {
-  if (existsSync(CADDY_BIN)) return CADDY_BIN;
-  return "caddy";
-}
 async function ensureCaddy(log) {
   if (existsSync(CADDY_BIN)) return CADDY_BIN;
   const logger = log || console.log;
@@ -332,4 +319,4 @@ class CaddyManager {
   }
 }
 
-export { CaddyManager, ensureCaddy, generateCaddyConfig, getCaddyPath, isCaddyAvailable };
+export { CaddyManager, ensureCaddy, generateCaddyConfig };