@mytegroupinc/myte-core 0.0.39 → 0.0.41

package/README.md

@@ -28,16 +28,17 @@ This package exists so the public wrapper can stay small and versioned cleanly.
 - Public package documentation is intentionally minimal. Internal rollout and design notes are not part of the npm package contract.
 - `mytecody` is a model-agnostic MyteCody team launcher. It supports `doctor`,
   `doctor --probe-gateway`, `update --dry-run`, and `update`. On first coding
-  run, it installs the branded MyteCody engine from the Myte release manifest
-  into a user-local Myte cache after signature/hash checks. Coding execution
-  requires that engine, a reachable Myte AI Cody gateway, and `MYTEAI_API_KEY`.
+  run, it installs the branded MyteCody engine and signed client assets from
+  the Myte release manifest into a user-local Myte cache after signature/hash
+  checks. Coding execution requires those assets, a reachable Myte AI Cody
+  gateway, and `MYTEAI_API_KEY`.
 - `mytecody doctor` reports both the signed MyteCody engine state and this npm
   package version. `mytecody update` updates the engine only. Use
   `npm install -g myte@latest` to update the launcher and the Myte API CLI
   commands shipped by npm.
-- The package does not bundle the large MyteCody engine binary. See
-  `THIRD_PARTY_NOTICES.md` and `TRADEMARKS.md` for Codex lineage and Myte brand
-  notices.
+- The package does not bundle the large MyteCody engine binary or the async
+  Responses bridge implementation. See `THIRD_PARTY_NOTICES.md` and
+  `TRADEMARKS.md` for Codex lineage and Myte brand notices.
 
 ## Agent Usage Contract
 

package/THIRD_PARTY_NOTICES.md

@@ -13,9 +13,9 @@ Source lineage tracked for this slice:
 - License: Apache-2.0
 - Upstream: https://github.com/openai/codex
 
-The MyteCody engine artifact is distributed separately from this npm package
-through a Myte release manifest. This package verifies the release artifact
-before installing it into the user's Myte-owned local cache.
+The MyteCody engine and signed client assets are distributed separately from
+this npm package through a Myte release manifest. This package verifies release
+artifacts before installing them into the user's Myte-owned local cache.
 
 Myte names, marks, logos, terminal branding, and product design are not part of
 the OpenAI Codex project and remain Myte-owned brand assets.

package/mytecody-cli.js

@@ -168,6 +168,10 @@ function currentBridgePath() {
   return path.join(currentInstallRoot(), "lib", "mytecody-async-responses-bridge.js");
 }
 
+function currentControllerPath() {
+  return path.join(currentInstallRoot(), "lib", "mytecody-controller.js");
+}
+
 function codexHome() {
   return path.join(installRoot(), "engine-home");
 }
@@ -192,6 +196,15 @@ function installedClientCommand() {
   return { cmd: enginePath, args: [], source: "myte-installed-engine" };
 }
 
+function installedClientUsable() {
+  return Boolean(
+    installedClientCommand() &&
+      fs.existsSync(currentBridgePath()) &&
+      fs.existsSync(currentControllerPath()) &&
+      readCurrentClientManifest(),
+  );
+}
+
 function loadSignedBridge() {
   const bridgePath = currentBridgePath();
   if (!fs.existsSync(bridgePath)) {
@@ -204,6 +217,18 @@ function loadSignedBridge() {
   return bridge;
 }
 
+function loadSignedController() {
+  const controllerPath = currentControllerPath();
+  if (!fs.existsSync(controllerPath)) {
+    throw new Error("signed MyteCody controller asset is missing; run `mytecody update`.");
+  }
+  const controller = require(controllerPath);
+  if (!controller || typeof controller.runMyteCodyController !== "function") {
+    throw new Error("signed MyteCody controller asset is invalid.");
+  }
+  return controller;
+}
+
 function releaseAssetsForPlatform(manifest, artifact) {
   const assets = [];
   const collect = (value, source) => {
@@ -369,9 +394,11 @@ function commonStatus(args, envPath) {
       install_root: installRoot(),
       engine_path: currentEnginePath(),
       bridge_path: currentBridgePath(),
+      controller_path: currentControllerPath(),
       client_manifest: currentClientManifestPath(),
       client_installed: Boolean(current && installedClientCommand()),
       bridge_installed: fs.existsSync(currentBridgePath()),
+      controller_installed: fs.existsSync(currentControllerPath()),
       client_version: current && current.version ? current.version : null,
     },
   };
@@ -1001,6 +1028,157 @@ function codexLaunchArgs(rawArgs, args = {}, providerBaseUrl = codyInferenceBase
   return [...providerArgs, ...rawArgs];
 }
 
+function execArgsAndStdin(rawArgs) {
+  if (!rawArgs.length) return { args: [], stdin: null };
+  const valueOptions = new Set([
+    "-a",
+    "--ask-for-approval",
+    "-C",
+    "--cd",
+    "-c",
+    "--config",
+    "-i",
+    "--image",
+    "-m",
+    "--model",
+    "-o",
+    "--output-last-message",
+    "-p",
+    "--profile",
+    "-s",
+    "--sandbox",
+    "--color",
+    "--local-provider",
+    "--output-schema",
+  ]);
+  const forwarded = [];
+  let index = 0;
+  while (index < rawArgs.length) {
+    const arg = rawArgs[index];
+    if (arg === "--") {
+      index += 1;
+      break;
+    }
+    if (arg === "-") break;
+    if (!arg.startsWith("-")) break;
+    forwarded.push(arg);
+    index += 1;
+    if (valueOptions.has(arg) && index < rawArgs.length) {
+      forwarded.push(rawArgs[index]);
+      index += 1;
+    }
+  }
+  const promptParts = rawArgs.slice(index);
+  if (!promptParts.length) return { args: forwarded, stdin: null };
+  if (promptParts.length === 1 && promptParts[0] === "-") {
+    return { args: [...forwarded, "-"], stdin: fs.readFileSync(0, "utf8") };
+  }
+  const prompt = promptParts.join(" ");
+  if (prompt.includes("\n") || prompt.includes("\r") || promptParts.length > 1) {
+    return { args: [...forwarded, "-"], stdin: prompt };
+  }
+  return { args: [...forwarded, prompt], stdin: null };
+}
+
+function stripControllerArgs(rawArgs) {
+  const kept = [];
+  let enabled = process.env.MYTE_CODY_CONTROLLER !== "0";
+  for (let i = 0; i < rawArgs.length; i += 1) {
+    const arg = rawArgs[i];
+    if (arg === "--controller") {
+      const next = rawArgs[i + 1];
+      if (next !== undefined && !next.startsWith("-")) {
+        enabled = !["0", "false", "off", "raw"].includes(String(next).toLowerCase());
+        i += 1;
+      } else {
+        enabled = true;
+      }
+      continue;
+    }
+    if (arg.startsWith("--controller=")) {
+      const value = arg.slice("--controller=".length);
+      enabled = !["0", "false", "off", "raw"].includes(String(value).toLowerCase());
+      continue;
+    }
+    if (arg === "--no-controller") {
+      enabled = false;
+      continue;
+    }
+    kept.push(arg);
+  }
+  return { enabled, args: kept };
+}
+
+function controllerPromptFromExecArgs(rawArgs) {
+  const execInput = execArgsAndStdin(rawArgs);
+  if (execInput.stdin != null) return { prompt: execInput.stdin, forwardedArgs: [] };
+  const prompt = execInput.args.length ? execInput.args[execInput.args.length - 1] : "";
+  if (!prompt || prompt.startsWith("-")) {
+    return { prompt: "", forwardedArgs: execInput.args };
+  }
+  return { prompt, forwardedArgs: execInput.args.slice(0, -1) };
+}
+
+function runEngineExecWorker({ command, args, providerBaseUrl, token, prompt, timeoutMs }) {
+  return new Promise((resolve) => {
+    const started = Date.now();
+    const env = {
+      ...process.env,
+      CODEX_HOME: codexHome(),
+      MYTE_CODY_AUTH_TOKEN: token,
+      MYTE_CODY_BRAND: "1",
+      MYTE_CODY_CONTROLLER: "0",
+      MYTE_CODY_BRIDGE_BASE_URL: providerBaseUrl,
+    };
+    const launchArgs = [...command.args, ...codexLaunchArgs(["exec", "--json", "-"], args, providerBaseUrl)];
+    const child = spawn(command.cmd, launchArgs, {
+      cwd: process.cwd(),
+      env,
+      stdio: ["pipe", "pipe", "pipe"],
+      shell: process.platform === "win32" && command.cmd === "codex",
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      try {
+        child.kill();
+      } catch {}
+    }, timeoutMs || 180000);
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (error) => {
+      settled = true;
+      clearTimeout(timer);
+      resolve({
+        status: 1,
+        stdout,
+        stderr,
+        error: error.message || String(error),
+        durationMs: Date.now() - started,
+      });
+    });
+    child.on("exit", (code, signal) => {
+      settled = true;
+      clearTimeout(timer);
+      resolve({
+        status: code == null ? 1 : code,
+        signal: signal || null,
+        stdout,
+        stderr,
+        error: null,
+        durationMs: Date.now() - started,
+      });
+    });
+    child.stdin.end(prompt);
+  });
+}
+
 async function runCodex(rawArgs, args = {}, envPath = null) {
   const token = getAuthToken();
   if (!token) {
@@ -1059,7 +1237,48 @@ async function runCodex(rawArgs, args = {}, envPath = null) {
     return 1;
   }
 
-  const launchArgs = [...command.args, ...codexLaunchArgs(rawArgs, args, bridge.baseUrl)];
+  const normalizedRawArgs = rawArgs[0] === "exec" ? ["exec", ...stripControllerArgs(rawArgs.slice(1)).args] : rawArgs;
+  const controllerState = rawArgs[0] === "exec" ? stripControllerArgs(rawArgs.slice(1)) : { enabled: false, args: [] };
+  if (rawArgs[0] === "exec" && controllerState.enabled) {
+    try {
+      progress("opening MyteCody controller");
+      const signedController = loadSignedController();
+      const promptInfo = controllerPromptFromExecArgs(controllerState.args);
+      if (!promptInfo.prompt.trim()) {
+        await splash.stop();
+        await bridge.close();
+        console.error("MyteCody controller exec requires a prompt or stdin via exec -.");
+        return 1;
+      }
+      await splash.stop();
+      if (packageNotice) statusLine(packageNotice);
+      const summary = await signedController.runMyteCodyController({
+        prompt: promptInfo.prompt,
+        workspace: process.cwd(),
+        artifactRoot: path.join(installRoot(), "controller-runs"),
+        runWorker: (workerPrompt, workerOptions = {}) =>
+          runEngineExecWorker({
+            command,
+            args,
+            providerBaseUrl: bridge.baseUrl,
+            token,
+            prompt: workerPrompt,
+            timeoutMs: workerOptions.timeoutMs || 180000,
+          }),
+      });
+      console.error(`[MYTE CODY] controller run: ${summary.artifact_dir}`);
+      console.error(`[MYTE CODY] controller status: ${summary.status}`);
+      await bridge.close();
+      return summary.status === "pass" ? 0 : 1;
+    } catch (error) {
+      await splash.stop();
+      await bridge.close();
+      console.error(`MyteCody controller failed: ${error && error.message ? error.message : error}`);
+      return 1;
+    }
+  }
+
+  const launchArgs = [...command.args, ...codexLaunchArgs(normalizedRawArgs, args, bridge.baseUrl)];
   const env = {
     ...process.env,
     CODEX_HOME: codexHome(),
@@ -1098,7 +1317,10 @@ async function runDoctor(args, envPath) {
     payload.gateway.probe = await probeGateway(args);
   }
   payload.ready_for_coding =
-    payload.auth.present && payload.release.client_installed && payload.release.bridge_installed;
+    payload.auth.present &&
+    payload.release.client_installed &&
+    payload.release.bridge_installed &&
+    payload.release.controller_installed;
   if (payload.gateway.probe) {
     payload.ready_for_coding = Boolean(payload.ready_for_coding && payload.gateway.probe.ok);
   }
@@ -1226,9 +1448,31 @@ async function ensureBrandedEngineInstalled(args = {}, envPath = null, { progres
   delete updateArgs.json;
 
   const source = manifestUrl(updateArgs);
-  const manifestResult = await readManifest(source, { fetchManifest: true, progress });
+  let manifestResult;
+  try {
+    manifestResult = await readManifest(source, { fetchManifest: true, progress });
+  } catch (error) {
+    if (isUrl(source) && installedClientUsable()) {
+      return {
+        ok: true,
+        installed: false,
+        reason: "cached-engine-manifest-unavailable",
+        manifest_status: "fetch-failed",
+        error: error && error.message ? error.message : String(error),
+      };
+    }
+    throw error;
+  }
   const manifest = manifestResult.manifest;
   if (!manifest) {
+    if (isUrl(source) && installedClientUsable()) {
+      return {
+        ok: true,
+        installed: false,
+        reason: "cached-engine-manifest-unavailable",
+        manifest_status: manifestResult.status,
+      };
+    }
     return { ok: false, installed: false, reason: "manifest-unavailable", manifest_status: manifestResult.status };
   }
   const signature = signatureAccepted(manifest, updateArgs);
@@ -1330,6 +1574,7 @@ module.exports = {
   codyInferenceBase,
   codyGatewayUrl,
   currentBridgePath,
+  currentControllerPath,
   currentClientManifestPath,
   currentEnginePath,
   ensureBrandedEngineInstalled,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mytegroupinc/myte-core",
-  "version": "0.0.39",
+  "version": "0.0.41",
   "description": "Myte CLI core implementation.",
   "type": "commonjs",
   "main": "cli.js",