@mytegroupinc/myte-core 0.0.41 → 0.0.43

package/README.md

@@ -31,7 +31,9 @@ This package exists so the public wrapper can stay small and versioned cleanly.
   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`.
+  gateway, and `MYTEAI_API_KEY`. Normal coding runs use the branded Codex
+  harness with Myte context hardening; the experimental controller is not the
+  default product path.
 - `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

package/lib/mytecody-splash.js

@@ -1,7 +1,7 @@
 "use strict";
 
 const FRAME_MS = 48;
-const MIN_MS = 850;
+const MIN_MS = 3000;
 const FRAMES = 32;
 const WIDTH = 84;
 const HEIGHT = 64;
@@ -225,12 +225,12 @@ function createMyteSplash() {
 
   async function stop() {
     if (!enabled) return;
+    const remaining = Math.max(0, MIN_MS - (Date.now() - started));
+    if (remaining) await new Promise((resolve) => setTimeout(resolve, remaining));
     if (timer) {
       clearInterval(timer);
       timer = null;
     }
-    const remaining = Math.max(0, MIN_MS - (Date.now() - started));
-    if (remaining) await new Promise((resolve) => setTimeout(resolve, remaining));
     if (rendered) process.stdout.write(`\x1b[${lineCount}F\x1b[J`);
     process.stdout.write("\x1b[?25h");
     rendered = false;

package/mytecody-cli.js

@@ -7,6 +7,7 @@ const path = require("path");
 const crypto = require("crypto");
 const zlib = require("zlib");
 const { spawn } = require("child_process");
+const readline = require("readline");
 const {
   DEFAULT_MYTEAI_BASE,
   normalizeMyteAiBase,
@@ -229,6 +230,55 @@ function loadSignedController() {
   return controller;
 }
 
+function controllerRunsRoot() {
+  return path.join(installRoot(), "controller-runs");
+}
+
+function readJsonFileIfPresent(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function listControllerRunRecords() {
+  const root = controllerRunsRoot();
+  if (!fs.existsSync(root)) return [];
+  const records = [];
+  for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const runPath = path.join(root, entry.name, "run.json");
+    const run = readJsonFileIfPresent(runPath);
+    if (!run || !run.run_id) continue;
+    let mtimeMs = 0;
+    try {
+      mtimeMs = fs.statSync(runPath).mtimeMs;
+    } catch {}
+    records.push({
+      run_id: run.run_id,
+      workspace_root: run.workspace_root || process.cwd(),
+      status: run.status || "unknown",
+      path: runPath,
+      mtimeMs,
+    });
+  }
+  return records.sort((a, b) => b.mtimeMs - a.mtimeMs);
+}
+
+function resolveControllerRunTarget(target = "latest") {
+  const records = listControllerRunRecords();
+  if (!records.length) return null;
+  const wanted = String(target || "latest");
+  if (wanted === "latest") return records[0];
+  const exact = records.find((record) => record.run_id === wanted);
+  if (exact) return exact;
+  const prefixed = records.filter((record) => record.run_id.startsWith(wanted));
+  if (prefixed.length === 1) return prefixed[0];
+  if (prefixed.length > 1) throw new Error(`CodyRun prefix is ambiguous: ${wanted}`);
+  return null;
+}
+
 function releaseAssetsForPlatform(manifest, artifact) {
   const assets = [];
   const collect = (value, source) => {
@@ -337,12 +387,23 @@ function printHelp() {
 
 Usage:
   mytecody
+  mytecody [prompt...]
   mytecody doctor [--json] [--base-url <url>] [--probe-gateway]
   mytecody exec [prompt or agent exec args...]
+  mytecody resume [codex-session-id|latest]
+  mytecody controller-resume [controller-run-id|latest]
+  mytecody codex [raw engine args...]
   mytecody update --dry-run [--json] [--manifest <url-or-file>] [--fetch-manifest]
   mytecody update [--json] [--manifest <url-or-file>]
   mytecody help
 
+Defaults:
+  mytecody opens the branded Codex harness with Myte context hardening.
+  Non-command prompt args are forwarded to the branded engine, not the experimental controller.
+  Use --controller on exec or controller-shell for temporary controller diagnostics.
+  Use mytecody controller-shell only for temporary controller-shell diagnostics.
+  Use mytecody codex only for raw engine diagnostics.
+
 Updates:
   mytecody update              updates the signed MyteCody engine only
   npm install -g myte@latest   updates this npm launcher and Myte API tools
@@ -747,6 +808,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 = [];
@@ -1082,12 +1200,13 @@ function execArgsAndStdin(rawArgs) {
 
 function stripControllerArgs(rawArgs) {
   const kept = [];
-  let enabled = process.env.MYTE_CODY_CONTROLLER !== "0";
+  let enabled = process.env.MYTE_CODY_CONTROLLER === "1";
   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("-")) {
+      const normalizedNext = String(next || "").toLowerCase();
+      if (next !== undefined && !next.startsWith("-") && ["0", "1", "false", "true", "off", "on", "raw"].includes(normalizedNext)) {
         enabled = !["0", "false", "off", "raw"].includes(String(next).toLowerCase());
         i += 1;
       } else {
@@ -1119,6 +1238,24 @@ function controllerPromptFromExecArgs(rawArgs) {
   return { prompt, forwardedArgs: execInput.args.slice(0, -1) };
 }
 
+function classifyMyteCodyInvocation(rawArgs = []) {
+  const args = Array.isArray(rawArgs) ? rawArgs : [];
+  if (!args.length) return { mode: "raw-codex", args: [], controller: false };
+
+  const command = args[0];
+  if (command === "codex") return { mode: "raw-codex", args: args.slice(1), controller: false };
+  if (command === "controller-shell") return { mode: "controller-shell", args: args.slice(1) };
+  if (command === "controller-resume") return { mode: "controller-resume", args: args.slice(1) };
+  if (command === "resume") return { mode: "raw-codex", args, controller: false };
+  if (command === "exec") {
+    const controller = stripControllerArgs(args.slice(1));
+    if (controller.enabled) return { mode: "controller-exec", args: controller.args };
+    return { mode: "raw-codex", args: ["exec", ...controller.args] };
+  }
+  if (String(command || "").startsWith("-")) return { mode: "raw-codex", args };
+  return { mode: "raw-codex", args, controller: false };
+}
+
 function runEngineExecWorker({ command, args, providerBaseUrl, token, prompt, timeoutMs }) {
   return new Promise((resolve) => {
     const started = Date.now();
@@ -1179,6 +1316,242 @@ function runEngineExecWorker({ command, args, providerBaseUrl, token, prompt, ti
   });
 }
 
+async function runSignedControllerPrompt({ signedController, command, args, bridge, token, promptInfo }) {
+  if (!promptInfo.prompt.trim()) {
+    console.error("MyteCody controller requires a prompt.");
+    return 1;
+  }
+  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}`);
+  if (summary.status === "paused") {
+    console.error(`[MYTE CODY] resume: mytecody resume ${summary.run_id}`);
+  }
+  return ["pass", "paused", "completed"].includes(summary.status) ? 0 : 1;
+}
+
+async function runSignedControllerResume({ signedController, command, args, bridge, token, target }) {
+  if (!signedController || typeof signedController.resumeMyteCodyControllerRun !== "function") {
+    console.error("Installed MyteCody controller does not support resume; run `mytecody update`.");
+    return 1;
+  }
+  let record;
+  try {
+    record = resolveControllerRunTarget(target || "latest");
+  } catch (error) {
+    console.error(`[MYTE CODY] ${error && error.message ? error.message : error}`);
+    return 1;
+  }
+  if (!record) {
+    console.error(`[MYTE CODY] CodyRun not found: ${target || "latest"}`);
+    return 1;
+  }
+  const summary = await signedController.resumeMyteCodyControllerRun({
+    runId: record.run_id,
+    workspace: record.workspace_root || process.cwd(),
+    artifactRoot: controllerRunsRoot(),
+    runWorker: (workerPrompt, workerOptions = {}) =>
+      runEngineExecWorker({
+        command,
+        args,
+        providerBaseUrl: bridge.baseUrl,
+        token,
+        prompt: workerPrompt,
+        timeoutMs: workerOptions.timeoutMs || 180000,
+      }),
+  });
+  console.error(`[MYTE CODY] resumed CodyRun: ${summary.run_id}`);
+  console.error(`[MYTE CODY] controller status: ${summary.status}`);
+  if (summary.status === "paused") {
+    console.error(`[MYTE CODY] resume: mytecody resume ${summary.run_id}`);
+  }
+  return ["pass", "paused", "completed"].includes(summary.status) ? 0 : 1;
+}
+
+function isControllerShellExit(value) {
+  return ["/exit", "/quit", "exit", "quit"].includes(String(value || "").trim().toLowerCase());
+}
+
+function compactWorkspacePath(workspace = process.cwd()) {
+  const home = os.homedir();
+  const resolved = path.resolve(workspace);
+  if (resolved.toLowerCase().startsWith(home.toLowerCase())) {
+    return `~${resolved.slice(home.length)}`;
+  }
+  return resolved;
+}
+
+function fitCell(value, width) {
+  const text = String(value || "");
+  if (text.length <= width) return `${text}${" ".repeat(width - text.length)}`;
+  return `${text.slice(0, Math.max(0, width - 1))}…`;
+}
+
+function printControllerShellBanner() {
+  const width = 70;
+  const lines = [
+    "MYTE CODY - Your Tech Your Way",
+    `workspace: ${compactWorkspacePath()}`,
+    "mode:      sovereign coding agent - Myte AI gateway",
+    "enter a prompt, /resume latest, /diagnostics, /help, or /exit",
+  ];
+  console.log(`╭${"─".repeat(width)}╮`);
+  for (const line of lines) console.log(`│ ${fitCell(line, width - 2)} │`);
+  console.log(`╰${"─".repeat(width)}╯`);
+}
+
+function printControllerShellHelp() {
+  console.log("");
+  console.log("MYTE CODY commands");
+  console.log("/resume [run_id|latest]  Continue a paused CodyRun.");
+  console.log("/diagnostics             Open the raw engine diagnostics view.");
+  console.log("/exit                    Quit.");
+  console.log("");
+}
+
+async function runControllerShell({ signedController, command, args, bridge, token }) {
+  printControllerShellBanner();
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: "\n› ",
+  });
+  rl.prompt();
+  for await (const line of rl) {
+    const prompt = String(line || "").trim();
+    if (!prompt) {
+      rl.prompt();
+      continue;
+    }
+    if (isControllerShellExit(prompt)) break;
+    if (prompt === "/help") {
+      printControllerShellHelp();
+      rl.prompt();
+      continue;
+    }
+    if (prompt === "/diagnostics" || prompt === "/codex") {
+      rl.close();
+      return { rawCodexRequested: true };
+    }
+    if (prompt.startsWith("/resume")) {
+      const target = prompt.split(/\s+/).slice(1)[0] || "latest";
+      await runSignedControllerResume({
+        signedController,
+        command,
+        args,
+        bridge,
+        token,
+        target,
+      });
+      rl.prompt();
+      continue;
+    }
+    await runSignedControllerPrompt({
+      signedController,
+      command,
+      args,
+      bridge,
+      token,
+      promptInfo: { prompt, forwardedArgs: [] },
+    });
+    rl.prompt();
+  }
+  return { rawCodexRequested: false };
+}
+
+function emitSidecarEvent(event) {
+  process.stdout.write(`${JSON.stringify(event)}\n`);
+}
+
+async function runControllerSidecar() {
+  let request;
+  try {
+    const raw = fs.readFileSync(0, "utf8");
+    request = raw.trim() ? JSON.parse(raw) : {};
+  } catch (error) {
+    emitSidecarEvent({
+      type: "failed",
+      message: `Invalid MyteCody sidecar request: ${error && error.message ? error.message : error}`,
+    });
+    return 1;
+  }
+
+  const prompt = String(request.prompt || "").trim();
+  const workspace = path.resolve(request.workspace || process.cwd());
+  if (!prompt) {
+    emitSidecarEvent({ type: "failed", message: "MyteCody sidecar request did not include a prompt." });
+    return 1;
+  }
+
+  const token = process.env.MYTE_CODY_AUTH_TOKEN || getAuthToken();
+  const providerBaseUrl = process.env.MYTE_CODY_BRIDGE_BASE_URL;
+  const command = resolveCodexCommand();
+  if (!token || !providerBaseUrl || !command) {
+    emitSidecarEvent({
+      type: "failed",
+      message: "MyteCody sidecar is missing auth, bridge URL, or installed engine command.",
+    });
+    return 1;
+  }
+
+  emitSidecarEvent({
+    type: "started",
+    message: "MyteCody controller started.",
+    workspace,
+  });
+
+  try {
+    const signedController = loadSignedController();
+    const summary = await signedController.runMyteCodyController({
+      prompt,
+      workspace,
+      artifactRoot: process.env.MYTE_CODY_CONTROLLER_RUNS_DIR || controllerRunsRoot(),
+      mode: process.env.MYTE_CODY_CONTROLLER_MODE || "gateway",
+      runWorker: (workerPrompt, workerOptions = {}) =>
+        runEngineExecWorker({
+          command,
+          args: {},
+          providerBaseUrl,
+          token,
+          prompt: workerPrompt,
+          timeoutMs: workerOptions.timeoutMs || 180000,
+        }),
+    });
+    const resumeCommand = `mytecody resume ${summary.run_id}`;
+    emitSidecarEvent({
+      type: summary.status === "paused" ? "paused" : "completed",
+      run_id: summary.run_id,
+      status: summary.status,
+      artifact_dir: summary.artifact_dir,
+      resume: summary.status === "paused" ? resumeCommand : null,
+      message:
+        summary.status === "paused"
+          ? `MyteCody paused with a durable run state. Resume with: ${resumeCommand}`
+          : `MyteCody controller completed with status: ${summary.status}`,
+    });
+    return ["pass", "paused", "completed"].includes(summary.status) ? 0 : 1;
+  } catch (error) {
+    emitSidecarEvent({
+      type: "failed",
+      message: error && error.stack ? error.stack : error && error.message ? error.message : String(error),
+    });
+    return 1;
+  }
+}
+
 async function runCodex(rawArgs, args = {}, envPath = null) {
   const token = getAuthToken();
   if (!token) {
@@ -1237,39 +1610,82 @@ async function runCodex(rawArgs, args = {}, envPath = null) {
     return 1;
   }
 
-  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) {
+  const invocation = classifyMyteCodyInvocation(rawArgs);
+  if (["controller-exec", "controller-prompt", "controller-shell", "controller-resume"].includes(invocation.mode)) {
     try {
       progress("opening MyteCody controller");
       const signedController = loadSignedController();
-      const promptInfo = controllerPromptFromExecArgs(controllerState.args);
+      await splash.stop();
+      if (packageNotice) statusLine(packageNotice);
+
+      if (invocation.mode === "controller-resume") {
+        const code = await runSignedControllerResume({
+          signedController,
+          command,
+          args,
+          bridge,
+          token,
+          target: invocation.args[0] || "latest",
+        });
+        await bridge.close();
+        return code;
+      }
+
+      if (invocation.mode === "controller-shell") {
+        const shellResult = await runControllerShell({
+          signedController,
+          command,
+          args,
+          bridge,
+          token,
+        });
+        if (shellResult.rawCodexRequested) {
+          const rawArgs = [...command.args, ...codexLaunchArgs([], args, bridge.baseUrl)];
+          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: bridge.baseUrl,
+          };
+          return await new Promise((resolve) => {
+            const child = spawn(command.cmd, rawArgs, {
+              cwd: process.cwd(),
+              env,
+              stdio: "inherit",
+              shell: process.platform === "win32" && command.cmd === "codex",
+            });
+            child.on("error", (error) => {
+              console.error(`Unable to launch MyteCody engine: ${error.message || error}`);
+              bridge.close().finally(() => resolve(1));
+            });
+            child.on("close", (code) => {
+              bridge.close().finally(() => resolve(Number.isInteger(code) ? code : 1));
+            });
+          });
+        }
+        await bridge.close();
+        return 0;
+      }
+
+      const promptInfo = controllerPromptFromExecArgs(invocation.args);
       if (!promptInfo.prompt.trim()) {
         await splash.stop();
         await bridge.close();
-        console.error("MyteCody controller exec requires a prompt or stdin via exec -.");
+        console.error("MyteCody controller requires a prompt.");
         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,
-          }),
+      const code = await runSignedControllerPrompt({
+        signedController,
+        command,
+        args,
+        bridge,
+        token,
+        promptInfo,
       });
-      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;
+      return code;
     } catch (error) {
       await splash.stop();
       await bridge.close();
@@ -1278,12 +1694,17 @@ async function runCodex(rawArgs, args = {}, envPath = null) {
     }
   }
 
-  const launchArgs = [...command.args, ...codexLaunchArgs(normalizedRawArgs, args, bridge.baseUrl)];
+  const launchArgs = [...command.args, ...codexLaunchArgs(invocation.args, args, bridge.baseUrl)];
   const env = {
     ...process.env,
     CODEX_HOME: codexHome(),
     MYTE_CODY_AUTH_TOKEN: token,
     MYTE_CODY_BRAND: "1",
+    MYTE_CODY_CONTROLLER: invocation.controller === true ? "1" : "0",
+    MYTE_CODY_CONTROLLER_MODE: "gateway",
+    MYTE_CODY_CONTROLLER_NODE: process.execPath,
+    MYTE_CODY_CONTROLLER_ENTRY: __filename,
+    MYTE_CODY_CONTROLLER_RUNS_DIR: controllerRunsRoot(),
     MYTE_CODY_BRIDGE_BASE_URL: bridge.baseUrl,
   };
   progress("opening MyteCody workspace");
@@ -1319,8 +1740,7 @@ async function runDoctor(args, envPath) {
   payload.ready_for_coding =
     payload.auth.present &&
     payload.release.client_installed &&
-    payload.release.bridge_installed &&
-    payload.release.controller_installed;
+    payload.release.bridge_installed;
   if (payload.gateway.probe) {
     payload.ready_for_coding = Boolean(payload.ready_for_coding && payload.gateway.probe.ok);
   }
@@ -1400,12 +1820,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;
@@ -1415,8 +1846,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,
@@ -1545,6 +1976,7 @@ async function run(argv = process.argv.slice(2)) {
   }
   if (command === "doctor") return runDoctor(restArgs, envPath);
   if (command === "update") return runUpdate(restArgs, envPath);
+  if (command === "controller-sidecar") return runControllerSidecar();
   if (command === "version" || command === "--version" || command === "-v") {
     console.log(PACKAGE_VERSION);
     return 0;
@@ -1569,6 +2001,7 @@ if (require.main === module) {
 
 module.exports = {
   checkPackageUpdate,
+  classifyMyteCodyInvocation,
   codexLaunchArgs,
   codexProviderArgs,
   codyInferenceBase,

package/package.json

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