zhitalk 0.0.0 → 0.0.3

package/dist/agent/db.js

@@ -0,0 +1,159 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DB_PATH = void 0;
+exports.searchMemories = searchMemories;
+exports.threadIdExists = threadIdExists;
+exports.initDb = initDb;
+exports.listRecentSessions = listRecentSessions;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+const config_1 = require("./config");
+const utils_1 = require("./utils");
+exports.DB_PATH = (0, path_1.join)(config_1.WORKSPACE_DIR, '.data', 'checkpointer.db');
+(0, fs_1.mkdirSync)((0, path_1.dirname)(exports.DB_PATH), { recursive: true });
+function searchMemories(query, limit = 10) {
+    const trimmedQueries = query.map((q) => q.trim()).filter((q) => q.length > 0);
+    if (trimmedQueries.length === 0) {
+        return [];
+    }
+    const queryStr = trimmedQueries.join(' OR ').replace(/-/g, ' ');
+    const db = new better_sqlite3_1.default(exports.DB_PATH);
+    try {
+        const rows = db.prepare(`
+      WITH ranked AS (
+        SELECT
+          m.*,
+          -bm25(memory_fts, 10.0, 5.0) AS relevance_score,
+          (m.importance * 0.3) AS importance_score,
+          (
+            1.0 / (
+              1.0 +
+              ((strftime('%s','now') - strftime('%s', m.updated_at)) / 86400.0)
+            )
+          ) AS time_score
+        FROM memory_fts
+        JOIN memory m ON m.id = memory_fts.rowid
+        WHERE memory_fts MATCH ?
+      )
+      SELECT *,
+        (
+          relevance_score * 0.6 +
+          importance_score * 0.3 +
+          time_score * 0.1
+        ) AS final_score
+      FROM ranked
+      ORDER BY final_score DESC
+      LIMIT ?
+    `).all(queryStr, limit);
+        return rows.map((r) => ({
+            id: r.id,
+            type: r.type,
+            content: r.content,
+            keywords: r.keywords,
+            importance: r.importance,
+            session_id: r.session_id,
+            created_at: r.created_at,
+            updated_at: r.updated_at,
+            final_score: r.final_score,
+        }));
+    }
+    finally {
+        db.close();
+    }
+}
+function threadIdExists(threadId) {
+    const db = new better_sqlite3_1.default(exports.DB_PATH);
+    try {
+        const row = db.prepare(`
+      SELECT 1 FROM checkpoints WHERE thread_id = ? LIMIT 1
+    `).get(threadId);
+        return !!row;
+    }
+    finally {
+        db.close();
+    }
+}
+function initDb() {
+    const db = new better_sqlite3_1.default(exports.DB_PATH);
+    try {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS memory (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        type TEXT NOT NULL,
+        content TEXT NOT NULL,
+        keywords TEXT,
+        importance INTEGER DEFAULT 3,
+        session_id TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS memory_fts USING fts5(
+        content,
+        keywords,
+        content='memory', content_rowid='id'
+      )
+    `);
+        db.exec(`
+      CREATE TRIGGER IF NOT EXISTS memory_fts_insert AFTER INSERT ON memory BEGIN
+        INSERT INTO memory_fts(rowid, content, keywords)
+        VALUES (new.id, new.content, new.keywords);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS memory_fts_delete AFTER DELETE ON memory BEGIN
+        INSERT INTO memory_fts(memory_fts, rowid, content, keywords)
+        VALUES ('delete', old.id, old.content, old.keywords);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS memory_fts_update AFTER UPDATE ON memory BEGIN
+        INSERT INTO memory_fts(memory_fts, rowid, content, keywords)
+        VALUES ('delete', old.id, old.content, old.keywords);
+        INSERT INTO memory_fts(rowid, content, keywords)
+        VALUES (new.id, new.content, new.keywords);
+      END;
+    `);
+    }
+    finally {
+        db.close();
+    }
+}
+function listRecentSessions() {
+    const db = new better_sqlite3_1.default(exports.DB_PATH);
+    try {
+        const rows = db.prepare(`
+      WITH thread_last_ts AS (
+        SELECT
+          thread_id,
+          MAX(json_extract(CAST(checkpoint AS TEXT), '$.ts')) AS last_ts
+        FROM checkpoints
+        GROUP BY thread_id
+      )
+      SELECT
+        t.thread_id,
+        (SELECT json_extract(CAST(w.value AS TEXT), '$[0].kwargs.content')
+         FROM writes w
+         WHERE w.thread_id = t.thread_id
+           AND w.channel = 'messages'
+           AND json_extract(CAST(w.value AS TEXT), '$[0].id[2]') = 'HumanMessage'
+         ORDER BY w.checkpoint_id DESC
+         LIMIT 1) AS last_question,
+        t.last_ts
+      FROM thread_last_ts t
+      ORDER BY t.last_ts DESC
+      LIMIT 20
+    `).all();
+        return rows.map((r) => ({
+            thread_id: r.thread_id,
+            last_question: (0, utils_1.truncate)(r.last_question, 50),
+            last_ts: (0, utils_1.formatRelativeTime)(r.last_ts),
+        }));
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/agent/hooks.d.ts

@@ -0,0 +1,27 @@
+import { HookConfig, HooksConfig } from './config';
+export type { HookConfig, HooksConfig };
+export type HookResult = {
+    action: 'continue';
+} | {
+    action: 'block';
+    reason: string;
+} | {
+    action: 'inject';
+    message: string;
+};
+export declare function loadHooksConfig(): HooksConfig;
+export declare function clearHooksCache(): void;
+export declare function matchHooks(hooks: HookConfig[] | undefined, toolName: string): HookConfig[];
+export declare function runHook(hook: HookConfig, env: Record<string, string>, timeout?: number): Promise<HookResult>;
+export interface ToolHookContext {
+    toolName: string;
+    toolArgs: any;
+    toolCallId: string;
+    threadId: string;
+}
+export declare function runPreToolUseHooks(context: ToolHookContext): Promise<HookResult>;
+export interface PostToolHookContext extends ToolHookContext {
+    toolOutput: string;
+}
+export declare function runPostToolUseHooks(context: PostToolHookContext): Promise<HookResult>;
+export declare function runSessionStartHooks(threadId: string): Promise<void>;

package/dist/agent/hooks.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadHooksConfig = loadHooksConfig;
+exports.clearHooksCache = clearHooksCache;
+exports.matchHooks = matchHooks;
+exports.runHook = runHook;
+exports.runPreToolUseHooks = runPreToolUseHooks;
+exports.runPostToolUseHooks = runPostToolUseHooks;
+exports.runSessionStartHooks = runSessionStartHooks;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const config_1 = require("./config");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+function loadHooksConfig() {
+    return (0, config_1.getHooksConfig)();
+}
+function clearHooksCache() {
+    (0, config_1.clearConfigCache)();
+}
+function matchHooks(hooks, toolName) {
+    if (!hooks)
+        return [];
+    return hooks.filter((h) => h.matcher === '*' || toolName.includes(h.matcher));
+}
+async function runHook(hook, env, timeout = 30000) {
+    const hookType = env.ZHITALK_HOOK_TYPE || 'hook';
+    console.log(`[Hook ${hookType}] ${hook.command}`);
+    try {
+        await execAsync(hook.command, {
+            cwd: process.cwd(),
+            env: { ...process.env, ...env },
+            timeout,
+        });
+        return { action: 'continue' };
+    }
+    catch (error) {
+        const code = error.code;
+        const stderr = error.stderr || '';
+        if (code === 1) {
+            return { action: 'block', reason: stderr };
+        }
+        else if (code === 2) {
+            return { action: 'inject', message: stderr };
+        }
+        return {
+            action: 'block',
+            reason: stderr || `Hook exited with code ${code}`,
+        };
+    }
+}
+async function runPreToolUseHooks(context) {
+    const config = loadHooksConfig();
+    const hooks = matchHooks(config.hooks.PreToolUse, context.toolName);
+    const injectMessages = [];
+    for (const hook of hooks) {
+        const result = await runHook(hook, {
+            ZHITALK_HOOK_TYPE: 'PreToolUse',
+            ZHITALK_TOOL_NAME: context.toolName,
+            ZHITALK_TOOL_ARGS: JSON.stringify(context.toolArgs),
+            ZHITALK_TOOL_CALL_ID: context.toolCallId,
+            ZHITALK_THREAD_ID: context.threadId,
+        });
+        if (result.action === 'block') {
+            return result;
+        }
+        if (result.action === 'inject') {
+            injectMessages.push(result.message);
+        }
+    }
+    if (injectMessages.length > 0) {
+        return { action: 'inject', message: injectMessages.join('\n') };
+    }
+    return { action: 'continue' };
+}
+async function runPostToolUseHooks(context) {
+    const config = loadHooksConfig();
+    const hooks = matchHooks(config.hooks.PostToolUse, context.toolName);
+    const injectMessages = [];
+    for (const hook of hooks) {
+        const result = await runHook(hook, {
+            ZHITALK_HOOK_TYPE: 'PostToolUse',
+            ZHITALK_TOOL_NAME: context.toolName,
+            ZHITALK_TOOL_ARGS: JSON.stringify(context.toolArgs),
+            ZHITALK_TOOL_OUTPUT: context.toolOutput,
+            ZHITALK_TOOL_CALL_ID: context.toolCallId,
+            ZHITALK_THREAD_ID: context.threadId,
+        });
+        if (result.action === 'block') {
+            return result;
+        }
+        if (result.action === 'inject') {
+            injectMessages.push(result.message);
+        }
+    }
+    if (injectMessages.length > 0) {
+        return { action: 'inject', message: injectMessages.join('\n') };
+    }
+    return { action: 'continue' };
+}
+async function runSessionStartHooks(threadId) {
+    const config = loadHooksConfig();
+    const hooks = config.hooks.SessionStart || [];
+    for (const hook of hooks) {
+        const result = await runHook(hook, {
+            ZHITALK_HOOK_TYPE: 'SessionStart',
+            ZHITALK_THREAD_ID: threadId,
+        });
+        if (result.action === 'block') {
+            console.error(`[SessionStart hook blocked] ${result.reason}`);
+        }
+        else if (result.action === 'inject') {
+            console.log(result.message);
+        }
+    }
+}

package/dist/agent/mcp/client.d.ts

@@ -0,0 +1,25 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+export interface McpServerConfig {
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    url?: string;
+    headers?: Record<string, string>;
+}
+export interface McpToolInfo {
+    name: string;
+    description?: string;
+    inputSchema: object;
+}
+export interface McpServerConnection {
+    name: string;
+    client: Client;
+    transport: Transport;
+    tools: McpToolInfo[];
+}
+export declare function loadMcpConfig(): Record<string, McpServerConfig>;
+export declare function connectMcpServer(name: string, config: McpServerConfig): Promise<McpServerConnection>;
+export declare function initializeMcpClients(): Promise<McpServerConnection[]>;
+export declare function callMcpTool(client: Client, name: string, args: Record<string, unknown>): Promise<string>;
+export declare function disconnectAllMcpClients(connections: McpServerConnection[]): Promise<void>;

package/dist/agent/mcp/client.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadMcpConfig = loadMcpConfig;
+exports.connectMcpServer = connectMcpServer;
+exports.initializeMcpClients = initializeMcpClients;
+exports.callMcpTool = callMcpTool;
+exports.disconnectAllMcpClients = disconnectAllMcpClients;
+const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/client/stdio.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+const colors_1 = require("../colors");
+const config_1 = require("../config");
+const CONNECT_TIMEOUT_MS = 60000;
+function loadMcpConfig() {
+    return (0, config_1.getMCPServerConfig)();
+}
+async function withTimeout(promise, ms, label) {
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms)),
+    ]);
+}
+function createMcpTransport(config) {
+    if (config.url) {
+        const url = new URL(config.url);
+        const requestInit = config.headers
+            ? { headers: config.headers }
+            : undefined;
+        return new streamableHttp_js_1.StreamableHTTPClientTransport(url, { requestInit });
+    }
+    if (config.command) {
+        return new stdio_js_1.StdioClientTransport({
+            command: config.command,
+            args: config.args,
+            env: config.env,
+        });
+    }
+    throw new Error('Invalid MCP server config: must have either "command" or "url"');
+}
+async function connectMcpServer(name, config) {
+    const transport = createMcpTransport(config);
+    const client = new index_js_1.Client({ name: 'zhitalk', version: '0.0.1' }, { capabilities: {} });
+    await withTimeout(client.connect(transport), CONNECT_TIMEOUT_MS, `MCP server "${name}" connect`);
+    const toolsResult = await withTimeout(client.listTools(), CONNECT_TIMEOUT_MS, `MCP server "${name}" listTools`);
+    const tools = (toolsResult.tools || []).map((t) => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: t.inputSchema,
+    }));
+    return { name, client, transport, tools };
+}
+async function initializeMcpClients() {
+    const config = loadMcpConfig();
+    const entries = Object.entries(config);
+    if (entries.length === 0) {
+        return [];
+    }
+    console.log(colors_1.color.info(`[MCP] Connecting to ${entries.length} server(s)...`));
+    const results = await Promise.allSettled(entries.map(([name, cfg]) => connectMcpServer(name, cfg).catch((err) => {
+        const msg = err.message || '';
+        const hint = msg.includes('timed out')
+            ? ' (Hint: if using npx, the first run may need to download the package. Consider pre-installing with `npm install -g <package>` or increasing timeout.)'
+            : '';
+        console.error(colors_1.color.error(`[MCP] Failed to connect "${name}": ${msg}${hint}`));
+        throw err;
+    })));
+    const connections = [];
+    for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        if (result.status === 'fulfilled') {
+            const conn = result.value;
+            console.log(colors_1.color.good(`[MCP] Connected "${conn.name}" with ${conn.tools.length} tool(s)`));
+            connections.push(conn);
+        }
+        else {
+            console.error(colors_1.color.error(`[MCP] Skipped "${entries[i][0]}" due to connection error`));
+        }
+    }
+    return connections;
+}
+async function callMcpTool(client, name, args) {
+    const result = await client.callTool({ name, arguments: args });
+    if (result.isError) {
+        const text = extractTextFromResult(result);
+        throw new Error(text || `MCP tool "${name}" returned an error`);
+    }
+    return extractTextFromResult(result);
+}
+function extractTextFromResult(result) {
+    if (!result.content || !Array.isArray(result.content)) {
+        return JSON.stringify(result);
+    }
+    const texts = [];
+    for (const item of result.content) {
+        if (item.type === 'text' && typeof item.text === 'string') {
+            texts.push(item.text);
+        }
+    }
+    if (texts.length === 0) {
+        return JSON.stringify(result);
+    }
+    return texts.join('\n');
+}
+async function disconnectAllMcpClients(connections) {
+    await Promise.allSettled(connections.map(async (conn) => {
+        try {
+            await conn.transport.close();
+        }
+        catch {
+            // ignore
+        }
+    }));
+}

package/dist/agent/mcp/index.d.ts

@@ -0,0 +1,4 @@
+import type { ZhitalkTool } from '../tools';
+export declare function initMcpTools(): Promise<ZhitalkTool[]>;
+export declare function getMcpTools(): ZhitalkTool[];
+export declare function shutdownMcp(): Promise<void>;

package/dist/agent/mcp/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initMcpTools = initMcpTools;
+exports.getMcpTools = getMcpTools;
+exports.shutdownMcp = shutdownMcp;
+const client_1 = require("./client");
+const wrapper_1 = require("./wrapper");
+let mcpConnections = [];
+let mcpTools = [];
+async function initMcpTools() {
+    mcpConnections = await (0, client_1.initializeMcpClients)();
+    mcpTools = [];
+    for (const conn of mcpConnections) {
+        for (const mcpTool of conn.tools) {
+            mcpTools.push((0, wrapper_1.wrapMcpTool)(conn, mcpTool));
+        }
+    }
+    return mcpTools;
+}
+function getMcpTools() {
+    return mcpTools;
+}
+async function shutdownMcp() {
+    await (0, client_1.disconnectAllMcpClients)(mcpConnections);
+    mcpConnections = [];
+    mcpTools = [];
+}

package/dist/agent/mcp/wrapper.d.ts

@@ -0,0 +1,7 @@
+import { type McpServerConnection } from './client';
+import type { ZhitalkTool } from '../tools';
+export declare function wrapMcpTool(connection: McpServerConnection, mcpTool: {
+    name: string;
+    description?: string;
+    inputSchema: object;
+}): ZhitalkTool;

package/dist/agent/mcp/wrapper.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapMcpTool = wrapMcpTool;
+const tools_1 = require("@langchain/core/tools");
+const client_1 = require("./client");
+const MCP_TOOL_PERMISSION_LEVEL = 'mcp';
+function wrapMcpTool(connection, mcpTool) {
+    const prefixedName = `${connection.name}_${mcpTool.name}`;
+    const schemaJson = JSON.stringify(mcpTool.inputSchema, null, 2);
+    const description = `[MCP:${connection.name}] ${mcpTool.description || 'No description'}\n\nParameters schema:\n${schemaJson}`;
+    // Pass the MCP server's JSON Schema directly to LangChain so the LLM
+    // sees the real parameter requirements instead of a shapeless passthrough.
+    const schema = mcpTool.inputSchema;
+    const impl = async (args) => {
+        const result = await (0, client_1.callMcpTool)(connection.client, mcpTool.name, args);
+        return result;
+    };
+    const t = (0, tools_1.tool)(impl, {
+        name: prefixedName,
+        description,
+        schema,
+    });
+    t.permission_level = MCP_TOOL_PERMISSION_LEVEL;
+    return t;
+}

package/dist/agent/model.d.ts

@@ -0,0 +1,5 @@
+import { ChatOpenAI } from '@langchain/openai';
+export declare function createModel(options?: {
+    streaming?: boolean;
+}): ChatOpenAI;
+export declare function checkModel(): Promise<void>;

package/dist/agent/model.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createModel = createModel;
+exports.checkModel = checkModel;
+const openai_1 = require("@langchain/openai");
+const config_1 = require("./config");
+const modelConfig = (0, config_1.getModelConfig)();
+function createModel(options) {
+    return new openai_1.ChatOpenAI({
+        model: modelConfig.model,
+        apiKey: modelConfig.apiKey,
+        configuration: {
+            baseURL: modelConfig.baseURL,
+        },
+        streaming: options?.streaming ?? true,
+        modelKwargs: {
+            thinking: { type: 'disabled' },
+        },
+    });
+}
+async function checkModel() {
+    if (modelConfig.apiKey.length < 20) {
+        try {
+            const model = createModel({ streaming: false });
+            await model.invoke([{ role: 'user', content: 'hi' }]);
+        }
+        catch {
+            throw new Error(`API Key 验证失败，请检查配置是否正确\n\n请参考 https://zhitalk.chat/#config 修改配置`);
+        }
+    }
+}

package/dist/agent/permission/dangerous-path.json

@@ -0,0 +1,115 @@
+{
+    "macos": [
+        "~/.ssh",
+        "~/.gnupg",
+        "~/.aws",
+        "~/.azure",
+        "~/.config/gcloud",
+        "~/.kube",
+        "~/.docker",
+        "~/.netrc",
+        "~/Library/Keychains",
+        "~/Library/Application Support/Google/Chrome",
+        "~/Library/Application Support/Chromium",
+        "~/Library/Application Support/Firefox",
+        "~/Library/Application Support/Slack",
+        "~/Library/Application Support/Discord",
+        "~/Library/Application Support/Telegram",
+        "~/Library/Application Support/Signal",
+        "~/.zshrc",
+        "~/.bashrc",
+        "~/.bash_profile",
+        "~/.profile",
+        "~/.env",
+        "~/.env.*",
+        "~/.gitconfig",
+        "~/.git-credentials",
+        "~/.npmrc",
+        "~/.pnpmrc",
+        "~/.yarnrc",
+        "~/.pypirc",
+        "~/.m2",
+        "~/.gradle",
+        "~/.terraform",
+        "~/.config/gh",
+        "~/.config/gitlab",
+        "~/.circleci",
+        "~/.vercel",
+        "~/.netlify",
+        "~/Library/Containers",
+        "/private",
+        "/etc",
+        "/var"
+    ],
+    "linux": [
+        "~/.ssh",
+        "~/.gnupg",
+        "~/.pki",
+        "~/.aws",
+        "~/.azure",
+        "~/.config/gcloud",
+        "~/.kube",
+        "~/.docker",
+        "~/.netrc",
+        "~/.local/share/keyrings",
+        "~/.config/google-chrome",
+        "~/.config/chromium",
+        "~/.mozilla/firefox",
+        "~/.config/Slack",
+        "~/.config/discord",
+        "~/.local/share/TelegramDesktop",
+        "~/.zshrc",
+        "~/.bashrc",
+        "~/.bash_profile",
+        "~/.profile",
+        "~/.env",
+        "~/.env.*",
+        "~/.gitconfig",
+        "~/.git-credentials",
+        "~/.npmrc",
+        "~/.pnpmrc",
+        "~/.yarnrc",
+        "~/.pypirc",
+        "~/.m2",
+        "~/.gradle",
+        "~/.terraform",
+        "~/.config/gh",
+        "~/.config/gitlab",
+        "~/.circleci",
+        "~/.vercel",
+        "~/.netlify",
+        "/etc/shadow",
+        "/etc/sudoers",
+        "/proc",
+        "/sys",
+        "/var/lib",
+        "/root"
+    ],
+    "windows": [
+        "%USERPROFILE%\\.ssh",
+        "%USERPROFILE%\\.gnupg",
+        "%USERPROFILE%\\.aws",
+        "%USERPROFILE%\\.azure",
+        "%USERPROFILE%\\.kube",
+        "%USERPROFILE%\\.docker",
+        "%LOCALAPPDATA%\\Google\\Chrome\\User Data",
+        "%LOCALAPPDATA%\\Chromium\\User Data",
+        "%APPDATA%\\Mozilla\\Firefox",
+        "%APPDATA%\\Slack",
+        "%APPDATA%\\Discord",
+        "%APPDATA%\\Telegram Desktop",
+        "%USERPROFILE%\\.gitconfig",
+        "%USERPROFILE%\\.git-credentials",
+        "%USERPROFILE%\\.npmrc",
+        "%USERPROFILE%\\.pnpmrc",
+        "%USERPROFILE%\\.yarnrc",
+        "%USERPROFILE%\\.m2",
+        "%USERPROFILE%\\.gradle",
+        "%APPDATA%",
+        "%LOCALAPPDATA%",
+        "C:\\Windows\\System32",
+        "C:\\Windows\\System32\\config\\SAM",
+        "C:\\Windows\\System32\\config\\SECURITY",
+        "C:\\Windows\\System32\\config\\SYSTEM"
+    ]
+}

package/dist/agent/permission/exec.d.ts

@@ -0,0 +1,11 @@
+export declare function checkExecPermission(toolCall: {
+    name: string;
+    args: Record<string, any>;
+}): {
+    action: 'allow';
+} | {
+    action: 'block';
+    reason: string;
+} | {
+    action: 'confirm';
+};