@cjhyy/code-shell-core 0.5.0-rc.0

package/dist/logging/sanitize-messages.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Strip image base64 payloads out of messages before they reach any log or
+ * persisted record.
+ *
+ * Transcripts (`<storage>/sessions/<sid>/transcript.jsonl`) still hold the
+ * full base64 — replay needs the bytes intact. Logs (`~/.code-shell/logs/`
+ * and `<repo>/log/`) do not. A 10 MB base64 string showing up in a daily
+ * log file would (a) bloat disk usage by orders of magnitude, (b) make
+ * `tail`/`less` unusable, and (c) leak sensitive image content into a
+ * file the user does not expect to be a content store.
+ *
+ * The sanitizer replaces every `{type:"image", source:{...base64...}}`
+ * block with a metadata-only stub of the form
+ * `{type:"image", source:{type:"base64", media_type, bytes, omitted:true}}`
+ * — preserving enough structure that a developer reading the log can see
+ * "yes, an image was here, type X, N bytes" without seeing the bytes
+ * themselves. Same idea for the OpenAI-compat `image_url` shape some
+ * downstream serializers may produce.
+ *
+ * Pure / no I/O. Allocates only when an image block actually exists, so
+ * pure-text turns pay essentially nothing on the fast path.
+ */
+import type { Message } from "../types.js";
+/**
+ * Walk a single message's content and replace image-payload blocks with
+ * metadata stubs. Returns a new value — the input is not mutated.
+ */
+export declare function sanitizeContent(content: Message["content"]): Message["content"];
+/**
+ * Walk a {@link Message}[] array and sanitize every entry's content.
+ * Returns the *same* array reference when no message held an image (fast
+ * path for the overwhelmingly common pure-text case).
+ */
+export declare function sanitizeMessages(messages: readonly Message[]): Message[];
+/**
+ * Sanitize a free-form task string before logging.
+ *
+ * The desktop encoder embeds images as `<codeshell-image>` blocks holding
+ * `data:…;base64,<payload>` URLs. Strip those URLs but keep the wrapper
+ * so a reader can see "an image was attached here".
+ */
+export declare function sanitizeTaskString(task: string): string;

package/dist/logging/sanitize-messages.js

@@ -0,0 +1,150 @@
+/**
+ * Strip image base64 payloads out of messages before they reach any log or
+ * persisted record.
+ *
+ * Transcripts (`<storage>/sessions/<sid>/transcript.jsonl`) still hold the
+ * full base64 — replay needs the bytes intact. Logs (`~/.code-shell/logs/`
+ * and `<repo>/log/`) do not. A 10 MB base64 string showing up in a daily
+ * log file would (a) bloat disk usage by orders of magnitude, (b) make
+ * `tail`/`less` unusable, and (c) leak sensitive image content into a
+ * file the user does not expect to be a content store.
+ *
+ * The sanitizer replaces every `{type:"image", source:{...base64...}}`
+ * block with a metadata-only stub of the form
+ * `{type:"image", source:{type:"base64", media_type, bytes, omitted:true}}`
+ * — preserving enough structure that a developer reading the log can see
+ * "yes, an image was here, type X, N bytes" without seeing the bytes
+ * themselves. Same idea for the OpenAI-compat `image_url` shape some
+ * downstream serializers may produce.
+ *
+ * Pure / no I/O. Allocates only when an image block actually exists, so
+ * pure-text turns pay essentially nothing on the fast path.
+ */
+/** Marker length below which we don't bother sanitizing — short URLs aren't base64. */
+const BASE64_MIN_BYTES = 64;
+/**
+ * Returns true iff this content block carries a real image payload that we
+ * should redact. Inline text/tool_use/tool_result blocks pass through.
+ */
+function isImageBlock(block) {
+    if (!block || typeof block !== "object")
+        return false;
+    const b = block;
+    if (b.type !== "image")
+        return false;
+    const src = b.source;
+    if (!src || src.type !== "base64")
+        return false;
+    return typeof src.data === "string" && src.data.length >= BASE64_MIN_BYTES;
+}
+/**
+ * Returns true if this is the OpenAI-compat `image_url` part with a data
+ * URL embedded inline.
+ */
+function isImageUrlPart(part) {
+    if (!part || typeof part !== "object")
+        return false;
+    const p = part;
+    if (p.type !== "image_url")
+        return false;
+    const iu = p.image_url;
+    if (!iu || typeof iu.url !== "string")
+        return false;
+    return iu.url.startsWith("data:") && iu.url.length >= BASE64_MIN_BYTES;
+}
+function sanitizeImageBlock(block) {
+    const src = block.source;
+    return {
+        type: "image",
+        source: {
+            type: "base64",
+            media_type: src.media_type,
+            bytes: src.data.length,
+            omitted: true,
+        },
+    };
+}
+function sanitizeImageUrlPart(part) {
+    // Best-effort byte count off the data URL. We don't decode — just report
+    // payload length so the reader knows the scale.
+    const url = part.image_url.url;
+    const comma = url.indexOf(",");
+    const payloadLen = comma === -1 ? 0 : url.length - comma - 1;
+    return {
+        type: "image_url",
+        image_url: {
+            // Keep the data-URL header so reviewers can see the MIME, but strip
+            // the payload. "data:image/png;base64,<omitted, 12345 bytes>"
+            url: comma === -1
+                ? url
+                : `${url.slice(0, comma + 1)}<omitted, ${payloadLen} bytes>`,
+            omitted: true,
+            bytes: payloadLen,
+        },
+    };
+}
+/**
+ * Walk a single message's content and replace image-payload blocks with
+ * metadata stubs. Returns a new value — the input is not mutated.
+ */
+export function sanitizeContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return content;
+    let touched = false;
+    const out = [];
+    for (const block of content) {
+        if (isImageBlock(block)) {
+            out.push(sanitizeImageBlock(block));
+            touched = true;
+            continue;
+        }
+        if (isImageUrlPart(block)) {
+            out.push(sanitizeImageUrlPart(block));
+            touched = true;
+            continue;
+        }
+        out.push(block);
+    }
+    return (touched ? out : content);
+}
+/**
+ * Walk a {@link Message}[] array and sanitize every entry's content.
+ * Returns the *same* array reference when no message held an image (fast
+ * path for the overwhelmingly common pure-text case).
+ */
+export function sanitizeMessages(messages) {
+    let touched = false;
+    const out = [];
+    for (const m of messages) {
+        const sanitized = sanitizeContent(m.content);
+        if (sanitized !== m.content) {
+            touched = true;
+            out.push({ ...m, content: sanitized });
+        }
+        else {
+            out.push(m);
+        }
+    }
+    return touched ? out : messages;
+}
+/**
+ * Sanitize a free-form task string before logging.
+ *
+ * The desktop encoder embeds images as `<codeshell-image>` blocks holding
+ * `data:…;base64,<payload>` URLs. Strip those URLs but keep the wrapper
+ * so a reader can see "an image was attached here".
+ */
+export function sanitizeTaskString(task) {
+    if (typeof task !== "string" || task.indexOf("<codeshell-image") === -1) {
+        return task;
+    }
+    return task.replace(/(<codeshell-image\b[^>]*>)([\s\S]*?)(<\/codeshell-image>)/g, (_full, open, body, close) => {
+        const trimmed = body.trim();
+        const comma = trimmed.indexOf(",");
+        const bytes = comma === -1 ? trimmed.length : trimmed.length - comma - 1;
+        const header = comma === -1 ? "" : trimmed.slice(0, comma + 1);
+        return `${open}${header}<omitted, ${bytes} bytes>${close}`;
+    });
+}

package/dist/logging/session-recorder.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Per-session verbose recorder for local-dev runs.
+ *
+ * Layout (per day, split by bucket):
+ *   <repo>/log/<YYYY-MM-DD>/engine/session-<sid>.jsonl
+ *     — unified timeline: LLM, tools, session events, AND UI events
+ *       (UI events are dual-written so this file is the full story.)
+ *   <repo>/log/<YYYY-MM-DD>/ui/session-<sid>.jsonl
+ *     — UI-only events (stream events received, ctx renders, chatStore
+ *       mutations). Open when chasing a display bug.
+ *
+ * Same sid → same filename in both folders. Diff/merge by sid to align
+ * "what the model said" with "what the UI did about it."
+ *
+ * Why a separate sink from logger.ts?
+ *   - logger.ts is the terse process-wide log (~/.code-shell/logs/) and stays
+ *     small for production observability.
+ *   - This sink keeps full prompt/response bodies for post-mortem debugging
+ *     and is gated to local-dev only (bun run dev / CODE_SHELL_DEV=1).
+ *
+ * Why JSONL not markdown?
+ *   - `jq` can slice on any field in one command: tool histograms, slowest
+ *     LLM calls, largest prompts, anything. Markdown would need ad-hoc parsing.
+ *   - Field bodies are inlined; JSON.stringify handles arbitrarily long
+ *     strings and jq streams, so no sidecar files are needed.
+ *
+ * Daily rotation: on first write each process, prune date folders older than
+ * RETENTION_DAYS.
+ */
+export declare function isVerboseRecorderEnabled(): boolean;
+export declare function getVerboseLogDir(): string;
+export declare function recordSessionStart(sid: string, info: {
+    task?: string;
+    cwd?: string;
+    model?: string;
+    provider?: string;
+    permissionMode?: string;
+    resumed?: boolean;
+}): void;
+export type RecordLLMRequest = {
+    provider: string;
+    model: string;
+    stream: boolean;
+    temperature?: number;
+    maxTokens?: number;
+    messages: unknown;
+    tools?: unknown;
+    systemPrompt?: string;
+};
+export declare function recordLLMRequest(sid: string, req: RecordLLMRequest, reqId: string): void;
+export type RecordLLMResponse = {
+    text?: string;
+    toolCalls?: Array<{
+        id: string;
+        toolName: string;
+        args: unknown;
+    }>;
+    stopReason?: string;
+    usage?: import("../types.js").TokenUsage;
+    durationMs?: number;
+    ttftMs?: number;
+};
+export declare function recordLLMResponse(sid: string, resp: RecordLLMResponse, reqId: string): void;
+export declare function recordLLMError(sid: string, reqId: string, err: unknown, durationMs: number): void;
+export declare function recordToolCall(sid: string, call: {
+    id: string;
+    toolName: string;
+    args: unknown;
+}): void;
+export declare function recordToolResult(sid: string, result: {
+    id: string;
+    toolName: string;
+    ok: boolean;
+    durationMs: number;
+    output?: string;
+    error?: string;
+}): void;
+export declare function recordEvent(sid: string, name: string, data?: Record<string, unknown>): void;
+/**
+ * Record a UI-side event. Goes into both engine.jsonl (unified timeline) and
+ * ui.jsonl (focused view). Use from the UI when chasing display bugs — pass
+ * the current sessionId.
+ */
+export declare function recordUIEvent(sid: string | undefined, name: string, data?: Record<string, unknown>): void;
+export declare function recordSessionEnd(sid: string, info: {
+    reason?: string;
+    turns?: number;
+    cost?: unknown;
+    durationMs?: number;
+}): void;

package/dist/logging/session-recorder.js

@@ -0,0 +1,304 @@
+/**
+ * Per-session verbose recorder for local-dev runs.
+ *
+ * Layout (per day, split by bucket):
+ *   <repo>/log/<YYYY-MM-DD>/engine/session-<sid>.jsonl
+ *     — unified timeline: LLM, tools, session events, AND UI events
+ *       (UI events are dual-written so this file is the full story.)
+ *   <repo>/log/<YYYY-MM-DD>/ui/session-<sid>.jsonl
+ *     — UI-only events (stream events received, ctx renders, chatStore
+ *       mutations). Open when chasing a display bug.
+ *
+ * Same sid → same filename in both folders. Diff/merge by sid to align
+ * "what the model said" with "what the UI did about it."
+ *
+ * Why a separate sink from logger.ts?
+ *   - logger.ts is the terse process-wide log (~/.code-shell/logs/) and stays
+ *     small for production observability.
+ *   - This sink keeps full prompt/response bodies for post-mortem debugging
+ *     and is gated to local-dev only (bun run dev / CODE_SHELL_DEV=1).
+ *
+ * Why JSONL not markdown?
+ *   - `jq` can slice on any field in one command: tool histograms, slowest
+ *     LLM calls, largest prompts, anything. Markdown would need ad-hoc parsing.
+ *   - Field bodies are inlined; JSON.stringify handles arbitrarily long
+ *     strings and jq streams, so no sidecar files are needed.
+ *
+ * Daily rotation: on first write each process, prune date folders older than
+ * RETENTION_DAYS.
+ */
+import { appendFileSync, existsSync, mkdirSync, readdirSync, rmSync, statSync, } from "node:fs";
+import { join } from "node:path";
+const RETENTION_DAYS = 7;
+// Per-record cap on the inlined tool output/error blob. The recorder is dev
+// only, but a stray CODE_SHELL_DEV=1 plus a Read of a large file would write
+// the whole file body to disk every run; this caps it.
+const MAX_RECORD_BYTES = 256 * 1024;
+function clip(s) {
+    if (s === undefined)
+        return undefined;
+    if (s.length <= MAX_RECORD_BYTES)
+        return s;
+    return s.slice(0, MAX_RECORD_BYTES) + `\n…(truncated, ${s.length - MAX_RECORD_BYTES} more bytes)`;
+}
+function isLocalDev() {
+    if (process.env.CODE_SHELL_VERBOSE_LOG === "0")
+        return false;
+    if (process.env.CODE_SHELL_DEV === "1")
+        return true;
+    if (process.argv.includes("--debug") || process.argv.includes("-d"))
+        return true;
+    if (process.argv.some((a) => a.startsWith("--debug=")))
+        return true;
+    if (process.env.NODE_ENV === "test" || process.env.BUN_TEST === "1")
+        return false;
+    const entry = process.argv[1] ?? "";
+    if (entry.includes(`${"/"}src${"/"}`))
+        return true;
+    return false;
+}
+const ENABLED = isLocalDev();
+// Anchor the log dir at the repo root. We can't trust process.cwd() because
+// the CLI may run from any subdirectory; instead walk up from this source
+// file looking for package.json. In a published install this file is under
+// dist/, which is fine — the recorder is only enabled in dev anyway.
+function resolveLogDir() {
+    let dir = new URL(".", import.meta.url).pathname;
+    if (dir.endsWith("/"))
+        dir = dir.slice(0, -1);
+    for (let i = 0; i < 8; i++) {
+        if (existsSync(join(dir, "package.json")))
+            return join(dir, "log");
+        const parent = join(dir, "..");
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return join(process.cwd(), "log");
+}
+const LOG_ROOT = ENABLED ? resolveLogDir() : "";
+// Strip secret-bearing flags before persisting argv. Covers both
+// `--flag value` and `--flag=value` shapes; case-insensitive match on
+// the flag name only (values are never inspected).
+const SENSITIVE_FLAG_RE = /^--?(api[-_]?key|auth[-_]?token|token|password|secret|bearer)(=|$)/i;
+function redactArgv(argv) {
+    const out = [];
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i] ?? "";
+        const m = SENSITIVE_FLAG_RE.exec(a);
+        if (!m) {
+            out.push(a);
+            continue;
+        }
+        if (m[2] === "=") {
+            out.push(`${a.slice(0, a.indexOf("=") + 1)}<redacted>`);
+        }
+        else {
+            out.push(a);
+            if (i + 1 < argv.length) {
+                out.push("<redacted>");
+                i += 1;
+            }
+        }
+    }
+    return out;
+}
+const states = new Map();
+let rotated = false;
+function todayStr() {
+    return new Date().toISOString().slice(0, 10);
+}
+function rotateOnce() {
+    if (rotated || !ENABLED)
+        return;
+    rotated = true;
+    try {
+        if (!existsSync(LOG_ROOT))
+            return;
+        const cutoff = Date.now() - RETENTION_DAYS * 24 * 60 * 60 * 1000;
+        for (const entry of readdirSync(LOG_ROOT)) {
+            const full = join(LOG_ROOT, entry);
+            try {
+                const st = statSync(full);
+                if (st.isDirectory() && st.mtimeMs < cutoff) {
+                    rmSync(full, { recursive: true, force: true });
+                }
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
+    catch {
+        /* best-effort */
+    }
+}
+function ensureState(sid) {
+    if (!ENABLED)
+        return null;
+    rotateOnce();
+    let st = states.get(sid);
+    if (st)
+        return st;
+    const dateStr = todayStr();
+    const dayDir = join(LOG_ROOT, dateStr);
+    const engineDir = join(dayDir, "engine");
+    const uiDir = join(dayDir, "ui");
+    const fileName = `session-${sid}.jsonl`;
+    try {
+        if (!existsSync(engineDir))
+            mkdirSync(engineDir, { recursive: true });
+        if (!existsSync(uiDir))
+            mkdirSync(uiDir, { recursive: true });
+    }
+    catch {
+        return null;
+    }
+    st = {
+        dir: dayDir,
+        engineFile: join(engineDir, fileName),
+        uiFile: join(uiDir, fileName),
+        startedAt: Date.now(),
+    };
+    states.set(sid, st);
+    return st;
+}
+function write(sid, bucket, event) {
+    const st = ensureState(sid);
+    if (!st)
+        return;
+    const record = { t: new Date().toISOString(), sid, ...event };
+    const line = JSON.stringify(record) + "\n";
+    try {
+        // Engine file is the unified timeline — every event lands here so a
+        // single `cat engine.jsonl` shows the complete story.
+        appendFileSync(st.engineFile, line, "utf-8");
+        // UI bucket also gets its own focused file for display-bug debugging
+        // without engine noise.
+        if (bucket === "ui") {
+            appendFileSync(st.uiFile, line, "utf-8");
+        }
+    }
+    catch {
+        /* best-effort */
+    }
+}
+// ─── Public API ────────────────────────────────────────────────────
+export function isVerboseRecorderEnabled() {
+    return ENABLED;
+}
+export function getVerboseLogDir() {
+    return LOG_ROOT;
+}
+export function recordSessionStart(sid, info) {
+    if (!ENABLED)
+        return;
+    write(sid, "engine", {
+        type: "session_start",
+        pid: process.pid,
+        argv: redactArgv(process.argv.slice(1)),
+        cwd: info.cwd,
+        model: info.model,
+        provider: info.provider,
+        permissionMode: info.permissionMode,
+        resumed: info.resumed,
+        task: info.task,
+    });
+}
+export function recordLLMRequest(sid, req, reqId) {
+    if (!ENABLED)
+        return;
+    write(sid, "engine", {
+        type: "llm.request",
+        reqId,
+        provider: req.provider,
+        model: req.model,
+        stream: req.stream,
+        temperature: req.temperature,
+        maxTokens: req.maxTokens,
+        toolCount: Array.isArray(req.tools) ? req.tools.length : 0,
+        messageCount: Array.isArray(req.messages) ? req.messages.length : undefined,
+        systemPrompt: req.systemPrompt,
+        tools: req.tools,
+        messages: req.messages,
+    });
+}
+export function recordLLMResponse(sid, resp, reqId) {
+    if (!ENABLED)
+        return;
+    write(sid, "engine", {
+        type: "llm.response",
+        reqId,
+        stopReason: resp.stopReason,
+        durationMs: resp.durationMs,
+        ttftMs: resp.ttftMs,
+        usage: resp.usage,
+        toolCallCount: resp.toolCalls?.length ?? 0,
+        text: resp.text,
+        toolCalls: resp.toolCalls,
+    });
+}
+export function recordLLMError(sid, reqId, err, durationMs) {
+    if (!ENABLED)
+        return;
+    write(sid, "engine", {
+        type: "llm.error",
+        reqId,
+        durationMs,
+        message: err instanceof Error ? err.message : String(err),
+        stack: err instanceof Error ? err.stack : undefined,
+    });
+}
+export function recordToolCall(sid, call) {
+    if (!ENABLED)
+        return;
+    write(sid, "engine", {
+        type: "tool.call",
+        toolCallId: call.id,
+        toolName: call.toolName,
+        args: call.args,
+    });
+}
+export function recordToolResult(sid, result) {
+    if (!ENABLED)
+        return;
+    write(sid, "engine", {
+        type: "tool.result",
+        toolCallId: result.id,
+        toolName: result.toolName,
+        ok: result.ok,
+        durationMs: result.durationMs,
+        chars: (result.output ?? result.error ?? "").length,
+        output: clip(result.output),
+        error: clip(result.error),
+    });
+}
+export function recordEvent(sid, name, data) {
+    if (!ENABLED)
+        return;
+    write(sid, "engine", { type: name, ...(data ?? {}) });
+}
+/**
+ * Record a UI-side event. Goes into both engine.jsonl (unified timeline) and
+ * ui.jsonl (focused view). Use from the UI when chasing display bugs — pass
+ * the current sessionId.
+ */
+export function recordUIEvent(sid, name, data) {
+    if (!ENABLED)
+        return;
+    if (!sid)
+        return;
+    write(sid, "ui", { type: name, ...(data ?? {}) });
+}
+export function recordSessionEnd(sid, info) {
+    if (!ENABLED)
+        return;
+    write(sid, "engine", {
+        type: "session_end",
+        reason: info.reason,
+        turns: info.turns,
+        durationMs: info.durationMs,
+        cost: info.cost,
+    });
+    states.delete(sid);
+}

package/dist/lsp/client.d.ts

@@ -0,0 +1,41 @@
+/**
+ * LSP client — JSON-RPC over stdio communication with language servers.
+ */
+import { EventEmitter } from "node:events";
+export interface LSPRequest {
+    method: string;
+    params?: Record<string, unknown>;
+}
+export interface LSPResponse {
+    id: number;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+    };
+}
+export interface LSPNotification {
+    method: string;
+    params?: Record<string, unknown>;
+}
+export declare class LSPClient extends EventEmitter {
+    private readonly command;
+    private readonly args;
+    private readonly cwd?;
+    private process;
+    private nextId;
+    private pending;
+    private buffer;
+    private contentLength;
+    private initialized;
+    constructor(command: string, args?: string[], cwd?: string | undefined);
+    start(): Promise<void>;
+    initialize(rootUri: string): Promise<unknown>;
+    request(method: string, params?: Record<string, unknown>): Promise<unknown>;
+    notify(method: string, params?: Record<string, unknown>): Promise<void>;
+    shutdown(): Promise<void>;
+    get isInitialized(): boolean;
+    get isAlive(): boolean;
+    private handleData;
+    private rejectAll;
+}