@tequila99/githuman 0.7.0 → 0.9.0

package/dist/server/services/notes-operations.service.js

@@ -0,0 +1,296 @@
+import { noteChildPath, noteParentPath } from "../../shared/notes/note-path.js";
+import { randomUUID } from 'node:crypto';
+import { lstat } from 'node:fs/promises';
+import { noteReferences, referenceTarget, rewriteReferences, sameReference } from "../../shared/notes/references.js";
+import { NotFoundError } from "../errors/http.js";
+import { NoteConflictError, NoteExistsError } from "../errors/notes.js";
+import { errorMessage } from "../../shared/utils/error-message.js";
+export class NotesOperationsService {
+    files;
+    catalog;
+    writer;
+    record;
+    changed;
+    constructor(options) {
+        this.files = options.files;
+        this.catalog = options.catalog;
+        this.writer = options.writer;
+        this.record = options.record;
+        this.changed = options.changed;
+    }
+    issue(id, message, noteId, _candidate, _kind) {
+        this.catalog.issue({
+            id,
+            message,
+            noteId,
+            candidateId: null,
+            kind: 'rewrite'
+        });
+    }
+    async prepare(moves, source, target, folder, moved, preview, restore) {
+        const operation = {
+            id: randomUUID(),
+            moves: moves.map(move => ({
+                ...move,
+                version: this.record(move.id).version
+            })),
+            source,
+            target,
+            folder,
+            moved,
+            committed: false,
+            writes: []
+        };
+        if (restore)
+            operation.restore = restore;
+        const records = (preview ?? this.catalog.all()).filter(note => note.presence === 'present' && !note.redirectId && !note.deletedAt);
+        const oldPath = (note) => moves.find(move => move.id === note.id)?.from ?? note.path;
+        const newPath = (note) => moves.find(move => move.id === note.id)?.to ?? note.path;
+        const oldPaths = records.map(oldPath);
+        for (const record of records) {
+            const disk = await this.files.read(moved ? record.path : oldPath(record));
+            if (!moved && disk.version !== record.version) {
+                throw new NoteConflictError();
+            }
+            const refs = noteReferences(disk.text);
+            const links = this.catalog.links(record.id);
+            const changes = [];
+            for (const ref of refs) {
+                const matches = links.filter(link => sameReference(link.reference, ref));
+                if (matches.some(link => link.ambiguous))
+                    continue;
+                const known = new Set(matches.map(link => link.targetId)).size === 1
+                    ? matches[0]
+                    : undefined;
+                const resolved = referenceTarget(ref, oldPath(record), oldPaths);
+                const targetRecord = known?.targetId
+                    ? this.catalog.get(known.targetId)
+                    : records.find(note => oldPath(note) === resolved?.path);
+                let destination = targetRecord ? newPath(targetRecord) : resolved?.path;
+                if (destination &&
+                    !targetRecord &&
+                    source &&
+                    (destination === source ||
+                        (folder && destination.startsWith(source + '/')))) {
+                    destination = target + destination.slice(source.length);
+                }
+                if (!destination)
+                    continue;
+                if (newPath(record) !== oldPath(record) ||
+                    (targetRecord && newPath(targetRecord) !== oldPath(targetRecord)) ||
+                    destination !== resolved?.path) {
+                    changes.push({
+                        reference: ref,
+                        from: newPath(record),
+                        target: destination,
+                        anchor: known?.anchor ?? resolved?.anchor ?? ''
+                    });
+                }
+            }
+            const after = rewriteReferences(disk.text, changes);
+            if (after !== disk.text) {
+                operation.writes.push({
+                    id: record.id,
+                    path: newPath(record),
+                    before: disk.text,
+                    after,
+                    done: false
+                });
+            }
+        }
+        if (source) {
+            const stat = await lstat(await this.files.path(moved ? target : source, false));
+            operation.sourceFingerprint = stat.dev + ':' + stat.ino;
+        }
+        this.catalog.operation(operation);
+        return operation;
+    }
+    async execute(operation) {
+        await this.writer.assertOwner();
+        if (!operation.moved) {
+            const caseOnly = process.platform === 'win32' &&
+                operation.source !== operation.target &&
+                operation.source.toLowerCase() === operation.target.toLowerCase();
+            if (caseOnly && !operation.temporary) {
+                operation.temporary = noteChildPath(noteParentPath(operation.source), '__ght-case-' + operation.id + (operation.folder ? '' : '.md'));
+                this.catalog.operation(operation);
+            }
+            let fromPath = operation.source;
+            if (operation.temporary) {
+                if (await this.files.exists(operation.temporary)) {
+                    fromPath = operation.temporary;
+                }
+                else if (!(await this.files.exactEntry(operation.target))) {
+                    const stat = await lstat(await this.files.path(operation.source, false));
+                    if (operation.sourceFingerprint &&
+                        operation.sourceFingerprint !== stat.dev + ':' + stat.ino) {
+                        throw new NoteConflictError();
+                    }
+                    for (const move of operation.moves) {
+                        const disk = await this.files.read(move.from);
+                        if (move.version && disk.version !== move.version) {
+                            throw new NoteConflictError();
+                        }
+                    }
+                    await this.files.moveEntry(operation.source, operation.temporary, operation.folder);
+                    fromPath = operation.temporary;
+                }
+            }
+            const from = await this.files.exists(fromPath);
+            const to = await this.files.exists(operation.target);
+            if (from && to && !caseOnly)
+                throw new NoteExistsError();
+            const physical = from && !(caseOnly && (await this.files.exactEntry(operation.target)))
+                ? fromPath
+                : operation.target;
+            if (!(await this.files.exists(physical))) {
+                throw new NotFoundError('Both operation paths are missing. Recovery needs manual attention.');
+            }
+            if (operation.sourceFingerprint) {
+                const stat = await lstat(await this.files.path(physical, false));
+                if (operation.sourceFingerprint !== stat.dev + ':' + stat.ino) {
+                    throw new NoteConflictError();
+                }
+            }
+            for (const move of operation.moves) {
+                const actual = physical === operation.target
+                    ? move.to
+                    : fromPath + move.from.slice(operation.source.length);
+                const disk = await this.files.read(actual);
+                if (move.version && disk.version !== move.version) {
+                    throw new NoteConflictError();
+                }
+            }
+            if (physical !== operation.target) {
+                await this.files.moveEntry(fromPath, operation.target, operation.folder);
+            }
+            operation.moved = true;
+            this.catalog.operation(operation);
+        }
+        if (!operation.committed) {
+            if (operation.restore) {
+                const candidate = this.catalog.get(operation.restore.candidateId);
+                if (!candidate ||
+                    candidate.presence !== 'present' ||
+                    (await this.files.read(candidate.path)).version !==
+                        operation.restore.version) {
+                    throw new NoteConflictError();
+                }
+            }
+            this.catalog.transaction(() => {
+                if (operation.restore) {
+                    const candidate = this.record(operation.restore.candidateId);
+                    this.catalog.put({
+                        ...candidate,
+                        presence: 'missing',
+                        redirectId: operation.restore.previousId
+                    });
+                }
+                for (const move of operation.moves) {
+                    const record = this.record(move.id);
+                    this.catalog.put({ ...record, presence: 'missing' });
+                }
+                for (const move of operation.moves) {
+                    const record = this.record(move.id);
+                    this.catalog.put({ ...record, path: move.to, presence: 'present' });
+                    this.catalog.history(record.id, move.from, move.to, operation.id);
+                }
+                if (operation.restore) {
+                    this.catalog.setLinks(operation.restore.previousId, operation.restore.links);
+                }
+                operation.committed = true;
+                this.catalog.operation(operation);
+            });
+        }
+        let complete = true;
+        for (const write of operation.writes) {
+            if (write.done)
+                continue;
+            try {
+                await this.writer.assertOwner();
+                const disk = await this.files.read(write.path);
+                if (disk.text === write.after) {
+                    write.done = true;
+                }
+                else if (disk.text === write.before) {
+                    await this.files.save(write.path, write.after, disk.version);
+                    write.done = true;
+                }
+                else {
+                    throw new NoteConflictError();
+                }
+                this.catalog.dismiss('rewrite:' + operation.id + ':' + write.id);
+                this.catalog.operation(operation);
+                const fresh = await this.files.read(write.path);
+                this.changed(write.id, fresh);
+            }
+            catch (error) {
+                complete = false;
+                this.issue('rewrite:' + operation.id + ':' + write.id, 'Relative links need repair: ' + errorMessage(error), write.id, null, 'rewrite');
+            }
+        }
+        if (complete) {
+            this.catalog.dismiss('operation:' + operation.id);
+            this.catalog.finishOperation(operation.id);
+        }
+        return complete;
+    }
+    async recover() {
+        for (const operation of this.catalog.operations()) {
+            try {
+                await this.execute(operation);
+            }
+            catch (error) {
+                this.issue('operation:' + operation.id, 'File operation needs attention: ' + errorMessage(error), operation.moves[0]?.id ?? null, null, 'rewrite');
+            }
+        }
+    }
+    async retry() {
+        await this.writer.acquire();
+        const paths = this.catalog
+            .all()
+            .filter(note => !note.redirectId)
+            .map(note => note.path);
+        for (const operation of this.catalog.operations()) {
+            if (!operation.moved || !operation.committed)
+                continue;
+            for (const write of operation.writes.filter(item => !item.done)) {
+                const disk = await this.files.read(write.path);
+                if (disk.text === write.before || disk.text === write.after)
+                    continue;
+                const before = noteReferences(write.before);
+                const after = noteReferences(write.after);
+                const current = noteReferences(disk.text);
+                const changes = [];
+                let safe = before.length === after.length;
+                for (let i = 0; i < before.length && safe; i++) {
+                    const old = before[i];
+                    const next = after[i];
+                    if (old.href === next.href)
+                        continue;
+                    const matches = current.filter(ref => sameReference(ref, old));
+                    const corrected = current.filter(ref => sameReference(ref, next));
+                    if (matches.length === 0 && corrected.length === 1)
+                        continue;
+                    const target = referenceTarget(next, write.path, paths);
+                    if (matches.length !== 1 || !target) {
+                        safe = false;
+                        break;
+                    }
+                    changes.push({
+                        reference: matches[0],
+                        from: write.path,
+                        target: target.path,
+                        anchor: target.anchor
+                    });
+                }
+                if (!safe)
+                    continue;
+                write.before = disk.text;
+                write.after = rewriteReferences(disk.text, changes);
+                this.catalog.operation(operation);
+            }
+        }
+        await this.recover();
+    }
+}

package/dist/server/services/notes-watcher.service.js

@@ -0,0 +1,44 @@
+import { setInterval, clearInterval } from 'node:timers';
+import { errorMessage } from "../../shared/utils/error-message.js";
+// File metadata detects changes without reading every note body on each poll.
+const POLL_INTERVAL_MS = 2000;
+export function watchNotes(service, onChange) {
+    let previous = '';
+    // Last snapshot error. Publish an event only when this state changes.
+    let previousError = '';
+    let pending = false;
+    let closed = false;
+    async function check() {
+        if (pending || closed)
+            return;
+        pending = true;
+        try {
+            const next = await service.snapshot();
+            if (!closed && (previousError || (previous && previous !== next))) {
+                onChange();
+            }
+            previous = next;
+            previousError = '';
+        }
+        catch (error) {
+            const message = errorMessage(error);
+            if (!closed && message !== previousError)
+                onChange();
+            previousError = message;
+        }
+        finally {
+            pending = false;
+        }
+    }
+    void check();
+    const timer = setInterval(() => {
+        void check();
+    }, POLL_INTERVAL_MS);
+    timer.unref();
+    return {
+        close() {
+            closed = true;
+            clearInterval(timer);
+        }
+    };
+}

package/dist/server/services/notes-writer.service.js

@@ -0,0 +1,116 @@
+import { open, readFile, unlink, mkdir, realpath, lstat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { hostname } from 'node:os';
+import { randomUUID } from 'node:crypto';
+import { isRecord } from "../../shared/utils/guards.js";
+import { BadRequestError } from "../errors/http.js";
+import { isSystemError } from "../utils/system-error.js";
+// Same-process instances must also honor the filesystem writer lock.
+const OWNERS = new Set();
+async function readOwner(path) {
+    if ((await lstat(path)).isSymbolicLink()) {
+        throw new BadRequestError('Notes writer lock cannot be a symbolic link.');
+    }
+    const text = await readFile(path, 'utf8');
+    const value = JSON.parse(text);
+    if (!isRecord(value) ||
+        typeof value.pid !== 'number' ||
+        typeof value.host !== 'string' ||
+        typeof value.token !== 'string') {
+        throw new BadRequestError('Invalid notes writer lock. Verify its owner before removing it.');
+    }
+    return { pid: value.pid, host: value.host, token: value.token, text };
+}
+export class NotesWriter {
+    root = null;
+    token = randomUUID();
+    configuredRoot;
+    constructor(configuredRoot) {
+        this.configuredRoot = configuredRoot;
+    }
+    async acquire(create = false) {
+        if (this.root)
+            return this.assertOwner();
+        if (create)
+            await mkdir(this.configuredRoot, { recursive: true });
+        let root;
+        try {
+            root = await realpath(this.configuredRoot);
+        }
+        catch (error) {
+            if (isSystemError(error, 'ENOENT'))
+                return;
+            throw error;
+        }
+        if (OWNERS.has(root)) {
+            throw new BadRequestError('This notes storage already has an active writer.');
+        }
+        const path = join(root, '.githuman-writer.lock');
+        const data = JSON.stringify({
+            pid: process.pid,
+            host: hostname(),
+            token: this.token
+        });
+        for (let attempt = 0; attempt < 2; attempt++) {
+            try {
+                const file = await open(path, 'wx', 0o600);
+                try {
+                    await file.writeFile(data);
+                    await file.sync();
+                }
+                finally {
+                    await file.close();
+                }
+                this.root = root;
+                OWNERS.add(root);
+                return;
+            }
+            catch (error) {
+                if (!isSystemError(error, 'EEXIST'))
+                    throw error;
+                const owner = await readOwner(path);
+                const old = owner.text;
+                if (owner.host !== hostname() ||
+                    !Number.isSafeInteger(owner.pid) ||
+                    owner.pid <= 0) {
+                    throw new BadRequestError('Notes writer lock belongs to another host or has invalid ownership.');
+                }
+                try {
+                    process.kill(owner.pid, 0);
+                }
+                catch (killError) {
+                    if (isSystemError(killError, 'ESRCH')) {
+                        if ((await readFile(path, 'utf8')) === old)
+                            await unlink(path);
+                        continue;
+                    }
+                    throw killError;
+                }
+                throw new BadRequestError('This notes storage already has an active writer.');
+            }
+        }
+        throw new BadRequestError('Could not acquire the notes writer lock.');
+    }
+    async assertOwner() {
+        if (!this.root)
+            throw new BadRequestError('Notes writer is not active.');
+        const data = await readOwner(join(this.root, '.githuman-writer.lock'));
+        if (data.token !== this.token) {
+            throw new BadRequestError('Notes writer ownership changed.');
+        }
+    }
+    async close() {
+        if (!this.root)
+            return;
+        try {
+            await this.assertOwner();
+            await unlink(join(this.root, '.githuman-writer.lock'));
+        }
+        catch (error) {
+            if (!isSystemError(error, 'ENOENT'))
+                throw error;
+        }
+        OWNERS.delete(this.root);
+        this.root = null;
+    }
+}

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

@@ -0,0 +1,150 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { appendFile, readFile } from 'node:fs/promises';
+import { relative, resolve } from 'node:path';
+import { createTestDatabase } from "../db/index.js";
+import { NotesIdentityService } from "./notes-identity.service.js";
+import { NotesRepository } from "../repositories/notes.repo.js";
+import { noteMetadata } from "../../shared/notes/document.js";
+import { BadRequestError } from "../errors/http.js";
+import { errorMessage } from "../../shared/utils/error-message.js";
+import { MAX_NOTE_ASSET_BYTES } from "../../shared/notes/constants.js";
+import { detectNoteAssetFormat } from "../utils/note-asset-format.js";
+// Git error text depends on the locale. The "not a git repository" check below needs English.
+const GIT_ENV = { ...process.env, LC_ALL: 'C' };
+const execFileAsync = promisify(execFile);
+export class NotesService {
+    repository;
+    inspected;
+    exclusion;
+    identity;
+    snapshotValue = '';
+    warning = null;
+    projectPath;
+    root;
+    local;
+    bus;
+    constructor(projectPath, root, local, bus, db = createTestDatabase()) {
+        this.projectPath = projectPath;
+        this.root = root;
+        this.local = local;
+        this.bus = bus;
+        this.repository = new NotesRepository(root);
+        this.identity = new NotesIdentityService(this.repository, db);
+    }
+    async visibility(ensureIgnored = false) {
+        try {
+            const { stdout: gitRoot } = await execFileAsync('git', ['rev-parse', '--show-toplevel'], { cwd: this.projectPath, env: GIT_ENV });
+            const path = relative(gitRoot.trim(), this.root).replaceAll('\\', '/');
+            if (path.startsWith('../'))
+                return;
+            const { stdout: tracked } = await execFileAsync('git', ['ls-files', '--', path + '/'], { cwd: gitRoot.trim(), env: GIT_ENV });
+            if (tracked && this.local) {
+                this.warning =
+                    'Some notes are already tracked by Git. Ignoring them does not remove them from Git.';
+            }
+            if (!this.local || !ensureIgnored)
+                return;
+            const { stdout: exclude } = await execFileAsync('git', ['rev-parse', '--git-path', 'info/exclude'], { cwd: this.projectPath, env: GIT_ENV });
+            const target = resolve(this.projectPath, exclude.trim());
+            const rule = '/' + path.replace(/[*?[\]#! ]/g, char => '\\' + char) + '/';
+            const content = await readFile(target, 'utf8').catch(() => '');
+            if (!content.split(/\r?\n/).includes(rule)) {
+                await appendFile(target, '\n' + rule + '\n');
+            }
+        }
+        catch (error) {
+            if (!(error instanceof Error &&
+                'stderr' in error &&
+                String(error.stderr).includes('not a git repository'))) {
+                this.warning = 'Could not verify Git exclusion: ' + errorMessage(error);
+            }
+        }
+    }
+    async index() {
+        this.inspected ??= this.visibility();
+        await this.inspected;
+        const index = await this.identity.index();
+        this.snapshotValue = JSON.stringify([
+            index,
+            this.identity.catalog
+                .all()
+                .map(note => [note.id, note.version, note.presence, note.deletedAt]),
+            this.warning
+        ]);
+        return { ...index, warning: this.warning };
+    }
+    async snapshot() {
+        await this.index();
+        return this.snapshotValue;
+    }
+    read(path) {
+        return this.identity.readPath(path);
+    }
+    async save(path, text, version, id, storageId) {
+        await this.repository.path(path);
+        const metadata = noteMetadata(text);
+        if (metadata.error)
+            throw new BadRequestError(metadata.error);
+        this.exclusion ??= this.visibility(true);
+        await this.exclusion;
+        const note = id && storageId && version !== undefined
+            ? await this.identity.saveId(id, storageId, text, version)
+            : await this.identity.save(path, text, version);
+        this.bus.publish({ type: 'notes:changed' });
+        return note;
+    }
+    async delete(id, storageId) {
+        await this.identity.deleteId(id, storageId);
+        this.bus.publish({ type: 'notes:changed' });
+    }
+    async uploadAsset(bytes) {
+        if (!bytes.length || bytes.length > MAX_NOTE_ASSET_BYTES) {
+            throw new BadRequestError('Image must be under 10 MB');
+        }
+        const format = await detectNoteAssetFormat(bytes);
+        if (format.display !== 'image') {
+            throw new BadRequestError('Only image uploads are supported');
+        }
+        this.exclusion ??= this.visibility(true);
+        await this.exclusion;
+        const id = await this.identity.run(async () => {
+            await this.repository.path('assets/probe.png', false);
+            await this.identity.writer.acquire(true);
+            await this.identity.writer.assertOwner();
+            return this.repository.saveAsset(bytes, format.extension);
+        });
+        return { url: '/api/notes/assets/' + id };
+    }
+    async importAsset(chunks, extension, signal) {
+        this.exclusion ??= this.visibility(true);
+        await this.exclusion;
+        const staged = await this.repository.stageAsset(chunks, extension, signal);
+        try {
+            const id = await this.identity.run(async () => {
+                await this.identity.writer.acquire(true);
+                await this.identity.writer.assertOwner();
+                return staged.commit();
+            });
+            return '/api/notes/assets/' + id;
+        }
+        finally {
+            await staged.dispose();
+        }
+    }
+    readAsset(id) {
+        return this.repository.readAsset(id);
+    }
+    async rename(path, name, folder, target, id, revision) {
+        const result = await this.identity.rename(path, name, folder, target, id, revision);
+        this.bus.publish({ type: 'notes:changed' });
+        return result;
+    }
+    async folder(path) {
+        await this.repository.path(path, false);
+        this.exclusion ??= this.visibility(true);
+        await this.exclusion;
+        await this.identity.folder(path);
+        this.bus.publish({ type: 'notes:changed' });
+    }
+}

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

@@ -24,8 +24,9 @@ function promptPrefix(shellName) {
 function promptSetup(shellName) {
     const assign = `PS1=${promptPrefix(shellName)}"$PS1"`;
     const marker = "printf '\\033]133;A\\007'";
-    if (shellName === 'bash')
+    if (shellName === 'bash') {
         return `${assign}; history -d $HISTCMD || true; ${marker}`;
+    }
     return `${assign}; ${marker}`;
 }
 async function shellActivity(pid, prompt, rows) {
@@ -150,8 +151,9 @@ export class PipeBackend {
         this.child.stdout.setEncoding('utf8');
         this.child.stdout.on('data', (data) => {
             this.prompt.output(data);
-            for (const listener of this.dataListeners)
+            for (const listener of this.dataListeners) {
                 listener(data.replace(/\n/g, '\r\n'));
+            }
         });
         this.child.on('error', () => {
             for (const listener of this.exitListeners)
@@ -198,8 +200,9 @@ export class PipeBackend {
     }
 }
 export async function createBackend(cwd, cols, rows) {
-    if (!terminalSupported())
+    if (!terminalSupported()) {
         throw new TerminalError('The terminal is not available on Windows.');
+    }
     const module = await loadPty();
     if (!module)
         return new PipeBackend(cwd);

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

@@ -45,12 +45,13 @@ export class TerminalChannel {
                 switch (value.type) {
                     case 'create': {
                         const session = await this.registry.create(value.cols, value.rows);
-                        if (!this.stopped)
+                        if (!this.stopped) {
                             this.send({
                                 type: 'created',
                                 requestId: value.requestId,
                                 terminalId: session.id
                             });
+                        }
                         break;
                     }
                     case 'subscribe':
@@ -83,13 +84,14 @@ export class TerminalChannel {
                 }
             }
             catch (error) {
-                if (!this.stopped)
+                if (!this.stopped) {
                     this.send({
                         type: 'error',
                         ...('requestId' in value ? { requestId: value.requestId } : {}),
                         code: 'GHT_TERMINAL',
                         message: errorMessage(error)
                     });
+                }
             }
             return undefined;
         })
@@ -134,11 +136,12 @@ export class TerminalChannel {
             this.disconnect();
             return;
         }
-        for (const [key, bytes] of credit.frames)
+        for (const [key, bytes] of credit.frames) {
             if (key <= sequence) {
                 credit.bytes -= bytes;
                 credit.frames.delete(key);
             }
+        }
         this.flow(id, credit);
     }
     flow(id, credit) {