cli-claw-kit 0.0.1

package/dist/script-runner.js

@@ -0,0 +1,64 @@
+import { exec } from 'child_process';
+import path from 'path';
+import { GROUPS_DIR } from './config.js';
+import { logger } from './logger.js';
+import { getSystemSettings } from './runtime-config.js';
+let activeScriptCount = 0;
+export function getActiveScriptCount() {
+    return activeScriptCount;
+}
+export function hasScriptCapacity() {
+    const { maxConcurrentScripts } = getSystemSettings();
+    return activeScriptCount < maxConcurrentScripts;
+}
+const MAX_BUFFER = 1024 * 1024; // 1MB
+export async function runScript(command, groupFolder, cwdOverride) {
+    const { scriptTimeout } = getSystemSettings();
+    const cwd = cwdOverride || path.join(GROUPS_DIR, groupFolder);
+    const startTime = Date.now();
+    activeScriptCount++;
+    try {
+        return await new Promise((resolve) => {
+            const child = exec(command, {
+                cwd,
+                timeout: scriptTimeout,
+                maxBuffer: MAX_BUFFER,
+                env: {
+                    PATH: process.env.PATH,
+                    LANG: process.env.LANG || 'en_US.UTF-8',
+                    TZ: process.env.TZ ||
+                        Intl.DateTimeFormat().resolvedOptions().timeZone,
+                    GROUP_FOLDER: groupFolder,
+                    HOME: cwd,
+                },
+                shell: '/bin/sh',
+            }, (error, stdout, stderr) => {
+                activeScriptCount--;
+                const durationMs = Date.now() - startTime;
+                const timedOut = error?.killed === true;
+                if (timedOut) {
+                    logger.warn({ command: command.slice(0, 100), groupFolder, durationMs }, 'Script timed out');
+                }
+                resolve({
+                    stdout: stdout.slice(0, MAX_BUFFER),
+                    stderr: stderr.slice(0, MAX_BUFFER),
+                    exitCode: timedOut ? null : (child.exitCode ?? (error ? 1 : 0)),
+                    timedOut,
+                    durationMs,
+                });
+            });
+        });
+    }
+    catch (err) {
+        activeScriptCount--;
+        const durationMs = Date.now() - startTime;
+        logger.error({ command: command.slice(0, 100), groupFolder, err }, 'Script exec() threw synchronously');
+        return {
+            stdout: '',
+            stderr: err instanceof Error ? err.message : String(err),
+            exitCode: 1,
+            timedOut: false,
+            durationMs,
+        };
+    }
+}

package/dist/sdk-query.js

@@ -0,0 +1,82 @@
+/**
+ * Lightweight Claude Agent SDK wrapper for simple text-in → text-out queries.
+ * Replaces all `claude --print` CLI calls so authentication uses the
+ * provider configured in the settings page (ANTHROPIC_API_KEY / OAuth / Base URL).
+ */
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { buildClaudeEnvLines, getClaudeProviderConfig, } from './runtime-config.js';
+import { logger } from './logger.js';
+// Mutex: process.env mutation is not re-entrant. Serialize concurrent calls
+// to prevent overlapping env writes from corrupting each other.
+let envLock = Promise.resolve();
+/**
+ * Send a prompt to Claude and return the plain-text response.
+ * Uses the provider configured in the web settings (not a separate CLI install).
+ *
+ * @param prompt  The user prompt text
+ * @param opts.model   Override model (defaults to provider config)
+ * @param opts.timeout Timeout in ms (default 60 000)
+ * @returns The assistant's text response, or null on failure
+ */
+export async function sdkQuery(prompt, opts) {
+    // Chain on the lock so only one sdkQuery touches process.env at a time
+    let release;
+    const acquired = new Promise((r) => (release = r));
+    const prevLock = envLock;
+    envLock = acquired;
+    await prevLock;
+    const timeout = opts?.timeout ?? 60_000;
+    // Inject provider credentials into process.env for the SDK
+    const config = getClaudeProviderConfig();
+    const envLines = buildClaudeEnvLines(config);
+    const savedEnv = {};
+    for (const line of envLines) {
+        const eq = line.indexOf('=');
+        if (eq <= 0)
+            continue;
+        const key = line.slice(0, eq);
+        const value = line.slice(eq + 1);
+        savedEnv[key] = process.env[key];
+        process.env[key] = value;
+    }
+    const abortController = new AbortController();
+    const timer = setTimeout(() => abortController.abort(), timeout);
+    try {
+        const model = opts?.model || config.anthropicModel || undefined;
+        let result = '';
+        const conversation = query({
+            prompt,
+            options: {
+                ...(model && { model }),
+                maxTurns: 1,
+                allowedTools: [],
+                permissionMode: 'bypassPermissions',
+                allowDangerouslySkipPermissions: true,
+                abortController,
+            },
+        });
+        for await (const event of conversation) {
+            if (event.type === 'result' && event.subtype === 'success') {
+                result = event.result;
+            }
+        }
+        return result.trim() || null;
+    }
+    catch (err) {
+        logger.warn({ err: err.message?.slice(0, 200) }, 'sdkQuery failed');
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+        // Restore original env
+        for (const [key, original] of Object.entries(savedEnv)) {
+            if (original === undefined) {
+                delete process.env[key];
+            }
+            else {
+                process.env[key] = original;
+            }
+        }
+        release();
+    }
+}

package/dist/skill-utils.js

@@ -0,0 +1,145 @@
+/**
+ * Shared skill utility functions.
+ * Used by both src/routes/skills.ts (user-level) and src/routes/workspace-config.ts (workspace-level).
+ */
+import fs from 'fs';
+import path from 'path';
+// --- Functions ---
+export function validateSkillId(id) {
+    return /^[\w\-]+$/.test(id);
+}
+export function validateSkillPath(skillsRoot, skillDir) {
+    try {
+        const realSkillsRoot = fs.realpathSync(skillsRoot);
+        const realSkillDir = fs.realpathSync(skillDir);
+        const relative = path.relative(realSkillsRoot, realSkillDir);
+        return !relative.startsWith('..') && !path.isAbsolute(relative);
+    }
+    catch {
+        return false;
+    }
+}
+export function parseFrontmatter(content) {
+    const lines = content.split('\n');
+    if (lines[0]?.trim() !== '---')
+        return {};
+    const endIndex = lines.slice(1).findIndex((line) => line.trim() === '---');
+    if (endIndex === -1)
+        return {};
+    const frontmatterLines = lines.slice(1, endIndex + 1);
+    const result = {};
+    let currentKey = null;
+    let currentValue = [];
+    let multilineMode = null;
+    for (const line of frontmatterLines) {
+        const keyMatch = line.match(/^([\w\-]+):\s*(.*)$/);
+        if (keyMatch) {
+            // Save previous key if exists
+            if (currentKey) {
+                result[currentKey] = currentValue.join(multilineMode === 'literal' ? '\n' : ' ');
+            }
+            currentKey = keyMatch[1];
+            const value = keyMatch[2].trim();
+            if (value === '>') {
+                multilineMode = 'folded';
+                currentValue = [];
+            }
+            else if (value === '|') {
+                multilineMode = 'literal';
+                currentValue = [];
+            }
+            else {
+                result[currentKey] = value;
+                currentKey = null;
+                currentValue = [];
+                multilineMode = null;
+            }
+        }
+        else if (currentKey && multilineMode) {
+            const trimmedLine = line.trimStart();
+            if (trimmedLine) {
+                currentValue.push(trimmedLine);
+            }
+        }
+    }
+    // Save last key
+    if (currentKey) {
+        result[currentKey] = currentValue.join(multilineMode === 'literal' ? '\n' : ' ');
+    }
+    return result;
+}
+export function listFiles(dir) {
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        return entries
+            .filter((entry) => !entry.name.startsWith('.'))
+            .map((entry) => {
+            const fullPath = path.join(dir, entry.name);
+            const stats = fs.statSync(fullPath);
+            return {
+                name: entry.name,
+                type: entry.isDirectory() ? 'directory' : 'file',
+                size: entry.isDirectory() ? 0 : stats.size,
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+export function scanSkillDirectory(rootDir, source) {
+    const skills = [];
+    if (!fs.existsSync(rootDir))
+        return skills;
+    try {
+        const entries = fs.readdirSync(rootDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const skillDir = path.join(rootDir, entry.name);
+            const skillMdPath = path.join(skillDir, 'SKILL.md');
+            const skillMdDisabledPath = path.join(skillDir, 'SKILL.md.disabled');
+            let enabled = false;
+            let skillFilePath = null;
+            if (fs.existsSync(skillMdPath)) {
+                enabled = true;
+                skillFilePath = skillMdPath;
+            }
+            else if (fs.existsSync(skillMdDisabledPath)) {
+                enabled = false;
+                skillFilePath = skillMdDisabledPath;
+            }
+            else {
+                continue;
+            }
+            try {
+                const content = fs.readFileSync(skillFilePath, 'utf-8');
+                const frontmatter = parseFrontmatter(content);
+                const stats = fs.statSync(skillDir);
+                skills.push({
+                    id: entry.name,
+                    name: frontmatter.name || entry.name,
+                    description: frontmatter.description || '',
+                    source,
+                    enabled,
+                    userInvocable: frontmatter['user-invocable'] === undefined
+                        ? true
+                        : frontmatter['user-invocable'] !== 'false',
+                    allowedTools: frontmatter['allowed-tools']
+                        ? frontmatter['allowed-tools'].split(',').map((t) => t.trim())
+                        : [],
+                    argumentHint: frontmatter['argument-hint'] || null,
+                    updatedAt: stats.mtime.toISOString(),
+                    files: listFiles(skillDir),
+                });
+            }
+            catch {
+                // Skip malformed skills
+            }
+        }
+    }
+    catch {
+        // Skip if directory is not readable
+    }
+    return skills;
+}

package/dist/sqlite-compat.js

@@ -0,0 +1,19 @@
+/**
+ * SQLite 兼容层：Bun 用 bun:sqlite，Node.js 用 better-sqlite3
+ *
+ * 两者 API 几乎一致（prepare/run/get/all/exec/transaction），
+ * 唯一差异是 import 路径和 pragma() 方法（Bun 无此方法，用 exec 替代）。
+ */
+const isBun = typeof globalThis.Bun !== 'undefined';
+let DatabaseConstructor;
+if (isBun) {
+    // 动态字符串阻止 tsc 尝试解析 bun:sqlite 模块
+    const modName = 'bun:sqlite';
+    const mod = await import(modName);
+    DatabaseConstructor = mod.Database;
+}
+else {
+    const mod = await import('better-sqlite3');
+    DatabaseConstructor = mod.default;
+}
+export default DatabaseConstructor;

package/dist/stream-event.types.js

@@ -0,0 +1,5 @@
+/**
+ * Thin type re-export wrapper around the canonical shared StreamEvent build output.
+ * Source of truth: shared/stream-event.ts
+ */
+export {};

package/dist/streaming-runtime-meta.js

@@ -0,0 +1,29 @@
+export function normalizeStreamingStatusText(statusText) {
+    if (typeof statusText !== 'string')
+        return null;
+    const trimmed = statusText.trim();
+    if (!trimmed)
+        return null;
+    if (trimmed === 'usage_updated')
+        return null;
+    return trimmed;
+}
+export function buildProvisionalTokenUsage(startedAtMs) {
+    const durationMs = Math.max(0, Date.now() - startedAtMs);
+    return {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadInputTokens: 0,
+        cacheCreationInputTokens: 0,
+        costUSD: 0,
+        durationMs,
+        numTurns: 1,
+    };
+}
+export function serializeAssistantTokenUsage(tokenUsage) {
+    if (!tokenUsage)
+        return undefined;
+    return typeof tokenUsage === 'string'
+        ? tokenUsage
+        : JSON.stringify(tokenUsage);
+}