@glrs-dev/harness-plugin-opencode 0.3.1 → 1.0.0

package/dist/chunk-BKTFWXLG.js

@@ -0,0 +1,204 @@
+// src/pilot/paths.ts
+import { promises as fs2 } from "fs";
+import * as os2 from "os";
+import * as path2 from "path";
+
+// src/plan-paths.ts
+import { execFile } from "child_process";
+import * as fs from "fs/promises";
+import * as os from "os";
+import * as path from "path";
+function execFileP(file, args, opts = {}) {
+  const { cwd, timeoutMs = 5e3 } = opts;
+  return new Promise((resolve2, reject) => {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    execFile(
+      file,
+      args,
+      { signal: controller.signal, cwd, encoding: "utf8" },
+      (err, stdout) => {
+        clearTimeout(timer);
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve2(stdout ?? "");
+      }
+    );
+  });
+}
+function expandTilde(p) {
+  if (p === "~") return os.homedir();
+  if (p.startsWith("~/")) return path.join(os.homedir(), p.slice(2));
+  return p;
+}
+async function getRepoFolder(worktreeDir) {
+  let stdout;
+  try {
+    stdout = await execFileP(
+      "git",
+      ["rev-parse", "--git-common-dir"],
+      { cwd: worktreeDir }
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "unknown error running `git rev-parse --git-common-dir`";
+    throw new Error(
+      `getRepoFolder: failed to resolve git-common-dir for ${worktreeDir}: ${msg}`
+    );
+  }
+  const gitCommonDir = stdout.trim();
+  if (!gitCommonDir) {
+    throw new Error(
+      `getRepoFolder: \`git rev-parse --git-common-dir\` returned empty for ${worktreeDir}`
+    );
+  }
+  const absCommonDir = path.isAbsolute(gitCommonDir) ? gitCommonDir : path.resolve(worktreeDir, gitCommonDir);
+  const repoRoot = path.dirname(absCommonDir);
+  return path.basename(repoRoot);
+}
+async function getPlanDir(worktreeDir) {
+  const override = process.env.GLORIOUS_PLAN_DIR;
+  const base = override ? expandTilde(override) : path.join(os.homedir(), ".glorious", "opencode");
+  const repoFolder = await getRepoFolder(worktreeDir);
+  const planDir = path.join(base, repoFolder, "plans");
+  await fs.mkdir(planDir, { recursive: true });
+  return planDir;
+}
+async function migratePlans(worktreeDir, planDir) {
+  const oldDir = path.join(worktreeDir, ".agent", "plans");
+  const marker = path.join(oldDir, ".migrated");
+  try {
+    await fs.stat(oldDir);
+  } catch {
+    return;
+  }
+  try {
+    await fs.stat(marker);
+    return;
+  } catch {
+  }
+  let entries;
+  try {
+    entries = await fs.readdir(oldDir);
+  } catch {
+    return;
+  }
+  const planFiles = entries.filter(
+    (name) => name.endsWith(".md") && !name.startsWith(".")
+  );
+  await fs.mkdir(planDir, { recursive: true });
+  for (const name of planFiles) {
+    const src = path.join(oldDir, name);
+    const dst = path.join(planDir, name);
+    let dstExists = false;
+    try {
+      await fs.stat(dst);
+      dstExists = true;
+    } catch {
+      dstExists = false;
+    }
+    if (!dstExists) {
+      await fs.rename(src, dst);
+      continue;
+    }
+    const [srcBuf, dstBuf] = await Promise.all([
+      fs.readFile(src),
+      fs.readFile(dst)
+    ]);
+    if (srcBuf.equals(dstBuf)) {
+      await fs.unlink(src);
+      continue;
+    }
+    process.stderr.write(
+      `[harness-opencode] migratePlans: conflict on ${name} \u2014 destination ${dst} exists with different content; leaving source ${src} in place. Resolve manually.
+`
+    );
+  }
+  await fs.writeFile(marker, "");
+}
+
+// src/pilot/paths.ts
+function expandTilde2(p) {
+  if (p === "~") return os2.homedir();
+  if (p.startsWith("~/")) return path2.join(os2.homedir(), p.slice(2));
+  return p;
+}
+function resolveBaseDir() {
+  const pilotEnv = process.env.GLORIOUS_PILOT_DIR;
+  if (pilotEnv) return expandTilde2(pilotEnv);
+  const planEnv = process.env.GLORIOUS_PLAN_DIR;
+  if (planEnv) {
+    return path2.dirname(expandTilde2(planEnv));
+  }
+  return path2.join(os2.homedir(), ".glorious", "opencode");
+}
+async function getPilotDir(cwd) {
+  const base = resolveBaseDir();
+  const repoFolder = await getRepoFolder(cwd);
+  const dir = path2.join(base, repoFolder, "pilot");
+  await fs2.mkdir(dir, { recursive: true });
+  return dir;
+}
+async function getPlansDir(cwd) {
+  const pilot = await getPilotDir(cwd);
+  const dir = path2.join(pilot, "plans");
+  await fs2.mkdir(dir, { recursive: true });
+  return dir;
+}
+async function getRunDir(cwd, runId) {
+  if (!isSafeRunId(runId)) {
+    throw new Error(
+      `getRunDir: runId ${JSON.stringify(runId)} is not a safe filesystem segment`
+    );
+  }
+  const pilot = await getPilotDir(cwd);
+  const dir = path2.join(pilot, "runs", runId);
+  await fs2.mkdir(dir, { recursive: true });
+  return dir;
+}
+async function getStateDbPath(cwd, runId) {
+  const runDir = await getRunDir(cwd, runId);
+  return path2.join(runDir, "state.db");
+}
+async function getWorkerJsonlPath(cwd, runId, n) {
+  const runDir = await getRunDir(cwd, runId);
+  const workersDir = path2.join(runDir, "workers");
+  await fs2.mkdir(workersDir, { recursive: true });
+  const padded = n.toString().padStart(2, "0");
+  return path2.join(workersDir, `${padded}.jsonl`);
+}
+async function getTaskJsonlPath(cwd, runId, taskId) {
+  if (!isSafeRunId(runId)) {
+    throw new Error(
+      `getTaskJsonlPath: runId ${JSON.stringify(runId)} is not a safe filesystem segment`
+    );
+  }
+  if (!isSafeTaskId(taskId)) {
+    throw new Error(
+      `getTaskJsonlPath: taskId ${JSON.stringify(taskId)} is not a safe filesystem segment`
+    );
+  }
+  const runDir = await getRunDir(cwd, runId);
+  const taskDir = path2.join(runDir, "tasks", taskId);
+  await fs2.mkdir(taskDir, { recursive: true });
+  return path2.join(taskDir, "session.jsonl");
+}
+function isSafeRunId(runId) {
+  return /^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(runId);
+}
+function isSafeTaskId(taskId) {
+  return /^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(taskId);
+}
+
+export {
+  getPlanDir,
+  migratePlans,
+  resolveBaseDir,
+  getPilotDir,
+  getPlansDir,
+  getRunDir,
+  getStateDbPath,
+  getWorkerJsonlPath,
+  getTaskJsonlPath
+};

package/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/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
+};