forgeos 0.1.0-alpha.7 → 0.1.0-alpha.71

package/src/forge/agent-memory/sources/codex-hook-runner.mjs

@@ -0,0 +1,343 @@
+#!/usr/bin/env node
+/**
+ * Lightweight Codex hook runner — no Forge CLI, no DeltaDB.
+ * Reads stdin with a short timeout, enqueues a redacted event to .forge/agent/events.ndjson, exits.
+ */
+import { createHash, randomUUID } from "node:crypto";
+import { execFileSync, spawn } from "node:child_process";
+import { connect } from "node:net";
+import { appendFileSync, mkdirSync, openSync, closeSync, existsSync, readFileSync, readSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+
+const STDIN_TIMEOUT_MS = 750;
+const eventName = process.argv[2];
+
+if (!eventName) {
+  process.stderr.write("usage: codex-hook.mjs <CodexHookEvent>\n");
+  process.exit(2);
+}
+
+const workspaceRoot = resolve(process.cwd());
+const eventsFile = join(workspaceRoot, ".forge", "agent", "events.ndjson");
+const queueLockFile = `${eventsFile}.append-lock.json`;
+const brokerStartLockFile = join(workspaceRoot, ".forge", "agent", "broker-start-lock.json");
+const QUEUE_LOCK_WAIT_MS = 500;
+
+const SAFE_ID = /^[A-Za-z0-9_.:-]{1,128}$/u;
+
+function readStdin(timeoutMs) {
+  return new Promise((resolveRead) => {
+    if (process.stdin.isTTY) {
+      resolveRead("");
+      return;
+    }
+    const chunks = [];
+    let settled = false;
+    const finish = () => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      resolveRead(Buffer.concat(chunks).toString("utf8"));
+    };
+    const timer = setTimeout(() => {
+      process.stdin.destroy();
+      finish();
+    }, timeoutMs);
+    process.stdin.on("data", (chunk) => {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+    });
+    process.stdin.on("end", finish);
+    process.stdin.on("close", finish);
+    process.stdin.on("error", finish);
+    process.stdin.resume();
+  });
+}
+
+async function main() {
+  const stdin = await readStdin(STDIN_TIMEOUT_MS);
+  const trimmed = stdin.trim();
+  let raw = {};
+  if (trimmed) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      raw = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : { _invalidPayload: true };
+    } catch {
+      raw = { _parseError: true, _rawLength: trimmed.length };
+    }
+  }
+  if (!raw.hook_event_name) {
+    raw.hook_event_name = eventName;
+  }
+  if (!raw.cwd) {
+    raw.cwd = workspaceRoot;
+  }
+
+  const entry = {
+    forgeHookQueueV1: true,
+    queueEventId: randomUUID(),
+    source: "codex",
+    integration: raw.forgeMcpHook === true ? "mcp" : "native-hook",
+    eventName,
+    workspaceRoot,
+    enqueuedAt: new Date().toISOString(),
+    rawStored: false,
+    payloadRedacted: true,
+    payload: sanitizePayload(raw, eventName),
+  };
+
+  mkdirSync(dirname(eventsFile), { recursive: true });
+  const lock = await acquireQueueLock();
+  try {
+    ensureQueueLineBoundary();
+    appendFileSync(eventsFile, `${JSON.stringify(entry)}\n`, "utf8");
+  } finally {
+    releaseQueueLock(lock);
+  }
+  await wakeBroker();
+}
+
+function ensureQueueLineBoundary() {
+  if (!existsSync(eventsFile)) return;
+  const size = statSync(eventsFile).size;
+  if (size === 0) return;
+  const fd = openSync(eventsFile, "r");
+  try {
+    const last = Buffer.alloc(1);
+    if (readSync(fd, last, 0, 1, size - 1) === 1 && last[0] !== 10) {
+      appendFileSync(eventsFile, "\n", "utf8");
+    }
+  } finally {
+    closeSync(fd);
+  }
+}
+
+async function wakeBroker() {
+  const endpointPath = join(workspaceRoot, ".forge", "delta", "broker-endpoint.json");
+  try {
+    const endpoint = JSON.parse(readFileSync(endpointPath, "utf8"));
+    if (endpoint?.root === workspaceRoot && await signalBroker(endpoint)) {
+      try { unlinkSync(brokerStartLockFile); } catch { /* already absent */ }
+      return;
+    }
+  } catch { /* no active broker */ }
+  const metaPath = join(workspaceRoot, ".forge", "agent", "codex-hook.meta.json");
+  let brokerRunnerPath;
+  try {
+    const meta = JSON.parse(readFileSync(metaPath, "utf8"));
+    if (meta?.workspaceRoot !== workspaceRoot || typeof meta.brokerRunnerPath !== "string" ||
+        !isAbsolute(meta.brokerRunnerPath) || !existsSync(meta.brokerRunnerPath)) return;
+    brokerRunnerPath = meta.brokerRunnerPath;
+  } catch { return; }
+  try {
+    const old = statSync(brokerStartLockFile);
+    if (Date.now() - old.mtimeMs < 10_000) return;
+    unlinkSync(brokerStartLockFile);
+  } catch { /* no launch in progress */ }
+  try {
+    const fd = openSync(brokerStartLockFile, "wx");
+    try { writeFileSync(fd, JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString() })); }
+    finally { closeSync(fd); }
+  } catch { return; }
+  try {
+    const child = spawn(process.execPath, [brokerRunnerPath, workspaceRoot], {
+      cwd: dirname(brokerRunnerPath), detached: true, windowsHide: true, stdio: "ignore",
+    });
+    child.once("error", () => { try { unlinkSync(brokerStartLockFile); } catch { /* retry on next hook */ } });
+    child.unref();
+  } catch {
+    try { unlinkSync(brokerStartLockFile); } catch { /* retry on next hook */ }
+  }
+}
+
+function signalBroker(endpoint) {
+  if (typeof endpoint?.pipe !== "string" || typeof endpoint?.token !== "string" ||
+      !/^[0-9a-f]{64}$/u.test(endpoint.token)) return Promise.resolve(false);
+  return new Promise((resolveSignal) => {
+    const socket = connect(endpoint.pipe);
+    let settled = false;
+    let response = "";
+    const finish = (ok) => {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      resolveSignal(ok);
+    };
+    socket.setTimeout(500, () => finish(false));
+    socket.once("error", () => finish(false));
+    socket.once("close", () => finish(false));
+    socket.once("connect", () => socket.write(`${JSON.stringify({ token: endpoint.token, method: "wake", args: [] })}\n`));
+    socket.on("data", (chunk) => {
+      response += chunk.toString("utf8");
+      const newline = response.indexOf("\n");
+      if (newline < 0) return;
+      try { finish(JSON.parse(response.slice(0, newline)).ok === true); }
+      catch { finish(false); }
+    });
+  });
+}
+
+async function acquireQueueLock() {
+  const started = Date.now();
+  const token = randomUUID();
+  for (;;) {
+    try {
+      const fd = openSync(queueLockFile, "wx");
+      try {
+        writeFileSync(fd, JSON.stringify({ pid: process.pid, token, createdAt: new Date().toISOString() }));
+      } finally {
+        closeSync(fd);
+      }
+      return token;
+    } catch (error) {
+      if (error?.code !== "EEXIST") throw error;
+      clearStaleQueueLock();
+      if (Date.now() - started >= QUEUE_LOCK_WAIT_MS) {
+        throw new Error("hook queue append lock remained busy");
+      }
+      await new Promise((resolveDelay) => setTimeout(resolveDelay, 15));
+    }
+  }
+}
+
+function clearStaleQueueLock() {
+  try {
+    const stat = statSync(queueLockFile);
+    const holder = JSON.parse(readFileSync(queueLockFile, "utf8"));
+    const ageMs = Date.now() - stat.mtimeMs;
+    if (ageMs < 2000) return;
+    // A live compactor may hold this lock for longer than the stale-age
+    // threshold. Never let a hook append to the soon-to-be-replaced file.
+    if (processAlive(holder.pid) && !pidWasReused(holder.pid, holder.createdAt)) return;
+    unlinkSync(queueLockFile);
+  } catch {
+    // A new holder may have replaced the lock; the next attempt will retry.
+  }
+}
+
+function processAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code === "EPERM";
+  }
+}
+
+function pidWasReused(pid, ownerCreatedAt) {
+  const createdAt = typeof ownerCreatedAt === "string" ? Date.parse(ownerCreatedAt) : NaN;
+  if (!Number.isSafeInteger(pid) || pid <= 0 || !Number.isFinite(createdAt)) return false;
+  try {
+    const output = process.platform === "win32"
+      ? execFileSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command",
+          `(Get-Process -Id ${pid} -ErrorAction Stop).StartTime.ToUniversalTime().ToString('o')`],
+        { encoding: "utf8", timeout: 3000, windowsHide: true, stdio: ["ignore", "pipe", "ignore"] })
+      : execFileSync("ps", ["-p", String(pid), "-o", "lstart="],
+        { encoding: "utf8", timeout: 3000, stdio: ["ignore", "pipe", "ignore"] });
+    const observedStart = Date.parse(output.trim());
+    return Number.isFinite(observedStart) && observedStart > createdAt + 1000;
+  } catch { return false; }
+}
+
+function releaseQueueLock(token) {
+  try {
+    const holder = JSON.parse(readFileSync(queueLockFile, "utf8"));
+    if (holder.token === token) unlinkSync(queueLockFile);
+  } catch {
+    // A stopped hook cannot keep the queue lock alive.
+  }
+}
+
+function sanitizePayload(raw, hookEventName) {
+  // Construct the queued event from known metadata. Recursively copying unknown
+  // fields risks persisting new Codex payload fields containing private text.
+  const payload = { hook_event_name: hookEventName, cwd: workspaceRoot };
+  if (raw.session_id === "forge-hook-probe" || raw.forgeHookProbe === true) payload.forgeHookProbe = true;
+  if (raw.forgeHookCanary === "FORGE_HOOK_SMOKE_CANARY") payload.forgeHookCanary = "FORGE_HOOK_SMOKE_CANARY";
+  for (const key of ["session_id", "turn_id", "tool_name", "tool_use_id", "permission_mode", "model", "source", "reason", "trigger"]) {
+    const value = raw[key];
+    if (typeof value === "string" && SAFE_ID.test(value)) payload[key] = value;
+  }
+
+  const toolInput = objectField(raw, "tool_input") ?? objectField(raw, "toolInput");
+  const toolResponse = objectField(raw, "tool_response") ?? objectField(raw, "toolResponse");
+  const command = stringField(toolInput, "command") ?? stringField(raw, "command");
+  if (command) {
+    payload.commandHash = hashStable(command);
+    payload.commandStored = false;
+    payload.commandSummary = summarizeCommand(command);
+    payload.commandKind = classifyCommand(stringField(raw, "tool_name") ?? stringField(raw, "toolName"), command);
+  } else if (typeof raw.commandHash === "string" && /^[a-f0-9]{64}$/u.test(raw.commandHash) && raw.forgeMcpHook === true) {
+    payload.commandHash = raw.commandHash;
+    payload.commandStored = false;
+    payload.commandSummary = raw.commandSummary === "[command redacted]" || /^forge (?:status|changed|check|verify|run|agent|fabric|generate|inspect|test)$/u.test(raw.commandSummary)
+      ? raw.commandSummary : "[command redacted]";
+  }
+
+  const exitCode = numberField(toolResponse, "exitCode") ?? numberField(toolResponse, "exit_code") ??
+    numberField(raw, "exitCode") ?? numberField(raw, "exit_code");
+  if (exitCode !== undefined) {
+    payload.exitCode = exitCode;
+    payload.resultStatus = exitCode === 0 ? "success" : "failed";
+  } else {
+    const status = stringField(toolResponse, "status") ?? stringField(raw, "status");
+    if (status && SAFE_ID.test(status)) {
+      payload.resultStatus = status;
+    }
+  }
+  if (toolResponse && raw.forgeMcpHook !== true) {
+    payload.responseHash = hashStable(JSON.stringify(toolResponse));
+    payload.responseStored = false;
+  }
+
+  return payload;
+}
+
+function objectField(value, key) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return undefined;
+  }
+  const child = value[key];
+  return child && typeof child === "object" && !Array.isArray(child) ? child : undefined;
+}
+
+function stringField(value, key) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return undefined;
+  }
+  const child = value[key];
+  return typeof child === "string" && child.length > 0 ? child : undefined;
+}
+
+function numberField(value, key) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return undefined;
+  }
+  const child = value[key];
+  return typeof child === "number" && Number.isFinite(child) ? child : undefined;
+}
+
+function summarizeCommand(command) {
+  const match = /^\s*(forge)\s+(status|changed|check|verify|run|agent|fabric|generate|inspect|test)\b/u.exec(command);
+  return match ? match.slice(1).filter(Boolean).join(" ") : "[command redacted]";
+}
+
+function classifyCommand(toolName, command) {
+  if (toolName === "apply_patch" || command.includes("*** Begin Patch")) {
+    return "patch";
+  }
+  if (/^\s*(?:node|npm|bun|pnpm|yarn|forge|git)\b/u.test(command)) {
+    return "shell";
+  }
+  return "unknown";
+}
+
+function hashStable(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+
+main()
+  .then(() => process.exit(0))
+  .catch(() => process.exit(1));

package/src/forge/agent-memory/sources/codex.ts

@@ -0,0 +1,161 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { releaseManifest } from "../../_generated/releaseManifest.ts";
+import type { AgentInstallResult } from "../types.ts";
+
+export const CODEX_EVENTS = [
+  "SessionStart",
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PermissionRequest",
+  "PostToolUse",
+  "SubagentStart",
+  "SubagentStop",
+  "PreCompact",
+  "PostCompact",
+  "Stop",
+];
+
+const CODEX_EVENT_STATUS: Record<string, string> = {
+  SessionStart: "Recording Codex session start",
+  UserPromptSubmit: "Recording Codex prompt metadata",
+  PreToolUse: "Recording Codex tool request",
+  PermissionRequest: "Recording Codex approval request",
+  PostToolUse: "Recording Codex tool result",
+  SubagentStart: "Recording Codex subagent start",
+  SubagentStop: "Recording Codex subagent stop",
+  PreCompact: "Recording Codex compaction start",
+  PostCompact: "Recording Codex compaction result",
+  Stop: "Recording Codex turn stop",
+};
+
+export const CODEX_HOOK_RUNNER_RELATIVE = ".forge/agent/codex-hook.mjs";
+export const CODEX_HOOK_META_RELATIVE = ".forge/agent/codex-hook.meta.json";
+export const CODEX_HOOK_QUEUE_RELATIVE = ".forge/agent/events.ndjson";
+export const CODEX_MCP_HOOK_TOOL = "agent_hook_ingest";
+
+const FAST_HOOK_EVENTS = new Set(["PreToolUse", "PostToolUse"]);
+
+function codexHookTimeout(event: string): number {
+  return FAST_HOOK_EVENTS.has(event) ? 2 : 3;
+}
+
+function codexHookCommand(event: string): string {
+  return `node ${CODEX_HOOK_RUNNER_RELATIVE} ${event}`;
+}
+
+function codexMcpHookPayload(event: string): Record<string, unknown> {
+  const payload: Record<string, unknown> = {
+    hook_event_name: "${hook_event_name}",
+    session_id: "${session_id}",
+    cwd: "${cwd}",
+    model: "${model}",
+  };
+  if (["PreToolUse", "PostToolUse", "PermissionRequest"].includes(event)) {
+    payload.turn_id = "${turn_id}";
+    payload.tool_name = "${tool_name}";
+    payload.tool_input = "${tool_input}";
+  }
+  if (["PreToolUse", "PostToolUse"].includes(event)) payload.tool_use_id = "${tool_use_id}";
+  if (event === "PostToolUse") {
+    // Large tool output must not fill the synchronous MCP hook request.
+    payload.tool_response = {
+      exitCode: "${tool_response.exitCode}",
+      exit_code: "${tool_response.exit_code}",
+      status: "${tool_response.status}",
+    };
+  }
+  if (["PreCompact", "PostCompact"].includes(event)) {
+    payload.turn_id = "${turn_id}";
+    payload.trigger = "${trigger}";
+  }
+  return payload;
+}
+
+function readCodexHookRunnerSource(): string {
+  const path = join(dirname(fileURLToPath(import.meta.url)), "codex-hook-runner.mjs");
+  return readFileSync(path, "utf8");
+}
+
+export function codexHookMetaContent(workspaceRoot: string, mcpServer?: string): string {
+  const meta = {
+    schema: "forge.codex-hook.meta.v1",
+    forgeVersion: releaseManifest.packageVersion,
+    installedAt: new Date().toISOString(),
+    commandResolvedFrom: "workspace",
+    workspaceRoot,
+    runner: CODEX_HOOK_RUNNER_RELATIVE,
+    queueFile: CODEX_HOOK_QUEUE_RELATIVE,
+    transport: mcpServer ? "mcp_tool" : "command",
+    ...(mcpServer ? { mcpServer } : {}),
+    brokerRunnerPath: fileURLToPath(new URL("../../delta/broker-runner.mjs", import.meta.url)),
+    stdinTimeoutMs: 750,
+    hookTimeouts: Object.fromEntries(CODEX_EVENTS.map((event) => [event, codexHookTimeout(event)])),
+  };
+  return `${JSON.stringify(meta, null, 2)}\n`;
+}
+
+export function codexInstallFiles(workspaceRoot?: string, mcpServer?: string): Array<{ path: string; content: string }> {
+  if (mcpServer && !/^[A-Za-z0-9_-]{1,64}$/u.test(mcpServer)) {
+    throw new Error("Codex MCP server name must be 1-64 letters, digits, underscores, or hyphens");
+  }
+  const hook = {
+    hooks: Object.fromEntries(CODEX_EVENTS.map((event) => [
+      event,
+      [
+        {
+          matcher: "*",
+          hooks: [
+            {
+              ...(mcpServer ? {
+                type: "mcp_tool",
+                server: mcpServer,
+                tool: CODEX_MCP_HOOK_TOOL,
+                input: {
+                  eventName: event,
+                  payload: codexMcpHookPayload(event),
+                },
+              } : { type: "command", command: codexHookCommand(event) }),
+              timeout: codexHookTimeout(event),
+              statusMessage: CODEX_EVENT_STATUS[event] ?? "Recording Codex event",
+            },
+          ],
+        },
+      ],
+    ])),
+  };
+  const files: Array<{ path: string; content: string }> = [
+    { path: ".codex/hooks.json", content: `${JSON.stringify(hook, null, 2)}\n` },
+    { path: CODEX_HOOK_RUNNER_RELATIVE, content: readCodexHookRunnerSource() },
+  ];
+  if (workspaceRoot) {
+    files.push({ path: CODEX_HOOK_META_RELATIVE, content: codexHookMetaContent(workspaceRoot, mcpServer) });
+  }
+  return files;
+}
+
+export function codexInstallResult(filesWritten: string[], filesPlanned: string[]): AgentInstallResult {
+  return {
+    ok: true,
+    target: "codex",
+    filesWritten,
+    filesPlanned,
+    privacy: privacyDefaults(),
+    warnings: [
+      "Codex memories and transcripts are not imported automatically.",
+      "Hooks enqueue to .forge/agent/events.ndjson; Agent Memory drains the queue automatically when read.",
+    ],
+    exitCode: 0,
+  };
+}
+
+export function privacyDefaults(): AgentInstallResult["privacy"] {
+  return {
+    rawPrompts: "off",
+    rawCompletions: "off",
+    rawToolArgs: "off",
+    transcriptImport: "off",
+    cloudSync: "off",
+  };
+}

package/src/forge/agent-memory/sources/cursor.ts

@@ -0,0 +1,35 @@
+import type { AgentInstallResult } from "../types.ts";
+import { privacyDefaults } from "./codex.ts";
+
+export function cursorInstallFiles(): Array<{ path: string; content: string }> {
+  return [
+    {
+      path: ".cursor/mcp.json",
+      content: `${JSON.stringify({
+        mcpServers: {
+          forgeos: {
+            type: "stdio",
+            command: "forge",
+            args: ["mcp", "serve"],
+          },
+        },
+      }, null, 2)}\n`,
+    },
+    {
+      path: ".cursor/rules/forgeos-agent-memory.mdc",
+      content: `---\ndescription: ForgeOS Agent Memory Bridge context and MCP workflow.\nalwaysApply: true\n---\n\n# ForgeOS Agent Memory\n\n- Before modifying runtime entries, call the ForgeOS MCP tool \`agent_context\` or run \`forge agent context --current --json\`.\n- Prefer ForgeOS MCP tools for inspect, timeline, check, verify, and agent context.\n- Do not edit \`src/forge/_generated/**\` directly.\n- Do not expose destructive or write tools without approval metadata.\n- After changes, run \`forge check --json\`; use \`forge verify --strict\` before handoff.\n- Do not ask ForgeOS to read Cursor internal chats, checkpoints, or editor databases.\n`,
+    },
+  ];
+}
+
+export function cursorInstallResult(filesWritten: string[], filesPlanned: string[]): AgentInstallResult {
+  return {
+    ok: true,
+    target: "cursor",
+    filesWritten,
+    filesPlanned,
+    privacy: privacyDefaults(),
+    warnings: ["Cursor internal chats, checkpoints, and databases are not read by ForgeOS."],
+    exitCode: 0,
+  };
+}