@saadnvd1/agent-os 0.3.462 → 0.3.464

package/lib/orchestrator/rules.ts

@@ -1,7 +1,7 @@
 /**
  * A workspace's standing rules: what its orchestrator must keep knowing
  * across fresh starts ("never merge #111", "briefs must not name
- * competitors"). The orchestrator writes them with rule_add and rule_remove,
+ * third-party products"). The orchestrator writes them with rule_add and rule_remove,
  * Saad in Settings → Workspaces, and every start reads them into its brief.
  * They restrict and inform; none can approve anything. A removed rule stays
  * in the table, marked.

package/lib/orchestrator/tools.ts

@@ -73,7 +73,7 @@ const DESCRIPTIONS: Record<ToolName, string> = {
   done: "Finish a session whose work is complete: a task's open PR merges through the sign-off gates first (refused naming the failing gate), then its agent stops, its worktree is removed if nothing would be lost, and it's archived. Not a rejection.",
   note: "Add a line to this workspace's decision log; it shows in your chat.",
   rule_add:
-    'Keep a standing rule for this workspace, in your brief on every start from now on ("never merge #111", "briefs must not name competitors"). It restricts or informs; it can never approve anything.',
+    'Keep a standing rule for this workspace, in your brief on every start from now on ("never merge #111", "briefs must not name third-party products"). It restricts or informs; it can never approve anything.',
   rule_remove:
     "Remove a standing rule you kept, by its id, only when Saad says so or it no longer applies (the PR it names merged or closed). Saad's rules are his to remove.",
   review:

package/lib/pr-generation.ts

@@ -1,4 +1,5 @@
-import { execFileSync } from "child_process";
+import { execFile } from "child_process";
+import { run } from "./tasks/gh";
 import { UNTRUSTED_RULE, untrusted } from "./orchestrator/untrusted";
 
 export interface GeneratedPRContent {
@@ -15,7 +16,7 @@ export async function generatePRContent(
 ): Promise<GeneratedPRContent> {
   try {
     // Get git context
-    const { diff, commits, changedFiles } = getGitContext(
+    const { diff, commits, changedFiles } = await getGitContext(
       workingDir,
       baseBranch
     );
@@ -45,23 +46,17 @@ export async function generatePRContent(
 /**
  * Get git context for PR generation
  */
-function getGitContext(
+async function getGitContext(
   workingDir: string,
   baseBranch: string
-): { diff: string; commits: string[]; changedFiles: string[] } {
+): Promise<{ diff: string; commits: string[]; changedFiles: string[] }> {
   let diff = "";
   let commits: string[] = [];
   let changedFiles: string[] = [];
 
   // Names and text here come from the repository; every one is an
   // argument to git, never shell text or an option.
-  const git = (args: string[]) =>
-    execFileSync("git", args, {
-      cwd: workingDir,
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "pipe"],
-      maxBuffer: 10 * 1024 * 1024,
-    });
+  const git = (args: string[]) => run("git", args, workingDir, 10_000);
   const lines = (out: string) =>
     out
       .split("\n")
@@ -72,7 +67,7 @@ function getGitContext(
     // Try to get the remote base branch reference
     let baseBranchRef = baseBranch;
     try {
-      git([
+      await git([
         "rev-parse",
         "--verify",
         "--end-of-options",
@@ -82,7 +77,7 @@ function getGitContext(
     } catch {
       // Fall back to local branch
       try {
-        git(["rev-parse", "--verify", "--end-of-options", baseBranch]);
+        await git(["rev-parse", "--verify", "--end-of-options", baseBranch]);
       } catch {
         // Base branch doesn't exist
         return { diff, commits, changedFiles };
@@ -91,18 +86,18 @@ function getGitContext(
     const range = `${baseBranchRef}...HEAD`;
 
     try {
-      diff = git(["diff", "--stat", "--end-of-options", range, "--"]);
+      diff = await git(["diff", "--stat", "--end-of-options", range, "--"]);
     } catch {}
 
     try {
       changedFiles = lines(
-        git(["diff", "--name-only", "--end-of-options", range, "--"])
+        await git(["diff", "--name-only", "--end-of-options", range, "--"])
       );
     } catch {}
 
     try {
       commits = lines(
-        git([
+        await git([
           "log",
           "--pretty=format:%s",
           "--end-of-options",
@@ -114,11 +109,11 @@ function getGitContext(
 
     // Also include uncommitted changes
     try {
-      const workingDiff = git(["diff", "--stat"]);
+      const workingDiff = await git(["diff", "--stat"]);
       if (workingDiff) {
         diff = diff ? `${diff}\n${workingDiff}` : workingDiff;
       }
-      const uncommittedFiles = lines(git(["diff", "--name-only"]));
+      const uncommittedFiles = lines(await git(["diff", "--name-only"]));
       changedFiles = [...new Set([...changedFiles, ...uncommittedFiles])];
     } catch {}
   } catch (error) {
@@ -138,7 +133,7 @@ async function generateWithClaude(
 ): Promise<GeneratedPRContent | null> {
   // Check if Claude CLI is available
   try {
-    execFileSync("claude", ["--version"], { stdio: "pipe", timeout: 5000 });
+    await run("claude", ["--version"], workingDir, 5000);
   } catch {
     return null;
   }
@@ -148,14 +143,7 @@ async function generateWithClaude(
   try {
     // Use claude CLI with --print flag for non-interactive output
     // The prompt goes on stdin: never argv, never a shell.
-    const output = execFileSync("claude", ["--print"], {
-      cwd: workingDir,
-      input: prompt,
-      encoding: "utf-8",
-      timeout: 30000,
-      maxBuffer: 1024 * 1024,
-    });
-
+    const output = await claudePrint(workingDir, prompt);
     return parseClaudeResponse(output);
   } catch (error) {
     console.debug("Claude CLI invocation failed", error);
@@ -163,6 +151,28 @@ async function generateWithClaude(
   }
 }
 
+// `claude --print` with the prompt on stdin, off the event loop and killed
+// at the ceiling.
+function claudePrint(cwd: string, prompt: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const child = execFile(
+      "claude",
+      ["--print"],
+      {
+        cwd,
+        encoding: "utf-8",
+        timeout: 30_000,
+        killSignal: "SIGKILL",
+        maxBuffer: 1024 * 1024,
+      },
+      (error, stdout) => (error ? reject(error) : resolve(stdout))
+    );
+    // claude exiting before it read the prompt is its failure, not a crash.
+    child.stdin?.on("error", () => {});
+    child.stdin?.end(prompt);
+  });
+}
+
 /**
  * Build prompt for PR generation
  */

package/lib/pr.ts

@@ -1,4 +1,6 @@
 import { execFileSync } from "child_process";
+import { run } from "./tasks/gh";
+import { GhBackoffError, isRateLimit } from "./tasks/gh-limit";
 
 /** The remote's default branch, or "main" when it has none. */
 export function remoteDefaultBranch(workingDir: string): string {
@@ -32,14 +34,19 @@ export interface CommitInfo {
   body: string;
 }
 
+// Every call here waits on git, gh or the network: all of it runs off the
+// event loop, so a slow GitHub never stalls the server's other requests.
+
 /**
- * Check if gh CLI is installed and authenticated
+ * Check if gh CLI is installed and authenticated. Throws GhBackoffError while
+ * every gh call waits out GitHub's rate limit: that isn't a missing login.
  */
-export function checkGhCli(): boolean {
+export async function checkGhCli(): Promise<boolean> {
   try {
-    execFileSync("gh", ["auth", "status"], { timeout: 5000, stdio: "pipe" });
+    await run("gh", ["auth", "status"], process.cwd(), 5000);
     return true;
-  } catch {
+  } catch (error) {
+    if (error instanceof GhBackoffError) throw error;
     return false;
   }
 }
@@ -47,22 +54,25 @@ export function checkGhCli(): boolean {
 /**
  * Get commits between current branch and base branch
  */
-export function getCommitsSinceBase(
+export async function getCommitsSinceBase(
   workingDir: string,
   baseBranch = "main"
-): CommitInfo[] {
+): Promise<CommitInfo[]> {
   try {
     // Get the merge base
     // Names come from the repository (its remote's default branch): they
     // are arguments, never shell text or options.
-    const mergeBase = execFileSync(
-      "git",
-      ["merge-base", "--end-of-options", baseBranch, "HEAD"],
-      { cwd: workingDir, encoding: "utf-8" }
+    const mergeBase = (
+      await run(
+        "git",
+        ["merge-base", "--end-of-options", baseBranch, "HEAD"],
+        workingDir,
+        10_000
+      )
     ).trim();
 
     // Get commits since merge base
-    const output = execFileSync(
+    const output = await run(
       "git",
       [
         "log",
@@ -70,7 +80,8 @@ export function getCommitsSinceBase(
         "--format=COMMIT_START%n%H%n%s%n%b%nCOMMIT_END",
         "--",
       ],
-      { cwd: workingDir, encoding: "utf-8" }
+      workingDir,
+      10_000
     );
 
     const commits: CommitInfo[] = [];
@@ -160,12 +171,12 @@ export function generatePRBody(commits: CommitInfo[]): string {
 /**
  * Get PR for a branch
  */
-export function getPRForBranch(
+export async function getPRForBranch(
   workingDir: string,
   branchName: string
-): PRInfo | null {
+): Promise<PRInfo | null> {
   try {
-    const output = execFileSync(
+    const output = await run(
       "gh",
       [
         "pr",
@@ -177,11 +188,16 @@ export function getPRForBranch(
         "--limit",
         "1",
       ],
-      { cwd: workingDir, encoding: "utf-8", timeout: 10000 }
+      workingDir,
+      10_000
     );
     const prs = JSON.parse(output);
     return prs.length > 0 ? prs[0] : null;
-  } catch {
+  } catch (error) {
+    // GitHub's rate limit says nothing about whether a PR exists.
+    if (error instanceof GhBackoffError) throw error;
+    if (isRateLimit(error))
+      throw new GhBackoffError("GitHub's rate limit is spent; try again later");
     return null;
   }
 }
@@ -189,30 +205,32 @@ export function getPRForBranch(
 /**
  * Create a new PR
  */
-export function createPR(
+export async function createPR(
   workingDir: string,
   branchName: string,
   baseBranch: string,
   title: string,
   body: string
-): PRInfo {
+): Promise<PRInfo> {
   // First ensure branch is pushed
   try {
-    execFileSync("git", ["push", "-u", "origin", "--", branchName], {
-      cwd: workingDir,
-      timeout: 30000,
-      stdio: "pipe",
-    });
+    await run(
+      "git",
+      ["push", "-u", "origin", "--", branchName],
+      workingDir,
+      30_000
+    );
   } catch {
     // Branch might already be pushed
   }
 
   // Create PR using gh CLI
   // gh pr create outputs the PR URL on success
-  const output = execFileSync(
+  const output = await run(
     "gh",
     ["pr", "create", "--title", title, "--base", baseBranch, "--body", body],
-    { cwd: workingDir, encoding: "utf-8", timeout: 30000 }
+    workingDir,
+    30_000
   );
 
   // Parse URL from output (gh pr create prints the URL)
@@ -235,20 +253,24 @@ export function createPR(
 /**
  * Get current branch name
  */
-export function getCurrentBranch(workingDir: string): string {
-  return execFileSync("git", ["branch", "--show-current"], {
-    cwd: workingDir,
-    encoding: "utf-8",
-  }).trim();
+export async function getCurrentBranch(workingDir: string): Promise<string> {
+  return (
+    await run("git", ["branch", "--show-current"], workingDir, 10_000)
+  ).trim();
 }
 
 /**
- * Get the default base branch (main or master)
+ * Get the default base branch: the remote's, or "main" when it has none.
  */
-export function getBaseBranch(workingDir: string): string {
+export async function getBaseBranch(workingDir: string): Promise<string> {
   try {
-    // Try to get from remote HEAD
-    return remoteDefaultBranch(workingDir);
+    const ref = await run(
+      "git",
+      ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"],
+      workingDir,
+      10_000
+    );
+    return ref.trim().replace(/^origin\//, "");
   } catch {
     return "main";
   }

package/lib/sidebar/machines.ts

@@ -1,6 +1,6 @@
 // A linked machine's sessions are sessions here. One whose folder maps to
 // a project here sits with that project's sessions; the rest are listed
-// under their machine ("homelab · 3"), with the same rows. Client-safe.
+// under their machine ("devbox · 3"), with the same rows. Client-safe.
 import type { Session } from "@/lib/db/types";
 import { buildShelves, type ShelfInput, type SidebarRow } from "./shelves";
 

package/lib/status-detector.ts

@@ -662,6 +662,13 @@ class SessionStatusDetector {
     return [...this.cache.data.values()];
   }
 
+  // A new object whenever the listing or its errors change (the cache is
+  // replaced, never edited): readers derived from them can skip the work
+  // while it's the same one.
+  listingStamp(): object {
+    return this.cache;
+  }
+
   hostErrors(): Record<string, string> {
     return Object.fromEntries(this.cache.hostErrors);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.462",
+  "version": "0.3.464",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"
@@ -18,7 +18,6 @@
     "mcp/",
     "public/",
     "scripts/",
-    "!scripts/competitor-audit/**",
     "stores/",
     "styles/",
     "next.config.ts",

package/scripts/check

@@ -1,12 +1,13 @@
 #!/usr/bin/env bash
 # The full guard, the same run locally and in CI:
-#   scripts/check            typecheck, lint, format, tests
+#   scripts/check            banned terms, typecheck, lint, format, tests
 #   scripts/check --build    ...and a production build, held to its JS budget
 set -euo pipefail
 cd "$(dirname "$0")/.."
 
 step() { printf '\n▸ %s\n' "$1"; }
 
+step "terms";     npx tsx scripts/hooks/banned-terms.ts --tree
 step "typecheck"; npx tsc --noEmit
 step "lint";      npx eslint . --max-warnings=40
 step "format";    npx prettier --check . --log-level warn

package/scripts/hooks/banned-terms.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, it } from "vitest";
+import { execFileSync, spawnSync } from "child_process";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { GENERIC_TERMS, loadTerms, matcher, scanTree } from "./banned-terms";
+
+const generic = GENERIC_TERMS[0];
+
+function tempRepo() {
+  const repo = fs.mkdtempSync(path.join(os.tmpdir(), "banned-terms-"));
+  const git = (...args: string[]) =>
+    execFileSync("git", args, { cwd: repo, stdio: "pipe" });
+  git("init", "-q");
+  return { repo, git };
+}
+
+describe("loadTerms", () => {
+  it("is the generic list alone when the private file is absent", () => {
+    const terms = loadTerms(path.join(os.tmpdir(), "no-such-banned-names"));
+    expect(terms.map((t) => t.source)).toEqual(GENERIC_TERMS);
+  });
+
+  it("adds the private regexes, skipping blanks and comments", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "banned-names-"));
+    const file = path.join(dir, "banned-names");
+    fs.writeFileSync(file, "# names\nacme[ -]?widgets\n\n  zorp  \n");
+    try {
+      const check = matcher(loadTerms(file));
+      expect(check("We copied Acme-Widgets here")).toBe('"Acme-Widgets"');
+      expect(check("ZORP")).toBe('"ZORP"');
+      expect(check(`the ${generic.toUpperCase()} list`)).not.toBeNull();
+      expect(check("nothing to see")).toBeNull();
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("scanTree", () => {
+  it("names the file and line of each hit, and a hit in a path", () => {
+    const { repo, git } = tempRepo();
+    try {
+      fs.mkdirSync(path.join(repo, `${generic}-x`));
+      fs.writeFileSync(path.join(repo, `${generic}-x`, "a.md"), "fine\n");
+      fs.writeFileSync(path.join(repo, "b.ts"), `ok\n// a ${generic}\n`);
+      fs.writeFileSync(path.join(repo, "c.bin"), `\0${generic}`);
+      git("add", ".");
+      expect(scanTree(repo, loadTerms("/nonexistent"))).toEqual([
+        { file: "b.ts", line: 2, what: `"${generic}"` },
+        { file: `${generic}-x/a.md`, line: 0, what: `"${generic}"` },
+      ]);
+    } finally {
+      fs.rmSync(repo, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("the pre-commit check", () => {
+  it("fails on a staged private name, and passes once it's gone", () => {
+    const { repo, git } = tempRepo();
+    const list = path.join(repo, "..", `${path.basename(repo)}-names`);
+    fs.writeFileSync(list, "acme\n");
+    const scan = () =>
+      spawnSync(
+        path.resolve("node_modules/.bin/tsx"),
+        [path.resolve("scripts/hooks/banned-terms.ts")],
+        {
+          cwd: repo,
+          encoding: "utf-8",
+          env: { ...process.env, AGENTOS_BANNED_NAMES: list },
+        }
+      );
+    try {
+      fs.writeFileSync(path.join(repo, "x.md"), "ok\nlike Acme does\n");
+      git("add", "x.md");
+      const bad = scan();
+      expect(bad.status).toBe(1);
+      expect(bad.stderr).toContain("x.md:2");
+      fs.writeFileSync(path.join(repo, "x.md"), "ok\nlike others do\n");
+      git("add", "x.md");
+      expect(scan().status).toBe(0);
+      fs.writeFileSync(path.join(repo, "acme-notes.md"), "clean\n");
+      git("add", "acme-notes.md");
+      const named = scan();
+      expect(named.status).toBe(1);
+      expect(named.stderr).toContain("acme-notes.md:0");
+    } finally {
+      fs.rmSync(repo, { recursive: true, force: true });
+      fs.rmSync(list, { force: true });
+    }
+  });
+});

package/scripts/hooks/banned-terms.ts

@@ -0,0 +1,103 @@
+/**
+ * Words that must never land in this public repo: one generic term, always,
+ * plus a private denylist kept outside the repo (the list itself would be a
+ * mention), one case-insensitive regex per line, skipped when it's absent.
+ *
+ *   tsx scripts/hooks/banned-terms.ts          the staged diff's added lines (pre-commit)
+ *   tsx scripts/hooks/banned-terms.ts --tree   every tracked file (scripts/check, CI)
+ */
+
+import { execFileSync } from "child_process";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { scanDiff, stagedDiff, type SecretHit } from "./staged-secrets";
+
+// Assembled so this file isn't a hit itself.
+export const GENERIC_TERMS = [["compet", "itor"].join("")];
+
+export const bannedFile = () =>
+  process.env.AGENTOS_BANNED_NAMES ||
+  path.join(os.homedir(), ".config", "agent-os", "banned-names");
+
+export function loadTerms(file = bannedFile()): RegExp[] {
+  const generic = GENERIC_TERMS.map((t) => new RegExp(t, "i"));
+  let raw = "";
+  try {
+    raw = fs.readFileSync(file, "utf8");
+  } catch {
+    return generic;
+  }
+  const own = raw
+    .split("\n")
+    .map((l) => l.trim())
+    .filter((l) => l && !l.startsWith("#"))
+    .map((l) => new RegExp(l, "i"));
+  return [...generic, ...own];
+}
+
+// What a line matched, without echoing the private pattern that caught it.
+export const matcher = (terms: RegExp[]) => (line: string) => {
+  for (const t of terms) {
+    const m = line.match(t);
+    if (m) return `"${m[0]}"`;
+  }
+  return null;
+};
+
+export function scanTree(cwd: string, terms: RegExp[]): SecretHit[] {
+  const check = matcher(terms);
+  const files = execFileSync("git", ["ls-files", "-z"], {
+    cwd,
+    encoding: "utf8",
+    maxBuffer: 64 * 1024 * 1024,
+  })
+    .split("\0")
+    .filter(Boolean);
+  const hits: SecretHit[] = [];
+  for (const file of files) {
+    let text: string;
+    try {
+      text = fs.readFileSync(path.join(cwd, file), "utf8");
+    } catch {
+      continue; // deleted in the working tree, or a submodule
+    }
+    if (text.includes("\0")) continue;
+    text.split("\n").forEach((l, i) => {
+      const what = check(l);
+      if (what) hits.push({ file, line: i + 1, what });
+    });
+  }
+  // A path can name something too.
+  for (const file of files) {
+    const what = check(file);
+    if (what) hits.push({ file, line: 0, what });
+  }
+  return hits;
+}
+
+function stagedHits(terms: RegExp[]): SecretHit[] {
+  const check = matcher(terms);
+  const names = execFileSync(
+    "git",
+    ["diff", "--cached", "--name-only", "-z", "--diff-filter=ACMR"],
+    { encoding: "utf8" }
+  )
+    .split("\0")
+    .filter(Boolean)
+    .flatMap((file) => {
+      const what = check(file);
+      return what ? [{ file, line: 0, what }] : [];
+    });
+  return [...scanDiff(stagedDiff(), check), ...names];
+}
+
+if (process.argv[1]?.endsWith("banned-terms.ts")) {
+  const terms = loadTerms();
+  const hits = process.argv.includes("--tree")
+    ? scanTree(process.cwd(), terms)
+    : stagedHits(terms);
+  for (const h of hits)
+    console.error(`✗ ${h.file}:${h.line}: names ${h.what}; reword it`);
+  if (hits.length) process.exit(1);
+}

package/scripts/hooks/staged-secrets.ts

@@ -13,10 +13,13 @@ export interface SecretHit {
   what: string;
 }
 
-// Each added line of a `git diff -U0` with the file and new line number it
-// lands on. Headers are only read before a file's first hunk, so an added
-// line that itself starts with "++" isn't taken for one.
-export function scanDiff(diff: string): SecretHit[] {
+// Each added line of a `git diff -U0` that `check` flags, with the file and
+// new line number it lands on. Headers are only read before a file's first
+// hunk, so an added line that itself starts with "++" isn't taken for one.
+export function scanDiff(
+  diff: string,
+  check: (line: string) => string | null = secretsIn
+): SecretHit[] {
   const hits: SecretHit[] = [];
   let file = "";
   let line = 0;
@@ -30,7 +33,7 @@ export function scanDiff(diff: string): SecretHit[] {
       header = false;
       line = Number(l.match(/\+(\d+)/)?.[1] ?? 0);
     } else if (!header && l.startsWith("+")) {
-      const what = secretsIn(l.slice(1));
+      const what = check(l.slice(1));
       if (what) hits.push({ file, line, what });
       line++;
     }
@@ -38,8 +41,8 @@ export function scanDiff(diff: string): SecretHit[] {
   return hits;
 }
 
-if (process.argv[1]?.endsWith("staged-secrets.ts")) {
-  const diff = execFileSync(
+export const stagedDiff = () =>
+  execFileSync(
     "git",
     [
       "diff",
@@ -51,7 +54,9 @@ if (process.argv[1]?.endsWith("staged-secrets.ts")) {
     ],
     { encoding: "utf8", maxBuffer: 256 * 1024 * 1024 }
   );
-  const hits = scanDiff(diff);
+
+if (process.argv[1]?.endsWith("staged-secrets.ts")) {
+  const hits = scanDiff(stagedDiff());
   for (const h of hits)
     console.error(`✗ ${h.file}:${h.line}: looks like a secret (${h.what})`);
   if (hits.length) {