@tequila99/githuman 0.7.0 → 0.9.0

package/dist/server/services/agent/context-builder.js

@@ -162,7 +162,20 @@ async function buildAttachmentItem(item, deps) {
         ...(item.mimeType === '' ? {} : { mimeType: item.mimeType })
     };
 }
+async function buildNoteItem(item, deps) {
+    try {
+        if (!deps.notes)
+            throw new AgentContextError('Notes are unavailable');
+        const note = await deps.notes.identity.readId(item.noteId, item.storageId);
+        return embed(deps, `githuman://note/${encodeURIComponent(item.storageId)}/${encodeURIComponent(item.noteId)}`, `Note ${note.path}:`, 'text/markdown', `Note: ${note.path}\n\n${note.text}`);
+    }
+    catch (error) {
+        throw asContextError(error);
+    }
+}
 function buildItem(item, deps) {
+    if (item.kind === 'note')
+        return buildNoteItem(item, deps);
     if (item.kind === 'diff') {
         return buildDiffItem(item, deps);
     }

package/dist/server/services/git.service.js

@@ -1,6 +1,7 @@
+import { isMissingPathError } from "../utils/system-error.js";
 import { execFile, spawn } from 'node:child_process';
 import { promisify } from 'node:util';
-import { readFile } from 'node:fs/promises';
+import { readFile, realpath } from 'node:fs/promises';
 import { basename, posix, resolve, sep } from 'node:path';
 import { simpleGit } from 'simple-git';
 import { GitFileNotFoundError } from "../errors/git.js";
@@ -49,13 +50,6 @@ function objectSpecFor(ref, path) {
     // the injection this would otherwise guard against.
     return ref === 'INDEX' ? `:${path}` : `${ref}:${path}`;
 }
-/** `ENOENT` and `ENOTDIR` both mean that the file does not exist. */
-function isMissingPathError(error) {
-    return (!!error &&
-        typeof error === 'object' &&
-        'code' in error &&
-        (error.code === 'ENOENT' || error.code === 'ENOTDIR'));
-}
 /**
  * Checks one path with `ls-tree` instead of listing the whole tree. A failing
  * `ls-tree` means the ref is invalid, so the path is reported as present and
@@ -88,16 +82,25 @@ export async function getFileAtRef(repoPath, ref, path, strict = false) {
     if (ref === 'WORKTREE') {
         try {
             const absolutePath = resolveWithinRepo(repoPath, path);
-            const buffer = await readFile(absolutePath);
+            let target = absolutePath;
+            if (strict) {
+                const [root, file] = await Promise.all([
+                    realpath(repoPath),
+                    realpath(absolutePath)
+                ]);
+                target = resolveWithinRepo(root, file);
+            }
+            const buffer = await readFile(target);
             const isBinary = isBinaryBuffer(buffer);
             return { content: isBinary ? '' : buffer.toString('utf-8'), isBinary };
         }
         catch (error) {
             if (strict) {
-                if (isMissingPathError(error))
+                if (isMissingPathError(error)) {
                     throw new GitFileNotFoundError('File was deleted or moved', {
                         cause: error
                     });
+                }
                 throw error;
             }
             return { content: '', isBinary: false };
@@ -118,10 +121,11 @@ export async function getFileAtRef(repoPath, ref, path, strict = false) {
     }
     catch (error) {
         if (strict) {
-            if (!(await pathExistsAtRef(repoPath, ref, path)))
+            if (!(await pathExistsAtRef(repoPath, ref, path))) {
                 throw new GitFileNotFoundError('File was deleted or moved', {
                     cause: error
                 });
+            }
             throw error;
         }
         return { content: '', isBinary: false };

package/dist/server/services/notes-external-assets.service.js

@@ -0,0 +1,177 @@
+import PQueue from 'p-queue';
+import { BadRequestError } from "../errors/http.js";
+import { NoteAssetLimitError, NoteAssetQueueError } from "../errors/note-assets.js";
+import { remoteAssetRequest, translateRemoteAssetError } from "../utils/remote-asset-request.js";
+import { detectNoteAssetFormat } from "../utils/note-asset-format.js";
+import { MAX_NOTE_ASSET_BYTES, NOTE_PDF_WARNING_BYTES } from "../../shared/notes/constants.js";
+import { maxNoteAssetBytes } from "../../shared/notes/asset-formats.js";
+// Limit disk and memory pressure across imports and background previews.
+const ACTIVE_LIMIT = 3;
+const QUEUE_LIMIT = 30;
+// Bound active operations so stalled imports cannot occupy queue slots indefinitely.
+const OPERATION_TIMEOUT_MS = 120000;
+// A small prefix is sufficient for supported image and PDF signatures.
+const FORMAT_PREFIX_BYTES = 8192;
+// Explain the preview limit to the client in megabytes.
+const PREVIEW_LIMIT_MESSAGE = `Image exceeds ${MAX_NOTE_ASSET_BYTES / 1_000_000} MB`;
+// Yields Buffer chunks and fails once the total passes the limit.
+async function* boundedChunks(source, limit, counter, signal, message) {
+    for await (const value of source) {
+        signal.throwIfAborted();
+        const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
+        counter.bytes += chunk.length;
+        if (counter.bytes > limit)
+            throw new NoteAssetLimitError(message);
+        yield chunk;
+    }
+}
+function isSuccess(response) {
+    return (!!response.statusCode &&
+        response.statusCode >= 200 &&
+        response.statusCode < 300);
+}
+export class NotesExternalAssetsService {
+    queue = new PQueue({ concurrency: ACTIVE_LIMIT });
+    request;
+    constructor(request = remoteAssetRequest) {
+        this.request = request;
+    }
+    run(signal, priority, work) {
+        signal.throwIfAborted();
+        if (this.queue.pending >= ACTIVE_LIMIT && this.queue.size >= QUEUE_LIMIT) {
+            throw new NoteAssetQueueError();
+        }
+        // The queue removes a task that waits when its signal aborts. A running
+        // task stops through the signal that it receives.
+        return this.queue.add(async () => {
+            try {
+                return await work(AbortSignal.any([signal, AbortSignal.timeout(OPERATION_TIMEOUT_MS)]));
+            }
+            catch (error) {
+                throw translateRemoteAssetError(error);
+            }
+        }, { priority: priority ? 1 : 0, signal });
+    }
+    async inspect(url, signal) {
+        return this.run(signal, false, async (abort) => {
+            const response = await this.request(url, 'HEAD', abort);
+            try {
+                return {
+                    size: isSuccess(response) ? this.length(response) : null
+                };
+            }
+            finally {
+                response.destroy();
+            }
+        });
+    }
+    length(response) {
+        const value = response.headers['content-length'];
+        if (!value || !/^\d+$/.test(value))
+            return null;
+        const size = Number(value);
+        return Number.isSafeInteger(size) ? size : null;
+    }
+    async importAsset(input, signal, save) {
+        return this.run(signal, true, async (abort) => {
+            const response = await this.request(input.url, 'GET', abort);
+            try {
+                this.checkResponse(response);
+                const fileLimit = maxNoteAssetBytes(input.kind);
+                const warningLimit = input.kind === 'pdf' && !input.allowLargePdf
+                    ? NOTE_PDF_WARNING_BYTES
+                    : fileLimit;
+                const limit = Math.min(input.remainingBytes, fileLimit, warningLimit);
+                const over = (size) => {
+                    if (size <= limit)
+                        return undefined;
+                    if (size > input.remainingBytes) {
+                        return { status: 'rejected', reason: 'operation-limit' };
+                    }
+                    if (size > fileLimit) {
+                        return { status: 'rejected', reason: 'file-too-large' };
+                    }
+                    return {
+                        status: 'confirmation-required',
+                        size: this.length(response)
+                    };
+                };
+                const known = this.length(response);
+                if (known !== null) {
+                    const result = over(known);
+                    if (result)
+                        return result;
+                }
+                const counter = { bytes: 0 };
+                const iterator = boundedChunks(response, limit, counter, abort, 'Attachment download limit reached');
+                const prefix = [];
+                let prefixBytes = 0;
+                try {
+                    while (prefixBytes < FORMAT_PREFIX_BYTES) {
+                        const next = await iterator.next();
+                        if (next.done)
+                            break;
+                        prefix.push(next.value);
+                        prefixBytes += next.value.length;
+                    }
+                    const format = await detectNoteAssetFormat(Buffer.concat(prefix));
+                    if ((format.display === 'link' ? 'pdf' : 'image') !== input.kind) {
+                        throw new BadRequestError('Attachment type does not match the selected resource');
+                    }
+                    const body = async function* () {
+                        yield* prefix;
+                        yield* iterator;
+                    };
+                    const url = await save(body(), format.extension, abort);
+                    return {
+                        status: 'stored',
+                        url,
+                        bytes: counter.bytes,
+                        format: format.extension
+                    };
+                }
+                catch (error) {
+                    if (error instanceof NoteAssetLimitError)
+                        return over(counter.bytes);
+                    throw error;
+                }
+            }
+            finally {
+                response.destroy();
+            }
+        });
+    }
+    async preview(url, signal) {
+        return this.run(signal, false, async (abort) => {
+            const response = await this.request(url, 'GET', abort);
+            try {
+                this.checkResponse(response);
+                if ((this.length(response) ?? 0) > MAX_NOTE_ASSET_BYTES) {
+                    throw new NoteAssetLimitError(PREVIEW_LIMIT_MESSAGE);
+                }
+                const chunks = [];
+                for await (const chunk of boundedChunks(response, MAX_NOTE_ASSET_BYTES, { bytes: 0 }, abort, PREVIEW_LIMIT_MESSAGE)) {
+                    chunks.push(chunk);
+                }
+                const body = Buffer.concat(chunks);
+                const format = await detectNoteAssetFormat(body);
+                if (format.display !== 'image') {
+                    throw new BadRequestError('Preview is not an image');
+                }
+                return { body, mime: format.mime };
+            }
+            finally {
+                response.destroy();
+            }
+        });
+    }
+    checkResponse(response) {
+        if (!isSuccess(response)) {
+            throw new BadRequestError('Attachment server returned HTTP ' + response.statusCode);
+        }
+        if (response.headers['content-encoding'] &&
+            response.headers['content-encoding'] !== 'identity') {
+            throw new BadRequestError('Compressed attachment responses are not supported');
+        }
+    }
+}