dgxay-code-cli 0.0.0-stage → 1.1.0

package/src/commands/export.js

@@ -0,0 +1,102 @@
+'use strict';
+
+/**
+ * export：导出会话（桌面版没有这个能力，CLI 补上）。
+ *
+ *   dgxay export                把最近一个会话输出到 stdout（Markdown）
+ *   dgxay export -o chat.md     写入文件
+ *   dgxay export --format json  导出 JSON
+ *   dgxay export 2              指定会话序号
+ */
+
+const fs = require('fs');
+const path = require('path');
+const print = require('../cli/print');
+const { actionFirst } = require('../cli/args');
+const sessions = require('../core/sessions');
+
+const options = [
+  { name: 'format', type: 'string', valueName: 'md|json', desc: 'Output format: markdown (default) / json' },
+  { name: 'output', alias: 'o', type: 'string', valueName: 'file', desc: 'Write to a file instead of printing' }
+];
+
+function toMarkdown(chat) {
+  const lines = [];
+  const date = new Date(chat.createdAt || Date.now());
+  lines.push(`# ${chat.title || 'New conversation'}`);
+  lines.push('');
+  lines.push(`> ${date.toLocaleString()} · ${chat.mode === 'work' ? 'Work mode' : 'Chat mode'}${chat.skill ? ` · Skill ${chat.skill}` : ''}`);
+  lines.push('');
+  for (const message of chat.messages) {
+    if (message.role === 'user') {
+      lines.push('## User');
+      lines.push('');
+      lines.push(message.content || '');
+      lines.push('');
+    } else if (message.role === 'assistant') {
+      lines.push('## DgxayCode');
+      lines.push('');
+      lines.push(message.content || '');
+      lines.push('');
+      if (message.toolLog?.length) {
+        lines.push('<details><summary>Tool calls</summary>');
+        lines.push('');
+        for (const tool of message.toolLog) {
+          lines.push(`- \`${tool.name}\` ${tool.ok ? 'ok' : 'failed'}${tool.review?.reason ? ` · ${tool.review.reason}` : ''}`);
+        }
+        lines.push('');
+        lines.push('</details>');
+        lines.push('');
+      }
+    } else if (message.role === 'terminal') {
+      lines.push('## Terminal');
+      lines.push('');
+      lines.push('```');
+      lines.push(`$ ${message.command}`);
+      lines.push(`${message.output || ''}${message.stderr || ''}`.trimEnd());
+      lines.push('```');
+      lines.push('');
+    }
+  }
+  return lines.join('\n');
+}
+
+async function run({ argv }) {
+  const { action, rest, options: opts } = actionFirst(argv, options);
+  const ref = action || rest[0] || '';
+  const chats = sessions.listChats();
+  if (!chats.length) {
+    print.warn('No conversation to export yet');
+    return 1;
+  }
+  const chat = ref ? sessions.resolveChat(ref, chats) : chats[0];
+  if (!chat) {
+    print.fail(`Conversation not found: ${ref}`);
+    return 1;
+  }
+  const format = String(opts.format || 'md').toLowerCase();
+  const content =
+    format === 'json'
+      ? `${JSON.stringify(chat, null, 2)}\n`
+      : toMarkdown(chat);
+
+  if (opts.output) {
+    const target = path.resolve(opts.output);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, content, 'utf8');
+    print.ok(`Exported "${chat.title}" to ${target}`);
+    return 0;
+  }
+  process.stdout.write(content.endsWith('\n') ? content : `${content}\n`);
+  return 0;
+}
+
+module.exports = {
+  name: 'export',
+  aliases: ['dump'],
+  summary: 'Export a conversation as Markdown / JSON',
+  usage: 'dgxay export [n|id] [--format md|json] [-o file]',
+  options,
+  examples: ['dgxay export', 'dgxay export 2 -o chat.md', 'dgxay export -o chats.json --format json'],
+  run
+};

package/src/commands/mcp.js

@@ -0,0 +1,257 @@
+'use strict';
+
+/**
+ * mcp：MCP Server 管理（对应桌面版「设置 → MCP」）。
+ *
+ *   dgxay mcp list
+ *   dgxay mcp add --name filesystem --command npx --args "-y @modelcontextprotocol/server-filesystem ."
+ *   dgxay mcp start <名称|ID>
+ *   dgxay mcp stop <名称|ID>
+ *   dgxay mcp logs <名称|ID>
+ *   dgxay mcp rm <名称|ID>
+ *   dgxay mcp env <名称|ID> --env "KEY=value"    追加环境变量
+ *
+ * 注意：与桌面版一致，当前版本只管理进程，不把 MCP 工具暴露给模型。
+ */
+
+const print = require('../cli/print');
+const { parseArgs, actionFirst } = require('../cli/args');
+const { COLORS } = require('../cli/ansi');
+const mcp = require('../core/mcp');
+const cfg = require('../services/config');
+const { ask } = require('../services/input');
+
+const options = [
+  { name: 'name', type: 'string', valueName: 'text', desc: 'Display name' },
+  { name: 'command', type: 'string', valueName: 'cmd', desc: 'Start command (e.g. npx / uvx)' },
+  { name: 'args', type: 'string', valueName: 'text', desc: 'Command arguments' },
+  { name: 'env', type: 'list', valueName: 'K=V', desc: 'Environment variables, repeatable' },
+  { name: 'cwd', type: 'string', valueName: 'dir', desc: 'Working directory' },
+  { name: 'follow', alias: 'f', type: 'boolean', desc: 'logs: keep streaming output' },
+  { name: 'yes', alias: 'y', type: 'boolean', desc: 'Skip confirmation' }
+];
+
+function statusText(status) {
+  if (status === 'running') return COLORS.green('running');
+  if (status === 'error') return COLORS.red('error');
+  if (status === 'stopping') return COLORS.yellow('stopping');
+  return COLORS.faint('stopped');
+}
+
+function list() {
+  const servers = mcp.listServers();
+  print.blank();
+  if (!servers.length) {
+    print.hint(`No MCP servers yet (config is stored in ${cfg.MCP_PATH})`);
+    print.hint('Add: dgxay mcp add --name filesystem --command npx --args "-y @modelcontextprotocol/server-filesystem ."');
+    print.blank();
+    return 0;
+  }
+  print.heading(`MCP servers (${servers.length})`);
+  const rows = servers.map((server, index) => [
+    String(index + 1),
+    server.name,
+    statusText(server.status),
+    server.pid ? String(server.pid) : '',
+    `${server.command} ${(server.args || []).join(' ')}`.trim(),
+    server.cwd || ''
+  ]);
+  print.table(
+    [
+      { title: '#', max: 3 },
+      { title: 'Name', max: 20 },
+      { title: 'Status', max: 8 },
+      { title: 'PID', max: 7 },
+      { title: 'Command', max: 50 },
+      { title: 'Working dir', max: 30 }
+    ],
+    rows
+  );
+  print.blank();
+  print.hint('MCP servers do not start with the app; run start manually each time');
+  print.hint('This version only manages processes; MCP tools are not yet exposed to the model');
+  print.blank();
+  return 0;
+}
+
+function resolve(ref) {
+  const server = mcp.findServer(ref);
+  if (!server) {
+    print.fail(`MCP not found: ${ref}`);
+    return null;
+  }
+  return server;
+}
+
+async function add(opts) {
+  let name = opts.name;
+  let command = opts.command;
+  if (!name && process.stdin.isTTY) name = String((await ask('Name: ')) || '').trim();
+  if (!command && process.stdin.isTTY) command = String((await ask('Start command (e.g. npx): ')) || '').trim();
+  if (!name || !command) {
+    throw Object.assign(new Error('Usage: dgxay mcp add --name <name> --command <command> [--args "..."]'), {
+      userError: true
+    });
+  }
+  const server = mcp.addServer({
+    name,
+    command,
+    args: opts.args || '',
+    env: (opts.env || []).join('\n'),
+    cwd: opts.cwd || ''
+  });
+  print.ok(`Saved MCP server "${server.name}" (${server.id})`);
+  print.hint(`Start: dgxay mcp start ${server.name}`);
+  return 0;
+}
+
+function start(ref) {
+  const server = resolve(ref);
+  if (!server) return 1;
+  try {
+    const result = mcp.startServer(server.id);
+    if (result.status === 'running' && result.pid) print.ok(`Started ${server.name} (pid ${result.pid})`);
+    else print.ok(`${server.name} is already running`);
+    print.hint(`View logs: dgxay mcp logs ${server.name}`);
+    return 0;
+  } catch (err) {
+    print.fail(err.message);
+    return 1;
+  }
+}
+
+function stop(ref) {
+  const server = resolve(ref);
+  if (!server) return 1;
+  const ok = mcp.stopServer(server.id);
+  if (ok) print.ok(`Stopped ${server.name}`);
+  else print.warn(`${server.name} is not running`);
+  return 0;
+}
+
+async function logs(ref, opts) {
+  const server = resolve(ref);
+  if (!server) return 1;
+  const shown = new Set();
+  const printLogs = () => {
+    const entries = mcp.statusOf(server.id).logs || [];
+    for (const entry of entries) {
+      const key = `${entry.at}:${entry.stream}:${entry.text}`;
+      if (shown.has(key)) continue;
+      shown.add(key);
+      print.write(entry.stream === 'stderr' ? COLORS.red(entry.text) : entry.text);
+    }
+  };
+  printLogs();
+  if (!opts.follow) {
+    if (!shown.size) print.hint('No logs yet');
+    return 0;
+  }
+  print.hint('Streaming; press Ctrl+C to exit');
+  mcp.setNotifier((event) => {
+    if (event.type === 'log' && event.id === server.id) {
+      print.write(event.stream === 'stderr' ? COLORS.red(event.text) : event.text);
+    }
+  });
+  await new Promise((resolve) => {
+    process.once('SIGINT', () => resolve());
+  });
+  return 0;
+}
+
+async function remove(ref, opts) {
+  const server = resolve(ref);
+  if (!server) return 1;
+  if (!opts.yes && process.stdin.isTTY) {
+    const answer = await ask(`Delete MCP server "${server.name}" and stop its process? [y/N] `);
+    if (!/^y/i.test(String(answer || '').trim())) {
+      print.hint('Cancelled');
+      return 1;
+    }
+  }
+  mcp.removeServer(server.id);
+  print.ok(`Deleted ${server.name}`);
+  return 0;
+}
+
+function updateEnv(ref, opts) {
+  const server = resolve(ref);
+  if (!server) return 1;
+  const env = { ...(server.env || {}) };
+  for (const pair of opts.env || []) {
+    const index = String(pair).indexOf('=');
+    if (index > 0) env[String(pair).slice(0, index).trim()] = String(pair).slice(index + 1).trim();
+  }
+  mcp.addServer({
+    name: server.name,
+    command: server.command,
+    args: server.args,
+    env,
+    cwd: server.cwd
+  });
+  print.ok(`Updated environment variables for ${server.name} (${Object.keys(env).length} entries)`);
+  print.warn('Takes effect after restart: dgxay mcp stop ' + server.name + ' && dgxay mcp start ' + server.name);
+  return 0;
+}
+
+async function run({ argv }) {
+  const { action: rawAction, rest: restArgs, options: opts } = actionFirst(argv, options);
+  const action = rawAction || 'list';
+  const ref = restArgs.join(' ');
+
+  // 兼容：dgxay mcp <名称> 视为 start
+  if (!['list', 'ls', 'add', 'start', 'run', 'stop', 'logs', 'log', 'rm', 'remove', 'delete', 'env'].includes(action)) {
+    return start(restArgs.join(' '));
+  }
+
+  switch (action) {
+    case 'list':
+    case 'ls':
+      return list();
+    case 'add':
+      return add(opts);
+    case 'start':
+    case 'run':
+      if (!ref) throw Object.assign(new Error('Usage: dgxay mcp start <name|id>'), { userError: true });
+      return start(ref);
+    case 'stop':
+      if (!ref) throw Object.assign(new Error('Usage: dgxay mcp stop <name|id>'), { userError: true });
+      return stop(ref);
+    case 'logs':
+    case 'log':
+      if (!ref) throw Object.assign(new Error('Usage: dgxay mcp logs <name|id> [-f]'), { userError: true });
+      return logs(ref, opts);
+    case 'rm':
+    case 'remove':
+    case 'delete':
+      if (!ref) throw Object.assign(new Error('Usage: dgxay mcp rm <name|id>'), { userError: true });
+      return remove(ref, opts);
+    case 'env':
+      if (!ref) throw Object.assign(new Error('Usage: dgxay mcp env <name|id> --env "KEY=value"'), { userError: true });
+      return updateEnv(ref, opts);
+    default:
+      return 1;
+  }
+}
+
+module.exports = {
+  name: 'mcp',
+  summary: 'Manage MCP servers',
+  usage: 'dgxay mcp <list|add|start|stop|logs|rm|env>',
+  options,
+  subcommands: [
+    ['list', 'List MCP servers'],
+    ['add', 'Add a server'],
+    ['start <name>', 'Start the process'],
+    ['stop <name>', 'Stop the process'],
+    ['logs <name> [-f]', 'View logs'],
+    ['rm <name>', 'Delete'],
+    ['env <name> --env K=V', 'Update environment variables']
+  ],
+  examples: [
+    'dgxay mcp add --name filesystem --command npx --args "-y @modelcontextprotocol/server-filesystem ."',
+    'dgxay mcp start filesystem',
+    'dgxay mcp logs filesystem -f'
+  ],
+  run
+};

package/src/commands/model.js

@@ -0,0 +1,223 @@
+'use strict';
+
+/**
+ * model：模型管理。
+ *
+ *   dgxay model list                 列出当前供应商的模型与上下文窗口
+ *   dgxay model use <id|序号>         设为当前模型
+ *   dgxay model add <id> [--name X] [--context-window N] [--provider P]
+ *   dgxay model rm <id> [--provider P]
+ *   dgxay model fetch [--provider P] [--base-url ...] [--api-key ...]
+ */
+
+const print = require('../cli/print');
+const { parseArgs, actionFirst } = require('../cli/args');
+const { COLORS } = require('../cli/ansi');
+const settings = require('../services/settings');
+const sessions = require('../core/sessions');
+const { askSecret } = require('../services/input');
+
+const options = [
+  { name: 'provider', alias: 'p', type: 'string', valueName: 'name', desc: 'Target provider (default: active provider)' },
+  { name: 'name', type: 'string', valueName: 'text', desc: 'Display name' },
+  { name: 'context-window', type: 'number', valueName: 'n', desc: 'Context window' },
+  { name: 'base-url', type: 'string', valueName: 'url', desc: 'Use this base URL when fetching the list' },
+  { name: 'api-key', type: 'string', valueName: 'key', desc: 'Use this key when fetching the list' },
+  { name: 'add', type: 'list', valueName: 'id', desc: 'Add the given models to the provider after fetching' }
+];
+
+function list(providerRef) {
+  const config = settings.readConfig();
+  const provider = providerRef ? settings.findProvider(providerRef) : settings.activeProvider(config);
+  if (!provider) {
+    print.warn('No providers yet, run dgxay config init');
+    return 1;
+  }
+  const models = provider.models || [];
+  print.blank();
+  print.heading(`Models for ${provider.name} (${models.length})`);
+  if (!models.length) {
+    print.hint('  No models yet, run dgxay model add <id>');
+    print.blank();
+    return 0;
+  }
+  const active = provider.id === config.activeProviderId ? config.activeModelId : '';
+  const rows = models.map((model, index) => [
+    String(index + 1),
+    model.id === active ? COLORS.accent('❯') : ' ',
+    model.name || model.id,
+    model.id,
+    model.contextWindow ? sessions.formatTokens(model.contextWindow) : COLORS.faint('protocol default'),
+    provider.reviewModelId === model.id ? 'review' : ''
+  ]);
+  print.table(
+    [
+      { title: '#', max: 3 },
+      { title: '', max: 1 },
+      { title: 'Name', max: 26 },
+      { title: 'ID', max: 32 },
+      { title: 'Context', max: 10 },
+      { title: '', max: 4 }
+    ],
+    rows
+  );
+  print.blank();
+  return 0;
+}
+
+async function fetchList(opts) {
+  const config = settings.readConfig();
+  const provider = opts.provider ? settings.findProvider(opts.provider) : settings.activeProvider(config);
+  let apiKey = opts.apiKey;
+  if (apiKey === undefined && provider && !(provider.authMode === 'oauth') && !provider.apiKey) {
+    const secret = await askSecret('API Key: ');
+    apiKey = secret || '';
+  }
+  process.stdout.write(`${COLORS.faint('Fetching model list...')}`);
+  try {
+    let models;
+    if (opts.baseUrl) {
+      models = await settings.fetchModels({
+        baseUrl: opts.baseUrl,
+        apiKey: apiKey ?? '',
+        protocol: opts.protocol || provider?.protocol || 'openai'
+      });
+    } else {
+      if (!provider) throw new Error('No provider available');
+      models = await settings.fetchModels({ providerRef: provider.id, apiKey });
+    }
+    process.stdout.write('\r\x1b[2K');
+    print.ok(`Fetched ${models.length} model(s)`);
+    const existing = new Set((provider?.models || []).map((m) => m.id));
+    for (const id of models) {
+      print.write(`  ${existing.has(id) ? COLORS.green('✓') : ' '} ${id}`);
+    }
+    print.blank();
+    print.hint('Use dgxay model add <id> to add to the provider; if fetching fails you can type the model ID manually');
+    return 0;
+  } catch (err) {
+    process.stdout.write('\r\x1b[2K');
+    print.fail(`Fetch failed: ${err.message}`);
+    print.hint('Some gateways do not support the /models endpoint; add models manually with dgxay model add <id>');
+    return 1;
+  }
+}
+
+function addModel(id, opts) {
+  const config = settings.readConfig();
+  const provider = opts.provider ? settings.findProvider(opts.provider) : settings.activeProvider(config);
+  if (!provider) {
+    print.warn('No providers yet, run dgxay config init');
+    return 1;
+  }
+  const models = (provider.models || []).slice();
+  if (models.some((m) => m.id === id)) {
+    print.warn(`Model ${id} already exists`);
+    return 1;
+  }
+  models.push({
+    id,
+    name: opts.name || id,
+    contextWindow: Number(opts.contextWindow) || 0
+  });
+  const next = (config.providers || []).map((p) => (p.id === provider.id ? { ...p, models } : p));
+  const patch = { providers: next };
+  if (provider.id === config.activeProviderId && !config.activeModelId) patch.activeModelId = id;
+  settings.saveConfig(patch);
+  print.ok(`Model added: ${id}`);
+  return 0;
+}
+
+function removeModel(id, opts) {
+  const config = settings.readConfig();
+  const provider = opts.provider ? settings.findProvider(opts.provider) : settings.activeProvider(config);
+  if (!provider) {
+    print.warn('No providers yet');
+    return 1;
+  }
+  const models = (provider.models || []).filter((m) => m.id !== id);
+  if (models.length === (provider.models || []).length) {
+    print.fail(`Provider ${provider.name} has no model ${id}`);
+    return 1;
+  }
+  if (!models.length) {
+    print.fail('Cannot delete the last model; add another model first');
+    return 1;
+  }
+  const reviewModelId = models.some((m) => m.id === provider.reviewModelId)
+    ? provider.reviewModelId
+    : models[0].id;
+  const next = (config.providers || []).map((p) =>
+    p.id === provider.id ? { ...p, models, reviewModelId } : p
+  );
+  const patch = { providers: next };
+  if (config.activeModelId === id) patch.activeModelId = models[0].id;
+  settings.saveConfig(patch);
+  print.ok(`Model deleted: ${id}`);
+  return 0;
+}
+
+function useModel(ref, opts) {
+  const config = settings.readConfig();
+  const provider = opts.provider ? settings.findProvider(opts.provider) : settings.activeProvider(config);
+  if (!provider) {
+    print.warn('No providers yet');
+    return 1;
+  }
+  const models = provider.models || [];
+  const index = Number(ref);
+  const target =
+    (Number.isInteger(index) && index >= 1 && index <= models.length ? models[index - 1] : null) ||
+    models.find((m) => m.id === ref) ||
+    models.find((m) => m.id.includes(ref));
+  if (!target) {
+    print.fail(`Model not found: ${ref}`);
+    return 1;
+  }
+  settings.setActiveModel(provider.id, target.id);
+  print.ok(`Active model: ${target.name || target.id} (${provider.name})`);
+  return 0;
+}
+
+async function run({ argv }) {
+  const { action: rawAction, rest, options: opts } = actionFirst(argv, options);
+  const action = rawAction || 'list';
+
+  // model add deepseek-chat gpt-4o 支持多个
+  if (action === 'add') {
+    if (!rest.length) throw Object.assign(new Error('Usage: dgxay model add <id> [<id>...]'), { userError: true });
+    let code = 0;
+    for (const id of rest) code = Math.max(code, addModel(id, opts));
+    return code;
+  }
+  if (action === 'rm' || action === 'remove' || action === 'delete') {
+    if (!rest[0]) throw Object.assign(new Error('Usage: dgxay model rm <id>'), { userError: true });
+    return removeModel(rest[0], opts);
+  }
+  if (action === 'use' || action === 'set') {
+    if (!rest[0]) throw Object.assign(new Error('Usage: dgxay model use <id|index>'), { userError: true });
+    return useModel(rest[0], opts);
+  }
+  if (action === 'fetch' || action === 'ls-remote') return fetchList(opts);
+  if (action === 'list' || action === 'ls') return list(opts.provider);
+
+  // 不是已知子命令：当作模型 ID 使用
+  return useModel(action, opts);
+}
+
+module.exports = {
+  name: 'model',
+  aliases: ['models'],
+  summary: 'Model management: list, switch, add/remove, fetch',
+  usage: 'dgxay model <list|use|add|rm|fetch>',
+  options,
+  subcommands: [
+    ['list', 'List models'],
+    ['use <id|index>', 'Switch the active model'],
+    ['add <id>', 'Add a model'],
+    ['rm <id>', 'Delete a model'],
+    ['fetch', 'Fetch the model list from the provider API']
+  ],
+  examples: ['dgxay model list', 'dgxay model use 2', 'dgxay model add gpt-4o --name GPT-4o', 'dgxay model fetch'],
+  run
+};