linkshell-cli 0.9.0 → 0.10.0

package/dist/cli/src/runtime/acp/claude-sdk-client.js

@@ -1,1147 +0,0 @@
-import { homedir } from "node:os";
-import { readdirSync, existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
-import { randomUUID } from "node:crypto";
-import { isAbsolute, join, relative, resolve } from "node:path";
-function id(prefix) {
-    return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-}
-function projectHash(cwd) {
-    return ("-" +
-        resolve(cwd)
-            .replace(/\/$/, "")
-            .replace(/\//g, "-"));
-}
-function claudeProjectDir(cwd) {
-    return join(homedir(), ".claude", "projects", projectHash(cwd));
-}
-function claudeProjectsRoot() {
-    return join(homedir(), ".claude", "projects");
-}
-function claudeProjectDirs(preferredCwd) {
-    const root = claudeProjectsRoot();
-    const preferred = claudeProjectDir(preferredCwd);
-    const dirs = [];
-    if (existsSync(preferred))
-        dirs.push(preferred);
-    if (!existsSync(root))
-        return dirs;
-    try {
-        for (const entry of readdirSync(root)) {
-            const fullPath = join(root, entry);
-            if (fullPath !== preferred && statSync(fullPath).isDirectory()) {
-                dirs.push(fullPath);
-            }
-        }
-    }
-    catch {
-        // Ignore unreadable Claude storage.
-    }
-    return dirs;
-}
-function parseTimestamp(value) {
-    if (typeof value === "number" && Number.isFinite(value)) {
-        return value > 10_000_000_000 ? value : value * 1000;
-    }
-    if (typeof value === "string" && value.trim()) {
-        const parsed = Date.parse(value);
-        return Number.isNaN(parsed) ? undefined : parsed;
-    }
-    return undefined;
-}
-function extractToolResultText(content) {
-    if (typeof content === "string")
-        return content;
-    if (Array.isArray(content)) {
-        return content
-            .map((part) => {
-            if (typeof part === "string")
-                return part;
-            if (part && typeof part === "object" && "text" in part && typeof part.text === "string") {
-                return part.text;
-            }
-            return "";
-        })
-            .join("");
-    }
-    if (content && typeof content === "object" && "text" in content && typeof content.text === "string") {
-        return content.text;
-    }
-    return String(content ?? "");
-}
-function splitImageDataUrl(value, fallbackMimeType = "image/png") {
-    const match = value.match(/^data:([^;,]+)?;base64,(.*)$/is);
-    if (!match)
-        return { data: value, mimeType: fallbackMimeType };
-    return {
-        data: match[2] ?? "",
-        mimeType: match[1] || fallbackMimeType,
-    };
-}
-function toClaudeMessageContent(blocks) {
-    return blocks
-        .map((block) => {
-        if (block.type === "image" && block.data) {
-            const image = splitImageDataUrl(block.data, block.mimeType);
-            return {
-                type: "image",
-                source: {
-                    type: "base64",
-                    media_type: image.mimeType,
-                    data: image.data,
-                },
-            };
-        }
-        return { type: "text", text: block.text ?? "" };
-    })
-        .filter((block) => block.type === "image" ||
-        (typeof block.text === "string" && block.text.trim().length > 0));
-}
-async function* singleUserMessage(content) {
-    yield {
-        type: "user",
-        message: {
-            role: "user",
-            content,
-        },
-        parent_tool_use_id: null,
-    };
-}
-function isRealClaudeSessionId(value) {
-    return Boolean(value && !value.startsWith("agent-session-"));
-}
-function asRecord(value) {
-    return value && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : undefined;
-}
-function stringField(value, keys) {
-    const record = asRecord(value);
-    if (!record)
-        return undefined;
-    for (const key of keys) {
-        const candidate = record[key];
-        if (typeof candidate === "string" && candidate.trim())
-            return candidate;
-    }
-    return undefined;
-}
-function previewText(text) {
-    return text.replace(/\s+/g, " ").trim().slice(0, 160);
-}
-function contentText(value) {
-    if (typeof value === "string")
-        return value;
-    if (!Array.isArray(value))
-        return "";
-    return value
-        .map((entry) => {
-        if (typeof entry === "string")
-            return entry;
-        const raw = asRecord(entry);
-        if (!raw)
-            return "";
-        if (typeof raw.text === "string")
-            return raw.text;
-        if (raw.type === "image")
-            return `[${stringField(raw.source, ["media_type", "mimeType"]) ?? "image"} attachment]`;
-        return "";
-    })
-        .filter(Boolean)
-        .join("\n");
-}
-function claudeToolItemType(toolName) {
-    if (toolName === "Bash")
-        return "commandExecution";
-    if (toolName === "Write" || toolName === "Edit" || toolName === "MultiEdit")
-        return "fileChange";
-    return "toolCall";
-}
-function claudeToolHistoryItem(toolId, toolName, toolInput, cwd) {
-    const filePath = stringField(toolInput, ["file_path", "path", "notebook_path"]);
-    return {
-        id: toolId,
-        type: claudeToolItemType(toolName),
-        toolName: toolName ?? "tool",
-        tool: toolName ?? "tool",
-        input: toolInput,
-        toolInput,
-        command: stringField(toolInput, ["command"]),
-        cwd: stringField(toolInput, ["cwd"]) ?? cwd,
-        path: filePath,
-        status: "running",
-    };
-}
-export function parseClaudeJsonlSession(input) {
-    const turns = [];
-    const toolItems = new Map();
-    let sessionId = input.sessionId;
-    let model;
-    let title;
-    let preview;
-    let createdAt;
-    let updatedAt = input.fallbackUpdatedAt;
-    let cwd = input.cwd;
-    // Last assistant line's token usage. input_tokens at the latest turn is the
-    // current context-window occupancy (NOT a running sum), so we keep the last
-    // one we see rather than accumulating. Decoupled from any live LinkShell turn
-    // — this is read straight from the on-disk transcript.
-    let usage;
-    // Last-seen raw permissionMode ("default" | "acceptEdits" | ...). Claude
-    // records it on user records; the LAST one is the session's current mode.
-    // Captured here so readSessionConfig can be a cache field read instead of a
-    // second full parse of the transcript.
-    let permissionMode;
-    let index = 0;
-    for (const line of input.text.split(/\r?\n/)) {
-        if (!line.trim())
-            continue;
-        index += 1;
-        let raw;
-        try {
-            const parsed = JSON.parse(line);
-            const record = asRecord(parsed);
-            if (!record)
-                continue;
-            raw = record;
-        }
-        catch {
-            continue;
-        }
-        permissionMode = stringField(raw, ["permissionMode"]) ?? permissionMode;
-        const timestamp = parseTimestamp(raw.timestamp ?? raw.createdAt ?? raw.created_at);
-        cwd = stringField(raw, ["cwd", "workingDirectory", "workspacePath"]) ?? cwd;
-        if (timestamp !== undefined) {
-            createdAt = createdAt === undefined ? timestamp : Math.min(createdAt, timestamp);
-            updatedAt = updatedAt === undefined ? timestamp : Math.max(updatedAt, timestamp);
-        }
-        sessionId = sessionId ?? stringField(raw, ["sessionId", "session_id"]);
-        model = model ?? stringField(raw, ["model"]);
-        const message = asRecord(raw.message);
-        model = model ?? stringField(message, ["model"]);
-        const type = stringField(raw, ["type"]);
-        const role = stringField(message, ["role"]) ?? type;
-        const content = message && "content" in message ? message.content : raw.content;
-        const turnId = stringField(raw, ["uuid", "id"]) ?? `claude-history-${index}`;
-        const items = [];
-        if (type === "summary" || typeof raw.summary === "string") {
-            const summary = typeof raw.summary === "string" ? raw.summary : undefined;
-            if (summary) {
-                items.push({
-                    id: turnId,
-                    type: "contextCompaction",
-                    summary,
-                    status: "completed",
-                });
-                preview = previewText(summary) || preview;
-            }
-        }
-        else if (role === "user") {
-            const contentBlocks = Array.isArray(content) ? content : [];
-            const toolResults = contentBlocks
-                .map(asRecord)
-                .filter((block) => Boolean(block && block.type === "tool_result"));
-            const ordinaryText = Array.isArray(content)
-                ? contentText(contentBlocks.filter((block) => asRecord(block)?.type !== "tool_result"))
-                : contentText(content);
-            if (ordinaryText.trim()) {
-                items.push({
-                    id: stringField(message, ["id"]) ?? turnId,
-                    type: "userMessage",
-                    content: [{ type: "text", text: ordinaryText }],
-                });
-                title = title ?? previewText(ordinaryText);
-                preview = previewText(ordinaryText) || preview;
-            }
-            for (const block of toolResults) {
-                const toolId = stringField(block, ["tool_use_id"]) ?? `tool-result-${index}`;
-                const previous = toolItems.get(toolId);
-                const output = extractToolResultText(block.content);
-                items.push({
-                    ...previous,
-                    id: toolId,
-                    type: stringField(previous, ["type"]) ?? "toolCall",
-                    toolName: stringField(previous, ["toolName", "tool", "name"]),
-                    tool: stringField(previous, ["toolName", "tool", "name"]),
-                    status: block.is_error === true ? "failed" : "completed",
-                    output,
-                    aggregatedOutput: output,
-                    isError: block.is_error === true,
-                });
-            }
-        }
-        else if (role === "assistant") {
-            const assistantMessageId = stringField(message, ["id"]) ?? turnId;
-            const lineUsage = asRecord(message?.usage);
-            if (lineUsage)
-                usage = lineUsage;
-            if (typeof content === "string") {
-                if (content.trim()) {
-                    items.push({
-                        id: assistantMessageId,
-                        type: "agentMessage",
-                        content: [{ type: "text", text: content }],
-                        status: "completed",
-                    });
-                    preview = previewText(content) || preview;
-                }
-            }
-            else {
-                const blocks = Array.isArray(content) ? content.map(asRecord).filter((block) => Boolean(block)) : [];
-                const text = contentText(blocks.filter((block) => block.type === "text"));
-                if (text.trim()) {
-                    items.push({
-                        id: assistantMessageId,
-                        type: "agentMessage",
-                        content: [{ type: "text", text }],
-                        status: "completed",
-                    });
-                    preview = previewText(text) || preview;
-                }
-                blocks.forEach((block, blockIndex) => {
-                    if (block.type === "thinking" && typeof block.thinking === "string" && block.thinking.trim()) {
-                        items.push({
-                            id: `${turnId}:thinking:${blockIndex}`,
-                            type: "thinking",
-                            text: block.thinking,
-                            status: "completed",
-                        });
-                    }
-                    else if (block.type === "tool_use") {
-                        const toolId = stringField(block, ["id"]) ?? `${turnId}:tool:${blockIndex}`;
-                        const toolName = stringField(block, ["name"]);
-                        const toolInput = asRecord(block.input);
-                        const item = claudeToolHistoryItem(toolId, toolName, toolInput, cwd);
-                        toolItems.set(toolId, item);
-                        items.push(item);
-                    }
-                });
-            }
-        }
-        else if (type === "system") {
-            model = model ?? stringField(raw, ["model"]);
-        }
-        if (items.length > 0) {
-            turns.push({
-                id: turnId,
-                createdAt: timestamp,
-                items,
-            });
-        }
-    }
-    return {
-        thread: {
-            id: sessionId ?? input.sessionId,
-            sessionId: sessionId ?? input.sessionId,
-            cwd,
-            model,
-            title,
-            preview,
-            createdAt,
-            updatedAt,
-            usage,
-            turns,
-            ...(permissionMode ? { permissionMode } : {}),
-        },
-    };
-}
-/** Derive whether an on-disk Claude transcript is being actively driven RIGHT
- *  NOW by some process (LinkShell or an external `claude` terminal), purely from
- *  the file. Combines a structural signal (the last record) with a freshness
- *  signal (mtime), so it neither misses a live external turn nor sticks at
- *  "running" forever if that process dies mid-turn.
- *
- *  - last record is a completed assistant turn (stop_reason "end_turn") → idle,
- *    regardless of mtime (the turn is definitively done).
- *  - otherwise the structure is mid-turn (awaiting an assistant response, an
- *    assistant still calling tools, or a half-written trailing line). If the
- *    file changed within FRESH_MS, a process is appending → running; if it's
- *    stale, the driver is gone → idle.
- *  Verified against real transcripts: mid-turn+fresh→running, mid-turn+stale→
- *  idle, end_turn+fresh→idle, half-written-line+fresh→running. */
-const TRANSCRIPT_FRESH_MS = 10_000;
-/** The structural half of the status verdict: does the LAST record of a
- *  transcript indicate an in-progress turn (awaiting/producing an assistant
- *  response, or a half-written trailing line)? This is purely content-derived
- *  — it does NOT depend on the clock — so it can be cached alongside the parsed
- *  metadata and reused across syncs until the file's (mtime,size) changes.
- *  Scans backward from the end to avoid split()-ing a possibly-huge transcript. */
-function deriveTranscriptMidTurn(text) {
-    let last;
-    let sawUnparseableTail = false;
-    let end = text.length;
-    while (end > 0) {
-        const nl = text.lastIndexOf("\n", end - 1);
-        const line = text.slice(nl + 1, end).trim();
-        end = nl; // step before this newline; nl === -1 ends the loop (first line)
-        if (!line)
-            continue;
-        try {
-            last = asRecord(JSON.parse(line));
-            break;
-        }
-        catch {
-            // A trailing half-written line means a writer is mid-append.
-            sawUnparseableTail = true;
-        }
-    }
-    if (!last)
-        return false;
-    const message = asRecord(last.message);
-    const role = stringField(message, ["role"]) ?? stringField(last, ["type"]);
-    const stop = message ? message.stop_reason ?? null : null;
-    if (role === "assistant" && stop === "end_turn")
-        return false;
-    return (role === "user" ||
-        last.type === "user" ||
-        (role === "assistant" && (stop === "tool_use" || stop === null)) ||
-        sawUnparseableTail);
-}
-/** Combine the (clock-independent) structural verdict with the freshness signal.
- *  A stale file (no writes within FRESH_MS) is always idle; a mid-turn file that
- *  is still being appended to is running. Cheap: one comparison + one boolean. */
-function statusFromMidTurn(midTurn, mtimeMs, nowMs) {
-    if (nowMs - mtimeMs >= TRANSCRIPT_FRESH_MS)
-        return "idle";
-    return midTurn ? "running" : "idle";
-}
-/** Derive whether an on-disk Claude transcript is being actively driven RIGHT
- *  NOW, purely from the file. See {@link deriveTranscriptMidTurn} /
- *  {@link statusFromMidTurn}; kept as a convenience wrapper for callers that
- *  hold the full text and the clock but no cache. */
-function deriveTranscriptStatus(text, mtimeMs, nowMs) {
-    // Stale short-circuit: most sessions in ~/.claude/projects are old, so avoid
-    // the backward scan entirely when the file can't possibly be running.
-    if (nowMs - mtimeMs >= TRANSCRIPT_FRESH_MS)
-        return "idle";
-    return statusFromMidTurn(deriveTranscriptMidTurn(text), mtimeMs, nowMs);
-}
-/** Parse a transcript into the clock-independent, cacheable half of its list
- *  metadata: everything except `status` (which depends on `now`). The caller
- *  layers status on via {@link statusFromMidTurn}, and can cache this result
- *  keyed by (path, mtime, size) so an unchanged transcript is never re-read. */
-function claudeSessionBaseFromFile(filePath, cwd, sessionId, mtimeMs) {
-    const text = readFileSync(filePath, "utf8");
-    const parsed = parseClaudeJsonlSession({
-        text,
-        cwd,
-        sessionId,
-        fallbackUpdatedAt: mtimeMs,
-    });
-    const thread = asRecord(parsed.thread) ?? {};
-    const base = {
-        id: sessionId,
-        cwd: stringField(thread, ["cwd", "workingDirectory", "workspacePath"]) ?? cwd,
-        title: stringField(thread, ["title", "preview"]),
-        model: stringField(thread, ["model"]),
-        createdAt: parseTimestamp(thread.createdAt),
-        lastActivityAt: parseTimestamp(thread.updatedAt) ?? mtimeMs,
-        lastModified: mtimeMs,
-        usage: asRecord(thread.usage),
-    };
-    return { base, midTurn: deriveTranscriptMidTurn(text) };
-}
-function claudeSessionMetadataFromFile(filePath, cwd, sessionId) {
-    const stat = statSync(filePath);
-    const { base, midTurn } = claudeSessionBaseFromFile(filePath, cwd, sessionId, stat.mtimeMs);
-    // Live status read straight from the transcript, so a session another
-    // `claude` process is actively driving shows as "running" in the list
-    // rather than the hardcoded "idle" the workspace would otherwise assign.
-    return { ...base, status: statusFromMidTurn(midTurn, stat.mtimeMs, Date.now()) };
-}
-function isInsideCwd(cwd, candidate) {
-    const root = resolve(cwd);
-    const target = resolve(root, candidate);
-    const rel = relative(root, target);
-    return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
-}
-function outcomeFromPermissionResponse(value) {
-    const raw = value && typeof value === "object" ? value : {};
-    if (raw.behavior === "allow")
-        return "allow";
-    if (raw.behavior === "deny")
-        return "deny";
-    const outcome = raw.outcome && typeof raw.outcome === "object"
-        ? raw.outcome.outcome
-        : raw.outcome;
-    if (outcome === "selected") {
-        const optionId = raw.outcome && typeof raw.outcome === "object"
-            ? String(raw.outcome.optionId ?? "")
-            : "";
-        return optionId.toLowerCase().includes("allow") ? "allow" : "deny";
-    }
-    return outcome === "allow" ? "allow" : "deny";
-}
-export function claudePermissionModeFor(input) {
-    if (input.collaborationMode === "plan" || input.permissionMode === "read_only")
-        return "plan";
-    if (input.permissionMode === "workspace_write")
-        return "acceptEdits";
-    if (input.permissionMode === "full_access")
-        return "bypassPermissions";
-    return "default";
-}
-const FALLBACK_MODEL_LABELS = {
-    default: "默认模型",
-    sonnet: "Sonnet",
-    opus: "Opus",
-    opusplan: "Opus Plan",
-    haiku: "Haiku",
-    "sonnet[1m]": "Sonnet 1M",
-    "opus[1m]": "Opus 1M",
-};
-// Canonical Claude Code model aliases, used whenever live model discovery
-// (supportedModels()) returns nothing. Hoisted so the two listModels() fallback
-// branches stay in sync — a new alias added here reaches both.
-const DEFAULT_FALLBACK_MODELS = ["default", "sonnet", "opus", "opusplan", "haiku", "sonnet[1m]", "opus[1m]"];
-const toModelEntries = (ids) => ids.map((id) => ({ id, label: FALLBACK_MODEL_LABELS[id] ?? id }));
-export class ClaudeSdkClient {
-    input;
-    query;
-    startup;
-    claudeSessionId;
-    abortController;
-    permissionWaiters = new Map();
-    // Per-file cache for listSessions: an unchanged transcript (same mtime+size)
-    // is never re-read or re-parsed. fs.watch re-syncs fire every ~1.5s while any
-    // session is active, and ~/.claude/projects can hold hundreds of old
-    // transcripts — without this, each sync would readFileSync + fully parse
-    // every one of them (the "scan storm"). Only the file being actively appended
-    // to changes, so the steady-state cost drops to stat()+status per file.
-    sessionMetaCache = new Map();
-    // Full parsed-transcript cache shared by readSession / readSessionConfig /
-    // listTurns, keyed by file path and validated by (mtime,size) like
-    // sessionMetaCache above. Opening a conversation hits all three of those in
-    // quick succession, and every history page re-slices the same parse — on a
-    // 39MB transcript that was ~257ms per open plus ~93ms per scroll page of
-    // redundant readFileSync + per-line JSON.parse. Unlike sessionMetaCache this
-    // holds the FULL turn list (large for big transcripts), so it is bounded to a
-    // small LRU (Map iteration order + delete/re-set on hit = LRU).
-    parsedTranscriptCache = new Map();
-    static PARSED_TRANSCRIPT_CACHE_MAX = 8;
-    /** Read + parse a session transcript through the LRU cache. Returns the
-     *  parseClaudeJsonlSession result (stable for a given (mtime,size)); an
-     *  appended-to or rewritten file re-parses on next access. */
-    parsedTranscript(filePath, sessionId) {
-        const stat = statSync(filePath);
-        const cached = this.parsedTranscriptCache.get(filePath);
-        if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
-            // Refresh recency so the hottest transcripts survive the LRU bound.
-            this.parsedTranscriptCache.delete(filePath);
-            this.parsedTranscriptCache.set(filePath, cached);
-            return cached.parsed;
-        }
-        const parsed = parseClaudeJsonlSession({
-            text: readFileSync(filePath, "utf8"),
-            cwd: this.input.cwd,
-            sessionId,
-            fallbackUpdatedAt: stat.mtimeMs,
-        });
-        this.parsedTranscriptCache.delete(filePath);
-        this.parsedTranscriptCache.set(filePath, { mtimeMs: stat.mtimeMs, size: stat.size, parsed });
-        while (this.parsedTranscriptCache.size > ClaudeSdkClient.PARSED_TRANSCRIPT_CACHE_MAX) {
-            const oldest = this.parsedTranscriptCache.keys().next().value;
-            if (oldest === undefined)
-                break;
-            this.parsedTranscriptCache.delete(oldest);
-        }
-        return parsed;
-    }
-    constructor(input) {
-        this.input = input;
-    }
-    async initialize() {
-        try {
-            const dynamicImport = new Function("specifier", "return import(specifier)");
-            const mod = await dynamicImport("@anthropic-ai/claude-agent-sdk");
-            const query = mod.query;
-            if (typeof query !== "function") {
-                throw new Error("Claude Agent SDK does not export query()");
-            }
-            this.query = query;
-            // startup() pre-warms the CLI subprocess so we can discover available models
-            // without starting a full conversation (via supportedModels() on the Query).
-            const startup = mod.startup;
-            if (typeof startup === "function") {
-                this.startup = startup;
-            }
-            return { status: "ok", protocol: "claude-agent-sdk" };
-        }
-        catch (error) {
-            throw new Error(`Claude Agent SDK is not available: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    async newSession(input) {
-        this.claudeSessionId = undefined;
-        return { sessionId: undefined, status: "ready", cwd: input.cwd };
-    }
-    async loadSession(input) {
-        this.claudeSessionId = input.sessionId;
-        return { sessionId: input.sessionId, status: "loaded", cwd: input.cwd };
-    }
-    async readSession(input) {
-        const filePath = this.resolveSessionFile(input.sessionId);
-        if (!filePath) {
-            return {
-                thread: {
-                    id: input.sessionId,
-                    sessionId: input.sessionId,
-                    cwd: this.input.cwd,
-                    turns: [],
-                },
-            };
-        }
-        return this.parsedTranscript(filePath, input.sessionId);
-    }
-    /** Resolve the on-disk JSONL transcript for a session, preferring the cwd's
-     *  project dir and falling back to a scan of sibling project dirs. */
-    resolveSessionFile(sessionId) {
-        const preferred = join(claudeProjectDir(this.input.cwd), `${sessionId}.jsonl`);
-        if (existsSync(preferred))
-            return preferred;
-        return claudeProjectDirs(this.input.cwd)
-            .map((dir) => join(dir, `${sessionId}.jsonl`))
-            .find((candidate) => existsSync(candidate));
-    }
-    /** Fork a session: copy the source transcript into a NEW session file,
-     *  truncated to include everything up to and including the turn `uptoTurnId`
-     *  (omitted → full clone). Claude has no native fork primitive, so this
-     *  simulates one by writing a fresh <uuid>.jsonl alongside the source. The
-     *  source file is NEVER modified. Turn ids match the per-line uuid/id (or the
-     *  `claude-history-<n>` fallback) that parseClaudeJsonlSession assigns, where
-     *  <n> counts non-empty lines — replicated here so the cut lands exactly on
-     *  the turn the client asked for. Returns the new session id, or undefined if
-     *  the source can't be read or the new file can't be created. */
-    forkSession(input) {
-        const sourceFile = this.resolveSessionFile(input.sourceSessionId);
-        if (!sourceFile)
-            return undefined;
-        let text;
-        try {
-            text = readFileSync(sourceFile, "utf8");
-        }
-        catch {
-            return undefined;
-        }
-        const lines = text.split("\n");
-        let cutIndex = lines.length - 1; // default: keep everything (full clone)
-        if (input.uptoTurnId) {
-            let nonEmpty = 0;
-            let found = -1;
-            for (let i = 0; i < lines.length; i += 1) {
-                const line = lines[i]?.trim();
-                if (!line)
-                    continue;
-                nonEmpty += 1;
-                let turnId;
-                try {
-                    const rec = asRecord(JSON.parse(line));
-                    turnId = stringField(rec, ["uuid", "id"]) ?? `claude-history-${nonEmpty}`;
-                }
-                catch {
-                    continue; // unparseable line — parser skips it too (index still bumped)
-                }
-                if (turnId === input.uptoTurnId) {
-                    found = i;
-                    break;
-                }
-            }
-            if (found < 0)
-                return undefined; // turn not found — don't silently full-clone
-            cutIndex = found;
-        }
-        const truncated = lines.slice(0, cutIndex + 1).join("\n") + "\n";
-        const newId = randomUUID();
-        const dir = claudeProjectDir(this.input.cwd);
-        const newPath = join(dir, `${newId}.jsonl`);
-        try {
-            // wx: fail if it somehow already exists — never overwrite.
-            writeFileSync(newPath, truncated, { flag: "wx" });
-        }
-        catch {
-            return undefined;
-        }
-        return { sessionId: newId };
-    }
-    /** Read a session's last-known settings (permission mode, plan mode) straight
-     *  from its on-disk transcript, so opening a session LinkShell never drove
-     *  shows the config it actually ran with instead of UI defaults. Claude
-     *  records `permissionMode` on user records (not reasoning effort), so effort
-     *  is left undefined. Only called on open (one file), never per-list. */
-    async readSessionConfig(input) {
-        const filePath = this.resolveSessionFile(input.sessionId);
-        if (!filePath)
-            return {};
-        let permissionModeRaw;
-        try {
-            // The shared parse already tracked the last-seen permissionMode, so this
-            // is a cache field read on the open path (readSession runs right before).
-            const thread = asRecord(this.parsedTranscript(filePath, input.sessionId).thread);
-            permissionModeRaw = stringField(thread, ["permissionMode"]);
-        }
-        catch {
-            return {};
-        }
-        // Map Claude's permission mode to ours. "default" means no explicit
-        // override → leave undefined so the pill shows 默认 rather than a guess.
-        switch (permissionModeRaw) {
-            case "acceptEdits":
-                return { permissionMode: "workspace_write" };
-            case "bypassPermissions":
-                return { permissionMode: "full_access" };
-            case "plan":
-                return { permissionMode: "read_only", collaborationMode: "plan" };
-            default:
-                return {};
-        }
-    }
-    /** Page OLDER transcript turns for scroll-back, mirroring Codex's
-     *  thread/turns/list. The whole transcript lives on disk and is already
-     *  parsed by parseClaudeJsonlSession, so we slice a window of chronological
-     *  turns by an integer end-exclusive cursor.
-     *
-     *  Cursor = the exclusive upper-bound turn index for the page. No cursor =
-     *  start at the end (total turn count). A page returns turns [lo, hi) where
-     *  lo = max(0, hi - limit); nextCursor = String(lo) while lo > 0, else absent
-     *  (start of history reached). The web client's mergeTimeline dedupes by id
-     *  and re-sorts by createdAt, so any overlap between this page and what the
-     *  client already shows is harmless. */
-    async listTurns(input) {
-        const empty = { sessionId: input.sessionId, turns: [], sortDirection: "asc" };
-        const filePath = this.resolveSessionFile(input.sessionId);
-        if (!filePath)
-            return empty;
-        const parsed = this.parsedTranscript(filePath, input.sessionId);
-        const thread = asRecord(parsed.thread);
-        const allTurns = Array.isArray(thread?.turns) ? thread.turns : [];
-        const total = allTurns.length;
-        if (total === 0)
-            return empty;
-        const limit = input.limit && input.limit > 0 ? Math.floor(input.limit) : 50;
-        // Parse the end-exclusive cursor; default to the end of history. Clamp into
-        // [0, total] so a stale/garbage cursor can't slice out of bounds.
-        const parsedCursor = input.cursor !== undefined ? Number.parseInt(input.cursor, 10) : total;
-        const hi = Number.isFinite(parsedCursor) ? Math.max(0, Math.min(total, parsedCursor)) : total;
-        const lo = Math.max(0, hi - limit);
-        const page = allTurns.slice(lo, hi);
-        return {
-            sessionId: input.sessionId,
-            turns: page, // already chronological (ascending)
-            sortDirection: "asc",
-            ...(lo > 0 ? { nextCursor: String(lo) } : {}),
-        };
-    }
-    async prompt(input) {
-        if (!this.query)
-            await this.initialize();
-        if (!this.query)
-            throw new Error("Claude Agent SDK is not initialized");
-        this.abortController?.abort();
-        const abortController = new AbortController();
-        this.abortController = abortController;
-        const inputBlocks = input.content;
-        const hasImages = inputBlocks.some((block) => block.type === "image" && block.data);
-        const prompt = inputBlocks
-            .map((block) => {
-            if (block.type === "image")
-                return `[${block.mimeType ?? "image"} attachment]`;
-            return block.text ?? "";
-        })
-            .filter(Boolean)
-            .join("\n");
-        const sdkOptions = {
-            cwd: input.cwd ?? this.input.cwd,
-            abortController,
-            permissionMode: claudePermissionModeFor({
-                permissionMode: input.permissionMode,
-                collaborationMode: input.collaborationMode,
-            }),
-            toolConfig: {
-                askUserQuestion: { previewFormat: "markdown" },
-            },
-            canUseTool: async (toolName, toolInput) => {
-                if (toolName === "AskUserQuestion") {
-                    const response = await this.input.onRequest("claude/askUserQuestion", {
-                        ...(asRecord(toolInput) ?? {}),
-                        requestId: id("claude-input"),
-                        sessionId: this.claudeSessionId,
-                    });
-                    return response;
-                }
-                if (input.permissionMode === "full_access")
-                    return { behavior: "allow", updatedInput: toolInput };
-                if (["Read", "Glob", "Grep", "LS", "NotebookRead", "TodoRead"].includes(toolName)) {
-                    return { behavior: "allow", updatedInput: toolInput };
-                }
-                if (input.permissionMode === "read_only" && ["Write", "Edit", "MultiEdit", "Bash"].includes(toolName)) {
-                    return { behavior: "deny", message: "Read-only mode is active." };
-                }
-                if (input.permissionMode === "workspace_write" && ["Write", "Edit", "MultiEdit"].includes(toolName)) {
-                    const filePath = stringField(toolInput, ["file_path", "path", "notebook_path"]);
-                    if (filePath && isInsideCwd(input.cwd ?? this.input.cwd, filePath)) {
-                        return { behavior: "allow", updatedInput: toolInput };
-                    }
-                }
-                const requestId = id("claude-perm");
-                const response = await this.input.onRequest("claude/requestApproval", {
-                    requestId,
-                    sessionId: this.claudeSessionId,
-                    toolCall: {
-                        toolName,
-                        input: toolInput,
-                    },
-                    context: `Claude wants to use ${toolName}`,
-                    options: [
-                        { id: "deny", label: "拒绝", kind: "deny" },
-                        { id: "allow_once", label: "允许一次", kind: "allow" },
-                    ],
-                });
-                return outcomeFromPermissionResponse(response) === "allow"
-                    ? { behavior: "allow", updatedInput: toolInput }
-                    : { behavior: "deny", message: "User denied this action from LinkShell." };
-            },
-        };
-        if (input.model)
-            sdkOptions.model = input.model;
-        if (isRealClaudeSessionId(input.sessionId ?? this.claudeSessionId)) {
-            sdkOptions.resume = input.sessionId ?? this.claudeSessionId;
-        }
-        const toolNames = new Map();
-        let currentToolId;
-        let currentToolName;
-        let currentMessageId;
-        const progressItemId = `claude-progress:${input.clientMessageId}`;
-        try {
-            this.input.onNotification("item/started", {
-                sessionId: input.sessionId ?? this.claudeSessionId,
-                item: {
-                    id: progressItemId,
-                    type: "thinking",
-                    text: "Claude 正在处理请求",
-                    status: "running",
-                },
-            });
-            const queryPrompt = hasImages ? singleUserMessage(toClaudeMessageContent(inputBlocks)) : prompt;
-            for await (const message of this.query({ prompt: queryPrompt, options: sdkOptions })) {
-                if (abortController.signal.aborted)
-                    break;
-                this.handleSdkMessage(message, {
-                    cwd: input.cwd ?? this.input.cwd,
-                    toolNames,
-                    currentToolId: (value) => {
-                        if (value !== undefined)
-                            currentToolId = value ?? undefined;
-                        return currentToolId;
-                    },
-                    currentToolName: (value) => {
-                        if (value !== undefined)
-                            currentToolName = value ?? undefined;
-                        return currentToolName;
-                    },
-                    currentMessageId: (value) => {
-                        if (value !== undefined)
-                            currentMessageId = value ?? undefined;
-                        return currentMessageId;
-                    },
-                });
-            }
-            return { sessionId: this.claudeSessionId, status: abortController.signal.aborted ? "cancelled" : "completed" };
-        }
-        finally {
-            this.input.onNotification("item/completed", {
-                sessionId: this.claudeSessionId ?? input.sessionId,
-                item: {
-                    id: progressItemId,
-                    type: "thinking",
-                    text: abortController.signal.aborted ? "Claude 已停止" : "Claude 已完成",
-                    status: abortController.signal.aborted ? "failed" : "completed",
-                },
-            });
-            if (this.abortController === abortController)
-                this.abortController = undefined;
-        }
-    }
-    cancel(input) {
-        this.abortController?.abort();
-        this.abortController = undefined;
-        for (const [, resolve] of this.permissionWaiters)
-            resolve("deny");
-        this.permissionWaiters.clear();
-    }
-    respondPermission(input) {
-        const waiter = this.permissionWaiters.get(input.requestId);
-        if (!waiter)
-            return;
-        this.permissionWaiters.delete(input.requestId);
-        waiter(input.outcome);
-    }
-    async listSessions() {
-        const sessions = [];
-        const seen = new Set();
-        const now = Date.now();
-        const liveKeys = new Set();
-        for (const projectDir of claudeProjectDirs(this.input.cwd)) {
-            try {
-                for (const entry of readdirSync(projectDir)) {
-                    if (!entry.endsWith(".jsonl"))
-                        continue;
-                    const sessionId = entry.replace(".jsonl", "");
-                    if (seen.has(sessionId))
-                        continue;
-                    seen.add(sessionId);
-                    const filePath = join(projectDir, entry);
-                    let stat;
-                    try {
-                        stat = statSync(filePath);
-                    }
-                    catch {
-                        continue; // vanished between readdir and stat
-                    }
-                    liveKeys.add(filePath);
-                    let cached = this.sessionMetaCache.get(filePath);
-                    if (!cached || cached.mtimeMs !== stat.mtimeMs || cached.size !== stat.size) {
-                        // Miss or stale: re-read + re-parse this ONE file, refresh the cache.
-                        const { base, midTurn } = claudeSessionBaseFromFile(filePath, this.input.cwd, sessionId, stat.mtimeMs);
-                        cached = { mtimeMs: stat.mtimeMs, size: stat.size, base, midTurn };
-                        this.sessionMetaCache.set(filePath, cached);
-                    }
-                    // status is clock-dependent, so recompute it every call (cheap) even
-                    // on a cache hit — a running session goes idle purely by time passing.
-                    sessions.push({ ...cached.base, status: statusFromMidTurn(cached.midTurn, stat.mtimeMs, now) });
-                }
-            }
-            catch {
-                // Ignore unreadable Claude project storage.
-            }
-        }
-        // Drop cache entries for transcripts that no longer exist so the map can't
-        // grow without bound across a long-lived process.
-        if (this.sessionMetaCache.size > liveKeys.size) {
-            for (const key of this.sessionMetaCache.keys()) {
-                if (!liveKeys.has(key))
-                    this.sessionMetaCache.delete(key);
-            }
-        }
-        return { sessions };
-    }
-    async listModels() {
-        let defaultModel = "default";
-        // Read the user's configured default model from settings.json. This is always
-        // consulted (both for live discovery and for the fallback path).
-        let availableModels;
-        try {
-            const settingsPath = join(homedir(), ".claude", "settings.json");
-            if (existsSync(settingsPath)) {
-                const raw = JSON.parse(readFileSync(settingsPath, "utf8"));
-                if (typeof raw.model === "string" && raw.model.trim().length > 0) {
-                    defaultModel = raw.model.trim();
-                }
-                if (Array.isArray(raw.availableModels)) {
-                    availableModels = raw.availableModels.filter((m) => typeof m === "string");
-                }
-            }
-        }
-        catch {
-            // Fallback to "default" if settings file is unreadable.
-        }
-        // Dynamic model discovery: use the Claude Agent SDK's startup() to get the
-        // REAL model list for THIS API key (different keys/tiers see different models).
-        // Falls back to settings.json availableModels → hardcoded list on any failure.
-        if (this.startup) {
-            let warm;
-            try {
-                warm = await this.startup({ initializeTimeoutMs: 10_000 });
-                const q = warm.query("");
-                try {
-                    const sdkModels = await q.supportedModels();
-                    // Discover the REAL slash-command set for the installed Claude Code
-                    // (built-ins like /goal + project/user custom commands), instead of a
-                    // hardcoded list that drifts out of sync. Best-effort: an older SDK
-                    // without supportedCommands() just leaves commands undefined and the
-                    // static defaults still apply.
-                    let commands;
-                    try {
-                        const sdkCommands = await q.supportedCommands?.();
-                        if (Array.isArray(sdkCommands) && sdkCommands.length > 0)
-                            commands = sdkCommands;
-                    }
-                    catch {
-                        // supportedCommands() unavailable or failed — fall back to static defaults.
-                    }
-                    // Discover MCP server status the same best-effort way. Older SDKs
-                    // without mcpServerStatus() just leave mcpServers undefined; live
-                    // startupStatus events still populate it. Shape is passed through
-                    // verbatim to the workspace parser, which tolerates array/record forms.
-                    let mcpServers;
-                    try {
-                        mcpServers = await q.mcpServerStatus?.();
-                    }
-                    catch {
-                        // mcpServerStatus() unavailable or failed — rely on live events.
-                    }
-                    if (sdkModels.length > 0) {
-                        // Filter to admin-configured allowlist if present, then map to our format.
-                        const allow = availableModels;
-                        const filtered = allow
-                            ? sdkModels.filter((m) => allow.includes(m.value) || m.value === "default")
-                            : sdkModels;
-                        return {
-                            defaultModel,
-                            models: filtered.map((m) => ({ id: m.value, label: m.displayName || m.value })),
-                            ...(commands ? { commands } : {}),
-                            ...(mcpServers ? { mcpServers } : {}),
-                        };
-                    }
-                    // No models surfaced, but commands may still be present — return them
-                    // so the command palette stays in sync even when the model list is empty.
-                    if (commands || mcpServers) {
-                        const fallbackModels = availableModels ?? DEFAULT_FALLBACK_MODELS;
-                        return {
-                            defaultModel,
-                            models: toModelEntries(fallbackModels),
-                            ...(commands ? { commands } : {}),
-                            ...(mcpServers ? { mcpServers } : {}),
-                        };
-                    }
-                }
-                catch {
-                    // supportedModels() failed — the subprocess may be in a bad state. Close it.
-                }
-                finally {
-                    try {
-                        warm.close();
-                    }
-                    catch { /* ignore */ }
-                }
-            }
-            catch {
-                // startup() failed — clean up if it partially succeeded.
-                try {
-                    warm?.close();
-                }
-                catch { /* ignore */ }
-            }
-        }
-        // Fallback: admin-configured allowlist, or the full Claude Code alias set.
-        const fallbackModels = availableModels ?? DEFAULT_FALLBACK_MODELS;
-        return {
-            defaultModel,
-            models: toModelEntries(fallbackModels),
-        };
-    }
-    stop() {
-        this.cancel({});
-    }
-    handleSdkMessage(event, state) {
-        switch (event.type) {
-            case "system": {
-                if (event.subtype === "init" && typeof event.session_id === "string") {
-                    this.claudeSessionId = event.session_id;
-                    this.input.onNotification("thread/started", {
-                        sessionId: event.session_id,
-                        threadId: event.session_id,
-                    });
-                    this.input.onNotification("initialized", {
-                        sessionId: event.session_id,
-                        threadId: event.session_id,
-                        cwd: event.cwd ?? state.cwd,
-                        model: event.model,
-                    });
-                }
-                break;
-            }
-            case "assistant": {
-                const rawMessage = event.message;
-                const content = (Array.isArray(rawMessage?.content) ? rawMessage.content : []);
-                state.currentMessageId(null);
-                for (const block of content) {
-                    if (block.type === "thinking") {
-                        this.input.onNotification("item/completed", {
-                            sessionId: this.claudeSessionId,
-                            item: {
-                                id: event.uuid ?? id("thinking"),
-                                type: "thinking",
-                                text: block.thinking,
-                                status: "completed",
-                            },
-                        });
-                    }
-                    else if (block.type === "text") {
-                        const messageId = (typeof rawMessage?.id === "string" ? rawMessage.id : undefined) ?? event.uuid ?? id("msg");
-                        state.currentMessageId(messageId);
-                        this.input.onNotification("item/agentMessage/delta", {
-                            sessionId: this.claudeSessionId,
-                            itemId: messageId,
-                            delta: block.text,
-                        });
-                    }
-                    else if (block.type === "tool_use") {
-                        const toolId = block.id ?? id("tool");
-                        const toolName = block.name ?? "tool";
-                        state.currentToolId(toolId);
-                        state.currentToolName(toolName);
-                        state.toolNames.set(toolId, toolName);
-                        this.input.onNotification("item/started", {
-                            sessionId: this.claudeSessionId,
-                            item: {
-                                id: toolId,
-                                type: toolName === "Bash" ? "commandExecution" : toolName === "Write" || toolName === "Edit" || toolName === "MultiEdit" ? "fileChange" : "toolCall",
-                                toolName,
-                                tool: toolName,
-                                input: block.input,
-                                command: block.input?.command,
-                                cwd: block.input?.cwd ?? state.cwd,
-                                status: "running",
-                            },
-                        });
-                    }
-                }
-                const messageId = state.currentMessageId();
-                if (messageId) {
-                    this.input.onNotification("item/completed", {
-                        sessionId: this.claudeSessionId,
-                        item: { id: messageId, type: "agentMessage", status: "completed" },
-                    });
-                }
-                break;
-            }
-            case "user": {
-                const rawMessage = event.message;
-                const content = (Array.isArray(rawMessage?.content) ? rawMessage.content : []);
-                for (const block of content) {
-                    if (block.type !== "tool_result")
-                        continue;
-                    const toolId = block.tool_use_id ?? state.currentToolId();
-                    const toolName = (toolId ? state.toolNames.get(toolId) : undefined) ?? state.currentToolName();
-                    const output = extractToolResultText(block.content);
-                    this.input.onNotification("item/completed", {
-                        sessionId: this.claudeSessionId,
-                        item: {
-                            id: toolId ?? id("tool"),
-                            type: "toolCall",
-                            toolName,
-                            tool: toolName,
-                            status: block.is_error ? "failed" : "completed",
-                            output,
-                            aggregatedOutput: output,
-                            isError: block.is_error === true,
-                        },
-                    });
-                }
-                break;
-            }
-            case "result": {
-                if (typeof event.session_id === "string")
-                    this.claudeSessionId = event.session_id;
-                this.input.onNotification("turn/completed", {
-                    sessionId: this.claudeSessionId,
-                    durationMs: event.duration_ms,
-                    totalCostUsd: event.total_cost_usd,
-                    usage: event.usage,
-                    isError: event.subtype === "error",
-                });
-                break;
-            }
-        }
-    }
-}
-//# sourceMappingURL=claude-sdk-client.js.map