svamp-cli 0.2.225 → 0.2.227

package/dist/serviceManager-hlOVxkhW.mjs

@@ -0,0 +1,78 @@
+const LAUNCHD_LABEL = "io.hypha.svamp.daemon";
+const SYSTEMD_UNIT = "svamp-daemon.service";
+async function ensureSupervisorViaServiceManager() {
+  const os = await import('os');
+  const { join } = await import('path');
+  const fs = await import('fs');
+  const { execSync } = await import('child_process');
+  if (process.platform === "darwin") {
+    const plistPath = join(os.homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+    if (!fs.existsSync(plistPath)) return false;
+    const uid = typeof process.getuid === "function" ? process.getuid() : 0;
+    try {
+      execSync(`launchctl bootstrap gui/${uid} "${plistPath}" 2>/dev/null`, { stdio: "ignore" });
+    } catch {
+    }
+    try {
+      execSync(`launchctl enable gui/${uid}/${LAUNCHD_LABEL} 2>/dev/null`, { stdio: "ignore" });
+    } catch {
+    }
+    try {
+      execSync(`launchctl kickstart -k gui/${uid}/${LAUNCHD_LABEL}`, { stdio: "ignore" });
+      return true;
+    } catch {
+      try {
+        execSync(`launchctl load "${plistPath}" 2>/dev/null`, { stdio: "ignore" });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  }
+  if (process.platform === "linux") {
+    const unitPath = join(os.homedir(), ".config", "systemd", "user", SYSTEMD_UNIT);
+    if (!fs.existsSync(unitPath)) return false;
+    try {
+      execSync(`systemctl --user start ${SYSTEMD_UNIT}`, { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+async function stopViaServiceManager() {
+  const os = await import('os');
+  const { join } = await import('path');
+  const fs = await import('fs');
+  const { execSync } = await import('child_process');
+  if (process.platform === "darwin") {
+    const plistPath = join(os.homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+    if (!fs.existsSync(plistPath)) return false;
+    const uid = typeof process.getuid === "function" ? process.getuid() : 0;
+    try {
+      execSync(`launchctl bootout gui/${uid}/${LAUNCHD_LABEL} 2>/dev/null`, { stdio: "ignore" });
+      return true;
+    } catch {
+      try {
+        execSync(`launchctl unload "${plistPath}" 2>/dev/null`, { stdio: "ignore" });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  }
+  if (process.platform === "linux") {
+    const unitPath = join(os.homedir(), ".config", "systemd", "user", SYSTEMD_UNIT);
+    if (!fs.existsSync(unitPath)) return false;
+    try {
+      execSync(`systemctl --user stop ${SYSTEMD_UNIT}`, { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+
+export { LAUNCHD_LABEL, SYSTEMD_UNIT, ensureSupervisorViaServiceManager, stopViaServiceManager };

package/dist/sideband-RJijk2GE.mjs

@@ -0,0 +1,80 @@
+import { R as READ_ONLY_TOOLS, B as loadMachineContext, C as buildMachineInstructions, D as machineToolsForRole, E as buildMachineTools } from './run-LEPH8aka.mjs';
+import 'node:child_process';
+import 'os';
+import 'fs/promises';
+import 'fs';
+import 'path';
+import 'url';
+import 'child_process';
+import 'crypto';
+import 'node: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 toolsForRole(role) {
+  if (role === "admin") return [...READ_ONLY_TOOLS, "run_bash", "send_to_session"];
+  if (role === "interact") return [...READ_ONLY_TOOLS, "send_to_session"];
+  return [...READ_ONLY_TOOLS];
+}
+function toRealtimeTools(tools) {
+  return tools.map((t) => ({ type: "function", name: t.name, description: t.description, parameters: t.parameters }));
+}
+function buildVoiceSessionUpdate(instructions, tools, opts) {
+  return {
+    type: "session.update",
+    session: {
+      type: "realtime",
+      instructions,
+      tools: toRealtimeTools(tools),
+      tool_choice: "auto",
+      ...opts?.voice ? { audio: { output: { voice: opts.voice } } } : {}
+    }
+  };
+}
+async function handleRealtimeEvent(ev, tools, send, nameByCallId) {
+  if (ev?.type === "response.output_item.added" && ev.item?.type === "function_call") {
+    if (nameByCallId && ev.item.call_id) nameByCallId.set(ev.item.call_id, ev.item.name);
+    return null;
+  }
+  if (!ev || ev.type !== "response.function_call_arguments.done") return null;
+  const callId = ev.call_id;
+  const name = ev.name || nameByCallId && nameByCallId.get(callId) || "";
+  let args = {};
+  try {
+    args = ev.arguments ? JSON.parse(ev.arguments) : {};
+  } catch {
+  }
+  const tool = tools.find((t) => t.name === name);
+  let output;
+  if (!tool) {
+    output = `error: tool "${name}" is not available to this caller`;
+  } else {
+    try {
+      output = await tool.run(args);
+    } catch (e) {
+      output = `error: ${e?.message || e}`;
+    }
+  }
+  send({ type: "conversation.item.create", item: { type: "function_call_output", call_id: callId, output } });
+  send({ type: "response.create" });
+  return { name, output };
+}
+async function initMachineVoiceSession(init) {
+  const ctx = await loadMachineContext(init.deps);
+  const instructions = buildMachineInstructions(ctx);
+  const allow = new Set(machineToolsForRole(init.role));
+  const granted = buildMachineTools(init.deps, ctx.skills).filter((t) => allow.has(t.name));
+  return { tools: granted, sessionUpdate: buildVoiceSessionUpdate(instructions, granted, { voice: init.voice }) };
+}
+
+export { buildVoiceSessionUpdate, handleRealtimeEvent, initMachineVoiceSession, toRealtimeTools, toolsForRole };

package/dist/store-BTs0H_y0.mjs

@@ -0,0 +1,148 @@
+import { existsSync, unlinkSync, readFileSync, readdirSync, statSync, mkdirSync, writeFileSync, renameSync } from 'node:fs';
+import { join } from 'node:path';
+import { parse, stringify } from 'yaml';
+
+function isWorkflowEnabled(wf) {
+  return wf.enabled !== false;
+}
+function workflowSteps(wf) {
+  return Object.values(wf.jobs || {}).flatMap((j) => j?.steps || []);
+}
+function workflowCrons(wf) {
+  return (wf.on?.schedule || []).map((s) => s?.cron).filter((c) => !!c);
+}
+function workflowsDir(projectRoot) {
+  return join(projectRoot, ".svamp", "workflows");
+}
+function workflowPath(projectRoot, name) {
+  return join(workflowsDir(projectRoot), `${name}.yaml`);
+}
+function normalizeOn(on) {
+  if (!on || typeof on !== "object") {
+    return void 0;
+  }
+  const out = {};
+  if (Array.isArray(on.schedule)) {
+    const sched = on.schedule.map((s) => ({ cron: String(s?.cron ?? s ?? "") })).filter((s) => s.cron);
+    if (sched.length) out.schedule = sched;
+  } else if (typeof on.schedule === "string" && on.schedule.trim()) {
+    out.schedule = [{ cron: on.schedule.trim() }];
+  }
+  if ("workflow_dispatch" in on || on.dispatch === true) out.workflow_dispatch = true;
+  if (typeof on.channel === "string" && on.channel) out.channel = on.channel;
+  if (Array.isArray(on.issue) && on.issue.length) out.issue = on.issue.map(String);
+  return Object.keys(out).length ? out : void 0;
+}
+function normalizeJobs(jobs) {
+  if (Array.isArray(jobs)) {
+    const steps = jobs.map((j) => ({ run: String(j?.run ?? "") })).filter((s) => s.run);
+    return steps.length ? { run: { steps } } : {};
+  }
+  if (jobs && typeof jobs === "object") {
+    const out = {};
+    for (const [id, job] of Object.entries(jobs)) {
+      const rawSteps = Array.isArray(job?.steps) ? job.steps : job?.run ? [{ run: job.run }] : [];
+      const steps = rawSteps.map((s) => ({ run: String(s?.run ?? ""), ...s?.name ? { name: String(s.name) } : {} })).filter((s) => s.run);
+      if (steps.length) out[String(id)] = { steps };
+    }
+    return out;
+  }
+  return {};
+}
+function parseWorkflow(content) {
+  try {
+    const o = parse(content);
+    if (!o || typeof o !== "object" || !o.name) return null;
+    return {
+      name: String(o.name),
+      on: normalizeOn(o.on),
+      jobs: normalizeJobs(o.jobs),
+      session: o.session ?? null,
+      // Only `enabled: false` disables; anything else (absent/true) is active.
+      ...o.enabled === false ? { enabled: false } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+function serializeWorkflow(wf) {
+  const clean = { name: wf.name };
+  if (wf.session) clean.session = wf.session;
+  if (wf.enabled === false) clean.enabled = false;
+  const on = {};
+  if (wf.on?.schedule?.length) on.schedule = wf.on.schedule.map((s) => ({ cron: s.cron }));
+  if (wf.on?.workflow_dispatch) on.workflow_dispatch = {};
+  if (wf.on?.channel) on.channel = wf.on.channel;
+  if (wf.on?.issue?.length) on.issue = wf.on.issue;
+  if (Object.keys(on).length) clean.on = on;
+  const jobs = {};
+  for (const [id, job] of Object.entries(wf.jobs || {})) {
+    jobs[id] = { steps: (job.steps || []).map((s) => s.name ? { name: s.name, run: s.run } : { run: s.run }) };
+  }
+  clean.jobs = Object.keys(jobs).length ? jobs : { run: { steps: [] } };
+  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;
+    const p = join(dir, name);
+    try {
+      const wf = parseWorkflow(readFileSync(p, "utf-8"));
+      if (wf) {
+        try {
+          const st = statSync(p);
+          wf.created = new Date(st.birthtimeMs || st.mtimeMs).toISOString();
+        } catch {
+        }
+        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 setWorkflowEnabled(projectRoot, name, enabled) {
+  const wf = getWorkflow(projectRoot, name);
+  if (!wf) return null;
+  const next = { ...wf };
+  if (enabled) delete next.enabled;
+  else next.enabled = false;
+  saveWorkflow(projectRoot, next);
+  return next;
+}
+function removeWorkflow(projectRoot, name) {
+  const p = workflowPath(projectRoot, name);
+  if (!existsSync(p)) return false;
+  try {
+    unlinkSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export { saveWorkflow as a, rawWorkflow as b, workflowSteps as c, workflowsDir as d, getWorkflow as g, isWorkflowEnabled as i, listWorkflows as l, removeWorkflow as r, setWorkflowEnabled as s, workflowCrons as w };

package/dist/supervisorLock-DmfzJx7B.mjs

@@ -0,0 +1,159 @@
+import { existsSync, readFileSync, unlinkSync, openSync, writeSync, closeSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+
+function acquireSupervisorLock(pidFile, pid = process.pid) {
+  try {
+    const fd = openSync(pidFile, "wx");
+    try {
+      writeSync(fd, String(pid));
+    } finally {
+      closeSync(fd);
+    }
+    return { acquired: true };
+  } catch (err) {
+    if (err?.code !== "EEXIST") throw err;
+  }
+  let existingPid = 0;
+  try {
+    existingPid = parseInt(readFileSync(pidFile, "utf-8").trim(), 10);
+  } catch {
+  }
+  if (!existingPid || Number.isNaN(existingPid) || existingPid <= 0) {
+    try {
+      unlinkSync(pidFile);
+    } catch {
+    }
+    return { acquired: false, staleCleaned: true };
+  }
+  if (isPidAlive(existingPid)) {
+    return { acquired: false, heldBy: existingPid };
+  }
+  try {
+    unlinkSync(pidFile);
+  } catch {
+  }
+  return { acquired: false, staleCleaned: true };
+}
+function acquireSupervisorLockWithRetry(pidFile, pid = process.pid) {
+  let result = acquireSupervisorLock(pidFile, pid);
+  if (!result.acquired && result.staleCleaned) {
+    result = acquireSupervisorLock(pidFile, pid);
+  }
+  return { acquired: result.acquired, heldBy: result.heldBy };
+}
+function releaseSupervisorLock(pidFile, pid = process.pid) {
+  try {
+    if (!existsSync(pidFile)) return;
+    const content = parseInt(readFileSync(pidFile, "utf-8").trim(), 10);
+    if (content === pid) unlinkSync(pidFile);
+  } catch {
+  }
+}
+function isPidAlive(pid) {
+  if (!pid || Number.isNaN(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err?.code === "EPERM";
+  }
+}
+function findOrphanedSyncPids(currentSupervisorPid = process.pid) {
+  if (process.platform === "win32") return [];
+  const pids = [];
+  try {
+    const uid = typeof process.getuid === "function" ? process.getuid() : void 0;
+    const pgrepArgs = uid !== void 0 ? ["-u", String(uid), "-af", "svamp daemon start-sync"] : ["-af", "svamp daemon start-sync"];
+    const output = execFileSync("pgrep", pgrepArgs, {
+      encoding: "utf-8",
+      timeout: 5e3
+    });
+    for (const line of output.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      const match = trimmed.match(/^(\d+)\s/);
+      if (!match) continue;
+      const pid = parseInt(match[1], 10);
+      if (Number.isNaN(pid) || pid <= 0) continue;
+      if (pid === process.pid) continue;
+      const ppid = getPpid(pid);
+      if (ppid === currentSupervisorPid) continue;
+      pids.push(pid);
+    }
+  } catch (err) {
+    if (err?.status !== 1) ;
+  }
+  return pids;
+}
+function getPpid(pid) {
+  if (process.platform === "win32") return 0;
+  try {
+    const out = execFileSync("ps", ["-o", "ppid=", "-p", String(pid)], {
+      encoding: "utf-8",
+      timeout: 2e3
+    }).trim();
+    const ppid = parseInt(out, 10);
+    return Number.isNaN(ppid) ? 0 : ppid;
+  } catch {
+    return 0;
+  }
+}
+async function killOrphanedSyncs(pids, opts = {}) {
+  if (pids.length === 0) return;
+  const log = opts.log || (() => {
+  });
+  const gracePeriodMs = opts.gracePeriodMs ?? 3e3;
+  log(`Killing ${pids.length} orphan sync daemon(s): ${pids.join(", ")}`);
+  for (const pid of pids) {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+    }
+  }
+  const pollStep = 100;
+  const steps = Math.max(1, Math.ceil(gracePeriodMs / pollStep));
+  for (let i = 0; i < steps; i++) {
+    await new Promise((r) => setTimeout(r, pollStep));
+    if (pids.every((p) => !isPidAlive(p))) {
+      log("All orphan daemons exited cleanly");
+      return;
+    }
+  }
+  const survivors = pids.filter(isPidAlive);
+  if (survivors.length > 0) {
+    log(`Force-killing survivors: ${survivors.join(", ")}`);
+    for (const pid of survivors) {
+      try {
+        process.kill(pid, "SIGKILL");
+      } catch {
+      }
+    }
+  }
+}
+function watchParentLiveness(opts) {
+  if (process.env.SVAMP_SUPERVISED !== "1") {
+    return () => {
+    };
+  }
+  const supervisorPid = process.ppid;
+  if (!supervisorPid || supervisorPid === 1) {
+    return () => {
+    };
+  }
+  const intervalMs = opts.intervalMs ?? 5e3;
+  let fired = false;
+  const timer = setInterval(() => {
+    if (fired) return;
+    if (!isPidAlive(supervisorPid)) {
+      fired = true;
+      clearInterval(timer);
+      opts.onParentDeath();
+    }
+  }, intervalMs);
+  timer.unref?.();
+  return () => {
+    clearInterval(timer);
+  };
+}
+
+export { acquireSupervisorLock, acquireSupervisorLockWithRetry, findOrphanedSyncPids, getPpid, isPidAlive, killOrphanedSyncs, releaseSupervisorLock, watchParentLiveness };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svamp-cli",
-  "version": "0.2.225",
+  "version": "0.2.227",
   "description": "Svamp CLI — AI workspace daemon on Hypha Cloud",
   "author": "Amun AI AB",
   "license": "SEE LICENSE IN LICENSE",