@myagentroam/node 0.1.3 → 0.1.6

package/dist/util/runner-native-session-parsers.d.ts

@@ -0,0 +1,72 @@
+import type { SessionActivityState } from '@myagentroam/protocol';
+import type { NodeAgentSession, NodeConversationTurn } from '../database.js';
+import type { NativeSessionHistory, NativeTranscriptImageAttachment } from '../native-session-history.js';
+export interface SessionContextUsage {
+    readonly model: string | null;
+    readonly usedTokens: number;
+    readonly maxTokens: number;
+    readonly percentage: number;
+}
+export type ConversationHistorySource = 'official' | 'native' | 'runtime';
+export interface ConversationHistoryPage {
+    readonly turns: readonly NodeConversationTurn[];
+    readonly nextCursor: string | null;
+    readonly snapshotSequence: number;
+    readonly source: ConversationHistorySource;
+    readonly readAt: number;
+    readonly latestVisibleAt: number;
+}
+export declare function extractId(result: unknown, key: 'thread' | 'turn'): string;
+export declare function settleWithin<T>(promise: Promise<T>, milliseconds: number): Promise<T | undefined>;
+export declare function extractCodexThreads(result: unknown): readonly {
+    readonly id: string;
+    readonly source: string | undefined;
+    readonly cwd: unknown;
+    readonly title: string | undefined;
+}[];
+export declare function codexThreadActivity(result: unknown): SessionActivityState;
+export declare function externalResumeFailureDetail(error: unknown): string;
+export declare function codexActiveTurnId(result: unknown): string | undefined;
+export declare function codexThreadCwd(value: unknown): string;
+export declare function isWithinWorkspace(cwd: string, workspacePath: string): boolean;
+export declare function claudeDiscoveredSession(value: unknown, fallbackCwd: string): {
+    readonly externalSessionId: string;
+    readonly cwd: string;
+    readonly title?: string;
+} | undefined;
+export declare function latestNativeActivity(history: NativeSessionHistory): number;
+export declare function sameContextUsage(left: SessionContextUsage, right: SessionContextUsage): boolean;
+export declare function isNativeHistory(value: unknown): value is NativeSessionHistory;
+export declare function deduplicateDirectSessions<T extends NodeAgentSession>(sessions: readonly T[]): readonly T[];
+export declare function nativeConversationPage(session: NodeAgentSession, history: NativeSessionHistory, input: {
+    readonly cursor?: string;
+    readonly limit?: number;
+}, runtimeTurns?: readonly NodeConversationTurn[], registerImages?: (images: readonly NativeTranscriptImageAttachment[]) => readonly Record<string, unknown>[]): {
+    readonly turns: readonly NodeConversationTurn[];
+    readonly nextCursor: string | null;
+};
+/**
+ * Claude JSONL 不保存浏览器请求 ID。Node 进程仍存活时，以正文和生成时刻
+ * 对齐当前运行态的用户消息，让 native 历史页替换同一乐观 Turn，而不是重复一条。
+ */
+export declare function nativeUserClientMessageId(entry: Extract<NativeSessionHistory['items'][number], {
+    readonly kind: 'message';
+}>, createdAt: number, runtimeTurns: readonly NodeConversationTurn[]): string | null;
+/**
+ * Normalize the documented App Server `thread/read(includeTurns: true)`
+ * result.  Only items with a user-visible Workbench representation are kept;
+ * raw protocol envelopes are deliberately never exposed to Web.
+ */
+export declare function claudePlanText(text: string): string | undefined;
+export declare function claudeUserInputQuestions(value: Record<string, unknown>): readonly {
+    readonly id: string;
+    readonly prompt: string;
+    readonly input: 'SINGLE_SELECT' | 'MULTI_SELECT' | 'SHORT_TEXT';
+    readonly options: readonly {
+        readonly value: string;
+        readonly label: string;
+        readonly description: string | null;
+    }[];
+    readonly allowOther: boolean;
+    readonly multiSelect: boolean;
+}[];

package/dist/util/runner-native-session-parsers.js

@@ -0,0 +1,381 @@
+import { fileURLToPath } from 'node:url';
+import { stripClaudePlanTag } from '../runner-command-engine.js';
+import { compactRunnerText, isClaudeCommandTool, isPlainRecord, nativeClaudeCommand, nativePageEnd } from './node-operation-parsers.js';
+export function extractId(result, key) {
+    if (typeof result === 'object' &&
+        result !== null &&
+        key in result &&
+        typeof result[key] === 'object' &&
+        result[key] !== null &&
+        typeof result[key]['id'] === 'string') {
+        return result[key]['id'];
+    }
+    throw new Error(`CODEX_${key.toUpperCase()}_ID_MISSING`);
+}
+export async function settleWithin(promise, milliseconds) {
+    let timer;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((resolve) => {
+                timer = setTimeout(() => resolve(undefined), milliseconds);
+                timer.unref();
+            })
+        ]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
+export function extractCodexThreads(result) {
+    if (typeof result !== 'object' || result === null || !('data' in result))
+        return [];
+    const data = result.data;
+    if (!Array.isArray(data))
+        return [];
+    return data.flatMap((entry) => {
+        if (typeof entry !== 'object' || entry === null)
+            return [];
+        const value = entry;
+        if (typeof value.id !== 'string')
+            return [];
+        const source = typeof value.sourceKind === 'string'
+            ? value.sourceKind
+            : typeof value.source === 'string'
+                ? value.source
+                : typeof value.source === 'object' &&
+                    value.source !== null &&
+                    typeof value.source.kind === 'string'
+                    ? value.source.kind
+                    : undefined;
+        const title = typeof value.name === 'string' && value.name.trim().length > 0
+            ? value.name.trim()
+            : typeof value.preview === 'string' && value.preview.trim().length > 0
+                ? value.preview.trim()
+                : undefined;
+        return [{ id: value.id, source, cwd: value.cwd, title }];
+    });
+}
+export function codexThreadActivity(result) {
+    if (!isPlainRecord(result) || !isPlainRecord(result.thread))
+        return 'UNAVAILABLE';
+    const status = result.thread.status;
+    if (!isPlainRecord(status) || typeof status.type !== 'string')
+        return 'UNAVAILABLE';
+    if (status.type === 'active')
+        return 'EXTERNAL_ACTIVE';
+    if (status.type === 'idle' || status.type === 'notLoaded')
+        return 'IDLE';
+    return 'UNAVAILABLE';
+}
+export function externalResumeFailureDetail(error) {
+    const message = error instanceof Error ? error.message : 'SESSION_RESUME_REJECTED';
+    return [...message]
+        .map((character) => (character <= '\u001f' || character === '\u007f' ? ' ' : character))
+        .join('')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .slice(0, 240);
+}
+export function codexActiveTurnId(result) {
+    if (!isPlainRecord(result) ||
+        !isPlainRecord(result.thread) ||
+        !Array.isArray(result.thread.turns))
+        return undefined;
+    const active = result.thread.turns.find((turn) => isPlainRecord(turn) &&
+        typeof turn.id === 'string' &&
+        (turn.status === 'active' || turn.status === 'inProgress'));
+    return isPlainRecord(active) && typeof active.id === 'string' ? active.id : undefined;
+}
+export function codexThreadCwd(value) {
+    if (typeof value !== 'string' || value.length === 0)
+        throw new Error('CODEX_THREAD_CWD_INVALID');
+    if (!value.startsWith('file:'))
+        return value;
+    try {
+        return fileURLToPath(value);
+    }
+    catch {
+        throw new Error('CODEX_THREAD_CWD_INVALID');
+    }
+}
+export function isWithinWorkspace(cwd, workspacePath) {
+    const normalize = (value) => {
+        const compact = value.replace(/[\\/]+/g, '/').replace(/\/$/, '');
+        return process.platform === 'win32' ? compact.toLowerCase() : compact;
+    };
+    const normalizedCwd = normalize(cwd);
+    const normalizedWorkspace = normalize(workspacePath);
+    if (normalizedCwd === normalizedWorkspace)
+        return true;
+    return normalizedCwd.startsWith(`${normalizedWorkspace}/`);
+}
+export function claudeDiscoveredSession(value, fallbackCwd) {
+    if (typeof value !== 'object' || value === null)
+        return undefined;
+    const record = value;
+    const externalSessionId = typeof record.sessionId === 'string'
+        ? record.sessionId
+        : typeof record.id === 'string'
+            ? record.id
+            : undefined;
+    if (externalSessionId === undefined || externalSessionId.length === 0)
+        return undefined;
+    const title = typeof record.summary === 'string'
+        ? record.summary
+        : typeof record.title === 'string'
+            ? record.title
+            : undefined;
+    const cwd = typeof record.cwd === 'string' && record.cwd.length > 0 ? record.cwd : fallbackCwd;
+    return { externalSessionId, cwd, ...(title === undefined ? {} : { title: title.slice(0, 80) }) };
+}
+export function latestNativeActivity(history) {
+    return history.lastActivityAt;
+}
+export function sameContextUsage(left, right) {
+    return (left.model === right.model &&
+        left.usedTokens === right.usedTokens &&
+        left.maxTokens === right.maxTokens);
+}
+export function isNativeHistory(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        Array.isArray(value.items));
+}
+export function deduplicateDirectSessions(sessions) {
+    const values = new Map();
+    for (const session of sessions) {
+        const existing = values.get(session.id);
+        if (existing === undefined || existing.lastActivityAt < session.lastActivityAt)
+            values.set(session.id, session);
+    }
+    return [...values.values()].sort((left, right) => right.lastActivityAt - left.lastActivityAt);
+}
+export function nativeConversationPage(session, history, input, runtimeTurns = [], registerImages = () => []) {
+    const limit = Math.min(Math.max(input.limit ?? 30, 1), 500);
+    const nativeTurns = nativeTranscriptTurns(history.items);
+    const end = nativePageEnd(input.cursor, session.id, nativeTurns.length);
+    const start = Math.max(0, end - limit);
+    const turns = nativeTurns
+        .slice(start, end)
+        .map((entries, relativeIndex) => {
+        const firstIndex = entries[0]?.index ?? 0;
+        const turnId = `${session.id}:native:${firstIndex}`;
+        const items = entries.map(({ entry, index }) => nativeTranscriptConversationItem(session, entry, index, turnId, runtimeTurns, registerImages));
+        const startedAt = items[0]?.startedAt ?? firstIndex;
+        const completedAt = items.at(-1)?.completedAt ?? startedAt;
+        const after = lastNativeItemId(entries);
+        return {
+            id: turnId,
+            sessionId: session.id,
+            runId: null,
+            userItemId: items.find((item) => item.kind === 'user_message')?.id ?? null,
+            status: 'SUCCEEDED',
+            model: null,
+            effort: null,
+            access: null,
+            ...(after === undefined || session.runner !== 'claude-code'
+                ? {}
+                : {
+                    rewind: {
+                        before: lastNativeItemId(nativeTurns[start + relativeIndex - 1] ?? []) ?? null,
+                        after
+                    }
+                }),
+            items,
+            startedAt,
+            completedAt
+        };
+    });
+    return {
+        turns,
+        nextCursor: start > 0
+            ? Buffer.from(JSON.stringify({ sessionId: session.id, end: start })).toString('base64url')
+            : null
+    };
+}
+function lastNativeItemId(entries) {
+    return entries.findLast(({ entry }) => entry.nativeId !== undefined)?.entry.nativeId;
+}
+function nativeTranscriptTurns(items) {
+    const turns = [];
+    let current = [];
+    for (const [index, entry] of items.entries()) {
+        if (entry.kind === 'message' && entry.role === 'USER' && current.length > 0) {
+            turns.push(current);
+            current = [];
+        }
+        current.push({ entry, index });
+    }
+    if (current.length > 0)
+        turns.push(current);
+    return turns;
+}
+function nativeTranscriptConversationItem(session, entry, index, turnId, runtimeTurns, registerImages) {
+    const time = entry.createdAt ?? index;
+    const isToolCall = entry.kind === 'tool_call';
+    const isUnknown = entry.kind === 'unknown';
+    const isReasoning = entry.kind === 'reasoning_summary';
+    const isCommand = isToolCall && isClaudeCommandTool(entry.toolName);
+    const userInputQuestions = session.runner === 'claude-code' &&
+        isToolCall &&
+        entry.toolName === 'AskUserQuestion' &&
+        isPlainRecord(entry.input)
+        ? claudeUserInputQuestions(entry.input)
+        : [];
+    const isUserInputRequest = userInputQuestions.length > 0;
+    const clientMessageId = entry.kind === 'message' && entry.role === 'USER'
+        ? nativeUserClientMessageId(entry, time, runtimeTurns)
+        : null;
+    // Claude 标签式 Plan Mode：用户正文剥离注入的规划指令标签，
+    // 完整的 <proposed_plan> Agent 文本归一化为计划卡。
+    const entryText = entry.kind === 'message'
+        ? entry.role === 'USER'
+            ? stripClaudePlanTag(entry.text)
+            : entry.text
+        : '';
+    const planText = entry.kind === 'message' && entry.role !== 'USER' ? claudePlanText(entryText) : undefined;
+    const item = {
+        id: `${turnId}:item:${index}`,
+        sessionId: session.id,
+        turnId,
+        runId: null,
+        parentItemId: null,
+        sourceSequence: index,
+        revision: 0,
+        kind: isUserInputRequest
+            ? 'user_input_request'
+            : isReasoning
+                ? 'reasoning_summary'
+                : isToolCall
+                    ? isCommand
+                        ? 'command_execution'
+                        : 'tool_call'
+                    : isUnknown
+                        ? 'unknown'
+                        : entry.kind === 'message' && entry.role === 'USER'
+                            ? 'user_message'
+                            : planText !== undefined
+                                ? 'plan'
+                                : 'assistant_message',
+        status: 'COMPLETED',
+        payload: isUserInputRequest
+            ? {
+                requestId: `native:${entry.kind === 'tool_call' ? entry.toolUseId : `item-${index}`}`,
+                questions: userInputQuestions
+            }
+            : isReasoning
+                ? { sections: entry.sections }
+                : isToolCall
+                    ? isCommand
+                        ? {
+                            command: nativeClaudeCommand(entry),
+                            cwd: null,
+                            outputPreview: entry.outputSummary ?? '',
+                            outputRef: null,
+                            exitCode: null,
+                            durationMs: null,
+                            truncated: entry.inputTruncated || entry.outputTruncated
+                        }
+                        : {
+                            namespace: session.runner,
+                            toolName: entry.toolName,
+                            title: entry.toolName,
+                            inputSummary: entry.inputSummary,
+                            outputSummary: entry.outputSummary,
+                            progressLabel: null,
+                            errorCode: entry.failed ? 'TOOL_EXECUTION_FAILED' : null,
+                            truncated: entry.inputTruncated || entry.outputTruncated,
+                            ...(entry.imageAttachments === undefined
+                                ? {}
+                                : { attachments: registerImages(entry.imageAttachments) })
+                        }
+                    : isUnknown
+                        ? { sourceEventType: entry.sourceEventType, label: entry.label }
+                        : entry.kind === 'message' && entry.role === 'USER'
+                            ? { clientMessageId, text: entryText, contexts: [], delivery: 'ACCEPTED' }
+                            : planText !== undefined
+                                ? { explanation: compactRunnerText(planText, 20_000), steps: [] }
+                                : { text: entryText, format: 'markdown', source: 'native-file' },
+        startedAt: time,
+        completedAt: time
+    };
+    return item;
+}
+/**
+ * Claude JSONL 不保存浏览器请求 ID。Node 进程仍存活时，以正文和生成时刻
+ * 对齐当前运行态的用户消息，让 native 历史页替换同一乐观 Turn，而不是重复一条。
+ */
+export function nativeUserClientMessageId(entry, createdAt, runtimeTurns) {
+    for (const turn of runtimeTurns) {
+        const user = turn.items.find((item) => item.kind === 'user_message');
+        if (user === undefined || !isPlainRecord(user.payload))
+            continue;
+        const payload = user.payload;
+        const clientMessageId = typeof payload.clientMessageId === 'string' ? payload.clientMessageId : null;
+        // 标签式 Plan Mode 的指令标签只存在于原生 transcript，运行态气泡始终是原文。
+        if (clientMessageId === null || payload.text !== stripClaudePlanTag(entry.text))
+            continue;
+        const runtimeCreatedAt = user.startedAt ?? turn.startedAt;
+        if (runtimeCreatedAt !== null &&
+            runtimeCreatedAt !== undefined &&
+            Math.abs(createdAt - runtimeCreatedAt) > 60_000)
+            continue;
+        return clientMessageId;
+    }
+    return null;
+}
+/**
+ * Normalize the documented App Server `thread/read(includeTurns: true)`
+ * result.  Only items with a user-visible Workbench representation are kept;
+ * raw protocol envelopes are deliberately never exposed to Web.
+ */
+export function claudePlanText(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith('<proposed_plan>') || !/<\/proposed_plan>\s*$/.test(trimmed))
+        return undefined;
+    const plan = trimmed
+        .slice('<proposed_plan>'.length)
+        .replace(/<\/proposed_plan>\s*$/, '')
+        .trim();
+    return plan.length > 0 ? plan : undefined;
+}
+export function claudeUserInputQuestions(value) {
+    if (!Array.isArray(value.questions) || value.questions.length === 0 || value.questions.length > 4)
+        return [];
+    const questions = value.questions.map((raw, index) => {
+        if (!isPlainRecord(raw) || typeof raw.question !== 'string')
+            return undefined;
+        const options = Array.isArray(raw.options)
+            ? raw.options.flatMap((option) => {
+                if (!isPlainRecord(option) || typeof option.label !== 'string')
+                    return [];
+                const label = compactRunnerText(option.label, 500);
+                return label.length === 0
+                    ? []
+                    : [
+                        {
+                            value: label,
+                            label,
+                            description: typeof option.description === 'string'
+                                ? compactRunnerText(option.description, 1_000)
+                                : null
+                        }
+                    ];
+            })
+            : [];
+        const multiSelect = raw.multiSelect === true;
+        return {
+            id: `claude-question-${index}`,
+            prompt: compactRunnerText(raw.question, 5_000),
+            input: options.length === 0 ? 'SHORT_TEXT' : multiSelect ? 'MULTI_SELECT' : 'SINGLE_SELECT',
+            options,
+            allowOther: true,
+            multiSelect
+        };
+    });
+    return questions.some((question) => question === undefined)
+        ? []
+        : questions;
+}

package/dist/util/secret-environment.d.ts

@@ -0,0 +1 @@
+export declare function parseSecretEnvironment(value: unknown): Readonly<Record<string, string>>;

package/dist/util/secret-environment.js

@@ -0,0 +1,25 @@
+const ENVIRONMENT_NAME = /^[A-Za-z_][A-Za-z0-9_]{0,127}$/;
+const MAX_SECRET_COUNT = 128;
+const MAX_SECRET_VALUE_BYTES = 16 * 1024;
+const MAX_SECRET_TOTAL_BYTES = 64 * 1024;
+export function parseSecretEnvironment(value) {
+    if (value === undefined)
+        return {};
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('SECRET_ENVIRONMENT_INVALID');
+    const entries = Object.entries(value);
+    if (entries.length > MAX_SECRET_COUNT)
+        throw new Error('SECRET_ENVIRONMENT_LIMIT_EXCEEDED');
+    const environment = {};
+    let bytes = 0;
+    for (const [name, secret] of entries) {
+        if (!ENVIRONMENT_NAME.test(name) || typeof secret !== 'string' || secret.includes('\0'))
+            throw new Error('SECRET_ENVIRONMENT_INVALID');
+        const valueBytes = Buffer.byteLength(secret);
+        bytes += Buffer.byteLength(name) + valueBytes;
+        if (valueBytes > MAX_SECRET_VALUE_BYTES || bytes > MAX_SECRET_TOTAL_BYTES)
+            throw new Error('SECRET_ENVIRONMENT_LIMIT_EXCEEDED');
+        environment[name] = secret;
+    }
+    return environment;
+}

package/dist/workspace.d.ts

@@ -41,6 +41,7 @@ export interface WorkspaceDirectoryListing {
     readonly entries: readonly WorkspaceDirectoryEntry[];
     readonly truncated: boolean;
 }
+export declare function createWorkspaceDirectory(parentPath: string, directoryName: string, allowedRoots: readonly string[]): Promise<string>;
 /** A per-workspace, process-local index for the Quick Open file picker. */
 export declare class WorkspaceFileIndex {
     private readonly workspaceRoot;
@@ -61,8 +62,12 @@ export declare class WorkspaceFileIndex {
     });
     /** Starts/renews the lightweight index observer without exposing file data. */
     observe(): Promise<void>;
+    contentCandidates(): Promise<{
+        readonly entries: readonly WorkspaceFileEntry[];
+        readonly truncated: boolean;
+    }>;
     dispose(): void;
-    search(query: string, cursor?: string, limit?: number): Promise<WorkspaceFileSearchPage>;
+    search(query: string, cursor?: string, limit?: number, includeDirectories?: boolean): Promise<WorkspaceFileSearchPage>;
     private ensureLoaded;
     private touch;
     private rebuild;
@@ -77,6 +82,24 @@ export declare class WorkspaceFileIndex {
  */
 export declare function listWorkspaceDirectories(requestedPath: string | undefined, allowedRoots: readonly string[], homePath?: string): Promise<WorkspaceDirectoryListing>;
 export declare function listWorkspaceFiles(workspaceRoot: string, requestedPath?: string, cursor?: string, limit?: number): Promise<WorkspaceFilePage>;
+export type WorkspaceFileMutation = {
+    readonly action: 'CREATE_FILE';
+    readonly path: string;
+} | {
+    readonly action: 'CREATE_DIRECTORY';
+    readonly path: string;
+} | {
+    readonly action: 'MOVE';
+    readonly path: string;
+    readonly destination: string;
+} | {
+    readonly action: 'DELETE';
+    readonly path: string;
+};
+export declare function mutateWorkspaceFile(workspaceRoot: string, mutation: WorkspaceFileMutation): Promise<{
+    readonly path?: string;
+    readonly deleted?: true;
+}>;
 /** Validates an upload destination without following an existing target symlink. */
 export declare function preflightWorkspaceUpload(workspaceRoot: string, requestedDirectory: string, name: string): Promise<WorkspaceUploadTarget>;
 export declare function workspaceUploadTemporaryName(uploadId: string): string;
@@ -98,7 +121,7 @@ export declare function readAllowedTextFile(requestedPath: string, allowedRoots:
     readonly nextOffset: number | null;
 }>;
 /** Searches file names only, so an exploratory request cannot exfiltrate file contents. */
-export declare function searchWorkspaceFiles(workspaceRoot: string, query: string, cursor?: string, limit?: number): Promise<WorkspaceFileSearchPage>;
+export declare function searchWorkspaceFiles(workspaceRoot: string, query: string, cursor?: string, limit?: number, includeDirectories?: boolean): Promise<WorkspaceFileSearchPage>;
 export declare function normalizeWorkspacePath(input: string, platform?: NodeJS.Platform): string;
 export declare function isWithinAllowedRoot(target: string, roots: readonly string[], platform?: NodeJS.Platform): boolean;
 /** Resolving both candidate and roots rejects Linux symlinks which point outside a root. */
@@ -128,6 +151,35 @@ export declare function readCurrentChangesSummary(workspacePath: string): Promis
 }>;
 export declare function listInitializedSubmodulePaths(workspacePath: string): Promise<readonly string[]>;
 export declare function resolveGitRepository(workspacePath: string, repositoryPath: string): Promise<string>;
+export interface GitHistoryRefEntry {
+    readonly name: string;
+    readonly displayName: string;
+    readonly kind: 'LOCAL' | 'REMOTE';
+    readonly hash: string;
+    readonly current: boolean;
+}
+export declare function listGitHistoryRefs(repository: string): Promise<readonly GitHistoryRefEntry[]>;
+export declare function readGitHistory(repository: string, input: {
+    readonly refs?: readonly string[];
+    readonly cursor?: string;
+    readonly limit?: number;
+}): Promise<{
+    readonly commits: readonly object[];
+    readonly nextCursor: string | null;
+}>;
+export declare function readGitHistoryFiles(repository: string, commit: string, refs?: readonly string[]): Promise<readonly {
+    path: string;
+    previousPath?: string;
+    change: ReturnType<typeof gitChange>;
+}[]>;
+export declare function readGitHistoryFileDiff(repository: string, commit: string, requestedPath: string, refs?: readonly string[], requestedPreviousPath?: string): Promise<{
+    readonly binary: boolean;
+    readonly text?: string;
+    readonly summary?: string;
+    readonly truncated: boolean;
+    readonly beforePreview?: BinaryDiffPreview;
+    readonly afterPreview?: BinaryDiffPreview;
+}>;
 export declare function readCurrentChanges(workspacePath: string): Promise<readonly {
     readonly path: string;
     readonly state: 'STAGED' | 'UNSTAGED' | 'UNTRACKED';
@@ -140,12 +192,20 @@ export declare function readCurrentChangeDiff(workspacePath: string, requestedPa
     readonly truncated: boolean;
     readonly afterText?: string;
     readonly afterTruncated?: boolean;
+    readonly beforePreview?: BinaryDiffPreview;
+    readonly afterPreview?: BinaryDiffPreview;
 }>;
 /** Current Changes must not expose an external link. */
 export declare function isWorkspaceChangeVisible(workspacePath: string, requestedPath: string): Promise<boolean>;
+interface BinaryDiffPreview {
+    readonly contentBase64?: string;
+    readonly truncated: boolean;
+}
 export declare function restoreCurrentChange(workspacePath: string, requestedPath: string, state: 'STAGED' | 'UNSTAGED' | 'UNTRACKED'): Promise<void>;
+declare function gitChange(status: string): 'ADDED' | 'MODIFIED' | 'DELETED' | 'RENAMED' | 'COPIED' | 'TYPE_CHANGED';
 export declare class GitCommandError extends Error {
     readonly code: number;
     readonly stderr: string;
     constructor(code: number, stderr: string);
 }
+export {};