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

package/dist/host-hooks.mjs

@@ -0,0 +1,386 @@
+// src/host-hooks.mjs
+import { dirname as dirname3 } from "node:path";
+
+// ../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/host-profile.ts
+import { readGatewayClientProfile, validateGatewayClientProfile } from "@ours.network/sdk/client";
+var validateHostProfile = validateGatewayClientProfile;
+
+// ../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/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((resolve3) => {
+    release = resolve3;
+  });
+  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/host-hooks.mjs
+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();
+  }
+}
+export {
+  readHostHookState
+};

package/dist/monitor-mcp.mjs

@@ -3857,7 +3857,7 @@ var require_fast_uri = __commonJS({
       const resolvedHost = resolved.host;
       const resolvedHostIsIP = resolvedHost !== void 0 && resolvedHost !== "" && (isIPv4(resolvedHost) || normalizeIPv6(resolvedHost).isIPV6);
       canonicalizeHost(resolved, options || {}, resolvedSchemeHandler, resolvedHostIsIP);
-      const encodedASCIIHost = resolvedHost && resolvedHost.indexOf("%") !== -1 && !/\P{ASCII}/u.test(resolvedHost);
+      const encodedASCIIHost = resolvedHost && resolvedHost.indexOf("%") !== -1 && !new RegExp("\\P{ASCII}", "u").test(resolvedHost);
       if (resolved.error && !encodedASCIIHost) {
         throw new Error(resolved.error);
       }
@@ -21398,6 +21398,20 @@ var StdioServerTransport = class {
 // src/monitor-mcp.mjs
 import { spawn } from "node:child_process";
 import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+
+// ../core/src/host-profile.ts
+import { readGatewayClientProfile, validateGatewayClientProfile } from "@ours.network/sdk/client";
+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 { attachOursClient } from "@ours.network/sdk";
 
 // src/control-server.mjs
 import { createServer, createConnection } from "node:net";
@@ -21442,10 +21456,20 @@ function sendControlCommand(socketPath, capability, message, timeoutMs = 2e3) {
 
 // src/monitor-mcp.mjs
 var require2 = createRequire(import.meta.url);
+var networkWatchPath = fileURLToPath(new URL("../bin/network-watch.mjs", import.meta.url));
 var monitorToolNames = ["arm_monitor", "foreground_monitor", "disarm_monitor", "monitor_status"];
 var content = (text, isError = false) => ({ content: [{ type: "text", text }], ...isError ? { isError: true } : {} });
 var foregroundOffer = (identity) => `IMPORTANT: Before offering the fallback, tell the user exactly: "This standard \`codex\` session only supports a blocking foreground monitor. For background monitoring, restart the session with \`ours-codex\` instead; it adds the App Server integration needed for session-scoped background wake." A blocking foreground monitor is available here, but while it waits this Codex session cannot accept another prompt (press Escape to stop it). Ask the user: "Do you want to arm the foreground blocking monitor here?" Only after an explicit yes, call get_messages once to drain existing unread mail, then call foreground_monitor({ identity: ${JSON.stringify(identity)} }).`;
-function foregroundWatchProcess(identity) {
+function foregroundWatchProcess(identity, nativeSessionId, env = process.env) {
+  if (hostProfileFromEnv(env)) {
+    if (typeof nativeSessionId !== "string" || !nativeSessionId.trim()) {
+      throw new Error("Native session metadata is required for host-profile monitoring.");
+    }
+    return {
+      command: process.execPath,
+      args: [networkWatchPath, identity, nativeSessionId]
+    };
+  }
   try {
     const cliPath = require2.resolve("@ours.network/mcp/dist/cli.js");
     return { command: process.execPath, args: [cliPath, "watch", identity] };
@@ -21468,7 +21492,7 @@ async function handleMonitorCommand(command, args = {}, { env = process.env, sen
   if (command === "disarm") return { text: "Live ours monitor disarmed." };
   return { text: state.armedIdentity ? `Live ours monitor is armed for "${state.armedIdentity}"${state.turnActive ? "; a turn is active" : ""}.` : `Live ours monitor is available but not armed${state.boundIdentity ? `; current binding is "${state.boundIdentity}"` : "; bind an identity first"}.` };
 }
-function waitForForegroundMail(identity, {
+function waitForForegroundMail(identity, nativeSessionId, {
   env = process.env,
   spawnImpl = spawn,
   signal,
@@ -21476,15 +21500,16 @@ function waitForForegroundMail(identity, {
 } = {}) {
   if (typeof identity !== "string" || !identity.trim()) return Promise.reject(new Error("identity is required"));
   return new Promise((resolve, reject) => {
-    const invocation = commandFor(identity);
+    const invocation = commandFor(identity, nativeSessionId, env);
     const child = spawnImpl(invocation.command, invocation.args, {
-      env,
-      stdio: ["ignore", "pipe", "pipe"]
+      env: invocation.env ?? env,
+      stdio: [invocation.stdin ?? "ignore", "pipe", "pipe"]
     });
     let stdout = "";
     let stderr = "";
     let settled = false;
     const stop = () => {
+      if (invocation.stdin === "pipe") child.stdin?.end();
       if (!child.killed) child.kill("SIGTERM");
     };
     const finish = (fn, value) => {
@@ -21530,7 +21555,7 @@ function createMonitorMcpServer(deps = {}) {
     identity: external_exports.string().min(1).describe("The already-bound ours identity to monitor.")
   }, async ({ identity }, extra) => {
     try {
-      const event = await waitForForegroundMail(identity, { ...deps, signal: extra?.signal });
+      const event = await waitForForegroundMail(identity, extra?._meta?.threadId, { ...deps, signal: extra?.signal });
       return content(`Foreground ours monitor received a body-free arrival event: ${event}
 Call get_messages now. After handling the mail, call foreground_monitor again without asking if monitoring should remain armed.`);
     } catch (error2) {