oh-my-codex 0.11.0 → 0.11.2

package/src/scripts/smoke-packed-install.ts

@@ -1,16 +1,11 @@
-import { createServer } from 'node:http';
-import type { AddressInfo } from 'node:net';
 import {
-  cpSync,
   existsSync,
   lstatSync,
   mkdtempSync,
-  readFileSync,
   rmSync,
   symlinkSync,
-  writeFileSync,
 } from 'node:fs';
-import { chmodSync, mkdirSync } from 'node:fs';
+import { mkdirSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { basename, dirname, join, resolve } from 'node:path';
 import { spawnSync } from 'node:child_process';
@@ -23,12 +18,17 @@ const REQUIRED_NODE_MODULE_MARKERS = [
   join('zod', 'package.json'),
 ];
 
+export const PACKED_INSTALL_SMOKE_CORE_COMMANDS = [
+  ['--help'],
+  ['version'],
+] as const;
+
 function usage(): string {
   return [
-    'Usage: node scripts/smoke-packed-install.mjs [--release-assets-dir <dir>] [--require-no-fallback]',
+    'Usage: node scripts/smoke-packed-install.mjs',
     '',
     'Creates an npm tarball, installs it into an isolated prefix, and smoke tests the installed omx CLI.',
-    'When --release-assets-dir is provided, native hydration is also exercised using a local HTTP server.',
+    'Release smoke stays intentionally minimal: install + boot + 1-2 core commands only.',
   ].join('\n');
 }
 
@@ -151,43 +151,24 @@ export function ensureRepoDependencies(repoRoot: string, options: EnsureRepoDeps
   };
 }
 
-export function hasSparkShellFallbackBanner(stderr: string | undefined): boolean {
-  return /GLIBC-incompatible native sidecar detected/i.test(String(stderr || ''));
-}
-
-function parseArgs(argv: string[]): { releaseAssetsDir: string | undefined; requireNoFallback: boolean } {
-  let releaseAssetsDir: string | undefined;
-  let requireNoFallback = false;
-  for (let index = 0; index < argv.length; index += 1) {
-    const token = argv[index];
+function parseArgs(argv: string[]): void {
+  for (const token of argv) {
     if (token === '--help' || token === '-h') {
       console.log(usage());
       process.exit(0);
     }
-    if (token === '--release-assets-dir') {
-      const value = argv[index + 1];
-      if (!value) throw new Error('Missing value after --release-assets-dir');
-      releaseAssetsDir = resolve(value);
-      index += 1;
-      continue;
-    }
-    if (token === '--require-no-fallback') {
-      requireNoFallback = true;
-      continue;
-    }
     throw new Error(`Unknown argument: ${token}\n${usage()}`);
   }
-  return { releaseAssetsDir, requireNoFallback };
 }
 
-function run(cmd: string, args: string[], options: Record<string, unknown> = {}): ReturnType<typeof spawnSync> {
-  const result = spawnSync(cmd, args, {
+function run(cmd: string, args: readonly string[], options: Record<string, unknown> = {}): ReturnType<typeof spawnSync> {
+  const result = spawnSync(cmd, [...args], {
     encoding: 'utf-8',
     stdio: 'pipe',
     ...options,
   });
   if (result.status !== 0) {
-    throw new Error(formatCommandFailure(cmd, args, result));
+    throw new Error(formatCommandFailure(cmd, [...args], result));
   }
   return result;
 }
@@ -196,115 +177,14 @@ function npmBinName(name: string): string {
   return process.platform === 'win32' ? `${name}.cmd` : name;
 }
 
-function startStaticServer(root: string): Promise<{ baseUrl: string; close: () => Promise<void> }> {
-  return new Promise((resolveServer, reject) => {
-    const server = createServer((req, res) => {
-      try {
-        const url = new URL(req.url || '/', 'http://127.0.0.1');
-        const requested = resolve(root, url.pathname.replace(/^\//, ''));
-        if (!requested.startsWith(root) || !existsSync(requested)) {
-          res.writeHead(404);
-          res.end('missing');
-          return;
-        }
-        res.writeHead(200);
-        res.end(readFileSync(requested));
-      } catch (error) {
-        res.writeHead(500);
-        res.end(String(error));
-      }
-    });
-    server.on('error', reject);
-    server.listen(0, '127.0.0.1', () => {
-      const address = server.address() as AddressInfo | null;
-      if (!address || typeof address === 'string') {
-        reject(new Error('Failed to bind local asset server'));
-        return;
-      }
-      resolveServer({
-        baseUrl: `http://127.0.0.1:${address.port}`,
-        close: () => new Promise<void>((done, fail) => server.close((error) => error ? fail(error) : done())),
-      });
-    });
-  });
-}
-
-function writeCodexStub(binDir: string): string {
-  const stubPath = join(binDir, process.platform === 'win32' ? 'codex.cmd' : 'codex');
-  if (process.platform === 'win32') {
-    writeFileSync(stubPath, [
-      '@echo off',
-      'setlocal enabledelayedexpansion',
-      'set output_path=',
-      ':loop',
-      'if "%~1"=="" goto done',
-      'if "%~1"=="-o" (',
-      '  set output_path=%~2',
-      '  shift',
-      ')',
-      'shift',
-      'goto loop',
-      ':done',
-      'if "%output_path%"=="" exit /b 1',
-      '> "%output_path%" echo # Answer',
-      '>> "%output_path%" echo - packed install smoke harness',
-      'exit /b 0',
-      '',
-    ].join('\r\n'));
-  } else {
-    writeFileSync(stubPath, [
-      '#!/bin/sh',
-      'set -eu',
-      "output_path=''",
-      'while [ "$#" -gt 0 ]; do',
-      '  if [ "$1" = "-o" ] && [ "$#" -ge 2 ]; then',
-      '    output_path="$2"',
-      '    shift 2',
-      '    continue',
-      '  fi',
-      '  shift',
-      'done',
-      'if [ -z "$output_path" ]; then',
-      "  printf 'missing -o output path\\n' >&2",
-      '  exit 1',
-      'fi',
-      "printf '# Answer\\n- packed install smoke harness\\n' > \"$output_path\"",
-      '',
-    ].join('\n'));
-    chmodSync(stubPath, 0o755);
-  }
-  return stubPath;
-}
-
-export function prepareLocalHydrationAssetDirectory(sourceDir: string, tempRoot: string): string {
-  const localDir = join(tempRoot, 'hydration-assets');
-  cpSync(sourceDir, localDir, { recursive: true });
-  return localDir;
-}
-
-export function rewriteManifestDownloadUrls(manifestPath: string, baseUrl: string): void {
-  const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8')) as { assets: Array<{ archive: string; download_url: string }> };
-  manifest.assets = Array.isArray(manifest.assets)
-    ? manifest.assets.map((asset) => ({
-      ...asset,
-      download_url: new URL(asset.archive, `${baseUrl}/`).toString(),
-    }))
-    : [];
-  writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
-}
-
 async function main(): Promise<void> {
-  const { releaseAssetsDir, requireNoFallback } = parseArgs(process.argv.slice(2));
+  parseArgs(process.argv.slice(2));
+
   const repoRoot = process.cwd();
   const tempRoot = mkdtempSync(join(tmpdir(), 'omx-packed-install-'));
   const prefixDir = join(tempRoot, 'prefix');
-  const cacheDir = join(tempRoot, 'cache');
-  const helperBinDir = join(tempRoot, 'bin');
   mkdirSync(prefixDir, { recursive: true });
-  mkdirSync(cacheDir, { recursive: true });
-  mkdirSync(helperBinDir, { recursive: true });
 
-  let server: { baseUrl: string; close: () => Promise<void> } | undefined;
   let tarballPath: string | undefined;
   try {
     ensureRepoDependencies(repoRoot, {
@@ -320,40 +200,13 @@ async function main(): Promise<void> {
     run('npm', ['install', '-g', tarballPath, '--prefix', prefixDir], { cwd: repoRoot });
 
     const omxPath = join(prefixDir, process.platform === 'win32' ? '' : 'bin', npmBinName('omx'));
-    run(omxPath, ['version'], { cwd: repoRoot });
-    run(omxPath, ['--help'], { cwd: repoRoot });
-
-    if (releaseAssetsDir) {
-      const hydrationAssetsDir = prepareLocalHydrationAssetDirectory(releaseAssetsDir, tempRoot);
-      server = await startStaticServer(hydrationAssetsDir);
-      rewriteManifestDownloadUrls(join(hydrationAssetsDir, 'native-release-manifest.json'), server.baseUrl);
-      const codexStub = writeCodexStub(helperBinDir);
-      const env = {
-        ...process.env,
-        PATH: `${helperBinDir}${process.platform === 'win32' ? ';' : ':'}${process.env.PATH || ''}`,
-        OMX_NATIVE_MANIFEST_URL: `${server.baseUrl}/native-release-manifest.json`,
-        OMX_NATIVE_CACHE_DIR: cacheDir,
-        OMX_EXPLORE_CODEX_BIN: codexStub,
-      };
-
-      const sparkshell = run(omxPath, ['sparkshell', 'node', '--version'], { cwd: repoRoot, env });
-      if (requireNoFallback && hasSparkShellFallbackBanner(sparkshell.stderr as string)) {
-        throw new Error(`Unexpected sparkshell fallback stderr:\n${sparkshell.stderr}`);
-      }
-      if (!/v\d+\./.test(sparkshell.stdout as string)) {
-        throw new Error(`Unexpected sparkshell stdout:\n${sparkshell.stdout}`);
-      }
-
-      const explore = run(omxPath, ['explore', '--prompt', 'where is buildExploreRoutingGuidance defined'], { cwd: repoRoot, env });
-      if (!(explore.stdout as string).includes('# Answer') || !(explore.stdout as string).includes('packed install smoke harness')) {
-        throw new Error(`Unexpected explore stdout:\n${explore.stdout}`);
-      }
+    for (const argv of PACKED_INSTALL_SMOKE_CORE_COMMANDS) {
+      run(omxPath, argv, { cwd: repoRoot });
     }
 
     console.log('packed install smoke: PASS');
   } finally {
     if (tarballPath) rmSync(tarballPath, { force: true });
-    if (server) await server.close();
     rmSync(tempRoot, { recursive: true, force: true });
   }
 }

package/src/scripts/test-reply-listener-live.ts

@@ -0,0 +1,188 @@
+interface ReplyListenerLiveConfig {
+  discordBotToken: string;
+  discordChannelId: string;
+  telegramBotToken: string;
+  telegramChatId: string;
+}
+
+interface ReplyListenerLiveEnvResolution {
+  enabled: boolean;
+  missing: string[];
+  config: ReplyListenerLiveConfig | null;
+}
+
+interface ReplyListenerLiveSmokeResult {
+  discordMessageId: string;
+  telegramMessageId: string;
+}
+
+interface ReplyListenerLiveSmokeDeps {
+  fetchImpl?: typeof fetch;
+  log?: (message: string) => void;
+}
+
+const LIVE_ENABLE_ENV = 'OMX_REPLY_LISTENER_LIVE';
+const REQUIRED_ENV_KEYS = [
+  'OMX_DISCORD_NOTIFIER_BOT_TOKEN',
+  'OMX_DISCORD_NOTIFIER_CHANNEL',
+  'OMX_TELEGRAM_BOT_TOKEN',
+  'OMX_TELEGRAM_CHAT_ID',
+] as const;
+
+function requireJsonObject(value: unknown, label: string): Record<string, unknown> {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error(`${label} returned a non-object JSON payload`);
+  }
+  return value as Record<string, unknown>;
+}
+
+async function parseResponseJson(response: Response, label: string): Promise<Record<string, unknown>> {
+  const body = await response.json() as unknown;
+  return requireJsonObject(body, label);
+}
+
+export function resolveReplyListenerLiveEnv(env: NodeJS.ProcessEnv = process.env): ReplyListenerLiveEnvResolution {
+  const enabled = env[LIVE_ENABLE_ENV] === '1';
+  if (!enabled) {
+    return { enabled: false, missing: [], config: null };
+  }
+
+  const missing = REQUIRED_ENV_KEYS.filter((key) => {
+    const value = env[key];
+    return typeof value !== 'string' || value.trim().length === 0;
+  });
+  if (missing.length > 0) {
+    return { enabled: true, missing: [...missing], config: null };
+  }
+
+  return {
+    enabled: true,
+    missing: [],
+    config: {
+      discordBotToken: env.OMX_DISCORD_NOTIFIER_BOT_TOKEN!.trim(),
+      discordChannelId: env.OMX_DISCORD_NOTIFIER_CHANNEL!.trim(),
+      telegramBotToken: env.OMX_TELEGRAM_BOT_TOKEN!.trim(),
+      telegramChatId: env.OMX_TELEGRAM_CHAT_ID!.trim(),
+    },
+  };
+}
+
+export async function runReplyListenerLiveSmoke(
+  config: ReplyListenerLiveConfig,
+  deps: ReplyListenerLiveSmokeDeps = {},
+): Promise<ReplyListenerLiveSmokeResult> {
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const log = deps.log ?? console.log;
+  const stamp = new Date().toISOString();
+
+  const discordSendResponse = await fetchImpl(
+    `https://discord.com/api/v10/channels/${config.discordChannelId}/messages`,
+    {
+      method: 'POST',
+      headers: {
+        Authorization: `Bot ${config.discordBotToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        content: `[omx live smoke ${stamp}] reply-listener Discord connectivity probe`,
+      }),
+      signal: AbortSignal.timeout(10_000),
+    },
+  );
+  if (!discordSendResponse.ok) {
+    throw new Error(`Discord live smoke failed: HTTP ${discordSendResponse.status}`);
+  }
+  const discordPayload = await parseResponseJson(discordSendResponse, 'Discord sendMessage');
+  const discordMessageId = typeof discordPayload.id === 'string' && discordPayload.id.trim()
+    ? discordPayload.id
+    : null;
+  if (!discordMessageId) {
+    throw new Error('Discord live smoke failed: missing message id');
+  }
+  log(`Discord probe message sent: ${discordMessageId}`);
+
+  try {
+    await fetchImpl(
+      `https://discord.com/api/v10/channels/${config.discordChannelId}/messages/${discordMessageId}`,
+      {
+        method: 'DELETE',
+        headers: { Authorization: `Bot ${config.discordBotToken}` },
+        signal: AbortSignal.timeout(10_000),
+      },
+    );
+  } catch {
+    log(`Discord probe cleanup skipped for ${discordMessageId}`);
+  }
+
+  const telegramSendResponse = await fetchImpl(
+    `https://api.telegram.org/bot${config.telegramBotToken}/sendMessage`,
+    {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        chat_id: config.telegramChatId,
+        text: `[omx live smoke ${stamp}] reply-listener Telegram connectivity probe`,
+      }),
+      signal: AbortSignal.timeout(10_000),
+    },
+  );
+  if (!telegramSendResponse.ok) {
+    throw new Error(`Telegram live smoke failed: HTTP ${telegramSendResponse.status}`);
+  }
+  const telegramPayload = await parseResponseJson(telegramSendResponse, 'Telegram sendMessage');
+  const telegramResult = requireJsonObject(telegramPayload.result, 'Telegram sendMessage.result');
+  const telegramMessageId = typeof telegramResult.message_id === 'number' || typeof telegramResult.message_id === 'string'
+    ? String(telegramResult.message_id)
+    : null;
+  if (!telegramMessageId) {
+    throw new Error('Telegram live smoke failed: missing message id');
+  }
+  log(`Telegram probe message sent: ${telegramMessageId}`);
+
+  try {
+    await fetchImpl(
+      `https://api.telegram.org/bot${config.telegramBotToken}/deleteMessage`,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          chat_id: config.telegramChatId,
+          message_id: Number(telegramMessageId),
+        }),
+        signal: AbortSignal.timeout(10_000),
+      },
+    );
+  } catch {
+    log(`Telegram probe cleanup skipped for ${telegramMessageId}`);
+  }
+
+  return { discordMessageId, telegramMessageId };
+}
+
+export async function main(): Promise<void> {
+  const resolution = resolveReplyListenerLiveEnv();
+  if (!resolution.enabled) {
+    console.log(`reply-listener live smoke: SKIP (${LIVE_ENABLE_ENV}=1 to enable)`);
+    return;
+  }
+  if (!resolution.config) {
+    console.log(`reply-listener live smoke: SKIP (missing env: ${resolution.missing.join(', ')})`);
+    return;
+  }
+
+  const result = await runReplyListenerLiveSmoke(resolution.config);
+  console.log('reply-listener live smoke: PASS');
+  console.log(`discord_message_id=${result.discordMessageId}`);
+  console.log(`telegram_message_id=${result.telegramMessageId}`);
+}
+
+const isMain = process.argv[1]
+  ? import.meta.url === new URL(`file://${process.argv[1]}`).href
+  : false;
+
+if (isMain) {
+  main().catch((error) => {
+    console.error(`reply-listener live smoke: FAIL\n${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  });
+}

package/src/scripts/tmux-hook-engine.ts

@@ -182,13 +182,17 @@ export function isPaneRunningShell(paneCurrentCommand: any): boolean {
 // Codex agent commands — do NOT include 'claude' (that's Claude Code CLI, a different tool)
 const AGENT_COMMANDS = new Set(['node', 'codex', 'npx']);
 
+function isHudStartCommand(startCommand: string): boolean {
+  return /\bomx\b.*\bhud\b.*--watch/i.test(startCommand);
+}
+
 /**
  * Canonical codex pane resolver. Finds the tmux pane running a codex/claude agent.
  *
  * Resolution order:
- * 1. TMUX_PANE env var — but only if the pane is running an agent (not a shell)
- * 2. Scan all panes in the same tmux session for one running an agent command
- * 3. Fall back to TMUX_PANE even if it's a shell (best effort)
+ * 1. TMUX_PANE env var — but only if the pane looks like a real agent pane, not HUD
+ * 2. Scan all panes in the same tmux session for one started with codex
+ * 3. Fail closed instead of guessing a shell or HUD pane
  *
  * All callers (auto-nudge, ralph steer, team dispatch, tmux injection) should
  * use this instead of raw `process.env.TMUX_PANE`.
@@ -197,43 +201,42 @@ export function resolveCodexPane(): string {
   const envPane = (process.env.TMUX_PANE || '').trim();
   if (!envPane) return '';
 
-  // Check if TMUX_PANE is actually running an agent
   try {
     const cmd = execFileSync('tmux', ['display-message', '-t', envPane, '-p', '#{pane_current_command}'], {
       encoding: 'utf-8', timeout: 2000,
     }).trim().toLowerCase();
+    const startCmd = execFileSync('tmux', ['display-message', '-t', envPane, '-p', '#{pane_start_command}'], {
+      encoding: 'utf-8', timeout: 2000,
+    }).trim().toLowerCase();
     const base = cmd.split('/').pop()?.replace(/^-/, '') || '';
-    if (AGENT_COMMANDS.has(base)) {
-      return envPane; // TMUX_PANE is running a codex agent — use it
+    if (AGENT_COMMANDS.has(base) && !isHudStartCommand(startCmd)) {
+      return envPane;
     }
     if (!SHELL_COMMANDS.has(base)) {
-      // Not a shell and not a known agent (e.g. 'claude' = Claude Code CLI)
-      // Fall through to session scan to find the actual codex pane
+      // Not a shell and not a known agent (e.g. claude CLI) — fall through to
+      // session scan so we can still reject HUD or locate a codex pane.
     }
   } catch {
-    return envPane; // Can't check — use it as-is
+    // Fall through to session scan instead of guessing.
   }
 
-  // TMUX_PANE is a shell — find the actual agent pane in the same session
   try {
-    const sessionName = execFileSync('tmux', ['display-message', '-t', envPane, '-p', '#{session_name}'], {
+    const sessionName = execFileSync('tmux', ['display-message', '-t', envPane, '-p', '#S'], {
       encoding: 'utf-8', timeout: 2000,
     }).trim();
-    if (!sessionName) return envPane;
+    if (!sessionName) return '';
 
     const panes = execFileSync('tmux', [
       'list-panes', '-s', '-t', sessionName,
       '-F', '#{pane_id}\t#{pane_current_command}\t#{pane_start_command}',
     ], { encoding: 'utf-8', timeout: 2000 }).trim().split('\n');
 
-    // Find the pane that was STARTED with codex (not the HUD or shell)
     for (const line of panes) {
       const parts = line.split('\t');
       const paneId = parts[0];
       const startCmd = (parts[2] || '').toLowerCase();
       if (!paneId) continue;
-      // The codex pane has 'codex' in its start command
-      if (startCmd.includes('codex') && !startCmd.includes('hud')) {
+      if (startCmd.includes('codex') && !isHudStartCommand(startCmd)) {
         return paneId;
       }
     }
@@ -241,7 +244,6 @@ export function resolveCodexPane(): string {
     // Fall through
   }
 
-  // No agent pane found in the session — don't fall back to a shell pane
   return '';
 }