mycomesh-consumer 0.1.32 → 0.1.34

package/README.md

@@ -6,9 +6,9 @@ Gateway dependency.
 
 ## Install
 
-Requirements: Node.js 20 or newer. The package includes the official Codex
-dependency and the small cryptographic dependencies needed for V8 EIP-712
-payment-key authorizations.
+Requirements: Node.js 20 or newer. The package contains only the small
+cryptographic dependencies needed for V8 EIP-712 payment-key authorizations;
+Codex is an independent client.
 
 ```sh
 npm install --global mycomesh-consumer
@@ -21,9 +21,9 @@ For a checkout:
 npm install --global ./packages/mycomesh-cli
 ```
 
-The command starts `127.0.0.1:8110`, prints and optionally opens the local
-credentials page, waits for a healthy Settlement V8 Relay, and launches Codex
-with a one-run `mycomesh` provider configuration. It does not edit Codex files.
+The command starts the Consumer API on `127.0.0.1:8110`, prints and optionally
+opens the local credentials page, and stays available for any
+OpenAI-compatible client. It does not start or configure Codex.
 
 The page exposes only the local API URL, payment key/export, prepaid balance,
 key operations, and local consumption history. It has no conversation or
@@ -31,12 +31,21 @@ request-session UI. The payment key is generated once and stored at
 `~/.mycomesh/consumer/payment-key` with mode `0600`; set
 `MYCOMESH_CONSUMER_DATA_DIR` to choose another directory.
 
-## Service-only mode
+## Connect a client
 
-Keep the native Consumer running without launching Codex:
+The default command is already service-only. Load the export block into a
+shell and then use Codex or another compatible client:
 
 ```sh
-mycomesh-consumer --no-codex
+mycomesh-consumer --no-browser
+eval "$(curl -sS http://127.0.0.1:8110/credentials)"
+codex
+```
+
+The optional convenience wrapper is explicit:
+
+```sh
+mycomesh-consumer --codex
 ```
 
 Use `--no-browser` on a headless machine. Stop the process without deleting

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mycomesh-consumer",
-  "version": "0.1.32",
+  "version": "0.1.34",
   "description": "Native Node.js MycoMesh Consumer and OpenAI-compatible request CLI.",
   "publishConfig": {
     "access": "public"
@@ -24,7 +24,6 @@
   "dependencies": {
     "@noble/curves": "1.9.1",
     "@noble/hashes": "1.8.0",
-    "@openai/codex": "0.146.0",
     "undici": "6.28.0"
   },
   "scripts": {

package/src/cli.mjs

@@ -1,7 +1,7 @@
 import { once } from "node:events";
 import { readFile } from "node:fs/promises";
 
-const CLI_VERSION = "0.1.32";
+const CLI_VERSION = "0.1.33";
 // The npm client is local-first. A public Gateway is an explicit override;
 // the default remains the loopback Consumer edge so a blocked domain cannot
 // strand the Codex client.

package/src/consumer-runtime.mjs

@@ -949,7 +949,7 @@ function writeJson(response, status, value, headers = {}) {
   response.end(body);
 }
 
-async function handleInference(state, request, response, path) {
+async function handleInference(state, request, response, path, alphaSearchQuery) {
   const authorization = String(request.headers.authorization || "");
   if (!sameSecret(authorization, `Bearer ${state.paymentKey}`)) {
     writeJson(response, 401, openaiError("invalid MycoMesh payment key", "invalid_api_key"));
@@ -960,6 +960,15 @@ async function handleInference(state, request, response, path) {
     writeJson(response, 400, openaiError(error.message, "invalid_request_error"));
     return;
   }
+  const alphaSearch = alphaSearchQuery !== undefined;
+  if (alphaSearch) {
+    body = {
+      model: body.model,
+      input: [{ type: "mycomesh_alpha_search_request", request: body, query: alphaSearchQuery }],
+      max_output_tokens: body.max_output_tokens ?? 2000,
+    };
+    path = "/v1/responses";
+  }
   if (path.endsWith("/responses/compact") && !hasCompactionTrigger(body.input)) {
     const items = Array.isArray(body.input) ? [...body.input] : [];
     if (body.input !== undefined && body.input !== "" && !Array.isArray(body.input)) {
@@ -975,6 +984,15 @@ async function handleInference(state, request, response, path) {
       return;
     }
     for (const [name, value] of Object.entries(result.headers || {})) response.setHeader(name, value);
+    if (alphaSearch) {
+      const payload = result.payload?.mycomesh_alpha_search_response;
+      if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+        writeJson(response, 502, openaiError("Provider returned an invalid alpha/search response", "mycomesh_provider_error"));
+        return;
+      }
+      writeJson(response, 200, payload, result.headers);
+      return;
+    }
     if (body.stream === true) {
       response.writeHead(200, { "content-type": "text/event-stream; charset=utf-8", "cache-control": "no-cache", connection: "keep-alive", "x-mycomesh-streaming-mode": "buffered" });
       const events = path.endsWith("/chat/completions")
@@ -1039,6 +1057,9 @@ export function createConsumerServer(state, { host = "127.0.0.1", port = 8110 }
             : "/v1/responses";
         await handleInference(state, request, response, relayPath); return;
       }
+      if (request.method === "POST" && ["/alpha/search", "/v1/alpha/search", "/backend-api/codex/alpha/search"].includes(path)) {
+        await handleInference(state, request, response, "/v1/responses", Object.fromEntries(url.searchParams)); return;
+      }
       writeJson(response, 404, openaiError("route not found", "invalid_request_error"));
     } catch (error) {
       if (!response.headersSent) writeJson(response, 500, openaiError(error.message)); else response.destroy();

package/src/consumer.mjs

@@ -1,5 +1,4 @@
 import { spawn as defaultSpawn } from "node:child_process";
-import { createRequire } from "node:module";
 import { existsSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import * as readline from "node:readline/promises";
@@ -12,7 +11,7 @@ import {
   createConsumerServer,
 } from "./consumer-runtime.mjs";
 
-export const CONSUMER_RELEASE_VERSION = "0.1.32";
+export const CONSUMER_RELEASE_VERSION = "0.1.34";
 export const API_COMMANDS = new Set(["health", "models", "responses", "chat"]);
 const API_VALUE_OPTIONS = new Set([
   "--base-url",
@@ -37,10 +36,11 @@ exposes an OpenAI-compatible loopback API.
 
 Options:
   --no-browser          Print the local credentials URL without opening it
-  --no-codex            Keep only the Consumer API running
+  --codex               Start an optional Codex client after Relay readiness
+  --no-codex            Keep only the Consumer API running (default)
   --stop                Stop a previously started native Consumer
   --reset-local         Confirm and delete the local Consumer data directory
-  --codex-command PATH  Codex executable (default: bundled Codex or codex)
+  --codex-command PATH  Codex executable for --codex (default: codex on PATH)
   --ready-timeout SEC   Relay readiness timeout (default: 1800)
   --data-dir DIR        Payment key and history directory
   --relay URLS          Comma-separated Relay URLs for automatic failover
@@ -123,7 +123,10 @@ export async function main(argv, dependencies = {}) {
     return code;
   } catch (error) {
     const exitCode = error instanceof ConsumerCliError ? error.exitCode : 1;
-    stderr.write(`mycomesh consumer: ${error instanceof Error ? error.message : String(error)}\n`);
+    const message = error?.code === "EADDRINUSE"
+      ? `port ${error.port || "requested"} is already in use; stop the old Consumer or choose --port with a matching --base-url`
+      : error instanceof Error ? error.message : String(error);
+    stderr.write(`mycomesh consumer: ${message}\n`);
     return exitCode;
   }
 }
@@ -131,10 +134,11 @@ export async function main(argv, dependencies = {}) {
 export function parseArguments(argv, env = process.env) {
   const parsed = {
     baseUrl: env.MYCOMESH_CONSUMER_PUBLIC_BASE_URL || DEFAULT_BASE_URL,
+    baseUrlExplicit: Boolean(env.MYCOMESH_CONSUMER_PUBLIC_BASE_URL),
     dataDir: env.MYCOMESH_CONSUMER_DATA_DIR || join(env.HOME || process.cwd(), ".mycomesh", "consumer"),
     relayUrls: env.MYCOMESH_V8_RELAY_URLS || env.MYCOMESH_CONSUMER_RELAY_URL || DEFAULT_RELAY_URL,
     proxy: env.MYCOMESH_CONSUMER_PROXY || "",
-    codexCommand: env.MYCOMESH_CODEX_COMMAND || bundledCodexCommand(),
+    codexCommand: env.MYCOMESH_CODEX_COMMAND || "codex",
     readyTimeout: parsePositive(env.MYCOMESH_CONSUMER_READY_TIMEOUT_SECONDS || "1800", "ready timeout", 86400),
     maxFeeUnits: parsePositive(env.MYCOMESH_V8_MAX_FEE_UNITS || String(DEFAULT_MAX_FEE_UNITS), "max fee"),
     host: env.MYCOMESH_CONSUMER_HOST || "127.0.0.1",
@@ -142,7 +146,7 @@ export function parseArguments(argv, env = process.env) {
     port: parsePositive(env.MYCOMESH_CONSUMER_PORT || "8110", "port", 65535),
     scheme: "http",
     noBrowser: false,
-    noCodex: false,
+    noCodex: env.MYCOMESH_CONSUMER_START_CODEX !== "1",
     stop: false,
     resetLocal: false,
     dryRun: false,
@@ -156,6 +160,7 @@ export function parseArguments(argv, env = process.env) {
     if (token === "-h" || token === "--help") { parsed.help = true; continue; }
     if (token === "-v" || token === "--version") { parsed.version = true; continue; }
     if (token === "--no-browser") { parsed.noBrowser = true; continue; }
+    if (token === "--codex") { parsed.noCodex = false; continue; }
     if (token === "--no-codex") { parsed.noCodex = true; continue; }
     if (token === "--stop") { parsed.stop = true; continue; }
     if (token === "--reset-local") { parsed.resetLocal = true; continue; }
@@ -167,7 +172,7 @@ export function parseArguments(argv, env = process.env) {
     if (!options.has(name)) throw new ConsumerCliError(`unknown option: ${token}`, 2);
     if (value === undefined) { index += 1; value = argv[index]; }
     if (!value) throw new ConsumerCliError(`${name} requires a value`, 2);
-    if (name === "--base-url") parsed.baseUrl = value;
+    if (name === "--base-url") { parsed.baseUrl = value; parsed.baseUrlExplicit = true; }
     if (name === "--data-dir") parsed.dataDir = value;
     if (name === "--relay") parsed.relayUrls = value;
     if (name === "--proxy") parsed.proxy = value;
@@ -177,6 +182,7 @@ export function parseArguments(argv, env = process.env) {
     if (name === "--port") parsed.port = parsePositive(value, name, 65535);
     if (name === "--max-fee") parsed.maxFeeUnits = parsePositive(value, name);
   }
+  if (!parsed.baseUrlExplicit) parsed.baseUrl = `http://${parsed.hostForUrl}:${parsed.port}/v1`;
   try { new URL(parsed.baseUrl); } catch { throw new ConsumerCliError("--base-url must be an absolute URL", 2); }
   return parsed;
 }
@@ -188,10 +194,6 @@ function parsePositive(value, label, maximum = Number.MAX_SAFE_INTEGER) {
   return parsed;
 }
 
-function bundledCodexCommand() {
-  try { return createRequire(import.meta.url).resolve("@openai/codex/bin/codex.js"); } catch { return "codex"; }
-}
-
 export function isApiInvocation(argv) {
   for (let index = 0; index < argv.length; index += 1) {
     const token = argv[index];