@saadnvd1/agent-os 0.3.738 → 0.3.743

package/lib/chat/drivers/demo.ts

@@ -1,16 +1,18 @@
 /**
  * The demo's stand-in for an agent (AGENTOS_DEMO=1): no process, no tools,
  * just a short canned reply streamed the way a real one is, so the chat
- * flow still works end to end.
+ * flow still works end to end. A typed `demo: running turn` runs the
+ * scripted turn in demo-script.ts instead.
  */
 
 import type { ChatConversation, ChatDriver } from "../driver";
 import type { DriverEvent } from "../events";
+import { parseDemoScript, runDemoScript, type DemoScript } from "./demo-script";
 
 export const DEMO_REPLY =
   "This is a demo, so agents don't run here. On your own machine, this is where the agent would answer and get to work.";
 
-const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+const sleep = (ms: number) => new Promise<void>((r) => setTimeout(r, ms));
 
 // Events pushed by sends and read by one consumer, in order.
 function channel() {
@@ -89,12 +91,27 @@ export function demoConversation(stepMs = 40): ChatConversation {
     });
     out.push({ type: "state", state: "idle" });
   };
+  // A scripted turn that a newer one took over from says nothing more.
+  let generation = 0;
+  const script = async (s: DemoScript, mine: number) => {
+    if (closed) return;
+    stopped = false;
+    await runDemoScript(s, {
+      push: (e) => mine === generation && out.push(e),
+      stopped: () => stopped || closed,
+      sleep,
+    });
+  };
   const refuse = async () => {
     throw new Error("Not available in the demo.");
   };
   return {
-    send() {
-      turn = turn.then(reply);
+    send(text) {
+      const s = parseDemoScript(text);
+      // A scripted turn takes over from one still running.
+      const mine = s ? ++generation : generation;
+      if (s) stopped = true;
+      turn = turn.then(s ? () => script(s, mine) : reply);
       return undefined;
     },
     async interrupt() {

package/lib/chat/drivers/edit-guard.ts

@@ -0,0 +1,311 @@
+import fs from "fs";
+import path from "path";
+import { createRequire } from "module";
+import { agentosHome } from "../../agentos-home";
+
+// What a model needs after an edit goes wrong, for Pi and OpenCode alike
+// (their edit tools are theirs, so this runs beside them as an extension and
+// a plugin):
+//
+// - an edit whose old text isn't in the file is refused before it runs, with
+//   the file's current text around the closest match, and a repeat of an edit
+//   that already failed is called out;
+// - after an edit or write to a TypeScript or JavaScript file, new syntax
+//   errors and block-scoped names declared twice come back in the tool result.
+//
+// Plain ESM with no imports beyond node's, so Node (Pi) and Bun (OpenCode)
+// both run it. It never throws and never blocks on anything it can't read.
+// Written as a string, like the other extensions, and exported for its test.
+export const EDIT_GUARD_LIB = String.raw`import { createHash } from "node:crypto";
+import { readFileSync, statSync } from "node:fs";
+import { createRequire } from "node:module";
+import { extname, resolve } from "node:path";
+
+const SOURCE = new Set([".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"]);
+const MAX_BYTES = 1048576;
+const MAX_REPORTED = 10;
+const EXCERPT_LINES = 40;
+const EXCERPT_CHARS = 3000;
+
+const norm = (s) => String(s).replace(/\r\n/g, "\n");
+const trimmed = (s) => norm(s).split("\n").map((l) => l.trim());
+const collapse = (s) => norm(s).replace(/\s+/g, " ").trim();
+
+export function readText(file) {
+  try {
+    if (statSync(file).size > MAX_BYTES) return null;
+    return readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+}
+
+export const absolute = (file, cwd) =>
+  resolve(cwd || process.cwd(), String(file).replace(/^@/, ""));
+
+function needLines(old) {
+  const need = trimmed(old);
+  while (need.length && need[need.length - 1] === "") need.pop();
+  while (need.length && need[0] === "") need.shift();
+  return need;
+}
+
+// Whether any of the harnesses' matchers could find this text: exact, line by
+// line without indentation, with whitespace collapsed, or by its first and
+// last lines. Only text none of them find is refused, so an edit a harness
+// would have accepted is never blocked here.
+export function isFound(text, old) {
+  if (typeof old !== "string" || !old.trim()) return true;
+  if (text.includes(old) || norm(text).includes(norm(old))) return true;
+  const hay = trimmed(text);
+  const need = needLines(old);
+  if (!need.length) return true;
+  for (let i = 0; i + need.length <= hay.length; i++) {
+    let same = true;
+    for (let j = 0; j < need.length && same; j++) same = hay[i + j] === need[j];
+    if (same) return true;
+  }
+  if (collapse(text).includes(collapse(old))) return true;
+  if (need.length >= 3) {
+    const last = need[need.length - 1];
+    for (let i = 0; i < hay.length; i++) {
+      if (hay[i] !== need[0]) continue;
+      const to = Math.min(hay.length, i + need.length + 10);
+      for (let k = i + 2; k < to; k++) if (hay[k] === last) return true;
+    }
+  }
+  return false;
+}
+
+// The file's lines around where the old text most likely was, numbered, or
+// null when nothing in the file resembles it.
+export function closestMatch(text, old) {
+  const lines = norm(text).split("\n");
+  const hay = lines.map((l) => l.trim());
+  const need = trimmed(old);
+  const real = need.filter((l) => l.length > 2);
+  if (!real.length) return null;
+  const anchor = real.reduce((a, b) => (b.length > a.length ? b : a));
+  const offset = need.indexOf(anchor);
+  let hits = [];
+  hay.forEach((l, i) => l === anchor && hits.push(i));
+  if (!hits.length) hay.forEach((l, i) => l.length > 2 && (l.includes(anchor) || anchor.includes(l)) && hits.push(i));
+  if (!hits.length) {
+    const words = (l) => new Set(l.toLowerCase().split(/[^a-z0-9_$]+/).filter(Boolean));
+    const want = words(anchor);
+    let top = 0.5;
+    hay.forEach((l, i) => {
+      const have = words(l);
+      let shared = 0;
+      for (const w of have) if (want.has(w)) shared++;
+      const dice = (2 * shared) / (want.size + have.size || 1);
+      if (dice > top) {
+        top = dice;
+        hits = [i];
+      }
+    });
+  }
+  if (!hits.length) return null;
+  let best = { score: -1, start: 0 };
+  for (const h of hits.slice(0, 200)) {
+    const start = Math.max(0, h - offset);
+    let score = 0;
+    for (let j = 0; j < need.length; j++) if (hay[start + j] === need[j] && need[j]) score++;
+    if (score > best.score) best = { score, start };
+  }
+  const from = Math.max(0, best.start - 3);
+  const to = Math.min(lines.length, best.start + need.length + 3);
+  let shown = lines.slice(from, to);
+  if (shown.length > EXCERPT_LINES) shown = shown.slice(0, EXCERPT_LINES);
+  let excerpt = shown.map((l, i) => (from + i + 1) + "\t" + l).join("\n");
+  if (excerpt.length > EXCERPT_CHARS) excerpt = excerpt.slice(0, EXCERPT_CHARS) + "\n…";
+  return { from: from + 1, to: from + shown.length, excerpt };
+}
+
+export function failureMessage(file, old, text, repeat) {
+  const near = closestMatch(text, old);
+  const out = [
+    "The old text was not found in " + file + ". The file is not what this edit assumes: it changed since you last read it, or the text is not exactly what is there.",
+  ];
+  if (repeat >= 2)
+    out.push("This is the same edit (same file, same old text) that has already failed " + (repeat - 1) + " time" + (repeat > 2 ? "s" : "") + ". Do not send it again unchanged.");
+  if (near) out.push("The file's current text near the closest match (lines " + near.from + "-" + near.to + "):", near.excerpt);
+  else out.push("Nothing in the file resembles that text (" + norm(text).split("\n").length + " lines).");
+  out.push("Read " + file + " again and build the edit from what is there now.");
+  return out.join("\n");
+}
+
+// Failed edits by file and old text, so a repeat can be named. A read, a
+// successful edit or a write of the file starts it over.
+export class FailureLog {
+  constructor() {
+    this.counts = new Map();
+  }
+  key(file, old) {
+    return file + "\0" + createHash("sha1").update(String(old)).digest("hex");
+  }
+  record(file, old) {
+    const key = this.key(file, old);
+    const n = (this.counts.get(key) || 0) + 1;
+    this.counts.set(key, n);
+    return n;
+  }
+  clear(file) {
+    for (const key of [...this.counts.keys()]) if (key.startsWith(file + "\0")) this.counts.delete(key);
+  }
+}
+
+// The refusal for an edit whose old text isn't in the file, or null to let
+// it run. Several edits to one file: the first missing one is named.
+export function guardEdit(log, file, oldTexts, cwd) {
+  try {
+    const path = absolute(file, cwd);
+    const text = readText(path);
+    if (text == null) return null;
+    const missing = oldTexts.find((o) => !isFound(text, o));
+    if (missing === undefined) return null;
+    return failureMessage(file, missing, text, log.record(path, missing));
+  } catch {
+    return null;
+  }
+}
+
+const tsByRoot = new Map();
+function loadTs(cwd) {
+  const root = resolve(cwd || process.cwd());
+  const cacheKey = root + "|" + (process.env.AGENTOS_TYPESCRIPT || "");
+  if (tsByRoot.has(cacheKey)) return tsByRoot.get(cacheKey);
+  let found = null;
+  const tries = [
+    () => createRequire(resolve(root, "package.json"))("typescript"),
+    () => (process.env.AGENTOS_TYPESCRIPT ? createRequire(import.meta.url)(process.env.AGENTOS_TYPESCRIPT) : null),
+  ];
+  for (const t of tries) {
+    try {
+      const m = t();
+      if (m && typeof m.createSourceFile === "function") {
+        found = m;
+        break;
+      }
+    } catch {}
+  }
+  tsByRoot.set(cacheKey, found);
+  return found;
+}
+
+function bindingNames(ts, name, out) {
+  if (ts.isIdentifier(name)) out.push(name);
+  else for (const el of name.elements) if (!ts.isOmittedExpression(el)) bindingNames(ts, el.name, out);
+}
+
+function duplicates(ts, sf) {
+  const found = [];
+  const check = (statements) => {
+    const lexical = new Map();
+    const hoisted = new Map();
+    const add = (map, id, kind) => {
+      const line = sf.getLineAndCharacterOfPosition(id.getStart(sf)).line + 1;
+      if (!map.has(id.text)) map.set(id.text, []);
+      map.get(id.text).push({ kind, line });
+    };
+    for (const st of statements) {
+      if (ts.isVariableStatement(st)) {
+        const flags = st.declarationList.flags;
+        const kind = flags & ts.NodeFlags.Const ? "const" : flags & ts.NodeFlags.Let ? "let" : "var";
+        const ids = [];
+        for (const d of st.declarationList.declarations) bindingNames(ts, d.name, ids);
+        for (const id of ids) add(kind === "var" ? hoisted : lexical, id, kind);
+      } else if (ts.isClassDeclaration(st) && st.name) add(lexical, st.name, "class");
+      else if (ts.isFunctionDeclaration(st) && st.name) add(hoisted, st.name, "function");
+    }
+    for (const [name, at] of lexical) {
+      const all = at.concat(hoisted.get(name) || []);
+      if (all.length > 1) found.push({ name, kind: at[0].kind, lines: all.map((a) => a.line).sort((a, b) => a - b) });
+    }
+  };
+  const visit = (node) => {
+    if (ts.isSourceFile(node) || ts.isBlock(node) || ts.isModuleBlock(node)) check(node.statements);
+    else if (ts.isCaseBlock(node)) check(node.clauses.flatMap((c) => [...c.statements]));
+    ts.forEachChild(node, visit);
+  };
+  visit(sf);
+  return found;
+}
+
+function problems(ts, file, text) {
+  const out = [];
+  const t = ts.transpileModule(text, {
+    fileName: file,
+    reportDiagnostics: true,
+    compilerOptions: { jsx: ts.JsxEmit.Preserve, target: ts.ScriptTarget.Latest, isolatedModules: true },
+  });
+  for (const d of t.diagnostics || []) {
+    const at = d.file && d.start != null ? d.file.getLineAndCharacterOfPosition(d.start) : null;
+    const message = ts.flattenDiagnosticMessageText(d.messageText, " ");
+    out.push({ key: message, text: (at ? (at.line + 1) + ":" + (at.character + 1) + " " : "") + message });
+  }
+  const sf = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true);
+  for (const d of duplicates(ts, sf))
+    out.push({
+      key: "duplicate " + d.name,
+      text: d.kind + " " + d.name + " is declared more than once in the same block (lines " + d.lines.join(", ") + ")",
+    });
+  return out;
+}
+
+// What an edit broke in a source file: the problems it has now that it didn't
+// before, as text for the tool result, or "" when there are none, the file
+// isn't source, or TypeScript can't be loaded. Syntax only, never types.
+export function syntaxReport(file, before, after, cwd) {
+  try {
+    if (!SOURCE.has(extname(file).toLowerCase()) || typeof after !== "string" || after.length > MAX_BYTES) return "";
+    const ts = loadTs(cwd);
+    if (!ts) return "";
+    const had = new Map();
+    for (const p of before == null || before.length > MAX_BYTES ? [] : problems(ts, file, before)) had.set(p.key, (had.get(p.key) || 0) + 1);
+    const fresh = [];
+    for (const p of problems(ts, file, after)) {
+      const n = had.get(p.key) || 0;
+      if (n > 0) had.set(p.key, n - 1);
+      else fresh.push(p);
+    }
+    if (!fresh.length) return "";
+    const shown = fresh.slice(0, MAX_REPORTED).map((p) => "- " + p.text);
+    if (fresh.length > shown.length) shown.push("- and " + (fresh.length - shown.length) + " more");
+    return "[AgentOS syntax check] This change left problems in " + file + " that were not there before. Fix them now:\n" + shown.join("\n");
+  } catch {
+    return "";
+  }
+}
+`;
+
+const dir = () => agentosHome("edit-guard");
+
+// Owner-only, like the other extension folders.
+export function writeEditGuard(
+  name: string,
+  source: string,
+  folder = dir()
+): string {
+  fs.mkdirSync(folder, { recursive: true, mode: 0o700 });
+  fs.chmodSync(folder, 0o700);
+  for (const [file, text] of [
+    ["agentos-edit-guard-lib.mjs", EDIT_GUARD_LIB],
+    [name, source],
+  ]) {
+    const target = path.join(folder, file);
+    if (!fs.existsSync(target) || fs.readFileSync(target, "utf8") !== text)
+      fs.writeFileSync(target, text);
+  }
+  return path.join(folder, name);
+}
+
+// The TypeScript this server runs on, for projects that have none of their
+// own, or undefined where there isn't one.
+export function typescriptPath(): string | undefined {
+  try {
+    return createRequire(import.meta.url).resolve("typescript");
+  } catch {
+    return undefined;
+  }
+}

package/lib/chat/drivers/index.ts

@@ -6,7 +6,7 @@ import { openCodeDriver } from "./opencode";
 import { piDriver } from "./pi";
 import { copilotDriver } from "./copilot";
 import { demoDriver } from "./demo";
-import { demoMode } from "../../security/demo";
+import { demoChatMode, demoMode } from "../../security/demo";
 
 // One driver per agent CLI. Adding a CLI means a driver here and its agent
 // type in CHAT_AGENT_TYPES.
@@ -21,5 +21,5 @@ const DRIVERS: Record<(typeof CHAT_AGENT_TYPES)[number], ChatDriver> = {
 export function chatDriverFor(agentType: string): ChatDriver | null {
   const driver = DRIVERS[agentType as keyof typeof DRIVERS] ?? null;
   // A demo never starts a real agent (lib/chat/demo runs this one).
-  return driver && demoMode() ? demoDriver : driver;
+  return driver && (demoMode() || demoChatMode()) ? demoDriver : driver;
 }

package/lib/chat/drivers/opencode-config.ts

@@ -0,0 +1,111 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { pathToFileURL } from "url";
+
+type P = Record<string, unknown>;
+
+// How long OpenCode waits for a model server's response headers (its default
+// is 5 minutes). A local model chewing through a long context sends nothing
+// until it has read all of it, and a retry at the same limit fails the same
+// way. The wait between chunks of a streamed reply keeps OpenCode's own 5
+// minute limit, so a stream that started is judged on idle time and a server
+// that never answers still ends the request.
+export const HEADER_TIMEOUT_MS = 1_200_000;
+
+const isObject = (v: unknown): v is P =>
+  !!v && typeof v === "object" && !Array.isArray(v);
+
+// JSON with comments and trailing commas (OpenCode's config allows both),
+// parsed without touching what is inside strings. Null when it isn't JSON.
+export function parseJsonc(text: string): P | null {
+  let out = "";
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (c === '"') {
+      let j = i + 1;
+      while (j < text.length && text[j] !== '"') j += text[j] === "\\" ? 2 : 1;
+      out += text.slice(i, j + 1);
+      i = j;
+    } else if (c === "/" && text[i + 1] === "/") {
+      while (i < text.length && text[i] !== "\n") i++;
+      out += "\n";
+    } else if (c === "/" && text[i + 1] === "*") {
+      const end = text.indexOf("*/", i + 2);
+      i = end < 0 ? text.length : end + 1;
+    } else out += c;
+  }
+  try {
+    const v: unknown = JSON.parse(out.replace(/,(\s*[}\]])/g, "$1"));
+    return isObject(v) ? v : null;
+  } catch {
+    return null;
+  }
+}
+
+function read(file: string): P | null {
+  try {
+    return parseJsonc(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function userConfigs(cwd: string, env: NodeJS.ProcessEnv): P[] {
+  const home = env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
+  const files = [
+    ...["opencode.json", "opencode.jsonc", "config.json"].map((f) =>
+      path.join(home, "opencode", f)
+    ),
+    ...(env.OPENCODE_CONFIG ? [env.OPENCODE_CONFIG] : []),
+    ...["opencode.json", "opencode.jsonc"].flatMap((f) => [
+      path.join(cwd, f),
+      path.join(cwd, ".opencode", f),
+    ]),
+  ];
+  return files.map(read).filter((c): c is P => !!c);
+}
+
+// The OPENCODE_CONFIG_CONTENT for one conversation: the user's own value
+// (never replaced, their providers are in it) plus the edit guard plugin and
+// a longer header wait for each provider in their config and for the
+// conversation's model, unless they set one themselves.
+export function openCodeConfigContent(o: {
+  cwd: string;
+  env: NodeJS.ProcessEnv;
+  // "provider/model", the conversation's.
+  model?: string;
+  pluginFile?: string;
+}): string {
+  const given = o.env.OPENCODE_CONFIG_CONTENT;
+  const base = given ? parseJsonc(given) : {};
+  if (!base) return given as string;
+
+  const own = new Set<string>();
+  const set = new Set<string>();
+  const slash = o.model?.indexOf("/") ?? -1;
+  if (o.model && slash > 0) set.add(o.model.slice(0, slash));
+  for (const c of [...userConfigs(o.cwd, o.env), base]) {
+    if (!isObject(c.provider)) continue;
+    for (const [id, p] of Object.entries(c.provider)) {
+      set.add(id);
+      const options = isObject(p) && isObject(p.options) ? p.options : {};
+      if (options.headerTimeout !== undefined) own.add(id);
+    }
+  }
+
+  const provider: P = isObject(base.provider) ? { ...base.provider } : {};
+  for (const id of set) {
+    if (own.has(id)) continue;
+    const p = isObject(provider[id]) ? (provider[id] as P) : {};
+    const options = isObject(p.options) ? p.options : {};
+    provider[id] = {
+      ...p,
+      options: { ...options, headerTimeout: HEADER_TIMEOUT_MS },
+    };
+  }
+
+  const plugin = Array.isArray(base.plugin) ? [...base.plugin] : [];
+  if (o.pluginFile) plugin.push(pathToFileURL(o.pluginFile).href);
+  return JSON.stringify({ ...base, provider, plugin });
+}