@shipwithai/loopnote 0.0.0-stage → 2.0.0-bootstrap.0

package/dist/server/export-store.js

@@ -0,0 +1,291 @@
+import { randomUUID } from 'node:crypto';
+import { lstat, mkdir, open, readdir, readFile, rename, rm } from 'node:fs/promises';
+import { join, relative, resolve } from 'node:path';
+import { hashExportBytes, parseCanonicalReviewExport } from '../export/review-export.js';
+import { renderReviewMarkdown } from '../export/render-review-markdown.js';
+import { RENAME_MAP } from '../domain/product-identity.js';
+import { assertAttachedStorageScope } from './draft-loader.js';
+export class ReExportUnsupported extends Error {
+    constructor() {
+        super('The current packaged target has no observed native directory exchange support.');
+    }
+}
+function isMissing(error) {
+    return typeof error === 'object' && error !== null && 'code' in error && error.code === 'ENOENT';
+}
+async function syncDirectory(path) {
+    try {
+        const handle = await open(path, 'r');
+        try {
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch (error) {
+        if (!(typeof error === 'object' && error !== null && 'code' in error && ['EINVAL', 'ENOTSUP', 'EISDIR'].includes(String(error.code)))) {
+            throw error;
+        }
+    }
+}
+async function writeFileExactly(path, bytes) {
+    const handle = await open(path, 'wx', 0o600);
+    try {
+        await handle.writeFile(bytes);
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function completePair(path) {
+    const directory = await lstat(path);
+    if (!directory.isDirectory() || directory.isSymbolicLink()) {
+        throw new Error('Managed export directory is not a real directory.');
+    }
+    const names = await readdir(path);
+    if (names.length !== 2 || !names.includes('review.json') || !names.includes('review.md')) {
+        throw new Error('Managed export directory does not contain exactly the review pair.');
+    }
+    const [jsonInfo, markdownInfo, json, markdown] = await Promise.all([
+        lstat(join(path, 'review.json')),
+        lstat(join(path, 'review.md')),
+        readFile(join(path, 'review.json')),
+        readFile(join(path, 'review.md')),
+    ]);
+    if (!jsonInfo.isFile() || jsonInfo.isSymbolicLink() || !markdownInfo.isFile() || markdownInfo.isSymbolicLink()) {
+        throw new Error('Managed export pair contains an unsupported file type.');
+    }
+    return Object.freeze({ json, markdown });
+}
+async function stableExists(path) {
+    try {
+        await completePair(path);
+        return true;
+    }
+    catch (error) {
+        if (isMissing(error))
+            return false;
+        throw error;
+    }
+}
+function stableNameFor(identity, storageScope) {
+    if (storageScope !== undefined) {
+        try {
+            return assertAttachedStorageScope(storageScope);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (identity.kind === 'range' || identity.kind === 'exact-patch' || identity.kind === 'standalone') {
+        return Object.keys(identity).length === 2 && /^[0-9a-f]{64}$/u.test(identity.reviewKey)
+            ? identity.reviewKey
+            : undefined;
+    }
+    return Object.keys(identity).length === 3
+        && /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/u.test(identity.baseOid)
+        && /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/u.test(identity.headOid)
+        ? `${identity.baseOid}..${identity.headOid}`
+        : undefined;
+}
+function matchesPublicationIdentity(document, identity) {
+    if (identity.kind === 'standalone') {
+        return document.schemaVersion === 4 && document.standalone.reviewKey === identity.reviewKey;
+    }
+    if (identity.kind === 'exact-patch') {
+        return document.schemaVersion === 3 && document.patch.reviewKey === identity.reviewKey;
+    }
+    return identity.kind === 'range'
+        ? document.schemaVersion === 2 && document.range.reviewKey === identity.reviewKey
+        : document.schemaVersion === 1
+            && document.comparison.selectedBase.launchOid === identity.baseOid
+            && document.comparison.selectedHead.launchOid === identity.headOid;
+}
+function receipt(exportsRoot, stable, pair) {
+    const stableRelative = relative(exportsRoot, stable).split('\\').join('/');
+    const json = hashExportBytes(pair.json);
+    const markdown = hashExportBytes(pair.markdown);
+    const files = [
+        Object.freeze({ path: `${RENAME_MAP.repoStateDir}exports/${stableRelative}/review.json`, ...json }),
+        Object.freeze({ path: `${RENAME_MAP.repoStateDir}exports/${stableRelative}/review.md`, ...markdown }),
+    ];
+    return Object.freeze({ files: Object.freeze(files) });
+}
+function identity(info) {
+    if (!info.isDirectory() || info.isSymbolicLink()) {
+        throw new Error('Managed export directory is not a real directory.');
+    }
+    return Object.freeze({ dev: info.dev, ino: info.ino });
+}
+function sameIdentity(left, right) {
+    return left.dev === right.dev && left.ino === right.ino;
+}
+async function managedDirectory(component, create) {
+    let info;
+    try {
+        info = await lstat(component);
+    }
+    catch (error) {
+        if (!isMissing(error))
+            throw error;
+        if (!create)
+            return undefined;
+        await mkdir(component, { mode: 0o700 });
+        info = await lstat(component);
+    }
+    return identity(info);
+}
+export async function ensureManagedExportsRoot(repositoryRoot, create) {
+    const root = resolve(repositoryRoot);
+    const stateRoot = join(root, RENAME_MAP.repoStateDir.replace(/\/$/, ''));
+    const stateIdentity = await managedDirectory(stateRoot, create);
+    if (stateIdentity === undefined)
+        return undefined;
+    const exportsRoot = join(stateRoot, 'exports');
+    const exportsIdentity = await managedDirectory(exportsRoot, create);
+    if (exportsIdentity === undefined)
+        return undefined;
+    return Object.freeze({ stateRoot, exportsRoot, stateIdentity, exportsIdentity });
+}
+export async function assertManagedExportsRoot(managedRoot) {
+    const stateIdentity = await managedDirectory(managedRoot.stateRoot, false);
+    if (stateIdentity === undefined
+        || !sameIdentity(stateIdentity, managedRoot.stateIdentity)) {
+        throw new Error('Managed export directory identity changed.');
+    }
+    const exportsIdentity = await managedDirectory(managedRoot.exportsRoot, false);
+    if (exportsIdentity === undefined
+        || !sameIdentity(exportsIdentity, managedRoot.exportsIdentity)) {
+        throw new Error('Managed export directory identity changed.');
+    }
+}
+export async function publishReviewExport(input) {
+    const publication = input.identity;
+    const stableName = stableNameFor(publication, input.storageScope);
+    if (stableName === undefined)
+        return Object.freeze({ kind: 'publicationFailed' });
+    const repositoryRoot = resolve(input.repositoryRoot);
+    let managedRoot;
+    let candidate;
+    let exportsRoot;
+    let stable;
+    let publicationMayHaveChanged = false;
+    try {
+        managedRoot = await ensureManagedExportsRoot(repositoryRoot, true);
+        if (managedRoot === undefined) {
+            return Object.freeze({ kind: 'publicationFailed' });
+        }
+        exportsRoot = managedRoot.exportsRoot;
+        stable = join(exportsRoot, stableName);
+        await assertManagedExportsRoot(managedRoot);
+        const stablePresent = await stableExists(stable);
+        if (stablePresent && input.reExportCapability.kind === 'reExportUnsupported') {
+            return Object.freeze({ kind: 'reExportUnsupported' });
+        }
+        const candidateName = `.${stableName}.candidate-${randomUUID()}`;
+        candidate = join(exportsRoot, candidateName);
+        await assertManagedExportsRoot(managedRoot);
+        await mkdir(candidate, { mode: 0o700 });
+        await assertManagedExportsRoot(managedRoot);
+        await writeFileExactly(join(candidate, 'review.json'), input.json);
+        await assertManagedExportsRoot(managedRoot);
+        await writeFileExactly(join(candidate, 'review.md'), input.markdown);
+        await assertManagedExportsRoot(managedRoot);
+        const validatedCandidate = await completePair(candidate);
+        if (!validatedCandidate.json.equals(input.json) || !validatedCandidate.markdown.equals(input.markdown)) {
+            throw new Error('Candidate reread differs from validated export bytes.');
+        }
+        const document = parseCanonicalReviewExport(validatedCandidate.json);
+        if (!matchesPublicationIdentity(document, publication)
+            || !Buffer.from(renderReviewMarkdown(validatedCandidate.json), 'utf8').equals(validatedCandidate.markdown)) {
+            throw new Error('Candidate export identity or Markdown does not match canonical export JSON.');
+        }
+        await assertManagedExportsRoot(managedRoot);
+        await syncDirectory(candidate);
+        if (input.revalidate !== undefined && !(await input.revalidate())) {
+            return Object.freeze({ kind: 'publicationFailed' });
+        }
+        await assertManagedExportsRoot(managedRoot);
+        if (!stablePresent) {
+            await assertManagedExportsRoot(managedRoot);
+            if (await stableExists(stable)) {
+                return Object.freeze({ kind: 'publicationFailed' });
+            }
+            publicationMayHaveChanged = true;
+            await rename(candidate, stable);
+        }
+        else {
+            if (input.reExportCapability.kind !== 'observedNativeExchange') {
+                throw new ReExportUnsupported();
+            }
+            const exchanged = input.reExportCapability.exchangeDirectories(exportsRoot, stableName, candidateName);
+            if (exchanged.kind === 'unsupported') {
+                throw new ReExportUnsupported();
+            }
+            publicationMayHaveChanged = true;
+            if (exchanged.kind !== 'supported') {
+                throw new Error('Native exchange did not confirm publication.');
+            }
+        }
+        await assertManagedExportsRoot(managedRoot);
+        await syncDirectory(exportsRoot);
+        await assertManagedExportsRoot(managedRoot);
+        const finalPair = await completePair(stable);
+        if (!finalPair.json.equals(input.json) || !finalPair.markdown.equals(input.markdown)) {
+            return Object.freeze({ kind: 'publicationFailed' });
+        }
+        const finalReceipt = receipt(exportsRoot, stable, finalPair);
+        return Object.freeze({ kind: 'exported', receipt: finalReceipt });
+    }
+    catch (error) {
+        if (error instanceof ReExportUnsupported) {
+            return Object.freeze({ kind: 'reExportUnsupported' });
+        }
+        if (!publicationMayHaveChanged || managedRoot === undefined || exportsRoot === undefined || stable === undefined) {
+            return Object.freeze({ kind: 'publicationFailed' });
+        }
+        try {
+            await assertManagedExportsRoot(managedRoot);
+            const recovered = await completePair(stable);
+            if (!recovered.json.equals(input.json) || !recovered.markdown.equals(input.markdown)) {
+                return Object.freeze({ kind: 'recoveryRequired' });
+            }
+            return Object.freeze({ kind: 'exported', receipt: receipt(exportsRoot, stable, recovered) });
+        }
+        catch (recoveryError) {
+            return Object.freeze({ kind: isMissing(recoveryError) ? 'publicationFailed' : 'recoveryRequired' });
+        }
+    }
+    finally {
+        if (candidate !== undefined && managedRoot !== undefined) {
+            try {
+                await assertManagedExportsRoot(managedRoot);
+                await rm(candidate, { force: true, recursive: true });
+            }
+            catch {
+                // A failed cleanup never changes the complete stable generation.
+            }
+        }
+    }
+}
+export async function recoverReviewExport(repositoryRoot, identity, storageScope) {
+    const stableName = stableNameFor(identity, storageScope);
+    if (stableName === undefined)
+        return undefined;
+    const managedRoot = await ensureManagedExportsRoot(repositoryRoot, false);
+    if (managedRoot === undefined)
+        return undefined;
+    await assertManagedExportsRoot(managedRoot);
+    const stable = join(managedRoot.exportsRoot, stableName);
+    try {
+        await assertManagedExportsRoot(managedRoot);
+        return await completePair(stable);
+    }
+    catch (error) {
+        if (isMissing(error))
+            return undefined;
+        throw error;
+    }
+}

package/dist/server/gitignore-capability.js

@@ -0,0 +1,197 @@
+import { constants } from 'node:fs';
+import { lstat, open } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { inspectLoopnoteIgnore } from '../git/ignore-status.js';
+import { RENAME_MAP } from '../domain/product-identity.js';
+const loopnoteIgnoreRule = Buffer.from(`/${RENAME_MAP.repoStateDir}\n`, 'ascii');
+const appendQueues = new Map();
+function isMissingPath(error) {
+    return typeof error === 'object' && error !== null && 'code' in error && error.code === 'ENOENT';
+}
+function result(kind) {
+    return Object.freeze({ kind });
+}
+async function closeAsUnconfirmed(handle) {
+    try {
+        await handle.close();
+    }
+    catch {
+        // A failed close cannot make this append safe to claim.
+    }
+    return result('unconfirmed');
+}
+async function inspectFailedMutation(ignorePath, identity, original, addition) {
+    let confirmation;
+    let outcome = result('ambiguous');
+    try {
+        confirmation = await open(ignorePath, constants.O_RDONLY | constants.O_NOFOLLOW);
+        const stat = await confirmation.stat();
+        if (stat.isFile() && stat.dev === identity.device && stat.ino === identity.inode) {
+            const bytes = await confirmation.readFile();
+            outcome = bytes.equals(original)
+                ? result('unchanged')
+                : bytes.equals(Buffer.concat([original, addition]))
+                    ? result('appendUnconfirmed')
+                    : result('ambiguous');
+        }
+    }
+    catch {
+        outcome = result('ambiguous');
+    }
+    finally {
+        if (confirmation !== undefined) {
+            try {
+                await confirmation.close();
+            }
+            catch {
+                outcome = result('ambiguous');
+            }
+        }
+    }
+    return outcome;
+}
+export async function appendLoopnoteIgnoreRule(options, dependencies = {}) {
+    const repositoryRoot = resolve(options.repositoryRoot);
+    const previous = appendQueues.get(repositoryRoot) ?? Promise.resolve();
+    let release;
+    const current = new Promise((resolveCurrent) => {
+        release = resolveCurrent;
+    });
+    const queued = previous.then(() => current);
+    appendQueues.set(repositoryRoot, queued);
+    await previous;
+    try {
+        const status = await inspectLoopnoteIgnore({ repositoryRoot });
+        if (status.kind === 'ignored') {
+            return result('alreadyIgnored');
+        }
+        if (status.kind === 'unavailable') {
+            return result('unconfirmed');
+        }
+        const ignorePath = join(repositoryRoot, '.gitignore');
+        if (dirname(ignorePath) !== repositoryRoot) {
+            return result('unconfirmed');
+        }
+        let handle;
+        let original;
+        let identity;
+        let size;
+        try {
+            let initial;
+            try {
+                initial = await lstat(ignorePath);
+            }
+            catch (error) {
+                if (!isMissingPath(error)) {
+                    return result('unconfirmed');
+                }
+            }
+            if (initial !== undefined) {
+                if (!initial.isFile() || initial.isSymbolicLink()) {
+                    return result('unconfirmed');
+                }
+                handle = await open(ignorePath, constants.O_RDWR | constants.O_APPEND | constants.O_NOFOLLOW);
+                const opened = await handle.stat();
+                if (!opened.isFile() ||
+                    opened.dev !== initial.dev ||
+                    opened.ino !== initial.ino ||
+                    opened.size !== initial.size) {
+                    return closeAsUnconfirmed(handle);
+                }
+                original = await handle.readFile();
+                if (original.byteLength !== opened.size) {
+                    return closeAsUnconfirmed(handle);
+                }
+                identity = { device: opened.dev, inode: opened.ino };
+                size = opened.size;
+            }
+            else {
+                handle = await open(ignorePath, constants.O_CREAT |
+                    constants.O_EXCL |
+                    constants.O_RDWR |
+                    constants.O_APPEND |
+                    constants.O_NOFOLLOW, 0o600);
+                const created = await handle.stat();
+                if (!created.isFile() || created.size !== 0) {
+                    return closeAsUnconfirmed(handle);
+                }
+                original = Buffer.alloc(0);
+                identity = { device: created.dev, inode: created.ino };
+                size = created.size;
+            }
+        }
+        catch {
+            return handle === undefined ? result('unconfirmed') : closeAsUnconfirmed(handle);
+        }
+        if (handle === undefined) {
+            return result('unconfirmed');
+        }
+        const addition = original.byteLength === 0 || original.at(-1) === 0x0a
+            ? loopnoteIgnoreRule
+            : Buffer.concat([Buffer.from('\n', 'ascii'), loopnoteIgnoreRule]);
+        let mutationFailed = false;
+        try {
+            await dependencies.beforeAppend?.();
+            const beforeWrite = await handle.stat();
+            if (!beforeWrite.isFile() ||
+                beforeWrite.dev !== identity.device ||
+                beforeWrite.ino !== identity.inode ||
+                beforeWrite.size !== size) {
+                try {
+                    await handle.close();
+                }
+                catch {
+                    // No append was attempted, so the outcome remains unconfirmed.
+                }
+                return result('unconfirmed');
+            }
+            await (dependencies.writeAddition?.(handle, addition) ?? handle.writeFile(addition));
+            await (dependencies.sync?.(handle) ?? handle.sync());
+        }
+        catch {
+            mutationFailed = true;
+        }
+        try {
+            await (dependencies.close?.(handle) ?? handle.close());
+        }
+        catch {
+            mutationFailed = true;
+        }
+        if (mutationFailed) {
+            return inspectFailedMutation(ignorePath, identity, original, addition);
+        }
+        try {
+            const confirmation = await open(ignorePath, constants.O_RDONLY | constants.O_NOFOLLOW);
+            try {
+                const confirmed = await confirmation.stat();
+                const bytes = await confirmation.readFile();
+                const expected = Buffer.concat([original, addition]);
+                if (!confirmed.isFile() ||
+                    confirmed.dev !== identity.device ||
+                    confirmed.ino !== identity.inode ||
+                    confirmed.size !== expected.byteLength ||
+                    !bytes.equals(expected)) {
+                    return result('ambiguous');
+                }
+            }
+            finally {
+                await confirmation.close();
+            }
+        }
+        catch {
+            return result('ambiguous');
+        }
+        return (await inspectLoopnoteIgnore({ repositoryRoot })).kind === 'ignored'
+            ? result('appended')
+            : result('appendUnconfirmed');
+    }
+    catch {
+        return result('unconfirmed');
+    }
+    finally {
+        release();
+        if (appendQueues.get(repositoryRoot) === queued) {
+            appendQueues.delete(repositoryRoot);
+        }
+    }
+}

package/dist/server/image-content.js

@@ -0,0 +1,101 @@
+import { Buffer } from 'node:buffer';
+import { lstat, readFile } from 'node:fs/promises';
+import { dirname, join, normalize } from 'node:path/posix';
+export const MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+const MAX_LS_TREE_OUTPUT_BYTES = 64 * 1024;
+const modePattern = /^[0-7]{6}$/;
+const oidPattern = /^[0-9a-f]+$/;
+export const IMAGE_CONTENT_TYPE_BY_EXTENSION = {
+    png: 'image/png',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    gif: 'image/gif',
+    svg: 'image/svg+xml',
+    webp: 'image/webp',
+};
+function isNodeErrorWithCode(error, code) {
+    if (typeof error !== 'object' || error === null || !('code' in error)) {
+        return false;
+    }
+    return error.code === code;
+}
+export function resolveRelativeImagePath(markdownDisplayPath, rawSrc) {
+    let decoded;
+    try {
+        decoded = decodeURIComponent(rawSrc);
+    }
+    catch {
+        return undefined;
+    }
+    if (decoded.length === 0 ||
+        decoded.startsWith('/') ||
+        /[\u0000-\u001f]/u.test(decoded)) {
+        return undefined;
+    }
+    const normalized = normalize(join(dirname(markdownDisplayPath), decoded));
+    if (normalized === '.' ||
+        normalized === '..' ||
+        normalized.startsWith('../') ||
+        normalized.startsWith('/') ||
+        normalized.endsWith('/')) {
+        return undefined;
+    }
+    return normalized;
+}
+export async function readWorktreeImageBytes(repositoryRoot, relativePath) {
+    const parts = relativePath.split('/');
+    let current = repositoryRoot;
+    try {
+        for (const [index, part] of parts.entries()) {
+            current = `${current}/${part}`;
+            const entry = await lstat(current);
+            if (entry.isSymbolicLink()) {
+                return undefined;
+            }
+            if (index < parts.length - 1) {
+                if (!entry.isDirectory()) {
+                    return undefined;
+                }
+                continue;
+            }
+            if (!entry.isFile() || entry.size > MAX_IMAGE_BYTES) {
+                return undefined;
+            }
+            const bytes = await readFile(current);
+            return bytes.length > MAX_IMAGE_BYTES ? undefined : bytes;
+        }
+        return undefined;
+    }
+    catch (error) {
+        if (isNodeErrorWithCode(error, 'ENOENT') || isNodeErrorWithCode(error, 'ENOTDIR')) {
+            return undefined;
+        }
+        throw error;
+    }
+}
+export async function readCommittedImageBytes(repositoryRoot, commitOid, relativePath, runner, reader) {
+    let result;
+    try {
+        result = await runner.run(['ls-tree', commitOid, '--', relativePath], {
+            cwd: repositoryRoot,
+            maxStdoutBytes: MAX_LS_TREE_OUTPUT_BYTES,
+        });
+    }
+    catch {
+        return undefined;
+    }
+    const output = result.stdout.toString('utf8').trim();
+    if (output.length === 0) {
+        return undefined;
+    }
+    const tab = output.indexOf('\t');
+    if (tab < 0) {
+        return undefined;
+    }
+    const fields = output.slice(0, tab).split(' ');
+    if (fields.length !== 3 || !modePattern.test(fields[0]) || fields[1] !== 'blob' || !oidPattern.test(fields[2])) {
+        return undefined;
+    }
+    const content = await reader.read(fields[2], { maxBytes: MAX_IMAGE_BYTES });
+    return content.kind === 'missing' ? undefined : content.bytes;
+}

package/dist/server/lifecycle.js

@@ -0,0 +1,72 @@
+import { RENAME_MAP } from '../domain/product-identity.js';
+const signalExitStatus = {
+    SIGINT: 130,
+    SIGTERM: 143,
+};
+export function createShutdownController(options) {
+    const signalSource = options.signalSource ?? process;
+    const setExitStatus = options.setExitStatus ??
+        ((status) => {
+            process.exitCode = status;
+        });
+    const reportError = options.reportError ??
+        ((error) => {
+            console.error(`${RENAME_MAP.displayName} shutdown failed.`, error);
+        });
+    let shutdownPromise;
+    const signalHandlers = {
+        SIGINT: () => {
+            void shutdown(signalExitStatus.SIGINT).catch(reportError);
+        },
+        SIGTERM: () => {
+            void shutdown(signalExitStatus.SIGTERM).catch(reportError);
+        },
+    };
+    function removeSignalHandlers() {
+        signalSource.off('SIGINT', signalHandlers.SIGINT);
+        signalSource.off('SIGTERM', signalHandlers.SIGTERM);
+    }
+    function shutdown(exitStatus = 0) {
+        if (shutdownPromise !== undefined) {
+            return shutdownPromise;
+        }
+        removeSignalHandlers();
+        shutdownPromise = (async () => {
+            let abortFailure;
+            try {
+                options.abortActiveWork();
+            }
+            catch (error) {
+                abortFailure = error;
+            }
+            let closeFailure;
+            try {
+                await options.closeListener();
+            }
+            catch (error) {
+                closeFailure = error;
+            }
+            finally {
+                setExitStatus(exitStatus);
+            }
+            if (abortFailure !== undefined && closeFailure !== undefined) {
+                throw new AggregateError([abortFailure, closeFailure], 'Active work abort and listener close both failed');
+            }
+            if (abortFailure !== undefined) {
+                throw abortFailure;
+            }
+            if (closeFailure !== undefined) {
+                throw closeFailure;
+            }
+        })();
+        return shutdownPromise;
+    }
+    signalSource.on('SIGINT', signalHandlers.SIGINT);
+    signalSource.on('SIGTERM', signalHandlers.SIGTERM);
+    return {
+        get isShuttingDown() {
+            return shutdownPromise !== undefined;
+        },
+        shutdown,
+    };
+}