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

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

@@ -6,7 +6,7 @@ import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { randomBytes } from 'node:crypto';
 import { once } from 'node:events';
-import { resolveDaemonProfile } from './profile.mjs';
+import { resolveDaemonProfile } from '../dist/profile.mjs';
 import { connectAppServer } from './app-server-client.mjs';
 import { AtomicStateStore, ControlServer } from './control-server.mjs';
 import { MonitorWatcher } from './watcher.mjs';
@@ -23,19 +23,15 @@ export const remoteTuiArgs = (url, codexArgs) => ['--remote', url, ...codexArgs]
 export function launcherEnvironment(env, profile, control) {
   const out = {
     ...env,
-    OURS_PORT: String(profile.port),
     OURS_CONFIG: profile.configPath,
-    OURS_AUTOSTART: '0',
     OURS_CODEX_CONTROL_SOCKET: control.socketPath,
     OURS_CODEX_CAPABILITY: control.capability,
     OURS_CODEX_LIVE: '1',
     // One stable owner pid for the MCP proxy, hooks, and launcher's own cleanup
     // call. The bin shim preserves an explicit value instead of replacing it
     // with whichever child happened to spawn it.
-    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;
 }
 
@@ -53,6 +49,12 @@ export function sessionRegistrationFromNotification(message, cwd) {
     : null;
 }
 
+export function sessionEndPayload(profile, state) {
+  return profile.profile && typeof state?.threadId === 'string' && state.threadId
+    ? `${JSON.stringify({ session_id: state.threadId })}\n`
+    : null;
+}
+
 async function freePort() {
   const server = createServer();
   await new Promise((resolve, reject) => { server.once('error', reject); server.listen(0, '127.0.0.1', resolve); });
@@ -75,6 +77,16 @@ function waitExit(child) {
   return once(child, 'exit').then(([code, signal]) => ({ code, signal }));
 }
 
+function waitCleanupExit(child) {
+  if (child.exitCode != null || child.signalCode != null) return Promise.resolve({ kind: 'exit', code: child.exitCode, signal: child.signalCode });
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (outcome) => { if (!settled) { settled = true; resolve(outcome); } };
+    child.once('error', (error) => finish({ kind: 'error', error }));
+    child.once('exit', (code, signal) => finish({ kind: 'exit', code, signal }));
+  });
+}
+
 export async function runLauncher({
   argv = process.argv.slice(2), env = process.env, platform = process.platform,
   spawn = nodeSpawn, fetch: fetchImpl = globalThis.fetch,
@@ -96,23 +108,37 @@ export async function runLauncher({
   let watcher;
   const sessionEndShim = join(dirname(dirname(fileURLToPath(import.meta.url))), 'bin', 'proxy.mjs');
   const cleanup = async () => {
-    watcher?.stop();
+    await watcher?.stop();
+    const retainedState = control?.state;
     await control?.close().catch(() => {});
     client?.close();
     // The TUI exit is an authoritative normal session end. Run the same lease
     // DELETE seam as the native hook while the shared daemon is still reachable;
     // duplicate hook+launcher cleanup is intentionally idempotent.
+    const input = sessionEndPayload(profile, retainedState);
+    if (profile.profile && input === null) {
+      if (tui && tui.exitCode == null) tui.kill('SIGTERM');
+      if (appServer && appServer.exitCode == null) appServer.kill('SIGTERM');
+      await rm(runtimeDir, { recursive: true, force: true });
+      return;
+    }
     const end = spawn(process.execPath, [sessionEndShim, 'session-end'], {
       env: processEnvs.appServer,
-      stdio: 'ignore',
+      stdio: input === null ? 'ignore' : ['pipe', 'ignore', 'inherit'],
     });
-    end.once('error', () => {});
+    if (input !== null) end.stdin?.end(input);
     let cleanupDeadline;
-    await Promise.race([
-      waitExit(end),
-      new Promise((resolve) => { cleanupDeadline = setTimeout(resolve, 30_000); }),
-    ]).catch(() => {}).finally(() => clearTimeout(cleanupDeadline));
-    if (end.exitCode == null) end.kill('SIGTERM');
+    const cleanupOutcome = await Promise.race([
+      waitCleanupExit(end),
+      new Promise((resolve) => { cleanupDeadline = setTimeout(() => resolve({ kind: 'timeout' }), 30_000); }),
+    ]).finally(() => clearTimeout(cleanupDeadline));
+    if (end.exitCode == null && end.signalCode == null) end.kill('SIGTERM');
+    let cleanupFailure;
+    if (cleanupOutcome.kind === 'error') cleanupFailure = `spawn error: ${cleanupOutcome.error.message}`;
+    else if (cleanupOutcome.kind === 'timeout') cleanupFailure = 'timed out';
+    else if (cleanupOutcome.signal) cleanupFailure = `signal ${cleanupOutcome.signal}`;
+    else if ((cleanupOutcome.code ?? 0) !== 0) cleanupFailure = `exit ${cleanupOutcome.code}`;
+    if (cleanupFailure) process.stderr.write(`ours: SessionEnd cleanup failed: ${cleanupFailure}\n`);
     if (tui && tui.exitCode == null) tui.kill('SIGTERM');
     if (appServer && appServer.exitCode == null) appServer.kill('SIGTERM');
     await rm(runtimeDir, { recursive: true, force: true });
@@ -129,7 +155,7 @@ export async function runLauncher({
       throw new Error(`ours monitor cannot answer ${message.method}`);
     });
     watcher = new MonitorWatcher({
-      baseUrl: profile.baseUrl, token: profile.token, fetch: fetchImpl, appServer: client,
+      baseUrl: profile.baseUrl, token: profile.token, profile: profile.profile, fetch: fetchImpl, appServer: client,
       stateStore: new AtomicStateStore(join(runtimeDir, 'cursor.json')),
     });
     control = new ControlServer({

package/src/monitor-mcp.mjs

@@ -2,10 +2,13 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { spawn } from 'node:child_process';
 import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
 import { z } from 'zod';
+import { hostProfileFromEnv } from '../../core/src/host-client/index.ts';
 import { sendControlCommand } from './control-server.mjs';
 
 const require = createRequire(import.meta.url);
+const networkWatchPath = fileURLToPath(new URL('../bin/network-watch.mjs', import.meta.url));
 export const monitorToolNames = ['arm_monitor', 'foreground_monitor', 'disarm_monitor', 'monitor_status'];
 const content = (text, isError = false) => ({ content: [{ type: 'text', text }], ...(isError ? { isError: true } : {}) });
 
@@ -20,7 +23,16 @@ const foregroundOffer = (identity) =>
   `Only after an explicit yes, call get_messages once to drain existing unread mail, then ` +
   `call foreground_monitor({ identity: ${JSON.stringify(identity)} }).`;
 
-export function foregroundWatchProcess(identity) {
+export 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 = require.resolve('@ours.network/mcp/dist/cli.js');
     return { command: process.execPath, args: [cliPath, 'watch', identity] };
@@ -48,7 +60,7 @@ export async function handleMonitorCommand(command, args = {}, { env = process.e
     : `Live ours monitor is available but not armed${state.boundIdentity ? `; current binding is "${state.boundIdentity}"` : '; bind an identity first'}.` };
 }
 
-export function waitForForegroundMail(identity, {
+export function waitForForegroundMail(identity, nativeSessionId, {
   env = process.env,
   spawnImpl = spawn,
   signal,
@@ -57,16 +69,17 @@ export 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) => {
@@ -109,7 +122,7 @@ export function createMonitorMcpServer(deps = {}) {
     identity: z.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}\nCall get_messages now. After handling the mail, call foreground_monitor again without asking if monitoring should remain armed.`);
     } catch (error) {
       if (extra?.signal?.aborted) return content('Foreground ours monitor stopped. It is no longer armed.');

package/src/network-watch.mjs

@@ -0,0 +1,45 @@
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+
+import { hostProfileFromEnv, nativeClientForAtRoot } from '../../core/src/host-client/index.ts';
+
+export 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 || join(env.HOME || homedir(), '.ours-mcp', 'config.json');
+  const hostRecordRoot = hostRecordRootValue ?? dirname(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}\n`);
+      return;
+    }
+  } finally {
+    if (installSignalHandlers) {
+      process.off('SIGINT', stop);
+      process.off('SIGTERM', stop);
+    }
+    await client?.close();
+  }
+}

package/src/profile.mjs

@@ -1,7 +1,7 @@
-import { join } from 'node:path';
-import { homedir } from 'node:os';
+import { randomUUID } from 'node:crypto';
 
-import { assertDaemonStateDir, resolveDaemonConfig } from '@ours.network/sdk';
+import { attachOursClient } from '@ours.network/sdk';
+import { hostProfileSelectionFromEnv } from '../../core/src/host-client/index.ts';
 
 function validPort(value) {
   const port = Number(value);
@@ -26,41 +26,17 @@ export function parseOursArgs(argv = []) {
   return { port, codexArgs };
 }
 
-export async function resolveDaemonProfile({ argv = [], env = process.env, fetch: fetchImpl = globalThis.fetch } = {}) {
+export async function resolveDaemonProfile({ argv = [], env = process.env, fetch: fetchImpl = globalThis.fetch, attach = attachOursClient } = {}) {
   const parsed = parseOursArgs(argv);
-  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,
-  };
+  const hostSelection = hostProfileSelectionFromEnv(env);
+    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 info;
+    try {
+      info = await client.version();
+      await client.identities();
+      await client.unread();
+    } finally { await client.close(); }
+    return { profile: hostProfile, info, baseUrl: hostProfile.endpoint, configPath, codexArgs: parsed.codexArgs };
 }

package/src/watcher.mjs

@@ -1,10 +1,15 @@
+import { randomUUID } from 'node:crypto';
+import { attachOursClient } from '@ours.network/sdk';
+
 export const WAKE_PROMPT = 'New ours mail is available for the identity already bound to this session. Use the ours skill and get_messages now, then handle the unread mail. Do not change identities or reveal message bodies outside the normal get_messages result.';
 
 export class MonitorWatcher {
-  constructor({ baseUrl, token = null, fetch: fetchImpl = globalThis.fetch, appServer, stateStore = { save: async () => {} }, sleep = (ms) => new Promise((r) => setTimeout(r, ms)) }) {
+  constructor({ baseUrl, token = null, profile = null, clientFactory = attachOursClient, fetch: fetchImpl = globalThis.fetch, appServer, stateStore = { save: async () => {} }, sleep = (ms) => new Promise((r) => setTimeout(r, ms)) }) {
     this.baseUrl = baseUrl;
     this.headers = token ? { 'x-ours-api-token': token } : {};
     this.fetch = fetchImpl;
+    this.profile = profile;
+    this.clientFactory = clientFactory;
     this.appServer = appServer;
     this.stateStore = stateStore;
     this.sleep = sleep;
@@ -23,6 +28,11 @@ export class MonitorWatcher {
     });
   }
 
+  async #client() {
+    this.clientPromise ??= this.clientFactory({ ...this.profile, sessionMode: 'external', leaseToken: randomUUID(), env: {} });
+    return this.clientPromise;
+  }
+
   async #json(path, signal) {
     const response = await this.fetch(`${this.baseUrl}${path}`, { headers: this.headers, signal });
     if (response.status === 401 || response.status === 403) {
@@ -62,11 +72,24 @@ export class MonitorWatcher {
 
   async pollOnce({ identity, threadId, cursor }, signal) {
     const since = cursor == null ? 'tip' : encodeURIComponent(cursor);
-    const data = await this.#json(`/identities/${encodeURIComponent(identity)}/notifications?since=${since}`, signal);
+    let data;
+    let unread;
+    try {
+      if (this.profile) {
+        const client = await this.#client();
+        data = await client.readNotificationPage(identity, { since: cursor == null ? 'tip' : Number(cursor), signal });
+        if (cursor == null) unread = await client.unread();
+      } else {
+        data = await this.#json(`/identities/${encodeURIComponent(identity)}/notifications?since=${since}`, signal);
+        if (cursor == null) unread = await this.#json('/unread', signal);
+      }
+    } catch (error) {
+      if (error?.status === 401 || error?.status === 403 || /HTTP (401|403)|authentication/i.test(error?.message || '')) this.authFailed = true;
+      throw error;
+    }
     const next = { identity, threadId, cursor: String(data.cursor ?? cursor ?? '') };
     await this.stateStore.save(next);
     if (cursor == null) {
-      const unread = await this.#json('/unread', signal);
       const entry = unread.identities?.find((item) => item.name === identity);
       if (entry && (Number(entry.count) > 0 || Number(entry.files) > 0)) await this.#wake(threadId);
     } else if (Array.isArray(data.events) && data.events.length > 0) {
@@ -106,5 +129,8 @@ export class MonitorWatcher {
     this.controller = null;
     this.pending = false;
     this.queued = false;
+    const clientPromise = this.clientPromise;
+    this.clientPromise = null;
+    return clientPromise ? clientPromise.then((client) => client.close()).catch(() => {}) : Promise.resolve();
   }
 }