@glrs-dev/cli 0.3.1 → 1.0.1

package/dist/vendor/harness-opencode/dist/chunk-KB7M7JXU.js

@@ -0,0 +1,145 @@
+// src/pilot/worker/safety-gate.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import picomatch from "picomatch";
+var execFileP = promisify(execFile);
+var SAFETY_GATE_TOLERATE = [
+  // opencode plugin installer churn. opencode upgrades its own plugin
+  // dependency in the background, which bumps the pinned version in
+  // .opencode/package.json + .opencode/package-lock.json. Users don't
+  // author those edits; refusing to start pilot because of them is a
+  // consistent friction.
+  ".opencode/**",
+  // Next.js — `next build` regenerates this every run, often outside
+  // a pilot session.
+  "**/next-env.d.ts",
+  // Next.js app-router generated types.
+  "**/.next/types/**",
+  "**/.next/dev/types/**",
+  // TypeScript project-reference build info — tsc writes these.
+  "**/*.tsbuildinfo",
+  // Snapshot test files rewritten by `vitest -u` / `jest -u`.
+  "**/__snapshots__/**",
+  "**/*.snap"
+];
+async function git(cwd, args) {
+  for (const a of args) {
+    if (a.includes("\0")) {
+      throw new Error(`git arg contains null byte: ${JSON.stringify(a)}`);
+    }
+  }
+  try {
+    const { stdout, stderr } = await execFileP("git", args, {
+      cwd,
+      timeout: 1e4,
+      maxBuffer: 1 << 20
+    });
+    return { stdout: stdout.toString(), stderr: stderr.toString(), ok: true };
+  } catch (err) {
+    const e = err;
+    return {
+      stdout: (e.stdout ?? "").toString(),
+      stderr: (e.stderr ?? "").toString(),
+      ok: false
+    };
+  }
+}
+async function headSha(cwd) {
+  const r = await git(cwd, ["rev-parse", "HEAD"]);
+  if (!r.ok) throw new Error(`git rev-parse HEAD failed: ${r.stderr.trim()}`);
+  return r.stdout.trim();
+}
+var FORBIDDEN_BRANCHES = /* @__PURE__ */ new Set(["main", "master"]);
+function parsePorcelainPaths(stdout) {
+  const paths = [];
+  for (const line of stdout.split("\n")) {
+    if (line.length < 4) continue;
+    let rest = line.slice(3);
+    const arrow = rest.indexOf(" -> ");
+    if (arrow !== -1) rest = rest.slice(arrow + 4);
+    if (rest.startsWith('"') && rest.endsWith('"')) {
+      rest = rest.slice(1, -1);
+    }
+    paths.push(rest);
+  }
+  return paths;
+}
+async function checkCwdSafety(cwd) {
+  const inside = await git(cwd, ["rev-parse", "--is-inside-work-tree"]);
+  if (!inside.ok || inside.stdout.trim() !== "true") {
+    return {
+      ok: false,
+      reason: `not inside a git worktree: ${cwd}`
+    };
+  }
+  const branchRes = await git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
+  if (!branchRes.ok) {
+    return {
+      ok: false,
+      reason: `cannot determine current branch: ${branchRes.stderr.trim()}`
+    };
+  }
+  const branch = branchRes.stdout.trim();
+  if (FORBIDDEN_BRANCHES.has(branch)) {
+    return {
+      ok: false,
+      reason: `refuse to run on protected branch: ${branch}. Switch to a feature branch first.`
+    };
+  }
+  const defaultRes = await git(cwd, [
+    "symbolic-ref",
+    "--short",
+    "refs/remotes/origin/HEAD"
+  ]);
+  if (defaultRes.ok) {
+    const remoteDefault = defaultRes.stdout.trim().replace(/^origin\//, "");
+    if (remoteDefault && branch === remoteDefault) {
+      return {
+        ok: false,
+        reason: `refuse to run on the remote's default branch: ${branch}. Switch to a feature branch first.`
+      };
+    }
+  }
+  const statusRes = await git(cwd, ["status", "--porcelain"]);
+  if (!statusRes.ok) {
+    return {
+      ok: false,
+      reason: `git status failed: ${statusRes.stderr.trim()}`
+    };
+  }
+  const rawStdout = statusRes.stdout.replace(/\n$/, "");
+  if (rawStdout.length === 0) {
+    return { ok: true, warnings: [] };
+  }
+  const paths = parsePorcelainPaths(rawStdout);
+  const matchTolerate = picomatch([...SAFETY_GATE_TOLERATE], { dot: true });
+  const tolerated = [];
+  const genuine = [];
+  for (const p of paths) {
+    if (matchTolerate(p)) tolerated.push(p);
+    else genuine.push(p);
+  }
+  if (genuine.length > 0) {
+    const lines = rawStdout.split("\n").slice(0, 10).map((s) => "  " + s).join("\n");
+    return {
+      ok: false,
+      reason: `working tree is dirty; pilot refuses to run on uncommitted changes.
+Commit, stash, or discard them, then re-run.
+First 10 lines of git status --porcelain:
+${lines}`
+    };
+  }
+  const preview = tolerated.slice(0, 5);
+  const suffix = tolerated.length > preview.length ? ` (+${tolerated.length - preview.length} more)` : "";
+  const warnings = [
+    `working tree has ${tolerated.length} modified file(s) in framework-owned paths; treating tree as clean:
+` + preview.map((p) => `  ${p}`).join("\n") + suffix
+  ];
+  return { ok: true, warnings };
+}
+
+export {
+  SAFETY_GATE_TOLERATE,
+  headSha,
+  checkCwdSafety
+};

package/dist/vendor/harness-opencode/dist/chunk-RNRCXQ65.js

@@ -0,0 +1,56 @@
+// src/pilot/mcp/session-registry.ts
+import * as fs from "fs";
+import * as path from "path";
+import { promisify } from "util";
+var writeFile2 = promisify(fs.writeFile);
+var rename2 = promisify(fs.rename);
+var unlink2 = promisify(fs.unlink);
+var mkdir2 = promisify(fs.mkdir);
+function getSessionsPath(runDir) {
+  return path.join(runDir, "sessions.json");
+}
+function readSessions(runDir) {
+  const sessionsPath = getSessionsPath(runDir);
+  try {
+    const content = fs.readFileSync(sessionsPath, "utf8");
+    const parsed = JSON.parse(content);
+    if (typeof parsed !== "object" || parsed === null) {
+      return {};
+    }
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+async function registerSession(args) {
+  const { runDir, sessionId, runId, taskId } = args;
+  const sessionsPath = getSessionsPath(runDir);
+  await mkdir2(runDir, { recursive: true });
+  const current = readSessions(runDir);
+  const updated = {
+    ...current,
+    [sessionId]: { runId, taskId }
+  };
+  const tempPath = `${sessionsPath}.tmp.${process.pid}.${Math.random().toString(36).slice(2, 8)}`;
+  await writeFile2(tempPath, JSON.stringify(updated, null, 2), "utf8");
+  await rename2(tempPath, sessionsPath);
+}
+async function unregisterSession(args) {
+  const { runDir, sessionId } = args;
+  const sessionsPath = getSessionsPath(runDir);
+  const current = readSessions(runDir);
+  if (!(sessionId in current)) {
+    return;
+  }
+  const { [sessionId]: _, ...rest } = current;
+  const tempPath = `${sessionsPath}.tmp.${process.pid}.${Math.random().toString(36).slice(2, 8)}`;
+  await writeFile2(tempPath, JSON.stringify(rest, null, 2), "utf8");
+  await rename2(tempPath, sessionsPath);
+}
+
+export {
+  getSessionsPath,
+  readSessions,
+  registerSession,
+  unregisterSession
+};