@myagentroam/node 0.9.3 → 0.9.5

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,47 +1243,58 @@ 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;
 }
 export async function readCurrentChangeDiff(workspacePath, requestedPath) {
     const path = safeGitWorkspacePath(requestedPath);
     await assertCurrentChangePathAccessible(workspacePath, path);
-    const result = await runGit(workspacePath, [
-        'diff',
-        '--no-ext-diff',
-        '--no-textconv',
-        'HEAD',
-        '--',
-        `:(literal)${path}`
-    ]);
+    const result = await readCurrentChangeGitDiff(workspacePath, path);
     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 {
@@ -1263,6 +1305,38 @@ export async function readCurrentChangeDiff(workspacePath, requestedPath) {
         ...(after === undefined ? {} : { afterTruncated: after.truncated })
     };
 }
+async function readCurrentChangeGitDiff(workspacePath, path) {
+    const untracked = await runGit(workspacePath, [
+        'ls-files',
+        '--others',
+        '--exclude-standard',
+        '-z',
+        '--',
+        `:(literal)${path}`
+    ]);
+    if (untracked.text.split('\0').includes(path)) {
+        const result = await runGitAllowFailure(workspacePath, [
+            'diff',
+            '--no-index',
+            '--no-ext-diff',
+            '--no-textconv',
+            '--',
+            '/dev/null',
+            path
+        ]);
+        if (result.code !== 0 && result.code !== 1)
+            throw new GitCommandError(result.code, result.stderr);
+        return result;
+    }
+    return runGit(workspacePath, [
+        'diff',
+        '--no-ext-diff',
+        '--no-textconv',
+        'HEAD',
+        '--',
+        `:(literal)${path}`
+    ]);
+}
 /** Current Changes must not expose an external link. */
 export async function isWorkspaceChangeVisible(workspacePath, requestedPath) {
     try {
@@ -1290,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.3",
+  "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.3"
+    "@myagentroam/protocol": "^0.9.5"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"