@ours.network/codex 1.2.0-nightly.3 → 1.2.0-nightly.5

package/dist/host-hooks.mjs

@@ -0,0 +1,425 @@
+// 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 { resolve as resolve2 } from "node:path";
+var PROFILE_KEYS = ["endpoint", "expectedInstanceId", "credentialPath"];
+var LEGACY_SELECTION_KEYS = ["port", "stateDir", "apiToken", "apiVisibility"];
+var UUID2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+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 or HTTPS origin.");
+  }
+  if (typeof expectedInstanceId !== "string" || !UUID2.test(expectedInstanceId)) {
+    throw profileError("expectedInstanceId must be a lowercase UUID.");
+  }
+  if (typeof credentialPath !== "string" || credentialPath === "" || !credentialPath.startsWith("/") || resolve2(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 or HTTPS origin.");
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:" || url.username || url.password || url.pathname !== "/" || url.search || url.hash) {
+    throw profileError("endpoint must be an HTTP or HTTPS origin without credentials, path, query, or fragment.");
+  }
+  return { endpoint: url.origin, expectedInstanceId, credentialPath };
+}
+
+// ../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 resolve3 } 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 UUID3 = /^[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("/") || resolve3(hostRecordRoot) !== hostRecordRoot) {
+    throw new Error("Native session host record root must be a normalized absolute path.");
+  }
+  if (!UUID3.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" || !UUID3.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/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

@@ -21426,7 +21426,7 @@ function validateHostProfile(value) {
   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.");
+    throw profileError("endpoint must be a non-empty HTTP or HTTPS origin.");
   }
   if (typeof expectedInstanceId !== "string" || !UUID.test(expectedInstanceId)) {
     throw profileError("expectedInstanceId must be a lowercase UUID.");
@@ -21438,10 +21438,10 @@ function validateHostProfile(value) {
   try {
     url = new URL(endpoint);
   } catch {
-    throw profileError("endpoint must be an HTTP origin.");
+    throw profileError("endpoint must be an HTTP or HTTPS 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.");
+  if (url.protocol !== "http:" && url.protocol !== "https:" || url.username || url.password || url.pathname !== "/" || url.search || url.hash) {
+    throw profileError("endpoint must be an HTTP or HTTPS origin without credentials, path, query, or fragment.");
   }
   return { endpoint: url.origin, expectedInstanceId, credentialPath };
 }
@@ -21512,9 +21512,6 @@ 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";
 

package/dist/network-watch.mjs

@@ -28,7 +28,7 @@ function validateHostProfile(value) {
   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.");
+    throw profileError("endpoint must be a non-empty HTTP or HTTPS origin.");
   }
   if (typeof expectedInstanceId !== "string" || !UUID.test(expectedInstanceId)) {
     throw profileError("expectedInstanceId must be a lowercase UUID.");
@@ -40,10 +40,10 @@ function validateHostProfile(value) {
   try {
     url = new URL(endpoint);
   } catch {
-    throw profileError("endpoint must be an HTTP origin.");
+    throw profileError("endpoint must be an HTTP or HTTPS 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.");
+  if (url.protocol !== "http:" && url.protocol !== "https:" || url.username || url.password || url.pathname !== "/" || url.search || url.hash) {
+    throw profileError("endpoint must be an HTTP or HTTPS origin without credentials, path, query, or fragment.");
   }
   return { endpoint: url.origin, expectedInstanceId, credentialPath };
 }
@@ -114,9 +114,6 @@ 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";

package/dist/profile.mjs

@@ -30,7 +30,7 @@ function validateHostProfile(value) {
   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.");
+    throw profileError("endpoint must be a non-empty HTTP or HTTPS origin.");
   }
   if (typeof expectedInstanceId !== "string" || !UUID.test(expectedInstanceId)) {
     throw profileError("expectedInstanceId must be a lowercase UUID.");
@@ -42,10 +42,10 @@ function validateHostProfile(value) {
   try {
     url = new URL(endpoint);
   } catch {
-    throw profileError("endpoint must be an HTTP origin.");
+    throw profileError("endpoint must be an HTTP or HTTPS 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.");
+  if (url.protocol !== "http:" && url.protocol !== "https:" || url.username || url.password || url.pathname !== "/" || url.search || url.hash) {
+    throw profileError("endpoint must be an HTTP or HTTPS origin without credentials, path, query, or fragment.");
   }
   return { endpoint: url.origin, expectedInstanceId, credentialPath };
 }
@@ -113,9 +113,6 @@ function hostProfileSelectionFromEnv(env = process.env) {
   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";
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/codex",
-  "version": "1.2.0-nightly.3",
+  "version": "1.2.0-nightly.5",
   "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,9 +46,10 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@ours.network/sdk": "3.8.1-nightly.3",
+    "@ours.network/sdk": "3.8.1-nightly.9",
     "ws": "^8.21.0",
-    "zod": "^3.25.76"
+    "zod": "^3.25.76",
+    "@ours.network/mcp": "1.2.0-nightly.5"
   },
   "devDependencies": {
     "esbuild": "^0.24.2"

package/src/hooks/runner.mjs

@@ -6,7 +6,7 @@ import { dirname, join, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { sendControlCommand } from '../control-server.mjs';
 import { resolveDaemonProfile } from '../profile.mjs';
-import { createHostSessionFactory } from '../network-proxy.mjs';
+import { readHostHookState } from '../host-hooks.mjs';
 import { attachOursClient } from '@ours.network/sdk';
 import { hostProfileFromEnv } from '../../../core/src/host-client/index.ts';
 
@@ -60,16 +60,7 @@ function renderContext(unread, pin) {
   return lines.join('\n');
 }
 
-function applicationIdentitiesFromResource(value) {
-  const text = value?.contents?.find((item) => item?.uri === 'ours://application-identities')?.text;
-  const parsed = JSON.parse(text);
-  if (!Array.isArray(parsed?.identities) || parsed.identities.some((name) => typeof name !== 'string')) {
-    throw new Error('invalid application identity resource');
-  }
-  return new Set(parsed.identities);
-}
-
-export async function handleHook(payload, { env = process.env, fetch: fetchImpl = globalThis.fetch, send = sendControlCommand, findPin = defaultFindPin, profileResolver = resolveDaemonProfile, clientFactory = attachOursClient, networkSessionFactory = createHostSessionFactory } = {}) {
+export async function handleHook(payload, { env = process.env, fetch: fetchImpl = globalThis.fetch, send = sendControlCommand, findPin = defaultFindPin, profileResolver = resolveDaemonProfile, clientFactory = attachOursClient, readHostState = readHostHookState } = {}) {
   try {
     const event = payload?.hook_event_name;
     const socket = env.OURS_CODEX_CONTROL_SOCKET;
@@ -97,18 +88,12 @@ export async function handleHook(payload, { env = process.env, fetch: fetchImpl
       const nativeSessionId = payload.session_id;
       if (typeof nativeSessionId !== 'string' || !nativeSessionId) return { continue: true };
       const appPath = env.OURS_MCP_CONFIG || join(env.HOME || homedir(), '.ours-mcp', 'config.json');
-      let session;
-      try {
-        const factory = networkSessionFactory({ profile: hostProfile, hostRecordRoot: dirname(appPath), send: async () => {} });
-        session = await factory(nativeSessionId);
-        const resource = await session.request({ method: 'resources/read', params: { uri: 'ours://application-identities' } });
-        const visible = applicationIdentitiesFromResource(resource);
-        const unread = safeUnread(await session.fileClient.unread()).filter((entry) => visible.has(entry.name));
-        const pin = await findPin(payload.cwd || process.cwd());
-        const context = renderContext(unread, pin);
-        return context ? { continue: true, hookSpecificOutput: { hookEventName: event, additionalContext: context } } : { continue: true };
-      } finally { await session?.close(); }
+      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 };
     }
+
     // Standard Codex does not pass through ours-codex's resolved environment.
     // Resolve the same coherent SDK selection here so SessionStart and
     // UserPromptSubmit inspect the same daemon as the stdio proxy.

package/src/host-hooks.mjs

@@ -0,0 +1,25 @@
+import { dirname } from 'node:path';
+import { ApplicationIdentityStore } from '../../core/src/application-identities.ts';
+import { nativeClientForAtRoot } from '../../core/src/host-client/index.ts';
+
+/** Body-free hook metadata, scoped to this client's adopted identities. */
+export 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, dirname(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(); }
+}

package/bin/container-launch.mjs

@@ -1,40 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { isAbsolute, join } from 'node:path';
-import { spawnSync } from 'node:child_process';
-
-// An explicit container selection is authoritative: failures never fall back
-// to a host MCP or host application-identity configuration.
-export function containerInvocation(command, args = [], env = process.env) {
-  const explicitPath = (env.OURS_CONFIG ?? '').trim();
-  const path = explicitPath || join(homedir(), '.ours', 'config.json');
-  let profile;
-  try { profile = JSON.parse(readFileSync(path, 'utf8')); }
-  catch (error) {
-    if (!explicitPath && error.code === 'ENOENT') return null;
-    throw new Error(`cannot read OURS_CONFIG profile ${path}: ${error.message}`);
-  }
-  if (!profile || !Object.hasOwn(profile, 'composeFile')) return null;
-  if (typeof profile.composeFile !== 'string' || !isAbsolute(profile.composeFile)) throw new Error('composeFile must be an absolute path');
-  if (typeof profile.expectedInstanceId !== 'string' || !profile.expectedInstanceId.trim()) throw new Error('container profile requires expectedInstanceId');
-  if (profile.composeProject !== undefined && (typeof profile.composeProject !== 'string' || !profile.composeProject.trim())) throw new Error('composeProject must be a nonempty string');
-  const dockerArgs = ['compose', '-f', profile.composeFile];
-  if (profile.composeProject !== undefined) dockerArgs.push('-p', profile.composeProject);
-  dockerArgs.push('exec', '-T');
-  for (const name of ['CLAUDE_CODE_SESSION_ID', 'OURS_BIND_IDENTITY']) {
-    if (env[name] !== undefined) dockerArgs.push('-e', `${name}=${env[name]}`);
-  }
-  dockerArgs.push('daemon', 'node', '/opt/ours/node_modules/@ours.network/mcp/dist/container.js', profile.expectedInstanceId, command, ...args);
-  return { command: 'docker', args: dockerArgs, env: { ...env, OURS_DAEMON_ID: profile.expectedInstanceId } };
-}
-
-export function readContainerJson(command, env = process.env) {
-  const invocation = containerInvocation(command, [], env);
-  if (!invocation) return null;
-  const child = spawnSync(invocation.command, invocation.args, { env: invocation.env, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: 5000, maxBuffer: 1024 * 1024 });
-  if (child.error) throw child.error;
-  if (child.status !== 0) throw new Error(`ours container ${command} failed: ${child.stderr.trim() || child.status}`);
-  const value = JSON.parse(child.stdout);
-  if (value === null) throw new Error(`ours container ${command} returned null`);
-  return value;
-}