@saadnvd1/agent-os 0.3.464 → 0.3.466

package/lib/git-status.ts

@@ -1,33 +1,20 @@
-import { execFile, execFileSync } from "child_process";
-import { promisify } from "util";
 import { realpathSync, unlinkSync } from "fs";
 import { basename, dirname, join, resolve, sep } from "path";
 import { homedir } from "os";
-import { remoteDefaultBranch } from "./pr";
-
-const execFileAsync = promisify(execFile);
-
-// The reads the git panel polls run off the event loop: a slow repo
-// shouldn't stall every terminal and status push while git works.
-async function git(cwd: string, args: string[]): Promise<string> {
-  // Paths are names, never globs or pathspec magic: "[draft].md" or "*"
-  // must not reach other files.
-  const { stdout } = await execFileAsync(
-    "git",
-    ["--literal-pathspecs", ...args],
-    {
-      cwd,
-      encoding: "utf-8",
-      maxBuffer: 10 * 1024 * 1024,
-      // A hung git (a stalled mount, a stuck hook) fails the request instead.
-      timeout: 30_000,
-      killSignal: "SIGKILL",
-      // Status reads never take the index lock a commit or rebase needs.
-      env: { ...process.env, GIT_OPTIONAL_LOCKS: "0" },
-    }
-  );
-  return stdout;
-}
+import {
+  currentBranch as readBranch,
+  git as runGit,
+  gitOk,
+  gitPush,
+  gitResult,
+  type GitOptions,
+} from "./git-exec";
+
+// The reads the git panel polls, and its stage/unstage/discard: paths are
+// names, never globs or pathspec magic, so "[draft].md" or "*" can't reach
+// other files. A hung git fails the request at 30s.
+const READ: GitOptions = { literalPathspecs: true, timeout: 30_000 };
+const git = (cwd: string, args: string[]) => runGit(cwd, args, READ);
 
 // For commands whose exit code isn't failure (a diff with changes exits 1):
 // whatever they printed, or nothing.
@@ -40,6 +27,9 @@ async function gitOutput(cwd: string, args: string[]): Promise<string> {
   }
 }
 
+// A commit or push can wait on a hook or a remote.
+const WRITE: GitOptions = { timeout: 120_000 };
+
 /**
  * Expand ~ to home directory in paths
  */
@@ -282,51 +272,25 @@ export async function discardChanges(
   unlinkSync(inside);
 }
 
-/**
- * Check if directory is a git repository
- */
-export async function isGitRepo(workingDir: string): Promise<boolean> {
-  try {
-    await git(workingDir, ["rev-parse", "--git-dir"]);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// Writes and the few sync reads: argv only, never a shell, so a branch name,
-// a commit message or a path is always data.
-function gitSync(cwd: string, args: string[], input?: string): string {
-  return execFileSync("git", args, {
-    cwd,
-    encoding: "utf-8",
-    input,
-    stdio: ["pipe", "pipe", "pipe"],
-    maxBuffer: 10 * 1024 * 1024,
-  });
-}
+export { isGitRepo } from "./git";
 
 /**
  * Get the root of the git repository
  */
-export function getGitRoot(workingDir: string): string {
+export async function getGitRoot(workingDir: string): Promise<string> {
   try {
-    return gitSync(workingDir, ["rev-parse", "--show-toplevel"]).trim();
+    return (await runGit(workingDir, ["rev-parse", "--show-toplevel"])).trim();
   } catch {
     return workingDir;
   }
 }
 
-function currentBranch(workingDir: string): string {
-  return gitSync(workingDir, ["branch", "--show-current"]).trim();
-}
-
 /**
  * Check if on main/master branch
  */
-export function isMainBranch(workingDir: string): boolean {
+export async function isMainBranch(workingDir: string): Promise<boolean> {
   try {
-    const branch = currentBranch(workingDir);
+    const branch = await readBranch(workingDir);
     return branch === "main" || branch === "master";
   } catch {
     return false;
@@ -337,59 +301,25 @@ export function isMainBranch(workingDir: string): boolean {
  * A name `git checkout -b` takes as a branch and nothing else: no option
  * ("-f", "--orphan=x"), nothing git itself refuses as a ref.
  */
-export function isValidBranchName(workingDir: string, name: string): boolean {
+export async function isValidBranchName(
+  workingDir: string,
+  name: string
+): Promise<boolean> {
   if (!name || name.startsWith("-")) return false;
-  try {
-    gitSync(workingDir, ["check-ref-format", "--branch", name]);
-    return true;
-  } catch {
-    return false;
-  }
+  return gitOk(workingDir, ["check-ref-format", "--branch", name]);
 }
 
 /**
  * Create a new branch and switch to it
  */
-export function createBranch(workingDir: string, branchName: string): void {
-  if (!isValidBranchName(workingDir, branchName)) {
+export async function createBranch(
+  workingDir: string,
+  branchName: string
+): Promise<void> {
+  if (!(await isValidBranchName(workingDir, branchName))) {
     throw new Error(`Invalid branch name: ${branchName}`);
   }
-  gitSync(workingDir, ["checkout", "-b", branchName, "--"]);
-}
-
-// A commit or push can wait on a hook or a remote: off the event loop, with a
-// ceiling (a hung ssh is killed at it), and no git credential prompt.
-function gitWrite(
-  cwd: string,
-  args: string[],
-  input?: string
-): Promise<{ stdout: string; stderr: string }> {
-  return new Promise((resolve, reject) => {
-    const child = execFile(
-      "git",
-      args,
-      {
-        cwd,
-        encoding: "utf-8",
-        maxBuffer: 10 * 1024 * 1024,
-        timeout: 120_000,
-        killSignal: "SIGKILL",
-        env: {
-          ...process.env,
-          GIT_TERMINAL_PROMPT: "0",
-        },
-      },
-      (error, stdout, stderr) => {
-        if (!error) return resolve({ stdout, stderr });
-        // "nothing to commit" is on stdout.
-        const reason = stderr.trim() || stdout.trim() || error.message;
-        reject(new Error(`git ${args[0]} failed: ${reason}`));
-      }
-    );
-    // git exiting before it read the message is its failure, not a crash.
-    child.stdin?.on("error", () => {});
-    child.stdin?.end(input ?? "");
-  });
+  await runGit(workingDir, ["checkout", "-b", branchName, "--"]);
 }
 
 /**
@@ -400,7 +330,11 @@ export async function commit(
   workingDir: string,
   message: string
 ): Promise<string> {
-  return (await gitWrite(workingDir, ["commit", "-F", "-"], message)).stdout;
+  const { stdout } = await gitResult(workingDir, ["commit", "-F", "-"], {
+    ...WRITE,
+    input: message,
+  });
+  return stdout;
 }
 
 /**
@@ -412,43 +346,30 @@ export async function push(
 ): Promise<string> {
   const args = ["push"];
   if (setUpstream) {
-    const branch = currentBranch(workingDir);
-    if (!isValidBranchName(workingDir, branch)) {
+    const branch = await readBranch(workingDir);
+    if (!(await isValidBranchName(workingDir, branch))) {
       throw new Error(`Can't push from "${branch || "a detached HEAD"}"`);
     }
     args.push("-u", "origin", `refs/heads/${branch}:refs/heads/${branch}`);
   }
   // git push reports progress and the remote's messages on stderr.
-  const { stdout, stderr } = await gitWrite(workingDir, args);
-  return `${stdout}${stderr}`;
+  return gitPush(workingDir, args.slice(1), WRITE);
 }
 
 /**
  * Check if branch has upstream
  */
-export function hasUpstream(workingDir: string): boolean {
-  try {
-    gitSync(workingDir, ["rev-parse", "--abbrev-ref", "@{upstream}"]);
-    return true;
-  } catch {
-    return false;
-  }
+export function hasUpstream(workingDir: string): Promise<boolean> {
+  return gitOk(workingDir, ["rev-parse", "--abbrev-ref", "@{upstream}"]);
 }
 
 /**
  * Get remote URL
  */
-export function getRemoteUrl(workingDir: string): string | null {
+export async function getRemoteUrl(workingDir: string): Promise<string | null> {
   try {
-    return gitSync(workingDir, ["remote", "get-url", "origin"]).trim();
+    return (await runGit(workingDir, ["remote", "get-url", "origin"])).trim();
   } catch {
     return null;
   }
 }
-
-/**
- * Get the default branch name (main or master)
- */
-export function getDefaultBranch(workingDir: string): string {
-  return remoteDefaultBranch(workingDir);
-}

package/lib/git.ts

@@ -1,98 +1,61 @@
 /**
- * Git utilities for worktree management
+ * Repository questions AgentOS asks: is this a repo, which branch is the
+ * default, which branches exist. Every git call goes through lib/git-exec.
  */
 
-import { execFile } from "child_process";
-import { promisify } from "util";
+import * as os from "os";
 import * as path from "path";
+import { currentBranch, git, gitOk, resolveRef } from "./git-exec";
 
-const execFileAsync = promisify(execFile);
+const expandHome = (p: string) => p.replace(/^~(?=$|\/)/, os.homedir());
 
 /**
- * Check if a directory is a git repository
+ * Check if a directory is a git repository. A slow mount gets the git
+ * panel's 30s before it reads as "not a repository".
  */
 export async function isGitRepo(dirPath: string): Promise<boolean> {
-  try {
-    const resolvedPath = dirPath.replace(/^~/, process.env.HOME || "");
-    await execFileAsync("git", ["-C", resolvedPath, "rev-parse", "--git-dir"], {
-      timeout: 5000,
-    });
-    return true;
-  } catch {
-    return false;
-  }
+  return gitOk(expandHome(dirPath), ["rev-parse", "--git-dir"], {
+    timeout: 30_000,
+  });
 }
 
 /**
- * Get the current branch name
+ * The checked-out branch, "HEAD" when detached.
  */
 export async function getCurrentBranch(dirPath: string): Promise<string> {
-  const resolvedPath = dirPath.replace(/^~/, process.env.HOME || "");
-  const { stdout } = await execFileAsync(
-    "git",
-    ["-C", resolvedPath, "rev-parse", "--abbrev-ref", "HEAD"],
-    { timeout: 5000 }
+  return (
+    (await currentBranch(expandHome(dirPath), { timeout: 5000 })) || "HEAD"
   );
-  return stdout.trim();
 }
 
 /**
- * Get the default branch (main or master)
+ * The default branch: the remote's, else main, else master, else the
+ * current one.
  */
 export async function getDefaultBranch(dirPath: string): Promise<string> {
-  const resolvedPath = dirPath.replace(/^~/, process.env.HOME || "");
-  try {
-    // Try to get the default branch from remote
-    const { stdout } = await execFileAsync(
-      "git",
-      ["-C", resolvedPath, "symbolic-ref", "refs/remotes/origin/HEAD"],
-      { timeout: 5000 }
-    );
-    const name = stdout.trim().replace(/^refs\/remotes\/origin\//, "");
-    // The remote picks this name: anything that isn't a plain branch name
-    // (a "$(...)" a hostile repo could set) is ignored.
-    if (name && isBranchName(name)) {
-      return name;
-    }
-  } catch {
-    // Ignore
-  }
-
-  // Fallback: check if main or master exists
-  try {
-    await execFileAsync(
-      "git",
-      ["-C", resolvedPath, "rev-parse", "--verify", "main"],
-      {
-        timeout: 5000,
-      }
-    );
-    return "main";
-  } catch {
-    try {
-      await execFileAsync(
-        "git",
-        ["-C", resolvedPath, "rev-parse", "--verify", "master"],
-        {
-          timeout: 5000,
-        }
-      );
-      return "master";
-    } catch {
-      // Return current branch as fallback
-      return getCurrentBranch(resolvedPath);
-    }
-  }
+  const dir = expandHome(dirPath);
+  const opts = { timeout: 5000 };
+  const remote = await git(
+    dir,
+    ["symbolic-ref", "refs/remotes/origin/HEAD"],
+    opts
+  ).catch(() => "");
+  const name = remote.trim().replace(/^refs\/remotes\/origin\//, "");
+  // The remote picks this name: anything that isn't a plain branch name
+  // (a "$(...)" a hostile repo could set) is ignored.
+  if (name && isBranchName(name)) return name;
+  if (await resolveRef(dir, "main", opts)) return "main";
+  if (await resolveRef(dir, "master", opts)) return "master";
+  return getCurrentBranch(dir);
 }
 
 /**
  * Get list of local branches
  */
 export async function getBranches(dirPath: string): Promise<string[]> {
-  const resolvedPath = dirPath.replace(/^~/, process.env.HOME || "");
-  const { stdout } = await execFileAsync(
-    "git",
-    ["-C", resolvedPath, "branch", "--format=%(refname:short)"],
+  const stdout = await git(
+    expandHome(dirPath),
+    ["branch", "--format=%(refname:short)"],
     { timeout: 5000 }
   );
   return stdout
@@ -108,32 +71,18 @@ export async function branchExists(
   dirPath: string,
   branchName: string
 ): Promise<boolean> {
-  const resolvedPath = dirPath.replace(/^~/, process.env.HOME || "");
-  try {
-    await execFileAsync(
-      "git",
-      [
-        "-C",
-        resolvedPath,
-        "rev-parse",
-        "--verify",
-        "--end-of-options",
-        branchName,
-      ],
-      { timeout: 5000 }
-    );
-    return true;
-  } catch {
-    return false;
-  }
+  return gitOk(
+    expandHome(dirPath),
+    ["rev-parse", "--verify", "--end-of-options", branchName],
+    { timeout: 5000 }
+  );
 }
 
 /**
  * Get the repository name from path
  */
 export function getRepoName(dirPath: string): string {
-  const resolvedPath = dirPath.replace(/^~/, process.env.HOME || "");
-  return path.basename(resolvedPath);
+  return path.basename(expandHome(dirPath));
 }
 
 /**
@@ -169,11 +118,10 @@ export async function remoteBranchExists(
   dirPath: string,
   branchName: string
 ): Promise<boolean> {
-  const resolvedPath = dirPath.replace(/^~/, process.env.HOME || "");
   try {
-    const { stdout } = await execFileAsync(
-      "git",
-      ["-C", resolvedPath, "ls-remote", "--heads", "origin", "--", branchName],
+    const stdout = await git(
+      expandHome(dirPath),
+      ["ls-remote", "--heads", "origin", "--", branchName],
       { timeout: 10000 }
     );
     return stdout.trim().length > 0;
@@ -194,72 +142,9 @@ export async function renameBranch(
 ): Promise<void> {
   if (await remoteBranchExists(dirPath, oldBranchName))
     throw new Error(`${oldBranchName} is on the remote; keeping its name`);
-  const resolvedPath = dirPath.replace(/^~/, process.env.HOME || "");
-  await execFileAsync(
-    "git",
-    ["-C", resolvedPath, "branch", "-m", "--", oldBranchName, newBranchName],
+  await git(
+    expandHome(dirPath),
+    ["branch", "-m", "--", oldBranchName, newBranchName],
     { timeout: 10000 }
   );
 }
-
-/**
- * Get git status summary (files changed, ahead/behind)
- */
-export async function getGitStatus(dirPath: string): Promise<{
-  staged: number;
-  unstaged: number;
-  untracked: number;
-  ahead: number;
-  behind: number;
-}> {
-  const resolvedPath = dirPath.replace(/^~/, process.env.HOME || "");
-
-  // Get file counts
-  const { stdout: statusOutput } = await execFileAsync(
-    "git",
-    ["-C", resolvedPath, "status", "--porcelain"],
-    { timeout: 5000 }
-  );
-
-  const lines = statusOutput.trim().split("\n").filter(Boolean);
-  let staged = 0;
-  let unstaged = 0;
-  let untracked = 0;
-
-  for (const line of lines) {
-    const index = line[0];
-    const worktree = line[1];
-    if (index === "?" && worktree === "?") {
-      untracked++;
-    } else {
-      if (index !== " " && index !== "?") staged++;
-      if (worktree !== " " && worktree !== "?") unstaged++;
-    }
-  }
-
-  // Get ahead/behind counts
-  let ahead = 0;
-  let behind = 0;
-  try {
-    // No upstream throws, and counts as level.
-    const { stdout: aheadBehind } = await execFileAsync(
-      "git",
-      [
-        "-C",
-        resolvedPath,
-        "rev-list",
-        "--left-right",
-        "--count",
-        "HEAD...@{upstream}",
-      ],
-      { timeout: 5000 }
-    );
-    const [a, b] = aheadBehind.trim().split(/\s+/);
-    ahead = parseInt(a, 10) || 0;
-    behind = parseInt(b, 10) || 0;
-  } catch {
-    // No upstream, ignore
-  }
-
-  return { staged, unstaged, untracked, ahead, behind };
-}

package/lib/lumifyhub/publish.ts

@@ -13,7 +13,7 @@ import {
   type Session,
 } from "../db";
 import { getProject } from "../projects";
-import { run } from "../tasks/gh";
+import { git as runGit } from "../git-exec";
 import { LumifyHubError } from "./client";
 import { requireClient } from "./connection";
 import { linkedWorkspaceFor } from "./links";
@@ -33,7 +33,7 @@ function localProject(projectId: string): Project {
 }
 
 const git = (dir: string, ...args: string[]) =>
-  run("git", args, dir).then((out) => out.trim());
+  runGit(dir, args).then((out) => out.trim());
 
 async function commonDir(dir: string): Promise<string | null> {
   return git(dir, "rev-parse", "--path-format=absolute", "--git-common-dir")

package/lib/orchestrator/deliver.ts

@@ -1,4 +1,5 @@
 import type { ChatOrigin, ChatState } from "../chat/events";
+import type { CompactFirst } from "../chat/stale";
 import {
   isAnswer,
   deliveriesSince,
@@ -22,7 +23,12 @@ export const AGENTOS_SENDER = "agentos";
 
 export type ChatSender = (
   sessionId: string,
-  input: { text: string; from: string; origin: ChatOrigin }
+  input: {
+    text: string;
+    from: string;
+    origin: ChatOrigin;
+    compact: CompactFirst;
+  }
 ) => Promise<void>;
 
 // After a failed send, wait 5s, then 10s, 20s ... up to 5 minutes.
@@ -97,6 +103,8 @@ export async function deliverEvents(opts: {
       text,
       from: AGENTOS_SENDER,
       origin,
+      // An orchestrator idle past its cache is compacted first.
+      compact: "auto",
     });
     failing.delete(workspaceId);
     return text;

package/lib/orchestrator/diff.ts

@@ -7,7 +7,7 @@
  */
 
 import path from "path";
-import { run } from "../tasks/gh";
+import { git } from "../git-exec";
 import { SECRET_ASSIGNMENT, SECRET_TOKENS } from "./untrusted";
 
 export interface ChangedFile {
@@ -38,30 +38,32 @@ export async function changedFiles(
   base: string,
   sha: string
 ): Promise<ChangedFile[]> {
-  const raw = await run(
-    "git",
-    ["diff", "--raw", "--no-renames", `${base}...${sha}`],
-    repo
-  );
+  const raw = await git(repo, [
+    "diff",
+    "--raw",
+    "--no-renames",
+    `${base}...${sha}`,
+  ]);
   const files = parseRaw(raw);
   for (const f of files)
     if (f.link !== undefined && f.status !== "D")
-      f.link = (await run("git", ["show", `${sha}:${f.path}`], repo)).trim();
+      f.link = (await git(repo, ["show", `${sha}:${f.path}`])).trim();
   return files;
 }
 
 // The whole change, as a reviewer reads it.
 export function fullDiff(repo: string, base: string, sha: string) {
-  return run("git", ["diff", "--no-color", `${base}...${sha}`], repo);
+  return git(repo, ["diff", "--no-color", `${base}...${sha}`]);
 }
 
 // The lines the change adds, for the secrets check.
 export async function addedLines(repo: string, base: string, sha: string) {
-  const diff = await run(
-    "git",
-    ["diff", "-U0", "--no-color", `${base}...${sha}`],
-    repo
-  );
+  const diff = await git(repo, [
+    "diff",
+    "-U0",
+    "--no-color",
+    `${base}...${sha}`,
+  ]);
   return diff
     .split("\n")
     .filter((l) => l.startsWith("+") && !l.startsWith("+++"))