@myagentroam/node 0.9.4 → 0.9.5

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

@@ -49,12 +49,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 +111,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'

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 {

package/dist/workspace.js

@@ -1,13 +1,12 @@
 import { createHash } from 'node:crypto';
 import { watch } from 'node:fs';
-import { lstat, mkdir, opendir, readdir, readFile, realpath, rename, rm, stat, unlink, writeFile } from 'node:fs/promises';
+import { lstat, mkdir, opendir, open, readdir, readFile, realpath, rename, rm, stat, unlink, writeFile } from 'node:fs/promises';
 import { homedir, platform as hostPlatform } from 'node:os';
 import { dirname, isAbsolute, posix, relative, resolve, sep, win32 } from 'node:path';
 import { spawn } from 'node:child_process';
 import { minimatch } from 'minimatch';
 const GIT_TIMEOUT_MS = 5_000;
 const GIT_OUTPUT_LIMIT = 512 * 1024;
-const GIT_BINARY_PREVIEW_LIMIT = 4 * 1024 * 1024;
 const FILE_READ_LIMIT = 512 * 1024;
 const DIRECTORY_PAGE_LIMIT = 200;
 const DIRECTORY_PICKER_LIMIT = 200;
@@ -665,6 +664,38 @@ export async function readWorkspaceTextFile(workspaceRoot, requestedPath, offset
         nextOffset
     };
 }
+export async function readWorkspaceFileContentRange(workspaceRoot, requestedPath, offset = 0, limit = FILE_READ_LIMIT) {
+    if (!Number.isSafeInteger(offset) ||
+        offset < 0 ||
+        !Number.isSafeInteger(limit) ||
+        limit < 1 ||
+        limit > FILE_READ_LIMIT)
+        throw new Error('FILE_RANGE_INVALID');
+    const root = await realpath(workspaceRoot);
+    const file = await resolveWorkspaceEntry(root, requestedPath, false);
+    const metadata = await lstat(file);
+    if (!metadata.isFile())
+        throw new Error('FILE_NOT_REGULAR');
+    if (offset > metadata.size)
+        throw new Error('FILE_RANGE_INVALID');
+    const length = Math.min(limit, metadata.size - offset);
+    const source = Buffer.allocUnsafe(length);
+    const handle = await open(file, 'r');
+    try {
+        const { bytesRead } = await handle.read(source, 0, length, offset);
+        const end = offset + bytesRead;
+        return {
+            path: relative(root, file).split(sep).join('/'),
+            size: metadata.size,
+            offset,
+            contentBase64: source.subarray(0, bytesRead).toString('base64'),
+            nextOffset: end < metadata.size ? end : null
+        };
+    }
+    finally {
+        await handle.close();
+    }
+}
 /** Reads one absolute file only when the resolved target remains within a Node allowed root. */
 export async function readAllowedTextFile(requestedPath, allowedRoots, offset = 0, limit = FILE_READ_LIMIT) {
     if (!isAbsolute(requestedPath))
@@ -1212,20 +1243,44 @@ export async function readGitHistoryFileDiff(repository, commit, requestedPath,
     ]);
     const binary = result.output.includes(0) || result.text.includes('Binary files ');
     if (binary) {
-        const [beforePreview, afterPreview] = await Promise.all([
-            readGitBinaryPreview(repository, `${commit}^`, previousPath ?? path),
-            readGitBinaryPreview(repository, commit, path)
-        ]);
         return {
             binary: true,
             summary: `binary diff sha256=${createHash('sha256').update(result.output).digest('hex')} bytes=${result.output.length}`,
-            truncated: result.truncated,
-            ...(beforePreview === undefined ? {} : { beforePreview }),
-            ...(afterPreview === undefined ? {} : { afterPreview })
+            truncated: result.truncated
         };
     }
     return { binary: false, text: result.text, truncated: result.truncated };
 }
+export async function readGitHistoryFileContentRange(repository, commit, requestedPath, offset, limit, refs) {
+    if (!Number.isSafeInteger(offset) ||
+        offset < 0 ||
+        !Number.isSafeInteger(limit) ||
+        limit < 1 ||
+        limit > 20 * 1024 * 1024 ||
+        offset + limit > 20 * 1024 * 1024)
+        throw new Error('FILE_RANGE_INVALID');
+    await assertHistoryCommitReachable(repository, commit, refs);
+    const path = safeGitWorkspacePath(requestedPath);
+    const object = `${commit}:${path}`;
+    const sizeResult = await runGit(repository, ['cat-file', '-s', object]);
+    const size = Number(sizeResult.text.trim());
+    if (!Number.isSafeInteger(size) || size < 0 || offset > size)
+        throw new Error('FILE_RANGE_INVALID');
+    if (offset === size)
+        return { path, size, offset, contentBase64: '', nextOffset: null };
+    const result = await runGitAllowFailure(repository, ['cat-file', 'blob', object], offset + limit);
+    if (result.code !== 0)
+        throw new GitCommandError(result.code, result.stderr);
+    const content = result.output.subarray(offset, Math.min(size, offset + limit));
+    const nextOffset = offset + content.length;
+    return {
+        path,
+        size,
+        offset,
+        contentBase64: content.toString('base64'),
+        nextOffset: nextOffset < size ? nextOffset : null
+    };
+}
 export async function readCurrentChanges(workspacePath) {
     return (await readCurrentChangesSummary(workspacePath)).changes;
 }
@@ -1236,16 +1291,10 @@ export async function readCurrentChangeDiff(workspacePath, requestedPath) {
     const after = await readWorkingTreeText(workspacePath, path);
     const binary = result.output.includes(0) || result.text.includes('Binary files ') || after?.binary === true;
     if (binary) {
-        const [beforePreview, afterPreview] = await Promise.all([
-            readGitBinaryPreview(workspacePath, 'HEAD', path),
-            readWorkingTreeBinaryPreview(workspacePath, path)
-        ]);
         return {
             binary: true,
             summary: `binary diff sha256=${createHash('sha256').update(result.output).digest('hex')} bytes=${result.output.length}`,
-            truncated: result.truncated || after?.truncated === true,
-            ...(beforePreview === undefined ? {} : { beforePreview }),
-            ...(afterPreview === undefined ? {} : { afterPreview })
+            truncated: result.truncated || after?.truncated === true
         };
     }
     return {
@@ -1315,32 +1364,6 @@ async function assertCurrentChangePathAccessible(workspacePath, path) {
         return;
     await resolveWorkspaceEntry(root, path, false);
 }
-async function readGitBinaryPreview(repository, ref, path) {
-    const result = await runGitAllowFailure(repository, ['show', `${ref}:${path}`], GIT_BINARY_PREVIEW_LIMIT);
-    if (result.code !== 0)
-        return undefined;
-    return result.truncated
-        ? { truncated: true }
-        : { contentBase64: result.output.toString('base64'), truncated: false };
-}
-async function readWorkingTreeBinaryPreview(workspacePath, path) {
-    const root = await realpath(workspacePath);
-    let file;
-    try {
-        file = await resolveWorkspaceEntry(root, path, false);
-    }
-    catch (error) {
-        if (error instanceof Error && error.message === 'FILE_NOT_FOUND')
-            return undefined;
-        throw error;
-    }
-    const metadata = await lstat(file);
-    if (!metadata.isFile())
-        return undefined;
-    if (metadata.size > GIT_BINARY_PREVIEW_LIMIT)
-        return { truncated: true };
-    return { contentBase64: (await readFile(file)).toString('base64'), truncated: false };
-}
 async function readWorkingTreeText(workspacePath, path) {
     const root = await realpath(workspacePath);
     let file;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.9.4",
+  "version": "0.9.5",
   "description": "MyAgentRoam Node runtime CLI.",
   "type": "module",
   "files": [
@@ -24,7 +24,7 @@
     "node-pty": "1.1.0",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/protocol": "^0.9.4"
+    "@myagentroam/protocol": "^0.9.5"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"