@ours.network/codex 1.1.0 → 1.2.0-nightly.1

package/dist/monitor-mcp.mjs

@@ -2979,7 +2979,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve.call(this, root, ref);
+      let _sch = resolve2.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref];
         const { schemaId } = this.opts;
@@ -3006,7 +3006,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve(root, ref) {
+    function resolve2(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -3831,7 +3831,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve(baseURI, relativeURI, options) {
+    function resolve2(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const {
         parsed: baseParsed,
@@ -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);
       }
@@ -4193,7 +4193,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve,
+      resolve: resolve2,
       resolveComponent,
       equal,
       serialize,
@@ -19274,7 +19274,7 @@ var Protocol = class {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+        await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error2) {
@@ -19291,7 +19291,7 @@ var Protocol = class {
    */
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const earlyReject = (error2) => {
         reject(error2);
       };
@@ -19369,7 +19369,7 @@ var Protocol = class {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve(parseResult.data);
+            resolve2(parseResult.data);
           }
         } catch (error2) {
           reject(error2);
@@ -19630,12 +19630,12 @@ var Protocol = class {
       }
     } catch {
     }
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve, interval);
+      const timeoutId = setTimeout(resolve2, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -20735,7 +20735,7 @@ var McpServer = class {
     let task = createTaskResult.task;
     const pollInterval = task.pollInterval ?? 5e3;
     while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
-      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+      await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
       const updatedTask = await extra.taskStore.getTask(taskId);
       if (!updatedTask) {
         throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
@@ -21384,12 +21384,12 @@ var StdioServerTransport = class {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const json = serializeMessage(message);
       if (this._stdout.write(json)) {
-        resolve();
+        resolve2();
       } else {
-        this._stdout.once("drain", resolve);
+        this._stdout.once("drain", resolve2);
       }
     });
   }
@@ -21398,6 +21398,125 @@ 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 { existsSync, lstatSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+var PROFILE_KEYS = ["endpoint", "expectedInstanceId", "credentialPath"];
+var LEGACY_SELECTION_KEYS = ["port", "stateDir", "apiToken", "apiVisibility"];
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+var CONFLICTING_ENV = ["OURS_API_TOKEN", "OURS_PORT", "OURS_STATE_DIR", "OURS_DAEMON_ID"];
+function profileError(reason) {
+  return new Error(`Invalid external host profile: ${reason}`);
+}
+function validateHostProfile(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw profileError("expected a complete host profile object.");
+  }
+  const record2 = value;
+  const present = PROFILE_KEYS.filter((key) => Object.hasOwn(record2, key));
+  if (present.length !== PROFILE_KEYS.length) {
+    throw profileError("expected a complete host profile tuple: endpoint, expectedInstanceId, credentialPath.");
+  }
+  const mixed = LEGACY_SELECTION_KEYS.filter((key) => Object.hasOwn(record2, key));
+  if (mixed.length) throw profileError(`legacy selection keys cannot be mixed with a host profile (${mixed.join(", ")}).`);
+  const endpoint = record2.endpoint;
+  const expectedInstanceId = record2.expectedInstanceId;
+  const credentialPath = record2.credentialPath;
+  if (typeof endpoint !== "string" || endpoint.trim() !== endpoint || endpoint === "") {
+    throw profileError("endpoint must be a non-empty HTTP origin.");
+  }
+  if (typeof expectedInstanceId !== "string" || !UUID.test(expectedInstanceId)) {
+    throw profileError("expectedInstanceId must be a lowercase UUID.");
+  }
+  if (typeof credentialPath !== "string" || credentialPath === "" || !credentialPath.startsWith("/") || resolve(credentialPath) !== credentialPath) {
+    throw profileError("credentialPath must be a normalized absolute path.");
+  }
+  let url;
+  try {
+    url = new URL(endpoint);
+  } catch {
+    throw profileError("endpoint must be an HTTP origin.");
+  }
+  if (url.protocol !== "http:" || url.username || url.password || url.pathname !== "/" || url.search || url.hash) {
+    throw profileError("endpoint must be an HTTP origin without credentials, path, query, or fragment.");
+  }
+  return { endpoint: url.origin, expectedInstanceId, credentialPath };
+}
+function readProfileObject(configPath) {
+  let text;
+  try {
+    text = readFileSync(configPath, "utf8");
+  } catch {
+    throw new Error(`Cannot read host profile ${JSON.stringify(configPath)}.`);
+  }
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    throw profileError(`config ${JSON.stringify(configPath)} is not valid JSON.`);
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw profileError(`config ${JSON.stringify(configPath)} must be an object.`);
+  return value;
+}
+function assertPrivateRegularFile(configPath) {
+  let stat;
+  try {
+    stat = lstatSync(configPath);
+  } catch {
+    throw new Error(`Cannot read host profile ${JSON.stringify(configPath)}.`);
+  }
+  if (!stat.isFile()) throw profileError(`config ${JSON.stringify(configPath)} must be a regular file.`);
+  const currentUid = process.getuid?.();
+  if (currentUid === void 0 || stat.uid !== currentUid) throw profileError(`config ${JSON.stringify(configPath)} must be owned by the current user.`);
+  if ((stat.mode & 63) !== 0) throw profileError(`config ${JSON.stringify(configPath)} must have private permissions.`);
+}
+function readHostProfile(configPath) {
+  const record2 = readProfileObject(configPath);
+  const found = PROFILE_KEYS.filter((key) => Object.hasOwn(record2, key));
+  if (found.length === 0) return null;
+  assertPrivateRegularFile(configPath);
+  return validateHostProfile(record2);
+}
+function nonempty(env, key) {
+  return (env[key] ?? "").trim() !== "";
+}
+function hostProfileSelectionFromEnv(env = process.env) {
+  const explicit = (env.OURS_CONFIG ?? "").trim();
+  const managedPath = resolve(env.HOME || homedir(), ".ours-client", "profile.json");
+  let configPath = explicit;
+  if (!configPath) {
+    try {
+      lstatSync(managedPath);
+      configPath = managedPath;
+    } catch (error2) {
+      if (error2.code !== "ENOENT") {
+        throw new Error(`Cannot read host profile ${JSON.stringify(managedPath)}.`);
+      }
+      configPath = resolve(homedir(), ".ours", "config.json");
+      if (!existsSync(configPath)) return null;
+    }
+  }
+  const profile = readHostProfile(configPath);
+  if (profile === null) {
+    if (resolve(configPath) === managedPath) throw profileError("managed client config must contain a complete host profile tuple.");
+    return null;
+  }
+  const conflicting = CONFLICTING_ENV.filter((key) => nonempty(env, key));
+  if (conflicting.length) throw profileError(`${conflicting.join(", ")} conflicts with host-profile mode.`);
+  return { profile, configPath };
+}
+function hostProfileFromEnv(env = process.env) {
+  return hostProfileSelectionFromEnv(env)?.profile ?? null;
+}
+
+// ../core/src/host-client/files.ts
+import { buildIdentityFile, writeIdentityFile } from "@ours.network/sdk/connector";
+
+// ../core/src/native-session.ts
+import { attachOursClient } from "@ours.network/sdk";
 
 // src/control-server.mjs
 import { createServer, createConnection } from "node:net";
@@ -21411,7 +21530,7 @@ function encodeControlResponse(value) {
 
 // src/control-server.mjs
 function sendControlCommand(socketPath, capability, message, timeoutMs = 2e3) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const socket = createConnection(socketPath);
     let buffer = "";
     const timer = setTimeout(() => {
@@ -21432,7 +21551,7 @@ function sendControlCommand(socketPath, capability, message, timeoutMs = 2e3) {
       try {
         const response = JSON.parse(buffer);
         if (!response.ok) reject(new Error(response.error || "monitor control failed"));
-        else resolve(response);
+        else resolve2(response);
       } catch (error2) {
         reject(error2);
       }
@@ -21442,10 +21561,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,23 +21597,24 @@ 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,
   commandFor = foregroundWatchProcess
 } = {}) {
   if (typeof identity !== "string" || !identity.trim()) return Promise.reject(new Error("identity is required"));
-  return new Promise((resolve, reject) => {
-    const invocation = commandFor(identity);
+  return new Promise((resolve2, reject) => {
+    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) => {
@@ -21506,7 +21636,7 @@ function waitForForegroundMail(identity, {
       const newline = stdout.indexOf("\n");
       if (newline === -1) return;
       const event = stdout.slice(0, newline).trim();
-      if (event) finish(resolve, event);
+      if (event) finish(resolve2, event);
     });
     child.once("exit", (code, childSignal) => {
       if (settled) return;
@@ -21530,7 +21660,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) {