@kai-chat/desktop 0.0.1

package/dist/electron/claude.js

@@ -0,0 +1,424 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRequest = parseRequest;
+exports.workingFolders = workingFolders;
+exports.buildArgs = buildArgs;
+exports.promptInput = promptInput;
+exports.mcpConfig = mcpConfig;
+exports.eventsOf = eventsOf;
+exports.findClaude = findClaude;
+exports.runClaude = runClaude;
+exports.cancelClaude = cancelClaude;
+exports.cancelAllClaude = cancelAllClaude;
+exports.claudeStatus = claudeStatus;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const TOOLS = ['Read', 'Glob', 'Grep', 'Edit', 'Write'];
+const WRITE_TOOLS = ['Edit', 'Write'];
+const MODEL = /^[A-Za-z0-9][A-Za-z0-9._:[\]-]{0,99}$/;
+const MCP_PATH = /^\/api\/claude-code\/mcp\/[A-Za-z0-9_-]{1,100}$/;
+const TOKEN = /^[A-Za-z0-9_-]{16,200}$/;
+const MAX_TEXT = 4 * 1024 * 1024;
+const ATTACHMENT_TYPES = ['image/png', 'image/jpeg', 'image/gif', 'image/webp', 'application/pdf'];
+const MAX_ATTACHMENTS = 20;
+const MAX_ATTACHMENT_CHARS = 12 * 1024 * 1024; // base64 characters: about 9 MB of file
+const MAX_ATTACHMENTS_TOTAL_CHARS = 30 * 1024 * 1024;
+const BASE64 = /^[A-Za-z0-9+/]+={0,2}$/;
+const MAX_TOOL_RESULT = 20_000;
+const KILL_GRACE_MS = 5_000;
+const NOT_FOUND = 'The Claude Code command was not found on this computer. Install Claude Code, sign in with it once, and try again.';
+const TURNED_OFF = 'Claude Code is turned off on this computer. Turn it on in the desktop app under Settings > Claude Code.';
+// ------------------------------------------------------------------ the request
+/** IPC arguments come from the renderer, so check their shape before use. */
+function parseRequest(value) {
+    const v = value;
+    const fail = (what) => {
+        throw new Error(`Invalid Claude Code request: ${what}`);
+    };
+    if (!v || typeof v !== 'object')
+        return fail('not an object');
+    const text = (key, max = MAX_TEXT) => {
+        const x = v[key];
+        return typeof x === 'string' && x.length <= max ? x : fail(key);
+    };
+    const runId = text('runId', 200);
+    if (runId === '')
+        fail('runId');
+    const model = text('model', 100);
+    if (model !== '' && !MODEL.test(model))
+        fail('model');
+    const tools = v['tools'];
+    if (!Array.isArray(tools) || !tools.every((t) => TOOLS.includes(t)))
+        fail('tools');
+    const rawAttachments = v['attachments'] === undefined ? [] : v['attachments'];
+    if (!Array.isArray(rawAttachments) || rawAttachments.length > MAX_ATTACHMENTS)
+        fail('attachments');
+    let total = 0;
+    const attachments = rawAttachments.map((item) => {
+        const a = item;
+        if (!a ||
+            typeof a['mediaType'] !== 'string' ||
+            !ATTACHMENT_TYPES.includes(a['mediaType']) ||
+            typeof a['data'] !== 'string' ||
+            a['data'].length === 0 ||
+            a['data'].length > MAX_ATTACHMENT_CHARS ||
+            a['data'].length % 4 !== 0 ||
+            !BASE64.test(a['data'])) {
+            return fail('attachments');
+        }
+        total += a['data'].length;
+        return { mediaType: a['mediaType'], data: a['data'] };
+    });
+    if (total > MAX_ATTACHMENTS_TOTAL_CHARS)
+        fail('attachments');
+    let mcp = null;
+    if (v['mcp'] !== null && v['mcp'] !== undefined) {
+        const m = v['mcp'];
+        if (typeof m['path'] !== 'string' || !MCP_PATH.test(m['path']) || typeof m['token'] !== 'string' || !TOKEN.test(m['token'])) {
+            fail('mcp');
+        }
+        mcp = { path: m['path'], token: m['token'] };
+    }
+    const serverUrl = text('serverUrl', 2_000);
+    try {
+        const url = new URL(serverUrl);
+        if (url.protocol !== 'http:' && url.protocol !== 'https:')
+            fail('serverUrl');
+    }
+    catch {
+        fail('serverUrl');
+    }
+    return {
+        runId,
+        model,
+        systemPrompt: text('systemPrompt'),
+        prompt: text('prompt'),
+        attachments,
+        tools: [...new Set(tools)],
+        mcp,
+        serverUrl,
+    };
+}
+// ---------------------------------------------------------------------- folders
+function realDir(p) {
+    try {
+        const real = fs_1.default.realpathSync(p);
+        return fs_1.default.statSync(real).isDirectory() ? real : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The folders the CLI may work in: the ones the user allowed in Settings, and nothing else. A run
+ * with a write tool only gets folders the user opened for writing: the CLI's tools cannot be held
+ * to write in one folder and read in another.
+ */
+function workingFolders(tools, granted) {
+    if (tools.length === 0)
+        return [];
+    const writes = tools.some(t => WRITE_TOOLS.includes(t));
+    const found = new Set();
+    for (const folder of granted) {
+        if (writes && folder.access !== 'readwrite')
+            continue;
+        const root = realDir(folder.path);
+        if (root)
+            found.add(root);
+    }
+    return [...found];
+}
+// -------------------------------------------------------------------- the command
+/**
+ * The CLI's arguments. The tool list is the ceiling (nothing else exists for the model), and the
+ * permission mode makes anything not pre-approved a refusal rather than a question nobody can answer:
+ * reads stay inside the working folders, and writes are only accepted there and only when the agent may.
+ */
+function buildArgs(params) {
+    const { request, folders } = params;
+    const writes = request.tools.some(t => WRITE_TOOLS.includes(t));
+    return [
+        '-p',
+        '--output-format',
+        'stream-json',
+        // A prompt with pictures or PDFs is a message of content blocks, not plain text.
+        ...(request.attachments.length > 0 ? ['--input-format', 'stream-json'] : []),
+        '--verbose',
+        '--include-partial-messages',
+        '--no-session-persistence',
+        '--permission-mode',
+        writes ? 'acceptEdits' : 'dontAsk',
+        '--tools',
+        request.tools.join(','),
+        // Nothing but the agent's own MCP endpoint: not this person's other servers or account connectors.
+        '--strict-mcp-config',
+        '--system-prompt-file',
+        params.systemPromptFile,
+        ...(request.model ? ['--model', request.model] : []),
+        ...(params.mcpConfigFile ? ['--mcp-config', params.mcpConfigFile, '--allowedTools', 'mcp__kai'] : []),
+        ...folders.slice(1).flatMap(f => ['--add-dir', f]),
+    ];
+}
+/**
+ * What is written to the CLI's stdin: the prompt as it is, or, with pictures or PDFs, one line of
+ * JSON holding a single user message (the text first, then each file as a base64 content block, in
+ * the order the prompt refers to them). It never goes on the command line or to disk.
+ */
+function promptInput(request) {
+    if (request.attachments.length === 0)
+        return request.prompt;
+    const blocks = request.attachments.map(a => ({
+        type: a.mediaType === 'application/pdf' ? 'document' : 'image',
+        source: { type: 'base64', media_type: a.mediaType, data: a.data },
+    }));
+    return `${JSON.stringify({ type: 'user', message: { role: 'user', content: [{ type: 'text', text: request.prompt }, ...blocks] } })}\n`;
+}
+function mcpConfig(request) {
+    const base = new URL(request.serverUrl);
+    const url = new URL(request.mcp.path, base);
+    // The token is only ever sent to the server this app is logged in to.
+    if (url.origin !== base.origin)
+        throw new Error('Invalid Claude Code request: mcp');
+    return JSON.stringify({
+        mcpServers: { kai: { type: 'http', url: url.toString(), headers: { Authorization: `Bearer ${request.mcp.token}` } } },
+    });
+}
+// ------------------------------------------------------------------- the output
+function contentText(content) {
+    const text = typeof content === 'string'
+        ? content
+        : Array.isArray(content)
+            ? content.map(b => (b && typeof b === 'object' && typeof b.text === 'string' ? b.text : '')).join('')
+            : '';
+    return text.length > MAX_TOOL_RESULT ? `${text.slice(0, MAX_TOOL_RESULT)}\n(cut: ${text.length - MAX_TOOL_RESULT} more characters)` : text;
+}
+/** What one line of the CLI's `stream-json` output means for the server (nothing, for most lines). */
+function eventsOf(line, runId, seenTools) {
+    let msg;
+    try {
+        msg = JSON.parse(line);
+    }
+    catch {
+        return [];
+    }
+    if (!msg || typeof msg !== 'object')
+        return [];
+    // What a sub-agent says is not the agent's answer.
+    const inner = msg.parent_tool_use_id != null;
+    if (msg.type === 'stream_event' && !inner) {
+        const delta = msg.event?.type === 'content_block_delta' ? msg.event.delta : null;
+        if (delta?.type === 'text_delta' && typeof delta.text === 'string' && delta.text !== '') {
+            return [{ runId, kind: 'text', delta: delta.text }];
+        }
+        return [];
+    }
+    if (msg.type === 'assistant' && !inner && Array.isArray(msg.message?.content)) {
+        const events = [];
+        for (const block of msg.message.content) {
+            if (block?.type === 'tool_use' && typeof block.id === 'string' && !seenTools.has(block.id)) {
+                seenTools.add(block.id);
+                events.push({
+                    runId,
+                    kind: 'tool_use',
+                    toolId: block.id,
+                    name: String(block.name),
+                    input: block.input && typeof block.input === 'object' ? block.input : {},
+                });
+            }
+        }
+        return events;
+    }
+    if (msg.type === 'user' && !inner && Array.isArray(msg.message?.content)) {
+        return msg.message.content
+            .filter((b) => b?.type === 'tool_result' && typeof b.tool_use_id === 'string')
+            .map((b) => ({
+            runId,
+            kind: 'tool_result',
+            toolId: b.tool_use_id,
+            isError: b.is_error === true,
+            content: contentText(b.content),
+        }));
+    }
+    if (msg.type === 'result') {
+        const text = typeof msg.result === 'string' ? msg.result : '';
+        return msg.is_error === true || (typeof msg.subtype === 'string' && msg.subtype !== 'success')
+            ? [{ runId, kind: 'error', message: text || `Claude Code stopped: ${msg.subtype ?? 'unknown reason'}` }]
+            : [{ runId, kind: 'done', text }];
+    }
+    return [];
+}
+// ------------------------------------------------------------------ the process
+/** Finds the CLI: on PATH first, then where its installers put it (a desktop app has a thin PATH). */
+function findClaude(env = process.env, exists = p => {
+    try {
+        return fs_1.default.statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}, home = os_1.default.homedir()) {
+    const names = process.platform === 'win32' ? ['claude.exe'] : ['claude'];
+    const dirs = [
+        ...(env['PATH'] ?? '').split(path_1.default.delimiter).filter(Boolean),
+        path_1.default.join(home, '.local', 'bin'),
+        path_1.default.join(home, '.claude', 'local'),
+        path_1.default.join(home, '.npm-global', 'bin'),
+        '/usr/local/bin',
+        '/opt/homebrew/bin',
+    ];
+    for (const dir of dirs) {
+        for (const name of names) {
+            const candidate = path_1.default.join(dir, name);
+            if (exists(candidate))
+                return candidate;
+        }
+    }
+    return null;
+}
+const running = new Map();
+/**
+ * Runs the request and reports what happens through `deps.emit`. Every outcome ends in exactly one
+ * `done` or `error` event (a cancelled run ends in neither: whoever cancelled it already knows).
+ */
+async function runClaude(input, deps) {
+    let runId = '';
+    let ended = false;
+    const emit = (event) => {
+        if (event.kind === 'done' || event.kind === 'error') {
+            if (ended)
+                return;
+            ended = true;
+        }
+        deps.emit(event);
+    };
+    const fail = (message) => emit({ runId, kind: 'error', message });
+    let request;
+    try {
+        request = parseRequest(input);
+    }
+    catch (err) {
+        // Without a valid run id nobody is waiting for an answer here, but the server still is: say what we can.
+        const id = input?.runId;
+        runId = typeof id === 'string' ? id : '';
+        if (runId)
+            fail(err instanceof Error ? err.message : String(err));
+        return;
+    }
+    runId = request.runId;
+    if (!deps.enabled())
+        return fail(TURNED_OFF);
+    if (running.has(runId))
+        return fail('Claude Code is already running for this request.');
+    const command = (deps.command ?? (() => findClaude()))();
+    if (!command)
+        return fail(NOT_FOUND);
+    const workDir = fs_1.default.mkdtempSync(path_1.default.join(deps.tmpDir ?? os_1.default.tmpdir(), 'kai-claude-'));
+    try {
+        fs_1.default.chmodSync(workDir, 0o700);
+        const folders = workingFolders(request.tools, deps.folders());
+        if (request.tools.length > 0 && folders.length === 0) {
+            return fail(request.tools.some(t => WRITE_TOOLS.includes(t))
+                ? 'No folder is open for reading and writing here. Add one under Settings > File access with "Read & write".'
+                : 'No folder is allowed here. Add one under Settings > File access.');
+        }
+        // Private files instead of the command line, which other programs on this computer can read.
+        const systemPromptFile = path_1.default.join(workDir, 'system-prompt.txt');
+        fs_1.default.writeFileSync(systemPromptFile, request.systemPrompt, { mode: 0o600 });
+        let mcpConfigFile = null;
+        if (request.mcp) {
+            mcpConfigFile = path_1.default.join(workDir, 'mcp.json');
+            fs_1.default.writeFileSync(mcpConfigFile, mcpConfig(request), { mode: 0o600 });
+        }
+        // With no folder granted the CLI starts in an empty one of its own.
+        const cwd = folders[0] ?? path_1.default.join(workDir, 'empty');
+        if (folders.length === 0)
+            fs_1.default.mkdirSync(cwd);
+        const args = buildArgs({ request, folders, systemPromptFile, mcpConfigFile });
+        const child = (deps.spawn ?? child_process_1.spawn)(command, args, { cwd, env: process.env, stdio: ['pipe', 'pipe', 'pipe'] });
+        const entry = { child, cancelled: false };
+        running.set(runId, entry);
+        await new Promise(resolve => {
+            const seenTools = new Set();
+            let stdout = '';
+            let stderr = '';
+            child.on('error', (err) => {
+                fail(err.code === 'ENOENT' ? NOT_FOUND : `Could not start Claude Code: ${err.message}`);
+                resolve();
+            });
+            child.on('spawn', () => {
+                emit({ runId, kind: 'started' });
+            });
+            child.stdout?.on('data', (chunk) => {
+                stdout += chunk.toString('utf8');
+                let newline;
+                while ((newline = stdout.indexOf('\n')) >= 0) {
+                    const line = stdout.slice(0, newline).trim();
+                    stdout = stdout.slice(newline + 1);
+                    if (line)
+                        for (const event of eventsOf(line, runId, seenTools))
+                            emit(event);
+                }
+            });
+            child.stderr?.on('data', (chunk) => {
+                stderr = (stderr + chunk.toString('utf8')).slice(-2_000);
+            });
+            child.on('close', code => {
+                if (stdout.trim())
+                    for (const event of eventsOf(stdout.trim(), runId, seenTools))
+                        emit(event);
+                if (!ended && !entry.cancelled) {
+                    fail(`Claude Code stopped without an answer${code !== null ? ` (exit code ${code})` : ''}.${stderr.trim() ? ` ${stderr.trim()}` : ''}`);
+                }
+                resolve();
+            });
+            child.stdin?.on('error', () => undefined); // the CLI may exit before it reads everything
+            child.stdin?.end(promptInput(request));
+        });
+    }
+    catch (err) {
+        fail(`Could not run Claude Code: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    finally {
+        running.delete(runId);
+        fs_1.default.rmSync(workDir, { recursive: true, force: true });
+    }
+}
+/** Stops a run (the server cancelled it, or the connection to the server was lost). */
+function cancelClaude(runId) {
+    const entry = running.get(runId);
+    if (!entry || entry.cancelled)
+        return;
+    entry.cancelled = true;
+    entry.child.kill('SIGTERM');
+    // A CLI that ignores SIGTERM must not keep running an agent nobody is waiting for.
+    const timer = setTimeout(() => entry.child.kill('SIGKILL'), KILL_GRACE_MS);
+    timer.unref?.();
+    entry.child.once('close', () => clearTimeout(timer));
+}
+function cancelAllClaude() {
+    for (const runId of [...running.keys()])
+        cancelClaude(runId);
+}
+/** For the Settings screen: is the command there, and does it run? */
+async function claudeStatus(enabled, find = () => findClaude(), run = command => new Promise((resolve, reject) => (0, child_process_1.execFile)(command, ['--version'], { timeout: 10_000 }, (err, stdout) => (err ? reject(err) : resolve(stdout))))) {
+    const command = find();
+    if (!command)
+        return { enabled, command: null, version: null, problem: NOT_FOUND };
+    try {
+        return { enabled, command, version: (await run(command)).trim() || null, problem: null };
+    }
+    catch (err) {
+        return {
+            enabled,
+            command,
+            version: null,
+            problem: `The command was found but did not run: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+}
+//# sourceMappingURL=claude.js.map

package/dist/electron/image.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_SIDE = void 0;
+exports.fitToBounds = fitToBounds;
+exports.toImageResult = toImageResult;
+const electron_1 = require("electron");
+// Pictures an agent is shown (a screenshot of the screen or of a page). A 4K screen is several
+// megabytes as PNG and far more than a model can use, so they are scaled down before they leave.
+/** The longest side, in pixels: what Anthropic recommends, larger images are scaled down by the API anyway. */
+exports.MAX_SIDE = 1568;
+/** The PNG, scaled down (never up) so that neither side is longer than `maxSide`. */
+function fitToBounds(png, maxSide = exports.MAX_SIDE) {
+    const image = electron_1.nativeImage.createFromBuffer(png);
+    if (image.isEmpty())
+        throw new Error('The picture could not be read');
+    const { width, height } = image.getSize();
+    const scale = Math.min(1, maxSide / Math.max(width, height));
+    if (scale === 1)
+        return png;
+    return image
+        .resize({ width: Math.max(1, Math.round(width * scale)), height: Math.max(1, Math.round(height * scale)), quality: 'best' })
+        .toPNG();
+}
+function toImageResult(png) {
+    return { kind: 'image', mediaType: 'image/png', data: fitToBounds(png).toString('base64') };
+}
+//# sourceMappingURL=image.js.map

package/dist/electron/main.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const electron_1 = require("electron");
+const path_1 = __importDefault(require("path"));
+const filesystem_js_1 = require("./capabilities/filesystem.js");
+const screen_js_1 = require("./capabilities/screen.js");
+const browser_window_js_1 = require("./browser-window.js");
+const claude_js_1 = require("./claude.js");
+const settings_js_1 = require("./settings.js");
+const isDev = process.env['NODE_ENV'] !== 'production';
+function createWindow() {
+    const win = new electron_1.BrowserWindow({
+        width: 1180,
+        height: 780,
+        minWidth: 860,
+        minHeight: 560,
+        resizable: true,
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+            preload: path_1.default.join(__dirname, 'preload.js'),
+        },
+        title: 'KAI',
+    });
+    if (isDev) {
+        win.loadURL('http://localhost:5173');
+    }
+    else {
+        win.loadFile(path_1.default.join(__dirname, '../renderer/index.html'));
+    }
+    return win;
+}
+electron_1.app.whenReady().then(() => {
+    createWindow();
+    electron_1.app.on('activate', () => {
+        if (electron_1.BrowserWindow.getAllWindows().length === 0)
+            createWindow();
+    });
+});
+electron_1.app.on('window-all-closed', () => {
+    if (process.platform !== 'darwin')
+        electron_1.app.quit();
+});
+// IPC arguments come from the renderer, so check their shape before use.
+// Folder access is read from the user's saved settings here; the renderer never supplies it.
+function asString(v, name) {
+    if (typeof v !== 'string')
+        throw new Error(`${name} must be a string`);
+    return v;
+}
+// Filesystem IPC handlers
+electron_1.ipcMain.handle('filesystem:list', async (_e, p) => (0, filesystem_js_1.listFiles)(asString(p, 'path'), (0, settings_js_1.getFolders)()));
+electron_1.ipcMain.handle('filesystem:read', async (_e, p) => (0, filesystem_js_1.readFile)(asString(p, 'path'), (0, settings_js_1.getFolders)()));
+electron_1.ipcMain.handle('filesystem:write', async (_e, p, content) => (0, filesystem_js_1.writeFile)(asString(p, 'path'), asString(content, 'content'), (0, settings_js_1.getFolders)()));
+// Settings IPC handlers (file permissions)
+electron_1.ipcMain.handle('settings:getFolders', async () => (0, settings_js_1.getFolders)());
+electron_1.ipcMain.handle('settings:addFolder', async (e) => (0, settings_js_1.addFolder)(electron_1.BrowserWindow.fromWebContents(e.sender)));
+electron_1.ipcMain.handle('settings:removeFolder', async (_e, p) => (0, settings_js_1.removeFolder)(asString(p, 'path')));
+electron_1.ipcMain.handle('settings:setAccess', async (_e, p, access) => {
+    if (access !== 'read' && access !== 'readwrite')
+        throw new Error('invalid access level');
+    return (0, settings_js_1.setAccess)(asString(p, 'path'), access);
+});
+// Claude Code: the server asks this app to run the CLI for an agent (see claude.ts for the checks)
+electron_1.ipcMain.handle('claude:status', async () => (0, claude_js_1.claudeStatus)((0, settings_js_1.getClaudeCodeEnabled)()));
+electron_1.ipcMain.handle('claude:setEnabled', async (_e, enabled) => {
+    if (typeof enabled !== 'boolean')
+        throw new Error('enabled must be true or false');
+    return (0, settings_js_1.setClaudeCodeEnabled)(enabled);
+});
+electron_1.ipcMain.handle('claude:run', async (e, request) => {
+    const sender = e.sender;
+    // Nobody is left to read what the CLI does once the window is gone.
+    const onGone = () => (0, claude_js_1.cancelAllClaude)();
+    sender.once('destroyed', onGone);
+    try {
+        await (0, claude_js_1.runClaude)(request, {
+            enabled: settings_js_1.getClaudeCodeEnabled,
+            folders: settings_js_1.getFolders,
+            emit: event => {
+                if (!sender.isDestroyed())
+                    sender.send('claude:event', event);
+            },
+        });
+    }
+    finally {
+        sender.removeListener('destroyed', onGone);
+    }
+});
+electron_1.ipcMain.handle('claude:cancel', async (_e, runId) => {
+    if (typeof runId === 'string')
+        (0, claude_js_1.cancelClaude)(runId);
+});
+electron_1.ipcMain.handle('claude:cancelAll', async () => (0, claude_js_1.cancelAllClaude)());
+// Screen IPC handler
+electron_1.ipcMain.handle('screen:capture', async () => (0, screen_js_1.captureScreen)());
+// Browser IPC handlers: the controller checks the tool and its arguments itself, and refuses
+// everything while the person has not turned the browser on in Settings.
+electron_1.ipcMain.handle('browser:run', async (_e, tool, args) => browser_window_js_1.browser.run(tool, args));
+electron_1.ipcMain.handle('settings:getBrowserEnabled', async () => (0, settings_js_1.getBrowserEnabled)());
+electron_1.ipcMain.handle('settings:setBrowserEnabled', async (_e, enabled) => {
+    const on = enabled === true;
+    if (!on)
+        browser_window_js_1.browser.shutdown();
+    return (0, settings_js_1.setBrowserEnabled)(on);
+});
+electron_1.app.on('before-quit', () => browser_window_js_1.browser.shutdown());
+// Secure storage IPC handlers
+electron_1.ipcMain.handle('storage:encrypt', async (_e, val) => {
+    if (electron_1.safeStorage.isEncryptionAvailable()) {
+        return electron_1.safeStorage.encryptString(val).toString('base64');
+    }
+    return val;
+});
+electron_1.ipcMain.handle('storage:decrypt', async (_e, val) => {
+    if (electron_1.safeStorage.isEncryptionAvailable()) {
+        return electron_1.safeStorage.decryptString(Buffer.from(val, 'base64'));
+    }
+    return val;
+});
+//# sourceMappingURL=main.js.map

package/dist/electron/preload.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const electron_1 = require("electron");
+electron_1.contextBridge.exposeInMainWorld('kai', {
+    filesystem: {
+        list: (p) => electron_1.ipcRenderer.invoke('filesystem:list', p),
+        read: (p) => electron_1.ipcRenderer.invoke('filesystem:read', p),
+        write: (p, content) => electron_1.ipcRenderer.invoke('filesystem:write', p, content),
+    },
+    settings: {
+        getFolders: () => electron_1.ipcRenderer.invoke('settings:getFolders'),
+        addFolder: () => electron_1.ipcRenderer.invoke('settings:addFolder'),
+        removeFolder: (p) => electron_1.ipcRenderer.invoke('settings:removeFolder', p),
+        setAccess: (p, access) => electron_1.ipcRenderer.invoke('settings:setAccess', p, access),
+    },
+    screen: {
+        capture: () => electron_1.ipcRenderer.invoke('screen:capture'),
+    },
+    browser: {
+        run: (tool, args) => electron_1.ipcRenderer.invoke('browser:run', tool, args),
+        getEnabled: () => electron_1.ipcRenderer.invoke('settings:getBrowserEnabled'),
+        setEnabled: (enabled) => electron_1.ipcRenderer.invoke('settings:setBrowserEnabled', enabled),
+    },
+    claude: {
+        status: () => electron_1.ipcRenderer.invoke('claude:status'),
+        setEnabled: (enabled) => electron_1.ipcRenderer.invoke('claude:setEnabled', enabled),
+        run: (request) => electron_1.ipcRenderer.invoke('claude:run', request),
+        cancel: (runId) => electron_1.ipcRenderer.invoke('claude:cancel', runId),
+        cancelAll: () => electron_1.ipcRenderer.invoke('claude:cancelAll'),
+        onEvent: (callback) => {
+            const listener = (_e, event) => callback(event);
+            electron_1.ipcRenderer.on('claude:event', listener);
+            return () => {
+                electron_1.ipcRenderer.removeListener('claude:event', listener);
+            };
+        },
+    },
+    storage: {
+        encrypt: (val) => electron_1.ipcRenderer.invoke('storage:encrypt', val),
+        decrypt: (val) => electron_1.ipcRenderer.invoke('storage:decrypt', val),
+    },
+});
+//# sourceMappingURL=preload.js.map