@hugo.bastidas/minimax-plugin 0.1.0

package/scripts/install.mjs

@@ -0,0 +1,548 @@
+#!/usr/bin/env node
+import { select, multiselect, text, confirm, outro, isCancel } from '@clack/prompts';
+import {
+  writeClaudeConfig,
+  removeClaudeConfig,
+  readClaudeMiniMaxEnv,
+  writeClaudeHooksConfig,
+  removeClaudeHooksConfig,
+  writeClaudeGlobalInstructions,
+  removeClaudeGlobalInstructions,
+} from '../dist/install/claude-config.js';
+import {
+  writeOpenCodeConfig,
+  removeOpenCodeConfig,
+  writeOpenCodeGlobalInstructions,
+  removeOpenCodeGlobalInstructions,
+} from '../dist/install/opencode-config.js';
+import {
+  writeCodexConfig,
+  removeCodexConfig,
+  readCodexMiniMaxEnv,
+  writeCodexGlobalInstructions,
+  removeCodexGlobalInstructions,
+} from '../dist/install/codex-config.js';
+import { readOpenCodeMiniMaxEnv } from '../dist/install/opencode-config.js';
+import { removeClaudeNativeMultimodalConfig, removeOpenCodeNativeMultimodalConfig, removeCodexNativeMultimodalConfig } from '../dist/install/native-multimodal-config.js';
+import { writeShellAlias, removeShellAlias, isShellAliasInstalled, isLegacyAliasInstalled, shellRcPath, DEFAULT_ALIAS_NAME } from '../dist/install/shell-alias.js';
+import { existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { execSync } from 'node:child_process';
+
+const CLAUDE_CONFIG_PATH = join(homedir(), '.claude.json');
+const CLAUDE_SETTINGS_PATH = join(homedir(), '.claude', 'settings.json');
+const CLAUDE_GLOBAL_INSTRUCTIONS_PATH = join(homedir(), '.claude', 'CLAUDE.md');
+const OPENCODE_CONFIG_PATH = join(homedir(), '.config', 'opencode', 'opencode.jsonc');
+const OPENCODE_GLOBAL_INSTRUCTIONS_PATH = join(homedir(), '.config', 'opencode', 'AGENTS.md');
+const CODEX_CONFIG_PATH = join(homedir(), '.codex', 'config.toml');
+const CODEX_GLOBAL_INSTRUCTIONS_PATH = join(homedir(), '.codex', 'AGENTS.md');
+
+// Rutas por host, reutilizadas por instalación, desinstalación y estado.
+const HOST_PATHS = {
+  claude: { config: CLAUDE_CONFIG_PATH, hooks: CLAUDE_SETTINGS_PATH, instructions: CLAUDE_GLOBAL_INSTRUCTIONS_PATH },
+  codex: { config: CODEX_CONFIG_PATH, instructions: CODEX_GLOBAL_INSTRUCTIONS_PATH },
+  opencode: { config: OPENCODE_CONFIG_PATH, instructions: OPENCODE_GLOBAL_INSTRUCTIONS_PATH },
+};
+
+// Expande el target elegido a la lista concreta de hosts afectados.
+function hostsForTarget(target) {
+  if (Array.isArray(target)) return target;
+  return target === 'all' ? ['claude', 'codex', 'opencode'] : [target];
+}
+
+function getDistPath() {
+  return join(import.meta.dirname ?? '.', '..', 'dist', 'index.js');
+}
+
+function getClaudeHookPath() {
+  return join(import.meta.dirname ?? '.', '..', 'dist', 'hooks', 'claude-routing-reminder.js');
+}
+
+function commandExists(command) {
+  try {
+    execSync(`command -v ${command}`, { stdio: 'ignore', shell: '/bin/sh' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function safeCommandVersion(command, args = ['--version']) {
+  try {
+    return execSync([command, ...args].join(' '), { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim() || 'installed';
+  } catch {
+    return commandExists(command) ? 'installed' : 'missing';
+  }
+}
+
+function getDotEnvValue(name) {
+  try {
+    const dotenvPath = join(process.cwd(), '.env');
+    if (existsSync(dotenvPath)) {
+      const content = readFileSync(dotenvPath, 'utf8');
+      const match = content.match(new RegExp(`^${name}=(.+)$`, 'm'));
+      if (match) return match[1].trim().replace(/^["']|["']$/g, '');
+    }
+  } catch { /* ignore */ }
+  return '';
+}
+
+function getApiKey() {
+  const existing = process.env.MINIMAX_API_KEY ?? '';
+  if (existing) return existing;
+  return getDotEnvValue('MINIMAX_API_KEY');
+}
+
+async function getExistingEnvForTarget(target) {
+  const hosts = hostsForTarget(target);
+  const candidates = [
+    {
+      MINIMAX_API_KEY: getApiKey(),
+      MINIMAX_API_MODE: process.env.MINIMAX_API_MODE ?? getDotEnvValue('MINIMAX_API_MODE'),
+      MINIMAX_MODEL: process.env.MINIMAX_MODEL ?? getDotEnvValue('MINIMAX_MODEL'),
+    },
+  ];
+  if (hosts.includes('claude')) candidates.push(await readClaudeMiniMaxEnv(CLAUDE_CONFIG_PATH));
+  if (hosts.includes('codex')) candidates.push(await readCodexMiniMaxEnv(CODEX_CONFIG_PATH));
+  if (hosts.includes('opencode')) candidates.push(await readOpenCodeMiniMaxEnv(OPENCODE_CONFIG_PATH));
+
+  return candidates.reduce((merged, current) => ({
+    ...merged,
+    ...Object.fromEntries(Object.entries(current).filter(([, value]) => typeof value === 'string' && value.trim())),
+  }), {});
+}
+
+const MAX_TEXT_MODEL_CHOICES = 1;
+const FALLBACK_TEXT_MODELS = ['MiniMax-M3'];
+
+function isAllowedTextModel(model) {
+  return typeof model === 'string' && /^MiniMax-M/i.test(model) && !/highspeed/i.test(model);
+}
+
+function uniqueAllowedModels(models) {
+  return [...new Set(models.map((model) => model?.toString().trim()).filter(isAllowedTextModel))];
+}
+
+function latestAllowedModels(models) {
+  return uniqueAllowedModels(models).slice(0, MAX_TEXT_MODEL_CHOICES);
+}
+
+async function listAvailableTextModels(apiKey, mode) {
+  const isOpenAi = mode === 'openai';
+  const url = isOpenAi ? 'https://api.minimax.io/v1/models' : 'https://api.minimax.io/anthropic/v1/models';
+  const headers = isOpenAi ? { Authorization: `Bearer ${apiKey}` } : { 'X-Api-Key': apiKey };
+  const response = await fetch(url, { headers, signal: AbortSignal.timeout(5000) });
+  if (!response.ok) throw new Error(`MiniMax model list failed: HTTP ${response.status}`);
+  const payload = await response.json();
+  return latestAllowedModels((payload.data ?? []).map((model) => model.id));
+}
+
+async function getModelFromUser(apiKey, mode, existingModel) {
+  let models = [];
+  try {
+    const availableModels = await listAvailableTextModels(apiKey, mode);
+    models = latestAllowedModels(availableModels);
+  } catch (err) {
+    console.warn(`Could not fetch MiniMax model list; using bundled fallback list (${err?.message ?? err})`);
+    models = latestAllowedModels(FALLBACK_TEXT_MODELS);
+  }
+  if (!models.length) models = FALLBACK_TEXT_MODELS;
+
+  const initialValue = models.includes(existingModel) ? existingModel : models[0];
+  const model = await select({
+    message: 'MINIMAX_MODEL (highspeed variants excluded)',
+    options: models.map((value) => ({
+      value,
+      label: value === initialValue ? `${value} (current/default)` : value,
+    })),
+    initialValue,
+  });
+  if (isCancel(model)) process.exit(1);
+  return model.toString();
+}
+
+async function getEnvFromUser(existing = {}) {
+  const existingApiKey = existing.MINIMAX_API_KEY ?? '';
+  const apiKey = await text({
+    message: existingApiKey ? 'MINIMAX_API_KEY (press Enter to keep existing)' : 'MINIMAX_API_KEY',
+    placeholder: existingApiKey ? 'keep existing key' : undefined,
+    defaultValue: existingApiKey || undefined,
+  });
+  if (isCancel(apiKey) || !apiKey?.trim()) { outro('API key is required'); process.exit(1); }
+  const existingMode = existing.MINIMAX_API_MODE === 'openai' ? 'openai' : 'anthropic';
+  const modeOptions = existingMode === 'openai'
+    ? [{ value: 'openai', label: 'openai (current)' }, { value: 'anthropic', label: 'anthropic' }]
+    : [{ value: 'anthropic', label: 'anthropic (default/current)' }, { value: 'openai', label: 'openai' }];
+  const mode = await select({ message: 'MINIMAX_API_MODE', options: modeOptions });
+  if (isCancel(mode)) process.exit(1);
+  const existingModel = existing.MINIMAX_MODEL || 'MiniMax-M3';
+  const model = await getModelFromUser(apiKey.trim(), mode, existingModel);
+  return { apiKey: apiKey.trim(), mode, model };
+}
+
+
+// Garantiza que existan los artefactos compilados que necesita el Core MCP.
+async function ensureBuilt() {
+  const distPath = getDistPath();
+  const hookPath = getClaudeHookPath();
+  if (!existsSync(distPath) || !existsSync(hookPath)) {
+    const shouldBuild = await confirm({ message: 'dist files not found. Build now?', default: true });
+    if (isCancel(shouldBuild) || !shouldBuild) { outro('Aborted'); process.exit(1); }
+    execSync('npm run build', { stdio: 'inherit' });
+  }
+}
+
+// --- Operaciones por componente (cada una recorre los hosts del target) ---
+
+
+async function removeLegacyNativeMultimodal(target) {
+  const hosts = hostsForTarget(target);
+  if (hosts.includes('claude')) await removeClaudeNativeMultimodalConfig(CLAUDE_CONFIG_PATH);
+  if (hosts.includes('opencode')) await removeOpenCodeNativeMultimodalConfig(OPENCODE_CONFIG_PATH);
+  if (hosts.includes('codex')) await removeCodexNativeMultimodalConfig(CODEX_CONFIG_PATH);
+}
+
+async function installCore(target, ctx) {
+  await removeLegacyNativeMultimodal(target);
+  console.log('Removed legacy native minimax_multimodal MCP entry if present');
+  const distPath = getDistPath();
+  const { env } = ctx;
+  const server = { command: 'node', args: [distPath], env: { MINIMAX_API_KEY: env.apiKey, MINIMAX_API_MODE: env.mode, MINIMAX_MODEL: env.model } };
+  const hosts = hostsForTarget(target);
+
+  if (hosts.includes('claude')) {
+    await writeClaudeConfig(CLAUDE_CONFIG_PATH, server);
+    await writeClaudeGlobalInstructions(CLAUDE_GLOBAL_INSTRUCTIONS_PATH);
+    await writeClaudeHooksConfig(CLAUDE_SETTINGS_PATH, getClaudeHookPath());
+    console.log(`Installed minimax in ${CLAUDE_CONFIG_PATH}`);
+    console.log(`Installed MiniMax routing reference in ${CLAUDE_GLOBAL_INSTRUCTIONS_PATH}`);
+    console.log(`Installed MiniMax routing hooks in ${CLAUDE_SETTINGS_PATH}`);
+  }
+  if (hosts.includes('opencode')) {
+    const dir = dirname(OPENCODE_CONFIG_PATH);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    await writeOpenCodeConfig(OPENCODE_CONFIG_PATH, server);
+    await writeOpenCodeGlobalInstructions(OPENCODE_GLOBAL_INSTRUCTIONS_PATH);
+    console.log(`Installed minimax in ${OPENCODE_CONFIG_PATH}`);
+    console.log(`Installed MiniMax routing reference in ${OPENCODE_GLOBAL_INSTRUCTIONS_PATH}`);
+  }
+  if (hosts.includes('codex')) {
+    const dir = dirname(CODEX_CONFIG_PATH);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    await writeCodexConfig(CODEX_CONFIG_PATH, server);
+    await writeCodexGlobalInstructions(CODEX_GLOBAL_INSTRUCTIONS_PATH);
+    console.log(`Installed minimax in ${CODEX_CONFIG_PATH}`);
+    console.log(`Installed MiniMax routing reference in ${CODEX_GLOBAL_INSTRUCTIONS_PATH}`);
+  }
+}
+
+async function uninstallCore(target) {
+  await removeLegacyNativeMultimodal(target);
+  console.log('Removed legacy native minimax_multimodal MCP entry if present');
+  const hosts = hostsForTarget(target);
+  if (hosts.includes('claude')) {
+    if (existsSync(CLAUDE_CONFIG_PATH)) {
+      await removeClaudeConfig(CLAUDE_CONFIG_PATH);
+      console.log(`Removed minimax from ${CLAUDE_CONFIG_PATH}`);
+    }
+    if (existsSync(CLAUDE_SETTINGS_PATH)) {
+      await removeClaudeHooksConfig(CLAUDE_SETTINGS_PATH);
+      console.log(`Removed MiniMax routing hooks from ${CLAUDE_SETTINGS_PATH}`);
+    }
+    await removeClaudeGlobalInstructions(CLAUDE_GLOBAL_INSTRUCTIONS_PATH);
+    console.log(`Removed MiniMax routing references from ${CLAUDE_GLOBAL_INSTRUCTIONS_PATH}`);
+  }
+  if (hosts.includes('opencode')) {
+    if (existsSync(OPENCODE_CONFIG_PATH)) {
+      await removeOpenCodeConfig(OPENCODE_CONFIG_PATH);
+      console.log(`Removed minimax from ${OPENCODE_CONFIG_PATH}`);
+    }
+    await removeOpenCodeGlobalInstructions(OPENCODE_GLOBAL_INSTRUCTIONS_PATH);
+    console.log(`Removed MiniMax routing references from ${OPENCODE_GLOBAL_INSTRUCTIONS_PATH}`);
+  }
+  if (hosts.includes('codex')) {
+    if (existsSync(CODEX_CONFIG_PATH)) {
+      await removeCodexConfig(CODEX_CONFIG_PATH);
+      console.log(`Removed minimax from ${CODEX_CONFIG_PATH}`);
+    }
+    await removeCodexGlobalInstructions(CODEX_GLOBAL_INSTRUCTIONS_PATH);
+    console.log(`Removed MiniMax routing references from ${CODEX_GLOBAL_INSTRUCTIONS_PATH}`);
+  }
+}
+
+async function installMiniMaxCli() {
+  execSync('npm install -g mmx-cli', { stdio: 'inherit' });
+  console.log(`Installed MiniMax CLI: ${safeCommandVersion('mmx')}`);
+}
+
+function ensurePluginLinked() {
+  const pluginRoot = join(import.meta.dirname ?? '.', '..');
+  const cliDist = join(pluginRoot, 'dist', 'cli.js');
+  if (!existsSync(cliDist)) return;
+  try {
+    execSync('npm link', { stdio: 'inherit', cwd: pluginRoot });
+    console.log('Linked minimax CLI globally (minimax gain available from any folder)');
+  } catch (err) {
+    console.warn('Could not link minimax CLI globally:', err?.message ?? err);
+  }
+}
+
+async function uninstallMiniMaxCli() {
+  execSync('npm uninstall -g mmx-cli', { stdio: 'inherit' });
+  console.log('Removed MiniMax CLI (mmx)');
+}
+
+// --- Registro de componentes: única fuente de verdad del instalador ---
+// Cada componente declara sus dependencias, si necesita credenciales/build,
+// y cómo instalarse, desinstalarse y detectarse. Agregar uno nuevo es agregar
+// una entrada aquí, sin tocar el flujo del menú.
+const COMPONENTS = [
+  {
+    id: 'core',
+    label: 'Core MCP',
+    hint: 'Coding/delegation MCP, mmx CLI wrapper tools, MINIMAX.md routing, and Claude Code hooks.',
+    requires: ['cli'],
+    needsEnv: true,
+    needsBuild: true,
+    install: installCore,
+    uninstall: uninstallCore,
+    isInstalled: (paths) => hasCoreMcpConfig(paths.config),
+  },
+  {
+    id: 'cli',
+    label: 'MiniMax CLI (mmx)',
+    hint: 'Official mmx CLI installed globally (host-independent).',
+    requires: [],
+    needsEnv: false,
+    hostIndependent: true,
+    install: installMiniMaxCli,
+    uninstall: uninstallMiniMaxCli,
+    isInstalled: () => commandExists('mmx'),
+  },
+  {
+    id: 'alias',
+    label: 'Shell alias (cc-mini)',
+    hint: 'Shell function that launches Claude Code pointing to MiniMax API (writes to ~/.zshrc).',
+    requires: [],
+    needsEnv: true,
+    hostIndependent: true,
+    install: async (_target, ctx) => {
+      const aliasName = await text({
+        message: 'Alias name',
+        placeholder: DEFAULT_ALIAS_NAME,
+        defaultValue: DEFAULT_ALIAS_NAME,
+      });
+      if (isCancel(aliasName)) { outro('Cancelled'); process.exit(0); }
+      const name = (aliasName?.toString().trim() || DEFAULT_ALIAS_NAME);
+      if (isLegacyAliasInstalled()) {
+        console.log('Migrating legacy claude-minimax alias → removing old block');
+      }
+      await writeShellAlias(ctx.env.apiKey, ctx.env.model, name);
+      console.log(`Installed ${name} function in ${shellRcPath()}`);
+      console.log(`Run: source ~/.zshrc  (or open a new terminal) to activate ${name}`);
+    },
+    uninstall: async () => {
+      await removeShellAlias();
+      console.log(`Removed shell alias from ${shellRcPath()}`);
+    },
+    isInstalled: () => isShellAliasInstalled(),
+  },
+];
+
+const COMPONENT_MAP = Object.fromEntries(COMPONENTS.map((component) => [component.id, component]));
+
+// Agrega las dependencias requeridas (p. ej. superpowers exige core).
+function withDependencies(ids) {
+  const set = new Set(ids);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const id of [...set]) {
+      for (const dep of COMPONENT_MAP[id].requires) {
+        if (!set.has(dep)) { set.add(dep); changed = true; }
+      }
+    }
+  }
+  return set;
+}
+
+// Reordena ids según el orden declarado en COMPONENTS (core antes que superpowers, etc.).
+function orderComponents(ids) {
+  const set = ids instanceof Set ? ids : new Set(ids);
+  return COMPONENTS.filter((component) => set.has(component.id)).map((component) => component.id);
+}
+
+function isComponentInstalled(component, target) {
+  if (component.hostIndependent) return component.isInstalled();
+  return hostsForTarget(target).some((host) => component.isInstalled(HOST_PATHS[host]));
+}
+
+function computeInstalledIds(target) {
+  return COMPONENTS.filter((component) => isComponentInstalled(component, target)).map((component) => component.id);
+}
+
+function yesNo(value) {
+  return value ? 'yes' : 'no';
+}
+
+function fileContains(path, value) {
+  try { return readFileSync(path, 'utf8').includes(value); } catch { return false; }
+}
+
+function hasCoreMcpConfig(path) {
+  return fileContains(path, '"minimax"') || fileContains(path, '[mcp_servers.minimax]');
+}
+
+function hostStatusRow(name, paths) {
+  const dir = dirname(paths.instructions);
+  return {
+    Host: name,
+    CoreMCP: yesNo(hasCoreMcpConfig(paths.config)),
+    NativeMCP: yesNo(fileContains(paths.config, 'minimax_multimodal')),
+    Hooks: paths.hooks ? yesNo(existsSync(paths.hooks)) : '-',
+    Global: yesNo(existsSync(paths.instructions)),
+    MiniMax: yesNo(existsSync(join(dir, 'MINIMAX.md'))),
+  };
+}
+
+async function showStatus() {
+  const existingKey = getApiKey();
+  console.log('MiniMax environment');
+  console.table([{
+    API_KEY: existingKey ? 'configured' : 'missing',
+    API_MODE: process.env.MINIMAX_API_MODE ?? 'anthropic (default)',
+    MODEL: process.env.MINIMAX_MODEL ?? 'MiniMax-M3 (default)',
+    MMX_CLI: safeCommandVersion('mmx'),
+  }]);
+
+  console.log('Host installation');
+  console.table([
+    hostStatusRow('Claude', HOST_PATHS.claude),
+    hostStatusRow('Codex', HOST_PATHS.codex),
+    hostStatusRow('OpenCode', HOST_PATHS.opencode),
+  ]);
+
+  console.log('Shell alias');
+  const hasLegacy = isLegacyAliasInstalled();
+  console.table([{
+    alias: isShellAliasInstalled() ? 'installed' : 'missing',
+    'legacy (claude-minimax)': hasLegacy ? 'yes → run install to migrate' : 'no',
+    'rc file': shellRcPath(),
+  }]);
+}
+
+async function selectTarget() {
+  const targets = await multiselect({
+    message: 'Target host? (space to select, enter to confirm)',
+    options: [
+      { value: 'claude', label: 'Claude Code' },
+      { value: 'codex', label: 'Codex' },
+      { value: 'opencode', label: 'OpenCode' },
+    ],
+    required: true,
+  });
+  if (isCancel(targets)) process.exit(1);
+  return targets;
+}
+
+// Flujo unificado de instalar/actualizar: una sola lista de componentes.
+async function runInstallOrUpdate(action, target) {
+  const isUpdate = action === 'update';
+  const installed = computeInstalledIds(target);
+  const initialValues = isUpdate ? installed : (installed.length ? installed : ['core']);
+
+  const picked = await multiselect({
+    message: isUpdate ? 'Components to refresh' : 'Components to install',
+    options: COMPONENTS.map((component) => ({ value: component.id, label: component.label, hint: component.hint })),
+    initialValues,
+    required: false,
+  });
+  if (isCancel(picked)) process.exit(1);
+
+  const resolved = withDependencies(picked);
+  const added = [...resolved].filter((id) => !picked.includes(id));
+  if (added.length) console.log(`Added required components: ${orderComponents(added).join(', ')}`);
+
+  const selected = orderComponents(resolved);
+  if (selected.length === 0) { outro('Nothing selected'); return; }
+
+  // CLI es global sin env: se maneja una sola vez antes de todo.
+  if (selected.includes('cli')) await installMiniMaxCli();
+  const nonCliComponents = selected.filter((id) => id !== 'cli');
+
+  if (nonCliComponents.length === 0) { outro(isUpdate ? 'Updated' : 'Installed'); return; }
+
+  const needsEnv = nonCliComponents.some((id) => COMPONENT_MAP[id].needsEnv);
+  const ctx = {};
+  if (needsEnv) ctx.env = await getEnvFromUser(await getExistingEnvForTarget(target));
+  if (nonCliComponents.some((id) => COMPONENT_MAP[id].needsBuild)) await ensureBuilt();
+
+  // Componentes host-independientes con env (alias) se instalan una sola vez.
+  for (const id of nonCliComponents.filter((id) => COMPONENT_MAP[id].hostIndependent)) {
+    await COMPONENT_MAP[id].install(null, ctx);
+  }
+  // Componentes específicos de host.
+  for (const id of nonCliComponents.filter((id) => !COMPONENT_MAP[id].hostIndependent)) {
+    await COMPONENT_MAP[id].install(target, ctx);
+  }
+  // Si el alias está instalado y se recolectó env pero el alias no fue seleccionado
+  // explícitamente, sincronizarlo automáticamente con las nuevas credenciales.
+  if (ctx.env && isShellAliasInstalled() && !selected.includes('alias')) {
+    await writeShellAlias(ctx.env.apiKey, ctx.env.model);
+    console.log(`Synced shell alias credentials in ${shellRcPath()}`);
+  }
+  ensurePluginLinked();
+  outro(isUpdate ? 'Updated' : 'Installed');
+}
+
+async function runUninstall(target) {
+  const installed = computeInstalledIds(target);
+  if (installed.length === 0) { outro('No MiniMax components installed for this target'); return; }
+
+  const picked = await multiselect({
+    message: 'Components to remove',
+    options: COMPONENTS.filter((component) => installed.includes(component.id)).map((component) => ({ value: component.id, label: component.label, hint: component.hint })),
+    initialValues: installed,
+    required: false,
+  });
+  if (isCancel(picked)) process.exit(1);
+  if (picked.length === 0) { outro('Nothing selected'); return; }
+
+  // Core en desinstalación arrastra la rutina Superpowers dependiente.
+  for (const id of orderComponents(picked)) {
+    await COMPONENT_MAP[id].uninstall(target);
+  }
+  outro('Uninstalled');
+}
+
+async function main() {
+  const action = await select({ message: 'Choose an action', options: [
+    { value: 'install', label: 'Install', hint: 'Pick components to add to a host.' },
+    { value: 'update', label: 'Update', hint: 'Refresh credentials and re-write installed components.' },
+    { value: 'uninstall', label: 'Uninstall', hint: 'Pick MiniMax components to remove from a host.' },
+    { value: 'status', label: 'Status', hint: 'Show installed configs, docs, and credential presence.' },
+    { value: 'exit', label: 'Exit', hint: 'Quit the installer.' },
+  ] });
+  if (isCancel(action) || action === 'exit') { outro('Goodbye'); process.exit(0); }
+
+  if (action === 'status') {
+    await showStatus();
+    outro('Done');
+    return;
+  }
+
+  const target = await selectTarget();
+
+  if (action === 'uninstall') {
+    await runUninstall(target);
+    return;
+  }
+
+  await runInstallOrUpdate(action, target);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/scripts/opencode-config.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+// OpenCode config mutation helpers - delegates to TypeScript implementation
+export { writeOpenCodeConfig, removeOpenCodeConfig } from '../dist/install/opencode-config.js';

package/skills/minimax-delegation/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: minimax-delegation
+description: Use when Claude/Codex already has a plan and wants MiniMax to perform bounded implementation-worker tasks through MCP without taking over planning, debugging, architecture, or final review.
+---
+
+# MiniMax Worker Delegation
+
+Use MiniMax as a secondary implementation worker, not as the primary agent.
+
+Claude/Codex must remain responsible for planning, architecture, debugging, review, verification, and final authority. Delegate to MiniMax only after the host has defined the task, constraints, target paths, and expected output.
+
+Good MiniMax work:
+
+- Draft implementation changes from a host-approved plan
+- Mechanical refactors with explicit instructions
+- Documentation updates
+- Test scaffold drafts when the host specifies behavior
+- Migration or boilerplate generation
+- Context compression/intake summaries
+- Optional cheap second opinions, never authoritative decisions
+
+Do not delegate secrets, `.env` files, `.git`, dependency folders, root-cause debugging, architecture decisions, or final review. Treat MiniMax output as a draft artifact that Claude/Codex must inspect before applying.
+
+If a MiniMax tool call fails, times out, or returns unusable/unsafe output, report that failure to the user and stop the delegated path. Do not silently continue as if MiniMax succeeded; switch to local work only after making the fallback explicit.