@worldzb/agent-sync 1.4.0

package/dist/agents/opencode-adapter.js

@@ -0,0 +1,193 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { AbstractFileAdapter } from './abstract-file-adapter.js';
+import { asString, isRecord } from './jsonl.js';
+import { findExecutable, runCommand } from './process-runner.js';
+import { normalizeMessage } from '../migration/transcript-normalizer.js';
+export class OpenCodeAdapter extends AbstractFileAdapter {
+    homeDirectory;
+    id = 'opencode';
+    name = 'OpenCode';
+    command = 'opencode';
+    historyRoot;
+    constructor(homeDirectory) {
+        super();
+        this.homeDirectory = homeDirectory;
+        this.historyRoot = path.join(homeDirectory, '.local', 'share', 'opencode');
+    }
+    listSessions() {
+        try {
+            const value = JSON.parse(this.execute(['session', 'list', '--format', 'json']));
+            const sessions = toSessions(value, this.id);
+            return sessions.length ? sessions : this.listSessionsFromDatabase();
+        }
+        catch {
+            return this.listSessionsFromDatabase();
+        }
+    }
+    listSessionsFromDatabase() {
+        const sqlite = findExecutable('sqlite3');
+        const database = path.join(this.historyRoot, 'opencode.db');
+        if (!sqlite || !fs.existsSync(database))
+            return [];
+        try {
+            const output = runCommand(sqlite, [
+                '-json',
+                '-readonly',
+                database,
+                'SELECT id, title, directory, time_updated FROM session ORDER BY time_updated DESC;',
+            ]);
+            return toSessions(JSON.parse(output), this.id);
+        }
+        catch {
+            return [];
+        }
+    }
+    readTranscript(session) {
+        try {
+            const value = JSON.parse(this.execute(['export', session.id]));
+            const messages = collectMessages(value);
+            return {
+                source: session,
+                messages,
+                warnings: messages.length ? [] : ['OpenCode 未返回可迁移的消息内容。'],
+            };
+        }
+        catch (error) {
+            return {
+                source: session,
+                messages: [],
+                warnings: [error instanceof Error ? error.message : '无法导出 OpenCode 会话。'],
+            };
+        }
+    }
+    createResumeLaunch(session) {
+        return { command: [this.command, '--session', session.id], cwd: session.cwd || process.cwd() };
+    }
+    createNewLaunch(input) {
+        const prompt = input.prompt
+            ? `${input.prompt}${input.assetDirectory ? `\n\n迁移附件目录：${input.assetDirectory}` : ''}`
+            : undefined;
+        return { command: [this.command, ...(prompt ? ['--prompt', prompt] : [])], cwd: input.cwd || process.cwd() };
+    }
+    deleteSession(session) {
+        this.execute(['session', 'delete', session.id], session.cwd);
+    }
+    integrationRoots(project) {
+        return [
+            { directory: path.join(this.homeDirectory, '.config', 'opencode'), scope: 'user' },
+            ...(project ? [{ directory: path.join(project, '.opencode'), scope: 'project' }] : []),
+        ];
+    }
+    listIntegrations(project) {
+        return [...super.listIntegrations(project), ...this.listLocalPlugins(project), ...this.listConfiguredItems(), ...this.listMcp()];
+    }
+    installPlugin(plugin, scope) {
+        this.execute(['plugin', plugin, ...(scope === 'user' ? ['--global'] : [])]);
+    }
+    removeIntegration(item) {
+        if (item.kind === 'mcp' || (item.kind === 'plugin' && item.location.endsWith('.json'))) {
+            throw new Error('当前 OpenCode 版本未提供该资源的安全移除命令；请在配置文件中手动移除。');
+        }
+        this.removeLocalPath(item.location);
+    }
+    listLocalPlugins(project) {
+        const roots = [
+            { directory: path.join(this.homeDirectory, '.config', 'opencode', 'plugins'), scope: 'user' },
+            ...(project ? [{ directory: path.join(project, '.opencode', 'plugins'), scope: 'project' }] : []),
+        ];
+        return roots.flatMap(({ directory, scope }) => {
+            if (!fs.existsSync(directory))
+                return [];
+            return fs.readdirSync(directory, { withFileTypes: true })
+                .filter((entry) => !entry.name.startsWith('.') && (entry.isDirectory() || entry.isFile()))
+                .map((entry) => ({
+                agent: this.id,
+                kind: 'plugin',
+                name: entry.name,
+                scope,
+                location: path.join(directory, entry.name),
+                removable: true,
+            }));
+        });
+    }
+    listConfiguredItems() {
+        const file = path.join(this.homeDirectory, '.config', 'opencode', 'opencode.json');
+        if (!fs.existsSync(file))
+            return [];
+        try {
+            const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+            if (!isRecord(parsed))
+                return [];
+            const plugins = Array.isArray(parsed.plugin) ? parsed.plugin : [];
+            const pluginItems = plugins.filter((plugin) => typeof plugin === 'string').map((name) => ({
+                agent: this.id,
+                kind: 'plugin',
+                name,
+                scope: 'user',
+                location: file,
+                removable: true,
+            }));
+            const mcp = isRecord(parsed.mcp) ? Object.keys(parsed.mcp).map((name) => ({
+                agent: this.id,
+                kind: 'mcp',
+                name,
+                scope: 'user',
+                location: file,
+                removable: false,
+            })) : [];
+            return [...pluginItems, ...mcp];
+        }
+        catch {
+            return [];
+        }
+    }
+    listMcp() {
+        try {
+            const output = this.execute(['mcp', 'list']);
+            return output.split('\n')
+                .map((line) => line.trim().split(/\s+/)[0])
+                .filter((name) => Boolean(name) && !name.toLowerCase().startsWith('name'))
+                .map((name) => ({ agent: this.id, kind: 'mcp', name, scope: 'user', location: 'opencode mcp', removable: false }));
+        }
+        catch {
+            return [];
+        }
+    }
+}
+function toSessions(value, agent) {
+    const rows = Array.isArray(value) ? value : isRecord(value) && Array.isArray(value.sessions) ? value.sessions : [];
+    return rows.filter(isRecord).flatMap((row) => {
+        const id = asString(row.id);
+        if (!id)
+            return [];
+        const time = isRecord(row.time) ? row.time : {};
+        return [{
+                agent,
+                id,
+                title: asString(row.title) || asString(row.slug) || '未命名 OpenCode 会话',
+                cwd: asString(row.directory) || asString(row.path) || process.cwd(),
+                updatedAt: toIso(row.time_updated ?? time.updated ?? time.updatedAt),
+                sourcePath: id,
+            }];
+    });
+}
+function collectMessages(value) {
+    if (Array.isArray(value))
+        return value.flatMap(collectMessages);
+    if (!isRecord(value))
+        return [];
+    const direct = normalizeMessage(value);
+    if (direct)
+        return [direct];
+    return Object.values(value).flatMap(collectMessages);
+}
+function toIso(value) {
+    if (typeof value === 'number')
+        return new Date(value).toISOString();
+    if (typeof value === 'string') {
+        const date = new Date(value);
+        return Number.isNaN(date.valueOf()) ? new Date(0).toISOString() : date.toISOString();
+    }
+    return new Date(0).toISOString();
+}

package/dist/agents/process-runner.js

@@ -0,0 +1,33 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+export function findExecutable(name) {
+    const paths = (process.env.PATH || '').split(path.delimiter);
+    const extensions = process.platform === 'win32' ? ['', '.cmd', '.exe', '.bat'] : [''];
+    return paths
+        .flatMap((directory) => extensions.map((extension) => path.join(directory, `${name}${extension}`)))
+        .find((candidate) => fs.existsSync(candidate));
+}
+export function runCommand(command, args, cwd) {
+    const result = spawnSync(command, args, {
+        cwd,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+        timeout: 30_000,
+    });
+    if (result.error) {
+        throw new Error(`无法执行 ${command}：${result.error.message}`);
+    }
+    if (result.status !== 0) {
+        throw new Error(`${command} 执行失败：${(result.stderr || result.stdout || '未知错误').trim()}`);
+    }
+    return result.stdout.trim();
+}
+export function getVersion(command) {
+    try {
+        return runCommand(command, ['--version']).split('\n')[0]?.trim();
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/agents/registry.js

@@ -0,0 +1,23 @@
+import { ClaudeAdapter } from './claude-adapter.js';
+import { CodexAdapter } from './codex-adapter.js';
+import { OpenCodeAdapter } from './opencode-adapter.js';
+export class AgentRegistry {
+    adapters;
+    constructor(homeDirectory) {
+        const adapters = [
+            new ClaudeAdapter(homeDirectory),
+            new CodexAdapter(homeDirectory),
+            new OpenCodeAdapter(homeDirectory),
+        ];
+        this.adapters = new Map(adapters.map((adapter) => [adapter.id, adapter]));
+    }
+    all() {
+        return [...this.adapters.values()];
+    }
+    get(id) {
+        const adapter = this.adapters.get(id);
+        if (!adapter)
+            throw new Error(`不支持的 Agent：${id}`);
+        return adapter;
+    }
+}

package/dist/agents/types.js

@@ -0,0 +1 @@
+export const AGENT_IDS = ['claude', 'codex', 'opencode'];

package/dist/claude/settings.js

@@ -0,0 +1,52 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export function readClaudeSettings(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return {};
+    }
+    try {
+        const value = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        if (!isRecord(value)) {
+            throw new Error('settings.json 必须是对象。');
+        }
+        return value;
+    }
+    catch {
+        throw new Error(`无法读取 Claude 设置文件：${filePath}`);
+    }
+}
+export function writeClaudeSettings(filePath, settings) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(settings, null, 2)}\n`, 'utf8');
+}
+export function applyDefaultConfig(settings, config) {
+    const env = isRecord(settings.env) ? settings.env : {};
+    return {
+        ...settings,
+        env: {
+            ...env,
+            ANTHROPIC_AUTH_TOKEN: config.apiKey,
+            ANTHROPIC_BASE_URL: config.baseUrl,
+        },
+    };
+}
+export function findActiveConfig(configs, settings) {
+    const authToken = settings.env?.ANTHROPIC_AUTH_TOKEN;
+    const baseUrl = settings.env?.ANTHROPIC_BASE_URL;
+    if (typeof authToken !== 'string' || typeof baseUrl !== 'string') {
+        return undefined;
+    }
+    return configs.find((config) => config.apiKey === authToken && config.baseUrl === baseUrl);
+}
+export function createTemporaryExports(config) {
+    return [
+        `export ANTHROPIC_API_KEY=${shellQuote(config.apiKey)}`,
+        `export ANTHROPIC_BASE_URL=${shellQuote(config.baseUrl)}`,
+    ].join('\n');
+}
+export function shellQuote(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/cli/create-program.js

@@ -0,0 +1,32 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { registerAddCommand } from '../commands/add.js';
+import { registerAgentsCommand } from '../commands/agents.js';
+import { registerCurrentCommand } from '../commands/current.js';
+import { registerDeleteCommand } from '../commands/delete.js';
+import { registerHistoryCommand } from '../commands/history.js';
+import { registerIntegrationsCommand } from '../commands/integrations.js';
+import { registerListCommand } from '../commands/list.js';
+import { registerMigrateCommand } from '../commands/migrate.js';
+import { registerSessionsCommand } from '../commands/sessions.js';
+import { registerSwitchCommand } from '../commands/switch.js';
+export function createProgram(context) {
+    const program = new Command();
+    program
+        .name('zmai')
+        .description('🤖 多 Agent 会话与 Claude API 配置管理工具')
+        .version('1.3.0')
+        .addHelpText('beforeAll', chalk.cyan.bold('\n╔══════════════════════════════════════╗\n║        ZMAI Agent Workspace          ║\n╚══════════════════════════════════════╝\n'))
+        .addHelpText('after', chalk.gray('\n💡 历史会话：zmai history\n💡 Agent 扫描：zmai agents\n💡 集成管理：zmai integrations\n'));
+    registerAgentsCommand(program, context);
+    registerHistoryCommand(program, context);
+    registerSessionsCommand(program, context);
+    registerMigrateCommand(program, context);
+    registerIntegrationsCommand(program, context);
+    registerAddCommand(program, context);
+    registerListCommand(program, context);
+    registerSwitchCommand(program, context);
+    registerDeleteCommand(program, context);
+    registerCurrentCommand(program, context);
+    return program;
+}

package/dist/commands/add.js

@@ -0,0 +1,70 @@
+import { cancel, confirm, intro, isCancel, note, outro, text } from '@clack/prompts';
+import chalk from 'chalk';
+import { addConfig, createApiConfig } from '../config/config-data.js';
+import { maskApiKey, printSuccess } from '../ui/output.js';
+export function registerAddCommand(program, context) {
+    program
+        .command('add')
+        .description('➕ 添加新的 Claude API 配置')
+        .option('-i, --interactive', '交互式添加（推荐）')
+        .option('-n, --name <name>', '配置名称')
+        .option('-k, --key <key>', 'API Key')
+        .option('-u, --url <url>', 'Base URL')
+        .action(async (options) => {
+        if (options.interactive || !options.name || !options.key) {
+            await interactiveAdd(context);
+            return;
+        }
+        saveConfig(context, createApiConfig({
+            name: options.name,
+            apiKey: options.key,
+            baseUrl: options.url,
+            createdAt: new Date().toISOString(),
+        }));
+    });
+}
+async function interactiveAdd(context) {
+    console.clear();
+    intro(chalk.cyan.bold('🤖 Claude API Switcher - 添加新配置'));
+    const existingNames = context.repository.read().configs.map((config) => config.name);
+    const name = await text({
+        message: '📝 配置名称',
+        placeholder: '例如: 官方 API、代理 API',
+        validate: (value) => !value ? '请输入配置名称' : existingNames.includes(value) ? `配置 "${value}" 已存在` : undefined,
+    });
+    if (isCancel(name))
+        return void cancel('操作已取消');
+    const apiKey = await text({
+        message: '🔑 API Key',
+        placeholder: 'sk-ant-api03-xxx',
+        validate: (value) => !value ? '请输入 API Key' : value.length < 10 ? 'API Key 格式不正确' : undefined,
+    });
+    if (isCancel(apiKey))
+        return void cancel('操作已取消');
+    const baseUrl = await text({
+        message: '🌐 Base URL',
+        initialValue: 'https://api.anthropic.com',
+        validate: (value) => {
+            try {
+                new URL(value);
+            }
+            catch {
+                return 'URL 格式不正确';
+            }
+            return undefined;
+        },
+    });
+    if (isCancel(baseUrl))
+        return void cancel('操作已取消');
+    const config = createApiConfig({ name, apiKey, baseUrl, createdAt: new Date().toISOString() });
+    note(`名称: ${config.name}\nAPI Key: ${maskApiKey(config.apiKey)}\nBase URL: ${config.baseUrl}`, '配置预览');
+    const accepted = await confirm({ message: '确认添加此配置？', initialValue: true });
+    if (isCancel(accepted) || !accepted)
+        return void cancel('已取消添加');
+    saveConfig(context, config);
+    outro(chalk.green('✅ 配置添加成功！'));
+}
+function saveConfig(context, config) {
+    context.repository.write(addConfig(context.repository.read(), config));
+    printSuccess(`配置 "${config.name}" 已添加！`);
+}

package/dist/commands/agents.js

@@ -0,0 +1,16 @@
+import chalk from 'chalk';
+export function registerAgentsCommand(program, context) {
+    program
+        .command('agents')
+        .description('🔎 扫描已安装的 Agent 工具')
+        .action(() => {
+        context.agents.all().map((agent) => agent.discover()).forEach((agent) => {
+            const status = agent.installed ? chalk.green('已安装') : chalk.gray('未安装');
+            console.log(`${agent.installed ? '🟢' : '⚪'} ${chalk.bold(agent.name)} ${status}`);
+            console.log(`   命令: ${agent.executable || '未在 PATH 中找到'}`);
+            console.log(`   版本: ${agent.version || '未知'}`);
+            console.log(`   历史目录: ${agent.historyRoot}`);
+            console.log(`   能力: ${agent.capabilities.join('、')}`);
+        });
+    });
+}

package/dist/commands/context.js

@@ -0,0 +1 @@
+export {};

package/dist/commands/current.js

@@ -0,0 +1,32 @@
+import chalk from 'chalk';
+import { findActiveConfig, readClaudeSettings } from '../claude/settings.js';
+import { maskApiKey } from '../ui/output.js';
+export function registerCurrentCommand(program, context) {
+    program
+        .command('current')
+        .description('👀 查看当前 Claude 配置')
+        .action(() => showCurrentConfig(context));
+}
+function showCurrentConfig(context) {
+    const data = context.repository.read();
+    const settings = readClaudeSettings(context.claudeSettingsFile);
+    const activeConfig = findActiveConfig(data.configs, settings);
+    const authToken = settings.env?.ANTHROPIC_AUTH_TOKEN;
+    const baseUrl = settings.env?.ANTHROPIC_BASE_URL;
+    console.log(chalk.hex('#7C3AED').bold('\n🟣 Claude Code 当前配置'));
+    console.log(chalk.gray('━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+    if (activeConfig) {
+        console.log(`名称: ${activeConfig.name}`);
+        console.log(`API Key: ${maskApiKey(activeConfig.apiKey)}`);
+        console.log(`Base URL: ${activeConfig.baseUrl}`);
+    }
+    else if (typeof authToken === 'string') {
+        console.log(`API Key: ${maskApiKey(authToken)}`);
+        console.log(`Base URL: ${typeof baseUrl === 'string' ? baseUrl : '(默认)'}`);
+        console.log(chalk.gray('（未匹配到已保存的配置）'));
+    }
+    else {
+        console.log(chalk.yellow('未配置'));
+    }
+    console.log('');
+}

package/dist/commands/delete.js

@@ -0,0 +1,47 @@
+import { cancel, confirm, intro, isCancel, outro, select } from '@clack/prompts';
+import chalk from 'chalk';
+import { deleteConfig } from '../config/config-data.js';
+import { maskApiKey, printSuccess } from '../ui/output.js';
+export function registerDeleteCommand(program, context) {
+    program
+        .command('delete')
+        .alias('rm')
+        .description('🗑️ 删除配置')
+        .option('-i, --interactive', '交互式删除')
+        .option('-n, --name <name>', '配置名称')
+        .action(async (options) => {
+        if (options.interactive || !options.name) {
+            await interactiveDelete(context);
+            return;
+        }
+        removeConfig(context, options.name);
+    });
+}
+async function interactiveDelete(context) {
+    console.clear();
+    intro(chalk.cyan.bold('🗑️ Claude API Switcher - 删除配置'));
+    const data = context.repository.read();
+    if (data.configs.length === 0) {
+        return void outro(chalk.yellow('暂无配置。'));
+    }
+    const selected = await select({
+        message: '选择要删除的配置',
+        options: data.configs.map((config) => ({
+            value: config.name,
+            label: `${config.name}${data.current === config.name ? ' (当前默认)' : ''}`,
+            hint: maskApiKey(config.apiKey),
+        })),
+    });
+    if (isCancel(selected))
+        return void cancel('操作已取消');
+    const selectedName = String(selected);
+    const accepted = await confirm({ message: `确认删除配置 "${selectedName}"？`, initialValue: false });
+    if (isCancel(accepted) || !accepted)
+        return void cancel('已取消删除');
+    removeConfig(context, selectedName);
+    outro(chalk.green('✅ 配置已删除！'));
+}
+function removeConfig(context, name) {
+    context.repository.write(deleteConfig(context.repository.read(), name));
+    printSuccess(`配置 "${name}" 已删除！`);
+}

package/dist/commands/history.js

@@ -0,0 +1,155 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { spawnSync } from 'node:child_process';
+import { Worker } from 'node:worker_threads';
+import { fileURLToPath } from 'node:url';
+import { cancel, confirm, isCancel } from '@clack/prompts';
+import { render } from 'ink';
+import React from 'react';
+import chalk from 'chalk';
+import { pageSessions } from '../history/session-service.js';
+import { HistoryApp } from '../history/ui/history-app.js';
+export function registerHistoryCommand(program, context) {
+    program
+        .command('history')
+        .description('🕘 查看所有 Agent 的历史会话')
+        .option('-a, --agent <agent>', '筛选 Agent：claude、codex、opencode')
+        .option('-p, --page <page>', '页码', '1')
+        .option('--page-size <size>', '每页数量', '20')
+        .option('--plain', '以非交互文本格式输出')
+        .action(async (options) => {
+        validateAgent(options.agent);
+        const page = parsePositiveInteger(options.page, 1, 'page');
+        const pageSize = parsePositiveInteger(options.pageSize, 20, 'page-size');
+        if (options.plain || !process.stdin.isTTY || !process.stdout.isTTY) {
+            printHistoryPage(loadSessions(context), options.agent, page, pageSize);
+            return;
+        }
+        await runInkHistory(context, options.agent, pageSize);
+    });
+}
+async function runInkHistory(context, agent, pageSize) {
+    let foregroundLaunch;
+    let clearScreen = () => { };
+    const app = render(_jsx(HistoryApp, { agent: agent, pageSize: pageSize, currentDirectory: process.cwd(), agents: context.agents.all().map((adapter) => ({
+            id: adapter.id,
+            name: adapter.name,
+            installed: adapter.discover().installed,
+        })), loadSessions: (onProgress) => loadSessionsInWorker(onProgress), onResume: async (session) => resumeSession(context, session), onMigrate: async (session, target) => migrateAndLaunch(context, session, target, true), onDelete: async (session) => deleteSession(context, session), onForegroundLaunch: (spec) => { foregroundLaunch = spec; }, onClearScreen: () => clearScreen() }));
+    clearScreen = app.clear;
+    try {
+        await app.waitUntilExit();
+    }
+    finally {
+        app.unmount();
+    }
+    if (foregroundLaunch)
+        launchInCurrentTerminal(foregroundLaunch);
+}
+function loadSessionsInWorker(onProgress) {
+    return new Promise((resolve, reject) => {
+        const worker = new Worker(fileURLToPath(new URL('../history/session-loader-worker.js', import.meta.url)));
+        worker.on('message', (message) => {
+            if (!isWorkerMessage(message))
+                return;
+            if (message.type === 'progress') {
+                onProgress(message.message);
+                return;
+            }
+            if (message.type === 'complete') {
+                resolve(message.sessions);
+                return;
+            }
+            reject(new Error(message.message));
+        });
+        worker.on('error', reject);
+        worker.on('exit', (code) => {
+            if (code !== 0)
+                reject(new Error(`历史扫描进程异常退出：${code}`));
+        });
+    });
+}
+function isWorkerMessage(value) {
+    return typeof value === 'object' && value !== null && typeof value.type === 'string';
+}
+function loadSessionsDeferred(context) {
+    return new Promise((resolve) => setTimeout(() => resolve(loadSessions(context)), 0));
+}
+function loadSessions(context) {
+    return context.agents.all().flatMap((adapter) => adapter.listSessions());
+}
+function printHistoryPage(contextSessions, agent, pageNumber, pageSize) {
+    const page = pageSessions(contextSessions, { page: pageNumber, pageSize, ...(agent ? { agent } : {}) });
+    console.log(chalk.bold(`\n🕘 历史会话：第 ${page.page}/${page.totalPages} 页，共 ${page.total} 条\n`));
+    if (!page.items.length) {
+        console.log(chalk.yellow('没有找到会话。'));
+        return;
+    }
+    page.items.forEach((session) => {
+        console.log(`${chalk.cyan(`[${session.agent}]`)} ${chalk.bold(session.title)}`);
+        console.log(chalk.gray(`  ${session.cwd} · ${session.updatedAt} · ${session.id}`));
+    });
+}
+async function resumeSession(context, session) {
+    return {
+        message: `正在当前终端启动 ${session.agent} 会话。`,
+        launch: context.agents.get(session.agent).createResumeLaunch(session),
+    };
+}
+async function deleteSession(context, session) {
+    context.agents.get(session.agent).deleteSession(session);
+    return { message: `已删除 ${session.agent} 会话：${session.title}` };
+}
+export async function migrateAndLaunch(context, session, target, confirmed = false) {
+    const prepared = context.migrationService.prepare(context.agents.get(session.agent), session, target);
+    if (!confirmed) {
+        const accepted = await confirm({
+            message: `将 ${session.agent} 会话迁移到 ${target}，创建新会话并保留原会话？附件：${prepared.attachmentCount} 个。`,
+            initialValue: true,
+        });
+        if (isCancel(accepted) || !accepted) {
+            cancel('已取消迁移');
+            return { message: '已取消迁移。' };
+        }
+    }
+    copyHistoryToClipboard(prepared.prompt);
+    const spec = context.agents.get(target).createNewLaunch({
+        cwd: session.cwd,
+        prompt: prepared.prompt,
+        assetDirectory: prepared.assetDirectory,
+    });
+    const warnings = prepared.warnings.length ? `\n迁移提示：${prepared.warnings.join('；')}` : '';
+    return {
+        message: `历史记录已自动导入 ${target} 新会话，并复制到剪贴板；迁移文件保留在 ${prepared.directory}。${warnings}`,
+        launch: spec,
+    };
+}
+function copyHistoryToClipboard(history) {
+    const clipboard = process.platform === 'darwin' ? 'pbcopy' : process.platform === 'win32' ? 'clip' : 'xclip';
+    const args = process.platform === 'linux' ? ['-selection', 'clipboard'] : [];
+    const result = spawnSync(clipboard, args, { input: history, encoding: 'utf8' });
+    if (result.error || result.status !== 0) {
+        throw new Error('无法复制历史记录到剪贴板。');
+    }
+}
+function launchInCurrentTerminal(spec) {
+    const [command, ...args] = spec.command;
+    if (!command)
+        throw new Error('启动命令为空。');
+    const result = spawnSync(command, args, { cwd: spec.cwd, stdio: 'inherit' });
+    if (result.error)
+        throw new Error(`无法启动 ${command}：${result.error.message}`);
+    if (result.status && result.status !== 0)
+        process.exitCode = result.status;
+}
+function parsePositiveInteger(value, fallback, option) {
+    const parsed = Number(value ?? fallback);
+    if (!Number.isInteger(parsed) || parsed < 1) {
+        throw new Error(`--${option} 必须为大于 0 的整数。`);
+    }
+    return parsed;
+}
+function validateAgent(agent) {
+    if (agent && !['claude', 'codex', 'opencode'].includes(agent)) {
+        throw new Error('Agent 必须为 claude、codex 或 opencode。');
+    }
+}