@mytegroupinc/myte-core 0.0.37 → 0.0.39

package/mytecody-cli.js

@@ -151,13 +151,21 @@ function installRoot() {
   return path.join(os.homedir(), ".myte", "cody");
 }
 
+function currentInstallRoot() {
+  return path.join(installRoot(), "current");
+}
+
 function currentClientManifestPath() {
-  return path.join(installRoot(), "current", "manifest.json");
+  return path.join(currentInstallRoot(), "manifest.json");
 }
 
 function currentEnginePath() {
   const executable = process.platform === "win32" ? "mytecody-engine.exe" : "mytecody-engine";
-  return path.join(installRoot(), "current", "bin", executable);
+  return path.join(currentInstallRoot(), "bin", executable);
+}
+
+function currentBridgePath() {
+  return path.join(currentInstallRoot(), "lib", "mytecody-async-responses-bridge.js");
 }
 
 function codexHome() {
@@ -184,6 +192,96 @@ function installedClientCommand() {
   return { cmd: enginePath, args: [], source: "myte-installed-engine" };
 }
 
+function loadSignedBridge() {
+  const bridgePath = currentBridgePath();
+  if (!fs.existsSync(bridgePath)) {
+    throw new Error("signed MyteCody inference bridge asset is missing; run `mytecody update`.");
+  }
+  const bridge = require(bridgePath);
+  if (!bridge || typeof bridge.startMyteCodyAsyncResponsesBridge !== "function") {
+    throw new Error("signed MyteCody inference bridge asset is invalid.");
+  }
+  return bridge;
+}
+
+function releaseAssetsForPlatform(manifest, artifact) {
+  const assets = [];
+  const collect = (value, source) => {
+    if (!value) return;
+    if (Array.isArray(value)) {
+      value.forEach((item, index) => {
+        if (item && typeof item === "object") {
+          assets.push({ ...item, source, index });
+        }
+      });
+      return;
+    }
+    if (typeof value === "object") {
+      Object.entries(value).forEach(([name, item], index) => {
+        if (item && typeof item === "object") {
+          assets.push({ name: item.name || name, ...item, source, index });
+        }
+      });
+    }
+  };
+
+  collect(manifest && manifest.client_assets, "manifest.client_assets");
+  collect(artifact && artifact.assets, "artifact.assets");
+
+  return assets
+    .map((asset) => ({
+      ...asset,
+      install_path: asset.install_path || asset.path || "",
+    }))
+    .filter((asset) => asset && asset.url && asset.sha256 && asset.install_path);
+}
+
+function assertSafeReleaseAssetInstallPath(installPath) {
+  const raw = String(installPath || "").replace(/\\/g, "/").trim();
+  if (!raw) throw new Error("release asset install_path is required");
+  if (path.isAbsolute(raw) || /^[A-Za-z]:/.test(raw)) {
+    throw new Error(`release asset install_path must be relative: ${installPath}`);
+  }
+  const parts = raw.split("/").filter(Boolean);
+  if (!parts.length || parts.includes("..")) {
+    throw new Error(`release asset install_path is unsafe: ${installPath}`);
+  }
+  return path.join(currentInstallRoot(), ...parts);
+}
+
+function currentReleaseAssetRecordByPath(current) {
+  const map = new Map();
+  for (const asset of Array.isArray(current && current.assets) ? current.assets : []) {
+    if (asset && asset.install_path) {
+      map.set(String(asset.install_path).replace(/\\/g, "/"), asset);
+    }
+  }
+  return map;
+}
+
+function installedReleaseAssetsMatchManifest(manifest, artifact) {
+  const assets = releaseAssetsForPlatform(manifest, artifact);
+  if (!assets.length) return true;
+  const current = readCurrentClientManifest();
+  const currentAssets = currentReleaseAssetRecordByPath(current);
+
+  for (const asset of assets) {
+    const installPath = String(asset.install_path || "").replace(/\\/g, "/");
+    const currentAsset = currentAssets.get(installPath);
+    if (!currentAsset) return false;
+    if (String(currentAsset.sha256 || "").toLowerCase() !== String(asset.sha256 || "").toLowerCase()) {
+      return false;
+    }
+    const targetPath = assertSafeReleaseAssetInstallPath(asset.install_path);
+    if (!fs.existsSync(targetPath)) return false;
+    const installedSha = sha256Hex(fs.readFileSync(targetPath));
+    if (installedSha.toLowerCase() !== String(asset.installed_sha256 || asset.sha256).toLowerCase()) {
+      return false;
+    }
+  }
+  return true;
+}
+
 function installedClientMatchesManifest(manifest, artifact) {
   const current = readCurrentClientManifest();
   if (!current || !installedClientCommand()) return false;
@@ -204,6 +302,8 @@ function installedClientMatchesManifest(manifest, artifact) {
     }
   }
 
+  if (!installedReleaseAssetsMatchManifest(manifest, artifact)) return false;
+
   return true;
 }
 
@@ -249,6 +349,7 @@ function commonStatus(args, envPath) {
     gateway: {
       base_url: gatewayBase(args),
       inference_base_url: codyInferenceBase(args),
+      responses_transport: "async-job-bridge",
       network_required_for_coding: true,
     },
     instruction_pack: {
@@ -267,8 +368,10 @@ function commonStatus(args, envPath) {
       platform: platformKey(),
       install_root: installRoot(),
       engine_path: currentEnginePath(),
+      bridge_path: currentBridgePath(),
       client_manifest: currentClientManifestPath(),
       client_installed: Boolean(current && installedClientCommand()),
+      bridge_installed: fs.existsSync(currentBridgePath()),
       client_version: current && current.version ? current.version : null,
     },
   };
@@ -513,11 +616,11 @@ function localPathFromArtifactUrl(urlValue) {
   return null;
 }
 
-async function readArtifactBytes(artifact, { progress } = {}) {
+async function readArtifactBytes(artifact, { progress, label = "MyteCody engine" } = {}) {
   const urlValue = artifact && artifact.url ? String(artifact.url) : "";
   const localPath = localPathFromArtifactUrl(urlValue);
   if (localPath) {
-    if (progress) progress("reading local MyteCody engine artifact");
+    if (progress) progress(`reading local ${label} artifact`);
     return fs.readFileSync(localPath);
   }
   const headers = {};
@@ -525,7 +628,7 @@ async function readArtifactBytes(artifact, { progress } = {}) {
   if (token) headers.Authorization = `Bearer ${token}`;
   if (progress) {
     const expectedSize = Number(artifact && artifact.size_bytes ? artifact.size_bytes : 0);
-    progress(`downloading MyteCody engine (${formatBytes(expectedSize)})`);
+    progress(`downloading ${label} (${formatBytes(expectedSize)})`);
   }
   const response = await fetch(urlValue, { method: "GET", headers });
   if (!response.ok) {
@@ -534,7 +637,7 @@ async function readArtifactBytes(artifact, { progress } = {}) {
   }
   if (!response.body || typeof response.body.getReader !== "function") {
     const bytes = Buffer.from(await response.arrayBuffer());
-    if (progress) progress(`downloaded MyteCody engine (${formatBytes(bytes.length)})`);
+    if (progress) progress(`downloaded ${label} (${formatBytes(bytes.length)})`);
     return bytes;
   }
 
@@ -552,13 +655,13 @@ async function readArtifactBytes(artifact, { progress } = {}) {
     if (progress && total > 0) {
       const pct = Math.min(100, Math.floor((received / total) * 100));
       if (pct >= lastPct + 10 || pct === 100) {
-        progress(`downloading MyteCody engine ${pct}% (${formatBytes(received)} / ${formatBytes(total)})`);
+        progress(`downloading ${label} ${pct}% (${formatBytes(received)} / ${formatBytes(total)})`);
         lastPct = pct;
       }
     }
   }
   const bytes = Buffer.concat(chunks);
-  if (progress) progress(`downloaded MyteCody engine (${formatBytes(bytes.length)})`);
+  if (progress) progress(`downloaded ${label} (${formatBytes(bytes.length)})`);
   return bytes;
 }
 
@@ -617,6 +720,34 @@ function installArtifactBytes(bytes, manifest, artifact) {
   return installedManifest;
 }
 
+async function installReleaseAssets(manifest, artifact, { progress } = {}) {
+  const assets = releaseAssetsForPlatform(manifest, artifact);
+  const installed = [];
+  for (const asset of assets) {
+    const name = String(asset.name || path.basename(String(asset.install_path || "")) || "client asset");
+    const bytes = await readArtifactBytes(asset, { progress, label: `MyteCody ${name}` });
+    const digest = sha256Hex(bytes);
+    if (digest.toLowerCase() !== String(asset.sha256 || "").toLowerCase()) {
+      throw new Error(`Release asset SHA-256 mismatch for ${name}: expected ${asset.sha256}, got ${digest}`);
+    }
+    const installBytes = artifactBytesForInstall(bytes, asset);
+    const targetPath = assertSafeReleaseAssetInstallPath(asset.install_path);
+    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+    fs.writeFileSync(targetPath, installBytes);
+    installed.push({
+      name,
+      install_path: String(asset.install_path || "").replace(/\\/g, "/"),
+      url: asset.url,
+      sha256: asset.sha256,
+      format: artifactFormat(asset),
+      size_bytes: bytes.length,
+      installed_sha256: sha256Hex(installBytes),
+      installed_size_bytes: installBytes.length,
+    });
+  }
+  return installed;
+}
+
 async function fetchJson(url, { headers = {}, timeoutMs = 8000 } = {}) {
   const controller = typeof AbortController !== "undefined" ? new AbortController() : undefined;
   const timeoutId =
@@ -765,7 +896,7 @@ function writeCodexModelCatalog() {
   return catalogPath;
 }
 
-function writeCodexConfig(args = {}) {
+function writeCodexConfig(args = {}, providerBaseUrl = codyInferenceBase(args)) {
   fs.mkdirSync(codexHome(), { recursive: true });
   const catalogPath = writeCodexModelCatalog();
   const config = `model = ${tomlString(DEFAULT_MODEL_ALIAS)}
@@ -786,7 +917,7 @@ terminal_title = ["project"]
 
 [model_providers.myte_ai]
 name = "Myte AI"
-base_url = ${tomlString(codyInferenceBase(args))}
+base_url = ${tomlString(providerBaseUrl)}
 env_key = "MYTE_CODY_AUTH_TOKEN"
 wire_api = "responses"
 requires_openai_auth = false
@@ -826,14 +957,14 @@ function resolveCodexCommand() {
   return null;
 }
 
-function codexProviderArgs(args = {}) {
+function codexProviderArgs(args = {}, providerBaseUrl = codyInferenceBase(args)) {
   return [
     "-c",
     'model_provider="myte_ai"',
     "-c",
     'model_providers.myte_ai.name="Myte AI"',
     "-c",
-    `model_providers.myte_ai.base_url="${codyInferenceBase(args)}"`,
+    `model_providers.myte_ai.base_url="${providerBaseUrl}"`,
     "-c",
     'model_providers.myte_ai.env_key="MYTE_CODY_AUTH_TOKEN"',
     "-c",
@@ -863,8 +994,8 @@ function codexProviderArgs(args = {}) {
   ];
 }
 
-function codexLaunchArgs(rawArgs, args = {}) {
-  const providerArgs = codexProviderArgs(args);
+function codexLaunchArgs(rawArgs, args = {}, providerBaseUrl = codyInferenceBase(args)) {
+  const providerArgs = codexProviderArgs(args, providerBaseUrl);
   if (!rawArgs.length) return providerArgs;
   if (rawArgs[0] === "exec") return [...providerArgs, "exec", "--skip-git-repo-check", ...rawArgs.slice(1)];
   return [...providerArgs, ...rawArgs];
@@ -880,7 +1011,6 @@ async function runCodex(rawArgs, args = {}, envPath = null) {
   const progress = setupProgress(splash);
   splash.start("preparing trusted workspace");
   progress("preparing trusted workspace");
-  writeCodexConfig(args);
   try {
     const install = await ensureBrandedEngineInstalled(args, envPath, { progress });
     if (install.ok && install.installed) {
@@ -914,12 +1044,28 @@ async function runCodex(rawArgs, args = {}, envPath = null) {
     console.error("Run `mytecody update` with access to the Myte release manifest.");
     return 1;
   }
-  const launchArgs = [...command.args, ...codexLaunchArgs(rawArgs, args)];
+  let bridge = null;
+  try {
+    progress("opening Myte inference bridge");
+    const signedBridge = loadSignedBridge();
+    bridge = await signedBridge.startMyteCodyAsyncResponsesBridge({
+      gatewayRoot: gatewayRoot(args),
+      token,
+    });
+    writeCodexConfig(args, bridge.baseUrl);
+  } catch (error) {
+    await splash.stop();
+    console.error(`MyteCody inference bridge failed to start: ${error && error.message ? error.message : error}`);
+    return 1;
+  }
+
+  const launchArgs = [...command.args, ...codexLaunchArgs(rawArgs, args, bridge.baseUrl)];
   const env = {
     ...process.env,
     CODEX_HOME: codexHome(),
     MYTE_CODY_AUTH_TOKEN: token,
     MYTE_CODY_BRAND: "1",
+    MYTE_CODY_BRIDGE_BASE_URL: bridge.baseUrl,
   };
   progress("opening MyteCody workspace");
   await splash.stop();
@@ -933,9 +1079,11 @@ async function runCodex(rawArgs, args = {}, envPath = null) {
     });
     child.on("error", (error) => {
       console.error(`Unable to launch MyteCody engine: ${error.message || error}`);
-      resolve(1);
+      bridge.close().finally(() => resolve(1));
+    });
+    child.on("close", (code) => {
+      bridge.close().finally(() => resolve(Number.isInteger(code) ? code : 1));
     });
-    child.on("close", (code) => resolve(Number.isInteger(code) ? code : 1));
   });
 }
 
@@ -949,7 +1097,8 @@ async function runDoctor(args, envPath) {
   if (args["probe-gateway"]) {
     payload.gateway.probe = await probeGateway(args);
   }
-  payload.ready_for_coding = payload.auth.present && payload.release.client_installed;
+  payload.ready_for_coding =
+    payload.auth.present && payload.release.client_installed && payload.release.bridge_installed;
   if (payload.gateway.probe) {
     payload.ready_for_coding = Boolean(payload.ready_for_coding && payload.gateway.probe.ok);
   }
@@ -978,6 +1127,7 @@ async function runDoctor(args, envPath) {
     console.log(`package update: ${payload.package.check_status}`);
   }
   console.log(`client:     ${payload.release.client_installed ? payload.release.client_version : "not installed"}`);
+  console.log(`bridge:     ${payload.release.bridge_installed ? "installed" : "not installed"}`);
   console.log(`install:    ${payload.release.install_root}`);
   console.log("");
   console.log("Coding requires the Myte AI gateway and a Myte AI key.");
@@ -995,6 +1145,7 @@ async function buildUpdatePayload(args, envPath, { dryRun = false, progress = nu
   const artifact = manifest ? artifactForPlatform(manifest) : null;
   const signature = manifest ? signatureAccepted(manifest, args) : { ok: false, signature: { status: "not-checked", verified: false } };
   const artifactMetadata = manifest ? validateArtifactMetadata(artifact) : { status: "not-checked", ok: false };
+  const releaseAssets = manifest ? releaseAssetsForPlatform(manifest, artifact) : [];
   const payload = {
     ok: true,
     dry_run: isDryRun,
@@ -1008,6 +1159,13 @@ async function buildUpdatePayload(args, envPath, { dryRun = false, progress = nu
       trusted_unsigned: Boolean(signature.trusted_unsigned),
     },
     artifact: artifactMetadata,
+    release_assets: releaseAssets.map((asset) => ({
+      name: asset.name || null,
+      install_path: asset.install_path,
+      url: asset.url || null,
+      format: asset.format || null,
+      sha256_present: Boolean(asset.sha256),
+    })),
   };
 
   if (!isDryRun) {
@@ -1026,6 +1184,11 @@ async function buildUpdatePayload(args, envPath, { dryRun = false, progress = nu
       throw new Error(`Artifact SHA-256 mismatch: expected ${artifact.sha256}, got ${digest}`);
     }
     const installed = installArtifactBytes(bytes, manifest, artifact);
+    const installedAssets = await installReleaseAssets(manifest, artifact, { progress });
+    if (installedAssets.length) {
+      installed.assets = installedAssets;
+      fs.writeFileSync(currentClientManifestPath(), JSON.stringify(installed, null, 2), "utf8");
+    }
     payload.installed = {
       ok: true,
       version: installed.version,
@@ -1035,6 +1198,7 @@ async function buildUpdatePayload(args, envPath, { dryRun = false, progress = nu
       installed_sha256: installed.artifact.installed_sha256,
       installed_size_bytes: installed.artifact.installed_size_bytes,
       format: installed.artifact.format,
+      assets: installedAssets,
     };
     payload.release = {
       ...payload.release,
@@ -1165,6 +1329,7 @@ module.exports = {
   codexProviderArgs,
   codyInferenceBase,
   codyGatewayUrl,
+  currentBridgePath,
   currentClientManifestPath,
   currentEnginePath,
   ensureBrandedEngineInstalled,

package/package.json

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