svamp-cli 0.2.225 → 0.2.227

package/dist/runStore-CtptN7US.mjs

@@ -0,0 +1,168 @@
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync, mkdirSync, writeFileSync, renameSync } from 'node:fs';
+import { join } from 'node:path';
+import { c as workflowSteps, d as workflowsDir } from './store-BTs0H_y0.mjs';
+
+const MAX_RUNS_PER_WORKFLOW = 50;
+const MAX_STREAM_CHARS = 8e3;
+const STEP_TIMEOUT_MS = 12e4;
+function capStream(s, max = MAX_STREAM_CHARS) {
+  if (s.length <= max) return s;
+  const head = Math.floor(max * 0.6);
+  const tail = max - head;
+  const omitted = s.length - max;
+  return `${s.slice(0, head)}
+\u2026 [${omitted} chars omitted] \u2026
+${s.slice(s.length - tail)}`;
+}
+function runsDir(projectRoot) {
+  return join(workflowsDir(projectRoot), ".runs");
+}
+function runsFile(projectRoot, workflow) {
+  const safe = workflow.replace(/[^\w.-]+/g, "_");
+  return join(runsDir(projectRoot), `${safe}.jsonl`);
+}
+function shortRunId(seed) {
+  let h = 2166136261;
+  for (let i = 0; i < seed.length; i++) {
+    h ^= seed.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(36).padStart(7, "0").slice(0, 7);
+}
+function recordRun(projectRoot, run) {
+  try {
+    const dir = runsDir(projectRoot);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    const file = runsFile(projectRoot, run.workflow);
+    const existing = loadRuns(projectRoot, run.workflow);
+    const idx = existing.findIndex((r) => r.id === run.id);
+    if (idx >= 0) existing[idx] = run;
+    else existing.push(run);
+    const kept = existing.slice(-MAX_RUNS_PER_WORKFLOW);
+    const tmp = `${file}.tmp`;
+    writeFileSync(tmp, kept.map((r) => JSON.stringify(r)).join("\n") + "\n");
+    renameSync(tmp, file);
+  } catch {
+  }
+}
+function loadRuns(projectRoot, workflow) {
+  try {
+    const file = runsFile(projectRoot, workflow);
+    if (!existsSync(file)) return [];
+    return readFileSync(file, "utf-8").split("\n").filter(Boolean).map((l) => {
+      try {
+        return JSON.parse(l);
+      } catch {
+        return null;
+      }
+    }).filter((r) => !!r);
+  } catch {
+    return [];
+  }
+}
+function listRuns(projectRoot, workflow, limit = MAX_RUNS_PER_WORKFLOW) {
+  return loadRuns(projectRoot, workflow).slice(-limit).reverse().map((r) => {
+    const failedStep = r.steps.findIndex((s) => s.exitCode !== 0 && s.exitCode !== null || s.timedOut);
+    const { steps, ...rest } = r;
+    return { ...rest, stepCount: steps.length, failedStep: failedStep >= 0 ? failedStep : void 0 };
+  });
+}
+function getRun(projectRoot, workflow, runId) {
+  return loadRuns(projectRoot, workflow).find((r) => r.id === runId) || null;
+}
+function defaultExecStep(root, cmd, env) {
+  return new Promise((resolve) => {
+    let stdout = "", stderr = "", timedOut = false, settled = false;
+    const finish = (exitCode) => {
+      if (settled) return;
+      settled = true;
+      resolve({ exitCode, stdout, stderr, timedOut });
+    };
+    try {
+      const child = spawn("sh", ["-c", cmd], { cwd: root, env, stdio: ["ignore", "pipe", "pipe"] });
+      const timer = setTimeout(() => {
+        timedOut = true;
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+      }, STEP_TIMEOUT_MS);
+      child.stdout?.on("data", (d) => {
+        stdout += d.toString();
+        if (stdout.length > MAX_STREAM_CHARS * 4) stdout = capStream(stdout);
+      });
+      child.stderr?.on("data", (d) => {
+        stderr += d.toString();
+        if (stderr.length > MAX_STREAM_CHARS * 4) stderr = capStream(stderr);
+      });
+      child.on("error", (e) => {
+        clearTimeout(timer);
+        stderr += `
+[spawn error] ${e.message}`;
+        finish(null);
+      });
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        finish(code);
+      });
+    } catch (e) {
+      stderr += `[spawn threw] ${e?.message || e}`;
+      finish(null);
+    }
+  });
+}
+async function runWorkflow(projectRoot, wf, opts) {
+  const now = opts.now || (() => {
+    const d = /* @__PURE__ */ new Date();
+    return { iso: d.toISOString(), ms: d.getTime() };
+  });
+  const exec = opts.execStep || defaultExecStep;
+  const start = now();
+  const id = shortRunId(`${wf.name}:${start.iso}:${start.ms}`);
+  const env = wf.session ? { ...process.env, SVAMP_SESSION_ID: wf.session } : process.env;
+  const run = {
+    id,
+    workflow: wf.name,
+    trigger: opts.trigger,
+    triggerContext: opts.triggerContext,
+    actor: opts.actor ?? wf.session ?? null,
+    startedAt: start.iso,
+    status: "running",
+    steps: []
+  };
+  recordRun(projectRoot, run);
+  const steps = workflowSteps(wf);
+  try {
+    for (let i = 0; i < steps.length; i++) {
+      const s0 = now();
+      const r = await exec(projectRoot, steps[i].run, env);
+      const s1 = now();
+      run.steps.push({
+        index: i,
+        cmd: steps[i].run,
+        exitCode: r.exitCode,
+        stdout: capStream(r.stdout),
+        stderr: capStream(r.stderr),
+        durationMs: s1.ms - s0.ms,
+        timedOut: r.timedOut || void 0
+      });
+      if (r.timedOut || r.exitCode !== 0) {
+        run.status = "failed";
+        break;
+      }
+    }
+    if (run.status === "running") run.status = "success";
+  } catch (e) {
+    run.status = "failed";
+    run.error = e?.message || String(e);
+  }
+  const end = now();
+  run.finishedAt = end.iso;
+  run.durationMs = end.ms - start.ms;
+  recordRun(projectRoot, run);
+  opts.log?.(`[workflow] run ${id} "${wf.name}" \u2192 ${run.status} (${run.steps.length} step${run.steps.length === 1 ? "" : "s"})`);
+  return run;
+}
+
+export { getRun as g, listRuns as l, runWorkflow as r };

package/dist/sandboxDetect-DNTcbgWD.mjs

@@ -0,0 +1,12 @@
+function isSandboxed() {
+  return process.env.SVAMP_SANDBOXED === "1";
+}
+const SANDBOX_BLOCKED_MSG = "This command is not available in sandboxed sessions. Available commands: set-title, set-link";
+function requireNotSandboxed(commandName) {
+  if (isSandboxed()) {
+    console.error(`${commandName}: ${SANDBOX_BLOCKED_MSG}`);
+    process.exit(1);
+  }
+}
+
+export { SANDBOX_BLOCKED_MSG, isSandboxed, requireNotSandboxed };

package/dist/scheduler-Bz80Ipep.mjs

@@ -0,0 +1,102 @@
+import { m as resolveProjectRoot, y as cronMatches } from './run-LEPH8aka.mjs';
+import { l as listWorkflows, i as isWorkflowEnabled, w as workflowCrons } from './store-BTs0H_y0.mjs';
+import { r as runWorkflow } from './runStore-CtptN7US.mjs';
+import 'os';
+import 'fs/promises';
+import 'fs';
+import 'path';
+import 'url';
+import 'child_process';
+import 'crypto';
+import 'node:crypto';
+import 'node:fs';
+import 'node:child_process';
+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';
+import 'yaml';
+
+function cronMatchesSafe(expr, date) {
+  try {
+    return cronMatches(expr, date);
+  } catch {
+    return false;
+  }
+}
+class WorkflowScheduler {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  // Wall-clock minute we last processed, so multiple sub-minute ticks fire a workflow at most once
+  // per minute (cron granularity is one minute).
+  lastMinuteKey = null;
+  // In-flight runs (fire-and-forget). `idle()` awaits them — used by tests; harmless in prod.
+  pending = /* @__PURE__ */ new Set();
+  /** Await all in-flight scheduled runs (test helper; the daemon never needs to block on these). */
+  async idle() {
+    await Promise.all([...this.pending]);
+  }
+  static minuteKey(d) {
+    return `${d.getFullYear()}-${d.getMonth()}-${d.getDate()}-${d.getHours()}-${d.getMinutes()}`;
+  }
+  /** Fire all scheduled workflows whose cron matches `now`. Returns the names fired (for tests/logs). */
+  tick(now) {
+    const key = WorkflowScheduler.minuteKey(now);
+    if (key === this.lastMinuteKey) return [];
+    this.lastMinuteKey = key;
+    const fired = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const dir of this.deps.projectRoots()) {
+      let root;
+      try {
+        root = resolveProjectRoot(dir);
+      } catch {
+        continue;
+      }
+      if (seen.has(root)) continue;
+      seen.add(root);
+      let workflows;
+      try {
+        workflows = listWorkflows(root);
+      } catch {
+        continue;
+      }
+      for (const wf of workflows) {
+        if (!isWorkflowEnabled(wf)) continue;
+        const crons = workflowCrons(wf);
+        if (!crons.length) continue;
+        if (crons.some((c) => cronMatchesSafe(c, now))) {
+          this.fire(root, wf);
+          fired.push(wf.name);
+        }
+      }
+    }
+    return fired;
+  }
+  fire(root, wf) {
+    const owner = wf.session || null;
+    this.deps.log?.(`[workflow] schedule fired "${wf.name}" in ${root}${owner ? ` as ${owner}` : ""}`);
+    const p = runWorkflow(root, wf, {
+      trigger: "schedule",
+      actor: owner,
+      execStep: this.deps.execStep,
+      now: this.deps.now,
+      log: this.deps.log
+    }).catch((e) => {
+      this.deps.log?.(`[workflow] scheduled run threw for "${wf.name}": ${e?.message || e}`);
+      return void 0;
+    });
+    this.pending.add(p);
+    p.finally(() => this.pending.delete(p));
+  }
+}
+
+export { WorkflowScheduler, cronMatchesSafe };

package/dist/serveCommands-u_GoFaBX.mjs

@@ -0,0 +1,310 @@
+import * as path from 'path';
+
+function getFlag(args, flag) {
+  const idx = args.indexOf(flag);
+  return idx !== -1 && idx + 1 < args.length ? args[idx + 1] : void 0;
+}
+function hasFlag(args, ...flags) {
+  return flags.some((f) => args.includes(f));
+}
+function positionalArgs(args) {
+  const result = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i].startsWith("-")) {
+      if (!args[i].startsWith("--no-") && i + 1 < args.length && !args[i + 1].startsWith("-")) {
+        i++;
+      }
+      continue;
+    }
+    result.push(args[i]);
+  }
+  return result;
+}
+async function handleServeCommand() {
+  const args = process.argv.slice(3);
+  const sub = args[0];
+  let machineId;
+  const mIdx = args.findIndex((a) => a === "--machine" || a === "-m");
+  if (mIdx !== -1 && mIdx + 1 < args.length) {
+    machineId = args[mIdx + 1];
+  }
+  const filteredArgs = args.filter((_a, i) => {
+    if (args[i] === "--machine" || args[i] === "-m") return false;
+    if (i > 0 && (args[i - 1] === "--machine" || args[i - 1] === "-m")) return false;
+    return true;
+  });
+  if (sub === "--help" || sub === "-h") {
+    printServeHelp();
+    return;
+  }
+  if (sub === "remove" || sub === "rm") {
+    await serveRemove(filteredArgs.slice(1), machineId);
+  } else if (sub === "list" || sub === "ls") {
+    await serveList(filteredArgs.slice(1), machineId);
+  } else if (sub === "info") {
+    await serveInfo(machineId);
+  } else if (sub === "add") {
+    await serveAdd(filteredArgs.slice(1), machineId);
+  } else if (sub === "apply") {
+    await serveApply(filteredArgs.slice(1), machineId);
+  } else if (sub && !sub.startsWith("-")) {
+    await serveAdd(filteredArgs, machineId);
+  } else {
+    printServeHelp();
+  }
+}
+async function serveAdd(args, machineId) {
+  const { connectAndGetMachine } = await import('./commands-CnlQyDxb.mjs');
+  const pos = positionalArgs(args);
+  const name = pos[0];
+  if (!name) {
+    console.error("Usage: svamp serve [add] <name> [directory] [--public | --owner | --access email1,email2]");
+    console.error("  Default: capability URL (link mode) \u2014 anyone with the URL can view, no login required.");
+    process.exit(1);
+  }
+  const directory = path.resolve(pos[1] || ".");
+  let access = "link";
+  if (hasFlag(args, "--public")) {
+    access = "public";
+  } else if (hasFlag(args, "--owner")) {
+    access = "owner";
+  } else {
+    const accessFlag = getFlag(args, "--access");
+    if (accessFlag) {
+      access = accessFlag.split(",").map((e) => e.trim()).filter(Boolean);
+    }
+  }
+  const { machine, server } = await connectAndGetMachine(machineId);
+  try {
+    const result = await machine.serveAdd({ name, directory, access });
+    console.log(`Mount added: ${name} \u2192 ${directory}`);
+    const accessLabel = access === "public" ? "public (no auth)" : access === "link" ? "link (capability URL \u2014 anyone with the URL can view)" : access === "owner" ? "owner only (Hypha login)" : `${access.join(", ")} (Hypha login)`;
+    console.log(`Access: ${accessLabel}`);
+    console.log(`URL: ${result.url}`);
+    if (access === "link") {
+      console.log(`(URL embeds a long capability token; keep it secret to keep the mount private.)`);
+    }
+  } catch (err) {
+    console.error(`Error: ${err.message || err}`);
+    process.exit(1);
+  } finally {
+    await server.disconnect().catch(() => {
+    });
+  }
+}
+async function serveApply(args, machineId) {
+  const { connectAndGetMachine } = await import('./commands-CnlQyDxb.mjs');
+  const fs = await import('fs');
+  const yaml = await import('yaml');
+  const file = positionalArgs(args)[0];
+  if (!file) {
+    console.error("Usage: svamp serve apply <yaml-or-json-file> [--machine <id>]");
+    console.error("");
+    console.error("YAML format:");
+    console.error("  name: my-app");
+    console.error("  # Static mount:");
+    console.error("  directory: ./public");
+    console.error("  # OR managed-process mount:");
+    console.error("  process:");
+    console.error("    command: npm");
+    console.error("    args: [start]");
+    console.error("    port: 3000");
+    console.error("    workdir: .");
+    console.error("    warmup_path: /          # default '/'");
+    console.error("    warmup_timeout_ms: 30000");
+    console.error("    idle_timeout_sec: 600   # 0 = always running");
+    console.error("    wake_on_request: true   # spawn lazily on first request");
+    console.error("  access: link              # link (default) | public | owner | [emails]");
+    console.error("  # link  \u2014 capability URL, anyone with the URL can view");
+    console.error("  # public \u2014 fully open, short URL");
+    console.error("  # owner / [emails] \u2014 Hypha login required");
+    process.exit(1);
+  }
+  if (!fs.existsSync(file)) {
+    console.error(`Error: file not found: ${file}`);
+    process.exit(1);
+  }
+  const raw = fs.readFileSync(file, "utf-8");
+  let parsed;
+  try {
+    parsed = file.endsWith(".json") ? JSON.parse(raw) : yaml.parse(raw);
+  } catch (err) {
+    console.error(`Error: failed to parse ${file}: ${err.message}`);
+    process.exit(1);
+  }
+  if (!parsed || typeof parsed !== "object") {
+    console.error("Error: top-level config must be an object");
+    process.exit(1);
+  }
+  if (!parsed.name) {
+    console.error("Error: name is required");
+    process.exit(1);
+  }
+  if (!parsed.directory && !parsed.process) {
+    console.error("Error: must specify either directory (static) or process (managed)");
+    process.exit(1);
+  }
+  const proc = parsed.process ? {
+    command: parsed.process.command,
+    args: parsed.process.args,
+    port: parsed.process.port,
+    workdir: parsed.process.workdir ? path.resolve(parsed.process.workdir) : void 0,
+    env: parsed.process.env,
+    warmupPath: parsed.process.warmupPath ?? parsed.process.warmup_path,
+    warmupTimeoutMs: parsed.process.warmupTimeoutMs ?? parsed.process.warmup_timeout_ms,
+    idleTimeoutSec: parsed.process.idleTimeoutSec ?? parsed.process.idle_timeout_sec,
+    wakeOnRequest: parsed.process.wakeOnRequest ?? parsed.process.wake_on_request
+  } : void 0;
+  const params = {
+    name: parsed.name,
+    directory: parsed.directory ? path.resolve(parsed.directory) : void 0,
+    process: proc,
+    sessionId: parsed.sessionId ?? parsed.session_id,
+    access: parsed.access ?? "link",
+    // default flipped from 'owner' to 'link' (capability URL)
+    ownerEmail: parsed.ownerEmail ?? parsed.owner_email
+  };
+  const { machine, server } = await connectAndGetMachine(machineId);
+  try {
+    const result = await machine.serveApply(params);
+    const kind = proc ? "managed" : "static";
+    const what = proc ? `${proc.command}${proc.args?.length ? " " + proc.args.join(" ") : ""} (port ${proc.port})` : params.directory;
+    console.log(`Mount applied (${kind}): ${params.name} \u2192 ${what}`);
+    if (proc?.wakeOnRequest) console.log("Wake-on-request: enabled (process starts on first incoming request)");
+    if (proc?.idleTimeoutSec) console.log(`Idle timeout: ${proc.idleTimeoutSec}s`);
+    console.log(`URL: ${result.url}`);
+  } catch (err) {
+    console.error(`Error: ${err.message || err}`);
+    process.exit(1);
+  } finally {
+    await server.disconnect().catch(() => {
+    });
+  }
+}
+async function serveRemove(args, machineId) {
+  const { connectAndGetMachine } = await import('./commands-CnlQyDxb.mjs');
+  const pos = positionalArgs(args);
+  const name = pos[0];
+  if (!name) {
+    console.error("Usage: svamp serve remove <name>");
+    process.exit(1);
+  }
+  const { machine, server } = await connectAndGetMachine(machineId);
+  try {
+    await machine.serveRemove({ name });
+    console.log(`Mount '${name}' removed.`);
+  } catch (err) {
+    console.error(`Error: ${err.message || err}`);
+    process.exit(1);
+  } finally {
+    await server.disconnect().catch(() => {
+    });
+  }
+}
+async function serveList(args, machineId) {
+  const { connectAndGetMachine } = await import('./commands-CnlQyDxb.mjs');
+  const all = hasFlag(args, "--all", "-a");
+  const json = hasFlag(args, "--json");
+  const sessionId = getFlag(args, "--session");
+  const { machine, server } = await connectAndGetMachine(machineId);
+  try {
+    const mounts = await machine.serveList({ sessionId, all });
+    if (json) {
+      console.log(JSON.stringify(mounts, null, 2));
+    } else if (mounts.length === 0) {
+      console.log(all ? "No mounts registered." : "No mounts for this session. Use --all to see all mounts.");
+    } else {
+      const label = all ? "All mounts" : `Mounts${sessionId ? ` (session ${sessionId.slice(0, 8)})` : ""}`;
+      console.log(`${label}:
+`);
+      for (const m of mounts) {
+        const session = m.sessionId ? m.sessionId.slice(0, 8) : "-";
+        console.log(`  ${m.name}`);
+        console.log(`    Directory: ${m.directory}`);
+        console.log(`    Session:   ${session}`);
+        console.log(`    Added:     ${new Date(m.addedAt).toISOString().slice(0, 16).replace("T", " ")}`);
+        console.log("");
+      }
+    }
+  } catch (err) {
+    console.error(`Error: ${err.message || err}`);
+    process.exit(1);
+  } finally {
+    await server.disconnect().catch(() => {
+    });
+  }
+}
+async function serveInfo(machineId) {
+  const { connectAndGetMachine } = await import('./commands-CnlQyDxb.mjs');
+  const { machine, server } = await connectAndGetMachine(machineId);
+  try {
+    const info = await machine.serveInfo();
+    console.log(`Static file server:`);
+    console.log(`  Status:  ${info.running ? "running" : "stopped"}`);
+    console.log(`  Port:    ${info.port || "-"}`);
+    console.log(`  URL:     ${info.url || "(not exposed)"}`);
+    console.log(`  Mounts:  ${info.mountCount}`);
+  } catch (err) {
+    console.error(`Error: ${err.message || err}`);
+    process.exit(1);
+  } finally {
+    await server.disconnect().catch(() => {
+    });
+  }
+}
+function printServeHelp() {
+  console.log(`
+svamp serve \u2014 Shared static file server
+
+Serve local directories via a single daemon-managed HTTP server with one public URL.
+Multiple sessions can register different mount points without port conflicts.
+
+Usage:
+  svamp serve <name> [directory]       Add a mount and print its URL (dir defaults to .)
+  svamp serve add <name> [directory]   Same as above
+  svamp serve apply <yaml>             Apply a declarative mount config (idempotent).
+                                       Supports static and managed-process mounts
+                                       with wake-on-request and idle timeout.
+  svamp serve remove <name>            Remove a mount
+  svamp serve list [--all] [--json]    List mounts (default: current session only)
+  svamp serve info                     Show server status and URL
+
+Access tiers (default: link):
+  (no flag)                 Capability URL \u2014 anyone with the URL can view.
+                            URL embeds a long random token (~192-bit entropy)
+                            as the first path segment. No login required.
+                            Best for embedding in agent artifact iframes.
+  --public                  Fully public \u2014 no auth, short URL.
+  --owner                   Hypha login required, owner-only.
+  --access email1,email2    Hypha login required, specific allowed emails.
+
+Options:
+  -m, --machine <id>    Target a specific machine
+  --session <id>        Filter by session ID
+  --all, -a             Show mounts from all sessions
+  --json                Output as JSON
+
+Examples:
+  svamp serve my-report ./output                   # Default: capability URL
+  svamp serve dashboard ./dist --public            # Anyone, short URL
+  svamp serve data ./csv --owner                   # Hypha login required
+  svamp serve data ./csv --access a@x.com,b@y.com  # Specific Hypha users
+  svamp serve apply my-app.yaml                    # Declarative apply
+  svamp serve list --all                           # Show all mounts
+  svamp serve remove my-report                     # Stop serving
+
+Declarative apply (svamp serve apply <yaml>):
+  name: my-app
+  process:
+    command: npm
+    args: [start]
+    port: 3000
+    workdir: .
+    warmup_path: /
+    idle_timeout_sec: 600
+    wake_on_request: true
+  access: public
+`);
+}
+
+export { handleServeCommand };