minecodex 0.2.1 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minecodex",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Lightweight, local-first plugins for the Codex desktop app.",
   "license": "MIT",
   "type": "module",

package/packages/cli/src/commands.mjs

@@ -4,6 +4,7 @@ import { createInterface } from "node:readline/promises";
 import { assertNodeSupported, MacPlatformAdapter } from "./platform.mjs";
 import { ensureConfig, ensureControlToken, readConfig } from "./config.mjs";
 import { createControlServer } from "./control-server.mjs";
+import { createInstallReporter } from "./install-progress.mjs";
 import { createNpmAdapter } from "./npm-adapter.mjs";
 import { resolvePaths } from "./paths.mjs";
 import { RuntimeManager, writeServicePid } from "./runtime-manager.mjs";
@@ -118,20 +119,37 @@ export async function confirmRestartNow({ input = process.stdin, terminalOutput
 }
 
 async function installCommand({ paths, platform, cliPath, output, serviceProbe, fetchImpl, confirmRestart, nodeVersion = process.versions.node }) {
-  assertNodeSupported(nodeVersion);
-  platform.assertInstallSupported();
-  await platform.assertCodexInstalled();
-  const previousService = await serviceSnapshot(platform, paths);
-  await ensureConfig(paths.configPath);
-  await ensureControlToken(paths.tokenPath);
+  const reporter = createInstallReporter({ output });
+  reporter.heading("Installing MineCodex");
+  let previousService = null;
   try {
-    await platform.installService({ cliPath, paths, start: true });
-    const waitForServiceImpl = serviceProbe?.waitForService ?? waitForService;
-    const waitForManagedReadyImpl = serviceProbe?.waitForManagedReady ?? waitForManagedReady;
-    if (!(await waitForServiceImpl(DEFAULT_CONTROL_PORT, { fetchImpl }))
-      || !(await waitForManagedReadyImpl(paths, { fetchImpl }))) {
-      throw new Error(`MineCodex service did not become ready. Check ${paths.serviceErrorLogPath}`);
-    }
+    await reporter.step(1, 6, "Checking your system", async () => {
+      assertNodeSupported(nodeVersion);
+      platform.assertInstallSupported();
+      await platform.assertCodexInstalled();
+    });
+    await reporter.step(2, 6, "Preparing your settings", async () => {
+      await ensureConfig(paths.configPath);
+      await ensureControlToken(paths.tokenPath);
+    });
+    previousService = await reporter.step(3, 6, "Checking your current setup", async () => {
+      return serviceSnapshot(platform, paths);
+    });
+    await reporter.step(4, 6, "Installing the background helper", async () => {
+      await platform.installService({ cliPath, paths, start: true });
+    });
+    await reporter.step(5, 6, "Waiting for the background helper (up to 20 seconds)", async () => {
+      const waitForServiceImpl = serviceProbe?.waitForService ?? waitForService;
+      if (!(await waitForServiceImpl(DEFAULT_CONTROL_PORT, { fetchImpl }))) {
+        throw new Error("MineCodex service did not become ready. Check " + paths.serviceErrorLogPath);
+      }
+    });
+    await reporter.step(6, 6, "Waiting for MineCodex to be ready (up to 30 seconds)", async () => {
+      const waitForManagedReadyImpl = serviceProbe?.waitForManagedReady ?? waitForManagedReady;
+      if (!(await waitForManagedReadyImpl(paths, { fetchImpl }))) {
+        throw new Error("MineCodex service did not become ready. Check " + paths.serviceErrorLogPath);
+      }
+    });
   } catch (error) {
     let rollbackError = null;
     try {
@@ -141,12 +159,12 @@ async function installCommand({ paths, platform, cliPath, output, serviceProbe,
     }
     throw appendRollbackError(error, rollbackError);
   }
-  output("MineCodex installed. It will be enabled the next time Codex restarts.");
+  reporter.heading("MineCodex installed. It will be enabled the next time Codex restarts.");
   if (await confirmRestart()) {
     await restartCommand({ paths, output, fetchImpl });
   } else {
-    output("Run `mcx restart` when you are ready.");
-  }
+    reporter.heading("Run `mcx restart` when you are ready.");
+}
 }
 
 async function openCommand({ paths, platform, serviceProbe, fetchImpl }) {

package/packages/cli/src/install-progress.mjs

@@ -0,0 +1,56 @@
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+function createInstallReporter({ output = console.log, terminalOutput = process.stdout } = {}) {
+  // 只有真实终端才显示 spinner；测试或脚本环境保持普通逐行文本。
+  const interactive = output === console.log && Boolean(terminalOutput?.isTTY);
+  let timer = null;
+
+  function stopSpinner() {
+    if (timer) clearInterval(timer);
+    timer = null;
+  }
+
+  function writeLine(line) {
+    if (!interactive) {
+      output(line);
+      return;
+    }
+    terminalOutput.write(`\r\x1b[2K${line}\n`);
+  }
+
+  function startSpinner(line) {
+    if (!interactive) {
+      output(line);
+      return;
+    }
+    let frame = 0;
+    terminalOutput.write(`\r\x1b[2K${SPINNER_FRAMES[frame]} ${line}`);
+    timer = setInterval(() => {
+      frame = (frame + 1) % SPINNER_FRAMES.length;
+      terminalOutput.write(`\r\x1b[2K${SPINNER_FRAMES[frame]} ${line}`);
+    }, 80);
+  }
+
+  return {
+    heading(line) {
+      writeLine(line);
+    },
+
+    async step(index, total, label, action) {
+      const prefix = `[${index}/${total}] ${label}`;
+      startSpinner(prefix);
+      try {
+        const result = await action();
+        stopSpinner();
+        writeLine(`✓ ${prefix}`);
+        return result;
+      } catch (error) {
+        stopSpinner();
+        writeLine(`✗ ${prefix}`);
+        throw error;
+      }
+    },
+  };
+}
+
+export { createInstallReporter };

package/packages/runtime-host/src/codex-runtime.mjs

@@ -1093,6 +1093,19 @@ export function createInjectionSource(features, {
       return formatIdentifier(identity.backend).toLowerCase() === nativeLabel ? native : thirdParty;
     }
 
+    function visibleReasoningLevelsFor(model) {
+      if (!model) return [];
+      const capability = model.modelSelectorCapability;
+      if (capability && Array.isArray(capability.levels)) {
+        const allowed = new Set(capability.levels);
+        return (model.supportedReasoningLevels ?? []).filter((level) => {
+          const effort = String(level?.effort ?? level ?? "").toLowerCase();
+          return allowed.has(effort);
+        });
+      }
+      return model.supportedReasoningLevels ?? [];
+    }
+
     function loadModelFavorites(selector) {
       try {
         const value = JSON.parse(localStorage.getItem(selector.favoriteStorageKey) ?? "[]");
@@ -2106,7 +2119,13 @@ export function createInjectionSource(features, {
     function enhanceGenericModelPicker(parentMenu, selector) {
       const identity = modelIdentity(nativeModelValue(parentMenu));
       const model = modelDefinitionFor(identity, selector);
-      const efforts = model?.supportedReasoningLevels ?? [];
+      const catalogModel = catalogModelFor(identity, selector);
+      const modelWithCapability = model?.modelSelectorCapability ? model : {
+        ...(model ?? {}),
+        ...(catalogModel ?? {}),
+        supportedReasoningLevels: model?.supportedReasoningLevels ?? catalogModel?.supportedReasoningLevels ?? [],
+      };
+      const efforts = visibleReasoningLevelsFor(modelWithCapability);
       if (!model || efforts.length < 2) return false;
       // 控制器推导的任务内实际 effort 优先，避免子任务/主任务切换后触发器属性滞后；
       // 触发器属性仅在控制器无法解析时作为实时回退，静态目录默认值最后兜底。
@@ -2116,9 +2135,19 @@ export function createInjectionSource(features, {
           ?.getAttribute("data-selected-reasoning-effort")
         ?? model.defaultReasoningLevel
         ?? efforts[0].effort;
+      const effortRank = (value) => {
+        const order = ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"];
+        const index = order.indexOf(String(value ?? "").toLowerCase());
+        return index < 0 ? -1 : index;
+      };
+      const visibleEffort = efforts.find((level) => level.effort === selectedEffort)?.effort
+        ?? efforts.filter((level) => effortRank(level.effort) <= effortRank(selectedEffort))
+          .sort((left, right) => effortRank(right.effort) - effortRank(left.effort))[0]?.effort
+        ?? efforts[0].effort;
+      const selectedEffortValue = visibleEffort;
       const selectedServiceTier = nativeComposerModelController()?.selectedServiceTier;
       const serviceTierKey = selectedServiceTier?.id ?? selectedServiceTier ?? "standard";
-      const key = `${identity.raw}:${selectedEffort}:${serviceTierKey}:${efforts.map((level) => level.effort).join(",")}`;
+      const key = `${identity.raw}:${selectedEffortValue}:${serviceTierKey}:${efforts.map((level) => level.effort).join(",")}`;
       const existing = parentMenu.querySelector(":scope > [data-codex-model-slider-generic]");
       const nativeTemplateReady = Boolean(
         parentMenu.firstElementChild
@@ -2140,7 +2169,7 @@ export function createInjectionSource(features, {
       existing?.remove();
       const nativeContainer = parentMenu.firstElementChild;
       if (!nativeContainer) return false;
-      const shell = createGenericModelSlider(parentMenu, selector, identity, model, selectedEffort);
+      const shell = createGenericModelSlider(parentMenu, selector, identity, model, selectedEffortValue);
       if (!shell) return false;
       if (!modelSelectorGenericContainers.has(nativeContainer)) {
         modelSelectorGenericContainers.set(nativeContainer, nativeContainer.style.display);

package/packages/runtime-host/src/main.mjs

@@ -11,6 +11,7 @@ import {
   selectEnabledFeatures,
   startFeatureProcesses,
 } from "./feature-registry.mjs";
+import { applyVisibleReasoningLevels, loadModelCapabilities } from "./model-capabilities.mjs";
 
 const runtimeRoot = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
 const featuresRoot = process.env.CODEX_FEATURES_ROOT ?? path.dirname(runtimeRoot);
@@ -22,8 +23,17 @@ const discoveredFeatures = await discoverFeatures(featuresRoot);
 if (!discoveredFeatures.length) throw new Error(`No codex-feature.json files found under ${featuresRoot}`);
 const features = selectEnabledFeatures(discoveredFeatures, process.env.MINECODEX_ENABLED_FEATURES);
 const modelCatalog = await loadConfiguredModelCatalog();
+const modelCapabilities = await loadModelCapabilities();
 for (const feature of features) {
-  if (feature.modelSelector) feature.modelSelector.models = modelCatalog;
+  if (feature.modelSelector) {
+    feature.modelSelector.models = modelCatalog.map((model) => (
+      applyVisibleReasoningLevels(
+        model,
+        modelCapabilities.get(String(model.slug ?? "").toLowerCase()),
+        model.supportedReasoningLevels,
+      )
+    ));
+  }
 }
 
 let readyWritePromise = Promise.resolve();

package/packages/runtime-host/src/model-capabilities.mjs

@@ -0,0 +1,86 @@
+import { readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+const CODEX_REASONING_ORDER = ["low", "medium", "high", "xhigh", "max", "ultra"];
+
+function uniqueLevels(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+
+
+function normalizedEfforts(entry) {
+  if (!Array.isArray(entry)) return null;
+  const levels = entry.map(String).filter((value) => (
+    CODEX_REASONING_ORDER.includes(value) || value === "none" || value === "minimal"
+  ));
+  return levels.length ? uniqueLevels(levels) : null;
+}
+
+export function resolveModelRecord(records, modelId) {
+  if (!records || typeof records !== "object") return undefined;
+  if (Object.prototype.hasOwnProperty.call(records, modelId)) return records[modelId];
+  const folded = modelId.toLowerCase();
+  for (const [key, value] of Object.entries(records)) {
+    if (key.toLowerCase() === folded) return value;
+  }
+  return undefined;
+}
+
+export function mergeCapability(providerConfig, modelId) {
+  if (!providerConfig) return null;
+  const configuredEfforts = normalizedEfforts(
+    resolveModelRecord(providerConfig.modelReasoningEfforts, modelId),
+  );
+  if (configuredEfforts) {
+    return {
+      source: "opencodex",
+      kind: "effort",
+      levels: uniqueLevels(configuredEfforts),
+      map: resolveModelRecord(providerConfig.modelReasoningEffortMap, modelId) ?? null,
+      rawEfforts: configuredEfforts,
+    };
+  }
+  if (Array.isArray(providerConfig.noReasoningModels) && providerConfig.noReasoningModels.includes(modelId)) {
+    return { source: "opencodex", kind: "no-effort", levels: null, map: null, rawEfforts: [] };
+  }
+  return null;
+}
+
+export async function loadModelCapabilities({
+  opencodexConfigPath = process.env.OPENCODEX_CONFIG_PATH ?? path.join(os.homedir(), ".opencodex", "config.json"),
+  read = readFile,
+} = {}) {
+  const configPayload = await read(opencodexConfigPath, "utf8").then((value) => JSON.parse(value)).catch(() => null);
+  const providers = configPayload?.providers ?? {};
+  const result = new Map();
+  for (const [providerId, providerConfig] of Object.entries(providers)) {
+    const modelIds = new Set([
+      ...Object.keys(providerConfig?.modelReasoningEfforts ?? {}),
+      ...Object.keys(providerConfig?.modelReasoningEffortMap ?? {}),
+      ...Object.keys(providerConfig?.thinkingToggleModels ?? {}),
+      ...Object.keys(providerConfig?.thinkingBudgetModels ?? {}),
+      ...(Array.isArray(providerConfig?.noReasoningModels) ? providerConfig.noReasoningModels : []),
+    ]);
+    for (const modelId of modelIds) {
+      const capability = mergeCapability(providerConfig, modelId);
+      if (capability) result.set(`${providerId}/${modelId}`.toLowerCase(), capability);
+    }
+  }
+  return result;
+}
+
+export function applyVisibleReasoningLevels(catalogModel, capability, fallbackLevels) {
+  if (!catalogModel) return catalogModel;
+  const rawLevels = Array.isArray(fallbackLevels) ? fallbackLevels : (catalogModel.supportedReasoningLevels ?? []);
+  if (!Array.isArray(rawLevels)) return catalogModel;
+  if (capability && Array.isArray(capability.levels)) {
+    const allowed = new Set(capability.levels);
+    const visible = rawLevels.filter((level) => {
+      const effort = String(level?.effort ?? level ?? "").toLowerCase();
+      return allowed.has(effort);
+    });
+    return { ...catalogModel, supportedReasoningLevels: visible, modelSelectorCapability: capability };
+  }
+  return { ...catalogModel, modelSelectorCapability: capability ?? null };
+}