@tequila99/githuman 0.6.0 → 0.8.0

package/dist/server/services/terminal/registry.js

@@ -42,15 +42,18 @@ export class TerminalRegistry {
     }
     get(id) {
         const entry = this.entries.get(id);
-        if (!entry)
+        if (!entry) {
             throw new TerminalNotFoundError('Terminal session no longer exists.');
+        }
         return entry.session;
     }
     async create(cols, rows) {
-        if (this.stopped)
+        if (this.stopped) {
             throw new TerminalNotFoundError('Terminal server is stopping.');
-        if (this.entries.size + this.creating >= MAX_TERMINAL_SESSIONS)
+        }
+        if (this.entries.size + this.creating >= MAX_TERMINAL_SESSIONS) {
             throw new TerminalLimitError('The terminal limit has been reached.');
+        }
         this.creating++;
         try {
             const backend = await (this.options.backend ?? createBackend)(this.options.repositoryPath, cols, rows);
@@ -78,16 +81,18 @@ export class TerminalRegistry {
     }
     attach(id, subscriber) {
         const entry = this.entries.get(id);
-        if (!entry)
+        if (!entry) {
             throw new TerminalNotFoundError('Terminal session no longer exists.');
+        }
         entry.subscribers.add(subscriber);
         entry.orphanedSince = null;
         entry.idleSince = null;
     }
     detach(subscriber) {
         for (const entry of this.entries.values()) {
-            if (!entry.subscribers.delete(subscriber) || entry.subscribers.size)
+            if (!entry.subscribers.delete(subscriber) || entry.subscribers.size) {
                 continue;
+            }
             entry.orphanedSince = this.now();
             entry.idleSince = entry.session.running === 'idle' ? this.now() : null;
         }

package/dist/server/services/terminal/session.js

@@ -99,8 +99,9 @@ export class TerminalSession {
             let end = Math.min(data.length, offset + FRAME_PART_UNITS);
             if (end < data.length &&
                 data.charCodeAt(end - 1) >= HIGH_SURROGATE_FIRST &&
-                data.charCodeAt(end - 1) <= HIGH_SURROGATE_LAST)
+                data.charCodeAt(end - 1) <= HIGH_SURROGATE_LAST) {
                 end--;
+            }
             const part = data.slice(offset, end);
             offset = end;
             const bytes = Buffer.byteLength(part);
@@ -131,8 +132,9 @@ export class TerminalSession {
                 .catch(() => this.onExit())
                 .finally(() => {
                 this.pendingBytes -= bytes;
-                if (!this.stopped && this.pendingBytes < QUEUE_RESUME_BYTES)
+                if (!this.stopped && this.pendingBytes < QUEUE_RESUME_BYTES) {
                     this.updateFlow();
+                }
             });
         }
     }
@@ -167,8 +169,9 @@ export class TerminalSession {
                 scrollback = Math.floor(scrollback / 2);
                 data = this.serializer.serialize({ scrollback }) + this.tail.tail;
             }
-            if (Buffer.byteLength(data) > TERMINAL_SNAPSHOT_BYTES)
+            if (Buffer.byteLength(data) > TERMINAL_SNAPSHOT_BYTES) {
                 throw new TerminalError('Terminal snapshot exceeds its limit.');
+            }
             send({
                 type: 'snapshot',
                 terminalId: this.id,
@@ -186,8 +189,9 @@ export class TerminalSession {
             this.backend.write(data);
     }
     line(data) {
-        if (this.backend.mode !== 'pipe')
+        if (this.backend.mode !== 'pipe') {
             throw new TerminalError('Line input requires limited mode.');
+        }
         this.output(data.replace(/\n/g, '\r\n') + '\r\n');
         this.backend.write(data + '\n');
     }
@@ -203,8 +207,9 @@ export class TerminalSession {
         this.flush();
         this.queue = this.queue
             .then(() => {
-            if (this.stopped || (cols === this.cols && rows === this.rows))
+            if (this.stopped || (cols === this.cols && rows === this.rows)) {
                 return undefined;
+            }
             this.backend.resize(cols, rows);
             this.terminal.resize(cols, rows);
             this.cols = cols;

package/dist/server/services/terminal/tokens.js

@@ -10,8 +10,9 @@ export class TerminalTokens {
     }
     issue(origin) {
         this.prune();
-        if (this.tokens.size >= MAX_TOKENS)
+        if (this.tokens.size >= MAX_TOKENS) {
             this.tokens.delete(this.tokens.keys().next().value ?? '');
+        }
         const token = randomBytes(32).toString('base64url');
         this.tokens.set(token, { origin, expires: this.now() + TERMINAL_TOKEN_MS });
         return token;
@@ -22,9 +23,10 @@ export class TerminalTokens {
         return !!info && info.expires > this.now() && info.origin === origin;
     }
     prune() {
-        for (const [token, info] of this.tokens)
+        for (const [token, info] of this.tokens) {
             if (info.expires <= this.now())
                 this.tokens.delete(token);
+        }
     }
     clear() {
         this.tokens.clear();

package/dist/server/utils/hash.js

@@ -0,0 +1,4 @@
+import { createHash } from 'node:crypto';
+export function sha256Hex(data) {
+    return createHash('sha256').update(data).digest('hex');
+}

package/dist/server/utils/note-asset-format.js

@@ -0,0 +1,19 @@
+import { fileTypeFromBuffer } from 'file-type';
+import { NOTE_ASSET_FORMATS, SUPPORTED_NOTE_ASSETS } from "../../shared/notes/asset-formats.js";
+import { BadRequestError } from "../errors/http.js";
+export async function detectNoteAssetFormat(bytes) {
+    let detected;
+    try {
+        detected = await fileTypeFromBuffer(bytes);
+    }
+    catch (cause) {
+        throw new BadRequestError('Could not identify attachment format', { cause });
+    }
+    const format = detected &&
+        NOTE_ASSET_FORMATS.find(candidate => candidate.extension === detected.ext ||
+            candidate.aliases.some(alias => alias === detected.ext));
+    if (!format) {
+        throw new BadRequestError('Supported images: ' + SUPPORTED_NOTE_ASSETS);
+    }
+    return format;
+}

package/dist/server/utils/system-error.js

@@ -0,0 +1,14 @@
+export function hasErrorCode(error, ...codes) {
+    return (error !== null &&
+        typeof error === 'object' &&
+        'code' in error &&
+        typeof error.code === 'string' &&
+        codes.includes(error.code));
+}
+export function isSystemError(error, code) {
+    return error instanceof Error && hasErrorCode(error, code);
+}
+// Git file reads treat a non-directory path component as a missing path.
+export function isMissingPathError(error) {
+    return hasErrorCode(error, 'ENOENT', 'ENOTDIR');
+}

package/dist/shared/events/types.js

@@ -10,5 +10,6 @@ export const SERVER_EVENT_TYPES = [
     'comment:created',
     'comment:updated',
     'comment:deleted',
+    'notes:changed',
     'files:changed'
 ];

package/dist/shared/notes/asset-formats.js

@@ -0,0 +1,39 @@
+// Keep upload policy, response MIME types and asset identifiers in agreement.
+export const NOTE_ASSET_FORMATS = [
+    // Animated PNG retains the same storage extension as existing PNG attachments.
+    {
+        extension: 'png',
+        mime: 'image/png',
+        label: 'PNG',
+        display: 'image',
+        aliases: ['apng']
+    },
+    {
+        extension: 'jpg',
+        mime: 'image/jpeg',
+        label: 'JPEG',
+        display: 'image',
+        aliases: []
+    },
+    {
+        extension: 'gif',
+        mime: 'image/gif',
+        label: 'GIF',
+        display: 'image',
+        aliases: []
+    },
+    {
+        extension: 'webp',
+        mime: 'image/webp',
+        label: 'WebP',
+        display: 'image',
+        aliases: []
+    }
+];
+// Existing content hashes and extensions remain valid across server upgrades.
+export const NOTE_ASSET_ID_PATTERN = `^[a-f0-9]{64}\\.(${NOTE_ASSET_FORMATS.map(format => format.extension).join('|')})$`;
+// Error messages follow the same allowlist as upload validation.
+export const SUPPORTED_NOTE_ASSETS = NOTE_ASSET_FORMATS.map(format => format.label).join(', ');
+export function noteAssetFormat(extension) {
+    return NOTE_ASSET_FORMATS.find(format => format.extension === extension);
+}

package/dist/shared/notes/constants.js

@@ -0,0 +1,2 @@
+// Bound image uploads in both the browser and the multipart parser.
+export const MAX_NOTE_ASSET_BYTES = 10_000_000;

package/dist/shared/notes/document.js

@@ -0,0 +1,118 @@
+import { isRecord } from "../utils/guards.js";
+import { errorMessage } from "../utils/error-message.js";
+import { isMap, isSeq, isScalar, parseDocument } from 'yaml';
+export function splitNote(text) {
+    const bom = text.startsWith('\uFEFF') ? '\uFEFF' : '';
+    const source = text.slice(bom.length);
+    if (!/^---\r?\n/.test(source)) {
+        return {
+            head: bom,
+            body: source,
+            yaml: '',
+            eol: text.includes('\r\n') ? '\r\n' : '\n'
+        };
+    }
+    const match = source.match(/^---\r?\n([\s\S]*?)(?:^---[ \t]*(?:\r?\n|$))/m);
+    if (!match)
+        throw new Error('Unclosed YAML frontmatter');
+    return {
+        head: bom + match[0],
+        body: source.slice(match[0].length),
+        yaml: match[1] ?? '',
+        eol: match[0].includes('\r\n') ? '\r\n' : '\n'
+    };
+}
+export function noteMetadata(text) {
+    try {
+        const { doc } = parseNoteHeader(text);
+        const tags = doc.get('tags');
+        if (tags === undefined)
+            return { tags: [], error: null };
+        if (!isSeq(tags) ||
+            tags.items.some(item => !isScalar(item) || typeof item.value !== 'string')) {
+            throw new Error('tags must be a list of strings');
+        }
+        return {
+            tags: normalizeTags(tags.items.map(item => (isScalar(item) ? String(item.value) : ''))),
+            error: null
+        };
+    }
+    catch (error) {
+        return {
+            tags: [],
+            error: errorMessage(error)
+        };
+    }
+}
+export function normalizeTags(tags) {
+    return [...new Set(tags.map(tag => tag.trim()).filter(Boolean))];
+}
+export function setNoteTags(text, tags) {
+    const metadata = noteMetadata(text);
+    if (metadata.error)
+        throw new Error(metadata.error);
+    const next = normalizeTags(tags);
+    if (JSON.stringify(next) === JSON.stringify(metadata.tags))
+        return text;
+    const { parts, doc } = parseNoteHeader(text);
+    doc.set('tags', next);
+    return writeNoteHeader(text, parts, doc.toString());
+}
+function parseNoteHeader(text) {
+    const parts = splitNote(text);
+    const doc = parseDocument(parts.yaml);
+    if (doc.errors.length)
+        throw new Error(doc.errors[0]?.message);
+    if (doc.contents && !isMap(doc.contents)) {
+        throw new Error('Frontmatter must be a YAML mapping');
+    }
+    return { parts, doc };
+}
+export function noteProperties(text) {
+    const { doc } = parseNoteHeader(text);
+    if (!isMap(doc.contents))
+        return [];
+    const values = doc.toJS({ maxAliasCount: 100 });
+    if (!isRecord(values))
+        return [];
+    return doc.contents.items.map(item => {
+        if (!isScalar(item.key) || typeof item.key.value !== 'string') {
+            throw new Error('Property names must be strings');
+        }
+        const key = item.key.value;
+        return { key, value: values[key] };
+    });
+}
+function writeNoteHeader(text, parts, yaml) {
+    const bom = text.startsWith('\uFEFF') ? '\uFEFF' : '';
+    return (bom +
+        '---' +
+        parts.eol +
+        yaml.replace(/\n/g, parts.eol) +
+        '---' +
+        parts.eol +
+        parts.body);
+}
+export function setNoteProperty(text, key, value) {
+    if (!key.trim())
+        throw new Error('Property name must not be empty');
+    if (key === 'tags') {
+        if (!Array.isArray(value))
+            throw new Error('tags must be a list of strings');
+        return setNoteTags(text, value);
+    }
+    const { parts, doc } = parseNoteHeader(text);
+    const current = noteProperties(text).find(property => property.key === key);
+    if (current && JSON.stringify(current.value) === JSON.stringify(value)) {
+        return text;
+    }
+    doc.set(key, value);
+    return writeNoteHeader(text, parts, doc.toString());
+}
+export function removeNoteProperty(text, key) {
+    const { parts, doc } = parseNoteHeader(text);
+    if (!doc.has(key))
+        return text;
+    doc.delete(key);
+    return writeNoteHeader(text, parts, doc.toString());
+}

package/dist/shared/notes/identity.js

@@ -0,0 +1,24 @@
+import { isScalar, parseDocument } from 'yaml';
+import { isUuid } from "../utils/is-uuid.js";
+import { splitNote, setNoteProperty } from "./document.js";
+export function noteIdentity(text) {
+    try {
+        const doc = parseDocument(splitNote(text).yaml);
+        const value = doc.get('githuman_id', true);
+        if (value === undefined)
+            return { id: null, warning: null };
+        if (isScalar(value) && isUuid(value.value)) {
+            return { id: value.value.toLowerCase(), warning: null };
+        }
+        return {
+            id: null,
+            warning: 'githuman_id must be a UUID. The catalog identity is unchanged.'
+        };
+    }
+    catch {
+        return { id: null, warning: null };
+    }
+}
+export function withNoteIdentity(text, id) {
+    return setNoteProperty(text, 'githuman_id', id);
+}

package/dist/shared/notes/links.js

@@ -0,0 +1,44 @@
+export function noteLink(from, to) {
+    const base = from.split('/').slice(0, -1);
+    const target = to.split('/');
+    while (base.length && target.length && base[0] === target[0]) {
+        base.shift();
+        target.shift();
+    }
+    return [
+        ...base.map(() => '..'),
+        ...target.map(segment => encodeURIComponent(segment).replace(/[!'()*]/g, char => '%' + char.charCodeAt(0).toString(16)))
+    ].join('/');
+}
+export function resolveNoteLink(from, href) {
+    if (/^[a-z][a-z\d+.-]*:/i.test(href) || href.startsWith('//'))
+        return null;
+    if (href.startsWith('/') || href.includes('\\') || href.includes('?')) {
+        throw new Error('Invalid note link');
+    }
+    const [target = '', fragment = ''] = href.split('#');
+    const decoded = decodeURIComponent(target);
+    if (decoded.includes('\\') ||
+        decoded.includes('\0') ||
+        decoded.startsWith('/')) {
+        throw new Error('Invalid note link');
+    }
+    const parts = target ? from.split('/').slice(0, -1) : from.split('/');
+    for (const part of decoded.split('/')) {
+        if (!part || part === '.')
+            continue;
+        if (part === '..') {
+            if (!parts.length)
+                throw new Error('Link leaves the notes folder');
+            parts.pop();
+        }
+        else {
+            parts.push(part);
+        }
+    }
+    const path = parts.join('/');
+    if (!path.toLowerCase().endsWith('.md')) {
+        throw new Error('This link does not point to a Markdown note');
+    }
+    return { path, anchor: decodeURIComponent(fragment) };
+}

package/dist/shared/notes/reference-path.js

@@ -0,0 +1,54 @@
+export function localReference(from, href) {
+    if (/^[a-z][a-z\d+.-]*:/i.test(href) ||
+        href.startsWith('/') ||
+        href.includes('?')) {
+        return null;
+    }
+    const hash = href.indexOf('#');
+    const target = hash < 0 ? href : href.slice(0, hash);
+    const anchor = hash < 0 ? '' : href.slice(hash + 1);
+    try {
+        const decoded = decodeURIComponent(target);
+        if (decoded.startsWith('/') || /[\\\0]/.test(decoded))
+            return null;
+        const parts = target ? from.split('/').slice(0, -1) : from.split('/');
+        for (const part of decoded.split('/')) {
+            if (!part || part === '.')
+                continue;
+            if (part === '..') {
+                if (!parts.length)
+                    return null;
+                parts.pop();
+            }
+            else {
+                parts.push(part);
+            }
+        }
+        return { path: parts.join('/'), anchor };
+    }
+    catch {
+        return null;
+    }
+}
+export function wikiReference(value, from, paths) {
+    const match = value.match(/^\[\[([^\]|]+)(?:\|([^\]]+))?\]\]$/);
+    if (!match)
+        return null;
+    const [name = '', anchor = ''] = match[1].split('#');
+    const target = /\.md$/i.test(name) ? name : name + '.md';
+    const local = localReference(from, target.split('/').map(encodeURIComponent).join('/'))?.path;
+    const candidates = paths.filter(path => path.split('/').at(-1) === target);
+    const path = local && paths.includes(local)
+        ? local
+        : paths.includes(target)
+            ? target
+            : candidates.length === 1
+                ? candidates[0]
+                : null;
+    return {
+        path,
+        anchor,
+        label: match[2] ?? name.replace(/\.md$/i, ''),
+        ambiguous: candidates.length > 1 && !path
+    };
+}

package/dist/shared/notes/references.js

@@ -0,0 +1,190 @@
+import { localReference, wikiReference } from "./reference-path.js";
+export { localReference, wikiReference } from "./reference-path.js";
+import { fromMarkdown } from 'mdast-util-from-markdown';
+import { isMap, isSeq, isScalar, parseDocument } from 'yaml';
+import { splitNote } from "./document.js";
+import { noteLink } from "./links.js";
+import { safeDecodeURIComponent } from "../utils/safe-decode.js";
+// The AST excludes code and HTML; this scanner locates only a parsed destination.
+function destinationRange(source, definition) {
+    let depth = 0;
+    let cursor = source.startsWith('!') ? 1 : 0;
+    for (; cursor < source.length; cursor++) {
+        if (source[cursor] === '\\') {
+            cursor++;
+            continue;
+        }
+        if (source[cursor] === '[')
+            depth++;
+        if (source[cursor] === ']' && --depth === 0) {
+            cursor++;
+            break;
+        }
+    }
+    while (/\s/.test(source[cursor] ?? '') && cursor < source.length)
+        cursor++;
+    if (source[cursor] !== (definition ? ':' : '('))
+        return null;
+    cursor++;
+    while (cursor < source.length && /\s/.test(source[cursor]))
+        cursor++;
+    const angle = source[cursor] === '<';
+    if (angle)
+        cursor++;
+    const start = cursor;
+    depth = 0;
+    for (; cursor < source.length; cursor++) {
+        const char = source[cursor];
+        if (char === '\\') {
+            cursor++;
+            continue;
+        }
+        if (angle && char === '>')
+            break;
+        if (!angle) {
+            if (char === '(')
+                depth++;
+            if (char === ')') {
+                if (!depth)
+                    break;
+                depth--;
+            }
+            if (/\s/.test(char))
+                break;
+        }
+    }
+    return cursor >= start ? [start, cursor] : null;
+}
+export function noteReferences(text) {
+    let parts;
+    try {
+        parts = splitNote(text);
+    }
+    catch {
+        return [];
+    }
+    const result = [];
+    const bodyOffset = text.length - parts.body.length;
+    const tree = fromMarkdown(parts.body);
+    const uses = new Map();
+    const definitions = new Map();
+    const visit = (node) => {
+        if (node.type === 'linkReference' || node.type === 'imageReference') {
+            const group = uses.get(node.identifier) ?? [];
+            group.push({
+                position: bodyOffset + (node.position?.start.offset ?? 0),
+                image: node.type === 'imageReference'
+            });
+            uses.set(node.identifier, group);
+        }
+        if (node.type === 'link' ||
+            node.type === 'image' ||
+            node.type === 'definition') {
+            const start = node.position?.start.offset;
+            const end = node.position?.end.offset;
+            if (start !== undefined && end !== undefined) {
+                const raw = parts.body.slice(start, end);
+                const range = destinationRange(raw, node.type === 'definition');
+                if (range) {
+                    result.push({
+                        href: node.url,
+                        start: bodyOffset + start + range[0],
+                        end: bodyOffset + start + range[1],
+                        context: raw.slice(0, range[0]) + '<href>' + raw.slice(range[1]),
+                        format: 'markdown',
+                        image: node.type === 'image',
+                        displayStarts: [bodyOffset + start]
+                    });
+                }
+                if (range && node.type === 'definition') {
+                    definitions.set(result[result.length - 1], node.identifier);
+                }
+            }
+        }
+        if ('children' in node)
+            for (const child of node.children)
+                visit(child);
+    };
+    visit(tree);
+    for (const [ref, identifier] of definitions) {
+        const references = uses.get(identifier) ?? [];
+        ref.displayStarts = references.map(use => use.position);
+        ref.image = references.length > 0 && references.every(use => use.image);
+    }
+    try {
+        const doc = parseDocument(parts.yaml);
+        const offset = text.indexOf(parts.yaml, text.startsWith('\uFEFF') ? 5 : 4);
+        if (doc.errors.length || !isMap(doc.contents))
+            return result;
+        const scalar = (value, key) => {
+            if (!isScalar(value) || typeof value.value !== 'string' || !value.range) {
+                return;
+            }
+            const wiki = value.value.startsWith('[[');
+            if (!wiki && !/\.md(?:#|$)/i.test(value.value))
+                return;
+            result.push({
+                href: value.value,
+                start: offset + value.range[0],
+                end: offset + value.range[1],
+                context: 'yaml:' + key,
+                format: wiki ? 'wiki' : 'yaml',
+                image: false,
+                displayStarts: [offset + value.range[0]]
+            });
+        };
+        for (const pair of doc.contents.items) {
+            if (!isScalar(pair.key) ||
+                pair.key.value === 'githuman_id' ||
+                pair.key.value === 'tags') {
+                continue;
+            }
+            const key = String(pair.key.value);
+            if (isSeq(pair.value)) {
+                for (const value of pair.value.items)
+                    scalar(value, key);
+            }
+            else {
+                scalar(pair.value, key);
+            }
+        }
+    }
+    catch {
+        /* Invalid YAML must not prevent indexing the Markdown body. */
+    }
+    return result;
+}
+export function referenceTarget(ref, from, paths) {
+    if (ref.format === 'wiki') {
+        const wiki = wikiReference(ref.href, from, paths);
+        return wiki?.path
+            ? { path: wiki.path, anchor: encodeURIComponent(wiki.anchor) }
+            : null;
+    }
+    return localReference(from, ref.href);
+}
+export function rewriteReferences(text, changes) {
+    let result = text;
+    for (const change of [...changes].sort((a, b) => b.reference.start - a.reference.start)) {
+        const ref = change.reference;
+        const href = noteLink(change.from, change.target) +
+            (change.anchor ? '#' + change.anchor : '');
+        let replacement = href;
+        if (ref.format === 'wiki') {
+            const alias = ref.href.match(/\|([^\]]+)\]\]$/)?.[1];
+            replacement =
+                '[[' +
+                    change.target.replace(/\.md$/i, '') +
+                    (change.anchor ? '#' + safeDecodeURIComponent(change.anchor) : '') +
+                    (alias ? '|' + alias : '') +
+                    ']]';
+        }
+        if (ref.format !== 'markdown')
+            replacement = JSON.stringify(replacement);
+        result = result.slice(0, ref.start) + replacement + result.slice(ref.end);
+    }
+    return result;
+}
+export function sameReference(a, b) {
+    return a.href === b.href && a.context === b.context && a.format === b.format;
+}