@mytegroupinc/myte-core 0.0.40 → 0.0.42

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");
 }
@@ -193,7 +197,12 @@ function installedClientCommand() {
 }
 
 function installedClientUsable() {
-  return Boolean(installedClientCommand() && fs.existsSync(currentBridgePath()) && readCurrentClientManifest());
+  return Boolean(
+    installedClientCommand() &&
+      fs.existsSync(currentBridgePath()) &&
+      fs.existsSync(currentControllerPath()) &&
+      readCurrentClientManifest(),
+  );
 }
 
 function loadSignedBridge() {
@@ -208,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) => {
@@ -373,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,
     },
   };
@@ -724,6 +747,63 @@ function installArtifactBytes(bytes, manifest, artifact) {
   return installedManifest;
 }
 
+function reusableInstalledArtifact(artifact) {
+  const enginePath = currentEnginePath();
+  const current = readCurrentClientManifest();
+  if (!current || !fs.existsSync(enginePath)) return null;
+
+  const currentArtifact = current.artifact || {};
+  if (artifact && artifact.sha256) {
+    if (String(currentArtifact.sha256 || "").toLowerCase() !== String(artifact.sha256 || "").toLowerCase()) {
+      return null;
+    }
+  }
+
+  const engineBytes = fs.readFileSync(enginePath);
+  const installedSha = sha256Hex(engineBytes);
+  const expectedInstalledSha =
+    artifact && (artifact.installed_sha256 || artifact.executable_sha256 || artifact.uncompressed_sha256);
+  if (expectedInstalledSha && installedSha.toLowerCase() !== String(expectedInstalledSha).toLowerCase()) {
+    return null;
+  }
+  if (
+    currentArtifact.installed_sha256 &&
+    installedSha.toLowerCase() !== String(currentArtifact.installed_sha256).toLowerCase()
+  ) {
+    return null;
+  }
+
+  return {
+    enginePath,
+    engineBytes,
+    artifactSizeBytes: Number(currentArtifact.size_bytes || artifact?.size_bytes || 0),
+    installedSha,
+  };
+}
+
+function installManifestForReusableArtifact(reusable, manifest, artifact) {
+  const installedManifest = {
+    schema_version: manifest.schema_version || 1,
+    channel: manifest.channel || DEFAULT_CHANNEL,
+    version: manifest.version || "unknown",
+    installed_at: new Date().toISOString(),
+    launcher_version: PACKAGE_VERSION,
+    platform: platformKey(),
+    executable: reusable.enginePath,
+    artifact: {
+      url: artifact.url,
+      sha256: artifact.sha256,
+      format: artifactFormat(artifact),
+      size_bytes: reusable.artifactSizeBytes,
+      installed_sha256: reusable.installedSha,
+      installed_size_bytes: reusable.engineBytes.length,
+    },
+  };
+  fs.mkdirSync(path.dirname(currentClientManifestPath()), { recursive: true });
+  fs.writeFileSync(currentClientManifestPath(), JSON.stringify(installedManifest, null, 2), "utf8");
+  return installedManifest;
+}
+
 async function installReleaseAssets(manifest, artifact, { progress } = {}) {
   const assets = releaseAssetsForPlatform(manifest, artifact);
   const installed = [];
@@ -1005,6 +1085,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) {
@@ -1063,7 +1294,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(),
@@ -1102,7 +1374,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);
   }
@@ -1182,12 +1457,23 @@ async function buildUpdatePayload(args, envPath, { dryRun = false, progress = nu
     if (!artifactMetadata.ok) {
       throw new Error(`MyteCody release artifact metadata is ${artifactMetadata.status}.`);
     }
-    const bytes = await readArtifactBytes(artifact, { progress });
-    const digest = sha256Hex(bytes);
-    if (digest.toLowerCase() !== String(artifact.sha256 || "").toLowerCase()) {
-      throw new Error(`Artifact SHA-256 mismatch: expected ${artifact.sha256}, got ${digest}`);
+    let installed;
+    let artifactDigest = String(artifact.sha256 || "");
+    let artifactSizeBytes = Number(artifact.size_bytes || 0);
+    const reusable = reusableInstalledArtifact(artifact);
+    if (reusable) {
+      if (progress) progress("reusing installed MyteCody engine");
+      installed = installManifestForReusableArtifact(reusable, manifest, artifact);
+      artifactSizeBytes = reusable.artifactSizeBytes;
+    } else {
+      const bytes = await readArtifactBytes(artifact, { progress });
+      artifactDigest = sha256Hex(bytes);
+      artifactSizeBytes = bytes.length;
+      if (artifactDigest.toLowerCase() !== String(artifact.sha256 || "").toLowerCase()) {
+        throw new Error(`Artifact SHA-256 mismatch: expected ${artifact.sha256}, got ${artifactDigest}`);
+      }
+      installed = installArtifactBytes(bytes, manifest, artifact);
     }
-    const installed = installArtifactBytes(bytes, manifest, artifact);
     const installedAssets = await installReleaseAssets(manifest, artifact, { progress });
     if (installedAssets.length) {
       installed.assets = installedAssets;
@@ -1197,8 +1483,8 @@ async function buildUpdatePayload(args, envPath, { dryRun = false, progress = nu
       ok: true,
       version: installed.version,
       executable: installed.executable,
-      sha256: digest,
-      size_bytes: bytes.length,
+      sha256: artifactDigest,
+      size_bytes: artifactSizeBytes,
       installed_sha256: installed.artifact.installed_sha256,
       installed_size_bytes: installed.artifact.installed_size_bytes,
       format: installed.artifact.format,
@@ -1356,6 +1642,7 @@ module.exports = {
   codyInferenceBase,
   codyGatewayUrl,
   currentBridgePath,
+  currentControllerPath,
   currentClientManifestPath,
   currentEnginePath,
   ensureBrandedEngineInstalled,

package/package.json

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