@saadnvd1/agent-os 0.3.463 → 0.3.464

package/README.md

@@ -947,7 +947,7 @@ it may do on its own, and the lines that always come back to you as asks.
 - **Decision log:** `note` and the brakes and escalations write to
   `orchestrator_notes`, and each line shows in its chat.
 - **Standing rules:** what it must keep knowing ("never merge #111", "briefs
-  must not name competitors") it keeps with `rule_add` and drops with
+  must not name third-party products") it keeps with `rule_add` and drops with
   `rule_remove`, in `orchestrator_rules`. You see, add, edit and remove them in
   Settings → Workspaces, each change with your passkey (any process on the
   machine reaches the route, and a rule of yours is your word to it). A rule restricts or informs; it never approves an
@@ -1273,7 +1273,12 @@ added lines for token-shaped secrets with the merge gate's own rule
 (`scripts/hooks/staged-secrets.ts` reads `secretsIn` from
 `lib/orchestrator/diff.ts`), naming the file and line. Build a test's fake
 token at runtime (`"gh" + "p_" + "a".repeat(36)`) rather than writing it
-whole. It runs in the worktrees AgentOS makes too, which have no `.husky/_`
+whole. It also refuses words that must not land in this public repo
+(`scripts/hooks/banned-terms.ts`): a short built-in list, plus, when it
+exists, a private list of regexes kept outside the repo in
+`~/.config/agent-os/banned-names` (`AGENTOS_BANNED_NAMES` overrides the
+path), checked against added lines and file names; `scripts/check` runs the
+same check over every tracked file. It runs in the worktrees AgentOS makes too, which have no `.husky/_`
 until `npm install` runs in them. Typecheck, lint and tests are left to CI.
 In an emergency, `git commit --no-verify` skips it. CI runs `scripts/check --build` on every pull request and push to main,
 which also holds the app's first-load JavaScript to a budget

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.463",
+  "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) {