@myagentroam/node 0.9.4 → 0.9.6

package/dist/service/workspace-workbench-service.js

@@ -1,8 +1,10 @@
-import { listGitHistoryRefs, readGitHistory, readGitHistoryFileDiff, readGitHistoryFiles, readCurrentChangeDiff, readRestrictedDiff, resolveGitRepository, restoreCurrentChange } from '../workspace.js';
+import { listGitHistoryRefs, readGitHistory, readGitHistoryFileDiff, readGitHistoryFileContentRange, readGitHistoryFiles, readCurrentChangeDiff, readRestrictedDiff, resolveGitRepository, restoreCurrentChange } from '../workspace.js';
 import { WorkspaceContentSearchService } from './workspace-content-search-service.js';
 export class WorkspaceWorkbenchService {
     options;
     contentSearch;
+    topicRefreshes = new Map();
+    dirtyTopics = new Set();
     constructor(options) {
         this.options = options;
         this.contentSearch = new WorkspaceContentSearchService(options.files);
@@ -13,6 +15,7 @@ export class WorkspaceWorkbenchService {
             'workspace.unwatch': (data) => this.unwatch(record(data)),
             'workspace.files.list': (data) => this.listFiles(record(data)),
             'workspace.file.read': (data) => this.readFile(record(data)),
+            'workspace.file.content.read': (data) => this.readFileContent(record(data)),
             'workspace.files.search': (data) => this.searchFiles(record(data)),
             'workspace.files.mutate': (data) => this.mutateFile(record(data)),
             'workspace.content.search': (data) => this.searchContent(record(data)),
@@ -31,44 +34,220 @@ export class WorkspaceWorkbenchService {
             'workspace.git.history.list': (data) => this.gitHistory(record(data)),
             'workspace.git.commit.files': (data) => this.gitCommitFiles(record(data)),
             'workspace.git.commit.file.diff': (data) => this.gitCommitFileDiff(record(data)),
+            'workspace.git.commit.file.content.read': (data) => this.gitCommitFileContent(record(data)),
             'workspace.diff': (data) => this.diff(record(data))
         };
     }
+    async refreshTopic(workspaceId, topic) {
+        const key = `${workspaceId}:${topic}`;
+        const active = this.topicRefreshes.get(key);
+        if (active !== undefined) {
+            this.dirtyTopics.add(key);
+            return active;
+        }
+        const refresh = this.performTopicRefresh(workspaceId, topic).catch(() => {
+            this.emitTopicFailure(workspaceId, topic);
+        });
+        this.topicRefreshes.set(key, refresh);
+        try {
+            await refresh;
+        }
+        finally {
+            if (this.topicRefreshes.get(key) === refresh)
+                this.topicRefreshes.delete(key);
+            if (this.dirtyTopics.delete(key))
+                void this.refreshTopic(workspaceId, topic);
+        }
+    }
+    emitTopicFailure(workspaceId, topic) {
+        for (const watch of this.options.watch.activeWatches(workspaceId)) {
+            const subscribed = topic === 'files' ? watch.topics.files !== undefined : watch.topics[topic] === true;
+            if (!subscribed)
+                continue;
+            this.options.emitWatchEvent({
+                type: 'watch.failed',
+                workbenchConnectionId: watch.workbenchConnectionId,
+                watchType: 'workspace',
+                watchId: watch.watchId,
+                nodeGeneration: watch.nodeGeneration,
+                nodeId: this.options.nodeId(),
+                workspaceId,
+                topic,
+                code: 'WORKSPACE_WATCH_SNAPSHOT_FAILED',
+                message: 'Workspace watch snapshot failed.'
+            });
+        }
+    }
+    async performTopicRefresh(workspaceId, topic) {
+        const workspace = this.options.requireWorkspace(workspaceId);
+        const watches = this.options.watch.activeWatches(workspaceId);
+        if (topic === 'sessions') {
+            const subscribers = watches.filter((watch) => watch.topics.sessions);
+            if (subscribers.length === 0)
+                return;
+            const payload = await this.options.listSessions(workspace.id);
+            for (const watch of subscribers)
+                this.deliverSnapshot(workspace, watch, topic, payload);
+            return;
+        }
+        if (topic === 'changes') {
+            const subscribers = watches.filter((watch) => watch.topics.changes);
+            if (subscribers.length === 0)
+                return;
+            const payload = workspace.kind === 'GIT_WORKSPACE' ? await this.options.changes.current(workspace) : null;
+            for (const watch of subscribers)
+                this.deliverSnapshot(workspace, watch, topic, payload);
+            return;
+        }
+        const views = new Map();
+        for (const watch of watches) {
+            if (watch.topics.files === undefined)
+                continue;
+            const key = JSON.stringify(watch.topics.files);
+            views.set(key, [...(views.get(key) ?? []), watch]);
+        }
+        await Promise.all([...views.values()].map(async (subscribers) => {
+            const view = subscribers[0]?.topics.files;
+            if (view === undefined)
+                return;
+            const payload = { files: await this.options.files.list(workspace, view) };
+            for (const watch of subscribers)
+                this.deliverSnapshot(workspace, watch, topic, payload);
+        }));
+    }
     async watch(input) {
         if (typeof input.workspaceId !== 'string' ||
             typeof input.watchId !== 'string' ||
+            typeof input.workbenchConnectionId !== 'string' ||
             !/^[A-Za-z0-9_-]{8,128}$/.test(input.watchId) ||
             (input.mode !== 'initial' && input.mode !== 'renew'))
             throw new Error('WORKSPACE_WATCH_INVALID');
         const workspace = this.options.requireWorkspace(input.workspaceId);
         if (input.mode === 'renew') {
-            const watch = this.options.watch.renew(workspace.id, this.options.watch.key(input));
+            const watch = this.options.watch.renew(workspace.id, this.options.watch.key(input), input.watchId);
             if (watch === undefined)
                 throw new Error('WORKSPACE_WATCH_NOT_FOUND');
-            return { renewed: true };
+            return this.accepted(watch);
         }
         const topics = this.options.watch.parseTopics(input);
-        const snapshot = {};
-        if (topics.sessions)
-            snapshot.sessions = await this.options.listSessions(workspace.id);
-        if (topics.files !== undefined)
-            snapshot.files = { files: await this.options.files.list(workspace, topics.files) };
-        if (topics.changes)
-            snapshot.changes =
-                workspace.kind === 'GIT_WORKSPACE' ? await this.options.changes.current(workspace) : null;
-        if (topics.files !== undefined || topics.changes)
-            await this.options.files.index(workspace).observe();
-        const watch = this.options.watch.create(workspace.id, input.watchId, this.options.watch.sessionHash(input), topics);
-        return { watch: { expiresAt: watch.expiresAt }, snapshot };
+        const existing = this.options.watch.existing(workspace.id, this.options.watch.key(input));
+        if (existing?.watchId === input.watchId &&
+            JSON.stringify(existing.topics) === JSON.stringify(topics)) {
+            this.options.watch.renew(workspace.id, this.options.watch.key(input), input.watchId);
+            return this.accepted(existing);
+        }
+        const watch = this.options.watch.create(workspace.id, input.watchId, this.options.watch.sessionHash(input), input.workbenchConnectionId, this.options.nodeGeneration(), topics);
+        void this.createInitialSnapshots(workspace, watch);
+        return this.accepted(watch);
     }
     unwatch(input) {
         if (typeof input.workspaceId !== 'string' ||
             typeof input.watchId !== 'string' ||
+            typeof input.workbenchConnectionId !== 'string' ||
             !/^[A-Za-z0-9_-]{8,128}$/.test(input.watchId))
             throw new Error('WORKSPACE_WATCH_INVALID');
-        this.options.watch.remove(input.workspaceId, this.options.watch.key(input));
+        const key = this.options.watch.key(input);
+        const watch = this.options.watch.renew(input.workspaceId, key, input.watchId);
+        if (watch !== undefined)
+            this.options.watch.remove(input.workspaceId, key);
         return { stopped: true };
     }
+    accepted(watch) {
+        return {
+            accepted: true,
+            watchId: watch.watchId,
+            nodeGeneration: watch.nodeGeneration,
+            expiresAt: watch.expiresAt
+        };
+    }
+    async createInitialSnapshots(workspace, watch) {
+        const tasks = [];
+        const emit = async (topic, read) => {
+            try {
+                const payload = await read();
+                if (!this.options.watch.matches(workspace.id, `${watch.sessionHash}:${watch.workbenchConnectionId}`, watch.watchId))
+                    return;
+                this.options.emitWatchEvent({
+                    type: 'watch.workspace.snapshot',
+                    workbenchConnectionId: watch.workbenchConnectionId,
+                    watchId: watch.watchId,
+                    nodeGeneration: watch.nodeGeneration,
+                    nodeId: this.options.nodeId(),
+                    workspaceId: workspace.id,
+                    topic,
+                    revision: this.options.watch.nextRevision(workspace.id),
+                    snapshotSequence: this.options.watch.nextSnapshotSequence(),
+                    expiresAt: watch.expiresAt,
+                    payload
+                });
+            }
+            catch {
+                this.options.emitWatchEvent({
+                    type: 'watch.failed',
+                    workbenchConnectionId: watch.workbenchConnectionId,
+                    watchType: 'workspace',
+                    watchId: watch.watchId,
+                    nodeGeneration: watch.nodeGeneration,
+                    nodeId: this.options.nodeId(),
+                    workspaceId: workspace.id,
+                    topic,
+                    code: 'WORKSPACE_WATCH_SNAPSHOT_FAILED',
+                    message: 'Workspace watch snapshot failed.'
+                });
+            }
+        };
+        if (watch.topics.sessions)
+            tasks.push(emit('sessions', () => this.options.listSessions(workspace.id)));
+        if (watch.topics.files !== undefined)
+            tasks.push(emit('files', async () => ({
+                files: await this.options.files.list(workspace, watch.topics.files)
+            })));
+        if (watch.topics.changes)
+            tasks.push(emit('changes', async () => workspace.kind === 'GIT_WORKSPACE' ? this.options.changes.current(workspace) : null));
+        if (watch.topics.files !== undefined || watch.topics.changes)
+            void this.options.files
+                .index(workspace)
+                .observe()
+                .catch(() => undefined);
+        await Promise.all(tasks);
+    }
+    async emitSnapshot(workspace, watch, topic, read) {
+        try {
+            const payload = await read();
+            this.deliverSnapshot(workspace, watch, topic, payload);
+        }
+        catch {
+            this.options.emitWatchEvent({
+                type: 'watch.failed',
+                workbenchConnectionId: watch.workbenchConnectionId,
+                watchType: 'workspace',
+                watchId: watch.watchId,
+                nodeGeneration: watch.nodeGeneration,
+                nodeId: this.options.nodeId(),
+                workspaceId: workspace.id,
+                topic,
+                code: 'WORKSPACE_WATCH_SNAPSHOT_FAILED',
+                message: 'Workspace watch snapshot failed.'
+            });
+        }
+    }
+    deliverSnapshot(workspace, watch, topic, payload) {
+        if (!this.options.watch.matches(workspace.id, `${watch.sessionHash}:${watch.workbenchConnectionId}`, watch.watchId))
+            return;
+        this.options.emitWatchEvent({
+            type: 'watch.workspace.snapshot',
+            workbenchConnectionId: watch.workbenchConnectionId,
+            watchId: watch.watchId,
+            nodeGeneration: watch.nodeGeneration,
+            nodeId: this.options.nodeId(),
+            workspaceId: workspace.id,
+            topic,
+            revision: this.options.watch.nextRevision(workspace.id),
+            snapshotSequence: this.options.watch.nextSnapshotSequence(),
+            expiresAt: watch.expiresAt,
+            payload
+        });
+    }
     async listFiles(input) {
         const workspace = this.options.requireWorkspace(input.workspaceId);
         return { files: await this.options.files.list(workspace, input) };
@@ -112,6 +291,13 @@ export class WorkspaceWorkbenchService {
     async currentChanges(input) {
         return this.options.changes.current(this.options.requireWorkspace(input.workspaceId));
     }
+    async readFileContent(input) {
+        if (typeof input.workspaceId !== 'string')
+            throw new Error('WORKSPACE_NOT_FOUND');
+        return {
+            file: await this.options.files.readContent(this.options.requireWorkspace(input.workspaceId), input)
+        };
+    }
     async changeDiff(input) {
         if (typeof input.workspaceId !== 'string' ||
             typeof input.path !== 'string' ||
@@ -184,6 +370,19 @@ export class WorkspaceWorkbenchService {
             diff: await readGitHistoryFileDiff(await this.gitRepository(input), input.commit, input.path, this.refs(input), input.previousPath)
         };
     }
+    async gitCommitFileContent(input) {
+        if (typeof input.commit !== 'string' ||
+            typeof input.path !== 'string' ||
+            !Number.isSafeInteger(input.offset) ||
+            input.offset < 0 ||
+            !Number.isSafeInteger(input.limit) ||
+            input.limit < 1 ||
+            input.limit > 20 * 1024 * 1024)
+            throw new Error('FILE_RANGE_INVALID');
+        return {
+            file: await readGitHistoryFileContentRange(await this.gitRepository(input), input.commit, input.path, input.offset, input.limit, this.refs(input))
+        };
+    }
     async diff(input) {
         if (typeof input.workspaceId !== 'string' ||
             typeof input.fromRef !== 'string' ||

package/dist/util/personal-instructions.d.ts

@@ -0,0 +1,2 @@
+import type { RunnerName } from '@myagentroam/protocol';
+export declare function personalInstructionsForRunner(value: unknown, runner: RunnerName): string | undefined;

package/dist/util/personal-instructions.js

@@ -0,0 +1,31 @@
+const MAX_CONTENT_LENGTH = 20_000;
+export function personalInstructionsForRunner(value, runner) {
+    if (value === undefined)
+        return undefined;
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('PERSONAL_INSTRUCTION_INVALID');
+    const record = value;
+    const instructions = {
+        common: content(record['common']),
+        codex: content(record['codex']),
+        claudeCode: content(record['claudeCode']),
+        openCode: content(record['openCode'])
+    };
+    const specialized = runner === 'codex'
+        ? instructions.codex
+        : runner === 'claude-code'
+            ? instructions.claudeCode
+            : instructions.openCode;
+    const merged = [instructions.common, specialized].filter((item) => item.length > 0).join('\n\n');
+    return merged.length === 0 ? undefined : merged;
+}
+function content(value) {
+    if (value === undefined)
+        return '';
+    if (typeof value !== 'string')
+        throw new Error('PERSONAL_INSTRUCTION_INVALID');
+    const normalized = value.trim();
+    if (normalized.length > MAX_CONTENT_LENGTH)
+        throw new Error('PERSONAL_INSTRUCTION_INVALID');
+    return normalized;
+}

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

@@ -22,6 +22,7 @@ export declare function settleWithin<T>(promise: Promise<T>, milliseconds: numbe
 export declare function extractCodexThreads(result: unknown): readonly {
     readonly id: string;
     readonly source: string | undefined;
+    readonly derived: boolean;
     readonly cwd: unknown;
     readonly title: string | undefined;
 }[];

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

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { stripClaudePlanTag } from '../runner-command-engine.js';
 import { compactRunnerText, isClaudeCommandTool, isPlainRecord, nativeClaudeCommand, nativePageEnd } from './node-operation-parsers.js';
@@ -49,12 +50,17 @@ export function extractCodexThreads(result) {
                     typeof value.source.kind === 'string'
                     ? value.source.kind
                     : undefined;
+        const sourceRecord = isPlainRecord(value.source) ? value.source : undefined;
+        const derived = source === 'subagent' ||
+            sourceRecord?.kind === 'subagent' ||
+            isPlainRecord(sourceRecord?.subagent) ||
+            isPlainRecord(sourceRecord?.subAgent);
         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 }];
+        return [{ id: value.id, source, derived, cwd: value.cwd, title }];
     });
 }
 export function codexThreadActivity(result) {
@@ -106,6 +112,8 @@ export function claudeDiscoveredSession(value, fallbackCwd) {
     if (typeof value !== 'object' || value === null)
         return undefined;
     const record = value;
+    if (record.isSidechain === true)
+        return undefined;
     const externalSessionId = typeof record.sessionId === 'string'
         ? record.sessionId
         : typeof record.id === 'string'
@@ -145,26 +153,27 @@ export function deduplicateDirectSessions(sessions) {
 }
 export function nativeConversationPage(session, history, input, runtimeTurns = [], registerImages = () => []) {
     const limit = Math.min(Math.max(input.limit ?? 30, 1), 500);
+    const effectiveCursor = history.cursorReset === true ? undefined : input.cursor;
     const nativeTurns = nativeTranscriptTurns(history.items);
+    const nativeTurnIds = nativeTranscriptTurnIds(session.id, nativeTurns);
     const representedClientMessageIds = new Set(nativeTurns.flatMap((entries) => entries.flatMap(({ entry, index }) => {
         if (entry.kind !== 'message' || entry.role !== 'USER')
             return [];
         const clientMessageId = nativeUserClientMessageId(entry, entry.createdAt ?? index, runtimeTurns);
         return clientMessageId === null ? [] : [clientMessageId];
     })));
-    const missingRuntimeErrorTurns = input.cursor === undefined
+    const missingRuntimeErrorTurns = effectiveCursor === undefined
         ? runtimeTurns.filter((turn) => {
             const clientMessageId = runtimeTurnClientMessageId(turn);
             return (turn.items.some((item) => item.kind === 'error') &&
                 (clientMessageId === undefined || !representedClientMessageIds.has(clientMessageId)));
         })
         : [];
-    const end = nativePageEnd(input.cursor, session.id, nativeTurns.length);
+    const end = nativePageEnd(effectiveCursor, session.id, nativeTurns.length);
     const start = Math.max(0, end - limit);
     const nativePageTurns = nativeTurns
         .slice(start, end)
         .map((entries, relativeIndex) => {
-        const firstIndex = entries[0]?.index ?? 0;
         const nativeUser = entries.find(({ entry }) => entry.kind === 'message' && entry.role === 'USER')?.entry;
         const matchedClientMessageId = nativeUser?.kind === 'message'
             ? nativeUserClientMessageId(nativeUser, nativeUser.createdAt, runtimeTurns)
@@ -172,9 +181,10 @@ export function nativeConversationPage(session, history, input, runtimeTurns = [
         const runtimeTurn = typeof matchedClientMessageId === 'string'
             ? runtimeTurns.find((turn) => runtimeTurnClientMessageId(turn) === matchedClientMessageId)
             : undefined;
-        const turnId = runtimeTurn?.id ?? `${session.id}:native:${firstIndex}`;
-        const nativeItems = entries.map(({ entry, index }) => ({
-            ...nativeTranscriptConversationItem(session, entry, index, turnId, runtimeTurns, registerImages),
+        const turnId = runtimeTurn?.id ?? nativeTurnIds[start + relativeIndex];
+        const itemIdentities = nativeTranscriptItemIdentities(entries);
+        const nativeItems = entries.map(({ entry, index }, entryIndex) => ({
+            ...nativeTranscriptConversationItem(session, entry, index, itemIdentities[entryIndex], turnId, runtimeTurns, registerImages),
             runId: runtimeTurn?.runId ?? null
         }));
         const runtimeErrors = (runtimeTurn?.items ?? [])
@@ -214,11 +224,33 @@ export function nativeConversationPage(session, history, input, runtimeTurns = [
     const turns = combined.slice(-limit);
     const nativePageIds = new Set(nativePageTurns.map((turn) => turn.id));
     const nextEnd = start + dropped.filter((turn) => nativePageIds.has(turn.id)).length;
+    const cursorBase = {
+        sessionId: session.id,
+        ...(history.snapshotEnd === undefined ? {} : { snapshotEnd: history.snapshotEnd }),
+        ...(history.windowEnd === undefined ? {} : { nextEnd: history.windowEnd }),
+        ...(history.fileAnchor === undefined ? {} : { fileAnchor: history.fileAnchor }),
+        ...(history.anchorBytes === undefined ? {} : { anchorBytes: history.anchorBytes }),
+        readLimit: history.windowReadLimit ?? limit
+    };
+    const precedingWindow = history.truncated === true &&
+        history.windowStart !== undefined &&
+        history.snapshotEnd !== undefined &&
+        history.fileAnchor !== undefined &&
+        history.anchorBytes !== undefined
+        ? Buffer.from(JSON.stringify({
+            sessionId: session.id,
+            snapshotEnd: history.snapshotEnd,
+            nextEnd: history.windowStart,
+            fileAnchor: history.fileAnchor,
+            anchorBytes: history.anchorBytes,
+            readLimit: history.windowReadLimit ?? limit
+        })).toString('base64url')
+        : null;
     return {
         turns,
         nextCursor: nextEnd > 0
-            ? Buffer.from(JSON.stringify({ sessionId: session.id, end: nextEnd })).toString('base64url')
-            : null
+            ? Buffer.from(JSON.stringify({ ...cursorBase, end: nextEnd })).toString('base64url')
+            : precedingWindow
     };
 }
 function runtimeTurnClientMessageId(turn) {
@@ -230,6 +262,38 @@ function runtimeTurnClientMessageId(turn) {
 function lastNativeItemId(entries) {
     return entries.findLast(({ entry }) => entry.nativeId !== undefined)?.entry.nativeId;
 }
+function nativeTranscriptTurnIds(sessionId, turns) {
+    const occurrences = new Map();
+    return turns.map((entries) => {
+        const user = entries.find(({ entry }) => entry.kind === 'message' && entry.role === 'USER')?.entry;
+        const first = user ?? entries[0]?.entry;
+        const base = first?.nativeId ?? nativeTranscriptItemFingerprint(first);
+        const occurrence = occurrences.get(base) ?? 0;
+        occurrences.set(base, occurrence + 1);
+        return `${sessionId}:native:${base}${occurrence === 0 ? '' : `:${occurrence}`}`;
+    });
+}
+function nativeTranscriptItemIdentities(entries) {
+    const nativeIdCounts = new Map();
+    for (const { entry } of entries)
+        if (entry.nativeId !== undefined)
+            nativeIdCounts.set(entry.nativeId, (nativeIdCounts.get(entry.nativeId) ?? 0) + 1);
+    const occurrences = new Map();
+    return entries.map(({ entry }) => {
+        const base = entry.nativeId !== undefined && nativeIdCounts.get(entry.nativeId) === 1
+            ? entry.nativeId
+            : `${entry.nativeId === undefined ? '' : `${entry.nativeId}:`}${nativeTranscriptItemFingerprint(entry)}`;
+        const occurrence = occurrences.get(base) ?? 0;
+        occurrences.set(base, occurrence + 1);
+        return occurrence === 0 ? base : `${base}:${occurrence}`;
+    });
+}
+function nativeTranscriptItemFingerprint(entry) {
+    return createHash('sha256')
+        .update(JSON.stringify(entry ?? null))
+        .digest('base64url')
+        .slice(0, 24);
+}
 function nativeTranscriptTurns(items) {
     const turns = [];
     let current = [];
@@ -244,7 +308,7 @@ function nativeTranscriptTurns(items) {
         turns.push(current);
     return turns;
 }
-function nativeTranscriptConversationItem(session, entry, index, turnId, runtimeTurns, registerImages) {
+function nativeTranscriptConversationItem(session, entry, index, itemIdentity, turnId, runtimeTurns, registerImages) {
     const time = entry.createdAt;
     const isToolCall = entry.kind === 'tool_call';
     const isUnknown = entry.kind === 'unknown';
@@ -269,7 +333,7 @@ function nativeTranscriptConversationItem(session, entry, index, turnId, runtime
         : '';
     const planText = entry.kind === 'message' && entry.role !== 'USER' ? claudePlanText(entryText) : undefined;
     const item = {
-        id: `${turnId}:item:${index}`,
+        id: `${turnId}:item:${itemIdentity}`,
         sessionId: session.id,
         turnId,
         runId: null,
@@ -294,7 +358,7 @@ function nativeTranscriptConversationItem(session, entry, index, turnId, runtime
         status: 'COMPLETED',
         payload: isUserInputRequest
             ? {
-                requestId: `native:${entry.kind === 'tool_call' ? entry.toolUseId : `item-${index}`}`,
+                requestId: `native:${entry.kind === 'tool_call' ? entry.toolUseId : `item-${itemIdentity}`}`,
                 questions: userInputQuestions
             }
             : isReasoning

package/dist/workspace.d.ts

@@ -111,6 +111,13 @@ export declare function readWorkspaceTextFile(workspaceRoot: string, requestedPa
     readonly truncated: boolean;
     readonly nextOffset: number | null;
 }>;
+export declare function readWorkspaceFileContentRange(workspaceRoot: string, requestedPath: string, offset?: number, limit?: number): Promise<{
+    readonly path: string;
+    readonly size: number;
+    readonly offset: number;
+    readonly contentBase64: string;
+    readonly nextOffset: number | null;
+}>;
 /** Reads one absolute file only when the resolved target remains within a Node allowed root. */
 export declare function readAllowedTextFile(requestedPath: string, allowedRoots: readonly string[], offset?: number, limit?: number): Promise<{
     readonly path: string;
@@ -177,8 +184,13 @@ export declare function readGitHistoryFileDiff(repository: string, commit: strin
     readonly text?: string;
     readonly summary?: string;
     readonly truncated: boolean;
-    readonly beforePreview?: BinaryDiffPreview;
-    readonly afterPreview?: BinaryDiffPreview;
+}>;
+export declare function readGitHistoryFileContentRange(repository: string, commit: string, requestedPath: string, offset: number, limit: number, refs?: readonly string[]): Promise<{
+    readonly path: string;
+    readonly size: number;
+    readonly offset: number;
+    readonly contentBase64: string;
+    readonly nextOffset: number | null;
 }>;
 export declare function readCurrentChanges(workspacePath: string): Promise<readonly {
     readonly path: string;
@@ -192,15 +204,9 @@ 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 {