zhitalk 0.0.0 → 0.0.2

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';
+};

package/dist/agent/permission/exec.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkExecPermission = checkExecPermission;
+const util_1 = require("./util");
+function checkExecPermission(toolCall) {
+    const command = toolCall.args?.command;
+    if (typeof command !== 'string') {
+        return { action: 'confirm' };
+    }
+    if ((0, util_1.isSafeCommand)(command)) {
+        return { action: 'allow' };
+    }
+    if ((0, util_1.isChangingDirectory)(command)) {
+        return {
+            action: 'block',
+            reason: `命令包含切换目录操作，为防止目录逃逸，禁止执行。如有需要请手动操作。`,
+        };
+    }
+    const scriptCheck = (0, util_1.isScriptExecution)(command);
+    if (scriptCheck.blocked) {
+        return {
+            action: 'block',
+            reason: scriptCheck.reason,
+        };
+    }
+    const dangerCheck = (0, util_1.isDangerousOperation)(command);
+    if (dangerCheck.blocked) {
+        return {
+            action: 'block',
+            reason: dangerCheck.reason,
+        };
+    }
+    return { action: 'confirm' };
+}

package/dist/agent/permission/is-dangerous-path.d.ts

@@ -0,0 +1 @@
+export declare function isDangerousPath(filepath: string): boolean;

package/dist/agent/permission/is-dangerous-path.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDangerousPath = isDangerousPath;
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const dangerous_path_json_1 = __importDefault(require("./dangerous-path.json"));
+function expandPath(filepath) {
+    let expanded = filepath;
+    if (expanded.startsWith('~')) {
+        expanded = path_1.default.join(os_1.default.homedir(), expanded.slice(1));
+    }
+    expanded = expanded.replace(/%USERPROFILE%/gi, os_1.default.homedir());
+    expanded = expanded.replace(/%APPDATA%/gi, process.env.APPDATA || path_1.default.join(os_1.default.homedir(), 'AppData', 'Roaming'));
+    expanded = expanded.replace(/%LOCALAPPDATA%/gi, process.env.LOCALAPPDATA || path_1.default.join(os_1.default.homedir(), 'AppData', 'Local'));
+    if (!path_1.default.isAbsolute(expanded)) {
+        expanded = path_1.default.resolve(expanded);
+    }
+    expanded = path_1.default.normalize(expanded);
+    return expanded;
+}
+function globToRegex(pattern) {
+    const escaped = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*/g, '[^\\\\/]*');
+    return new RegExp(`^${escaped}(?:[\\\\/].*)?$`);
+}
+function isDangerousPath(filepath) {
+    const platform = process.platform === 'win32'
+        ? 'windows'
+        : process.platform === 'darwin'
+            ? 'macos'
+            : 'linux';
+    const dangerousList = dangerous_path_json_1.default[platform];
+    const expandedInput = expandPath(filepath);
+    for (const dangerous of dangerousList) {
+        const expandedDangerous = expandPath(dangerous);
+        if (dangerous.includes('*')) {
+            const regex = globToRegex(expandedDangerous);
+            if (regex.test(expandedInput))
+                return true;
+        }
+        else {
+            if (expandedInput === expandedDangerous)
+                return true;
+            if (expandedInput.startsWith(expandedDangerous + path_1.default.sep))
+                return true;
+        }
+    }
+    return false;
+}

package/dist/agent/permission/is-safe-domains.d.ts

@@ -0,0 +1 @@
+export declare function isSafeDomain(url: string): boolean;