dgxay-code-cli 0.0.0-stage → 1.1.0

package/src/core/tools.js

@@ -0,0 +1,391 @@
+'use strict';
+
+/**
+ * 工具定义、权限矩阵与文件 / 命令 / 联网执行。
+ *
+ * 权限在主进程逻辑之外再校验一次，渲染层（这里是交互层）无法绕过：
+ *  - none    仅允许只读工作空间内文件
+ *  - normal  每次调用都必须经 requestApproval 同意
+ *  - auto    先由审查模型判断，可疑才询问
+ *  - full    直接执行
+ *
+ * 新增工具时必须同步更新：DEFINITIONS / PERMISSION_TOOLS / execute() 分支 /
+ * 系统提示中的能力描述 / 审查授权路径。
+ */
+
+const fs = require('fs');
+const fsp = require('fs/promises');
+const path = require('path');
+const os = require('os');
+const { exec } = require('child_process');
+
+const MAX_READ = 120000;
+const MAX_OUTPUT = 24000;
+
+const DEFINITIONS = {
+  list_directory: {
+    type: 'function',
+    function: {
+      name: 'list_directory',
+      description:
+        'List files and folders inside a directory. Use it to understand the workspace before reading or editing files.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: {
+            type: 'string',
+            description: 'Directory path, absolute or relative to the workspace. Defaults to workspace root.'
+          },
+          depth: { type: 'integer', description: 'How deep to recurse, 1-3. Default 1.' }
+        },
+        additionalProperties: false
+      }
+    }
+  },
+  read_file: {
+    type: 'function',
+    function: {
+      name: 'read_file',
+      description: 'Read the text content of a file. Always read a file before modifying it.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'File path, absolute or relative to the workspace.' }
+        },
+        required: ['path'],
+        additionalProperties: false
+      }
+    }
+  },
+  write_file: {
+    type: 'function',
+    function: {
+      name: 'write_file',
+      description:
+        'Create or overwrite a file with the given content. Parent folders are created automatically. Generated files must stay inside the workspace.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Target file path, preferably relative to the workspace.' },
+          content: { type: 'string', description: 'Full file content to write.' }
+        },
+        required: ['path', 'content'],
+        additionalProperties: false
+      }
+    }
+  },
+  create_directory: {
+    type: 'function',
+    function: {
+      name: 'create_directory',
+      description: 'Create a folder (including missing parents) inside the workspace.',
+      parameters: {
+        type: 'object',
+        properties: { path: { type: 'string', description: 'Folder path.' } },
+        required: ['path'],
+        additionalProperties: false
+      }
+    }
+  },
+  delete_path: {
+    type: 'function',
+    function: {
+      name: 'delete_path',
+      description: 'Delete a file or folder. Use with care and only when the user asked for it.',
+      parameters: {
+        type: 'object',
+        properties: { path: { type: 'string', description: 'Path to delete.' } },
+        required: ['path'],
+        additionalProperties: false
+      }
+    }
+  },
+  run_command: {
+    type: 'function',
+    function: {
+      name: 'run_command',
+      description: 'Run a shell command on the user machine and return stdout/stderr.',
+      parameters: {
+        type: 'object',
+        properties: {
+          command: { type: 'string', description: 'Command line to execute.' },
+          cwd: { type: 'string', description: 'Working directory, defaults to the workspace.' }
+        },
+        required: ['command'],
+        additionalProperties: false
+      }
+    }
+  },
+  install_mcp_server: {
+    type: 'function',
+    function: {
+      name: 'install_mcp_server',
+      description:
+        'Install an MCP server into DgxayCode by saving its startup command to ~/.dcb/mcp.json. The user can start it later with `dgxay mcp start`.',
+      parameters: {
+        type: 'object',
+        properties: {
+          name: { type: 'string', description: 'Display name for the MCP server.' },
+          command: { type: 'string', description: 'Executable used to start the server, e.g. npx or uvx.' },
+          args: { type: 'array', items: { type: 'string' }, description: 'Command arguments.' },
+          env: {
+            type: 'object',
+            additionalProperties: { type: 'string' },
+            description: 'Extra environment variables.'
+          },
+          cwd: { type: 'string', description: 'Optional working directory.' }
+        },
+        required: ['name', 'command'],
+        additionalProperties: false
+      }
+    }
+  },
+  fetch_url: {
+    type: 'function',
+    function: {
+      name: 'fetch_url',
+      description:
+        'Fetch a URL over HTTP(S) and return the response body as text. In normal mode the user reviews the request before it runs.',
+      parameters: {
+        type: 'object',
+        properties: {
+          url: { type: 'string', description: 'Absolute http(s) URL.' },
+          method: {
+            type: 'string',
+            enum: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'],
+            description: 'HTTP method, default GET.'
+          },
+          body: { type: 'string', description: 'Optional request body (JSON or raw text).' }
+        },
+        required: ['url'],
+        additionalProperties: false
+      }
+    }
+  }
+};
+
+const PERMISSION_TOOLS = {
+  none: ['list_directory', 'read_file'],
+  // 普通权限与自动审查都拥有全部能力，区别在授权流程
+  normal: Object.keys(DEFINITIONS),
+  auto: Object.keys(DEFINITIONS),
+  full: Object.keys(DEFINITIONS)
+};
+
+function toolsFor(permission) {
+  const names = PERMISSION_TOOLS[permission] || PERMISSION_TOOLS.none;
+  return names.map((name) => DEFINITIONS[name]);
+}
+
+function sameOrInside(root, target) {
+  if (!root) return false;
+  const rel = path.relative(root.toLowerCase(), target.toLowerCase());
+  return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+}
+
+function resolveTarget(input, workspace) {
+  const raw = String(input || '').trim();
+  if (!raw) throw new Error('Missing path argument');
+  const base = workspace || os.homedir();
+  return path.normalize(path.isAbsolute(raw) ? raw : path.resolve(base, raw));
+}
+
+function displayPath(abs, workspace) {
+  if (workspace && sameOrInside(workspace, abs)) {
+    const rel = path.relative(workspace, abs) || '.';
+    return rel.split(path.sep).join('/');
+  }
+  return abs;
+}
+
+function assertReadable(target, ctx) {
+  if (ctx.permission === 'none') {
+    if (!ctx.workspace) throw new Error('No workspace selected in read-only mode: cannot read files');
+    if (!sameOrInside(ctx.workspace, target)) {
+      throw new Error('Read-only mode only allows files inside the workspace');
+    }
+  }
+}
+
+function assertWritable(target, ctx) {
+  if (ctx.permission === 'none') throw new Error('Read-only mode forbids modifying files');
+  const roots = [path.parse(target).root, os.homedir(), ctx.workspace || ''].filter(Boolean);
+  for (const root of roots) {
+    if (path.normalize(target).toLowerCase() === path.normalize(root).toLowerCase()) {
+      throw new Error('Refusing to write to or delete a root directory');
+    }
+  }
+}
+
+async function walkTree(dir, depth, prefix, acc, limit) {
+  if (acc.length >= limit) return;
+  let entries = [];
+  try {
+    entries = await fsp.readdir(dir, { withFileTypes: true });
+  } catch (err) {
+    acc.push(`${prefix}[cannot read: ${err.code || err.message}]`);
+    return;
+  }
+  entries.sort((a, b) => Number(b.isDirectory()) - Number(a.isDirectory()) || a.name.localeCompare(b.name));
+  const visible = entries
+    .filter((e) => !e.name.startsWith('.') || e.name === '.dcb' || e.name === '.env.example')
+    .slice(0, 80);
+  for (const entry of visible) {
+    if (acc.length >= limit) {
+      acc.push(`${prefix}... (truncated)`);
+      return;
+    }
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      acc.push(`${prefix}${entry.name}/`);
+      if (depth > 1) {
+        await walkTree(full, depth - 1, `${prefix}  `, acc, limit);
+      }
+    } else {
+      let size = 0;
+      try {
+        size = (await fsp.stat(full)).size;
+      } catch {
+        /* ignore */
+      }
+      acc.push(`${prefix}${entry.name}  (${size} B)`);
+    }
+  }
+}
+
+function truncate(text, limit) {
+  if (text.length <= limit) return text;
+  return `${text.slice(0, limit)}\n\n... (output truncated, ${text.length} chars total)`;
+}
+
+async function execute(name, args, ctx) {
+  const permission = ctx.permission || 'none';
+  const allowed = PERMISSION_TOOLS[permission] || [];
+  if (!allowed.includes(name)) {
+    throw new Error(`Permission level (${permission}) does not allow tool ${name}`);
+  }
+  const workspace = ctx.workspace || '';
+
+  if (permission === 'normal' || permission === 'auto') {
+    if (typeof ctx.requestApproval !== 'function') {
+      throw new Error('Missing approval callback for this permission level — blocked');
+    }
+    const ok = await ctx.requestApproval({ name, args });
+    if (!ok) throw new Error('The user declined this operation — do not retry');
+  }
+
+  switch (name) {
+    case 'list_directory': {
+      const target = resolveTarget(args.path || '.', workspace);
+      assertReadable(target, ctx);
+      const stat = await fsp.stat(target);
+      if (!stat.isDirectory()) throw new Error(`${displayPath(target, workspace)} is not a directory`);
+      const acc = [`${displayPath(target, workspace)}/`];
+      await walkTree(target, Math.min(Math.max(Number(args.depth) || 1, 1), 3), '  ', acc, 200);
+      return acc.join('\n');
+    }
+    case 'read_file': {
+      const target = resolveTarget(args.path, workspace);
+      assertReadable(target, ctx);
+      const stat = await fsp.stat(target);
+      if (stat.isDirectory()) throw new Error('That path is a directory — use list_directory');
+      if (stat.size > 2 * 1024 * 1024) throw new Error('File too large (>2MB) — use a shell command instead');
+      const content = await fsp.readFile(target, 'utf8');
+      return `File: ${displayPath(target, workspace)}\n\n${truncate(content, MAX_READ)}`;
+    }
+    case 'write_file': {
+      const target = resolveTarget(args.path, workspace);
+      assertWritable(target, ctx);
+      const content = typeof args.content === 'string' ? args.content : String(args.content ?? '');
+      await fsp.mkdir(path.dirname(target), { recursive: true });
+      let action = 'created';
+      try {
+        await fsp.access(target);
+        action = 'updated';
+      } catch {
+        /* new file */
+      }
+      await fsp.writeFile(target, content, 'utf8');
+      const bytes = Buffer.byteLength(content, 'utf8');
+      ctx.onFile?.({ action, path: target, display: displayPath(target, workspace), bytes });
+      return `${action === 'created' ? 'Created' : 'Updated'} ${displayPath(target, workspace)} (${bytes} bytes)`;
+    }
+    case 'create_directory': {
+      const target = resolveTarget(args.path, workspace);
+      assertWritable(target, ctx);
+      await fsp.mkdir(target, { recursive: true });
+      return `Created directory ${displayPath(target, workspace)}`;
+    }
+    case 'delete_path': {
+      const target = resolveTarget(args.path, workspace);
+      assertWritable(target, ctx);
+      const stat = await fsp.stat(target);
+      await fsp.rm(target, { recursive: stat.isDirectory(), force: false });
+      ctx.onFile?.({ action: 'deleted', path: target, display: displayPath(target, workspace), bytes: 0 });
+      return `Deleted ${displayPath(target, workspace)}`;
+    }
+    case 'run_command': {
+      const cwd = args.cwd ? resolveTarget(args.cwd, workspace) : workspace || os.homedir();
+      const safeCwd = fs.existsSync(cwd) ? cwd : os.homedir();
+      return await new Promise((resolve) => {
+        exec(
+          String(args.command || ''),
+          { cwd: safeCwd, timeout: 180000, maxBuffer: 8 * 1024 * 1024, windowsHide: true, shell: true },
+          (err, stdout, stderr) => {
+            const parts = [`$ ${args.command}`];
+            if (stdout) parts.push(String(stdout).trim());
+            if (stderr) parts.push(`[stderr]\n${String(stderr).trim()}`);
+            if (err) parts.push(`[exit] code=${err.code ?? 'unknown'} ${err.killed ? '(timeout or killed)' : ''}`);
+            if (!stdout && !stderr && !err) parts.push('(no output)');
+            resolve(truncate(parts.join('\n\n'), MAX_OUTPUT));
+          }
+        );
+      });
+    }
+    case 'fetch_url': {
+      const url = String(args.url || '');
+      let parsed;
+      try {
+        parsed = new URL(url);
+      } catch {
+        throw new Error('Invalid URL');
+      }
+      if (!/^https?:$/.test(parsed.protocol)) throw new Error('Only http/https is supported');
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), 30000);
+      try {
+        const res = await fetch(url, {
+          method: (args.method || 'GET').toUpperCase(),
+          headers: {
+            'User-Agent': 'Mozilla/5.0 DgxayCode-CLI/1.0',
+            ...(args.body ? { 'Content-Type': 'application/json' } : {})
+          },
+          body: args.body || undefined,
+          signal: controller.signal
+        });
+        const text = await res.text();
+        const contentType = res.headers.get('content-type') || '';
+        return truncate(`HTTP ${res.status} ${res.statusText}\ncontent-type: ${contentType}\n\n${text}`, MAX_OUTPUT);
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+    case 'install_mcp_server': {
+      const mcp = require('./mcp');
+      const server = mcp.addServer({
+        name: args.name,
+        command: args.command,
+        args: args.args,
+        env: args.env,
+        cwd: args.cwd
+      });
+      return `Installed MCP server "${server.name}" (command: ${server.command} ${(server.args || []).join(
+        ' '
+      )}）。请用 dgxay mcp start ${server.id} 或在 /mcp 面板中启动。`;
+    }
+    default:
+      throw new Error(`Unknown tool: ${name}`);
+  }
+}
+
+module.exports = { toolsFor, execute, PERMISSION_TOOLS, DEFINITIONS, resolveTarget, displayPath, sameOrInside };

package/src/services/config.js

@@ -0,0 +1,182 @@
+'use strict';
+
+/**
+ * 数据目录与配置读写。
+ *
+ * 数据目录为 %USERPROFILE%\.dcb（Windows）或 ~/.dcb（macOS / Linux），
+ * 可用 DGXAY_HOME 覆盖（桌面版等价变量名 DCB_HOME 同样兼容），便于测试隔离。
+ *
+ * config.json / chats.json / oauth.json / mcp.json 均以 0600 原子写入，目录为 0700。
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const DCB_DIR = process.env.DGXAY_HOME
+  ? path.resolve(process.env.DGXAY_HOME)
+  : process.env.DCB_HOME
+    ? path.resolve(process.env.DCB_HOME)
+    : path.join(os.homedir(), '.dcb');
+const CONFIG_PATH = path.join(DCB_DIR, 'config.json');
+const CHATS_PATH = path.join(DCB_DIR, 'chats.json');
+const MCP_PATH = path.join(DCB_DIR, 'mcp.json');
+const SKILLS_DIR = path.join(DCB_DIR, 'skills');
+const OAUTH_PATH = path.join(DCB_DIR, 'oauth.json');
+
+const DEFAULT_CONFIG = {
+  version: 1,
+  onboarded: false,
+  providers: [],
+  activeProviderId: '',
+  activeModelId: '',
+  ui: {
+    mode: 'chat',
+    permission: 'normal'
+  },
+  work: {
+    workspace: '',
+    recentWorkspaces: []
+  },
+  chat: {
+    stream: true,
+    temperature: 0.7,
+    maxTokens: 4096,
+    systemPrompt: ''
+  },
+  meta: {
+    createdAt: null,
+    updatedAt: null
+  }
+};
+
+function isPlainObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function deepMerge(base, patch) {
+  if (!isPlainObject(patch)) return base;
+  const out = Array.isArray(base) ? base.slice() : { ...base };
+  for (const [key, value] of Object.entries(patch)) {
+    if (isPlainObject(value) && isPlainObject(base[key])) {
+      out[key] = deepMerge(base[key], value);
+    } else {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+
+function ensureDir() {
+  if (!fs.existsSync(DCB_DIR)) {
+    fs.mkdirSync(DCB_DIR, { recursive: true, mode: 0o700 });
+  }
+  return DCB_DIR;
+}
+
+function hasDcbDir() {
+  try {
+    return fs.existsSync(DCB_DIR);
+  } catch {
+    return false;
+  }
+}
+
+function readConfig() {
+  const base = JSON.parse(JSON.stringify(DEFAULT_CONFIG));
+  if (!fs.existsSync(CONFIG_PATH)) return base;
+  try {
+    const raw = fs.readFileSync(CONFIG_PATH, 'utf8');
+    const parsed = JSON.parse(raw);
+    const merged = deepMerge(base, parsed);
+    if (!Array.isArray(merged.providers)) merged.providers = [];
+    if (!merged.ui) merged.ui = { ...base.ui };
+    merged.meta = {
+      ...merged.meta,
+      createdAt: merged.meta?.createdAt || new Date().toISOString(),
+      updatedAt: merged.meta?.updatedAt || new Date().toISOString()
+    };
+    return merged;
+  } catch {
+    // 配置损坏时备份，避免用户数据被直接覆盖丢失
+    try {
+      fs.copyFileSync(CONFIG_PATH, `${CONFIG_PATH}.broken-${Date.now()}`);
+    } catch {
+      /* ignore */
+    }
+    return base;
+  }
+}
+
+function writeJsonAtomic(target, data, mode = 0o600) {
+  ensureDir();
+  const tmp = `${target}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}\n`, { encoding: 'utf8', mode });
+  fs.renameSync(tmp, target);
+}
+
+function saveConfig(patch) {
+  const current = readConfig();
+  const next = deepMerge(current, patch || {});
+  const now = new Date().toISOString();
+  next.meta = {
+    createdAt: next.meta?.createdAt || now,
+    updatedAt: now
+  };
+  writeJsonAtomic(CONFIG_PATH, next);
+  return next;
+}
+
+function resetConfig() {
+  const fresh = JSON.parse(JSON.stringify(DEFAULT_CONFIG));
+  fresh.meta.createdAt = new Date().toISOString();
+  fresh.meta.updatedAt = fresh.meta.createdAt;
+  writeJsonAtomic(CONFIG_PATH, fresh);
+  return fresh;
+}
+
+function loadChats() {
+  try {
+    if (!fs.existsSync(CHATS_PATH)) return [];
+    const parsed = JSON.parse(fs.readFileSync(CHATS_PATH, 'utf8'));
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+function saveChats(chats) {
+  try {
+    // 与桌面版一致：最多保留 200 段对话，超出直接丢弃
+    writeJsonAtomic(CHATS_PATH, Array.isArray(chats) ? chats.slice(0, 200) : []);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function maskKey(key) {
+  if (!key) return '';
+  const str = String(key);
+  if (str.length <= 8) return '••••••••';
+  return `${str.slice(0, 3)}••••••${str.slice(-4)}`;
+}
+
+module.exports = {
+  DCB_DIR,
+  CONFIG_PATH,
+  CHATS_PATH,
+  MCP_PATH,
+  SKILLS_DIR,
+  OAUTH_PATH,
+  DEFAULT_CONFIG,
+  deepMerge,
+  hasDcbDir,
+  readConfig,
+  saveConfig,
+  resetConfig,
+  loadChats,
+  saveChats,
+  ensureDir,
+  maskKey
+};

package/src/services/input.js

@@ -0,0 +1,91 @@
+'use strict';
+
+/**
+ * 可复用的小工具：提示输入、确认、掩码输入、状态行。
+ */
+
+const readline = require('readline');
+const { COLORS } = require('../cli/ansi');
+
+function ask(prompt) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(prompt, (answer) => {
+      rl.close();
+      resolve(String(answer || ''));
+    });
+    rl.on('SIGINT', () => {
+      rl.close();
+      resolve(null);
+    });
+  });
+}
+
+/** 掩码输入（用于 API Key；非 TTY 时退化为普通读取） */
+function askSecret(prompt, options = {}) {
+  if (!process.stdin.isTTY) return ask(prompt);
+  return new Promise((resolve) => {
+    process.stdout.write(prompt);
+    const stdin = process.stdin;
+    let value = '';
+    readline.emitKeypressEvents(stdin);
+    stdin.setRawMode(true);
+    stdin.resume();
+    const onKey = (str, key = {}) => {
+      if (key.ctrl && key.name === 'c') {
+        stdin.setRawMode(false);
+        stdin.removeListener('keypress', onKey);
+        process.stdout.write('\n');
+        resolve(null);
+        return;
+      }
+      if (key.name === 'return' || key.name === 'enter') {
+        stdin.setRawMode(false);
+        stdin.removeListener('keypress', onKey);
+        process.stdout.write('\n');
+        resolve(value);
+        return;
+      }
+      if (key.name === 'backspace') {
+        if (value.length) {
+          value = value.slice(0, -1);
+          process.stdout.write('\b \b');
+        }
+        return;
+      }
+      if (key.ctrl && key.name === 'u') {
+        process.stdout.write('\b \b'.repeat(value.length));
+        value = '';
+        return;
+      }
+      if (str && !key.ctrl && !key.meta) {
+        value += str;
+        process.stdout.write(options.showLength ? String(str.length) : '*');
+      }
+    };
+    stdin.on('keypress', onKey);
+  });
+}
+
+async function confirm(prompt, defaultYes = false) {
+  if (!process.stdin.isTTY) return false;
+  const suffix = defaultYes ? ' [Y/n] ' : ' [y/N] ';
+  const answer = await ask(`${prompt}${suffix}`);
+  if (answer === null) return false;
+  const text = answer.trim().toLowerCase();
+  if (!text) return defaultYes;
+  return text === 'y' || text === 'yes';
+}
+
+/** 单行状态提示（覆盖当前行，避免刷新时刷屏） */
+function statusLine(text) {
+  if (!process.stdout.isTTY) return;
+  process.stdout.write(`\r\x1b[2K${COLORS.faint(text)}`);
+}
+
+function clearStatus() {
+  if (!process.stdout.isTTY) return;
+  process.stdout.write('\r\x1b[2K');
+}
+
+module.exports = { ask, askSecret, confirm, statusLine, clearStatus };