@mytegroupinc/myte-core 0.0.34 → 0.0.36

package/lib/mytecody-splash.js

@@ -0,0 +1,251 @@
+"use strict";
+
+const FRAME_MS = 48;
+const MIN_MS = 850;
+const FRAMES = 32;
+const WIDTH = 84;
+const HEIGHT = 64;
+const RX = 32.5;
+const RY = 27.5;
+const CYAN = [93, 226, 255];
+const BLUE = [45, 150, 255];
+const DIM = [45, 72, 102];
+const WHITE = [229, 244, 255];
+const SOFT = [92, 132, 172];
+
+const NODES = [
+  [-68, 0], [-55, -110], [-55, -35], [-55, 35], [-55, 110],
+  [-35, -150], [-35, -90], [-35, -30], [-35, 30], [-35, 90], [-35, 150],
+  [-15, -165], [-15, -110], [-15, -55], [-15, 0], [-15, 55], [-15, 110], [-15, 165],
+  [15, -165], [15, -110], [15, -55], [15, 0], [15, 55], [15, 110], [15, 165],
+  [35, -150], [35, -90], [35, -30], [35, 30], [35, 90], [35, 150],
+  [55, -110], [55, -35], [55, 35], [55, 110], [68, 0],
+];
+
+const LINKS = [
+  [0, 1], [0, 2], [0, 3], [0, 4], [1, 5], [2, 6], [2, 7], [3, 8], [3, 9], [4, 10],
+  [5, 11], [6, 12], [7, 13], [8, 15], [9, 16], [10, 17], [11, 18], [12, 19],
+  [13, 20], [14, 21], [15, 22], [16, 23], [17, 24], [18, 25], [19, 26], [20, 27],
+  [21, 28], [22, 29], [23, 30], [24, 30], [25, 31], [26, 31], [27, 32], [28, 33],
+  [29, 34], [30, 35], [31, 35], [32, 35], [33, 35], [34, 35],
+];
+
+const BRAILLE = [[0x01, 0x08], [0x02, 0x10], [0x04, 0x20], [0x40, 0x80]];
+
+function envTruthy(name, fallback = false) {
+  const value = process.env[name];
+  if (value == null || value === "") return fallback;
+  return !["0", "false", "no", "off"].includes(String(value).toLowerCase());
+}
+
+function ansi(rgb, text, opts = {}) {
+  if (process.env.NO_COLOR || process.env.MYTE_CODY_SPLASH_ASCII === "1") return text;
+  const flags = [opts.bold ? "1" : null, opts.dim ? "2" : null, `38;2;${rgb[0]};${rgb[1]};${rgb[2]}`]
+    .filter(Boolean)
+    .join(";");
+  return `\x1b[${flags}m${text}\x1b[0m`;
+}
+
+function mix(a, b, t) {
+  return a.map((v, i) => Math.round(v + (b[i] - v) * t));
+}
+
+function grid() {
+  return Array.from({ length: HEIGHT }, () =>
+    Array.from({ length: WIDTH }, () => ({ v: 0, n: false })),
+  );
+}
+
+function put(g, x, y, value, node = false) {
+  const px = Math.round(x);
+  const py = Math.round(y);
+  if (py < 0 || py >= HEIGHT || px < 0 || px >= WIDTH) return;
+  if (value > g[py][px].v) g[py][px] = { v: value, n: g[py][px].n || node };
+  else if (node) g[py][px].n = true;
+}
+
+function dot(g, x, y, value, radius = 0.85, node = false) {
+  const r = Math.ceil(radius);
+  for (let dy = -r; dy <= r; dy += 1) {
+    for (let dx = -r; dx <= r; dx += 1) {
+      const d = Math.sqrt(dx * dx + dy * dy);
+      if (d <= radius) put(g, x + dx, y + dy, value * (1 - d / (radius + 0.8)), node);
+    }
+  }
+}
+
+function project(latDeg, lonDeg, phase) {
+  const lat = (latDeg * Math.PI) / 180;
+  const lon = (lonDeg * Math.PI) / 180;
+  const cosLat = Math.cos(lat);
+  const x = cosLat * Math.sin(lon);
+  const y = Math.sin(lat);
+  const z = cosLat * Math.cos(lon);
+  const rp = { x: x * Math.cos(phase) + z * Math.sin(phase), z: -x * Math.sin(phase) + z * Math.cos(phase) };
+  return { x: WIDTH / 2 - 0.5 + rp.x * RX, y: HEIGHT / 2 - 0.5 - y * RY, z: rp.z };
+}
+
+function drawCurve(g, points, base = 0.08, radius = 0.75) {
+  for (let i = 1; i < points.length; i += 1) {
+    const a = points[i - 1];
+    const b = points[i];
+    const steps = Math.max(2, Math.ceil(Math.hypot(b.x - a.x, b.y - a.y) * 1.7));
+    for (let s = 0; s <= steps; s += 1) {
+      const t = s / steps;
+      const z = a.z + (b.z - a.z) * t;
+      const front = Math.max(0, (z + 1) / 2);
+      const fade = Math.max(0, (z + 0.38) / 1.38);
+      dot(g, a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, base * fade + front * 0.21, radius);
+    }
+  }
+}
+
+function lonBetween(a, b, t) {
+  let delta = b - a;
+  if (delta > 180) delta -= 360;
+  if (delta < -180) delta += 360;
+  let value = a + delta * t;
+  if (value > 180) value -= 360;
+  if (value < -180) value += 360;
+  return value;
+}
+
+function drawFrame(index) {
+  const phase = (index / FRAMES) * Math.PI * 2;
+  const g = grid();
+  const cx = WIDTH / 2 - 0.5;
+  const cy = HEIGHT / 2 - 0.5;
+
+  for (let deg = 0; deg < 360; deg += 1) {
+    const a = (deg * Math.PI) / 180;
+    const pulse = 0.22 + 0.18 * Math.max(0, 1 - Math.abs((((a - phase + Math.PI) % (Math.PI * 2)) - Math.PI)) / 1.1);
+    dot(g, cx + Math.cos(a) * RX, cy + Math.sin(a) * RY, pulse + 0.27, 1.0);
+  }
+  for (const lat of [-60, -42, -24, -8, 8, 24, 42, 60]) {
+    const pts = [];
+    for (let lon = -180; lon <= 180; lon += 3) pts.push(project(lat, lon, phase));
+    drawCurve(g, pts, 0.07, 0.55);
+  }
+  for (const lon of [-150, -105, -60, -20, 20, 60, 105, 150]) {
+    const pts = [];
+    for (let lat = -76; lat <= 76; lat += 3) pts.push(project(lat, lon, phase));
+    drawCurve(g, pts, 0.055, 0.48);
+  }
+  for (const [a, b] of LINKS) {
+    const start = NODES[a];
+    const end = NODES[b];
+    const pts = [];
+    for (let s = 0; s <= 14; s += 1) {
+      const t = s / 14;
+      pts.push(project(start[0] + (end[0] - start[0]) * t, lonBetween(start[1], end[1], t), phase));
+    }
+    drawCurve(g, pts, 0.035, 0.45);
+  }
+  NODES.forEach(([lat, lon], i) => {
+    const p = project(lat, lon, phase);
+    const front = Math.max(0, (p.z + 1) / 2);
+    const pulse = 0.5 + 0.5 * Math.sin(phase * 2.2 + i * 0.75);
+    dot(g, p.x, p.y, 0.28 + front * 0.42 + pulse * 0.24, (front > 0.48 ? 1.55 : 0.9) + pulse * 0.45, true);
+  });
+
+  const rows = Math.floor(HEIGHT / 4);
+  const cols = Math.floor(WIDTH / 2);
+  const lines = [];
+  for (let y = 0; y < rows; y += 1) {
+    let line = "";
+    for (let x = 0; x < cols; x += 1) {
+      let mask = 0;
+      let value = 0;
+      let node = false;
+      for (let dy = 0; dy < 4; dy += 1) {
+        for (let dx = 0; dx < 2; dx += 1) {
+          const px = g[y * 4 + dy][x * 2 + dx];
+          if (px.v <= 0.11) continue;
+          mask |= BRAILLE[dy][dx];
+          value = Math.max(value, px.v);
+          node = node || px.n;
+        }
+      }
+      if (!mask) line += " ";
+      else line += ansi(node ? mix(CYAN, WHITE, Math.min(0.35, value * 0.28)) : mix(DIM, BLUE, Math.min(0.8, value)), String.fromCharCode(0x2800 + mask), { bold: node && value > 0.62, dim: value < 0.25 });
+    }
+    lines.push(line.replace(/\s+$/u, ""));
+  }
+  return lines;
+}
+
+function shouldShowSplash() {
+  if (!envTruthy("MYTE_CODY_SPLASH", true)) return false;
+  if (process.env.CI && process.env.MYTE_CODY_SPLASH_FORCE !== "1") return false;
+  return Boolean(process.stdout.isTTY || process.env.MYTE_CODY_SPLASH_FORCE === "1");
+}
+
+function buildLines(frame, status) {
+  return [
+    "",
+    ...drawFrame(frame),
+    "",
+    `  ${ansi(WHITE, "MYTE CODY", { bold: true })}${ansi(SOFT, " - Your Tech Your Way")}`,
+    `  ${ansi(BLUE, "sovereign coding gateway", { bold: true })}`,
+    `  ${ansi(CYAN, "◆", { bold: true })} ${ansi(SOFT, status || "opening workspace")}`,
+  ];
+}
+
+function createMyteSplash() {
+  const enabled = shouldShowSplash();
+  let frame = 0;
+  let lineCount = 0;
+  let rendered = false;
+  let timer = null;
+  let started = 0;
+  let status = "opening workspace";
+
+  function render() {
+    if (!enabled) return;
+    const lines = buildLines(frame, status);
+    if (rendered) process.stdout.write(`\x1b[${lineCount}F\x1b[J`);
+    process.stdout.write(`${lines.join("\n")}\n`);
+    lineCount = lines.length;
+    rendered = true;
+    frame = (frame + 1) % FRAMES;
+  }
+
+  function start(initialStatus) {
+    if (!enabled || timer) return;
+    status = initialStatus || status;
+    started = Date.now();
+    process.stdout.write("\x1b[?25l");
+    render();
+    timer = setInterval(render, FRAME_MS);
+  }
+
+  function setStatus(nextStatus) {
+    if (nextStatus) status = String(nextStatus);
+  }
+
+  async function stop() {
+    if (!enabled) return;
+    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;
+    lineCount = 0;
+  }
+
+  return { enabled, start, setStatus, stop };
+}
+
+function previewPlain() {
+  const strip = (text) => text.replace(/\x1b\[[0-9;]*m/g, "");
+  return [0, 8, 16, 24].map((frame) => buildLines(frame, "checking signed release manifest").map(strip).join("\n")).join("\n\n");
+}
+
+module.exports = {
+  createMyteSplash,
+  previewPlain,
+};

package/mytecody-cli.js

@@ -11,6 +11,7 @@ const {
   DEFAULT_MYTEAI_BASE,
   normalizeMyteAiBase,
 } = require("./lib/ai-gateway");
+const { createMyteSplash } = require("./lib/mytecody-splash");
 
 const PACKAGE_VERSION = require("./package.json").version;
 const DEFAULT_CHANNEL = "alpha";
@@ -262,12 +263,41 @@ 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 setupProgress(splash) {
+  return (message) => {
+    if (splash && splash.enabled) {
+      splash.setStatus(message);
+      return;
+    }
+    statusLine(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) {
@@ -367,20 +397,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;
 }
 
@@ -525,8 +587,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() {
@@ -597,7 +667,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}
@@ -636,7 +706,7 @@ include_instructions = true
 [skills.bundled]
 enabled = false
 
-[projects.${tomlString(pathForToml(process.cwd()))}]
+[projects.${tomlLiteralString(process.cwd())}]
 trust_level = "trusted"
 
 [windows]
@@ -666,7 +736,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",
@@ -703,23 +773,32 @@ async function runCodex(rawArgs, args = {}, envPath = null) {
     console.error("MyteCody requires MYTEAI_API_KEY for coding.");
     return 1;
   }
+  const splash = createMyteSplash();
+  const progress = setupProgress(splash);
+  splash.start("preparing trusted workspace");
+  progress("preparing trusted workspace");
   writeCodexConfig(args);
   try {
-    const install = await ensureBrandedEngineInstalled(args, envPath);
+    const install = await ensureBrandedEngineInstalled(args, envPath, { progress });
     if (install.ok && install.installed) {
-      console.error(`MyteCody engine installed: ${install.payload.installed.version}`);
+      progress(`engine installed: ${install.payload.installed.version}`);
+    } else if (install.ok) {
+      progress("engine ready");
     } else if (!install.ok) {
+      await splash.stop();
       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) {
+    await splash.stop();
     console.error(`MyteCody engine verification failed: ${error && error.message ? error.message : error}`);
     return 1;
   }
 
   const command = resolveCodexCommand();
   if (!command) {
+    await splash.stop();
     console.error("MyteCody branded engine is not installed.");
     console.error("Run `mytecody update` with access to the Myte release manifest.");
     return 1;
@@ -729,7 +808,10 @@ async function runCodex(rawArgs, args = {}, envPath = null) {
     ...process.env,
     CODEX_HOME: codexHome(),
     MYTE_CODY_AUTH_TOKEN: token,
+    MYTE_CODY_BRAND: "1",
   };
+  progress("opening MyteCody workspace");
+  await splash.stop();
   return new Promise((resolve) => {
     const child = spawn(command.cmd, launchArgs, {
       cwd: process.cwd(),
@@ -778,10 +860,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 } };
@@ -811,7 +896,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}`);
@@ -844,7 +929,7 @@ function autoInstallEnabled(args = {}) {
   return true;
 }
 
-async function ensureBrandedEngineInstalled(args = {}, envPath = null) {
+async function ensureBrandedEngineInstalled(args = {}, envPath = null, { progress = null } = {}) {
   const updateArgs = {
     ...args,
     "fetch-manifest": true,
@@ -853,7 +938,7 @@ async function ensureBrandedEngineInstalled(args = {}, envPath = null) {
   delete updateArgs.json;
 
   const source = manifestUrl(updateArgs);
-  const manifestResult = await readManifest(source, { fetchManifest: true });
+  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 };
@@ -875,7 +960,7 @@ async function ensureBrandedEngineInstalled(args = {}, envPath = null) {
     return { ok: false, installed: false, reason: "update-required-auto-install-disabled" };
   }
 
-  const payload = await buildUpdatePayload(updateArgs, envPath, { dryRun: false });
+  const payload = await buildUpdatePayload(updateArgs, envPath, { dryRun: false, progress });
   return {
     ok: Boolean(payload.installed && payload.installed.ok),
     installed: Boolean(payload.installed && payload.installed.ok),
@@ -886,7 +971,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);
@@ -959,6 +1047,7 @@ module.exports = {
   run,
   sha256Hex,
   stableJson,
+  tomlLiteralString,
   verifyManifestSignature,
   writeCodexConfig,
 };

package/package.json

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