@ours.network/codex 1.1.1 → 1.2.0-nightly.10

package/dist/hooks-runner.mjs

@@ -0,0 +1,562 @@
+#!/usr/bin/env node
+
+// src/hooks/runner.mjs
+import { readFileSync } from "node:fs";
+import { readFile as readFile3 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname4, join as join3, resolve as resolve3 } from "node:path";
+import { pathToFileURL } from "node:url";
+
+// src/control-server.mjs
+import { createServer, createConnection } from "node:net";
+
+// src/control-protocol.mjs
+var MAX_LINE = 64 * 1024;
+function encodeControlResponse(value) {
+  return `${JSON.stringify(value)}
+`;
+}
+
+// src/control-server.mjs
+function sendControlCommand(socketPath, capability, message, timeoutMs = 2e3) {
+  return new Promise((resolve4, reject) => {
+    const socket = createConnection(socketPath);
+    let buffer = "";
+    const timer = setTimeout(() => {
+      socket.destroy();
+      reject(new Error("monitor control timed out"));
+    }, timeoutMs);
+    socket.setEncoding("utf8");
+    socket.on("connect", () => socket.write(encodeControlResponse({ ...message, capability })));
+    socket.on("data", (chunk) => {
+      buffer += chunk;
+    });
+    socket.on("error", (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+    socket.on("end", () => {
+      clearTimeout(timer);
+      try {
+        const response = JSON.parse(buffer);
+        if (!response.ok) reject(new Error(response.error || "monitor control failed"));
+        else resolve4(response);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+}
+
+// src/profile.mjs
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { attachOursClient as attachOursClient2 } from "@ours.network/sdk";
+
+// ../core/src/host-profile.ts
+import { readGatewayClientProfile, validateGatewayClientProfile } from "@ours.network/sdk/client";
+var validateHostProfile = validateGatewayClientProfile;
+function hostProfileSelectionFromEnv(env = process.env) {
+  const { configPath, ...profile } = readGatewayClientProfile(env);
+  return { profile, configPath };
+}
+function hostProfileFromEnv(env = process.env) {
+  return hostProfileSelectionFromEnv(env).profile;
+}
+
+// ../core/src/native-session.ts
+import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
+import { chmod as chmod2, mkdir as mkdir2, readFile as readFile2, rename as rename2, unlink as unlink2, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname2, join as join2, resolve as resolve2 } from "node:path";
+import { attachOursClient } from "@ours.network/sdk";
+
+// ../core/src/application-identities.ts
+import { randomUUID } from "node:crypto";
+import { chmod, mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, resolve } from "node:path";
+var APPLICATION_IDENTITIES_VERSION = 1;
+var APPLICATION_IDENTITIES_ENV = "OURS_MCP_CONFIG";
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+var emptyConfig = () => ({ version: 1, daemons: {}, instances: {} });
+function applicationIdentityConfigPath(env = process.env) {
+  const explicit = (env[APPLICATION_IDENTITIES_ENV] ?? "").trim();
+  return resolve(explicit || resolve(homedir(), ".ours-mcp", "config.json"));
+}
+function parseRows(raw, path, namespace, normalizeKey) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error(`Invalid ours-mcp application identity config at ${path}: "${namespace}s" must be an object.`);
+  }
+  const rows = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      throw new Error(`Invalid ours-mcp application identity config at ${path}: ${namespace} ${JSON.stringify(key)} must be an object.`);
+    }
+    const row = value;
+    if (!Array.isArray(row.identities) || row.identities.some((name) => typeof name !== "string" || name.length === 0)) {
+      throw new Error(`Invalid ours-mcp application identity config at ${path}: ${namespace} ${JSON.stringify(key)} has an invalid identity list.`);
+    }
+    rows[normalizeKey(key)] = { identities: [...new Set(row.identities)].sort() };
+  }
+  return rows;
+}
+function parseConfig(text, path) {
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch (error) {
+    throw new Error(`Invalid ours-mcp application identity config at ${path}: ${String(error)}`);
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`Invalid ours-mcp application identity config at ${path}: expected an object.`);
+  const record = value;
+  if (record.version !== APPLICATION_IDENTITIES_VERSION) {
+    throw new Error(`Unsupported ours-mcp application identity config version at ${path}: expected ${APPLICATION_IDENTITIES_VERSION}, found ${String(record.version)}.`);
+  }
+  const daemons = parseRows(record.daemons, path, "daemon", resolve);
+  const instances = record.instances === void 0 ? {} : parseRows(record.instances, path, "instance", (instanceId) => {
+    if (!UUID.test(instanceId)) throw new Error(`Invalid ours-mcp application identity config at ${path}: instance ${JSON.stringify(instanceId)} must be a lowercase UUID.`);
+    return instanceId;
+  });
+  return { version: 1, daemons, instances };
+}
+async function readConfig(path) {
+  try {
+    return parseConfig(await readFile(path, "utf8"), path);
+  } catch (error) {
+    if (error.code === "ENOENT") return emptyConfig();
+    throw error;
+  }
+}
+async function writeConfigAtomic(path, config) {
+  const parent = dirname(path);
+  await mkdir(parent, { recursive: true, mode: 448 });
+  const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(temporary, `${JSON.stringify(config, null, 2)}
+`, { mode: 384, flag: "wx" });
+    await rename(temporary, path);
+    await chmod(path, 384);
+  } catch (error) {
+    try {
+      await unlink(temporary);
+    } catch {
+    }
+    throw error;
+  }
+}
+var ApplicationIdentityStore = class {
+  stateDir;
+  instanceId;
+  path;
+  constructor(target, options = {}) {
+    if (typeof target === "string") {
+      this.stateDir = resolve(target);
+      this.instanceId = null;
+    } else {
+      if (!target || !UUID.test(target.instanceId)) throw new Error("Application identity instanceId must be a lowercase UUID.");
+      this.stateDir = null;
+      this.instanceId = target.instanceId;
+    }
+    this.path = resolve(options.path ?? applicationIdentityConfigPath(options.env));
+  }
+  rows(config) {
+    return this.instanceId === null ? config.daemons : config.instances;
+  }
+  key() {
+    return this.instanceId ?? this.stateDir;
+  }
+  async list() {
+    const config = await readConfig(this.path);
+    return [...this.rows(config)[this.key()]?.identities ?? []];
+  }
+  async has(name) {
+    return (await this.list()).includes(name);
+  }
+  async add(name) {
+    if (!name) throw new Error("Cannot add an empty identity name to ours-mcp.");
+    const config = await readConfig(this.path);
+    const rows = this.rows(config);
+    const key = this.key();
+    const identities = rows[key]?.identities ?? [];
+    if (identities.includes(name)) return;
+    rows[key] = { identities: [...identities, name].sort() };
+    await writeConfigAtomic(this.path, config);
+  }
+  async remove(name) {
+    const config = await readConfig(this.path);
+    const rows = this.rows(config);
+    const key = this.key();
+    const current = rows[key];
+    if (!current?.identities.includes(name)) return;
+    const identities = current.identities.filter((candidate) => candidate !== name);
+    if (identities.length === 0) delete rows[key];
+    else rows[key] = { identities };
+    await writeConfigAtomic(this.path, config);
+  }
+};
+
+// ../core/src/session-guard.ts
+import { createHash } from "node:crypto";
+import { openSync, closeSync, lstatSync, mkdirSync, chmodSync, constants } from "node:fs";
+import { join } from "node:path";
+import { createRequire } from "node:module";
+var BUSY_TIMEOUT_MS = 5e3;
+var DatabaseSync = null;
+var resolveAttempted = false;
+function resolveDatabase() {
+  if (DatabaseSync) return DatabaseSync;
+  if (resolveAttempted) throw new Error("No SQLite implementation available for native session guard");
+  resolveAttempted = true;
+  try {
+    const mod = createRequire(import.meta.url)("node:sqlite");
+    DatabaseSync = mod.DatabaseSync;
+    return DatabaseSync;
+  } catch {
+    try {
+      const mod = createRequire(import.meta.url)("better-sqlite3");
+      DatabaseSync = mod.default ?? mod;
+      return DatabaseSync;
+    } catch {
+      throw new Error("Native session guard requires node:sqlite (Node >=22.13) or better-sqlite3");
+    }
+  }
+}
+function ensureGuardFile(guardPath) {
+  try {
+    const fd = openSync(guardPath, constants.O_RDWR | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 384);
+    closeSync(fd);
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+  }
+  const stat = lstatSync(guardPath);
+  if (!stat.isFile() || stat.uid !== process.getuid() || (stat.mode & 63) !== 0 || stat.nlink !== 1) {
+    throw new Error("Native session guard file must be an owner-only regular file");
+  }
+}
+function acquireSessionGuard(recordPath) {
+  const uid = process.getuid();
+  const base = join(`/tmp/ours-${uid}`, "session-guards");
+  mkdirSync(base, { recursive: true, mode: 448 });
+  try {
+    chmodSync(base, 448);
+  } catch {
+  }
+  const hash = createHash("sha256").update(recordPath).digest("hex");
+  const guardPath = join(base, `${hash}.guard`);
+  ensureGuardFile(guardPath);
+  const before = lstatSync(guardPath);
+  const Database = resolveDatabase();
+  const db = new Database(guardPath);
+  try {
+    const after = lstatSync(guardPath);
+    if (before.dev !== after.dev || before.ino !== after.ino || before.mode !== after.mode || before.uid !== after.uid) {
+      throw new Error("Native session guard file changed during acquisition");
+    }
+    db.exec(`PRAGMA busy_timeout=${BUSY_TIMEOUT_MS}; BEGIN EXCLUSIVE`);
+    return () => {
+      try {
+        db.close();
+      } catch {
+      }
+    };
+  } catch (error) {
+    try {
+      db.close();
+    } catch {
+    }
+    throw error;
+  }
+}
+
+// ../core/src/native-session.ts
+var RECORD_VERSION = 1;
+var UUID2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+var clients = /* @__PURE__ */ new Map();
+var operations = /* @__PURE__ */ new Map();
+function selector(value) {
+  if (typeof value !== "string" || value.length === 0 || value.length > 4096 || value.trim() !== value || value.includes("\0")) {
+    throw new Error("Native session metadata is missing or invalid for this host-profile tool call.");
+  }
+  return value;
+}
+function nativeSessionRecordPath(hostRecordRoot, instanceId, nativeSessionId) {
+  if (!hostRecordRoot || !hostRecordRoot.startsWith("/") || resolve2(hostRecordRoot) !== hostRecordRoot) {
+    throw new Error("Native session host record root must be a normalized absolute path.");
+  }
+  if (!UUID2.test(instanceId)) throw new Error("Native session daemon instance must be a lowercase UUID.");
+  const hash = createHash2("sha256").update(selector(nativeSessionId), "utf8").digest("hex");
+  return join2(hostRecordRoot, "sessions", instanceId, `${hash}.json`);
+}
+function parseRecord(text, path) {
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch (error) {
+    throw new Error(`Invalid native session record at ${path}: ${String(error)}`);
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`Invalid native session record at ${path}: expected an object.`);
+  }
+  const record = value;
+  const keys = Object.keys(record).sort();
+  if (keys.join(",") !== "ownerInstanceId,state,version" || record.version !== RECORD_VERSION || typeof record.ownerInstanceId !== "string" || !UUID2.test(record.ownerInstanceId) || !["active", "pending", "ended"].includes(String(record.state))) {
+    throw new Error(`Invalid native session record at ${path}.`);
+  }
+  return record;
+}
+async function readRecord(path) {
+  try {
+    return parseRecord(await readFile2(path, "utf8"), path);
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+async function writeRecord(path, record) {
+  const parent = dirname2(path);
+  await mkdir2(parent, { recursive: true, mode: 448 });
+  await chmod2(parent, 448);
+  const temporary = `${path}.${process.pid}.${randomUUID2()}.tmp`;
+  try {
+    await writeFile2(temporary, `${JSON.stringify(record, null, 2)}
+`, { mode: 384, flag: "wx" });
+    await rename2(temporary, path);
+    await chmod2(path, 384);
+  } catch (error) {
+    try {
+      await unlink2(temporary);
+    } catch {
+    }
+    throw error;
+  }
+}
+async function serialized(key, operation) {
+  const predecessor = operations.get(key) ?? Promise.resolve();
+  let release;
+  const gate = new Promise((resolve4) => {
+    release = resolve4;
+  });
+  const tail = predecessor.catch(() => {
+  }).then(() => gate);
+  operations.set(key, tail);
+  await predecessor.catch(() => {
+  });
+  let releaseGuard;
+  try {
+    releaseGuard = acquireSessionGuard(key);
+    return await operation();
+  } finally {
+    try {
+      releaseGuard?.();
+    } finally {
+      release();
+      if (operations.get(key) === tail) operations.delete(key);
+    }
+  }
+}
+function attach(profile, ownerInstanceId) {
+  return attachOursClient({
+    endpoint: profile.endpoint,
+    expectedInstanceId: profile.expectedInstanceId,
+    credentialPath: profile.credentialPath,
+    sessionMode: "external",
+    leaseToken: ownerInstanceId,
+    env: {}
+  });
+}
+function cachedClient(path, profile, ownerInstanceId) {
+  const cached = clients.get(path);
+  if (cached?.ownerInstanceId === ownerInstanceId) return cached.promise;
+  if (cached) {
+    clients.delete(path);
+    void cached.promise.then((client) => client.close()).catch(() => {
+    });
+  }
+  const promise = attach(profile, ownerInstanceId);
+  const next = { ownerInstanceId, promise };
+  clients.set(path, next);
+  void promise.catch(() => {
+    if (clients.get(path) === next) clients.delete(path);
+  });
+  return promise;
+}
+async function releaseOwner(path, profile, ownerInstanceId) {
+  const cached = clients.get(path);
+  const client = cached?.ownerInstanceId === ownerInstanceId ? await cached.promise : await attach(profile, ownerInstanceId);
+  try {
+    await client.releaseLease();
+  } finally {
+    if (cached?.ownerInstanceId !== ownerInstanceId) await client.close();
+  }
+}
+async function finishPending(path, profile, ownerInstanceId) {
+  await releaseOwner(path, profile, ownerInstanceId);
+  const current = await readRecord(path);
+  if (current?.state === "pending" && current.ownerInstanceId === ownerInstanceId) {
+    await writeRecord(path, { version: RECORD_VERSION, ownerInstanceId, state: "ended" });
+  }
+  const cached = clients.get(path);
+  if (cached?.ownerInstanceId === ownerInstanceId) {
+    clients.delete(path);
+    void cached.promise.then((client) => client.close()).catch(() => {
+    });
+  }
+}
+async function nativeClientForAtRoot(profileValue, nativeSessionId, hostRecordRoot) {
+  const profile = validateHostProfile(profileValue);
+  const path = nativeSessionRecordPath(hostRecordRoot, profile.expectedInstanceId, nativeSessionId);
+  return serialized(path, async () => {
+    let record = await readRecord(path);
+    if (record?.state === "pending") {
+      await finishPending(path, profile, record.ownerInstanceId);
+      record = await readRecord(path);
+    }
+    if (record?.state === "active") return cachedClient(path, profile, record.ownerInstanceId);
+    const ownerInstanceId = randomUUID2();
+    await writeRecord(path, { version: RECORD_VERSION, ownerInstanceId, state: "active" });
+    return cachedClient(path, profile, ownerInstanceId);
+  });
+}
+
+// src/profile.mjs
+function validPort(value) {
+  const port = Number(value);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error(`ours: ${value} is not a valid TCP port`);
+  return port;
+}
+function parseOursArgs(argv = []) {
+  const codexArgs = [];
+  let port;
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--ours-port") {
+      if (argv[index + 1] == null) throw new Error("ours: --ours-port requires a value");
+      port = validPort(argv[++index]);
+    } else if (arg.startsWith("--ours-port=")) {
+      port = validPort(arg.slice("--ours-port=".length));
+    } else {
+      codexArgs.push(arg);
+    }
+  }
+  return { port, codexArgs };
+}
+async function resolveDaemonProfile({ argv = [], env = process.env, fetch: fetchImpl = globalThis.fetch, attach: attach2 = attachOursClient2 } = {}) {
+  const parsed = parseOursArgs(argv);
+  const hostSelection = hostProfileSelectionFromEnv(env);
+  const { profile: hostProfile, configPath } = hostSelection;
+  if (parsed.port != null) throw new Error("ours: --ours-port conflicts with host-profile mode");
+  const client = await attach2({ ...hostProfile, sessionMode: "external", leaseToken: randomUUID3(), env: {} });
+  let info;
+  try {
+    info = await client.version();
+    await client.identities();
+    await client.unread();
+  } finally {
+    await client.close();
+  }
+  return { profile: hostProfile, info, baseUrl: hostProfile.endpoint, configPath, codexArgs: parsed.codexArgs };
+}
+
+// src/host-hooks.mjs
+import { dirname as dirname3 } from "node:path";
+async function readHostHookState({ profile, nativeSessionId, applicationPath, clientFor = nativeClientForAtRoot }) {
+  const store = new ApplicationIdentityStore({ instanceId: profile.expectedInstanceId }, { path: applicationPath });
+  const identities = await store.list();
+  const visible = new Set(identities);
+  const client = await clientFor(profile, nativeSessionId, dirname3(applicationPath));
+  try {
+    const [unread, rows] = await Promise.all([client.unread(), client.listIdentities()]);
+    const entries = (Array.isArray(unread?.identities) ? unread.identities : []).flatMap((entry) => {
+      if (!entry || !visible.has(entry.name)) return [];
+      const count = Number.isSafeInteger(entry.count) ? entry.count : 0;
+      const files = Number.isSafeInteger(entry.files) ? entry.files : 0;
+      if (count <= 0 && files <= 0) return [];
+      const recent = (Array.isArray(entry.recent) ? entry.recent.slice(-5) : []).flatMap((message) => message && typeof message.from === "string" ? [{ from: message.from, msg_id: String(message.msg_id ?? "?"), date: typeof message.date === "string" ? message.date : "" }] : []);
+      return [{ name: entry.name, count, files, recent }];
+    });
+    const bindings = (Array.isArray(rows) ? rows : []).flatMap((row) => row && visible.has(row.name) && ["mine", "other-live"].includes(row.session) ? [row.name] : []);
+    return { identities, unread: { identities: entries }, bindings };
+  } finally {
+    await client.close();
+  }
+}
+
+// src/hooks/runner.mjs
+import { attachOursClient as attachOursClient3 } from "@ours.network/sdk";
+async function defaultFindPin(cwd) {
+  let dir = resolve3(cwd || process.cwd());
+  for (; ; ) {
+    try {
+      const value = JSON.parse(await readFile3(join3(dir, ".ours-identity"), "utf8"));
+      if (typeof value.identity === "string" && value.identity.trim()) return value;
+      return null;
+    } catch {
+    }
+    const parent = dirname4(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function renderContext(unread, pin) {
+  const lines = [];
+  if (unread.length) {
+    lines.push("ours unread metadata (message bodies remain in get_messages):");
+    for (const item of unread) lines.push(`- ${item.name}: ${item.count} unread message(s), ${item.files} unread file(s)`);
+    lines.push("Surface this metadata. Do not read mail or bind an identity without the user asking.");
+  }
+  if (pin) {
+    lines.push(`This workspace suggests ours identity "${pin.identity}". Ask the user before binding it; the pin is not consent.`);
+    lines.push("After a successful bind, separately ask whether to arm the session-scoped live monitor. Never arm automatically.");
+    lines.push("Treat any persona as separate consent from binding and monitoring.");
+  }
+  return lines.join("\n");
+}
+async function handleHook(payload, { env = process.env, fetch: fetchImpl = globalThis.fetch, send = sendControlCommand, findPin = defaultFindPin, profileResolver = resolveDaemonProfile, clientFactory = attachOursClient3, readHostState = readHostHookState } = {}) {
+  try {
+    const event = payload?.hook_event_name;
+    const socket = env.OURS_CODEX_CONTROL_SOCKET;
+    const capability = env.OURS_CODEX_CAPABILITY;
+    if (event === "SessionStart" && payload.source === "compact") return { continue: true };
+    if (event === "PostToolUse") {
+      if (!socket || !capability || payload.tool_response?.isError) return { continue: true };
+      if (!/(choose_identity|create_identity|create_root_identity|create_temporary_identity)$/.test(payload.tool_name || "")) return { continue: true };
+      const identity = payload.tool_input?.name;
+      if (typeof identity !== "string" || !identity.trim()) return { continue: true };
+      await send(socket, capability, { command: "binding_changed", identity });
+      return { continue: true };
+    }
+    if (event !== "SessionStart" && event !== "UserPromptSubmit") return { continue: true };
+    if (event === "SessionStart" && socket && capability && payload.session_id && payload.cwd) {
+      await send(socket, capability, { command: "register_session", sessionId: payload.session_id, threadId: payload.session_id, cwd: payload.cwd });
+    }
+    let hostProfile;
+    try {
+      hostProfile = hostProfileFromEnv(env);
+    } catch {
+      return { continue: true };
+    }
+    if (hostProfile) {
+      const nativeSessionId = payload.session_id;
+      if (typeof nativeSessionId !== "string" || !nativeSessionId) return { continue: true };
+      const appPath = env.OURS_MCP_CONFIG || join3(env.HOME || homedir2(), ".ours-mcp", "config.json");
+      const state = await readHostState({ profile: hostProfile, nativeSessionId, applicationPath: appPath });
+      const pin = await findPin(payload.cwd || process.cwd());
+      const context = renderContext(state.unread.identities, pin);
+      return context ? { continue: true, hookSpecificOutput: { hookEventName: event, additionalContext: context } } : { continue: true };
+    }
+    return { continue: true };
+  } catch {
+    return { continue: true };
+  }
+}
+async function main() {
+  let payload = {};
+  try {
+    payload = JSON.parse(readFileSync(0, "utf8"));
+  } catch {
+  }
+  process.stdout.write(JSON.stringify(await handleHook(payload)));
+}
+if (process.argv[1] && pathToFileURL(process.argv[1]).href === import.meta.url) main();
+export {
+  handleHook
+};