@bolloon/bolloon-agent 0.1.0

package/dist/constraints/runtime.js

@@ -0,0 +1,135 @@
+import { getCommands } from './commands';
+import { getTools, executeTool } from './tools';
+import { executeCommand } from './commands';
+import { ToolPermissionContext } from './permissions';
+import { buildSystemInitMessage } from './system-init';
+export class ConstraintRuntime {
+    permissionContext;
+    constructor(permissionContext) {
+        this.permissionContext = permissionContext || new ToolPermissionContext();
+    }
+    routePrompt(prompt, limit = 5) {
+        const tokens = new Set(prompt
+            .replace(/\//g, ' ')
+            .replace(/-/g, ' ')
+            .split(/\s+/)
+            .map((t) => t.toLowerCase())
+            .filter((t) => t.length > 0));
+        const commandMatches = this.scoreMatches(tokens, getCommands(), 'command');
+        const toolMatches = this.scoreMatches(tokens, getTools(), 'tool');
+        const selected = [];
+        if (commandMatches.length > 0) {
+            selected.push(commandMatches[0]);
+        }
+        if (toolMatches.length > 0) {
+            selected.push(toolMatches[0]);
+        }
+        const leftovers = [...commandMatches, ...toolMatches]
+            .filter((m) => !selected.some((s) => s.name === m.name))
+            .sort((a, b) => b.score - a.score || a.name.localeCompare(b.name));
+        selected.push(...leftovers.slice(0, Math.max(0, limit - selected.length)));
+        return selected.slice(0, limit);
+    }
+    scoreMatches(tokens, entries, kind) {
+        const matches = [];
+        for (const entry of entries) {
+            const haystacks = [entry.name.toLowerCase(), entry.sourceHint.toLowerCase()];
+            let score = 0;
+            for (const token of tokens) {
+                if (haystacks.some((h) => h.includes(token))) {
+                    score += 1;
+                }
+            }
+            if (score > 0) {
+                matches.push({
+                    kind,
+                    name: entry.name,
+                    sourceHint: entry.sourceHint,
+                    score,
+                });
+            }
+        }
+        return matches.sort((a, b) => b.score - a.score || a.name.localeCompare(b.name));
+    }
+    bootstrapSession(prompt, limit = 5, trusted = true) {
+        const sessionId = crypto.randomUUID();
+        const matches = this.routePrompt(prompt, limit);
+        const commandExecs = [];
+        const toolExecs = [];
+        const denials = [];
+        for (const match of matches) {
+            if (match.kind === 'command') {
+                const result = executeCommand(match.name, prompt);
+                if (result.handled) {
+                    commandExecs.push(result.message);
+                }
+            }
+            else if (match.kind === 'tool') {
+                if (this.permissionContext.blocks(match.name)) {
+                    denials.push({
+                        toolName: match.name,
+                        reason: 'permission denied by context',
+                    });
+                }
+                else {
+                    const result = executeTool(match.name, '');
+                    if (result.handled) {
+                        toolExecs.push(result.message);
+                    }
+                }
+            }
+        }
+        return {
+            sessionId,
+            prompt,
+            trusted,
+            systemInitMessage: buildSystemInitMessage(trusted),
+            routedMatches: matches,
+            commandExecutionMessages: commandExecs,
+            toolExecutionMessages: toolExecs,
+            permissionDenials: denials,
+        };
+    }
+    runTurnLoop(prompt, limit = 5, maxTurns = 3) {
+        const results = [];
+        let currentPrompt = prompt;
+        for (let turn = 0; turn < maxTurns; turn++) {
+            const turnPrompt = turn === 0 ? currentPrompt : `${currentPrompt} [turn ${turn + 1}]`;
+            const matches = this.routePrompt(turnPrompt, limit);
+            const commandNames = matches
+                .filter((m) => m.kind === 'command')
+                .map((m) => m.name);
+            const toolNames = matches
+                .filter((m) => m.kind === 'tool')
+                .map((m) => m.name);
+            const outputLines = [
+                `Turn ${turn + 1}`,
+                `Prompt: ${turnPrompt}`,
+                `Matched commands: ${commandNames.join(', ') || 'none'}`,
+                `Matched tools: ${toolNames.join(', ') || 'none'}`,
+            ];
+            const output = outputLines.join('\n');
+            const inputTokens = turnPrompt.split(/\s+/).length;
+            const outputTokens = output.split(/\s+/).length;
+            results.push({
+                output,
+                matchedCommands: commandNames,
+                matchedTools: toolNames,
+                permissionDenials: [],
+                stopReason: 'completed',
+                usage: { inputTokens, outputTokens },
+            });
+            if (turn < maxTurns - 1) {
+                currentPrompt = turnPrompt;
+            }
+        }
+        return results;
+    }
+    setPermissionContext(context) {
+        this.permissionContext = context;
+    }
+    getPermissionContext() {
+        return this.permissionContext;
+    }
+}
+export const defaultRuntime = new ConstraintRuntime();

package/dist/constraints/session.js

@@ -0,0 +1,48 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+const DEFAULT_SESSION_DIR = path.join(process.env.HOME || '/tmp', '.bolloon', 'sessions');
+export async function saveSession(session, directory) {
+    const targetDir = directory || DEFAULT_SESSION_DIR;
+    await fs.mkdir(targetDir, { recursive: true });
+    const filePath = path.join(targetDir, `${session.sessionId}.json`);
+    await fs.writeFile(filePath, JSON.stringify(session, null, 2));
+    return filePath;
+}
+export async function loadSession(sessionId, directory) {
+    const targetDir = directory || DEFAULT_SESSION_DIR;
+    const data = await fs.readFile(path.join(targetDir, `${sessionId}.json`), 'utf-8');
+    return JSON.parse(data);
+}
+export async function listSessions(directory) {
+    const targetDir = directory || DEFAULT_SESSION_DIR;
+    try {
+        const files = await fs.readdir(targetDir);
+        const sessions = [];
+        for (const file of files) {
+            if (file.endsWith('.json')) {
+                try {
+                    const data = await fs.readFile(path.join(targetDir, file), 'utf-8');
+                    sessions.push(JSON.parse(data));
+                }
+                catch {
+                    // Skip invalid session files
+                }
+            }
+        }
+        return sessions.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+    }
+    catch {
+        return [];
+    }
+}
+export async function deleteSession(sessionId, directory) {
+    const targetDir = directory || DEFAULT_SESSION_DIR;
+    const filePath = path.join(targetDir, `${sessionId}.json`);
+    try {
+        await fs.unlink(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/constraints/system-init.js

@@ -0,0 +1,51 @@
+import { getCommands } from './commands';
+import { getTools } from './tools';
+const STARTUP_STEPS = [
+    { name: 'start top-level prefetch side effects', description: 'Initiate background prefetch operations' },
+    { name: 'build workspace context', description: 'Construct workspace context for agent operations' },
+    { name: 'load mirrored command snapshot', description: 'Load command definitions from snapshot' },
+    { name: 'load mirrored tool snapshot', description: 'Load tool definitions from snapshot' },
+    { name: 'prepare parity audit hooks', description: 'Set up parity audit instrumentation' },
+    { name: 'apply trust-gated deferred init', description: 'Execute deferred initialization based on trust level' },
+];
+function buildWorkspaceSetup(trusted, context) {
+    return {
+        trusted,
+        builtInCommandCount: getBuiltInCommandNames().size,
+        loadedCommandCount: getCommands().length,
+        loadedToolCount: getTools().length,
+        startupSteps: STARTUP_STEPS,
+        permissionContext: context?.permissionContext,
+        currentTime: new Date().toISOString(),
+    };
+}
+function getBuiltInCommandNames() {
+    const commands = getCommands();
+    return new Set(commands.map((c) => c.name));
+}
+export function buildSystemInitMessage(trusted, context) {
+    const setup = buildWorkspaceSetup(trusted, context);
+    const commands = getCommands();
+    const tools = getTools();
+    const lines = [
+        '# System Init',
+        '',
+        `Trusted: ${setup.trusted}`,
+        `Built-in command names: ${setup.builtInCommandCount}`,
+        `Loaded command entries: ${commands.length}`,
+        `Loaded tool entries: ${tools.length}`,
+        '',
+        '## Available Commands',
+        ...commands.map((cmd) => `- ${cmd.name}: ${cmd.responsibility}`),
+        '',
+        '## Available Tools',
+        ...tools.map((tool) => `- ${tool.name}: ${tool.responsibility}`),
+        '',
+        '## Startup Steps',
+        ...setup.startupSteps.map((step) => `- ${step.name}`),
+        '',
+        `Current Time: ${setup.currentTime}`,
+    ];
+    return lines.join('\n');
+}
+export { STARTUP_STEPS };

package/dist/constraints/tools.js

@@ -0,0 +1,104 @@
+const PORTED_TOOLS_DATA = [
+    {
+        name: 'read_document',
+        responsibility: 'Read content from a document or file',
+        sourceHint: 'bolloon/documents/reader.ts',
+        status: 'mirrored',
+    },
+    {
+        name: 'summarize_document',
+        responsibility: 'Generate a summary of a document',
+        sourceHint: 'bolloon/documents/summarizer.ts',
+        status: 'mirrored',
+    },
+    {
+        name: 'improve_document',
+        responsibility: 'Improve the quality of a document',
+        sourceHint: 'bolloon/documents/improver.ts',
+        status: 'mirrored',
+    },
+    {
+        name: 'list_peers',
+        responsibility: 'List all connected peers in the network',
+        sourceHint: 'bolloon/network/p2p.ts',
+        status: 'mirrored',
+    },
+    {
+        name: 'send_message',
+        responsibility: 'Send a direct message to a peer',
+        sourceHint: 'bolloon/network/messaging.ts',
+        status: 'mirrored',
+    },
+    {
+        name: 'broadcast_message',
+        responsibility: 'Broadcast a message to all connected peers',
+        sourceHint: 'bolloon/network/messaging.ts',
+        status: 'mirrored',
+    },
+    {
+        name: 'get_identity',
+        responsibility: 'Get the identity information of the current node',
+        sourceHint: 'bolloon/agents/protocol.ts',
+        status: 'mirrored',
+    },
+    {
+        name: 'get_operation_logs',
+        responsibility: 'Retrieve operation logs for the current session',
+        sourceHint: 'bolloon/agents/protocol.ts',
+        status: 'mirrored',
+    },
+    {
+        name: 'search_files',
+        responsibility: 'Search for files matching a query pattern',
+        sourceHint: 'bolloon/documents/search.ts',
+        status: 'mirrored',
+    },
+];
+export const PORTED_TOOLS = PORTED_TOOLS_DATA;
+export function getTool(name) {
+    const needle = name.toLowerCase();
+    for (const tool of PORTED_TOOLS) {
+        if (tool.name.toLowerCase() === needle) {
+            return tool;
+        }
+    }
+    return null;
+}
+export function getTools() {
+    return [...PORTED_TOOLS];
+}
+export function findTools(query, limit = 20) {
+    const needle = query.toLowerCase();
+    const matches = PORTED_TOOLS.filter((tool) => tool.name.toLowerCase().includes(needle) ||
+        tool.sourceHint.toLowerCase().includes(needle));
+    return matches.slice(0, limit);
+}
+export function executeTool(name, payload = '') {
+    const tool = getTool(name);
+    if (tool === null) {
+        return {
+            name,
+            sourceHint: '',
+            payload,
+            handled: false,
+            message: `Unknown mirrored tool: ${name}`,
+        };
+    }
+    const message = `Mirrored tool '${tool.name}' from ${tool.sourceHint} would handle payload ${JSON.stringify(payload)}.`;
+    return {
+        name: tool.name,
+        sourceHint: tool.sourceHint,
+        payload,
+        handled: true,
+        message,
+    };
+}
+export function filterToolsByPermissionContext(tools, permissionContext) {
+    if (permissionContext === null) {
+        return [...tools];
+    }
+    return tools.filter((tool) => !permissionContext.blocks(tool.name));
+}
+export function toolNames() {
+    return PORTED_TOOLS.map((tool) => tool.name);
+}

package/dist/documents/reader.js

@@ -0,0 +1,104 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.documentReader = exports.DocumentReader = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const pdf_parse_1 = __importDefault(require("pdf-parse"));
+const mammoth_1 = __importDefault(require("mammoth"));
+class DocumentReader {
+    async read(filePath) {
+        const stats = await fs.stat(filePath);
+        const ext = path.extname(filePath).toLowerCase();
+        const filename = path.basename(filePath);
+        let text;
+        switch (ext) {
+            case '.txt':
+            case '.md':
+                text = await fs.readFile(filePath, 'utf-8');
+                break;
+            case '.pdf':
+                text = await this.readPdf(filePath);
+                break;
+            case '.docx':
+                text = await this.readDocx(filePath);
+                break;
+            default:
+                throw new Error(`Unsupported file type: ${ext}`);
+        }
+        return {
+            text,
+            metadata: {
+                filename,
+                size: stats.size,
+                type: ext
+            }
+        };
+    }
+    async readPdf(filePath) {
+        const dataBuffer = await fs.readFile(filePath);
+        // @ts-ignore - pdf-parse v2 API differs
+        const data = await (0, pdf_parse_1.default)(dataBuffer);
+        return data.text;
+    }
+    async readDocx(filePath) {
+        const result = await mammoth_1.default.extractRawText({ path: filePath });
+        return result.value;
+    }
+    chunk(text, maxChunkSize = 4000) {
+        const chunks = [];
+        let current = '';
+        const sentences = text.split(/(?<=[.!?。！？])\s+/);
+        for (const sentence of sentences) {
+            if ((current + sentence).length <= maxChunkSize) {
+                current += (current ? ' ' : '') + sentence;
+            }
+            else {
+                if (current)
+                    chunks.push(current);
+                current = sentence;
+            }
+        }
+        if (current)
+            chunks.push(current);
+        return chunks;
+    }
+}
+exports.DocumentReader = DocumentReader;
+exports.documentReader = new DocumentReader();
+//# sourceMappingURL=reader.js.map

package/dist/documents/reader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reader.js","sourceRoot":"","sources":["../../src/documents/reader.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,gDAAkC;AAClC,2CAA6B;AAC7B,0DAAiC;AACjC,sDAA8B;AAW9B,MAAa,cAAc;IACzB,KAAK,CAAC,IAAI,CAAC,QAAgB;QACzB,MAAM,KAAK,GAAG,MAAM,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACtC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,WAAW,EAAE,CAAC;QACjD,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;QAEzC,IAAI,IAAY,CAAC;QAEjB,QAAQ,GAAG,EAAE,CAAC;YACZ,KAAK,MAAM,CAAC;YACZ,KAAK,KAAK;gBACR,IAAI,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;gBAC5C,MAAM;YACR,KAAK,MAAM;gBACT,IAAI,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;gBACpC,MAAM;YACR,KAAK,OAAO;gBACV,IAAI,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;gBACrC,MAAM;YACR;gBACE,MAAM,IAAI,KAAK,CAAC,0BAA0B,GAAG,EAAE,CAAC,CAAC;QACrD,CAAC;QAED,OAAO;YACL,IAAI;YACJ,QAAQ,EAAE;gBACR,QAAQ;gBACR,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,IAAI,EAAE,GAAG;aACV;SACF,CAAC;IACJ,CAAC;IAEO,KAAK,CAAC,OAAO,CAAC,QAAgB;QACpC,MAAM,UAAU,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;QAC/C,wCAAwC;QACxC,MAAM,IAAI,GAAG,MAAM,IAAA,mBAAQ,EAAC,UAAU,CAAC,CAAC;QACxC,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;IAEO,KAAK,CAAC,QAAQ,CAAC,QAAgB;QACrC,MAAM,MAAM,GAAG,MAAM,iBAAO,CAAC,cAAc,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;QAChE,OAAO,MAAM,CAAC,KAAK,CAAC;IACtB,CAAC;IAED,KAAK,CAAC,IAAY,EAAE,eAAuB,IAAI;QAC7C,MAAM,MAAM,GAAa,EAAE,CAAC;QAC5B,IAAI,OAAO,GAAG,EAAE,CAAC;QAEjB,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC;QAEjD,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;YACjC,IAAI,CAAC,OAAO,GAAG,QAAQ,CAAC,CAAC,MAAM,IAAI,YAAY,EAAE,CAAC;gBAChD,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC;YAC7C,CAAC;iBAAM,CAAC;gBACN,IAAI,OAAO;oBAAE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;gBAClC,OAAO,GAAG,QAAQ,CAAC;YACrB,CAAC;QACH,CAAC;QAED,IAAI,OAAO;YAAE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAClC,OAAO,MAAM,CAAC;IAChB,CAAC;CACF;AA/DD,wCA+DC;AAEY,QAAA,cAAc,GAAG,IAAI,cAAc,EAAE,CAAC"}

package/dist/electron-preload.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Electron Preload 脚本
+ * 在渲染进程和主进程之间建立安全的通信桥梁
+ */
+const electron_1 = require("electron");
+// 暴露给渲染进程的 API
+electron_1.contextBridge.exposeInMainWorld('electronAPI', {
+    getVersion: () => electron_1.ipcRenderer.invoke('get-version'),
+    getUserDataPath: () => electron_1.ipcRenderer.invoke('get-user-data-path'),
+    openExternal: (url) => electron_1.ipcRenderer.invoke('open-external', url),
+    platform: process.platform,
+});
+//# sourceMappingURL=electron-preload.js.map

package/dist/electron-preload.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"electron-preload.js","sourceRoot":"","sources":["../src/electron-preload.ts"],"names":[],"mappings":";;AAAA;;;GAGG;AACH,uCAAsD;AAEtD,eAAe;AACf,wBAAa,CAAC,iBAAiB,CAAC,aAAa,EAAE;IAC7C,UAAU,EAAE,GAAG,EAAE,CAAC,sBAAW,CAAC,MAAM,CAAC,aAAa,CAAC;IACnD,eAAe,EAAE,GAAG,EAAE,CAAC,sBAAW,CAAC,MAAM,CAAC,oBAAoB,CAAC;IAC/D,YAAY,EAAE,CAAC,GAAW,EAAE,EAAE,CAAC,sBAAW,CAAC,MAAM,CAAC,eAAe,EAAE,GAAG,CAAC;IACvE,QAAQ,EAAE,OAAO,CAAC,QAAQ;CAC3B,CAAC,CAAC"}

package/dist/electron.js

@@ -0,0 +1,206 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Electron 主进程入口
+ */
+const electron_1 = require("electron");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const child_process_1 = require("child_process");
+const isDev = process.env.NODE_ENV === 'development' || !electron_1.app.isPackaged;
+// 日志文件路径
+const userDataPath = electron_1.app.getPath('userData');
+const logPath = path.join(userDataPath, 'bolloon.log');
+function log(msg) {
+    const ts = new Date().toISOString();
+    const line = `[${ts}] ${msg}\n`;
+    fs.appendFileSync(logPath, line);
+    console.log(msg);
+}
+log('Bolloon Electron 启动');
+// 全局窗口引用
+let mainWindow = null;
+let webServerProcess = null;
+// 防止多个实例
+const gotTheLock = electron_1.app.requestSingleInstanceLock();
+if (!gotTheLock) {
+    log('已有实例在运行，退出');
+    electron_1.app.quit();
+}
+electron_1.app.on('second-instance', () => {
+    if (mainWindow) {
+        if (mainWindow.isMinimized())
+            mainWindow.restore();
+        mainWindow.focus();
+    }
+});
+function startWebServer(port) {
+    return new Promise((resolve, reject) => {
+        const serverScript = path.join(__dirname, 'web', 'server.js');
+        log(`启动 Web 服务器进程: ${serverScript}`);
+        webServerProcess = (0, child_process_1.spawn)(process.execPath, [serverScript], {
+            env: {
+                ...process.env,
+                NODE_ENV: 'production',
+                PORT: String(port),
+                ELECTRON_PORT: String(port),
+            },
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdoutData = '';
+        let stderrData = '';
+        webServerProcess.stdout?.on('data', (data) => {
+            stdoutData += data.toString();
+            process.stdout.write(`[WebServer] ${data}`);
+        });
+        webServerProcess.stderr?.on('data', (data) => {
+            stderrData += data.toString();
+            process.stderr.write(`[WebServer ERR] ${data}`);
+        });
+        webServerProcess.on('error', (err) => {
+            log(`Web 服务器进程启动失败: ${err}`);
+            reject(err);
+        });
+        webServerProcess.on('exit', (code, signal) => {
+            log(`Web 服务器进程退出: code=${code} signal=${signal}`);
+            if (code !== 0 && code !== null) {
+                log(`Web 服务器 stderr: ${stderrData}`);
+            }
+        });
+        // 等待服务器就绪 - 检查 stdout 中的标记
+        const checkReady = setInterval(() => {
+            if (stdoutData.includes('服务器已监听') || stdoutData.includes('Web 服务器启动完成')) {
+                clearInterval(checkReady);
+                log('Web 服务器进程已就绪');
+                resolve();
+            }
+        }, 200);
+        // 超时
+        setTimeout(() => {
+            clearInterval(checkReady);
+            if (webServerProcess?.killed === false) {
+                log('Web 服务器启动超时');
+                reject(new Error('Web server startup timeout'));
+            }
+        }, 15000);
+    });
+}
+async function createWindow() {
+    log('创建主窗口...');
+    const width = 1200;
+    const height = 800;
+    const minWidth = 800;
+    const minHeight = 600;
+    mainWindow = new electron_1.BrowserWindow({
+        width,
+        height,
+        minWidth,
+        minHeight,
+        title: 'Bolloon Agent',
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+            sandbox: false,
+        },
+        show: false,
+    });
+    const port = parseInt(process.env.ELECTRON_PORT || '54188');
+    if (isDev) {
+        mainWindow.loadURL(`http://localhost:${port}`);
+        mainWindow.webContents.openDevTools();
+    }
+    else {
+        try {
+            log(`启动内置 Web 服务器...`);
+            await startWebServer(port);
+            mainWindow.loadURL(`http://localhost:${port}`);
+        }
+        catch (err) {
+            log(`启动服务器失败: ${err}`);
+            console.error('启动服务器失败:', err);
+        }
+    }
+    mainWindow.once('ready-to-show', () => {
+        mainWindow?.show();
+        log('窗口已显示');
+    });
+    mainWindow.webContents.setWindowOpenHandler(({ url }) => {
+        if (url.startsWith('http://') || url.startsWith('https://')) {
+            electron_1.shell.openExternal(url);
+        }
+        return { action: 'deny' };
+    });
+    mainWindow.on('closed', () => {
+        mainWindow = null;
+    });
+    log('窗口创建完成');
+}
+electron_1.app.whenReady().then(async () => {
+    log('Electron 准备好');
+    await createWindow();
+    electron_1.app.on('activate', async () => {
+        if (electron_1.BrowserWindow.getAllWindows().length === 0) {
+            await createWindow();
+        }
+    });
+});
+electron_1.app.on('window-all-closed', () => {
+    log('所有窗口已关闭');
+    if (webServerProcess) {
+        webServerProcess.kill();
+        log('Web 服务器进程已终止');
+    }
+    if (process.platform !== 'darwin') {
+        electron_1.app.quit();
+    }
+});
+electron_1.app.on('before-quit', () => {
+    log('应用即将退出');
+    if (webServerProcess) {
+        webServerProcess.kill();
+    }
+});
+electron_1.ipcMain.handle('get-version', () => {
+    return electron_1.app.getVersion();
+});
+electron_1.ipcMain.handle('get-user-data-path', () => {
+    return userDataPath;
+});
+electron_1.ipcMain.handle('open-external', async (_, url) => {
+    await electron_1.shell.openExternal(url);
+});
+log('主进程初始化完成');
+//# sourceMappingURL=electron.js.map