@mytegroupinc/myte-core 0.0.33 → 0.0.35

package/mytecody-cli.js

@@ -179,6 +179,29 @@ function installedClientCommand() {
   return { cmd: enginePath, args: [], source: "myte-installed-engine" };
 }
 
+function installedClientMatchesManifest(manifest, artifact) {
+  const current = readCurrentClientManifest();
+  if (!current || !installedClientCommand()) return false;
+  if (manifest && manifest.version && current.version !== manifest.version) return false;
+
+  const currentArtifact = current.artifact || {};
+  if (artifact && artifact.sha256) {
+    if (String(currentArtifact.sha256 || "").toLowerCase() !== String(artifact.sha256 || "").toLowerCase()) {
+      return false;
+    }
+  }
+
+  const expectedInstalledSha =
+    artifact && (artifact.installed_sha256 || artifact.executable_sha256 || artifact.uncompressed_sha256);
+  if (expectedInstalledSha) {
+    if (String(currentArtifact.installed_sha256 || "").toLowerCase() !== String(expectedInstalledSha).toLowerCase()) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
 function printHelp() {
   console.log(`MYTE CODY - Your Tech Your Way
 
@@ -239,12 +262,31 @@ function isUrl(value) {
   return /^https?:\/\//i.test(String(value || ""));
 }
 
-async function readManifest(source, { fetchManifest }) {
+function statusLine(message) {
+  if (process.env.MYTE_CODY_QUIET_SETUP === "1") return;
+  console.error(`[MYTE CODY] ${message}`);
+}
+
+function formatBytes(bytes) {
+  const value = Number(bytes || 0);
+  if (!Number.isFinite(value) || value <= 0) return "unknown size";
+  const units = ["B", "KB", "MB", "GB"];
+  let size = value;
+  let unit = 0;
+  while (size >= 1024 && unit < units.length - 1) {
+    size /= 1024;
+    unit += 1;
+  }
+  return `${size.toFixed(unit === 0 ? 0 : 1)} ${units[unit]}`;
+}
+
+async function readManifest(source, { fetchManifest, progress } = {}) {
   if (!source) return { status: "missing", manifest: null };
   if (isUrl(source)) {
     if (!fetchManifest) {
       return { status: "skipped", manifest: null };
     }
+    if (progress) progress("checking signed release manifest");
     const response = await fetch(source);
     const text = await response.text();
     if (!response.ok) {
@@ -344,20 +386,52 @@ function localPathFromArtifactUrl(urlValue) {
   return null;
 }
 
-async function readArtifactBytes(artifact) {
+async function readArtifactBytes(artifact, { progress } = {}) {
   const urlValue = artifact && artifact.url ? String(artifact.url) : "";
   const localPath = localPathFromArtifactUrl(urlValue);
   if (localPath) {
+    if (progress) progress("reading local MyteCody engine artifact");
     return fs.readFileSync(localPath);
   }
   const headers = {};
   const token = getAuthToken();
   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)})`);
+  }
   const response = await fetch(urlValue, { method: "GET", headers });
-  const bytes = Buffer.from(await response.arrayBuffer());
   if (!response.ok) {
+    const bytes = Buffer.from(await response.arrayBuffer());
     throw new Error(`Artifact fetch failed (${response.status}): ${bytes.toString("utf8", 0, Math.min(bytes.length, 300))}`);
   }
+  if (!response.body || typeof response.body.getReader !== "function") {
+    const bytes = Buffer.from(await response.arrayBuffer());
+    if (progress) progress(`downloaded MyteCody engine (${formatBytes(bytes.length)})`);
+    return bytes;
+  }
+
+  const total = Number(response.headers.get("content-length") || artifact?.size_bytes || 0);
+  const reader = response.body.getReader();
+  const chunks = [];
+  let received = 0;
+  let lastPct = -1;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    const chunk = Buffer.from(value);
+    chunks.push(chunk);
+    received += chunk.length;
+    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)})`);
+        lastPct = pct;
+      }
+    }
+  }
+  const bytes = Buffer.concat(chunks);
+  if (progress) progress(`downloaded MyteCody engine (${formatBytes(bytes.length)})`);
   return bytes;
 }
 
@@ -502,8 +576,16 @@ function tomlString(value) {
   return JSON.stringify(String(value || ""));
 }
 
+function tomlLiteralString(value) {
+  const text = String(value || "");
+  if (!text.includes("'") && !text.includes("\n") && !text.includes("\r")) {
+    return `'${text}'`;
+  }
+  return tomlString(text);
+}
+
 function pathForToml(value) {
-  return String(value || "").replace(/\\/g, "\\\\");
+  return String(value || "");
 }
 
 function writeCodexModelCatalog() {
@@ -574,7 +656,7 @@ function writeCodexConfig(args = {}) {
   const catalogPath = writeCodexModelCatalog();
   const config = `model = ${tomlString(DEFAULT_MODEL_ALIAS)}
 model_provider = "myte_ai"
-model_catalog_json = ${tomlString(pathForToml(catalogPath))}
+model_catalog_json = ${tomlString(catalogPath)}
 model_context_window = ${DEFAULT_CONTEXT_WINDOW}
 model_auto_compact_token_limit = ${DEFAULT_AUTO_COMPACT_TOKENS}
 tool_output_token_limit = ${DEFAULT_TOOL_OUTPUT_TOKENS}
@@ -613,7 +695,7 @@ include_instructions = true
 [skills.bundled]
 enabled = false
 
-[projects.${tomlString(pathForToml(process.cwd()))}]
+[projects.${tomlLiteralString(process.cwd())}]
 trust_level = "trusted"
 
 [windows]
@@ -643,7 +725,7 @@ function codexProviderArgs(args = {}) {
     "-c",
     'model_providers.myte_ai.wire_api="responses"',
     "-c",
-    `model_catalog_json="${pathForToml(codexModelCatalogPath())}"`,
+    `model_catalog_json=${tomlString(codexModelCatalogPath())}`,
     "-c",
     `model_context_window=${DEFAULT_CONTEXT_WINDOW}`,
     "-c",
@@ -680,30 +762,36 @@ async function runCodex(rawArgs, args = {}, envPath = null) {
     console.error("MyteCody requires MYTEAI_API_KEY for coding.");
     return 1;
   }
+  statusLine("preparing trusted workspace");
   writeCodexConfig(args);
-  let command = resolveCodexCommand();
-  if (!command) {
-    try {
-      console.error("MyteCody branded engine is not installed; installing the current Myte release...");
-      const install = await ensureBrandedEngineInstalled(args, envPath);
-      if (install.ok && install.installed) {
-        console.error(`MyteCody engine installed: ${install.payload.installed.version}`);
-      }
-    } catch (error) {
-      console.error(`MyteCody engine auto-install failed: ${error && error.message ? error.message : error}`);
-    }
-    command = resolveCodexCommand();
-    if (!command) {
-      console.error("MyteCody branded engine is not installed.");
+  try {
+    const install = await ensureBrandedEngineInstalled(args, envPath, { progress: statusLine });
+    if (install.ok && install.installed) {
+      statusLine(`engine installed: ${install.payload.installed.version}`);
+    } else if (install.ok) {
+      statusLine("engine ready");
+    } else if (!install.ok) {
+      console.error(`MyteCody branded engine could not be verified: ${install.reason || "unknown"}.`);
       console.error("Run `mytecody update` with access to the Myte release manifest.");
       return 1;
     }
+  } catch (error) {
+    console.error(`MyteCody engine verification failed: ${error && error.message ? error.message : error}`);
+    return 1;
+  }
+
+  const command = resolveCodexCommand();
+  if (!command) {
+    console.error("MyteCody branded engine is not installed.");
+    console.error("Run `mytecody update` with access to the Myte release manifest.");
+    return 1;
   }
   const launchArgs = [...command.args, ...codexLaunchArgs(rawArgs, args)];
   const env = {
     ...process.env,
     CODEX_HOME: codexHome(),
     MYTE_CODY_AUTH_TOKEN: token,
+    MYTE_CODY_BRAND: "1",
   };
   return new Promise((resolve) => {
     const child = spawn(command.cmd, launchArgs, {
@@ -753,10 +841,13 @@ async function runDoctor(args, envPath) {
   return 0;
 }
 
-async function buildUpdatePayload(args, envPath, { dryRun = false } = {}) {
+async function buildUpdatePayload(args, envPath, { dryRun = false, progress = null } = {}) {
   const isDryRun = Boolean(dryRun);
   const source = manifestUrl(args);
-  const manifestResult = await readManifest(source, { fetchManifest: Boolean(args["fetch-manifest"]) || !isDryRun });
+  const manifestResult = await readManifest(source, {
+    fetchManifest: Boolean(args["fetch-manifest"]) || !isDryRun,
+    progress,
+  });
   const manifest = manifestResult.manifest;
   const artifact = manifest ? artifactForPlatform(manifest) : null;
   const signature = manifest ? signatureAccepted(manifest, args) : { ok: false, signature: { status: "not-checked", verified: false } };
@@ -786,7 +877,7 @@ async function buildUpdatePayload(args, envPath, { dryRun = false } = {}) {
     if (!artifactMetadata.ok) {
       throw new Error(`MyteCody release artifact metadata is ${artifactMetadata.status}.`);
     }
-    const bytes = await readArtifactBytes(artifact);
+    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}`);
@@ -819,20 +910,38 @@ function autoInstallEnabled(args = {}) {
   return true;
 }
 
-async function ensureBrandedEngineInstalled(args = {}, envPath = null) {
-  if (installedClientCommand()) {
-    return { ok: true, installed: false, reason: "already-installed" };
-  }
-  if (!autoInstallEnabled(args)) {
-    return { ok: false, installed: false, reason: "auto-install-disabled" };
-  }
+async function ensureBrandedEngineInstalled(args = {}, envPath = null, { progress = null } = {}) {
   const updateArgs = {
     ...args,
     "fetch-manifest": true,
   };
   delete updateArgs["dry-run"];
   delete updateArgs.json;
-  const payload = await buildUpdatePayload(updateArgs, envPath, { dryRun: false });
+
+  const source = manifestUrl(updateArgs);
+  const manifestResult = await readManifest(source, { fetchManifest: true, progress });
+  const manifest = manifestResult.manifest;
+  if (!manifest) {
+    return { ok: false, installed: false, reason: "manifest-unavailable", manifest_status: manifestResult.status };
+  }
+  const signature = signatureAccepted(manifest, updateArgs);
+  if (!signature.ok) {
+    return { ok: false, installed: false, reason: "manifest-untrusted", signature: signature.signature };
+  }
+  const artifact = artifactForPlatform(manifest);
+  const artifactMetadata = validateArtifactMetadata(artifact);
+  if (!artifactMetadata.ok) {
+    return { ok: false, installed: false, reason: "artifact-metadata-invalid", artifact: artifactMetadata };
+  }
+  if (installedClientMatchesManifest(manifest, artifact)) {
+    return { ok: true, installed: false, reason: "already-current" };
+  }
+
+  if (!autoInstallEnabled(args)) {
+    return { ok: false, installed: false, reason: "update-required-auto-install-disabled" };
+  }
+
+  const payload = await buildUpdatePayload(updateArgs, envPath, { dryRun: false, progress });
   return {
     ok: Boolean(payload.installed && payload.installed.ok),
     installed: Boolean(payload.installed && payload.installed.ok),
@@ -843,7 +952,10 @@ async function ensureBrandedEngineInstalled(args = {}, envPath = null) {
 
 async function runUpdate(args, envPath) {
   const dryRun = Boolean(args["dry-run"]);
-  const payload = await buildUpdatePayload(args, envPath, { dryRun });
+  const payload = await buildUpdatePayload(args, envPath, {
+    dryRun,
+    progress: args.json ? null : statusLine,
+  });
 
   if (args.json) {
     printJson(payload);
@@ -907,6 +1019,7 @@ module.exports = {
   codexProviderArgs,
   codyInferenceBase,
   codyGatewayUrl,
+  currentClientManifestPath,
   currentEnginePath,
   ensureBrandedEngineInstalled,
   gatewayRoot,
@@ -915,6 +1028,7 @@ module.exports = {
   run,
   sha256Hex,
   stableJson,
+  tomlLiteralString,
   verifyManifestSignature,
   writeCodexConfig,
 };

package/package.json

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