@saadnvd1/agent-os 0.3.465 → 0.3.466

package/README.md

@@ -1258,6 +1258,13 @@ One Node process serves every terminal, chat stream and request, so a route
 handler in `app/api/` may not call a `*Sync` child_process or fs function:
 ESLint refuses it. Use the async form with a timeout.
 
+Every git process starts in `lib/git-exec.ts`: `git()`, `gitResult()`,
+`gitOk()` and named operations (`revParse`, `worktreeAdd`, `gitPush`, …). It
+sets one timeout, kills a hung git, never lets git prompt, keeps the server's
+tmux out of hooks and rejects with a `GitError` carrying the exit code and
+stderr. ESLint refuses git spawned anywhere else in `lib/`, `app/` or
+`server.ts`.
+
 `scripts/redeploy` (and `scripts/autodeploy`, which calls it) builds into
 `.next-build` while the live server keeps serving `.next`. The build is swapped
 in by rename only once it finished with a `BUILD_ID`, right before the restart.

package/app/api/git/commit/route.ts

@@ -45,7 +45,8 @@ export async function POST(request: NextRequest) {
 
     if (
       branchName &&
-      (typeof branchName !== "string" || !isValidBranchName(path, branchName))
+      (typeof branchName !== "string" ||
+        !(await isValidBranchName(path, branchName)))
     ) {
       return NextResponse.json(
         { error: "Invalid branch name" },
@@ -64,8 +65,8 @@ export async function POST(request: NextRequest) {
 
     // Create new branch if on main/master and branch name provided
     let newBranch = false;
-    if (branchName && isMainBranch(path)) {
-      createBranch(path, branchName);
+    if (branchName && (await isMainBranch(path))) {
+      await createBranch(path, branchName);
       newBranch = true;
     }
 

package/app/api/git/file-content/route.ts

@@ -1,10 +1,7 @@
 import { NextRequest, NextResponse } from "next/server";
-import { execFile } from "child_process";
-import { promisify } from "util";
+import { git } from "@/lib/git-exec";
 import { expandPath } from "@/lib/git-status";
 
-const execFileAsync = promisify(execFile);
-
 /**
  * GET /api/git/file-content?path=...&file=...
  * Get file content from git HEAD (original version before changes)
@@ -33,17 +30,9 @@ export async function GET(request: NextRequest) {
 
     try {
       // Get file content from HEAD
-      const { stdout: content } = await execFileAsync(
-        "git",
-        ["show", `HEAD:${file}`],
-        {
-          cwd: expandedPath,
-          encoding: "utf-8",
-          maxBuffer: 10 * 1024 * 1024, // 10MB
-          timeout: 30_000,
-          killSignal: "SIGKILL",
-        }
-      );
+      const content = await git(expandedPath, ["show", `HEAD:${file}`], {
+        timeout: 30_000,
+      });
 
       return NextResponse.json({ content });
     } catch (gitError: unknown) {

package/app/api/git/history/[hash]/diff/route.ts

@@ -31,7 +31,7 @@ export async function GET(request: NextRequest, { params }: RouteParams) {
       );
     }
 
-    const diff = getCommitFileDiff(path, hash, file);
+    const diff = await getCommitFileDiff(path, hash, file);
     return NextResponse.json({ diff });
   } catch (error) {
     console.error("Error getting commit file diff:", error);

package/app/api/git/history/[hash]/route.ts

@@ -23,7 +23,7 @@ export async function GET(request: NextRequest, { params }: RouteParams) {
       );
     }
 
-    const commit = getCommitDetail(path, hash);
+    const commit = await getCommitDetail(path, hash);
     if (!commit) {
       return NextResponse.json({ error: "Commit not found" }, { status: 404 });
     }

package/app/api/git/history/route.ts

@@ -15,7 +15,7 @@ export async function GET(request: NextRequest) {
       );
     }
 
-    const commits = getCommitHistory(path, limit);
+    const commits = await getCommitHistory(path, limit);
     return NextResponse.json({ commits });
   } catch (error) {
     console.error("Error getting commit history:", error);

package/app/api/git/push/route.ts

@@ -28,7 +28,7 @@ export async function POST(request: NextRequest) {
     }
 
     // Check if remote exists
-    const remoteUrl = getRemoteUrl(path);
+    const remoteUrl = await getRemoteUrl(path);
     if (!remoteUrl) {
       return NextResponse.json(
         { error: "No remote origin configured" },
@@ -48,7 +48,7 @@ export async function POST(request: NextRequest) {
     }
 
     // Push (set upstream if needed)
-    const needsUpstream = !hasUpstream(path);
+    const needsUpstream = !(await hasUpstream(path));
     const output = await push(path, needsUpstream);
 
     forgetGitStatus(path);

package/app/api/sessions/[id]/pr/route.ts

@@ -2,6 +2,7 @@ import { NextRequest, NextResponse } from "next/server";
 import { execFile } from "child_process";
 import { promisify } from "util";
 import { getDb, queries, type Session } from "@/lib/db";
+import { gitPush } from "@/lib/git-exec";
 
 const execFileAsync = promisify(execFile);
 
@@ -69,8 +70,7 @@ async function createPR(
 ): Promise<PRInfo> {
   // First push the branch if not already pushed
   try {
-    await execFileAsync("git", ["push", "-u", "origin", "--", branchName], {
-      cwd: projectPath,
+    await gitPush(projectPath, ["-u", "origin", "--", branchName], {
       timeout: 30000,
     });
   } catch {

package/lib/away/deploy.ts

@@ -9,7 +9,7 @@
 
 import fs from "fs";
 import type { ProjectConfig } from "../project-config";
-import { run } from "../tasks/gh";
+import { gitFetch, isAncestor } from "../git-exec";
 import { expandHome } from "../tasks/session";
 import { selfUrl } from "../agents/self-env";
 import { commitTime } from "../orchestrator/repo";
@@ -61,15 +61,11 @@ async function contains(
   sha: string
 ): Promise<boolean> {
   if (tip === sha) return true;
-  const ancestor = () =>
-    run("git", ["merge-base", "--is-ancestor", sha, tip], repo).then(
-      () => true,
-      () => false
-    );
+  const ancestor = () => isAncestor(repo, sha, tip);
   if (await ancestor()) return true;
   // The deployed commit may be newer than this checkout knows. A fetch that
   // fails throws, so stale refs never read as "not deployed".
-  await run("git", ["fetch", "--quiet", "origin"], repo);
+  await gitFetch(repo, ["--quiet", "origin"]);
   return ancestor();
 }
 

package/lib/away/run.ts

@@ -23,6 +23,7 @@ import { notifyPhone } from "../notify";
 import { getProject } from "../projects";
 import { loadProjectConfig } from "../project-config";
 import { run } from "../tasks/gh";
+import { git } from "../git-exec";
 import { expandHome } from "../tasks/session";
 import { auditId, auditsRoot, writeAtomic } from "../session-audit/store";
 import {
@@ -199,11 +200,11 @@ async function dirtySessions(ids: string[]): Promise<Set<string>> {
         // A linked machine's worktree isn't on this disk.
         if (!s || (s.host_id && s.host_id !== "local")) return;
         const dir = expandHome(s.worktree_path || s.working_directory);
-        const out = await run(
-          "git",
-          ["status", "--porcelain", "--untracked-files=normal"],
-          dir
-        ).catch(() => "");
+        const out = await git(dir, [
+          "status",
+          "--porcelain",
+          "--untracked-files=normal",
+        ]).catch(() => "");
         if (out.trim()) dirty.add(id);
       })
     );

package/lib/build.ts

@@ -3,20 +3,16 @@
 // A worker whose build isn't the server's is running code from before a
 // redeploy.
 
-import { execFileSync } from "child_process";
 import fs from "fs";
 import path from "path";
 import type { ChatState } from "./chat/events";
+import { gitSync } from "./git-exec";
 
 export function buildId(): string {
   if (process.env.AGENTOS_BUILD) return process.env.AGENTOS_BUILD;
   let id = "";
   try {
-    id = execFileSync("git", ["rev-parse", "HEAD"], {
-      cwd: process.cwd(),
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
-    }).trim();
+    id = gitSync(process.cwd(), ["rev-parse", "HEAD"]).trim();
   } catch {}
   if (!id) {
     try {

package/lib/chat/files.ts

@@ -1,5 +1,6 @@
 import { execFile } from "child_process";
 import { promisify } from "util";
+import { git } from "../git-exec";
 import type { FileSuggestion } from "./events";
 import {
   indexPaths,
@@ -33,11 +34,36 @@ export function sweepFileIndexes(now = Date.now()): void {
 
 export const fileIndexCount = () => cache.size;
 
+const LIST_TIMEOUT_MS = 5000;
+
+export interface Lister {
+  // The program it needs.
+  cmd: string;
+  list: (cwd: string) => Promise<string>;
+}
+
 // Ways to list a folder's files with ignored ones left out: ripgrep, or
 // git where ripgrep isn't installed.
-export const LISTERS: [string, string[]][] = [
-  ["rg", ["--files", "--hidden", "-g", "!.git"]],
-  ["git", ["ls-files", "--cached", "--others", "--exclude-standard"]],
+export const LISTERS: Lister[] = [
+  {
+    cmd: "rg",
+    list: async (cwd) =>
+      (
+        await execFileAsync("rg", ["--files", "--hidden", "-g", "!.git"], {
+          cwd,
+          maxBuffer: 64 * 1024 * 1024,
+          timeout: LIST_TIMEOUT_MS,
+        })
+      ).stdout,
+  },
+  {
+    cmd: "git",
+    list: (cwd) =>
+      git(cwd, ["ls-files", "--cached", "--others", "--exclude-standard"], {
+        timeout: LIST_TIMEOUT_MS,
+        maxBuffer: 64 * 1024 * 1024,
+      }),
+  },
 ];
 
 // The folder's files, for @mentions when no agent is running to match them
@@ -46,13 +72,9 @@ export async function listFiles(
   cwd: string,
   listers = LISTERS
 ): Promise<IndexedPath[]> {
-  for (const [cmd, args] of listers) {
+  for (const { list } of listers) {
     try {
-      const { stdout } = await execFileAsync(cmd, args, {
-        cwd,
-        maxBuffer: 64 * 1024 * 1024,
-        timeout: 5000,
-      });
+      const stdout = await list(cwd);
       return indexPaths(
         withFolders(stdout.split("\n").filter(Boolean).slice(0, MAX_FILES))
       );

package/lib/done/remote.ts

@@ -4,7 +4,7 @@
 
 import type { Session } from "../db";
 import type { TaskPR } from "../tasks";
-import { run } from "../tasks/gh";
+import { git, gitPush } from "../git-exec";
 import { projectPathFor } from "../tasks/session";
 import { PROTECTED_BRANCHES } from "../tasks/finish";
 import { liveChildren } from "../stacks/guard";
@@ -23,15 +23,14 @@ export async function deleteMergedRemote(
     liveChildren(s.id).length
   )
     return false;
-  const line = await run(
-    "git",
-    ["ls-remote", "--heads", "origin", `refs/heads/${branch}`],
+  const line = await git(
     repo,
-    30000
+    ["ls-remote", "--heads", "origin", `refs/heads/${branch}`],
+    { timeout: 30000 }
   ).catch(() => "");
   const tip = line.trim().split(/\s+/)[0];
   if (!tip || tip !== pr.head) return false;
-  return run("git", ["push", "origin", "--delete", branch], repo, 60000)
+  return gitPush(repo, ["origin", "--delete", branch], { timeout: 60000 })
     .then(() => true)
     .catch(() => false);
 }

package/lib/done/testing.ts

@@ -4,18 +4,13 @@
 import fs from "fs";
 import os from "os";
 import path from "path";
-import { execFileSync } from "child_process";
+import { gitSync } from "../git-exec";
 
 // Old enough that CI counts as settled on every commit.
 const env = { ...process.env, GIT_COMMITTER_DATE: "2026-01-01T00:00:00Z" };
 
 export const git = (cwd: string, ...args: string[]) =>
-  execFileSync("git", args, {
-    cwd,
-    encoding: "utf8",
-    stdio: "pipe",
-    env,
-  }).trim();
+  gitSync(cwd, args, { env }).trim();
 
 export function commitFile(cwd: string, file: string, text: string): string {
   fs.mkdirSync(path.dirname(path.join(cwd, file)), { recursive: true });

package/lib/done/worktree.ts

@@ -7,7 +7,7 @@
 import fs from "fs";
 import type { Session } from "../db";
 import { getDefaultBranch } from "../git";
-import { run } from "../tasks/gh";
+import { git as runGit } from "../git-exec";
 import { mergePolicy } from "../tasks/merge-policy";
 import { getProject } from "../projects";
 import {
@@ -24,7 +24,7 @@ export type WorktreeFate =
   | { action: "kept"; why: string; path: string };
 
 const git = (cwd: string, ...args: string[]) =>
-  run("git", args, cwd, 30000).then((out) => out.trim());
+  runGit(cwd, args, { timeout: 30000 }).then((out) => out.trim());
 
 // The main checkout a worktree belongs to.
 async function repoOf(worktree: string): Promise<string> {

package/lib/git-exec.ts

@@ -0,0 +1,334 @@
+/**
+ * The one way AgentOS runs git. Every git process starts here, so they all
+ * share the same hardening:
+ *
+ * - argv only, never a shell: a branch name, path or message is always data;
+ * - off the event loop, with a ceiling (a hung ssh, a stalled mount or a
+ *   stuck hook is killed at it, with SIGKILL);
+ * - no prompt can ever wait for an answer (GIT_TERMINAL_PROMPT=0), and stdin
+ *   is always closed;
+ * - no optional locks, so a read never takes the index lock a commit or
+ *   rebase needs;
+ * - the server's own tmux (TMUX, TMUX_PANE) never reaches a hook;
+ * - a failure is a GitError carrying the exit code, stderr and stdout.
+ *
+ * A lint rule (eslint.config.mjs) refuses git spawned anywhere else.
+ */
+
+import { execFile, execFileSync } from "child_process";
+
+export const GIT_TIMEOUT_MS = 60_000;
+const MAX_BUFFER = 16 * 1024 * 1024;
+
+export interface GitOptions {
+  // Milliseconds before git is killed. Default GIT_TIMEOUT_MS.
+  timeout?: number;
+  // Written to stdin, which is closed either way.
+  input?: string;
+  // Added to the shared environment.
+  env?: Record<string, string>;
+  // Paths are names, never globs or pathspec magic: "[draft].md" or "*"
+  // must not reach other files.
+  literalPathspecs?: boolean;
+  // Bytes of output before git is killed. Default 16MB.
+  maxBuffer?: number;
+  signal?: AbortSignal;
+}
+
+export class GitError extends Error {
+  override readonly name = "GitError";
+  constructor(
+    message: string,
+    readonly args: string[],
+    readonly cwd: string,
+    // git's exit status; null when it never exited on its own.
+    readonly exitCode: number | null,
+    readonly signal: NodeJS.Signals | null,
+    readonly stdout: string,
+    readonly stderr: string,
+    readonly timedOut: boolean,
+    options?: { cause?: unknown }
+  ) {
+    super(message, options);
+  }
+
+  // What execFile's errors carry, for callers written against them.
+  get code(): number | string | null {
+    const cause = this.cause as { code?: unknown } | undefined;
+    if (this.exitCode !== null) return this.exitCode;
+    return typeof cause?.code === "string" ? cause.code : null;
+  }
+
+  get killed(): boolean {
+    return this.timedOut || this.signal !== null;
+  }
+}
+
+export const isGitError = (error: unknown): error is GitError =>
+  error instanceof GitError;
+
+/** The environment every git runs with. */
+export function gitEnv(extra?: Record<string, string>): NodeJS.ProcessEnv {
+  const env: NodeJS.ProcessEnv = {
+    ...process.env,
+    GIT_TERMINAL_PROMPT: "0",
+    GIT_OPTIONAL_LOCKS: "0",
+    ...extra,
+  };
+  delete env.TMUX;
+  delete env.TMUX_PANE;
+  return env;
+}
+
+const argv = (args: string[], opts: GitOptions) =>
+  opts.literalPathspecs ? ["--literal-pathspecs", ...args] : args;
+
+// The subcommand, for messages: "git worktree add", "git push".
+const named = (args: string[]) => {
+  const words = args.filter((a) => !a.startsWith("-")).slice(0, 2);
+  return ["git", ...(words[0] === "worktree" ? words : words.slice(0, 1))]
+    .join(" ")
+    .trim();
+};
+
+function toGitError(
+  error: unknown,
+  args: string[],
+  cwd: string,
+  stdout: string,
+  stderr: string,
+  timeout: number
+): GitError {
+  const e = error as {
+    code?: unknown;
+    status?: unknown;
+    killed?: boolean;
+    signal?: NodeJS.Signals | null;
+    name?: string;
+    message?: string;
+  };
+  // execFile reports the exit status as `code`, execFileSync as `status`.
+  const exitCode =
+    typeof e.code === "number"
+      ? e.code
+      : typeof e.status === "number"
+        ? e.status
+        : null;
+  const aborted = e.name === "AbortError" || e.code === "ABORT_ERR";
+  const overflow = e.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER";
+  const timedOut =
+    e.code === "ETIMEDOUT" ||
+    (exitCode === null && !aborted && !overflow && e.killed === true);
+  const what = named(args);
+  const reason =
+    stderr.trim() || stdout.trim() || e.message || String(error ?? "");
+  const message = timedOut
+    ? `${what} timed out after ${Math.round(timeout / 1000)}s`
+    : `${what} failed: ${reason}`;
+  return new GitError(
+    message,
+    args,
+    cwd,
+    exitCode,
+    e.signal ?? null,
+    stdout,
+    stderr,
+    timedOut,
+    { cause: error }
+  );
+}
+
+/** Runs git in `cwd`; resolves stdout and stderr, rejects with a GitError. */
+export function gitResult(
+  cwd: string,
+  args: string[],
+  opts: GitOptions = {}
+): Promise<{ stdout: string; stderr: string }> {
+  const full = argv(args, opts);
+  const timeout = opts.timeout ?? GIT_TIMEOUT_MS;
+  return new Promise((resolve, reject) => {
+    const child = execFile(
+      "git",
+      full,
+      {
+        cwd,
+        encoding: "utf-8",
+        maxBuffer: opts.maxBuffer ?? MAX_BUFFER,
+        timeout,
+        killSignal: "SIGKILL",
+        env: gitEnv(opts.env),
+        signal: opts.signal,
+      },
+      (error, stdout, stderr) => {
+        if (!error) return resolve({ stdout, stderr });
+        reject(toGitError(error, args, cwd, stdout, stderr, timeout));
+      }
+    );
+    // git exiting before it read its input is its failure, not a crash.
+    child.stdin?.on("error", () => {});
+    child.stdin?.end(opts.input ?? "");
+  });
+}
+
+/** Runs git in `cwd` and resolves what it printed, untrimmed. */
+export async function git(
+  cwd: string,
+  args: string[],
+  opts: GitOptions = {}
+): Promise<string> {
+  return (await gitResult(cwd, args, opts)).stdout;
+}
+
+/** Whether git exits 0. Never throws. */
+export function gitOk(
+  cwd: string,
+  args: string[],
+  opts: GitOptions = {}
+): Promise<boolean> {
+  return gitResult(cwd, args, opts).then(
+    () => true,
+    () => false
+  );
+}
+
+/**
+ * The blocking form, for what runs once outside a request (the build id at
+ * startup) and test setup. Never in a request handler.
+ */
+export function gitSync(
+  cwd: string,
+  args: string[],
+  opts: Omit<GitOptions, "signal"> = {}
+): string {
+  const full = argv(args, opts);
+  const timeout = opts.timeout ?? GIT_TIMEOUT_MS;
+  try {
+    return execFileSync("git", full, {
+      cwd,
+      encoding: "utf-8",
+      input: opts.input ?? "",
+      stdio: ["pipe", "pipe", "pipe"],
+      maxBuffer: opts.maxBuffer ?? MAX_BUFFER,
+      timeout,
+      killSignal: "SIGKILL",
+      env: gitEnv(opts.env),
+    });
+  } catch (error) {
+    const e = error as { stdout?: unknown; stderr?: unknown };
+    const text = (v: unknown) =>
+      typeof v === "string" ? v : Buffer.isBuffer(v) ? v.toString() : "";
+    throw toGitError(error, args, cwd, text(e.stdout), text(e.stderr), timeout);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// The operations AgentOS actually runs. Names reach git as arguments after
+// "--" or --end-of-options wherever git allows it, so none is read as an
+// option.
+
+const trimmed = (p: Promise<string>) => p.then((s) => s.trim());
+
+/** `rev-parse <ref>`, trimmed. Throws when it doesn't resolve. */
+export const revParse = (cwd: string, ref: string, opts?: GitOptions) =>
+  trimmed(git(cwd, ["rev-parse", ref], opts));
+
+/** The object `ref` names, or null when it names none. */
+export const resolveRef = (cwd: string, ref: string, opts?: GitOptions) =>
+  git(cwd, ["rev-parse", "--verify", "--quiet", ref], opts).then(
+    (out) => out.trim() || null,
+    () => null
+  );
+
+/** The checked-out branch, "" when HEAD is detached. */
+export const currentBranch = (cwd: string, opts?: GitOptions) =>
+  trimmed(git(cwd, ["branch", "--show-current"], opts));
+
+/** `status --porcelain` as printed. */
+export const statusPorcelain = (cwd: string, opts?: GitOptions) =>
+  git(cwd, ["status", "--porcelain"], opts);
+
+/** Whether `ancestor` is reachable from `ref`; false when git can't say. */
+export const isAncestor = (
+  cwd: string,
+  ancestor: string,
+  ref: string,
+  opts?: GitOptions
+) => gitOk(cwd, ["merge-base", "--is-ancestor", ancestor, ref], opts);
+
+/** The best common ancestor of `a` and `b`. */
+export const mergeBase = (
+  cwd: string,
+  a: string,
+  b: string,
+  opts?: GitOptions
+) => trimmed(git(cwd, ["merge-base", "--end-of-options", a, b], opts));
+
+export const gitFetch = (cwd: string, args: string[] = [], opts?: GitOptions) =>
+  git(cwd, ["fetch", ...args], opts);
+
+/** Pushes; resolves stdout then stderr, where git reports what it did. */
+export const gitPush = (cwd: string, args: string[], opts?: GitOptions) =>
+  gitResult(cwd, ["push", ...args], opts).then(
+    ({ stdout, stderr }) => `${stdout}${stderr}`
+  );
+
+export const gitRebase = (cwd: string, args: string[], opts?: GitOptions) =>
+  git(cwd, ["rebase", ...args], opts);
+
+/** `diff --stat` of `args` (a range, paths), as printed. */
+export const diffStat = (cwd: string, args: string[], opts?: GitOptions) =>
+  git(cwd, ["diff", "--stat", ...args], opts);
+
+/** Deletes a local branch; `force` deletes it unmerged (-D). */
+export const deleteBranch = (
+  cwd: string,
+  branch: string,
+  { force = false, ...opts }: GitOptions & { force?: boolean } = {}
+) => git(cwd, ["branch", force ? "-D" : "-d", "--", branch], opts);
+
+export const worktreeAdd = (repo: string, args: string[], opts?: GitOptions) =>
+  git(repo, ["worktree", "add", ...args], opts);
+
+export const worktreeRemove = (
+  repo: string,
+  dir: string,
+  { force = 1, ...opts }: GitOptions & { force?: 0 | 1 | 2 } = {}
+) =>
+  git(
+    repo,
+    ["worktree", "remove", ...Array(force).fill("--force"), "--", dir],
+    opts
+  );
+
+export interface WorktreeEntry {
+  path: string;
+  // Short name, "" when detached.
+  branch: string;
+  head: string;
+}
+
+/** `worktree list --porcelain`, parsed. The main checkout is first. */
+export async function worktreeList(
+  repo: string,
+  opts?: GitOptions
+): Promise<WorktreeEntry[]> {
+  const out = await git(repo, ["worktree", "list", "--porcelain"], opts);
+  return parseWorktreeList(out);
+}
+
+export function parseWorktreeList(out: string): WorktreeEntry[] {
+  const entries: WorktreeEntry[] = [];
+  for (const block of out.split("\n\n")) {
+    let path = "";
+    let branch = "";
+    let head = "";
+    for (const line of block.split("\n")) {
+      if (line.startsWith("worktree ")) path = line.slice(9);
+      else if (line.startsWith("branch "))
+        branch = line.slice(7).replace(/^refs\/heads\//, "");
+      else if (line.startsWith("HEAD ")) head = line.slice(5);
+    }
+    if (path) entries.push({ path, branch, head });
+  }
+  return entries;
+}