cli-claw-kit 0.0.1

package/dist/routes/browse.js

@@ -0,0 +1,210 @@
+import { Hono } from 'hono';
+import fs from 'node:fs';
+import path from 'node:path';
+import { hasHostExecutionPermission } from '../web-context.js';
+import { authMiddleware } from '../middleware/auth.js';
+import { logger } from '../logger.js';
+import { loadMountAllowlist, expandPath, findAllowedRoot, matchesBlockedPattern, } from '../mount-security.js';
+const MAX_ENTRIES = 200;
+const browseRoutes = new Hono();
+/**
+ * List subdirectories of a given path, filtering hidden dirs and blocked patterns.
+ */
+function listSubdirectories(dirPath, blockedPatterns) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const dirs = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        // Skip hidden directories
+        if (entry.name.startsWith('.'))
+            continue;
+        // Skip blocked patterns
+        const fullPath = path.join(dirPath, entry.name);
+        if (matchesBlockedPattern(fullPath, blockedPatterns) !== null)
+            continue;
+        // Check if has subdirectories (for expand indicator)
+        let hasChildren = false;
+        try {
+            const children = fs.readdirSync(fullPath, { withFileTypes: true });
+            hasChildren = children.some((c) => c.isDirectory() && !c.name.startsWith('.'));
+        }
+        catch {
+            // Permission denied or other error — treat as no children
+        }
+        dirs.push({ name: entry.name, path: fullPath, hasChildren });
+        if (dirs.length >= MAX_ENTRIES)
+            break;
+    }
+    dirs.sort((a, b) => a.name.localeCompare(b.name));
+    return dirs;
+}
+// GET /api/browse/directories?path=xxx
+browseRoutes.get('/directories', authMiddleware, (c) => {
+    const authUser = c.get('user');
+    if (!hasHostExecutionPermission(authUser)) {
+        return c.json({ error: 'Insufficient permissions' }, 403);
+    }
+    const requestedPath = c.req.query('path');
+    const allowlist = loadMountAllowlist();
+    const blockedPatterns = allowlist?.blockedPatterns ?? [];
+    const hasAllowlist = allowlist !== null && allowlist.allowedRoots.length > 0;
+    // No path → return root listing
+    if (!requestedPath) {
+        if (hasAllowlist) {
+            // Return allowlist roots as top-level entries
+            const roots = [];
+            for (const root of allowlist.allowedRoots) {
+                const expanded = expandPath(root.path);
+                let realPath;
+                try {
+                    realPath = fs.realpathSync(expanded);
+                }
+                catch {
+                    continue; // Root doesn't exist, skip
+                }
+                if (!fs.existsSync(realPath) || !fs.statSync(realPath).isDirectory())
+                    continue;
+                let hasChildren = false;
+                try {
+                    const children = fs.readdirSync(realPath, { withFileTypes: true });
+                    hasChildren = children.some((ch) => ch.isDirectory() && !ch.name.startsWith('.'));
+                }
+                catch {
+                    /* ignore */
+                }
+                roots.push({
+                    name: root.description || path.basename(realPath),
+                    path: realPath,
+                    hasChildren,
+                });
+            }
+            return c.json({
+                currentPath: null,
+                parentPath: null,
+                directories: roots,
+                hasAllowlist: true,
+            });
+        }
+        // No allowlist → return HOME directory
+        const homeDir = process.env.HOME || '/';
+        return c.json({
+            currentPath: homeDir,
+            parentPath: homeDir === '/' ? null : path.dirname(homeDir),
+            directories: listSubdirectories(homeDir, blockedPatterns),
+            hasAllowlist: false,
+        });
+    }
+    // Validate path
+    if (!path.isAbsolute(requestedPath)) {
+        return c.json({ error: 'Path must be absolute' }, 400);
+    }
+    let realPath;
+    try {
+        realPath = fs.realpathSync(requestedPath);
+    }
+    catch {
+        return c.json({ error: 'Path does not exist' }, 400);
+    }
+    if (!fs.statSync(realPath).isDirectory()) {
+        return c.json({ error: 'Path is not a directory' }, 400);
+    }
+    // Allowlist range check
+    if (hasAllowlist) {
+        const root = findAllowedRoot(realPath, allowlist.allowedRoots);
+        if (!root) {
+            return c.json({ error: 'Path is not within allowed roots' }, 403);
+        }
+    }
+    // Compute parentPath
+    let parentPath = path.dirname(realPath);
+    if (parentPath === realPath) {
+        // At filesystem root
+        parentPath = null;
+    }
+    else if (hasAllowlist) {
+        // Check if parent is still within an allowed root
+        const parentRoot = findAllowedRoot(parentPath, allowlist.allowedRoots);
+        if (!parentRoot) {
+            // Parent is outside allowed roots — return null to go back to root listing
+            parentPath = null;
+        }
+    }
+    return c.json({
+        currentPath: realPath,
+        parentPath,
+        directories: listSubdirectories(realPath, blockedPatterns),
+        hasAllowlist,
+    });
+});
+// POST /api/browse/directories — create a new folder
+browseRoutes.post('/directories', authMiddleware, async (c) => {
+    const authUser = c.get('user');
+    if (!hasHostExecutionPermission(authUser)) {
+        return c.json({ error: 'Insufficient permissions' }, 403);
+    }
+    const body = await c.req.json().catch(() => ({}));
+    const { parentPath, name } = body;
+    if (!parentPath || typeof parentPath !== 'string') {
+        return c.json({ error: 'parentPath is required' }, 400);
+    }
+    if (!name || typeof name !== 'string') {
+        return c.json({ error: 'name is required' }, 400);
+    }
+    // Validate name
+    if (name.includes('/') || name.includes('..') || name.startsWith('.')) {
+        return c.json({ error: 'Invalid folder name: must not contain /, .., or start with .' }, 400);
+    }
+    if (!path.isAbsolute(parentPath)) {
+        return c.json({ error: 'parentPath must be absolute' }, 400);
+    }
+    let realParent;
+    try {
+        realParent = fs.realpathSync(parentPath);
+    }
+    catch {
+        return c.json({ error: 'Parent path does not exist' }, 400);
+    }
+    if (!fs.statSync(realParent).isDirectory()) {
+        return c.json({ error: 'Parent path is not a directory' }, 400);
+    }
+    // Allowlist range check
+    const allowlist = loadMountAllowlist();
+    const hasAllowlist = allowlist !== null && allowlist.allowedRoots.length > 0;
+    if (hasAllowlist) {
+        const root = findAllowedRoot(realParent, allowlist.allowedRoots);
+        if (!root) {
+            return c.json({ error: 'Parent path is not within allowed roots' }, 403);
+        }
+    }
+    // Blocked patterns check
+    const blockedPatterns = allowlist?.blockedPatterns ?? [];
+    const targetPath = path.join(realParent, name);
+    if (matchesBlockedPattern(targetPath, blockedPatterns) !== null) {
+        return c.json({ error: 'Folder name matches a blocked pattern' }, 400);
+    }
+    // Check if already exists
+    if (fs.existsSync(targetPath)) {
+        return c.json({ error: 'Directory already exists' }, 400);
+    }
+    try {
+        fs.mkdirSync(targetPath, { recursive: false });
+        logger.info({ path: targetPath }, 'Directory created via browse API');
+    }
+    catch (err) {
+        logger.error({ err, path: targetPath }, 'Failed to create directory');
+        return c.json({ error: 'Failed to create directory' }, 500);
+    }
+    return c.json({
+        name,
+        path: targetPath,
+        hasChildren: false,
+    });
+});
+export default browseRoutes;

package/dist/routes/bug-report.js

@@ -0,0 +1,387 @@
+import { execFile } from 'child_process';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { promisify } from 'util';
+import { Hono } from 'hono';
+import { APP_ROOT, resolveAppPath } from '../app-root.js';
+import { DATA_DIR } from '../config.js';
+import { getUserHomeGroup } from '../db.js';
+import { getClaudeProviderConfig } from '../runtime-config.js';
+import { sdkQuery } from '../sdk-query.js';
+import { logger } from '../logger.js';
+import { authMiddleware } from '../middleware/auth.js';
+import { BugReportGenerateSchema, BugReportSubmitSchema } from '../schemas.js';
+import { getWebDeps } from '../web-context.js';
+const execFileAsync = promisify(execFile);
+const bugReportRoutes = new Hono();
+// --- Rate limiting (60s per user) ---
+const cooldowns = new Map();
+const COOLDOWN_MS = 60_000;
+const generateCooldowns = new Map();
+const GENERATE_COOLDOWN_MS = 30_000;
+function checkCooldown(userId, map = cooldowns, cooldownMs = COOLDOWN_MS) {
+    const last = map.get(userId);
+    if (last) {
+        const remaining = cooldownMs - (Date.now() - last);
+        if (remaining > 0) {
+            return `请等待 ${Math.ceil(remaining / 1000)} 秒后再试`;
+        }
+    }
+    return null;
+}
+// --- Capability detection (cached 5min) ---
+let capCache = null;
+const CAP_CACHE_TTL = 5 * 60 * 1000;
+async function checkCapabilities() {
+    if (capCache && Date.now() - capCache.checkedAt < CAP_CACHE_TTL) {
+        return {
+            ghAvailable: capCache.ghAvailable,
+            ghUsername: capCache.ghUsername,
+            claudeAvailable: capCache.claudeAvailable,
+        };
+    }
+    const [gh] = await Promise.all([
+        execFileAsync('gh', ['auth', 'status'], { timeout: 5000 })
+            .then(() => true)
+            .catch(() => false),
+    ]);
+    // Claude availability is determined by provider config, not CLI presence
+    const providerConfig = getClaudeProviderConfig();
+    const claude = !!(providerConfig.anthropicApiKey ||
+        providerConfig.claudeCodeOauthToken ||
+        providerConfig.claudeOAuthCredentials);
+    // Get gh username if available
+    let ghUsername = null;
+    if (gh) {
+        try {
+            const { stdout } = await execFileAsync('gh', ['api', 'user', '--jq', '.login'], { timeout: 5000 });
+            ghUsername = stdout.trim() || null;
+        }
+        catch {
+            // gh available but can't get username
+        }
+    }
+    capCache = {
+        ghAvailable: gh,
+        ghUsername,
+        claudeAvailable: claude,
+        checkedAt: Date.now(),
+    };
+    return { ghAvailable: gh, ghUsername, claudeAvailable: claude };
+}
+// --- Helpers ---
+function getVersion() {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(resolveAppPath('package.json'), 'utf-8'));
+        return pkg.version || 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+function readRecentLogs(folder, maxLines = 50) {
+    const logsDir = path.join(DATA_DIR, 'groups', folder, 'logs');
+    try {
+        if (!fs.existsSync(logsDir))
+            return '(no logs directory)';
+        const files = fs
+            .readdirSync(logsDir)
+            .filter((f) => f.endsWith('.log'))
+            .sort()
+            .reverse();
+        if (files.length === 0)
+            return '(no log files)';
+        const latestFile = path.join(logsDir, files[0]);
+        const content = fs.readFileSync(latestFile, 'utf-8');
+        const lines = content.split('\n');
+        return lines.slice(-maxLines).join('\n');
+    }
+    catch {
+        return '(failed to read logs)';
+    }
+}
+/** Mask environment variable values in log text */
+function sanitizeLogs(text) {
+    let result = text;
+    // Replace absolute paths to project root and home directory with placeholders
+    const projectRoot = APP_ROOT;
+    const homeDir = os.homedir();
+    // Replace longer path first to avoid partial replacement
+    if (projectRoot.startsWith(homeDir)) {
+        result = result.replaceAll(projectRoot, '<project>');
+        result = result.replaceAll(homeDir, '<home>');
+    }
+    else {
+        result = result.replaceAll(homeDir, '<home>');
+        result = result.replaceAll(projectRoot, '<project>');
+    }
+    // Generic pattern matching any env var name containing sensitive keywords
+    const sensitivePattern = /(\b\w*(?:token|password|passwd|secret|api[_-]?key|auth[_-]?token|authorization|cookie|credential|private[_-]?key|access[_-]?key|app[_-]?secret)\w*)[=:]\s*\S+/gi;
+    result = result.replace(sensitivePattern, '$1=***');
+    return result;
+}
+function buildGeneratePrompt(description, systemInfo, logs, screenshotCount) {
+    const sysInfoText = Object.entries(systemInfo)
+        .map(([k, v]) => `- ${k}: ${v}`)
+        .join('\n');
+    const screenshotNote = screenshotCount > 0
+        ? `\n\n## 附加截图\n用户附加了 ${screenshotCount} 张截图（截图内容无法在此展示）。请在 Issue 正文末尾添加提示：「报告者附加了 ${screenshotCount} 张截图，如需查看请联系报告者。」`
+        : '';
+    return `你是一个 Bug 报告助手，帮用户将 bug 描述整理为结构化的 GitHub Issue。
+
+## 用户描述
+${description}${screenshotNote}
+
+## 系统信息
+${sysInfoText}
+
+## 最近日志（最后 50 行）
+\`\`\`
+${logs}
+\`\`\`
+
+请生成一个结构化的 GitHub Issue。输出**纯 JSON**（不要 markdown 代码块），包含两个字段：
+- "title": 简洁的 issue 标题，格式为 "bug: 简要描述"（小写 bug: 前缀，不超过 80 字符）
+- "body": 结构化的 Markdown 正文，严格按照以下模板：
+
+  ## 用户现象
+  （从用户视角描述看到了什么、体验上有什么异常）
+
+  ## 问题描述
+  （从技术视角简要说明发生了什么）
+
+  ## 复现路径
+  1. 步骤一
+  2. 步骤二
+  3. 期望行为 vs 实际行为
+  （如果能从描述和日志推断出复现步骤就写，无法推断则省略此章节）
+
+  ## 根因（可选）
+  （如果能从日志分析出代码层面的原因就写，否则省略）
+
+  ## 影响
+  （对用户体验/数据/安全的影响）
+
+  ## 环境信息
+  （系统信息表格）
+
+  ## 相关日志
+  （如有错误日志，摘录关键部分）
+
+只输出 JSON，不要其他内容。`;
+}
+function buildFallbackReport(description, systemInfo, logs) {
+    const sysInfoTable = Object.entries(systemInfo)
+        .map(([k, v]) => `| ${k} | ${v} |`)
+        .join('\n');
+    const body = `## 用户现象
+
+${description}
+
+## 问题描述
+
+（待补充技术分析）
+
+## 影响
+
+（待补充）
+
+## 环境信息
+
+| 项目 | 值 |
+|------|-----|
+${sysInfoTable}
+
+## 相关日志
+
+\`\`\`
+${logs.slice(0, 3000)}
+\`\`\`
+`;
+    return {
+        title: `bug: ${description.slice(0, 70)}`,
+        body,
+    };
+}
+/** Try multiple strategies to extract JSON { title, body } from Claude output */
+function tryParseJsonOutput(raw) {
+    const candidates = [];
+    // Strategy 1: strip markdown fencing (greedy to handle nested backticks)
+    const fenceMatch = raw.match(/```(?:json)?\s*([\s\S]*?)```\s*$/);
+    if (fenceMatch)
+        candidates.push(fenceMatch[1].trim());
+    // Strategy 2: extract first { ... } block
+    const braceMatch = raw.match(/\{[\s\S]*\}/);
+    if (braceMatch)
+        candidates.push(braceMatch[0]);
+    // Strategy 3: raw string as-is
+    candidates.push(raw.trim());
+    for (const candidate of candidates) {
+        try {
+            const parsed = JSON.parse(candidate);
+            if (typeof parsed === 'object' && parsed !== null && parsed.body) {
+                return parsed;
+            }
+        }
+        catch {
+            // try next candidate
+        }
+    }
+    return null;
+}
+// ========== Routes ==========
+/**
+ * GET /api/bug-report/capabilities
+ * Check what tools are available for bug reporting
+ */
+bugReportRoutes.get('/capabilities', authMiddleware, async (c) => {
+    const caps = await checkCapabilities();
+    return c.json(caps);
+});
+/**
+ * POST /api/bug-report/generate
+ * Analyze the bug with Claude and generate a structured report
+ */
+bugReportRoutes.post('/generate', authMiddleware, async (c) => {
+    const user = c.get('user');
+    // Rate limiting — 30s cooldown per user for generate
+    const generateCooldownMsg = checkCooldown(user.id, generateCooldowns, GENERATE_COOLDOWN_MS);
+    if (generateCooldownMsg) {
+        return c.json({ error: generateCooldownMsg }, 429);
+    }
+    const parseResult = BugReportGenerateSchema.safeParse(await c.req.json());
+    if (!parseResult.success) {
+        return c.json({ error: 'Invalid request', details: parseResult.error.issues }, 400);
+    }
+    const { description, screenshots } = parseResult.data;
+    // Set cooldown immediately to prevent concurrent requests
+    generateCooldowns.set(user.id, Date.now());
+    // Collect system info
+    const homeGroup = getUserHomeGroup(user.id);
+    const folder = homeGroup?.folder || 'main';
+    const deps = getWebDeps();
+    const queueStatus = deps?.queue.getStatus();
+    const systemInfo = {
+        'cli-claw版本': getVersion(),
+        'Node.js': process.version,
+        操作系统: `${os.platform()} ${os.release()}`,
+        架构: os.arch(),
+        活跃容器数: String(queueStatus?.activeContainerCount ?? 'N/A'),
+        活跃宿主机进程: String(queueStatus?.activeHostProcessCount ?? 'N/A'),
+        等待队列: String(queueStatus?.waitingCount ?? 'N/A'),
+        截图数量: String(screenshots?.length || 0),
+    };
+    // Read recent logs
+    const rawLogs = readRecentLogs(folder);
+    const logs = sanitizeLogs(rawLogs);
+    // Try Claude analysis
+    const caps = await checkCapabilities();
+    if (!caps.claudeAvailable) {
+        logger.info('bug-report: claude CLI not available, using fallback template');
+        const fallback = buildFallbackReport(description, systemInfo, logs);
+        return c.json({ ...fallback, systemInfo });
+    }
+    const prompt = buildGeneratePrompt(description, systemInfo, logs, screenshots?.length || 0);
+    try {
+        logger.info({ promptLen: prompt.length, userId: user.id }, 'bug-report: invoking Claude SDK');
+        const model = process.env.RECALL_MODEL || undefined;
+        const result = await sdkQuery(prompt, { model, timeout: 60_000 });
+        if (!result) {
+            const fallback = buildFallbackReport(description, systemInfo, logs);
+            return c.json({ ...fallback, systemInfo });
+        }
+        // Try to parse Claude's JSON output
+        const parsed = tryParseJsonOutput(result);
+        if (parsed?.body) {
+            return c.json({
+                title: parsed.title || `Bug: ${description.slice(0, 70)}`,
+                body: parsed.body,
+                systemInfo,
+            });
+        }
+        // Claude didn't return valid JSON, use raw output as body
+        logger.info('bug-report: claude output was not valid JSON, using as raw body');
+        return c.json({
+            title: `Bug: ${description.slice(0, 70)}`,
+            body: result,
+            systemInfo,
+        });
+    }
+    catch (err) {
+        logger.error({ error: err.message }, 'bug-report: unexpected error during generation');
+        const fallback = buildFallbackReport(description, systemInfo, logs);
+        return c.json({ ...fallback, systemInfo });
+    }
+});
+/**
+ * POST /api/bug-report/submit
+ * Create a GitHub issue or return a pre-filled URL
+ */
+bugReportRoutes.post('/submit', authMiddleware, async (c) => {
+    const user = c.get('user');
+    // Rate limiting — only on actual issue submission
+    const cooldownMsg = checkCooldown(user.id);
+    if (cooldownMsg) {
+        return c.json({ error: cooldownMsg }, 429);
+    }
+    const parseResult = BugReportSubmitSchema.safeParse(await c.req.json());
+    if (!parseResult.success) {
+        return c.json({ error: 'Invalid request', details: parseResult.error.issues }, 400);
+    }
+    const { title, body } = parseResult.data;
+    // Append submitter info
+    const fullBody = `${body}\n\n---\n> Submitted via cli-claw by ${user.display_name || user.username}`;
+    // Try gh CLI first
+    const caps = await checkCapabilities();
+    if (caps.ghAvailable) {
+        try {
+            logger.info({ userId: user.id }, 'bug-report: attempting gh issue create');
+            const result = await new Promise((resolve, reject) => {
+                const child = execFile('gh', [
+                    'issue',
+                    'create',
+                    '--repo',
+                    'RyanProMax/cli-claw',
+                    '--title',
+                    title,
+                    '--body-file',
+                    '-',
+                ], { timeout: 30000, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
+                    if (err) {
+                        logger.warn({
+                            message: err.message?.slice(0, 200),
+                            stderr: stderr?.slice(0, 300),
+                        }, 'bug-report: gh issue create failed');
+                        reject(err);
+                        return;
+                    }
+                    resolve(stdout.trim());
+                });
+                child.stdin?.write(fullBody);
+                child.stdin?.end();
+            });
+            // gh outputs the issue URL on success
+            const urlMatch = result.match(/https:\/\/github\.com\/[^\s]+\/issues\/\d+/);
+            const url = urlMatch ? urlMatch[0] : result;
+            logger.info({ url, userId: user.id }, 'bug-report: issue created via gh');
+            cooldowns.set(user.id, Date.now());
+            return c.json({ method: 'created', url });
+        }
+        catch {
+            // Fall through to manual URL
+            logger.info('bug-report: gh failed, falling back to manual URL');
+        }
+    }
+    // Fallback: pre-filled GitHub URL
+    const maxBodyLen = 6000; // conservative limit for URL length
+    const truncatedBody = fullBody.length > maxBodyLen
+        ? fullBody.slice(0, maxBodyLen) +
+            '\n\n...(内容过长已截断，请补充完整信息)'
+        : fullBody;
+    const url = `https://github.com/RyanProMax/cli-claw/issues/new?title=${encodeURIComponent(title)}&body=${encodeURIComponent(truncatedBody)}`;
+    logger.info({ userId: user.id }, 'bug-report: returning pre-filled URL');
+    cooldowns.set(user.id, Date.now());
+    return c.json({ method: 'manual', url });
+});
+export default bugReportRoutes;