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

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';
 
@@ -35,16 +35,6 @@ const safeUnread = (value) => (Array.isArray(value?.identities) ? value.identiti
   return [{ name: entry.name, count, files, recent }];
 });
 
-async function applicationIdentityNames(env, selection) {
-  const path = env.OURS_MCP_CONFIG || join(homedir(), '.ours-mcp', 'config.json');
-  const value = JSON.parse(await readFile(path, 'utf8'));
-  if (value?.version !== 1 || !value.daemons || typeof value.daemons !== 'object') return new Set();
-  const identities = selection.instanceId
-    ? value.instances?.[selection.instanceId]?.identities
-    : value.daemons[resolve(selection.stateDir)]?.identities;
-  return new Set(Array.isArray(identities) ? identities.filter((name) => typeof name === 'string') : []);
-}
-
 function renderContext(unread, pin) {
   const lines = [];
   if (unread.length) {
@@ -60,16 +50,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;
@@ -87,9 +68,6 @@ export async function handleHook(payload, { env = process.env, fetch: fetchImpl
     if (event === 'SessionStart' && socket && capability && payload.session_id && payload.cwd) {
       await send(socket, capability, { command: 'register_session', sessionId: payload.session_id, threadId: payload.session_id, cwd: payload.cwd });
     }
-    let port = env.OURS_PORT || '3050';
-    let selectedStateDir = resolve(env.OURS_STATE_DIR || join(homedir(), '.ours'));
-    let selectedToken = env.OURS_API_TOKEN || '';
     let hostProfile;
     try { hostProfile = hostProfileFromEnv(env); }
     catch { return { continue: true }; }
@@ -97,53 +75,13 @@ 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.
-    try {
-      const selected = await profileResolver({ env, fetch: fetchImpl });
-      if (selected.profile) {
-        let client;
-        try {
-          client = await clientFactory({ ...selected.profile, sessionMode: 'external', leaseToken: `codex-hook-${process.pid}`, env: {} });
-          const visible = await applicationIdentityNames(env, { instanceId: selected.profile.expectedInstanceId });
-          const unread = safeUnread(await client.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 client?.close(); }
-      }
-      port = String(selected.port);
-      selectedToken = selected.token || '';
-      selectedStateDir = resolve(selected.stateDir);
-    } catch {
-      /* proxy/launcher owns legacy diagnostics; hooks emit a benign no-op */
-    }
-    const headers = selectedToken ? { 'x-ours-api-token': selectedToken } : {};
-    let unread = [];
-    try {
-      const response = await fetchImpl(`http://127.0.0.1:${port}/unread`, { headers, signal: AbortSignal.timeout(1500) });
-      if (response.ok) {
-        const visible = await applicationIdentityNames(env, { stateDir: selectedStateDir });
-        unread = safeUnread(await response.json()).filter((entry) => visible.has(entry.name));
-      }
-    } catch { /* daemon diagnostics belong to launcher/proxy */ }
-    const pin = await findPin(payload.cwd || process.cwd());
-    const context = renderContext(unread, pin);
-    if (!context) return { continue: true };
-    return { continue: true, hookSpecificOutput: { hookEventName: event, additionalContext: context } };
+
+    return { continue: true };
   } catch { return { continue: true }; }
 }
 

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/src/launcher.mjs

@@ -31,15 +31,7 @@ export function launcherEnvironment(env, profile, control) {
     // call. The bin shim preserves an explicit value instead of replacing it
     // with whichever child happened to spawn it.
   };
-  if (profile.profile) {
-    for (const key of ['OURS_PORT', 'OURS_API_TOKEN', 'OURS_STATE_DIR', 'OURS_CLIENT_PID', 'OURS_AUTOSTART', 'OURS_DAEMON_ID']) delete out[key];
-  } else {
-    out.OURS_PORT = String(profile.port);
-    out.OURS_AUTOSTART = '0';
-    out.OURS_CLIENT_PID = String(process.pid);
-    if (profile.token) out.OURS_API_TOKEN = profile.token;
-    else delete out.OURS_API_TOKEN;
-  }
+  for (const key of ['OURS_PORT', 'OURS_API_TOKEN', 'OURS_STATE_DIR', 'OURS_CLIENT_PID', 'OURS_AUTOSTART', 'OURS_DAEMON_ID', 'OURS_DAEMON_URL', 'OURS_DAEMON_CREDENTIAL_PATH']) delete out[key];
   return out;
 }
 

package/src/profile.mjs

@@ -1,8 +1,6 @@
-import { join } from 'node:path';
-import { homedir } from 'node:os';
 import { randomUUID } from 'node:crypto';
 
-import { assertDaemonStateDir, attachOursClient, resolveDaemonConfig } from '@ours.network/sdk';
+import { attachOursClient } from '@ours.network/sdk';
 import { hostProfileSelectionFromEnv } from '../../core/src/host-client/index.ts';
 
 function validPort(value) {
@@ -31,7 +29,6 @@ export function parseOursArgs(argv = []) {
 export async function resolveDaemonProfile({ argv = [], env = process.env, fetch: fetchImpl = globalThis.fetch, attach = attachOursClient } = {}) {
   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: {} });
@@ -42,40 +39,4 @@ export async function resolveDaemonProfile({ argv = [], env = process.env, fetch
       await client.unread();
     } finally { await client.close(); }
     return { profile: hostProfile, info, baseUrl: hostProfile.endpoint, configPath, codexArgs: parsed.codexArgs };
-  }
-  const selection = resolveDaemonConfig({
-    ...(parsed.port == null ? {} : { port: parsed.port }),
-    env,
-    homeDir: env.HOME || homedir(),
-  });
-  await assertDaemonStateDir(selection, { fetch: fetchImpl, timeoutMs: 2000 });
-
-  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(2000) });
-  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(2000) });
-    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,
-  };
 }

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;
-}