svamp-cli 0.2.190 → 0.2.193

package/dist/pinnedClaudeCode-HydRNEt7.mjs

@@ -0,0 +1,58 @@
+import { spawn, exec as exec$1 } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const PINNED_CLAUDE_CODE_VERSION = "2.1.168";
+const exec = promisify(exec$1);
+async function readClaudeVersion() {
+  try {
+    const { stdout } = await exec("claude --version", { timeout: 1e4 });
+    const m = stdout.trim().match(/(\d+\.\d+\.\d+(?:[-.][\w]+)?)/);
+    return m ? m[1] : null;
+  } catch {
+    return null;
+  }
+}
+function runInstaller(version, log) {
+  return new Promise((resolve) => {
+    const proc = spawn("claude", ["install", version], { stdio: ["ignore", "pipe", "pipe"] });
+    let stderr = "";
+    proc.stdout?.on("data", (b) => log(`[claude install] ${b.toString().trimEnd()}`));
+    proc.stderr?.on("data", (b) => {
+      const s = b.toString();
+      stderr += s;
+      log(`[claude install] ${s.trimEnd()}`);
+    });
+    proc.on("error", (e) => {
+      stderr += String(e);
+      resolve({ ok: false, stderr });
+    });
+    proc.on("exit", (code) => resolve({ ok: code === 0, stderr }));
+  });
+}
+async function ensureClaudeCodeVersion(log, pinned = PINNED_CLAUDE_CODE_VERSION, opts) {
+  const autoInstall = opts?.allowAutoInstall !== false;
+  const current = await readClaudeVersion();
+  if (!current) {
+    log(`[claude-version] 'claude' not on PATH \u2014 please run the Anthropic installer once: curl -fsSL https://claude.ai/install.sh | sh`);
+    return { kind: "not-installed", want: pinned };
+  }
+  if (current === pinned) {
+    log(`[claude-version] OK \u2014 claude ${current} matches pinned ${pinned}`);
+    return { kind: "ok", version: current };
+  }
+  if (!autoInstall) {
+    log(`[claude-version] DRIFT \u2014 installed ${current} \u2260 pinned ${pinned} (auto-install disabled)`);
+    return { kind: "skipped", reason: `installed=${current} pinned=${pinned}` };
+  }
+  log(`[claude-version] DRIFT \u2014 installed ${current} \u2260 pinned ${pinned}; running 'claude install ${pinned}'`);
+  const { ok, stderr } = await runInstaller(pinned, log);
+  if (!ok) {
+    log(`[claude-version] install failed for ${pinned}: ${stderr.trim().slice(0, 400)}`);
+    return { kind: "install-failed", from: current, want: pinned, error: stderr.slice(0, 400) };
+  }
+  const after = await readClaudeVersion();
+  log(`[claude-version] installer finished; now reports ${after ?? "unknown"}`);
+  return { kind: "installed", from: current, to: after ?? pinned };
+}
+
+export { PINNED_CLAUDE_CODE_VERSION, ensureClaudeCodeVersion };

package/dist/rpc-CBVukorH.mjs

@@ -0,0 +1,87 @@
+import { spawnSync } from 'node:child_process';
+import { m as resolveProjectRoot } from './run-B_UWCqRV.mjs';
+import { g as getWorkflow, w as workflowSteps, s as setWorkflowEnabled, r as removeWorkflow, a as saveWorkflow, b as rawWorkflow, l as listWorkflows } from './store-DEZ8e-uE.mjs';
+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';
+import 'yaml';
+
+function workflowRpc(cwd, params) {
+  const root = resolveProjectRoot(cwd || process.cwd());
+  const op = params.op;
+  switch (op) {
+    case "list":
+      return listWorkflows(root);
+    case "show": {
+      const wf = getWorkflow(root, String(params.name));
+      return { meta: wf, yaml: wf ? rawWorkflow(root, String(params.name)) || "" : null };
+    }
+    case "add": {
+      const on = {};
+      const crons = Array.isArray(params.cron) ? params.cron.map(String) : params.cron ? [String(params.cron)] : [];
+      if (crons.length) on.schedule = crons.map((c) => ({ cron: c }));
+      if (params.dispatch || params.workflow_dispatch) on.workflow_dispatch = true;
+      if (params.channel) on.channel = String(params.channel);
+      if (Array.isArray(params.issue) && params.issue.length) on.issue = params.issue.map(String);
+      const runs = Array.isArray(params.runs) ? params.runs.map(String).filter(Boolean) : [];
+      if (!params.name || !runs.length) throw new Error("workflow add: name and at least one run step required");
+      const wf = {
+        name: String(params.name),
+        on: Object.keys(on).length ? on : void 0,
+        jobs: { run: { steps: runs.map((r) => ({ run: r })) } },
+        session: params.session || null
+      };
+      saveWorkflow(root, wf);
+      return wf;
+    }
+    case "remove":
+      return { removed: removeWorkflow(root, String(params.name)) };
+    case "enable":
+    case "disable": {
+      const wf = setWorkflowEnabled(root, String(params.name), op === "enable");
+      if (!wf) throw new Error(`Workflow not found: ${params.name}`);
+      return wf;
+    }
+    case "run": {
+      const wf = getWorkflow(root, String(params.name));
+      if (!wf) throw new Error(`Workflow not found: ${params.name}`);
+      const steps = workflowSteps(wf);
+      const stepEnv = wf.session ? { ...process.env, SVAMP_SESSION_ID: wf.session } : process.env;
+      const out = [`\u25B6 running workflow "${wf.name}" (${steps.length} step${steps.length === 1 ? "" : "s"})`];
+      for (let i = 0; i < steps.length; i++) {
+        const step = steps[i];
+        out.push(`  [${i + 1}/${steps.length}] $ ${step.run}`);
+        const r = spawnSync("sh", ["-c", step.run], { cwd: root, encoding: "utf-8", timeout: 12e4, env: stepEnv });
+        if (r.stdout) out.push(r.stdout.trimEnd());
+        if (r.stderr) out.push(r.stderr.trimEnd());
+        if (r.status !== 0) {
+          out.push(`  \u2717 step ${i + 1} failed (exit ${r.status ?? "signal"}). Stopping.`);
+          return { ok: false, output: out.join("\n") };
+        }
+      }
+      out.push(`\u2713 workflow "${wf.name}" completed.`);
+      return { ok: true, output: out.join("\n") };
+    }
+    default:
+      throw new Error(`workflow rpc: unknown op "${op}"`);
+  }
+}
+
+export { workflowRpc };

package/dist/rpc-MAQMw8il.mjs

@@ -0,0 +1,151 @@
+import { m as resolveProjectRoot, u as updateIssue, n as getIssue, o as addComment, p as addIssue, q as listIssues, t as searchIssues } from './run-B_UWCqRV.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';
+
+function compact(i) {
+  const { body, original, ...rest } = i;
+  return rest;
+}
+function buildVerify(p) {
+  if (p.verifyCmd) return { type: "command", text: String(p.verifyCmd) };
+  if (p.verify) return { type: "agent", text: String(p.verify) };
+  if (p.manual) return { type: "manual" };
+  if (p.noVerify) return null;
+  return void 0;
+}
+function ownerScoped(items, session) {
+  if (!session) return items;
+  return items.filter((i) => i.scope === "project" || i.session === session);
+}
+const STATUS_MAP = {
+  ready: "ready",
+  start: "in_progress",
+  close: "archived",
+  done: "archived",
+  reopen: "ready",
+  archive: "archived",
+  backlog: "ready"
+};
+function issueRpc(cwd, params) {
+  const root = resolveProjectRoot(cwd || process.cwd());
+  const op = params.op;
+  switch (op) {
+    case "list": {
+      const opts = { includeArchived: params.status === "all" || params.status === "archived" || params.includeArchived };
+      if (params.status && params.status !== "all") opts.status = params.status;
+      if (params.label) opts.label = params.label;
+      if (params.scope) opts.scope = params.scope;
+      return ownerScoped(listIssues(root, opts), params.session).map(compact);
+    }
+    case "show":
+      return getIssue(root, String(params.id));
+    case "search":
+      return ownerScoped(searchIssues(root, String(params.query || "")), params.session).map(compact);
+    case "pending": {
+      const items = ownerScoped(listIssues(root), params.session).filter((i) => i.status === "ready" || i.status === "in_progress");
+      return { pending: items.map((i) => i.id), count: items.length };
+    }
+    case "add": {
+      const owner = params.session || null;
+      const scope = params.scope || (owner ? "session" : "project");
+      let title = params.title ? String(params.title) : "";
+      let body = params.body ? String(params.body) : void 0;
+      let original;
+      if (!title) {
+        const src = (body || "").trim();
+        if (!src) throw new Error("issue add: title or body required");
+        const nl = src.indexOf("\n");
+        title = (nl === -1 ? src : src.slice(0, nl)).trim().slice(0, 200);
+        original = src;
+        body = void 0;
+      }
+      return addIssue(root, {
+        title,
+        status: "ready",
+        scope,
+        labels: Array.isArray(params.labels) ? params.labels.map(String) : [],
+        verify: buildVerify(params) ?? null,
+        session: scope === "session" ? owner : null,
+        original,
+        body
+      });
+    }
+    case "comment":
+      return addComment(root, String(params.id), String(params.text || ""));
+    case "status": {
+      const status = STATUS_MAP[params.status];
+      if (!status) throw new Error(`issue status: unknown status "${params.status}"`);
+      const patch = { status };
+      if (status === "in_progress" && params.session) {
+        const cur = getIssue(root, String(params.id));
+        if (cur && cur.scope === "project" && !cur.session) patch.session = params.session;
+      }
+      const updated = updateIssue(root, String(params.id), patch);
+      if (!updated) throw new Error(`Issue not found: ${params.id}`);
+      return updated;
+    }
+    case "work": {
+      const patch = { status: "in_progress" };
+      if (params.branch) patch.branch = String(params.branch);
+      const worker = params.session || null;
+      const cur = getIssue(root, String(params.id));
+      if (worker && cur && cur.scope === "project" && !cur.session) patch.session = worker;
+      const updated = updateIssue(root, String(params.id), patch);
+      if (!updated) throw new Error(`Issue not found: ${params.id}`);
+      return updated;
+    }
+    case "edit": {
+      const patch = {};
+      if (params.title != null) patch.title = String(params.title);
+      if (Array.isArray(params.labels)) patch.labels = params.labels.map(String);
+      const v = buildVerify(params);
+      if (v !== void 0) patch.verify = v;
+      if (params.scope) patch.scope = params.scope;
+      if (params.unclaim) patch.session = null;
+      else if (params.session != null) patch.session = String(params.session);
+      if (params.body != null) patch.body = String(params.body);
+      if (params.status) patch.status = params.status;
+      if (params.disposition) patch.disposition = params.disposition === "crew" ? "crew" : "inline";
+      if (params.triaged) patch.triaged = true;
+      const updated = updateIssue(root, String(params.id), patch);
+      if (!updated) throw new Error(`Issue not found: ${params.id}`);
+      return updated;
+    }
+    case "triage": {
+      const patch = { triaged: true };
+      if (params.title != null) patch.title = String(params.title);
+      if (Array.isArray(params.labels) && params.labels.length) patch.labels = params.labels.map(String);
+      if (params.disposition) patch.disposition = params.disposition === "crew" ? "crew" : "inline";
+      const v = buildVerify(params);
+      if (v) patch.verify = v;
+      if (params.body != null) patch.body = String(params.body);
+      patch.status = "ready";
+      const updated = updateIssue(root, String(params.id), patch);
+      if (!updated) throw new Error(`Issue not found: ${params.id}`);
+      return updated;
+    }
+    default:
+      throw new Error(`issue rpc: unknown op "${op}"`);
+  }
+}
+
+export { issueRpc };