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

package/dist/network-watch.mjs

@@ -0,0 +1,391 @@
+// src/network-watch.mjs
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname2, join as join3 } from "node:path";
+
+// ../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 record = value;
+  const present = PROFILE_KEYS.filter((key) => Object.hasOwn(record, 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(record, key));
+  if (mixed.length) throw profileError(`legacy selection keys cannot be mixed with a host profile (${mixed.join(", ")}).`);
+  const endpoint = record.endpoint;
+  const expectedInstanceId = record.expectedInstanceId;
+  const credentialPath = record.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 record = readProfileObject(configPath);
+  const found = PROFILE_KEYS.filter((key) => Object.hasOwn(record, key));
+  if (found.length === 0) return null;
+  assertPrivateRegularFile(configPath);
+  return validateHostProfile(record);
+}
+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 (error) {
+      if (error.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 { createHash as createHash2, randomUUID } from "node:crypto";
+import { chmod, mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { dirname, 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 as lstatSync2, 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 = lstatSync2(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 = lstatSync2(guardPath);
+  const Database = resolveDatabase();
+  const db = new Database(guardPath);
+  try {
+    const after = lstatSync2(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 readFile(path, "utf8"), path);
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+async function writeRecord(path, record) {
+  const parent = dirname(path);
+  await mkdir(parent, { recursive: true, mode: 448 });
+  await chmod(parent, 448);
+  const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(temporary, `${JSON.stringify(record, null, 2)}
+`, { mode: 384, flag: "wx" });
+    await rename(temporary, path);
+    await chmod(path, 384);
+  } catch (error) {
+    try {
+      await unlink(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 = randomUUID();
+    await writeRecord(path, { version: RECORD_VERSION, ownerInstanceId, state: "active" });
+    return cachedClient(path, profile, ownerInstanceId);
+  });
+}
+
+// src/network-watch.mjs
+async function runNetworkWatch({
+  identity,
+  nativeSessionId,
+  env = process.env,
+  profile: profileValue,
+  hostRecordRoot: hostRecordRootValue,
+  clientFor = nativeClientForAtRoot,
+  write = (value) => process.stdout.write(value),
+  installSignalHandlers = true
+} = {}) {
+  if (typeof identity !== "string" || !identity.trim()) throw new Error("identity is required");
+  if (typeof nativeSessionId !== "string" || !nativeSessionId.trim()) throw new Error("native session id is required");
+  const profile = profileValue ?? hostProfileFromEnv(env);
+  if (!profile) throw new Error("A selected host network profile is required.");
+  const appPath = env.OURS_MCP_CONFIG || join3(env.HOME || homedir2(), ".ours-mcp", "config.json");
+  const hostRecordRoot = hostRecordRootValue ?? dirname2(appPath);
+  const controller = new AbortController();
+  const stop = () => controller.abort();
+  if (installSignalHandlers) {
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+  }
+  let client;
+  try {
+    client = await clientFor(profile, nativeSessionId, hostRecordRoot);
+    for await (const event of client.watchNotifications(identity, { kinds: ["inbound"], signal: controller.signal })) {
+      const summary = event?.event === "file_received" ? `[${identity}] new file ${event.filename ?? "?"} from ${event.from ?? "?"}` : `[${identity}] new message from ${event?.from ?? "?"}`;
+      write(`${summary}
+`);
+      return;
+    }
+  } finally {
+    if (installSignalHandlers) {
+      process.off("SIGINT", stop);
+      process.off("SIGTERM", stop);
+    }
+    await client?.close();
+  }
+}
+export {
+  runNetworkWatch
+};

package/dist/profile.mjs

@@ -0,0 +1,198 @@
+// src/profile.mjs
+import { join } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { randomUUID } from "node:crypto";
+import { assertDaemonStateDir, attachOursClient as attachOursClient2, resolveDaemonConfig } from "@ours.network/sdk";
+
+// ../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 record = value;
+  const present = PROFILE_KEYS.filter((key) => Object.hasOwn(record, 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(record, key));
+  if (mixed.length) throw profileError(`legacy selection keys cannot be mixed with a host profile (${mixed.join(", ")}).`);
+  const endpoint = record.endpoint;
+  const expectedInstanceId = record.expectedInstanceId;
+  const credentialPath = record.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 record = readProfileObject(configPath);
+  const found = PROFILE_KEYS.filter((key) => Object.hasOwn(record, key));
+  if (found.length === 0) return null;
+  assertPrivateRegularFile(configPath);
+  return validateHostProfile(record);
+}
+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 (error) {
+      if (error.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 };
+}
+
+// ../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/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 = attachOursClient2 } = {}) {
+  const parsed = parseOursArgs(argv);
+  const hostSelection = hostProfileSelectionFromEnv(env);
+  if (hostSelection !== null) {
+    const { profile: hostProfile, configPath } = hostSelection;
+    if (parsed.port != null) throw new Error("ours: --ours-port conflicts with host-profile mode");
+    const client = await attach({ ...hostProfile, sessionMode: "external", leaseToken: randomUUID(), env: {} });
+    let info2;
+    try {
+      info2 = await client.version();
+      await client.identities();
+      await client.unread();
+    } finally {
+      await client.close();
+    }
+    return { profile: hostProfile, info: info2, baseUrl: hostProfile.endpoint, configPath, codexArgs: parsed.codexArgs };
+  }
+  const selection = resolveDaemonConfig({
+    ...parsed.port == null ? {} : { port: parsed.port },
+    env,
+    homeDir: env.HOME || homedir2()
+  });
+  await assertDaemonStateDir(selection, { fetch: fetchImpl, timeoutMs: 2e3 });
+  const baseUrl = selection.baseUrl.value;
+  const token = selection.token?.value ?? null;
+  const headers = token ? { "x-ours-api-token": token } : {};
+  const response = await fetchImpl(`${baseUrl}/info`, { signal: AbortSignal.timeout(2e3) });
+  if (!response.ok) throw new Error(`ours daemon at ${baseUrl} returned HTTP ${response.status}`);
+  const info = await response.json();
+  if (info?.name !== "ours" || !Number.isInteger(info?.protocol) || info.protocol < 1) {
+    throw new Error(`incompatible service at ${baseUrl}; expected an ours daemon with notification protocol 1`);
+  }
+  for (const path of ["/identities", "/unread"]) {
+    const capability = await fetchImpl(`${baseUrl}${path}`, { headers, signal: AbortSignal.timeout(2e3) });
+    if (capability.status === 401 || capability.status === 403) {
+      throw new Error(`ours daemon authentication failed at ${baseUrl}; supply the matching coherent selection`);
+    }
+    if (!capability.ok) throw new Error(`selected daemon lacks ${path} (HTTP ${capability.status})`);
+  }
+  return {
+    port: selection.port.value,
+    stateDir: selection.expectStateDir,
+    token,
+    visibility: "owner",
+    source: selection.baseUrl.source,
+    info,
+    baseUrl,
+    configPath: selection.configPath?.value ?? join(selection.expectStateDir, "config.json"),
+    codexArgs: parsed.codexArgs
+  };
+}
+export {
+  parseOursArgs,
+  resolveDaemonProfile
+};

package/hooks/hooks.json

@@ -6,7 +6,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"${PLUGIN_ROOT}/src/hooks/runner.mjs\"",
+            "command": "node \"${PLUGIN_ROOT}/dist/hooks-runner.mjs\"",
             "timeout": 5,
             "statusMessage": "Checking ours mail metadata"
           }
@@ -18,7 +18,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"${PLUGIN_ROOT}/src/hooks/runner.mjs\"",
+            "command": "node \"${PLUGIN_ROOT}/dist/hooks-runner.mjs\"",
             "timeout": 3
           }
         ]
@@ -30,7 +30,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"${PLUGIN_ROOT}/src/hooks/runner.mjs\"",
+            "command": "node \"${PLUGIN_ROOT}/dist/hooks-runner.mjs\"",
             "timeout": 3
           }
         ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/codex",
-  "version": "1.1.1",
+  "version": "1.2.0-nightly.2",
   "description": "Native Codex plugin for secure ours.network messaging and explicitly armed, session-scoped live mail wake.",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",
@@ -46,8 +46,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@ours.network/mcp": "1.1.1",
-    "@ours.network/sdk": "3.7.0",
+    "@ours.network/sdk": "3.8.1-nightly.3",
     "ws": "^8.21.0",
     "zod": "^3.25.76"
   },
@@ -58,7 +57,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "esbuild src/monitor-mcp.mjs --bundle --platform=node --format=esm --external:@ours.network/mcp --outfile=dist/monitor-mcp.mjs",
+    "build": "node build.mjs",
     "prepack": "npm run build",
     "install-plugin": "bash install.sh",
     "test": "node --test"

package/skills/ours/SKILL.md

@@ -448,6 +448,7 @@ feature and still works; it is described above.
   watcher for exactly one TUI session. The launcher observes that session's thread
   directly; monitor MCP tools carry explicit arm/disarm consent, while trusted hooks add
   defensive identity-state synchronization. Standard `codex` falls back, after separate
-  consent, to a foreground `ours-mcp watch` call that returns on the next body-free event.
+  consent, to a package-local authenticated network watch that returns on the next
+  body-free event.
   Authenticated daemon notification endpoints remain body-free. Message text is returned
   only by the explicit unread-drain and history tools.