@gleapai/kai-bridge 0.2.0

package/src/workspace.mjs

@@ -0,0 +1,175 @@
+// Where a session's changes land on the device.
+//
+//   worktree (default) — `~/.kai/worktrees/<repo>/<session-slug>` created
+//                        from a fresh `origin/<base>`; identical to the
+//                        cloud flow, never touches the user's checkout.
+//                        Optionally starts from the checkout's uncommitted
+//                        changes (applied as a patch).
+//   local              — run in place on the checkout's current branch; the
+//                        dashboard shows the dirty-file count first.
+//
+// Multi-repo sessions bind each repo independently (one may be local,
+// another a worktree). Git ops ported from the retired desktop runtime's
+// git-checkout-ops.mjs in spirit: plain `git` CLI, no libraries.
+
+import { execFileSync } from "node:child_process";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+function git(cwd, args, opts = {}) {
+  return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], ...opts }).trim();
+}
+
+export function sessionSlug(sessionId, title) {
+  const t = String(title || "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 32);
+  const id = String(sessionId || "").slice(-8);
+  return t ? `${t}-${id}` : `session-${id}`;
+}
+
+export function worktreePath(kaiHome, repoName, slug) {
+  return join(kaiHome, "worktrees", repoName, slug);
+}
+
+/**
+ * Copy the primary checkout's local env files (.env, .env.local, …) into a
+ * worktree when the worktree doesn't have its own. They're gitignored, so a
+ * fresh worktree never carries them — and an env-dependent app (the Gleap
+ * dashboard, most real services) boots blank without them. Same machine,
+ * same user, never overwrites: safe by construction.
+ */
+export function copyPrimaryEnvFiles(primaryPath, cwd) {
+  if (!primaryPath || !cwd || primaryPath === cwd) return [];
+  const copied = [];
+  let names = [];
+  try {
+    names = readdirSync(primaryPath).filter((n) => n === ".env" || n.startsWith(".env."));
+  } catch {
+    return copied;
+  }
+  for (const name of names) {
+    const src = join(primaryPath, name);
+    const dst = join(cwd, name);
+    try {
+      if (!statSync(src).isFile()) continue;
+      if (existsSync(dst)) continue;
+      copyFileSync(src, dst);
+      copied.push(name);
+    } catch {
+      /* best-effort */
+    }
+  }
+  return copied;
+}
+
+/**
+ * Materialise one repo binding. Returns `{ cwd, mode, branch, base }`.
+ * `repo` = `{ name, primaryPath, defaultBranch }`, `binding` = `{ mode, base?, carryUncommitted? }`.
+ */
+export function materializeBinding({ kaiHome, repo, binding, sessionId, title, branchPrefix = "kai" }) {
+  const mode = binding?.mode === "local" ? "local" : "worktree";
+  if (mode === "local") {
+    const branch = git(repo.primaryPath, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    return { cwd: repo.primaryPath, mode, branch, base: branch };
+  }
+  const base = binding?.base || repo.defaultBranch || "main";
+  const slug = sessionSlug(sessionId, title);
+  const dir = worktreePath(kaiHome, repo.name, slug);
+  const branch = `${branchPrefix}/${slug}`;
+  if (existsSync(dir)) {
+    // Resume: the worktree from the previous turn is the session state.
+    return { cwd: dir, mode, branch, base, resumed: true };
+  }
+  mkdirSync(join(kaiHome, "worktrees", repo.name), { recursive: true });
+  git(repo.primaryPath, ["fetch", "origin", base, "--quiet"]);
+  git(repo.primaryPath, ["worktree", "add", "-b", branch, dir, `origin/${base}`]);
+  if (binding?.carryUncommitted) {
+    // Tracked changes as a patch; untracked (non-ignored) files copied.
+    const patch = git(repo.primaryPath, ["diff", "HEAD"], { maxBuffer: 64 * 1024 * 1024 });
+    if (patch) {
+      const patchPath = join(dir, ".kai-carry.patch");
+      writeFileSync(patchPath, patch + "\n");
+      try {
+        git(dir, ["apply", "--3way", patchPath]);
+      } finally {
+        rmSync(patchPath, { force: true });
+      }
+    }
+    const untracked = git(repo.primaryPath, ["ls-files", "--others", "--exclude-standard"]).split("\n").filter(Boolean);
+    for (const rel of untracked) {
+      try {
+        mkdirSync(dirname(join(dir, rel)), { recursive: true });
+        copyFileSync(join(repo.primaryPath, rel), join(dir, rel));
+      } catch {
+        /* best-effort */
+      }
+    }
+  }
+  return { cwd: dir, mode, branch, base, resumed: false };
+}
+
+/** Diff of what the turn changed (for the dashboard's file-changes panel). */
+export function collectChanges(cwd) {
+  const status = git(cwd, ["status", "--porcelain"]);
+  const files = status
+    .split("\n")
+    .filter(Boolean)
+    .map((l) => ({ status: l.slice(0, 2).trim(), path: l.slice(3).trim() }));
+  const diff = git(cwd, ["diff", "HEAD"], { maxBuffer: 64 * 1024 * 1024 });
+  return { files, diff };
+}
+
+/** Drop a session's worktrees (after merge/close). */
+export function removeWorktree({ kaiHome, repo, sessionId, title }) {
+  const dir = worktreePath(kaiHome, repo.name, sessionSlug(sessionId, title));
+  if (!existsSync(dir)) return false;
+  try {
+    git(repo.primaryPath, ["worktree", "remove", "--force", dir]);
+  } catch {
+    rmSync(dir, { recursive: true, force: true });
+    try {
+      git(repo.primaryPath, ["worktree", "prune"]);
+    } catch {
+      /* best-effort */
+    }
+  }
+  return true;
+}
+
+/**
+ * After a build turn in worktree mode: commit everything the agent left
+ * uncommitted (the runner forbids the agent from committing) under the
+ * user's own git identity and push the session branch with the user's
+ * own git auth. Local mode is left alone — the user owns that tree.
+ *
+ * Returns `{ committed, commitSha, pushed, branch, remote, error? }`.
+ * A failed push is NOT fatal: the dashboard still shows the diff, and the
+ * result carries the reason (no credentials, protected branch, …).
+ */
+export function commitAndPush(cwd, { branch, message, allowEmpty = false } = {}) {
+  const out = { committed: false, pushed: false, branch, commitSha: null, remote: null, error: null };
+  try {
+    // Agent state dirs must never enter the commit.
+    const excludes = [".codex-kai/", ".kai-acp-state/", ".kai-carry.patch"];
+    const excludePath = join(cwd, ".git", "info", "exclude");
+    try {
+      const current = existsSync(excludePath) ? readFileSync(excludePath, "utf8") : "";
+      const missing = excludes.filter((e) => !current.includes(e));
+      if (missing.length) writeFileSync(excludePath, `${current.trimEnd()}\n${missing.join("\n")}\n`);
+    } catch {
+      /* worktree .git is a file → exclude lives in the main repo; fine */
+    }
+    git(cwd, ["add", "-A"]);
+    const staged = git(cwd, ["diff", "--cached", "--name-only"]);
+    if (staged || allowEmpty) {
+      git(cwd, ["commit", "-q", "-m", message || "Kai Code changes", ...(allowEmpty ? ["--allow-empty"] : [])]);
+      out.committed = true;
+    }
+    out.commitSha = git(cwd, ["rev-parse", "HEAD"]);
+    out.remote = git(cwd, ["remote", "get-url", "origin"]);
+    git(cwd, ["push", "-u", "origin", `HEAD:${branch}`], { timeout: 120_000 });
+    out.pushed = true;
+  } catch (err) {
+    out.error = String(err?.stderr || err?.message || err).trim().slice(0, 500);
+  }
+  return out;
+}