@steerable/agent-shell 0.6.15

package/dist/host/visible-terminal-exec.js

@@ -0,0 +1,151 @@
+/**
+ * 可见 PTY 执行路由（Codex 式"看 agent 打字"）：shell 命令优先打进共享的
+ * 可见终端，多行/heredoc 等 sentinel 抓不住的形态回退 headless。
+ * Electron main 与 BS server 共用；`terminal:reveal` 等事件经注入的
+ * broadcast 出口（Electron 窗口广播 / BS SSE 总线）。
+ */
+import log from 'electron-log';
+import { GUI_LAUNCH_WAIT_MS, getConfiguredExecTimeoutMs, isGuiLaunchCommand, rewriteExeCommandIfNeeded, } from '../local-executor.js';
+/**
+ * Map a raw PTY shell binary name (e.g. `powershell.exe`, `cmd.exe`, `zsh`) to
+ * the {@link LocalExecResult} `shell` enum so the agent sees the *real* dialect
+ * it just ran under and can pick the right syntax next turn.
+ */
+export function mapSessionShell(shell) {
+    const s = (shell || '').toLowerCase();
+    if (s.includes('powershell') || s.includes('pwsh'))
+        return 'powershell';
+    if (s.includes('cmd'))
+        return 'cmd';
+    if (s.includes('wsl'))
+        return 'wsl';
+    if (s.includes('bash'))
+        return 'bash';
+    if (s.includes('zsh'))
+        return 'zsh';
+    return process.platform === 'win32' ? 'powershell' : 'zsh';
+}
+/**
+ * Decide whether to route a shell command through the visible PTY instead of
+ * the headless local-executor. Returns null to fall back headless. No renderer
+ * needs to be attached — the exec sentinel capture runs entirely in this
+ * process.
+ */
+export function createVisibleTerminalExec(deps) {
+    const { localExecutor, terminalManager, broadcast } = deps;
+    return async function maybeExecInTerminal(req) {
+        if (req.command) {
+            req.command = rewriteExeCommandIfNeeded(req.command);
+        }
+        // Multi-line / heredoc commands break the sentinel pattern; fall back to
+        // headless local-executor for those.
+        if (req.command && req.command.includes('\n')) {
+            log.info('[terminal-exec] skip multiline command, fallback headless');
+            return null;
+        }
+        // The visible-terminal path must run the same dangerous-command check as
+        // headless `executeShell` — both paths enforce the same safety policy.
+        if (req.command) {
+            const dangerousReason = localExecutor.detectDangerousCommand(req.command);
+            if (dangerousReason) {
+                log.warn('[terminal-exec] blocked dangerous command', { pattern: dangerousReason });
+                return {
+                    success: false,
+                    error: `Blocked dangerous command: ${dangerousReason}`,
+                    platform: process.platform,
+                };
+            }
+        }
+        // GUI/交互式命令（命令行带 "gui" token——场景应用启动图形图件的
+        // 命令行约定）：没显式 timeout 时只等一小段，到点按"已启动"处理
+        // （见下方 catch）。
+        const guiCommand = isGuiLaunchCommand(req.command || '');
+        let timeoutMs = req.timeout;
+        if (timeoutMs !== undefined) {
+            if (timeoutMs > 0 && timeoutMs < 1000) {
+                timeoutMs *= 1000;
+            }
+        }
+        else if (guiCommand) {
+            timeoutMs = GUI_LAUNCH_WAIT_MS;
+        }
+        else {
+            timeoutMs = getConfiguredExecTimeoutMs() ?? undefined;
+        }
+        const session = terminalManager.ensurePrimary({ cwd: req.cwd });
+        // Codex 式面板自动展开：命令进入可见 PTY 时通知 renderer 打开内嵌终端
+        // 面板。幂等——面板已打开时 renderer 端是 no-op。
+        broadcast('terminal:reveal', { sessionId: session.id });
+        const resolvedShell = mapSessionShell(session.shell);
+        // 项目模式（ToolRouter 会把项目根塞进 req.cwd）：可见 PTY 是共享交互
+        // 会话，已有 session 不会随 ensurePrimary 改目录——显式 cd 过去。
+        const commandForPty = req.cwd
+            ? `cd "${req.cwd.replace(/"/g, '\\"')}" && ${req.command}`
+            : req.command;
+        log.info('[terminal-exec] start', {
+            sessionId: session.id,
+            cwd: req.cwd || session.cwd,
+            shell: resolvedShell,
+            timeout: timeoutMs,
+            commandPreview: (req.command || '').slice(0, 200),
+        });
+        try {
+            // killOnTimeout: a timed-out non-GUI command is SIGINTed so it can't jam
+            // the shared visible terminal for every subsequent exec (GUI launches
+            // keep the "launched, still running" semantics — never killed).
+            const r = await terminalManager.exec(session.id, commandForPty, timeoutMs, !guiCommand);
+            log.info('[terminal-exec] done', {
+                sessionId: session.id,
+                success: r.success,
+                exitCode: r.exitCode,
+                stdoutBytes: (r.stdout || '').length,
+                stderrBytes: (r.stderr || '').length,
+                durationMs: r.durationMs,
+                truncated: r.truncated,
+            });
+            return {
+                success: r.success,
+                stdout: r.stdout,
+                stderr: r.stderr,
+                exitCode: r.exitCode,
+                truncated: r.truncated,
+                shell: resolvedShell,
+                platform: process.platform,
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            // 超时绝不能 fallback headless——那会把同一条命令原样再跑一遍
+            // （GUI/启动类命令会被重复拉起，正是"Qt 图件被启动多次"的根源）。
+            if (message.includes('exec timeout after')) {
+                if (guiCommand) {
+                    log.info('[terminal-exec] gui command still running after wait, treat as launched', {
+                        commandPreview: (req.command || '').slice(0, 120),
+                    });
+                    return {
+                        success: true,
+                        timedOut: true,
+                        stillRunning: true,
+                        stdout: `[GUI 程序已启动，仍在终端中运行（等待 ${timeoutMs}ms 后未退出，进程未被终止）。` +
+                            `请在打开的界面中继续操作；不要重新执行同一条启动命令。]`,
+                        stderr: '',
+                        shell: mapSessionShell(session.shell),
+                        platform: process.platform,
+                    };
+                }
+                log.warn('[terminal-exec] timed out, NOT falling back (would re-run command)', message);
+                return {
+                    success: false,
+                    timedOut: true,
+                    error: `Command timed out after ${timeoutMs}ms in the visible terminal (the process may still be running). ` +
+                        `DO NOT blindly re-run the same command — if it launched a GUI/long-running program, ` +
+                        `first check whether it is already running, or re-run with a larger \`timeout\`.`,
+                    shell: mapSessionShell(session.shell),
+                    platform: process.platform,
+                };
+            }
+            log.warn('[terminal-exec] failed, fallback headless', message);
+            return null;
+        }
+    };
+}

package/dist/hosted-web-search.d.ts

@@ -0,0 +1,13 @@
+/**
+ * OpenAI hosted web search using the existing chat credential.
+ *
+ * The sidecar must not hold the chat key under credential-broker mode.
+ * This runs in the Electron host. Providers without hosted search
+ * (GLM, OpenRouter, DeepSeek, Ollama) stay on the Tavily settings key.
+ */
+import type { LlmSettings } from './storage/llm-settings.js';
+export declare function executeHostedWebSearch(query: string, maxResults: number, settings: LlmSettings): Promise<{
+    success: boolean;
+    data?: Record<string, unknown>;
+    error?: string;
+}>;

package/dist/hosted-web-search.js

@@ -0,0 +1,82 @@
+/**
+ * OpenAI hosted web search using the existing chat credential.
+ *
+ * The sidecar must not hold the chat key under credential-broker mode.
+ * This runs in the Electron host. Providers without hosted search
+ * (GLM, OpenRouter, DeepSeek, Ollama) stay on the Tavily settings key.
+ */
+import { hostedSearchAvailable } from './storage/web-search-settings.js';
+export async function executeHostedWebSearch(query, maxResults, settings) {
+    const q = query.trim();
+    if (!q) {
+        return { success: false, error: 'query is empty' };
+    }
+    if (!hostedSearchAvailable(settings.baseUrl)) {
+        return {
+            success: false,
+            error: 'this LLM provider has no hosted web search; set a Tavily key in settings',
+        };
+    }
+    if (!settings.apiKey) {
+        return { success: false, error: 'hosted web search needs the chat API key' };
+    }
+    const base = (settings.baseUrl || 'https://api.openai.com').replace(/\/+$/, '');
+    const url = `${base}/chat/completions`;
+    const cap = Math.min(Math.max(maxResults, 1), 20);
+    let response;
+    try {
+        response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${settings.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                model: settings.model,
+                messages: [{ role: 'user', content: q }],
+                web_search_options: {},
+            }),
+        });
+    }
+    catch (err) {
+        return {
+            success: false,
+            error: `hosted web search request failed: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    if (!response.ok) {
+        const text = await response.text().catch(() => '');
+        return {
+            success: false,
+            error: `hosted web search returned HTTP ${response.status}: ${text.slice(0, 200)}` +
+                (response.status === 400
+                    ? ' — this model may not support hosted search; set a Tavily key'
+                    : ''),
+        };
+    }
+    const payload = (await response.json());
+    const message = payload.choices?.[0]?.message;
+    const hits = [];
+    for (const annotation of message?.annotations ?? []) {
+        const cite = annotation.url_citation;
+        if (cite?.url) {
+            hits.push({
+                title: cite.title || '',
+                url: cite.url,
+                snippet: '',
+            });
+        }
+        if (hits.length >= cap)
+            break;
+    }
+    const snippet = typeof message?.content === 'string' ? message.content : '';
+    return {
+        success: true,
+        data: {
+            query: q,
+            result_count: hits.length,
+            results: hits,
+            snippet: hits.length ? undefined : snippet.slice(0, 2000),
+        },
+    };
+}

package/dist/image-attachment.d.ts

@@ -0,0 +1,39 @@
+import type { LlmImage } from './llm/types.js';
+/** Refuse to read source files larger than this (10 MB). */
+export declare const IMAGE_MAX_SOURCE_BYTES: number;
+/** Downscale so the long edge is at most this many px (matches common vision limits). */
+export declare const IMAGE_MAX_DIMENSION = 1568;
+/** Refuse the encoded payload if it still exceeds this after re-encode (5 MB). */
+export declare const IMAGE_MAX_ENCODED_BYTES: number;
+export interface ImageAttachmentInput {
+    path: string;
+    name?: string;
+}
+export interface ProcessedImageAttachments {
+    images: LlmImage[];
+    /** One line per input describing the outcome, for the model-visible note. */
+    notes: string[];
+}
+export declare function isImagePath(path: string): boolean;
+/**
+ * Validate the wire value (`metadata.images` from the renderer) into a clean
+ * input list. Anything that isn't an object with a non-empty string `path`
+ * is dropped; non-image extensions are dropped here too so a renamed file
+ * can't smuggle arbitrary bytes into the decoder.
+ */
+export declare function parseImageAttachments(value: unknown): ImageAttachmentInput[];
+/**
+ * Pure resize decision, exported for tests: given source dimensions, return
+ * the target dimensions honoring `IMAGE_MAX_DIMENSION` (aspect preserved,
+ * never upscale, never below 1px).
+ */
+export declare function computeTargetSize(width: number, height: number, maxDimension?: number): {
+    width: number;
+    height: number;
+    resized: boolean;
+};
+/**
+ * Process a batch of image attachments. Synchronous: `nativeImage` decode /
+ * resize / encode are all synchronous, and the byte check uses `statSync`.
+ */
+export declare function processImageAttachments(files: ImageAttachmentInput[]): ProcessedImageAttachments;

package/dist/image-attachment.js

@@ -0,0 +1,133 @@
+/**
+ * W6-3: turn an attached image file into a base64 `LlmImage` the model can
+ * actually see, replacing the old behavior of dropping only the file *path*
+ * into the prompt text.
+ *
+ * Runs in the Electron main process and uses `nativeImage` to decode /
+ * downscale — no native dependency, works in the packaged app. Two caps are
+ * enforced before the image ever reaches the model:
+ *
+ *   - source bytes  (`IMAGE_MAX_SOURCE_BYTES`) — refuse to read huge files;
+ *   - long-edge px  (`IMAGE_MAX_DIMENSION`)    — downscale so the provider's
+ *     vision input limit and our token budget aren't blown by a 4K screenshot;
+ *   - encoded bytes (`IMAGE_MAX_ENCODED_BYTES`) — re-encode PNG->JPEG and
+ *     finally refuse if still too large.
+ *
+ * Every decision (attached / resized / skipped + why) is returned as a note
+ * line so the caller can inject it into the model-visible context — the model
+ * should know an image was attached even when it was too large to send.
+ */
+import { getNativeImage } from './runtime.js';
+import { statSync } from 'fs';
+import { basename, extname } from 'path';
+/** Refuse to read source files larger than this (10 MB). */
+export const IMAGE_MAX_SOURCE_BYTES = 10 * 1024 * 1024;
+/** Downscale so the long edge is at most this many px (matches common vision limits). */
+export const IMAGE_MAX_DIMENSION = 1568;
+/** Refuse the encoded payload if it still exceeds this after re-encode (5 MB). */
+export const IMAGE_MAX_ENCODED_BYTES = 5 * 1024 * 1024;
+const IMAGE_EXTENSIONS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp']);
+export function isImagePath(path) {
+    return IMAGE_EXTENSIONS.has(extname(path).toLowerCase());
+}
+/**
+ * Validate the wire value (`metadata.images` from the renderer) into a clean
+ * input list. Anything that isn't an object with a non-empty string `path`
+ * is dropped; non-image extensions are dropped here too so a renamed file
+ * can't smuggle arbitrary bytes into the decoder.
+ */
+export function parseImageAttachments(value) {
+    if (!Array.isArray(value))
+        return [];
+    const out = [];
+    for (const item of value) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const path = item.path;
+        if (typeof path !== 'string' || !path.trim() || !isImagePath(path))
+            continue;
+        const name = item.name;
+        out.push({ path, name: typeof name === 'string' ? name : undefined });
+    }
+    return out;
+}
+/**
+ * Pure resize decision, exported for tests: given source dimensions, return
+ * the target dimensions honoring `IMAGE_MAX_DIMENSION` (aspect preserved,
+ * never upscale, never below 1px).
+ */
+export function computeTargetSize(width, height, maxDimension = IMAGE_MAX_DIMENSION) {
+    if (width <= 0 || height <= 0)
+        return { width: 0, height: 0, resized: false };
+    if (width <= maxDimension && height <= maxDimension) {
+        return { width, height, resized: false };
+    }
+    const scale = Math.min(maxDimension / width, maxDimension / height);
+    return {
+        width: Math.max(1, Math.round(width * scale)),
+        height: Math.max(1, Math.round(height * scale)),
+        resized: true,
+    };
+}
+function formatMb(bytes) {
+    return (bytes / (1024 * 1024)).toFixed(1).replace(/\.0$/, '');
+}
+/**
+ * Process a batch of image attachments. Synchronous: `nativeImage` decode /
+ * resize / encode are all synchronous, and the byte check uses `statSync`.
+ */
+export function processImageAttachments(files) {
+    const images = [];
+    const notes = [];
+    for (const file of files) {
+        const label = file.name || basename(file.path);
+        // Existence + source-size guards run before the decoder so they're
+        // exercisable in a non-Electron (test) host too.
+        let sourceBytes = 0;
+        try {
+            sourceBytes = statSync(file.path).size;
+        }
+        catch {
+            notes.push(`- ${label}：文件不存在或不可读，未附加`);
+            continue;
+        }
+        if (sourceBytes > IMAGE_MAX_SOURCE_BYTES) {
+            notes.push(`- ${label}：源文件 ${formatMb(sourceBytes)}MB 超过 ${formatMb(IMAGE_MAX_SOURCE_BYTES)}MB 上限，未附加`);
+            continue;
+        }
+        const nativeImage = getNativeImage();
+        if (!nativeImage) {
+            // Non-Electron host (BS server, unit tests, headless) — can't decode images.
+            notes.push(`- ${label}：当前运行环境不支持图片解码，未附加`);
+            continue;
+        }
+        const image = nativeImage.createFromPath(file.path);
+        if (image.isEmpty()) {
+            notes.push(`- ${label}：不是可识别的图片，未附加`);
+            continue;
+        }
+        const { width, height } = image.getSize();
+        const target = computeTargetSize(width, height);
+        const rendered = target.resized
+            ? image.resize({ width: target.width, height: target.height, quality: 'good' })
+            : image;
+        // PNG for graphics/screenshots (lossless), JPEG for photos (smaller).
+        const preferJpeg = ['.jpg', '.jpeg'].includes(extname(file.path).toLowerCase());
+        let mediaType = preferJpeg ? 'image/jpeg' : 'image/png';
+        let buffer = preferJpeg ? rendered.toJPEG(85) : rendered.toPNG();
+        if (buffer.length > IMAGE_MAX_ENCODED_BYTES && mediaType !== 'image/jpeg') {
+            mediaType = 'image/jpeg';
+            buffer = rendered.toJPEG(80);
+        }
+        if (buffer.length > IMAGE_MAX_ENCODED_BYTES) {
+            notes.push(`- ${label}：压缩后仍超过 ${formatMb(IMAGE_MAX_ENCODED_BYTES)}MB，未附加`);
+            continue;
+        }
+        images.push({ data: buffer.toString('base64'), mediaType });
+        const sizeText = target.resized
+            ? `${width}×${height}，已缩放至 ${target.width}×${target.height}`
+            : `${width}×${height}`;
+        notes.push(`- ${label}（${sizeText}）`);
+    }
+    return { images, notes };
+}

package/dist/insights/flush.d.ts

@@ -0,0 +1,10 @@
+export declare function insightsNetworkDisabled(): boolean;
+export declare function buildInsightsExportPayload(): Record<string, unknown>;
+export declare function postInsightsJson(url: string, body: unknown): Promise<boolean>;
+export declare function flushInsightsOutbox(): Promise<{
+    uploaded: number;
+    skipped: number;
+    failed: number;
+}>;
+export declare function uploadInsightsBundle(): Promise<boolean>;
+export declare function scheduleInsightsFlush(): void;

package/dist/insights/flush.js

@@ -0,0 +1,139 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { getBrand } from '../brand.js';
+import { resolveInsightsApiBase, rowsEligibleForAutoUpload, } from '../storage/insights-settings.js';
+import { localStore } from '../storage/index.js';
+const FLUSH_TIMEOUT_MS = 8_000;
+const MAX_BATCH = 20;
+export function insightsNetworkDisabled() {
+    return Boolean(process.env.VITEST) || process.env.DEEPPATH_INSIGHTS_DISABLE_UPLOAD === '1';
+}
+let cachedVersion = null;
+/** Packaged Electron has no npm_package_version — read package.json like brand.ts does. */
+function detectAppVersion() {
+    if (cachedVersion)
+        return cachedVersion;
+    const fromEnv = process.env.npm_package_version;
+    if (fromEnv) {
+        cachedVersion = fromEnv;
+        return fromEnv;
+    }
+    try {
+        const here = path.dirname(fileURLToPath(import.meta.url));
+        const pkgPath = path.join(here, '..', '..', 'package.json');
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        if (typeof pkg.version === 'string' && pkg.version) {
+            cachedVersion = pkg.version;
+            return cachedVersion;
+        }
+    }
+    catch {
+        // fall through
+    }
+    cachedVersion = '0.0.0';
+    return cachedVersion;
+}
+function clientMeta(settings) {
+    return {
+        installId: settings.installId,
+        flavor: getBrand().flavor,
+        appVersion: detectAppVersion(),
+    };
+}
+export function buildInsightsExportPayload() {
+    const settings = localStore.ensureInsightsSettings();
+    return {
+        ...localStore.exportInsightsBundle(),
+        ...clientMeta(settings),
+    };
+}
+function ingestHeaders() {
+    const headers = { 'Content-Type': 'application/json' };
+    const token = (process.env.DEEPPATH_INSIGHTS_INGEST_TOKEN || '').trim();
+    // 线协议常量：header 名由遥测接收端（产品注入的 insightsApiBase）定义，
+    // shell 只是按对端契约发送——不属产品硬编码。
+    if (token)
+        headers['X-DeepPath-Insights-Key'] = token; // shell-neutral:allow
+    return headers;
+}
+export async function postInsightsJson(url, body) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), FLUSH_TIMEOUT_MS);
+    try {
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: ingestHeaders(),
+            body: JSON.stringify(body),
+            signal: controller.signal,
+        });
+        return res.ok;
+    }
+    catch (err) {
+        console.warn('[insights] upload failed', err instanceof Error ? err.message : err);
+        return false;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function pathForKind(kind) {
+    if (kind === 'event')
+        return '/api/v2/agent-insights/events';
+    if (kind === 'turn')
+        return '/api/v2/agent-insights/turns';
+    return '/api/v2/agent-insights/profile';
+}
+export async function flushInsightsOutbox() {
+    if (insightsNetworkDisabled()) {
+        return { uploaded: 0, skipped: 0, failed: 0 };
+    }
+    const settings = localStore.ensureInsightsSettings();
+    const pending = localStore.listInsightOutbox({ uploaded: false, limit: MAX_BATCH });
+    const { upload, skipped } = rowsEligibleForAutoUpload(settings, pending);
+    let uploaded = 0;
+    let failed = 0;
+    const base = resolveInsightsApiBase(settings, process.env.DEEPPATH_INSIGHTS_API_BASE);
+    // 无端点（中性 shell 未注入遥测配置）= 不上报，outbox 留本地待导出。
+    if (!base)
+        return { uploaded, skipped, failed };
+    const meta = clientMeta(settings);
+    for (const row of upload) {
+        const ok = await postInsightsJson(`${base}${pathForKind(row.kind)}`, {
+            ...meta,
+            ...row.payload,
+            clientEventId: row.id,
+        });
+        if (ok) {
+            localStore.markInsightUploaded(row.id);
+            uploaded += 1;
+        }
+        else {
+            localStore.markInsightUploadError(row.id, 'upload_failed');
+            failed += 1;
+        }
+    }
+    return { uploaded, skipped, failed };
+}
+export async function uploadInsightsBundle() {
+    if (insightsNetworkDisabled()) {
+        return false;
+    }
+    const settings = localStore.ensureInsightsSettings();
+    const bundle = buildInsightsExportPayload();
+    const base = resolveInsightsApiBase(settings, process.env.DEEPPATH_INSIGHTS_API_BASE);
+    if (!base)
+        return false;
+    const ok = await postInsightsJson(`${base}/api/v2/agent-insights/bundle`, bundle);
+    if (ok) {
+        const records = Array.isArray(bundle.records) ? bundle.records : [];
+        for (const row of records)
+            localStore.markInsightUploaded(row.id);
+    }
+    return ok;
+}
+export function scheduleInsightsFlush() {
+    void flushInsightsOutbox().catch((err) => {
+        console.warn('[insights] flush crashed', err);
+    });
+}

package/dist/insights/record.d.ts

@@ -0,0 +1,17 @@
+export declare function recordInsightEvent(eventName: string, properties?: Record<string, unknown>): void;
+export declare function recordInsightTurn(input: {
+    chatId: string;
+    mode?: string;
+    modelId?: string | null;
+    completionStatus?: string;
+    durationMs?: number | null;
+    toolNames?: unknown;
+    userText?: string;
+    assistantText?: string;
+}): void;
+export declare function recordInsightProfile(profile: {
+    displayName?: string;
+    email?: string;
+    company?: string;
+    note?: string;
+}): void;

package/dist/insights/record.js

@@ -0,0 +1,44 @@
+import { redactInsightText, toolNamesOnly } from '../storage/insights-redact.js';
+import { localStore } from '../storage/index.js';
+import { scheduleInsightsFlush } from './flush.js';
+export function recordInsightEvent(eventName, properties = {}) {
+    try {
+        localStore.enqueueInsight('event', { eventName, properties });
+        scheduleInsightsFlush();
+    }
+    catch (err) {
+        console.warn('[insights] event enqueue failed', err);
+    }
+}
+export function recordInsightTurn(input) {
+    try {
+        localStore.enqueueInsight('turn', {
+            chatId: input.chatId,
+            mode: input.mode === 'plan' ? 'plan' : 'agent',
+            modelId: typeof input.modelId === 'string' ? input.modelId.slice(0, 128) : undefined,
+            completionStatus: input.completionStatus,
+            durationMs: typeof input.durationMs === 'number' ? input.durationMs : undefined,
+            toolNames: toolNamesOnly(input.toolNames),
+            userText: redactInsightText(input.userText, 4000),
+            assistantText: redactInsightText(input.assistantText, 8000),
+        });
+        scheduleInsightsFlush();
+    }
+    catch (err) {
+        console.warn('[insights] turn enqueue failed', err);
+    }
+}
+export function recordInsightProfile(profile) {
+    try {
+        localStore.enqueueInsight('profile', {
+            displayName: redactInsightText(profile.displayName, 128),
+            email: redactInsightText(profile.email, 191),
+            company: redactInsightText(profile.company, 191),
+            note: redactInsightText(profile.note, 500),
+        });
+        scheduleInsightsFlush();
+    }
+    catch (err) {
+        console.warn('[insights] profile enqueue failed', err);
+    }
+}

package/dist/json-store.d.ts

@@ -0,0 +1,9 @@
+export interface JsonStore<T extends Record<string, unknown>> {
+    get<Key extends keyof T>(key: Key): T[Key];
+    get<Key extends keyof T>(key: Key, defaultValue: Required<T>[Key]): Required<T>[Key];
+    set<Key extends keyof T>(key: Key, value?: T[Key]): void;
+}
+export declare function createJsonStore<T extends Record<string, unknown>>(options: {
+    name: string;
+    defaults?: Partial<T>;
+}): JsonStore<T>;

package/dist/json-store.js

@@ -0,0 +1,22 @@
+/**
+ * JSON 键值存储工厂（agent-mcp-servers.json / agent-projects.json / window-state）。
+ *
+ * 历史上用 electron-store；它只在构造时读 `app.getPath('userData')` 当 cwd，
+ * 而 conf（electron-store 的底层，已是本项目直接依赖）API 完全覆盖用到的
+ * get/set + name + defaults 子集。统一走 conf + getUserDataDir()，Electron
+ * 与 BS server 得到同一个文件路径，两种模式共享同一份数据。
+ *
+ * conf@10 的 d.ts 是 ESM 风格但包本身没有 `type: module`，NodeNext 下类型
+ * 解析会塌成 namespace——所以这里声明用到的最小接口并做一次强转，不依赖
+ * 它的声明文件。
+ */
+import ConfImport from 'conf';
+import { getUserDataDir } from './runtime.js';
+const Conf = ConfImport;
+export function createJsonStore(options) {
+    return new Conf({
+        cwd: getUserDataDir(),
+        name: options.name,
+        defaults: options.defaults,
+    });
+}