@mytegroupinc/myte-core 0.0.32 → 0.0.34

package/mytecody-cli.js

@@ -0,0 +1,964 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const crypto = require("crypto");
+const zlib = require("zlib");
+const { spawn } = require("child_process");
+const {
+  DEFAULT_MYTEAI_BASE,
+  normalizeMyteAiBase,
+} = require("./lib/ai-gateway");
+
+const PACKAGE_VERSION = require("./package.json").version;
+const DEFAULT_CHANNEL = "alpha";
+const DEFAULT_MODEL_ALIAS = "myte";
+const DEFAULT_CONTEXT_WINDOW = Number(process.env.MYTE_CODY_CONTEXT_WINDOW || 49152);
+const DEFAULT_AUTO_COMPACT_TOKENS = Number(process.env.MYTE_CODY_AUTO_COMPACT_TOKENS || 40960);
+const DEFAULT_TOOL_OUTPUT_TOKENS = Number(process.env.MYTE_CODY_TOOL_OUTPUT_TOKENS || 10000);
+const DEFAULT_AGENT_THREADS = Number(process.env.MYTE_CODY_AGENT_THREADS || 4);
+
+function findEnvPath(startDir) {
+  let cur = startDir;
+  for (let i = 0; i < 8; i += 1) {
+    const candidate = path.join(cur, ".env");
+    if (fs.existsSync(candidate)) return candidate;
+    const parent = path.dirname(cur);
+    if (parent === cur) break;
+    cur = parent;
+  }
+  return null;
+}
+
+function loadEnv() {
+  const envPath = findEnvPath(process.cwd());
+  if (!envPath || !fs.existsSync(envPath)) return null;
+  const content = fs.readFileSync(envPath, "utf8");
+  content.split(/\r?\n/).forEach((line) => {
+    const trimmed = String(line || "").trim();
+    if (!trimmed || trimmed.startsWith("#")) return;
+    const idx = trimmed.indexOf("=");
+    if (idx === -1) return;
+    const key = trimmed.slice(0, idx).trim();
+    let value = trimmed.slice(idx + 1).trim();
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+    if (key && !(key in process.env)) process.env[key] = value;
+  });
+  return envPath;
+}
+
+function parseArgs(argv) {
+  const parsed = { _: [] };
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (token === "--") {
+      parsed._.push(...argv.slice(i + 1));
+      break;
+    }
+    if (token.startsWith("--no-")) {
+      parsed[token.slice(5)] = false;
+      continue;
+    }
+    if (token.startsWith("--")) {
+      const eqIdx = token.indexOf("=");
+      if (eqIdx !== -1) {
+        parsed[token.slice(2, eqIdx)] = token.slice(eqIdx + 1);
+        continue;
+      }
+      const key = token.slice(2);
+      const next = argv[i + 1];
+      if (next !== undefined && !next.startsWith("-")) {
+        parsed[key] = next;
+        i += 1;
+      } else {
+        parsed[key] = true;
+      }
+      continue;
+    }
+    parsed._.push(token);
+  }
+  return parsed;
+}
+
+function getKeyInfo(env = process.env) {
+  if (String(env.MYTEAI_API_KEY || "").trim()) {
+    return { present: true, source: "MYTEAI_API_KEY" };
+  }
+  if (String(env.MYTE_AI_API_KEY || "").trim()) {
+    return { present: true, source: "MYTE_AI_API_KEY" };
+  }
+  return { present: false, source: null };
+}
+
+function getAuthToken(env = process.env) {
+  return String(env.MYTEAI_API_KEY || env.MYTE_AI_API_KEY || "").trim();
+}
+
+function gatewayBase(args = {}) {
+  const raw =
+    args["base-url"] ||
+    process.env.MYTE_CODY_API_BASE ||
+    process.env.MYTEAI_API_BASE ||
+    process.env.MYTE_AI_API_BASE ||
+    DEFAULT_MYTEAI_BASE;
+  return normalizeMyteAiBase(raw);
+}
+
+function gatewayRoot(args = {}) {
+  return gatewayBase(args).replace(/\/v1$/i, "");
+}
+
+function codyGatewayUrl(args = {}, suffix = "") {
+  const root = gatewayRoot(args).replace(/\/+$/, "");
+  const tail = String(suffix || "").startsWith("/") ? String(suffix) : `/${suffix}`;
+  return `${root}${tail}`;
+}
+
+function codyInferenceBase(args = {}) {
+  return codyGatewayUrl(args, "/cody/v1");
+}
+
+function manifestUrl(args = {}) {
+  return String(
+    args.manifest ||
+      process.env.MYTE_CODY_RELEASE_MANIFEST ||
+      `${gatewayRoot(args)}/cody/releases/manifest.json`,
+  );
+}
+
+function platformKey() {
+  return `${process.platform}-${process.arch}`;
+}
+
+function installRoot() {
+  if (process.env.MYTE_CODY_HOME) return path.resolve(process.env.MYTE_CODY_HOME);
+  if (process.platform === "win32") {
+    const base = process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local");
+    return path.join(base, "Myte", "Cody");
+  }
+  return path.join(os.homedir(), ".myte", "cody");
+}
+
+function currentClientManifestPath() {
+  return path.join(installRoot(), "current", "manifest.json");
+}
+
+function currentEnginePath() {
+  const executable = process.platform === "win32" ? "mytecody-engine.exe" : "mytecody-engine";
+  return path.join(installRoot(), "current", "bin", executable);
+}
+
+function codexHome() {
+  return path.join(installRoot(), "engine-home");
+}
+
+function codexModelCatalogPath() {
+  return path.join(codexHome(), "mytecody-models.json");
+}
+
+function readCurrentClientManifest() {
+  const filePath = currentClientManifestPath();
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function installedClientCommand() {
+  const enginePath = currentEnginePath();
+  if (!fs.existsSync(enginePath)) return null;
+  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
+
+Usage:
+  mytecody
+  mytecody doctor [--json] [--base-url <url>] [--probe-gateway]
+  mytecody exec [prompt or agent exec args...]
+  mytecody update --dry-run [--json] [--manifest <url-or-file>] [--fetch-manifest]
+  mytecody update [--json] [--manifest <url-or-file>]
+  mytecody help
+
+Network:
+  The distributed MyteCody client uses the Myte AI gateway for coding
+  inference. It can inspect local config without network, but coding requires
+  gateway access and a Myte AI key.
+
+Environment:
+  MYTEAI_API_KEY       Myte AI inference key
+  MYTE_CODY_API_BASE   Myte AI gateway base URL
+  MYTE_CODY_HOME       local MyteCody client cache/install directory
+`);
+}
+
+function commonStatus(args, envPath) {
+  const keyInfo = getKeyInfo();
+  const current = readCurrentClientManifest();
+  return {
+    product: "MyteCody",
+    command: "mytecody",
+    package_version: PACKAGE_VERSION,
+    mode: "team-gateway",
+    workspace: process.cwd(),
+    env_file: envPath,
+    auth: keyInfo,
+    gateway: {
+      base_url: gatewayBase(args),
+      inference_base_url: codyInferenceBase(args),
+      network_required_for_coding: true,
+    },
+    release: {
+      channel: String(args.channel || process.env.MYTE_CODY_RELEASE_CHANNEL || DEFAULT_CHANNEL),
+      manifest_url: manifestUrl(args),
+      platform: platformKey(),
+      install_root: installRoot(),
+      engine_path: currentEnginePath(),
+      client_manifest: currentClientManifestPath(),
+      client_installed: Boolean(current && installedClientCommand()),
+      client_version: current && current.version ? current.version : null,
+    },
+  };
+}
+
+function printJson(payload) {
+  console.log(JSON.stringify(payload, null, 2));
+}
+
+function isUrl(value) {
+  return /^https?:\/\//i.test(String(value || ""));
+}
+
+async function readManifest(source, { fetchManifest }) {
+  if (!source) return { status: "missing", manifest: null };
+  if (isUrl(source)) {
+    if (!fetchManifest) {
+      return { status: "skipped", manifest: null };
+    }
+    const response = await fetch(source);
+    const text = await response.text();
+    if (!response.ok) {
+      throw new Error(`Manifest fetch failed (${response.status}): ${text.slice(0, 300)}`);
+    }
+    return { status: "fetched", manifest: JSON.parse(text) };
+  }
+  const filePath = path.resolve(source);
+  const text = fs.readFileSync(filePath, "utf8");
+  return { status: "read", manifest: JSON.parse(text), file_path: filePath };
+}
+
+function stableJson(value) {
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.keys(value)
+      .sort()
+      .map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`)
+      .join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+
+function manifestWithoutSignature(manifest) {
+  const clone = JSON.parse(JSON.stringify(manifest || {}));
+  delete clone.signature;
+  return clone;
+}
+
+function verifyManifestSignature(manifest) {
+  const signature = manifest && manifest.signature;
+  if (!signature || !signature.value) {
+    return { status: "missing", verified: false };
+  }
+  const publicKey = builtInPublicKeyPem();
+  if (!publicKey) {
+    return {
+      status: "public-key-missing",
+      verified: false,
+      key_id: signature.key_id || null,
+    };
+  }
+  const verifier = crypto.createVerify("SHA256");
+  verifier.update(stableJson(manifestWithoutSignature(manifest)));
+  verifier.end();
+  return {
+    status: "checked",
+    verified: verifier.verify(publicKey, String(signature.value), "base64"),
+    key_id: signature.key_id || null,
+  };
+}
+
+function builtInPublicKeyPem() {
+  const publicKeyPath = path.join(__dirname, "lib", "mytecody-release-public-key.pem");
+  if (!fs.existsSync(publicKeyPath)) return "";
+  return fs.readFileSync(publicKeyPath, "utf8");
+}
+
+function artifactForPlatform(manifest) {
+  const artifacts = manifest && manifest.artifacts;
+  const platform = platformKey();
+  if (Array.isArray(artifacts)) {
+    return (
+      artifacts.find((artifact) => {
+        if (!artifact || typeof artifact !== "object") return false;
+        const combined = `${artifact.platform || process.platform}-${artifact.arch || process.arch}`;
+        return artifact.platform_key === platform || combined === platform;
+      }) || null
+    );
+  }
+  if (!artifacts || typeof artifacts !== "object") return null;
+  return artifacts[platform] || null;
+}
+
+function validateArtifactMetadata(artifact) {
+  if (!artifact) return { status: "missing", ok: false };
+  const missing = [];
+  if (!artifact.url) missing.push("url");
+  if (!artifact.sha256) missing.push("sha256");
+  return {
+    status: missing.length ? "invalid" : "present",
+    ok: missing.length === 0,
+    missing,
+    url: artifact.url || null,
+    format: artifact.format || null,
+    sha256_present: Boolean(artifact.sha256),
+  };
+}
+
+function localPathFromArtifactUrl(urlValue) {
+  const raw = String(urlValue || "").trim();
+  if (/^file:\/\//i.test(raw)) {
+    const url = new URL(raw);
+    return decodeURIComponent(url.pathname.replace(/^\/([A-Za-z]:)/, "$1"));
+  }
+  if (!isUrl(raw)) return path.resolve(raw);
+  return null;
+}
+
+async function readArtifactBytes(artifact) {
+  const urlValue = artifact && artifact.url ? String(artifact.url) : "";
+  const localPath = localPathFromArtifactUrl(urlValue);
+  if (localPath) {
+    return fs.readFileSync(localPath);
+  }
+  const headers = {};
+  const token = getAuthToken();
+  if (token) headers.Authorization = `Bearer ${token}`;
+  const response = await fetch(urlValue, { method: "GET", headers });
+  const bytes = Buffer.from(await response.arrayBuffer());
+  if (!response.ok) {
+    throw new Error(`Artifact fetch failed (${response.status}): ${bytes.toString("utf8", 0, Math.min(bytes.length, 300))}`);
+  }
+  return bytes;
+}
+
+function sha256Hex(bytes) {
+  return crypto.createHash("sha256").update(bytes).digest("hex");
+}
+
+function artifactFormat(artifact) {
+  const explicit = String((artifact && artifact.format) || "").trim().toLowerCase();
+  if (explicit) return explicit;
+  const urlValue = String((artifact && artifact.url) || "").trim().toLowerCase();
+  if (urlValue.endsWith(".gz")) return "gzip";
+  return "exe";
+}
+
+function artifactBytesForInstall(bytes, artifact) {
+  const format = artifactFormat(artifact);
+  if (format === "exe" || format === "binary" || format === "raw") return bytes;
+  if (format === "gzip" || format === "gz") return zlib.gunzipSync(bytes);
+  throw new Error(`Unsupported MyteCody release artifact format: ${format}`);
+}
+
+function signatureAccepted(manifest, args = {}) {
+  const signature = verifyManifestSignature(manifest);
+  if (signature.verified) return { ok: true, signature, trusted_unsigned: false };
+  return { ok: false, signature, trusted_unsigned: false };
+}
+
+function installArtifactBytes(bytes, manifest, artifact) {
+  const installBytes = artifactBytesForInstall(bytes, artifact);
+  const enginePath = currentEnginePath();
+  fs.rmSync(path.dirname(path.dirname(enginePath)), { recursive: true, force: true });
+  fs.mkdirSync(path.dirname(enginePath), { recursive: true });
+  fs.writeFileSync(enginePath, installBytes);
+  if (process.platform !== "win32") {
+    fs.chmodSync(enginePath, 0o755);
+  }
+  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: enginePath,
+    artifact: {
+      url: artifact.url,
+      sha256: artifact.sha256,
+      format: artifactFormat(artifact),
+      size_bytes: bytes.length,
+      installed_sha256: sha256Hex(installBytes),
+      installed_size_bytes: installBytes.length,
+    },
+  };
+  fs.writeFileSync(currentClientManifestPath(), JSON.stringify(installedManifest, null, 2), "utf8");
+  return installedManifest;
+}
+
+async function fetchJson(url, { headers = {}, timeoutMs = 8000 } = {}) {
+  const controller = typeof AbortController !== "undefined" ? new AbortController() : undefined;
+  const timeoutId =
+    controller && timeoutMs > 0 ? setTimeout(() => controller.abort(), timeoutMs) : undefined;
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+        ...headers,
+      },
+      signal: controller?.signal,
+    });
+    const text = await response.text();
+    let body = {};
+    if (text.trim()) {
+      try {
+        body = JSON.parse(text);
+      } catch {
+        body = { raw_text: text.slice(0, 500) };
+      }
+    }
+    return {
+      ok: Boolean(response.ok),
+      status: response.status,
+      body,
+    };
+  } finally {
+    if (timeoutId) clearTimeout(timeoutId);
+  }
+}
+
+async function probeGateway(args = {}) {
+  const token = getAuthToken();
+  const healthUrl = codyGatewayUrl(args, "/cody/health");
+  const modelsUrl = codyGatewayUrl(args, "/cody/v1/models");
+  const result = {
+    ok: false,
+    health: {
+      url: healthUrl,
+      ok: false,
+      status: null,
+    },
+    models: {
+      url: modelsUrl,
+      ok: false,
+      status: null,
+      skipped: !token,
+    },
+  };
+  try {
+    const health = await fetchJson(healthUrl);
+    result.health.ok = Boolean(health.ok && health.body && health.body.ok === true);
+    result.health.status = health.status;
+    result.health.service = health.body && health.body.service ? String(health.body.service) : null;
+    result.health.model = health.body && health.body.model ? health.body.model : null;
+  } catch (error) {
+    result.health.error = error && error.message ? error.message : String(error);
+  }
+
+  if (token) {
+    try {
+      const models = await fetchJson(modelsUrl, {
+        headers: { Authorization: `Bearer ${token}` },
+      });
+      const ids = Array.isArray(models.body?.data)
+        ? models.body.data.map((item) => String(item && item.id ? item.id : "")).filter(Boolean)
+        : [];
+      result.models.ok = Boolean(models.ok && ids.includes("myte"));
+      result.models.status = models.status;
+      result.models.ids = ids;
+      result.models.skipped = false;
+    } catch (error) {
+      result.models.error = error && error.message ? error.message : String(error);
+      result.models.skipped = false;
+    }
+  }
+
+  result.ok = Boolean(result.health.ok && result.models.ok);
+  return result;
+}
+
+function tomlString(value) {
+  return JSON.stringify(String(value || ""));
+}
+
+function pathForToml(value) {
+  return String(value || "").replace(/\\/g, "\\\\");
+}
+
+function writeCodexModelCatalog() {
+  fs.mkdirSync(codexHome(), { recursive: true });
+  const baseInstructions = [
+    "You are MyteCody, a coding agent running in the Myte terminal harness.",
+    "",
+    "You and the user share one local workspace. Start in the current repository and operate there by default. Inspect outside the current repository only when explicitly asked.",
+    "",
+    "Your job is to understand the user's intent, inspect the relevant files, run local commands when useful, edit files with the available patch tool, run focused verification, and stop when the task is actually handled.",
+    "",
+    "For documentation, architecture, and repo-summary work, verify each material claim independently before presenting it as implemented fact. Separate current implementation from planned direction and unknowns. Treat planning docs as intent unless source code, config, command output, or logs prove the behavior exists.",
+    "",
+    "For edits, prefer apply_patch. If a patch fails, read the error, inspect the target file again, and retry with a corrected patch. Do not claim completion until after inspecting the resulting file or relevant diff.",
+    "",
+    "Keep responses concise and factual. Do not invent commands, flags, telemetry names, tool behavior, context-window defaults, retrieval behavior, or implemented features.",
+  ].join("\n");
+  const catalog = {
+    models: [
+      {
+        slug: DEFAULT_MODEL_ALIAS,
+        display_name: "Myte",
+        description: "Myte AI coding model.",
+        base_instructions: baseInstructions,
+        default_reasoning_level: "medium",
+        supported_reasoning_levels: [
+          { effort: "low", description: "Fast local coding pass." },
+          { effort: "medium", description: "Balanced coding pass." },
+          { effort: "high", description: "Deeper coding pass." },
+        ],
+        shell_type: "shell_command",
+        visibility: "list",
+        supported_in_api: true,
+        priority: 0,
+        availability_nux: null,
+        upgrade: null,
+        supports_reasoning_summaries: false,
+        default_reasoning_summary: "none",
+        support_verbosity: false,
+        default_verbosity: null,
+        apply_patch_tool_type: "freeform",
+        web_search_tool_type: "text",
+        truncation_policy: {
+          mode: "tokens",
+          limit: 10000,
+        },
+        supports_parallel_tool_calls: true,
+        supports_image_detail_original: false,
+        context_window: DEFAULT_CONTEXT_WINDOW,
+        max_context_window: DEFAULT_CONTEXT_WINDOW,
+        auto_compact_token_limit: DEFAULT_AUTO_COMPACT_TOKENS,
+        effective_context_window_percent: 90,
+        experimental_supported_tools: [],
+        input_modalities: ["text"],
+        supports_search_tool: false,
+        use_responses_lite: false,
+        auto_review_model_override: null,
+      },
+    ],
+  };
+  const catalogPath = codexModelCatalogPath();
+  fs.writeFileSync(catalogPath, JSON.stringify(catalog, null, 2), "utf8");
+  return catalogPath;
+}
+
+function writeCodexConfig(args = {}) {
+  fs.mkdirSync(codexHome(), { recursive: true });
+  const catalogPath = writeCodexModelCatalog();
+  const config = `model = ${tomlString(DEFAULT_MODEL_ALIAS)}
+model_provider = "myte_ai"
+model_catalog_json = ${tomlString(pathForToml(catalogPath))}
+model_context_window = ${DEFAULT_CONTEXT_WINDOW}
+model_auto_compact_token_limit = ${DEFAULT_AUTO_COMPACT_TOKENS}
+tool_output_token_limit = ${DEFAULT_TOOL_OUTPUT_TOKENS}
+web_search = "disabled"
+suppress_unstable_features_warning = true
+check_for_update_on_startup = false
+
+[tui]
+show_tooltips = false
+status_line = ["run-state", "current-dir"]
+status_line_use_colors = true
+terminal_title = ["project"]
+
+[model_providers.myte_ai]
+name = "Myte AI"
+base_url = ${tomlString(codyInferenceBase(args))}
+env_key = "MYTE_CODY_AUTH_TOKEN"
+wire_api = "responses"
+requires_openai_auth = false
+
+[features]
+apps = false
+multi_agent = false
+hooks = false
+memories = false
+plugins = false
+tool_suggest = false
+
+[features.multi_agent_v2]
+enabled = true
+max_concurrent_threads_per_session = ${DEFAULT_AGENT_THREADS}
+
+[skills]
+include_instructions = true
+
+[skills.bundled]
+enabled = false
+
+[projects.${tomlString(pathForToml(process.cwd()))}]
+trust_level = "trusted"
+
+[windows]
+sandbox = "unelevated"
+`;
+  const configPath = path.join(codexHome(), "config.toml");
+  fs.writeFileSync(configPath, config, "utf8");
+  return { configPath, catalogPath };
+}
+
+function resolveCodexCommand() {
+  const installed = installedClientCommand();
+  if (installed) return installed;
+  return null;
+}
+
+function codexProviderArgs(args = {}) {
+  return [
+    "-c",
+    'model_provider="myte_ai"',
+    "-c",
+    'model_providers.myte_ai.name="Myte AI"',
+    "-c",
+    `model_providers.myte_ai.base_url="${codyInferenceBase(args)}"`,
+    "-c",
+    'model_providers.myte_ai.env_key="MYTE_CODY_AUTH_TOKEN"',
+    "-c",
+    'model_providers.myte_ai.wire_api="responses"',
+    "-c",
+    `model_catalog_json="${pathForToml(codexModelCatalogPath())}"`,
+    "-c",
+    `model_context_window=${DEFAULT_CONTEXT_WINDOW}`,
+    "-c",
+    `model_auto_compact_token_limit=${DEFAULT_AUTO_COMPACT_TOKENS}`,
+    "-c",
+    `tool_output_token_limit=${DEFAULT_TOOL_OUTPUT_TOKENS}`,
+    "-c",
+    "web_search=\"disabled\"",
+    "-c",
+    "suppress_unstable_features_warning=true",
+    "-c",
+    "features.multi_agent_v2.enabled=true",
+    "-c",
+    `features.multi_agent_v2.max_concurrent_threads_per_session=${DEFAULT_AGENT_THREADS}`,
+    "--sandbox",
+    "danger-full-access",
+    "--ask-for-approval",
+    "never",
+    "-m",
+    DEFAULT_MODEL_ALIAS,
+  ];
+}
+
+function codexLaunchArgs(rawArgs, args = {}) {
+  const providerArgs = codexProviderArgs(args);
+  if (!rawArgs.length) return providerArgs;
+  if (rawArgs[0] === "exec") return [...providerArgs, "exec", "--skip-git-repo-check", ...rawArgs.slice(1)];
+  return [...providerArgs, ...rawArgs];
+}
+
+async function runCodex(rawArgs, args = {}, envPath = null) {
+  const token = getAuthToken();
+  if (!token) {
+    console.error("MyteCody requires MYTEAI_API_KEY for coding.");
+    return 1;
+  }
+  writeCodexConfig(args);
+  try {
+    const install = await ensureBrandedEngineInstalled(args, envPath);
+    if (install.ok && install.installed) {
+      console.error(`MyteCody engine installed: ${install.payload.installed.version}`);
+    } 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,
+  };
+  return new Promise((resolve) => {
+    const child = spawn(command.cmd, launchArgs, {
+      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}`);
+      resolve(1);
+    });
+    child.on("close", (code) => resolve(Number.isInteger(code) ? code : 1));
+  });
+}
+
+async function runDoctor(args, envPath) {
+  const payload = {
+    ok: true,
+    ready_for_coding: false,
+    ...commonStatus(args, envPath),
+  };
+  if (args["probe-gateway"]) {
+    payload.gateway.probe = await probeGateway(args);
+  }
+  payload.ready_for_coding = payload.auth.present && payload.release.client_installed;
+  if (payload.gateway.probe) {
+    payload.ready_for_coding = Boolean(payload.ready_for_coding && payload.gateway.probe.ok);
+  }
+  if (args.json) {
+    printJson(payload);
+    return 0;
+  }
+  console.log("MYTE CODY - Your Tech Your Way");
+  console.log("");
+  console.log(`mode:       ${payload.mode}`);
+  console.log(`workspace:  ${payload.workspace}`);
+  console.log(`auth:       ${payload.auth.present ? `present (${payload.auth.source})` : "missing"}`);
+  console.log(`gateway:    ${payload.gateway.base_url}`);
+  if (payload.gateway.probe) {
+    console.log(`gateway probe: ${payload.gateway.probe.ok ? "ok" : "failed"}`);
+  }
+  console.log(`client:     ${payload.release.client_installed ? payload.release.client_version : "not installed"}`);
+  console.log(`install:    ${payload.release.install_root}`);
+  console.log("");
+  console.log("Coding requires the Myte AI gateway and a Myte AI key.");
+  return 0;
+}
+
+async function buildUpdatePayload(args, envPath, { dryRun = false } = {}) {
+  const isDryRun = Boolean(dryRun);
+  const source = manifestUrl(args);
+  const manifestResult = await readManifest(source, { fetchManifest: Boolean(args["fetch-manifest"]) || !isDryRun });
+  const manifest = manifestResult.manifest;
+  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 payload = {
+    ok: true,
+    dry_run: isDryRun,
+    would_write: !isDryRun,
+    ...commonStatus(args, envPath),
+    manifest: {
+      source,
+      read_status: manifestResult.status,
+      version: manifest && manifest.version ? manifest.version : null,
+      signature: signature.signature,
+      trusted_unsigned: Boolean(signature.trusted_unsigned),
+    },
+    artifact: artifactMetadata,
+  };
+
+  if (!isDryRun) {
+    if (!manifest) {
+      throw new Error("Cannot install MyteCody engine without a readable release manifest.");
+    }
+    if (!signature.ok) {
+      throw new Error("MyteCody release manifest signature is not trusted.");
+    }
+    if (!artifactMetadata.ok) {
+      throw new Error(`MyteCody release artifact metadata is ${artifactMetadata.status}.`);
+    }
+    const bytes = await readArtifactBytes(artifact);
+    const digest = sha256Hex(bytes);
+    if (digest.toLowerCase() !== String(artifact.sha256 || "").toLowerCase()) {
+      throw new Error(`Artifact SHA-256 mismatch: expected ${artifact.sha256}, got ${digest}`);
+    }
+    const installed = installArtifactBytes(bytes, manifest, artifact);
+    payload.installed = {
+      ok: true,
+      version: installed.version,
+      executable: installed.executable,
+      sha256: digest,
+      size_bytes: bytes.length,
+      installed_sha256: installed.artifact.installed_sha256,
+      installed_size_bytes: installed.artifact.installed_size_bytes,
+      format: installed.artifact.format,
+    };
+    payload.release = {
+      ...payload.release,
+      client_installed: true,
+      client_version: installed.version,
+      engine_path: installed.executable,
+    };
+  }
+
+  return payload;
+}
+
+function autoInstallEnabled(args = {}) {
+  if (args["auto-update"] === false) return false;
+  if (process.env.MYTE_CODY_AUTO_UPDATE === "0") return false;
+  return true;
+}
+
+async function ensureBrandedEngineInstalled(args = {}, envPath = null) {
+  const updateArgs = {
+    ...args,
+    "fetch-manifest": true,
+  };
+  delete updateArgs["dry-run"];
+  delete updateArgs.json;
+
+  const source = manifestUrl(updateArgs);
+  const manifestResult = await readManifest(source, { fetchManifest: true });
+  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 });
+  return {
+    ok: Boolean(payload.installed && payload.installed.ok),
+    installed: Boolean(payload.installed && payload.installed.ok),
+    reason: "installed",
+    payload,
+  };
+}
+
+async function runUpdate(args, envPath) {
+  const dryRun = Boolean(args["dry-run"]);
+  const payload = await buildUpdatePayload(args, envPath, { dryRun });
+
+  if (args.json) {
+    printJson(payload);
+    return 0;
+  }
+  console.log(dryRun ? "MYTE CODY update dry-run" : "MYTE CODY update");
+  console.log(`manifest: ${payload.manifest.source}`);
+  console.log(`manifest read: ${payload.manifest.read_status}`);
+  console.log(`platform: ${payload.release.platform}`);
+  console.log(`install: ${payload.release.install_root}`);
+  console.log(`would write: ${payload.would_write}`);
+  if (payload.manifest.read_status !== "skipped") {
+    console.log(`version: ${payload.manifest.version || "unknown"}`);
+    console.log(`signature: ${payload.manifest.signature.status}`);
+    console.log(`artifact: ${payload.artifact.status}`);
+  } else {
+    console.log("manifest fetch skipped; pass --fetch-manifest to test the configured endpoint.");
+  }
+  if (payload.installed) {
+    console.log(`installed: ${payload.installed.executable}`);
+  }
+  return 0;
+}
+
+async function run(argv = process.argv.slice(2)) {
+  const envPath = loadEnv();
+  const parsed = parseArgs(argv);
+  const command = argv[0] || "codex";
+  const restArgs = parseArgs(argv.slice(1));
+
+  if (command === "help" || command === "--help" || command === "-h") {
+    printHelp();
+    return 0;
+  }
+  if (command === "doctor") return runDoctor(restArgs, envPath);
+  if (command === "update") return runUpdate(restArgs, envPath);
+  if (command === "version" || command === "--version" || command === "-v") {
+    console.log(PACKAGE_VERSION);
+    return 0;
+  }
+
+  return runCodex(argv, parsed, envPath);
+}
+
+async function main() {
+  try {
+    const code = await run();
+    process.exitCode = code;
+  } catch (error) {
+    console.error(error && error.message ? error.message : error);
+    process.exitCode = 1;
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  codexLaunchArgs,
+  codexProviderArgs,
+  codyInferenceBase,
+  codyGatewayUrl,
+  currentClientManifestPath,
+  currentEnginePath,
+  ensureBrandedEngineInstalled,
+  gatewayRoot,
+  installedClientCommand,
+  resolveCodexCommand,
+  run,
+  sha256Hex,
+  stableJson,
+  verifyManifestSignature,
+  writeCodexConfig,
+};