@4xeoz/re-entry 0.2.16 → 0.2.18

package/README.md

@@ -132,7 +132,14 @@ npx --yes --package=@4xeoz/re-entry re-entry test "Reply with: Re-entry is worki
 ```
 
 This starts one fresh local Codex process through the same adapter seam used by real deliveries. It
-does not create a Grant, claim Receiver work, or prove the browser/WebMCP return path.
+forwards Codex output when run in an interactive terminal, so the smoke test behaves like the
+underlying direct `codex exec` command. It does not create a Grant, claim Receiver work, or prove a
+Desktop UI thread, browser, or WebMCP return path. If it times out, run the equivalent direct
+`codex exec` command to inspect Codex's own output; the test does not contact the Receiver.
+
+The one-shot test allows up to one hour by default. Override it with
+`--activation-timeout <milliseconds>` when needed. Background delivery keeps its separate
+60-second adapter bound.
 
 To pause or remove the local Connector:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@4xeoz/re-entry",
-  "version": "0.2.16",
+  "version": "0.2.18",
   "type": "module",
   "description": "Outbound Local Connector process for Re-entry Core; uses the Cloud Receiver v2 preview by default with an explicit override for other accepted origins.",
   "publishConfig": {

package/src/codex-exec-adapter.mjs

@@ -10,6 +10,8 @@ import {
 } from "./codex-discovery.mjs";
 
 export const CODEX_EXEC_ADAPTER_ID = "codex_exec_local";
+export const DEFAULT_CODEX_PROMPT_TIMEOUT_MS = 3_600_000;
+export const MAX_CODEX_PROMPT_TIMEOUT_MS = 3_600_000;
 
 const OPTION_FIELDS = Object.freeze([
   "workingDirectory",
@@ -59,6 +61,7 @@ export function createCodexExecAdapter(options) {
         executable,
         workingDirectory,
         prompt: buildContinuationPrompt(activation),
+        stdio: ["ignore", "ignore", "ignore"],
         commandTimeoutMs,
         spawnCommand,
       });
@@ -79,7 +82,7 @@ export function createCodexExecAdapter(options) {
 export async function runCodexPrompt(options) {
   requireExactRecord(
     options,
-    ["workingDirectory", "prompt", "executable", "commandTimeoutMs", "spawnCommand"],
+    ["workingDirectory", "prompt", "executable", "commandTimeoutMs", "spawnCommand", "stdio"],
     ["workingDirectory", "prompt"],
     "Codex prompt options",
   );
@@ -88,12 +91,16 @@ export async function runCodexPrompt(options) {
     ? discoverCodexExecutable()
     : requireReference(options.executable, "Codex executable");
   const prompt = requirePrompt(options.prompt);
-  const timeoutMs = requireTimeout(options.commandTimeoutMs ?? 60_000);
+  const timeoutMs = requireTimeout(
+    options.commandTimeoutMs ?? DEFAULT_CODEX_PROMPT_TIMEOUT_MS,
+    MAX_CODEX_PROMPT_TIMEOUT_MS,
+  );
   const spawnCommand = options.spawnCommand ?? spawn;
   if (typeof spawnCommand !== "function") {
     throw new TypeError("Codex prompt spawnCommand must be a function");
   }
-  await runCodexExec({ executable, workingDirectory, prompt, timeoutMs, spawnCommand });
+  const stdio = requireStdio(options.stdio ?? "inherit");
+  await runCodexExec({ executable, workingDirectory, prompt, timeoutMs, spawnCommand, stdio });
 }
 
 function buildContinuationPrompt(activation) {
@@ -114,7 +121,7 @@ function buildContinuationPrompt(activation) {
   ].join("\n");
 }
 
-function runCodexExec({ executable, workingDirectory, prompt, timeoutMs, spawnCommand }) {
+function runCodexExec({ executable, workingDirectory, prompt, timeoutMs, spawnCommand, stdio }) {
   return new Promise((resolve, reject) => {
     let child;
     let settled = false;
@@ -131,15 +138,25 @@ function runCodexExec({ executable, workingDirectory, prompt, timeoutMs, spawnCo
       child = spawnCommand(
         executable,
         ["exec", "--cd", workingDirectory, prompt],
-        { stdio: ["ignore", "ignore", "ignore"] },
+        { stdio },
       );
     } catch (error) {
-      finish(reject, error);
+      finish(
+        reject,
+        codexExecError(
+          "connector_codex_exec_start_failed",
+          "Codex exec could not be started",
+          error,
+        ),
+      );
       return;
     }
 
     if (!child || typeof child.once !== "function") {
-      finish(reject, new Error("Codex exec process is invalid"));
+      finish(
+        reject,
+        codexExecError("connector_codex_exec_invalid", "Codex exec returned an invalid process"),
+      );
       return;
     }
 
@@ -149,16 +166,36 @@ function runCodexExec({ executable, workingDirectory, prompt, timeoutMs, spawnCo
       } catch {
         // The activation remains unknown even if the process cannot be terminated.
       }
-      finish(reject, new Error("Codex exec process timed out"));
+      finish(
+        reject,
+        codexExecError(
+          "connector_codex_exec_timeout",
+          `Codex exec process timed out after ${timeoutMs} milliseconds`,
+        ),
+      );
     }, timeoutMs);
 
-    child.once("error", (error) => finish(reject, error));
+    child.once("error", (error) => finish(
+      reject,
+      codexExecError("connector_codex_exec_start_failed", "Codex exec process failed to start", error),
+    ));
     child.once("close", (code, signal) => {
       if (code === 0 && signal === null) {
         finish(resolve);
         return;
       }
-      finish(reject, new Error("Codex exec process did not complete successfully"));
+      const detail = signal
+        ? ` (signal ${signal})`
+        : code === null
+          ? ""
+          : ` (exit code ${code})`;
+      finish(
+        reject,
+        codexExecError(
+          "connector_codex_exec_failed",
+          `Codex exec process did not complete successfully${detail}`,
+        ),
+      );
     });
   });
 }
@@ -184,11 +221,11 @@ function readClock(clock) {
   return new Date(value.getTime());
 }
 
-function requireTimeout(value) {
+function requireTimeout(value, maximum = MAX_COMMAND_TIMEOUT_MS) {
   if (
     !Number.isSafeInteger(value) ||
     value < MIN_COMMAND_TIMEOUT_MS ||
-    value > MAX_COMMAND_TIMEOUT_MS
+    value > maximum
   ) {
     throw new TypeError("Codex exec adapter commandTimeoutMs is invalid");
   }
@@ -221,6 +258,24 @@ function requirePrompt(value) {
   return value;
 }
 
+function requireStdio(value) {
+  if (value === "inherit") return value;
+  if (
+    Array.isArray(value) &&
+    value.length === 3 &&
+    value.every((entry) => entry === "ignore" || entry === "inherit" || entry === "pipe")
+  ) {
+    return value;
+  }
+  throw new TypeError("Codex prompt stdio is invalid");
+}
+
+function codexExecError(code, message, cause = undefined) {
+  const error = cause === undefined ? new Error(message) : new Error(message, { cause });
+  error.code = code;
+  return error;
+}
+
 function requireExactRecord(value, allowedFields, requiredFields, label) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     throw new TypeError(`${label} must be an object`);

package/src/main.mjs

@@ -10,7 +10,12 @@ import process from "node:process";
 
 import { LocalConnectorClient } from "@webmcp-challenge/reentry-core/local-connector-client";
 import { followConnectorActivity } from "./activity-monitor.mjs";
-import { createCodexExecAdapter, runCodexPrompt } from "./codex-exec-adapter.mjs";
+import {
+  createCodexExecAdapter,
+  DEFAULT_CODEX_PROMPT_TIMEOUT_MS,
+  MAX_CODEX_PROMPT_TIMEOUT_MS,
+  runCodexPrompt,
+} from "./codex-exec-adapter.mjs";
 import {
   discoverCodexExecutable,
   requireSupportedNode,
@@ -514,15 +519,19 @@ async function testCodex(flags, positionals, ui) {
     ui.info("Prompt", prompt);
     ui.wait("Starting a fresh Codex session…");
   }
+  if (ui.interactive) {
+    ui.stopWait("Codex", "running the local prompt; Codex output follows below", "info");
+  }
   await runCodexPrompt({
     workingDirectory: readiness.workingDirectory,
     executable: readiness.installation.executable,
     prompt,
+    stdio: ui.interactive ? "inherit" : ["ignore", "ignore", "ignore"],
     commandTimeoutMs: readBoundedNumber(
-      flags["activation-timeout"] ?? 60_000,
+      flags["activation-timeout"] ?? DEFAULT_CODEX_PROMPT_TIMEOUT_MS,
       100,
-      60_000,
-      "connector_activation_timeout_invalid",
+      MAX_CODEX_PROMPT_TIMEOUT_MS,
+      "connector_test_timeout_invalid",
     ),
   });
   if (ui.interactive) {
@@ -1114,6 +1123,10 @@ function errorHint(error) {
     pairing_expired: "ask the Host backend for a new pairing code",
     pairing_request_timeout: "the Receiver took too long to answer; check your connection and run the command again",
     pairing_network_error: "check your internet connection and the Receiver address, then try again",
+    connector_codex_exec_timeout: "Codex did not finish in time; run the same codex exec command directly to inspect its output",
+    connector_codex_exec_failed: "run the same codex exec command directly and confirm that Codex is signed in and the workspace is accessible",
+    connector_codex_exec_start_failed: "open Codex, complete login if needed, then run the command again",
+    connector_codex_exec_invalid: "the installed Codex executable returned an invalid process; run doctor and try again",
     workspace_directory_unavailable: "choose a readable folder or pass --codex-cd /absolute/path",
     workspace_selection_cancelled: "run the command again when you are ready to choose a workspace",
     device_authorization_expired: `run \`${cliCommand("connect")}\` again and approve within ten minutes`,
@@ -1125,9 +1138,10 @@ function errorHint(error) {
     connector_service_stop_failed: `check the Connector status and try \`${cliCommand("stop")}\` again`,
     connector_test_prompt_missing: `use \`${cliCommand('test "Reply with: Re-entry is working."')}\``,
     connector_test_prompt_invalid: "use one short, single-line prompt inside quotes",
+    connector_test_timeout_invalid: "use a test timeout between 100 and 3600000 milliseconds",
     connector_activation_timeout_invalid: "use an activation timeout between 100 and 60000 milliseconds",
   };
-  return hints[error?.code] ?? "check the Receiver address and try again";
+  return hints[error?.code] ?? "check the command output and try again";
 }
 
 await main();