svamp-cli 0.2.342 → 0.2.356

package/dist/store-B4E6NzG6.mjs

@@ -0,0 +1,356 @@
+import { existsSync, readFileSync, statSync, mkdirSync, writeFileSync, readdirSync, unlinkSync, renameSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { execFileSync, execSync, exec } from 'node:child_process';
+import { w as withFileLock } from './fileLock-BMPwCrB6.mjs';
+
+function normalizeStatus(s) {
+  if (s === "backlog") return "ready";
+  if (s === "done") return "archived";
+  return s === "ready" || s === "in_progress" || s === "paused" || s === "archived" ? s : "ready";
+}
+const ISSUE_STATUSES = ["ready", "in_progress", "paused", "archived"];
+const ISSUE_SCOPES = ["session", "project"];
+function parseStatusArg(s) {
+  return ISSUE_STATUSES.includes(s) ? s : null;
+}
+function parseScopeArg(s) {
+  return ISSUE_SCOPES.includes(s) ? s : null;
+}
+const FIELD_ORDER = ["id", "title", "status", "scope", "labels", "verify", "disposition", "triaged", "branch", "session", "owner", "original", "created", "closed", "question", "answer"];
+function resolveProjectRoot(start = process.cwd()) {
+  let dir = start;
+  for (let i = 0; i < 40; i++) {
+    if (existsSync(join(dir, ".git")) || existsSync(join(dir, ".svamp"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return start;
+}
+function issuesDir(projectRoot) {
+  return join(projectRoot, ".svamp", "issues");
+}
+function archiveDir(projectRoot) {
+  return join(issuesDir(projectRoot), "archive");
+}
+function issuePath(projectRoot, id, archived = false) {
+  return join(archived ? archiveDir(projectRoot) : issuesDir(projectRoot), `${id}.md`);
+}
+function serializeIssue(issue) {
+  const lines = ["---"];
+  for (const k of FIELD_ORDER) {
+    const v = issue[k];
+    if (v === void 0) continue;
+    lines.push(`${k}: ${JSON.stringify(v)}`);
+  }
+  lines.push("---", "");
+  return lines.join("\n") + (issue.body ? issue.body.replace(/\s+$/, "") + "\n" : "");
+}
+function parseIssue(content) {
+  const m = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!m) return null;
+  const fm = {};
+  for (const line of m[1].split("\n")) {
+    const idx = line.indexOf(": ");
+    if (idx === -1) continue;
+    const key = line.slice(0, idx).trim();
+    const raw = line.slice(idx + 2).trim();
+    try {
+      fm[key] = JSON.parse(raw);
+    } catch {
+      fm[key] = raw;
+    }
+  }
+  if (!fm.id) return null;
+  return {
+    id: String(fm.id),
+    title: String(fm.title ?? ""),
+    status: normalizeStatus(fm.status),
+    scope: fm.scope ?? "session",
+    labels: Array.isArray(fm.labels) ? fm.labels.map(String) : [],
+    verify: fm.verify ?? null,
+    disposition: fm.disposition === "crew" ? "crew" : "inline",
+    triaged: fm.triaged === true,
+    branch: fm.branch ?? null,
+    session: fm.session ?? null,
+    owner: fm.owner ?? null,
+    original: fm.original ?? null,
+    created: String(fm.created ?? (/* @__PURE__ */ new Date()).toISOString()),
+    closed: fm.closed ?? null,
+    question: fm.question && typeof fm.question === "object" ? fm.question : null,
+    answer: typeof fm.answer === "string" && fm.answer.trim() ? fm.answer : null,
+    body: (m[2] || "").trim() || void 0
+  };
+}
+function readDirWithMtime(dir) {
+  if (!existsSync(dir)) return [];
+  const out = [];
+  for (const name of readdirSync(dir)) {
+    if (!name.endsWith(".md")) continue;
+    try {
+      const p = join(dir, name);
+      const issue = parseIssue(readFileSync(p, "utf-8"));
+      if (issue) out.push({ issue, mtimeMs: statSync(p).mtimeMs });
+    } catch {
+    }
+  }
+  return out;
+}
+function listIssues(projectRoot, opts = {}) {
+  const entries = readDirWithMtime(issuesDir(projectRoot));
+  if (opts.includeArchived) entries.push(...readDirWithMtime(archiveDir(projectRoot)));
+  const byId = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const prev = byId.get(e.issue.id);
+    if (!prev || e.mtimeMs >= prev.mtimeMs) byId.set(e.issue.id, e);
+  }
+  let items = Array.from(byId.values()).map((e) => e.issue);
+  if (opts.status) items = items.filter((i) => i.status === opts.status);
+  if (opts.label) items = items.filter((i) => i.labels.includes(opts.label));
+  if (opts.scope) items = items.filter((i) => i.scope === opts.scope);
+  return items.sort((a, b) => Number(a.id) - Number(b.id));
+}
+function isPendingIssue(issue) {
+  return issue.status !== "archived" && issue.status !== "paused";
+}
+function applyTriageStatus(projectRoot, id, patch, fail) {
+  const current = getIssue(projectRoot, id);
+  if (current?.status === "archived") {
+    fail(`#${id} is archived (closed). Triage will not reopen it \u2014 use \`svamp issue reopen ${id}\` if that is what you mean.`);
+    return;
+  }
+  if (current?.status === "paused" && current.question) patch.question = null;
+  patch.status = "ready";
+}
+function isVisibleTo(issue, session) {
+  if (issue.scope === "session") return issue.session === session || issue.owner === session;
+  if (issue.owner === session) return true;
+  if (issue.session === session) return true;
+  if (!issue.owner && !issue.session) return true;
+  return false;
+}
+function normalizeIssueRef(id) {
+  const s = String(id ?? "").trim().replace(/^#+/, "");
+  return /^\d+$/.test(s) ? s.padStart(4, "0") : s;
+}
+function getIssue(projectRoot, id) {
+  const padded = normalizeIssueRef(id);
+  let best = null;
+  for (const p of [issuePath(projectRoot, padded), issuePath(projectRoot, padded, true)]) {
+    if (!existsSync(p)) continue;
+    try {
+      const issue = parseIssue(readFileSync(p, "utf-8"));
+      if (!issue) continue;
+      const mtimeMs = statSync(p).mtimeMs;
+      if (!best || mtimeMs >= best.mtimeMs) best = { issue, mtimeMs };
+    } catch {
+    }
+  }
+  if (best) return best.issue;
+  try {
+    for (const issue of listIssues(projectRoot, { includeArchived: true })) {
+      if (normalizeIssueRef(issue.id) === padded) return issue;
+    }
+  } catch {
+  }
+  return null;
+}
+function atomicWrite(path, content) {
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.tmp-${process.pid}-${randomBytes(4).toString("hex")}`;
+  writeFileSync(tmp, content);
+  renameSync(tmp, path);
+}
+function nextId(projectRoot) {
+  const all = listIssues(projectRoot, { includeArchived: true });
+  const max = all.reduce((acc, i) => Math.max(acc, Number(i.id) || 0), 0);
+  return String(max + 1).padStart(4, "0");
+}
+function addIssue(projectRoot, fields) {
+  const issue = {
+    id: nextId(projectRoot),
+    title: fields.title.trim(),
+    status: fields.status ?? "ready",
+    scope: fields.scope ?? "session",
+    labels: fields.labels ?? [],
+    verify: fields.verify ?? null,
+    disposition: fields.disposition ?? "inline",
+    triaged: fields.triaged ?? false,
+    branch: null,
+    session: fields.session ?? null,
+    owner: fields.owner ?? null,
+    original: fields.original ?? null,
+    created: (/* @__PURE__ */ new Date()).toISOString(),
+    closed: null,
+    body: fields.body
+  };
+  mkdirSync(dirname(issuePath(projectRoot, issue.id)), { recursive: true });
+  let n = Number(issue.id);
+  for (let attempt = 0; attempt < 1e4; attempt++) {
+    issue.id = String(n).padStart(4, "0");
+    try {
+      writeFileSync(issuePath(projectRoot, issue.id), serializeIssue(issue), { flag: "wx" });
+      return issue;
+    } catch (err) {
+      if (err && err.code === "EEXIST") {
+        n++;
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw new Error("addIssue: could not allocate a free issue id");
+}
+function issueLockPath(projectRoot, id) {
+  return join(issuesDir(projectRoot), `${normalizeIssueRef(id)}.lock`);
+}
+const ISSUE_LOCK_DEADLINE_MS = 3e3;
+function withIssueLock(projectRoot, id, fn) {
+  try {
+    mkdirSync(issuesDir(projectRoot), { recursive: true });
+  } catch {
+  }
+  return withFileLock(issueLockPath(projectRoot, id), fn, { deadlineMs: ISSUE_LOCK_DEADLINE_MS });
+}
+function _updateIssueUnlocked(projectRoot, id, patch) {
+  const cur = getIssue(projectRoot, id);
+  if (!cur) return null;
+  const wasArchived = cur.status === "archived";
+  const canonicalId = normalizeIssueRef(cur.id);
+  const next = { ...cur, ...patch, id: canonicalId };
+  if (patch.status) next.status = normalizeStatus(patch.status);
+  const nowArchived = next.status === "archived";
+  if (nowArchived && !next.closed) next.closed = (/* @__PURE__ */ new Date()).toISOString();
+  if (!nowArchived) next.closed = null;
+  atomicWrite(issuePath(projectRoot, next.id, nowArchived), serializeIssue(next));
+  for (const stale of [
+    issuePath(projectRoot, cur.id, wasArchived),
+    issuePath(projectRoot, cur.id, nowArchived)
+  ]) {
+    if (stale === issuePath(projectRoot, next.id, nowArchived)) continue;
+    try {
+      if (existsSync(stale)) unlinkSync(stale);
+    } catch {
+    }
+  }
+  return next;
+}
+function updateIssue(projectRoot, id, patch) {
+  return withIssueLock(projectRoot, id, () => _updateIssueUnlocked(projectRoot, id, patch));
+}
+function addComment(projectRoot, id, text) {
+  if (!text.trim()) return getIssue(projectRoot, id);
+  return withIssueLock(projectRoot, id, () => {
+    const cur = getIssue(projectRoot, id);
+    if (!cur) return null;
+    const entry = `
+
+---
+**Follow-up \xB7 ${(/* @__PURE__ */ new Date()).toISOString()}**
+
+${text.trim()}`;
+    const body = (cur.body ? cur.body.replace(/\s+$/, "") : "") + entry;
+    return _updateIssueUnlocked(projectRoot, id, { body });
+  });
+}
+function pauseIssue(projectRoot, id, question, blocked) {
+  const cur = getIssue(projectRoot, id);
+  if (!cur) return null;
+  const q = question?.text ? { text: question.text.trim(), options: (question.options || []).map((o) => String(o).trim()).filter(Boolean), askedAt: (/* @__PURE__ */ new Date()).toISOString() } : null;
+  const why = (blocked || "").trim();
+  if (q) {
+    const optLine = q.options && q.options.length ? `
+Options: ${q.options.join(" \xB7 ")}` : "";
+    const blockLine = why ? `
+Blocked: ${why}` : "";
+    addComment(projectRoot, id, `\u23F8 Paused \u2014 needs your input: ${q.text}${optLine}${blockLine}`);
+  } else if (why) {
+    addComment(projectRoot, id, `\u23F8 Paused \u2014 BLOCKED: ${why}`);
+  } else {
+    addComment(projectRoot, id, "\u23F8 Paused \u2014 waiting on your input.");
+  }
+  return updateIssue(projectRoot, id, { status: "paused", question: q, answer: null });
+}
+function resumeIssue(projectRoot, id, answer) {
+  const cur = getIssue(projectRoot, id);
+  if (!cur) return null;
+  const a = answer && answer.trim() ? answer.trim() : "";
+  if (a) addComment(projectRoot, id, `\u25B6 Resumed \u2014 your answer: ${a}`);
+  else addComment(projectRoot, id, "\u25B6 Resumed.");
+  return updateIssue(projectRoot, id, { status: "in_progress", question: null, answer: a || null });
+}
+function routeCrewVerdict(projectRoot, childSessionId, v) {
+  const linked = listIssues(projectRoot, { includeArchived: true }).find((i) => i.disposition === "crew" && i.session === childSessionId);
+  if (!linked) return null;
+  const meta = [v.round != null ? `round ${v.round}` : "", v.judge ? `judge:${v.judge}` : ""].filter(Boolean).join(", ");
+  addComment(projectRoot, linked.id, `Crew child ${childSessionId.slice(0, 8)} \u2192 ${v.verdict}${meta ? ` (${meta})` : ""}.${v.guidance ? " " + v.guidance : ""}`);
+  return v.verdict === "approved" ? updateIssue(projectRoot, linked.id, { status: "archived" }) ?? null : getIssue(projectRoot, linked.id);
+}
+function resolveCrewIssueOnMerge(projectRoot, childSessionId, detail = {}) {
+  const linked = listIssues(projectRoot, { includeArchived: true }).find((i) => i.disposition === "crew" && i.session === childSessionId);
+  if (!linked) return null;
+  if (linked.status === "archived") return linked;
+  const where = detail.branch && detail.base ? ` ${detail.branch} \u2192 ${detail.base}` : "";
+  addComment(projectRoot, linked.id, `Merged${where} by the lead; crew child ${childSessionId.slice(0, 8)} archived. Closing.`);
+  return updateIssue(projectRoot, linked.id, { status: "archived" }) ?? null;
+}
+function searchIssues(projectRoot, query) {
+  const q = query.trim();
+  if (!q) return [];
+  try {
+    const out = execFileSync("rg", ["-l", "-i", "-F", "--no-messages", "-e", q, "--", issuesDir(projectRoot)], { encoding: "utf-8" });
+    const files = out.split("\n").filter(Boolean);
+    const issues = [];
+    for (const f of files) {
+      try {
+        const i = parseIssue(readFileSync(f, "utf-8"));
+        if (i) issues.push(i);
+      } catch {
+      }
+    }
+    return issues.sort((a, b) => Number(a.id) - Number(b.id));
+  } catch (e) {
+    if (e?.status === 1) return [];
+    return searchIssuesInMemory(projectRoot, q);
+  }
+}
+function searchIssuesInMemory(projectRoot, q) {
+  const ql = q.toLowerCase();
+  return listIssues(projectRoot, { includeArchived: true }).filter((i) => i.title.toLowerCase().includes(ql) || (i.body || "").toLowerCase().includes(ql) || i.labels.some((l) => l.toLowerCase().includes(ql)));
+}
+function verifyGateCommand(issue) {
+  return issue?.verify?.type === "command" ? (issue.verify.text || "").trim() : "";
+}
+const VERIFY_GATE_TIMEOUT_MS = 6e5;
+const VERIFY_GATE_MAX_BUFFER = 64 * 1024 * 1024;
+function verifyGateFailure(cmd, stdout, stderr) {
+  const output = (String(stdout || "") + String(stderr || "")).split("\n").slice(-15).join("\n").trim();
+  return { ok: false, cmd, output };
+}
+function checkVerifyCommand(projectRoot, issue) {
+  const cmd = verifyGateCommand(issue);
+  if (!cmd) return { ok: true };
+  try {
+    execSync(cmd, { cwd: projectRoot, stdio: "pipe", timeout: VERIFY_GATE_TIMEOUT_MS, maxBuffer: VERIFY_GATE_MAX_BUFFER });
+    return { ok: true, cmd };
+  } catch (e) {
+    return verifyGateFailure(cmd, e?.stdout, e?.stderr);
+  }
+}
+function checkVerifyCommandAsync(projectRoot, issue) {
+  const cmd = verifyGateCommand(issue);
+  if (!cmd) return Promise.resolve({ ok: true });
+  return new Promise((resolve) => {
+    exec(cmd, { cwd: projectRoot, timeout: VERIFY_GATE_TIMEOUT_MS, maxBuffer: VERIFY_GATE_MAX_BUFFER }, (err, stdout, stderr) => {
+      if (err) resolve(verifyGateFailure(cmd, stdout, stderr));
+      else resolve({ ok: true, cmd });
+    });
+  });
+}
+function summarize(issues) {
+  const by = (s) => issues.filter((i) => i.status === s).length;
+  return { total: issues.length, ready: by("ready"), in_progress: by("in_progress"), paused: by("paused"), archived: by("archived") };
+}
+
+export { ISSUE_SCOPES as I, applyTriageStatus as a, parseStatusArg as b, checkVerifyCommandAsync as c, ISSUE_STATUSES as d, resumeIssue as e, pauseIssue as f, getIssue as g, addComment as h, addIssue as i, isPendingIssue as j, isVisibleTo as k, listIssues as l, checkVerifyCommand as m, summarize as n, resolveCrewIssueOnMerge as o, parseScopeArg as p, routeCrewVerdict as q, resolveProjectRoot as r, searchIssues as s, updateIssue as u };

package/dist/store-fi0f-ff1.mjs

@@ -0,0 +1,184 @@
+import { existsSync, unlinkSync, readFileSync, readdirSync, statSync, mkdirSync, writeFileSync, renameSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomBytes } from 'node:crypto';
+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 workflowSchedules(wf) {
+  return (wf.on?.schedule || []).filter((s) => !!s?.cron);
+}
+function workflowsDir(projectRoot) {
+  return join(projectRoot, ".svamp", "workflows");
+}
+function validateWorkflowName(name) {
+  if (typeof name !== "string" || !/^[A-Za-z0-9._-]+$/.test(name) || name === "." || name === "..") {
+    throw new Error(`Invalid workflow name "${name}" \u2014 allowed: letters, digits, dot, dash, underscore (no path separators).`);
+  }
+  return name;
+}
+function workflowPath(projectRoot, name) {
+  return join(workflowsDir(projectRoot), `${validateWorkflowName(name)}.yaml`);
+}
+function resolveWorkflowPath(projectRoot, name) {
+  const canonical = workflowPath(projectRoot, name);
+  if (existsSync(canonical)) return canonical;
+  const alt = join(workflowsDir(projectRoot), `${validateWorkflowName(name)}.yml`);
+  return existsSync(alt) ? alt : canonical;
+}
+function normalizeOn(on) {
+  if (!on || typeof on !== "object") {
+    return void 0;
+  }
+  const out = {};
+  if (Array.isArray(on.schedule)) {
+    const sched = on.schedule.map((s) => {
+      const entry = { cron: String(s?.cron ?? s ?? "") };
+      if (s && typeof s === "object" && s.tz != null && String(s.tz).trim()) entry.tz = String(s.tz).trim();
+      return entry;
+    }).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);
+  if ("idle" in on && on.idle !== false || on.idle === true) out.idle = true;
+  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) => s.tz ? { cron: s.cron, tz: s.tz } : { 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 (wf.on?.idle) on.idle = {};
+  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) {
+  let p;
+  try {
+    p = resolveWorkflowPath(projectRoot, name);
+  } catch {
+    return null;
+  }
+  if (!existsSync(p)) return null;
+  try {
+    return parseWorkflow(readFileSync(p, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function rawWorkflow(projectRoot, name) {
+  let p;
+  try {
+    p = resolveWorkflowPath(projectRoot, name);
+  } catch {
+    return null;
+  }
+  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}-${randomBytes(4).toString("hex")}`;
+  writeFileSync(tmp, serializeWorkflow(wf));
+  renameSync(tmp, path);
+  const alt = join(dir, `${validateWorkflowName(wf.name)}.yml`);
+  if (alt !== path && existsSync(alt)) {
+    try {
+      unlinkSync(alt);
+    } catch {
+    }
+  }
+}
+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 = resolveWorkflowPath(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, validateWorkflowName as v, workflowSchedules as w };

package/dist/types-57J3Re0n.mjs

@@ -0,0 +1,17 @@
+const ROLE_HIERARCHY = {
+  view: 0,
+  interact: 1,
+  admin: 2
+};
+function normalizeAllowedUser(input, addedBy) {
+  const role = input.role && input.role in ROLE_HIERARCHY ? input.role : "admin";
+  return {
+    email: input.email.trim().toLowerCase(),
+    role,
+    addedAt: typeof input.addedAt === "number" ? input.addedAt : Date.now(),
+    addedBy: input.addedBy ?? addedBy
+  };
+}
+const ISOLATION_PREFERENCE = ["nono", "docker", "podman"];
+
+export { ISOLATION_PREFERENCE as I, ROLE_HIERARCHY as R, normalizeAllowedUser as n };

package/dist/wantsHelp-6bMOeNUz.mjs

@@ -0,0 +1,5 @@
+function wantsHelp(args) {
+  return args.some((a) => a === "--help" || a === "-h");
+}
+
+export { wantsHelp as w };

package/dist/wrapCommand-CdNawSaa.mjs

@@ -0,0 +1,117 @@
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+function expandHome(p) {
+  if (p === "~") return homedir();
+  if (p.startsWith("~/")) return join(homedir(), p.slice(2));
+  return p;
+}
+function wrapWithIsolation(originalCommand, originalArgs, config) {
+  switch (config.method) {
+    case "nono":
+      return wrapWithNono(originalCommand, originalArgs, config);
+    case "docker":
+      return wrapWithContainer("docker", originalCommand, originalArgs, config);
+    case "podman":
+      return wrapWithContainer("podman", originalCommand, originalArgs, config);
+    default:
+      throw new Error(`Unsupported isolation method: ${config.method}`);
+  }
+}
+function wrapWithNono(command, args, config) {
+  const nonoArgs = ["run"];
+  const env = {};
+  if (config.nonoConfig?.profilePath) {
+    nonoArgs.push("--profile", config.nonoConfig.profilePath);
+  } else if (config.nonoConfig?.profile) {
+    nonoArgs.push("--profile", config.nonoConfig.profile);
+  }
+  nonoArgs.push("--workdir", config.workspacePath);
+  nonoArgs.push("--allow-cwd");
+  if (config.credentialStagingPath) {
+    env.HOME = config.credentialStagingPath;
+    const realLocalDir = join(homedir(), ".local");
+    if (existsSync(realLocalDir)) {
+      nonoArgs.push("--read", realLocalDir);
+    }
+    const realKeychainDir = join(homedir(), "Library", "Keychains");
+    if (existsSync(realKeychainDir)) {
+      nonoArgs.push("--read", realKeychainDir);
+    }
+  }
+  if (config.nonoConfig?.allowDirs) {
+    for (const dir of config.nonoConfig.allowDirs) {
+      nonoArgs.push("--allow", expandHome(dir));
+    }
+  }
+  if (config.nonoConfig?.readDirs) {
+    for (const dir of config.nonoConfig.readDirs) {
+      nonoArgs.push("--read", expandHome(dir));
+    }
+  }
+  if (config.nonoConfig?.allowFiles) {
+    for (const file of config.nonoConfig.allowFiles) {
+      nonoArgs.push("--allow-file", expandHome(file));
+    }
+  }
+  if (config.nonoConfig?.readFiles) {
+    for (const file of config.nonoConfig.readFiles) {
+      nonoArgs.push("--read-file", expandHome(file));
+    }
+  }
+  if (config.nonoConfig?.netBlock) {
+    nonoArgs.push("--net-block");
+  }
+  if (config.nonoConfig?.proxyAllow) {
+    for (const host of config.nonoConfig.proxyAllow) {
+      nonoArgs.push("--proxy-allow", host);
+    }
+  }
+  if (config.nonoConfig?.silent !== false) {
+    nonoArgs.push("-s");
+  }
+  if (config.nonoConfig?.trustOverride) {
+    nonoArgs.push("--trust-override");
+  }
+  nonoArgs.push("--", command, ...args);
+  return {
+    command: config.binaryPath,
+    args: nonoArgs,
+    env: Object.keys(env).length > 0 ? env : void 0
+  };
+}
+function wrapWithContainer(runtime, command, args, config) {
+  const image = config.containerConfig?.image || "node:lts-slim";
+  const networkMode = config.containerConfig?.networkMode || "none";
+  const containerArgs = [
+    "run",
+    "--rm",
+    "-i",
+    // interactive (for stdin/stdout piping)
+    `--network=${networkMode}`,
+    "-v",
+    `${config.workspacePath}:${config.workspacePath}`,
+    "-w",
+    config.workspacePath
+  ];
+  if (config.credentialStagingPath) {
+    const stagedClaudeDir = join(config.credentialStagingPath, ".claude");
+    containerArgs.push("-v", `${stagedClaudeDir}:/root/.claude:ro`);
+    const stagedGitconfig = join(config.credentialStagingPath, ".gitconfig");
+    containerArgs.push("-v", `${stagedGitconfig}:/root/.gitconfig:ro`);
+    containerArgs.push("-e", "HOME=/root");
+  }
+  if (config.containerConfig?.extraMounts) {
+    for (const mount of config.containerConfig.extraMounts) {
+      containerArgs.push("-v", mount);
+    }
+  }
+  containerArgs.push(image, command, ...args);
+  return {
+    command: config.binaryPath,
+    args: containerArgs
+  };
+}
+
+export { wrapWithIsolation as w };