invokora 0.1.0

package/dist/cli/app.js

@@ -0,0 +1,1087 @@
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { RELEASE_VERSION } from './release.js';
+import { CONFIG_PATH, DEFAULT_BACKEND_URL, LANGUAGE_PATH, SYNC_SCOPE_ALIASES, SYNC_TARGET_ALIASES } from './constants.js';
+import { ConfigStore } from './config.js';
+import { McpConfigService } from './mcp_setup.js';
+import { OAuthBrowserLoginFlow, parseLoginCommandOptions } from './oauth.js';
+import { CliPrompts } from './prompts.js';
+import { InvokoraApiClient, SkillShellManager } from './skills.js';
+import { getErrorMessage } from './mcp/errors.js';
+import { startStdioServer } from './mcp/app.js';
+const USAGE_TEXT_EN = `
+invokora CLI
+
+Commands:
+  -h, --help                   Print CLI help
+  -v, --version                Print CLI version
+  login [--timeout <ms>] [--no-open]
+                               Authenticate via browser OAuth loopback callback
+  language [en|zh]             Show or set CLI language
+  sync [--prune]               Sync local skills interactively
+    --scope <scope>            project | user
+    --target <client>          Repeatable: codex | claude | claudecode | cursor
+    --yes                      Non-interactive mode
+  skill add                    Add or refresh local skills
+    --scope <scope>            project | user
+    --target <client>          Repeatable: codex | claude | claudecode | cursor
+    --yes                      Add all syncable skills without prompt
+  skill prune                  Sync and remove stale Invokora-managed local skills
+    --scope <scope>            project | user
+    --target <client>          Repeatable: codex | claude | claudecode | cursor
+    --yes                      Non-interactive mode
+  skill remove                 Remove Invokora-managed local skills
+    --scope <scope>            project | user
+    --target <client>          Repeatable: codex | claude | claudecode | cursor
+    --yes                      Remove all managed skills without prompt
+  workflow add                 Add or refresh local skills from selected workflows
+    --scope <scope>            project | user
+    --target <client>          Repeatable: codex | claude | claudecode | cursor
+    --yes                      Add all syncable workflows without prompt
+  mcp serve                    Start the stdio MCP server
+  mcp setup                    Setup MCP config in Claude/Cursor/Codex
+    --target <client>          Repeatable: claude | cursor | codex
+    --path <file>              Optional explicit config path (repeat with target order)
+    --yes                      Non-interactive mode
+  mcp defaults                 Show or set MCP default model/reason
+    --model <model>            Default model for new MCP chat sessions
+    --reason <effort>          Default reasoning effort: low | medium | high | xhigh
+    --clear-model              Clear default model
+    --clear-reason             Clear default reasoning effort
+
+Examples:
+  invokora login                           # Open browser login and save local token
+  invokora --version                       # Print CLI version
+  invokora language zh                     # Show CLI help in Chinese
+  invokora login --no-open                 # Print login URL without opening browser
+  invokora login --timeout 180000          # Wait up to 180 seconds for login callback
+  invokora sync                            # Choose scope and clients interactively
+  invokora sync --scope project --target codex --yes
+                                        # Sync into project Codex skills without prompts
+  invokora skill add                       # Choose local skills to add or refresh
+  invokora skill prune --scope project --target cursor --yes
+                                        # Sync Cursor skills and prune stale managed skills
+  invokora skill remove --scope project --target codex --yes
+                                        # Remove project Codex Invokora-managed skills
+  invokora workflow add                  # Choose workflows to add or refresh
+  invokora mcp serve                       # Start stdio MCP server
+  invokora mcp setup                       # Setup MCP config interactively
+  invokora mcp setup --target claude --yes # Setup Claude MCP config without prompts
+  invokora mcp defaults --model gpt-5.4 --reason high
+                                        # Set MCP default model and reasoning effort
+`.trim();
+const USAGE_TEXT_ZH = `
+invokora CLI
+
+命令：
+  -h, --help                   输出 CLI help
+  -v, --version                输出 CLI 版本
+  login [--timeout <ms>] [--no-open]
+                               通过浏览器 OAuth 回调登录
+  language [en|zh]             查看或设置 CLI 语言
+  sync [--prune]               交互式同步可本地使用的 skills
+    --scope <scope>            project | user
+    --target <client>          可重复：codex | claude | claudecode | cursor
+    --yes                      非交互模式
+  skill add                    新增或刷新本地 skills
+    --scope <scope>            project | user
+    --target <client>          可重复：codex | claude | claudecode | cursor
+    --yes                      免选择新增全部可同步 skills
+  skill prune                  同步并清理失效的 Invokora 托管本地 skills
+    --scope <scope>            project | user
+    --target <client>          可重复：codex | claude | claudecode | cursor
+    --yes                      非交互模式
+  skill remove                 删除 Invokora 托管本地 skills
+    --scope <scope>            project | user
+    --target <client>          可重复：codex | claude | claudecode | cursor
+    --yes                      免选择删除全部托管 skills
+  workflow add                 新增或刷新所选 workflow 的本地 skills
+    --scope <scope>            project | user
+    --target <client>          可重复：codex | claude | claudecode | cursor
+    --yes                      免选择新增全部可同步 workflows
+  mcp serve                    启动 stdio MCP server
+  mcp setup                    写入 Claude/Cursor/Codex MCP 配置
+    --target <client>          可重复：claude | cursor | codex
+    --path <file>              可选配置路径，顺序对应 target
+    --yes                      非交互模式
+  mcp defaults                 查看或设置 MCP 默认模型 / 思考深度
+    --model <model>            新 MCP 会话默认模型
+    --reason <effort>          默认思考深度：low | medium | high | xhigh
+    --clear-model              清除默认模型
+    --clear-reason             清除默认思考深度
+
+示例：
+  invokora login                           # 打开浏览器登录并保存本地 token
+  invokora --version                       # 输出 CLI 版本
+  invokora language en                     # 使用英文显示 CLI help
+  invokora login --no-open                 # 只打印登录 URL，不自动打开浏览器
+  invokora login --timeout 180000          # 等待登录回调最多 180 秒
+  invokora sync                            # 交互式选择同步范围和客户端
+  invokora sync --scope project --target codex --yes
+                                        # 免交互同步到项目级 Codex skills
+  invokora skill add                       # 选择要新增或刷新的本地 skills
+  invokora skill prune --scope project --target cursor --yes
+                                        # 同步 Cursor skills 并清理失效托管目录
+  invokora skill remove --scope project --target codex --yes
+                                        # 删除项目级 Codex 的 Invokora 托管 skills
+  invokora workflow add                  # 选择要新增或刷新的 workflows
+  invokora mcp serve                       # 启动 stdio MCP server
+  invokora mcp setup                       # 交互式写入 MCP 配置
+  invokora mcp setup --target claude --yes # 免确认写入 Claude MCP 配置
+  invokora mcp defaults --model gpt-5.4 --reason high
+                                        # 设置 MCP 默认模型和思考深度
+`.trim();
+const HELP_TEXT_EN = {
+    root: USAGE_TEXT_EN,
+    login: `
+Usage: invokora login [--timeout <ms>] [--no-open]
+
+Authenticate via browser OAuth loopback callback.
+
+Options:
+  -h, --help                   Print login help
+  --timeout <ms>               Wait for login callback; default 120000
+  --no-open                    Print login URL without opening browser
+`.trim(),
+    language: `
+Usage: invokora language [en|zh]
+
+Show or set CLI language.
+
+Options:
+  -h, --help                   Print language help
+`.trim(),
+    sync: `
+Usage: invokora sync [--prune] [--scope <scope>] [--target <client>] [--yes]
+
+Sync local skills interactively.
+
+Options:
+  -h, --help                   Print sync help
+  --prune                      Remove stale Invokora-managed local skills
+  --scope <scope>              project | user
+  --target <client>            Repeatable: codex | claude | claudecode | cursor
+  --yes                        Non-interactive mode
+`.trim(),
+    skill: `
+Skill Commands:
+  invokora skill add           Add or refresh local skills
+  invokora skill prune         Sync and remove stale managed skills
+  invokora skill remove        Remove managed local skills
+
+Options:
+  -h, --help                   Print skill help
+`.trim(),
+    'skill-add': `
+Usage: invokora skill add [--scope <scope>] [--target <client>] [--yes]
+
+Add or refresh local skills.
+
+Options:
+  -h, --help                   Print skill add help
+  --scope <scope>              project | user
+  --target <client>            Repeatable: codex | claude | claudecode | cursor
+  --yes                        Add all syncable skills without prompt
+`.trim(),
+    'skill-prune': `
+Usage: invokora skill prune [--scope <scope>] [--target <client>] [--yes]
+
+Sync and remove stale Invokora-managed local skills.
+
+Options:
+  -h, --help                   Print skill prune help
+  --scope <scope>              project | user
+  --target <client>            Repeatable: codex | claude | claudecode | cursor
+  --yes                        Non-interactive mode
+`.trim(),
+    'skill-remove': `
+Usage: invokora skill remove [--scope <scope>] [--target <client>] [--yes]
+
+Remove Invokora-managed local skills.
+
+Options:
+  -h, --help                   Print skill remove help
+  --scope <scope>              project | user
+  --target <client>            Repeatable: codex | claude | claudecode | cursor
+  --yes                        Remove all managed skills without prompt
+`.trim(),
+    workflow: `
+Workflow Commands:
+  invokora workflow add        Add or refresh local skills from selected workflows
+
+Options:
+  -h, --help                   Print workflow help
+`.trim(),
+    'workflow-add': `
+Usage: invokora workflow add [--scope <scope>] [--target <client>] [--yes]
+
+Add or refresh local skills from selected workflows.
+
+Options:
+  -h, --help                   Print workflow add help
+  --scope <scope>              project | user
+  --target <client>            Repeatable: codex | claude | claudecode | cursor
+  --yes                        Add all syncable workflows without prompt
+`.trim(),
+    mcp: `
+MCP Commands:
+  invokora mcp serve           Start the stdio MCP server
+  invokora mcp setup           Setup MCP config in Claude/Cursor/Codex
+  invokora mcp defaults        Show or set MCP default model/reason
+
+Options:
+  -h, --help                   Print MCP help
+`.trim(),
+    'mcp-serve': `
+Usage: invokora mcp serve
+
+Start the stdio MCP server.
+
+Options:
+  -h, --help                   Print MCP serve help
+`.trim(),
+    'mcp-setup': `
+Usage: invokora mcp setup [--target <client>] [--path <file>] [--yes]
+
+Setup MCP config in Claude/Cursor/Codex.
+
+Options:
+  -h, --help                   Print MCP setup help
+  --target <client>            Repeatable: claude | cursor | codex
+  --path <file>                Optional explicit config path; repeat with target order
+  --yes                        Non-interactive mode
+`.trim(),
+    'mcp-defaults': `
+Usage: invokora mcp defaults [--model <model>] [--reason <effort>] [--clear-model] [--clear-reason]
+
+Show or set MCP default model/reason.
+
+Options:
+  -h, --help                   Print MCP defaults help
+  --model <model>              Default model for new MCP chat sessions
+  --reason <effort>            Default reasoning effort: low | medium | high | xhigh
+  --clear-model                Clear default model
+  --clear-reason               Clear default reasoning effort
+`.trim(),
+};
+const HELP_TEXT_ZH = {
+    root: USAGE_TEXT_ZH,
+    login: `
+用法：invokora login [--timeout <ms>] [--no-open]
+
+通过浏览器 OAuth 回调登录。
+
+选项：
+  -h, --help                   输出 login help
+  --timeout <ms>               等待登录回调，默认 120000
+  --no-open                    只打印登录 URL，不自动打开浏览器
+`.trim(),
+    language: `
+用法：invokora language [en|zh]
+
+查看或设置 CLI 语言。
+
+选项：
+  -h, --help                   输出 language help
+`.trim(),
+    sync: `
+用法：invokora sync [--prune] [--scope <scope>] [--target <client>] [--yes]
+
+交互式同步可本地使用的 skills。
+
+选项：
+  -h, --help                   输出 sync help
+  --prune                      清理失效的 Invokora 托管本地 skills
+  --scope <scope>              project | user
+  --target <client>            可重复：codex | claude | claudecode | cursor
+  --yes                        非交互模式
+`.trim(),
+    skill: `
+Skill 命令：
+  invokora skill add           新增或刷新本地 skills
+  invokora skill prune         同步并清理失效托管 skills
+  invokora skill remove        删除托管本地 skills
+
+选项：
+  -h, --help                   输出 skill help
+`.trim(),
+    'skill-add': `
+用法：invokora skill add [--scope <scope>] [--target <client>] [--yes]
+
+新增或刷新本地 skills。
+
+选项：
+  -h, --help                   输出 skill add help
+  --scope <scope>              project | user
+  --target <client>            可重复：codex | claude | claudecode | cursor
+  --yes                        免选择新增全部可同步 skills
+`.trim(),
+    'skill-prune': `
+用法：invokora skill prune [--scope <scope>] [--target <client>] [--yes]
+
+同步并清理失效的 Invokora 托管本地 skills。
+
+选项：
+  -h, --help                   输出 skill prune help
+  --scope <scope>              project | user
+  --target <client>            可重复：codex | claude | claudecode | cursor
+  --yes                        非交互模式
+`.trim(),
+    'skill-remove': `
+用法：invokora skill remove [--scope <scope>] [--target <client>] [--yes]
+
+删除 Invokora 托管本地 skills。
+
+选项：
+  -h, --help                   输出 skill remove help
+  --scope <scope>              project | user
+  --target <client>            可重复：codex | claude | claudecode | cursor
+  --yes                        免选择删除全部托管 skills
+`.trim(),
+    workflow: `
+Workflow 命令：
+  invokora workflow add        新增或刷新所选 workflow 的本地 skills
+
+选项：
+  -h, --help                   输出 workflow help
+`.trim(),
+    'workflow-add': `
+用法：invokora workflow add [--scope <scope>] [--target <client>] [--yes]
+
+新增或刷新所选 workflow 的本地 skills。
+
+选项：
+  -h, --help                   输出 workflow add help
+  --scope <scope>              project | user
+  --target <client>            可重复：codex | claude | claudecode | cursor
+  --yes                        免选择新增全部可同步 workflows
+`.trim(),
+    mcp: `
+MCP 命令：
+  invokora mcp serve           启动 stdio MCP server
+  invokora mcp setup           写入 Claude/Cursor/Codex MCP 配置
+  invokora mcp defaults        查看或设置 MCP 默认模型 / 思考深度
+
+选项：
+  -h, --help                   输出 MCP help
+`.trim(),
+    'mcp-serve': `
+用法：invokora mcp serve
+
+启动 stdio MCP server。
+
+选项：
+  -h, --help                   输出 MCP serve help
+`.trim(),
+    'mcp-setup': `
+用法：invokora mcp setup [--target <client>] [--path <file>] [--yes]
+
+写入 Claude/Cursor/Codex MCP 配置。
+
+选项：
+  -h, --help                   输出 MCP setup help
+  --target <client>            可重复：claude | cursor | codex
+  --path <file>                可选配置路径，顺序对应 target
+  --yes                        非交互模式
+`.trim(),
+    'mcp-defaults': `
+用法：invokora mcp defaults [--model <model>] [--reason <effort>] [--clear-model] [--clear-reason]
+
+查看或设置 MCP 默认模型 / 思考深度。
+
+选项：
+  -h, --help                   输出 MCP defaults help
+  --model <model>              新 MCP 会话默认模型
+  --reason <effort>            默认思考深度：low | medium | high | xhigh
+  --clear-model                清除默认模型
+  --clear-reason               清除默认思考深度
+`.trim(),
+};
+export function parseCliLanguage(raw) {
+    const value = raw?.trim().toLowerCase().replace(/_/g, '-');
+    if (!value)
+        return null;
+    if (value === 'en' || value === 'en-us' || value === 'english')
+        return 'en';
+    if (value === 'zh' || value === 'zh-cn' || value === 'zh-hans' || value === 'chinese' || value === '中文')
+        return 'zh';
+    return null;
+}
+export function loadCliLanguage(languagePath = LANGUAGE_PATH) {
+    if (!existsSync(languagePath))
+        return 'en';
+    try {
+        return parseCliLanguage(readFileSync(languagePath, 'utf-8')) ?? 'en';
+    }
+    catch {
+        return 'en';
+    }
+}
+export function saveCliLanguage(language, languagePath = LANGUAGE_PATH) {
+    mkdirSync(dirname(languagePath), { recursive: true });
+    writeFileSync(languagePath, `${language}\n`, 'utf-8');
+}
+export function getUsageText(language = loadCliLanguage()) {
+    return language === 'zh' ? USAGE_TEXT_ZH : USAGE_TEXT_EN;
+}
+export function getCommandHelpText(args, language = loadCliLanguage()) {
+    const topic = resolveHelpTopic(args);
+    return language === 'zh' ? HELP_TEXT_ZH[topic] : HELP_TEXT_EN[topic];
+}
+export class InvokoraCliApp {
+    prompts;
+    configStore;
+    shellManager;
+    mcpService;
+    constructor(params) {
+        this.prompts = params?.prompts ?? new CliPrompts();
+        this.configStore = params?.configStore ?? new ConfigStore();
+        this.shellManager = params?.shellManager ?? new SkillShellManager();
+        this.mcpService = new McpConfigService(this.prompts);
+    }
+    async run(argv = process.argv) {
+        const [, , cmd, ...args] = argv;
+        if (isHelpRequest(cmd, args)) {
+            this.printUsage([cmd, ...args]);
+            return;
+        }
+        switch (cmd) {
+            case '-v':
+            case '--version':
+                return this.cmdVersion();
+            case 'login':
+                return this.cmdLogin(args);
+            case 'language':
+                return this.cmdLanguage(args);
+            case 'sync': {
+                let parsed;
+                try {
+                    parsed = this.parseSyncArgs(args);
+                }
+                catch (error) {
+                    console.error(error instanceof Error ? error.message : String(error));
+                    process.exit(1);
+                }
+                let destinations;
+                try {
+                    destinations = await this.resolveSyncDestinations(parsed);
+                }
+                catch (error) {
+                    console.error(error instanceof Error ? error.message : String(error));
+                    process.exit(1);
+                }
+                await this.syncSkills({ prune: parsed.prune }, undefined, destinations);
+                return;
+            }
+            case 'mcp':
+                if (args[0] === 'setup') {
+                    return this.cmdMcpSetup(args.slice(1));
+                }
+                if (args[0] === 'serve') {
+                    if (args.length > 1) {
+                        console.error(`Unknown mcp serve options: ${args.slice(1).join(' ')}`);
+                        process.exit(1);
+                    }
+                    return this.cmdMcpServe();
+                }
+                if (args[0] === 'defaults') {
+                    return this.cmdMcpDefaults(args.slice(1));
+                }
+                console.error(`Unknown mcp subcommand/options: ${args.join(' ')}`);
+                process.exit(1);
+            case 'skill':
+                return this.cmdSkill(args);
+            case 'workflow':
+                return this.cmdWorkflow(args);
+            default:
+                this.printUsage();
+        }
+    }
+    async cmdLogin(rawArgs) {
+        let options;
+        try {
+            options = parseLoginCommandOptions(rawArgs);
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+        try {
+            const backendUrl = process.env.SKILZ_BACKEND_URL || DEFAULT_BACKEND_URL;
+            const response = await new OAuthBrowserLoginFlow({
+                backendUrl,
+                timeoutMs: options.timeoutMs,
+                noOpen: options.noOpen,
+            }).run();
+            this.configStore.save({
+                backend_url: backendUrl,
+                token: response.access_token,
+                refresh_token: response.refresh_token,
+            });
+            const email = response.user?.email;
+            console.log(`✓ Logged in${email ? ` as ${email}` : ''}`);
+            console.log(`  Config saved to ${CONFIG_PATH}`);
+        }
+        catch (error) {
+            console.error('Login failed:', error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+    }
+    cmdVersion() {
+        console.log(`invokora ${RELEASE_VERSION}`);
+    }
+    cmdLanguage(rawArgs) {
+        if (rawArgs.length === 0) {
+            console.log(`Language: ${loadCliLanguage()} (${LANGUAGE_PATH})`);
+            return;
+        }
+        if (rawArgs.length > 1) {
+            console.error('Usage: invokora language [en|zh]');
+            process.exit(1);
+        }
+        const language = parseCliLanguage(rawArgs[0]);
+        if (!language) {
+            console.error('Unsupported language. Use: en or zh');
+            process.exit(1);
+        }
+        saveCliLanguage(language);
+        console.log(`Language set to ${language}`);
+    }
+    async cmdMcpServe() {
+        try {
+            await startStdioServer();
+        }
+        catch (error) {
+            console.error(getErrorMessage(error));
+            const config = this.configStore.load();
+            if (config) {
+                console.error(`Support: ${this.supportUrl(config, { category: 'cannot_invoke' })}`);
+            }
+            process.exit(1);
+        }
+    }
+    cmdMcpDefaults(rawArgs) {
+        let parsed;
+        try {
+            parsed = parseMcpDefaultsArgs(rawArgs);
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+        const config = this.requireConfig();
+        if (!parsed.changed) {
+            this.printMcpDefaults(config);
+            return;
+        }
+        const next = { ...config };
+        if (parsed.clearModel) {
+            delete next.default_model;
+        }
+        if (parsed.model !== undefined) {
+            next.default_model = parsed.model;
+        }
+        if (parsed.clearReason) {
+            delete next.default_reason;
+        }
+        if (parsed.reason !== undefined) {
+            next.default_reason = parsed.reason;
+        }
+        this.configStore.save(next);
+        console.log(`✓ MCP defaults saved to ${CONFIG_PATH}`);
+        this.printMcpDefaults(next);
+    }
+    async cmdSkill(args) {
+        const [subcommand, ...rawArgs] = args;
+        switch (subcommand) {
+            case 'add':
+                return this.cmdSkillAdd(rawArgs);
+            case 'prune':
+                return this.cmdSkillPrune(rawArgs);
+            case 'remove':
+                return this.cmdSkillRemove(rawArgs);
+            default:
+                console.error(`Unknown skill subcommand/options: ${args.join(' ')}`);
+                process.exit(1);
+        }
+    }
+    async cmdSkillAdd(rawArgs) {
+        const parsed = this.parseLocalSkillArgs(rawArgs);
+        const destinations = await this.resolveSyncDestinations(parsed);
+        const config = this.requireConfig();
+        const skills = await this.loadActiveSyncableSkills(config);
+        const selectedSkills = parsed.yes ? skills : await this.pickSkillsForAdd(skills);
+        if (selectedSkills.length === 0) {
+            console.log('No skill selected. Nothing changed.');
+            return;
+        }
+        await this.syncSkills({ prune: false }, config, destinations, selectedSkills);
+    }
+    async cmdSkillPrune(rawArgs) {
+        const parsed = this.parseLocalSkillArgs(rawArgs, { allowPruneFlag: true });
+        const destinations = await this.resolveSyncDestinations(parsed);
+        await this.syncSkills({ prune: true }, undefined, destinations);
+    }
+    async cmdSkillRemove(rawArgs) {
+        const parsed = this.parseLocalSkillArgs(rawArgs);
+        const destinations = await this.resolveSyncDestinations(parsed);
+        const selectedByDestination = parsed.yes
+            ? new Map(destinations.map((destination) => [destination.label, undefined]))
+            : await this.pickLocalManagedSkills(destinations);
+        if (selectedByDestination.size === 0) {
+            console.log('No skill selected. Nothing changed.');
+            return;
+        }
+        if (!parsed.yes) {
+            const selectedCount = [...selectedByDestination.values()].reduce((sum, slugs) => sum + (slugs?.length ?? 0), 0);
+            const confirmed = await this.prompts.yesNo(`Remove ${selectedCount} selected Invokora-managed local skill(s)?`, false);
+            if (!confirmed) {
+                console.log('Skipped.');
+                return;
+            }
+        }
+        let removed = 0;
+        for (const destination of destinations) {
+            if (!selectedByDestination.has(destination.label))
+                continue;
+            const result = this.shellManager.removeManagedSkills(destination.rootDir, selectedByDestination.get(destination.label));
+            removed += result.removed;
+            console.log(`✓ ${destination.label}: removed ${result.removed} Invokora-managed skill(s) from ${destination.rootDir}`);
+        }
+        console.log(`Remove complete for ${destinations.length} destination(s), ${removed} skill(s) removed.`);
+    }
+    async cmdWorkflow(args) {
+        const [subcommand, ...rawArgs] = args;
+        switch (subcommand) {
+            case 'add':
+                return this.cmdWorkflowAdd(rawArgs);
+            default:
+                console.error(`Unknown workflow subcommand/options: ${args.join(' ')}`);
+                process.exit(1);
+        }
+    }
+    async cmdWorkflowAdd(rawArgs) {
+        const parsed = this.parseLocalSkillArgs(rawArgs);
+        const destinations = await this.resolveSyncDestinations(parsed);
+        const config = this.requireConfig();
+        const client = this.apiClient(config);
+        const skills = await this.loadActiveSyncableSkills(config, client);
+        const workflows = this.filterWorkflowsWithSyncableSkills(await this.loadSyncableWorkflows(client), skills);
+        if (workflows.length === 0) {
+            console.log('No workflow available to add. Nothing changed.');
+            return;
+        }
+        const selectedWorkflows = parsed.yes ? workflows : await this.pickSyncableWorkflows(workflows);
+        if (selectedWorkflows.length === 0) {
+            console.log('No workflow selected. Nothing changed.');
+            return;
+        }
+        const selectedSkillIDs = new Set(selectedWorkflows.flatMap((workflow) => workflow.skill_ids));
+        const selectedSkills = skills.filter((skill) => selectedSkillIDs.has(skill.id));
+        if (selectedSkills.length === 0) {
+            console.log('No syncable skill found for selected workflow(s). Nothing changed.');
+            return;
+        }
+        await this.syncSkills({ prune: false }, config, destinations, selectedSkills);
+    }
+    async cmdMcpSetup(rawArgs) {
+        let parsed;
+        try {
+            parsed = this.mcpService.parseSetupArgs(rawArgs);
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+        let targets;
+        try {
+            targets = await this.mcpService.resolveTargets(parsed);
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+        if (targets.length === 0) {
+            console.log('No valid target selected. Nothing changed.');
+            return;
+        }
+        let explicitPaths;
+        try {
+            explicitPaths = this.mcpService.mapPathsToTargets(targets, parsed.paths);
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+        const config = this.requireConfig();
+        const serverConfig = this.mcpService.buildServerConfig(config);
+        let updatedCount = 0;
+        for (const target of targets) {
+            const explicitPath = explicitPaths.get(target);
+            try {
+                const result = await this.mcpService.setupTargetConfig({
+                    target,
+                    explicitPath,
+                    serverConfig,
+                    yes: parsed.yes,
+                });
+                if (result.status === 'updated') {
+                    updatedCount++;
+                    console.log(`✓ ${target}: ${result.path}`);
+                }
+                else {
+                    console.log(`- ${target}: skipped`);
+                }
+            }
+            catch (error) {
+                console.error(`✗ ${target}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        if (updatedCount === 0) {
+            console.error('No MCP target was updated.');
+            process.exit(1);
+        }
+        console.log('\nMCP setup complete.');
+    }
+    parseSyncArgs(args) {
+        let prune = false;
+        let yes = false;
+        let scope;
+        const targets = [];
+        for (let i = 0; i < args.length; i += 1) {
+            const arg = args[i];
+            if (arg === '--prune') {
+                prune = true;
+                continue;
+            }
+            if (arg === '--yes' || arg === '-y') {
+                yes = true;
+                continue;
+            }
+            if (arg === '--scope') {
+                const value = args[i + 1];
+                if (!value)
+                    throw new Error('Missing value for --scope');
+                const parsedScope = SYNC_SCOPE_ALIASES[value.trim().toLowerCase()];
+                if (!parsedScope)
+                    throw new Error(`Unsupported sync scope: ${value}`);
+                scope = parsedScope;
+                i += 1;
+                continue;
+            }
+            if (arg === '--target') {
+                const value = args[i + 1];
+                if (!value)
+                    throw new Error('Missing value for --target');
+                const parsedTarget = SYNC_TARGET_ALIASES[value.trim().toLowerCase()];
+                if (!parsedTarget)
+                    throw new Error(`Unsupported sync target: ${value}`);
+                targets.push(parsedTarget);
+                i += 1;
+                continue;
+            }
+            throw new Error(`Unknown sync option: ${arg}`);
+        }
+        return { prune, yes, scope, targets: [...new Set(targets)] };
+    }
+    parseLocalSkillArgs(args, options = {}) {
+        try {
+            const parsed = this.parseSyncArgs(args);
+            if (parsed.prune && !options.allowPruneFlag) {
+                throw new Error('--prune is only supported by invokora sync or invokora skill prune');
+            }
+            return parsed;
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+    }
+    async resolveSyncDestinations(parsed) {
+        const scope = parsed.scope ?? (parsed.yes ? 'project' : await this.prompts.pickSyncScope());
+        const targets = parsed.targets.length > 0
+            ? parsed.targets
+            : parsed.yes
+                ? ['codex']
+                : await this.prompts.pickSyncTargets(scope);
+        return targets.map((target) => this.shellManager.resolveSyncDestination(target, scope));
+    }
+    async syncSkills(options, config = this.requireConfig(), destinations = [this.shellManager.resolveSyncDestination('codex', 'project')], selectedSkills) {
+        const client = this.apiClient(config);
+        const skills = selectedSkills ?? await this.loadActiveSyncableSkills(config, client);
+        const syncedContentBySkill = await this.downloadManagedSkillContent(client, skills);
+        const aggregate = { written: 0, pruned: 0, activeSlugs: new Set() };
+        for (const destination of destinations) {
+            const result = this.shellManager.sync(skills, {
+                ...options,
+                rootDir: destination.rootDir,
+                destinationLabel: destination.label,
+            }, syncedContentBySkill);
+            result.activeSlugs.forEach((slug) => aggregate.activeSlugs.add(slug));
+            aggregate.written += result.written;
+            aggregate.pruned += result.pruned;
+            if (!options.quiet) {
+                console.log(`✓ ${destination.label}: synced ${result.written} skill(s) to ${destination.rootDir}`);
+                if (options.prune) {
+                    console.log(`  pruned ${result.pruned} stale skill(s)`);
+                }
+            }
+        }
+        if (!options.quiet) {
+            console.log(`Sync complete for ${destinations.length} destination(s).`);
+        }
+        return aggregate;
+    }
+    async loadActiveSyncableSkills(config, client = this.apiClient(config)) {
+        return (await client.listSyncableDetails()).filter((skill) => skill.status === 'active');
+    }
+    async pickSyncableSkills(skills) {
+        const selectedIDs = new Set(await this.prompts.pickSyncableSkills(skills.map((skill) => ({
+            value: skill.id,
+            label: skill.name || skill.id,
+            hint: skill.description || skill.access_source,
+        }))));
+        return skills.filter((skill) => selectedIDs.has(skill.id));
+    }
+    async pickSkillsForAdd(skills) {
+        if (skills.length === 0) {
+            return [];
+        }
+        const mode = await this.prompts.pickSyncableSkillAddMode();
+        if (mode === 'all') {
+            return skills;
+        }
+        if (mode === 'none') {
+            return [];
+        }
+        return this.pickSyncableSkills(skills);
+    }
+    async pickSyncableWorkflows(workflows) {
+        const selectedIDs = new Set(await this.prompts.pickSyncableWorkflows(workflows.map((workflow) => ({
+            value: workflow.id,
+            label: workflow.name || workflow.id,
+            hint: `${workflow.source} · ${workflow.skill_ids.length} skill(s)${workflow.description ? ` · ${workflow.description}` : ''}`,
+        }))));
+        return workflows.filter((workflow) => selectedIDs.has(workflow.id));
+    }
+    async loadSyncableWorkflows(client) {
+        const workflows = [];
+        const entitlements = await client.listEntitlements();
+        const marketplaceWorkflowIDs = [...new Set(entitlements.map((entitlement) => entitlement.workflow_id).filter((id) => Boolean(id)))];
+        for (const workflowID of marketplaceWorkflowIDs) {
+            const detail = await client.getWorkflowDetail(workflowID);
+            workflows.push({
+                id: `marketplace:${workflowID}`,
+                name: detail.workflow.name || workflowID,
+                description: detail.workflow.description || '',
+                source: 'marketplace',
+                skill_ids: this.workflowSkillIDs(detail.components),
+            });
+        }
+        const personalWorkflows = await client.listPersonalWorkflows();
+        for (const workflow of personalWorkflows.filter((item) => item.status === undefined || item.status === 'active')) {
+            const detail = await client.getPersonalWorkflowDetail(workflow.id);
+            workflows.push({
+                id: `personal:${workflow.id}`,
+                name: detail.workflow.name || workflow.name || workflow.id,
+                description: detail.workflow.description || workflow.description || '',
+                source: 'personal',
+                skill_ids: this.workflowSkillIDs(detail.components),
+            });
+        }
+        return workflows;
+    }
+    filterWorkflowsWithSyncableSkills(workflows, skills) {
+        const syncableSkillIDs = new Set(skills.map((skill) => skill.id));
+        return workflows
+            .map((workflow) => ({
+            ...workflow,
+            skill_ids: workflow.skill_ids.filter((skillID) => syncableSkillIDs.has(skillID)),
+        }))
+            .filter((workflow) => workflow.skill_ids.length > 0);
+    }
+    workflowSkillIDs(components) {
+        const ids = components.map((component) => {
+            if ('skill' in component)
+                return component.skill?.id;
+            return component.id;
+        });
+        return [...new Set(ids.filter((id) => Boolean(id)))];
+    }
+    async pickLocalManagedSkills(destinations) {
+        const choices = destinations.flatMap((destination) => this.shellManager.listManagedSkills(destination.rootDir).map((skill) => ({
+            value: `${destination.label}\u0000${skill.slug}`,
+            label: skill.slug,
+            hint: `${destination.label}${skill.skill_id ? ` · ${skill.skill_id}` : ''}`,
+        })));
+        const selectedValues = await this.prompts.pickLocalManagedSkills(choices);
+        const selectedByDestination = new Map();
+        for (const selectedValue of selectedValues) {
+            const [label, slug] = selectedValue.split('\u0000');
+            if (!label || !slug)
+                continue;
+            const slugs = selectedByDestination.get(label) ?? [];
+            slugs.push(slug);
+            selectedByDestination.set(label, slugs);
+        }
+        return selectedByDestination;
+    }
+    async downloadManagedSkillContent(client, skills) {
+        const syncedContentBySkill = new Map();
+        for (const skill of skills) {
+            if (!this.shouldWriteManagedContent(skill))
+                continue;
+            syncedContentBySkill.set(skill.id, await client.getSyncableSkillContent(skill.id));
+        }
+        return syncedContentBySkill;
+    }
+    shouldWriteManagedContent(skill) {
+        if (skill.access_source === 'personal') {
+            return true;
+        }
+        if (skill.access_source !== 'entitlement') {
+            return false;
+        }
+        return skill.billing_mode === 'public_version_lock' || skill.billing_mode === 'public_buyout_updates';
+    }
+    apiClient(config = this.requireConfig()) {
+        return new InvokoraApiClient(config);
+    }
+    supportUrl(config, params) {
+        const q = new URLSearchParams();
+        for (const [key, value] of Object.entries(params)) {
+            if (value)
+                q.set(key, value);
+        }
+        const query = q.toString();
+        return new URL(query ? `/workspace/support?${query}` : '/workspace/support', config.backend_url).toString();
+    }
+    requireConfig() {
+        try {
+            return this.configStore.require();
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+    }
+    printUsage(args = []) {
+        console.log(getCommandHelpText(args.filter((arg) => typeof arg === 'string')));
+    }
+    printMcpDefaults(config) {
+        console.log(`Default model: ${config.default_model || '(backend default)'}`);
+        console.log(`Default reason: ${config.default_reason || '(backend default)'}`);
+    }
+}
+function parseMcpDefaultsArgs(args) {
+    const parsed = {
+        changed: false,
+        clearModel: false,
+        clearReason: false,
+    };
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === '--model') {
+            const value = args[i + 1]?.trim();
+            if (!value)
+                throw new Error('Missing value for --model');
+            parsed.model = value;
+            parsed.changed = true;
+            i += 1;
+            continue;
+        }
+        if (arg === '--reason') {
+            const value = args[i + 1];
+            if (!value)
+                throw new Error('Missing value for --reason');
+            parsed.reason = parseReasoningEffort(value);
+            parsed.changed = true;
+            i += 1;
+            continue;
+        }
+        if (arg === '--clear-model') {
+            parsed.clearModel = true;
+            parsed.changed = true;
+            continue;
+        }
+        if (arg === '--clear-reason') {
+            parsed.clearReason = true;
+            parsed.changed = true;
+            continue;
+        }
+        throw new Error(`Unknown mcp defaults option: ${arg}`);
+    }
+    if (parsed.model !== undefined && parsed.clearModel) {
+        throw new Error('--model and --clear-model cannot be used together');
+    }
+    if (parsed.reason !== undefined && parsed.clearReason) {
+        throw new Error('--reason and --clear-reason cannot be used together');
+    }
+    return parsed;
+}
+function parseReasoningEffort(value) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'low' || normalized === 'medium' || normalized === 'high' || normalized === 'xhigh') {
+        return normalized;
+    }
+    throw new Error('--reason must be one of: low, medium, high, xhigh');
+}
+function resolveHelpTopic(args) {
+    const tokens = args.filter((arg) => !isHelpFlag(arg));
+    const [cmd, subcommand] = tokens;
+    if (cmd === 'login')
+        return 'login';
+    if (cmd === 'language')
+        return 'language';
+    if (cmd === 'sync')
+        return 'sync';
+    if (cmd === 'skill') {
+        if (subcommand === 'add')
+            return 'skill-add';
+        if (subcommand === 'prune')
+            return 'skill-prune';
+        if (subcommand === 'remove')
+            return 'skill-remove';
+        return 'skill';
+    }
+    if (cmd === 'workflow') {
+        if (subcommand === 'add')
+            return 'workflow-add';
+        return 'workflow';
+    }
+    if (cmd === 'mcp') {
+        if (subcommand === 'serve')
+            return 'mcp-serve';
+        if (subcommand === 'setup')
+            return 'mcp-setup';
+        if (subcommand === 'defaults')
+            return 'mcp-defaults';
+        return 'mcp';
+    }
+    return 'root';
+}
+function isHelpRequest(cmd, args) {
+    return isHelpFlag(cmd) || args.some(isHelpFlag);
+}
+function isHelpFlag(arg) {
+    return arg === '-h' || arg === '--help';
+}
+export async function cmdLogin(rawArgs) {
+    await new InvokoraCliApp().cmdLogin(rawArgs);
+}
+export function isMainModule(importMetaUrl) {
+    const entryPoint = process.argv[1];
+    if (typeof entryPoint !== 'string')
+        return false;
+    try {
+        const currentFile = fileURLToPath(importMetaUrl);
+        return realpathSync(entryPoint) === realpathSync(currentFile);
+    }
+    catch {
+        return pathToFileURL(entryPoint).href === importMetaUrl;
+    }
+}
+export async function main(argv = process.argv) {
+    await new InvokoraCliApp().run(argv);
+}