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

package/dist/server/routes.js

@@ -0,0 +1,418 @@
+import { z } from 'zod';
+import { AppendLoopnoteIgnoreResultSchema, LoopnoteIgnoreStatusSchema, DraftLoadResponseSchema, DraftMutationRequestSchema, DraftMutationResultSchema, DraftRecoveryRequestSchema, DraftRecoveryResultSchema, DraftRevealResultSchema, ExportDirectoryRevealResultSchema, ExportReviewRequestSchema, ExportReviewResultSchema, PatchStatusResponseSchema, SelectorDriftResponseSchema, OpaqueFileIdSchema, AttachedCompletionStatusSchema, FinishReviewRequestSchema, FinishReviewResultSchema, SupportStartRequestSchema, SupportStartResultSchema, SupportStatusSchema, UncommittedDraftRecoveryResultSchema, } from '../contracts/api.js';
+import { DurableAnchorV1Schema } from '../contracts/draft.js';
+import { buildDurableAnchor } from '../domain/anchor.js';
+import { REQUEST_UNAVAILABLE_ERROR } from './security.js';
+const FileImageQuerySchema = z.strictObject({
+    path: z.string().min(1),
+    side: z.enum(['base', 'head']),
+    // Carries the session token for same-origin <img src> requests (GAP-01, 16-UI-REVIEW);
+    // security.ts's auth gate validates it, this schema just tolerates its presence.
+    token: z.string().optional(),
+});
+const EMPTY_QUERY_SCHEMA = {
+    type: 'object',
+    properties: {},
+    additionalProperties: false,
+};
+const FILE_PARAMS_SCHEMA = {
+    type: 'object',
+    required: ['fileId'],
+    properties: {
+        fileId: { type: 'string' },
+    },
+    additionalProperties: false,
+};
+function unavailable(reply, statusCode) {
+    return reply.code(statusCode).send(REQUEST_UNAVAILABLE_ERROR);
+}
+function publicLoad(load, draft) {
+    switch (load.kind) {
+        case 'missing':
+            return DraftLoadResponseSchema.parse({ kind: load.kind, path: load.path });
+        case 'current':
+            return DraftLoadResponseSchema.parse({ kind: load.kind, path: load.path, draft });
+        case 'malformed':
+            return DraftLoadResponseSchema.parse({
+                kind: load.kind,
+                path: load.path,
+                fingerprint: load.fingerprint,
+                detail: load.detail,
+            });
+        case 'schemaInvalid':
+            return DraftLoadResponseSchema.parse({
+                kind: load.kind,
+                path: load.path,
+                fingerprint: load.fingerprint,
+                details: load.details,
+            });
+        case 'newerUnsupported':
+            return DraftLoadResponseSchema.parse({
+                kind: load.kind,
+                path: load.path,
+                foundVersion: load.foundVersion,
+                supportedVersion: load.supportedVersion,
+            });
+    }
+}
+async function draftView(capabilities, load) {
+    return {
+        ...load.draft,
+        comments: await Promise.all(load.draft.comments.map(async (comment) => ({
+            ...comment,
+            verification: await capabilities.verifyAnchor(comment.anchor),
+        }))),
+    };
+}
+function publicMutationResult(result) {
+    if (result.kind === 'readOnly') {
+        return DraftMutationResultSchema.parse({ kind: result.kind, load: publicLoad(result.load) });
+    }
+    return DraftMutationResultSchema.parse(result);
+}
+function mutationResponse(reply, result, acceptedStatus) {
+    const response = publicMutationResult(result);
+    switch (response.kind) {
+        case 'accepted':
+            return reply.code(acceptedStatus).send(response);
+        case 'revisionConflict':
+        case 'illegalTransition':
+        case 'readOnly':
+            return reply.code(409).send(response);
+        case 'invalidTarget':
+            return reply.code(404).send(response);
+        case 'persistenceFailure':
+            return reply.code(500).send(response);
+    }
+}
+export function registerSessionRoutes(app, capabilities) {
+    app.get('/api/session', { schema: { querystring: EMPTY_QUERY_SCHEMA } }, async () => await capabilities.session());
+    if (capabilities.support !== undefined) {
+        app.get('/api/support/status', { schema: { querystring: EMPTY_QUERY_SCHEMA } }, async (request, reply) => {
+            if (request.body !== undefined || request.headers['content-length'] !== undefined)
+                return unavailable(reply, 400);
+            return SupportStatusSchema.parse(await capabilities.support.status());
+        });
+        app.post('/api/support/start', { schema: { querystring: EMPTY_QUERY_SCHEMA }, bodyLimit: 1024 }, async (request, reply) => {
+            if (request.headers['content-type']?.split(';', 1)[0] !== 'application/json')
+                return unavailable(reply, 400);
+            const body = SupportStartRequestSchema.safeParse(request.body);
+            if (!body.success)
+                return unavailable(reply, 400);
+            return SupportStartResultSchema.parse(await capabilities.support.start(body.data.action));
+        });
+        app.post('/api/support/refresh', { schema: { querystring: EMPTY_QUERY_SCHEMA }, bodyLimit: 1 }, async (request, reply) => {
+            if (request.body !== undefined || (request.headers['content-length'] !== undefined && request.headers['content-length'] !== '0') || request.headers['content-type'] !== undefined)
+                return unavailable(reply, 400);
+            return SupportStatusSchema.parse(await capabilities.support.refresh());
+        });
+    }
+    if (capabilities.attachedCompletion !== undefined) {
+        app.get('/api/review-completion', { schema: { querystring: EMPTY_QUERY_SCHEMA } }, async (request, reply) => {
+            if (Object.keys(request.query).length !== 0
+                || request.body !== undefined
+                || request.headers['content-length'] !== undefined
+                || request.headers['content-type'] !== undefined) {
+                return unavailable(reply, 400);
+            }
+            return AttachedCompletionStatusSchema.parse(capabilities.attachedCompletion.status());
+        });
+        app.post('/api/review-completion/finish', { schema: { querystring: EMPTY_QUERY_SCHEMA }, bodyLimit: 256 }, async (request, reply) => {
+            if (Object.keys(request.query).length !== 0
+                || request.headers['content-type']?.split(';', 1)[0] !== 'application/json') {
+                return unavailable(reply, 400);
+            }
+            const input = FinishReviewRequestSchema.safeParse(request.body);
+            if (!input.success)
+                return unavailable(reply, 400);
+            const result = FinishReviewResultSchema.parse(await capabilities.attachedCompletion.finish(input.data.expectedRevision));
+            switch (result.kind) {
+                case 'completed':
+                    reply.raw.once('finish', () => capabilities.attachedCompletion.markResponseSettled());
+                    return reply.code(201).send(result);
+                case 'alreadyCompleted':
+                    return reply.code(200).send(result);
+                case 'revisionConflict':
+                case 'staleAnchors':
+                case 'scopeInvalid':
+                case 'draftReadOnly':
+                    return reply.code(409).send(result);
+                case 'persistenceFailure':
+                case 'canonicalizationFailure':
+                case 'deliveryFailed':
+                    return reply.code(500).send(result);
+            }
+        });
+    }
+    if (capabilities.patchStatus !== undefined) {
+        app.get('/api/patch-status', { schema: { querystring: EMPTY_QUERY_SCHEMA } }, async (request, reply) => {
+            if (Object.keys(request.query).length !== 0 ||
+                request.body !== undefined ||
+                request.headers['content-length'] !== undefined ||
+                request.headers['content-type'] !== undefined) {
+                return unavailable(reply, 400);
+            }
+            return PatchStatusResponseSchema.parse(await capabilities.patchStatus());
+        });
+    }
+    const selectorDriftObserver = capabilities.selectorDriftObserver;
+    if (selectorDriftObserver !== undefined) {
+        app.get('/api/selector-drift', { schema: { querystring: EMPTY_QUERY_SCHEMA } }, async (request, reply) => {
+            if (Object.keys(request.query).length !== 0 ||
+                request.body !== undefined ||
+                request.headers['content-length'] !== undefined) {
+                return unavailable(reply, 400);
+            }
+            return SelectorDriftResponseSchema.parse(await selectorDriftObserver.observe());
+        });
+    }
+    if (capabilities.refresh !== undefined) {
+        app.post('/api/refresh', { schema: { querystring: EMPTY_QUERY_SCHEMA }, bodyLimit: 1 }, async (request, reply) => {
+            if (request.body !== undefined ||
+                (request.headers['content-length'] !== undefined && request.headers['content-length'] !== '0') ||
+                request.headers['content-type'] !== undefined) {
+                return unavailable(reply, 400);
+            }
+            return await capabilities.refresh();
+        });
+    }
+    if (capabilities.worktreeChangeIndicator !== undefined) {
+        app.get('/api/worktree-status', { schema: { querystring: EMPTY_QUERY_SCHEMA } }, async (request, reply) => {
+            if (Object.keys(request.query).length !== 0 ||
+                request.body !== undefined ||
+                request.headers['content-length'] !== undefined ||
+                request.headers['content-type'] !== undefined) {
+                return unavailable(reply, 400);
+            }
+            return await capabilities.worktreeChangeIndicator();
+        });
+    }
+    if (capabilities.recoverUncommittedDraft !== undefined) {
+        app.post('/api/uncommitted/recover-draft', { schema: { querystring: EMPTY_QUERY_SCHEMA }, bodyLimit: 1 }, async (request, reply) => {
+            if (request.body !== undefined ||
+                (request.headers['content-length'] !== undefined && request.headers['content-length'] !== '0') ||
+                request.headers['content-type'] !== undefined) {
+                return unavailable(reply, 400);
+            }
+            return UncommittedDraftRecoveryResultSchema.parse(await capabilities.recoverUncommittedDraft());
+        });
+    }
+    app.get('/api/files/:fileId', {
+        schema: {
+            params: FILE_PARAMS_SCHEMA,
+            querystring: EMPTY_QUERY_SCHEMA,
+        },
+    }, async (request, reply) => {
+        const fileId = OpaqueFileIdSchema.safeParse(request.params.fileId);
+        if (!fileId.success) {
+            return unavailable(reply, 404);
+        }
+        const metadata = await capabilities.lookup(fileId.data);
+        if (metadata === undefined) {
+            return unavailable(reply, 404);
+        }
+        return metadata;
+    });
+    app.get('/api/files/:fileId/content', async (request, reply) => {
+        if (Object.keys(request.query).length !== 0) {
+            return unavailable(reply, 400);
+        }
+        const fileId = OpaqueFileIdSchema.safeParse(request.params.fileId);
+        if (!fileId.success) {
+            return unavailable(reply, 404);
+        }
+        const metadata = await capabilities.lookup(fileId.data);
+        if (metadata === undefined) {
+            return unavailable(reply, 404);
+        }
+        if (metadata.availability.kind !== 'text') {
+            return unavailable(reply, 409);
+        }
+        const content = await capabilities.readContent(fileId.data);
+        if (content === undefined) {
+            return unavailable(reply, 409);
+        }
+        return content;
+    });
+    app.get('/api/files/:fileId/image', async (request, reply) => {
+        const query = FileImageQuerySchema.safeParse(request.query);
+        if (!query.success) {
+            return unavailable(reply, 400);
+        }
+        const fileId = OpaqueFileIdSchema.safeParse(request.params.fileId);
+        if (!fileId.success) {
+            return unavailable(reply, 404);
+        }
+        const metadata = await capabilities.lookup(fileId.data);
+        if (metadata === undefined) {
+            return unavailable(reply, 404);
+        }
+        const image = await capabilities.readRelativeImage(fileId.data, query.data.side, query.data.path);
+        if (image === undefined) {
+            return unavailable(reply, 409);
+        }
+        return reply.type(image.contentType).send(image.bytes);
+    });
+    app.get('/api/draft', { schema: { querystring: EMPTY_QUERY_SCHEMA } }, async (request, reply) => {
+        if (Object.keys(request.query).length !== 0) {
+            return unavailable(reply, 400);
+        }
+        try {
+            const load = await capabilities.draftStore.loadState();
+            return publicLoad(load, load.kind === 'current' ? await draftView(capabilities, load) : undefined);
+        }
+        catch {
+            return unavailable(reply, 500);
+        }
+    });
+    app.post('/api/draft/mutations', { schema: { querystring: EMPTY_QUERY_SCHEMA } }, async (request, reply) => {
+        const requestMutation = DraftMutationRequestSchema.safeParse(request.body);
+        if (!requestMutation.success) {
+            return unavailable(reply, 400);
+        }
+        const initialLoad = await capabilities.draftStore.loadState();
+        if (initialLoad.kind === 'malformed' || initialLoad.kind === 'schemaInvalid' || initialLoad.kind === 'newerUnsupported') {
+            return mutationResponse(reply, { kind: 'readOnly', load: initialLoad }, requestMutation.data.type === 'addComment' ? 201 : 200);
+        }
+        const { expectedRevision } = requestMutation.data;
+        let mutation;
+        if (requestMutation.data.type === 'addComment') {
+            const content = await capabilities.readContent(requestMutation.data.fileId);
+            const selectedSide = content?.[requestMutation.data.side];
+            if (selectedSide === undefined || selectedSide.exists === false) {
+                return unavailable(reply, 409);
+            }
+            if (/(?:\r\n|\n)$/u.test(selectedSide.text) &&
+                requestMutation.data.line === selectedSide.text.split(/\r\n|\n/u).length) {
+                return unavailable(reply, 409);
+            }
+            try {
+                mutation = {
+                    type: 'addComment',
+                    body: requestMutation.data.body,
+                    anchor: DurableAnchorV1Schema.parse(buildDurableAnchor({
+                        path: selectedSide.path,
+                        safeDisplayPath: selectedSide.path.display,
+                        side: requestMutation.data.side,
+                        blobOid: selectedSide.blobOid,
+                        line: requestMutation.data.line,
+                        endLine: requestMutation.data.endLine,
+                        text: selectedSide.text,
+                    })),
+                };
+            }
+            catch {
+                return unavailable(reply, 409);
+            }
+            if (capabilities.onAnchorAdd !== undefined) {
+                try {
+                    await capabilities.onAnchorAdd({ body: requestMutation.data.body, anchor: mutation.anchor });
+                }
+                catch {
+                    return unavailable(reply, 500);
+                }
+            }
+            if (capabilities.onAnchorAdd !== undefined) {
+                return reply.code(201).send({ kind: 'accepted' });
+            }
+        }
+        else {
+            const { expectedRevision: _expectedRevision, ...operation } = requestMutation.data;
+            mutation = operation;
+        }
+        const result = await capabilities.draftStore.mutate({ expectedRevision, mutation });
+        return mutationResponse(reply, result, requestMutation.data.type === 'addComment' ? 201 : 200);
+    });
+    app.post('/api/export', { schema: { querystring: EMPTY_QUERY_SCHEMA }, bodyLimit: 256 }, async (request, reply) => {
+        if (capabilities.exportReview === undefined)
+            return unavailable(reply, 404);
+        if (Object.keys(request.query).length !== 0 ||
+            request.headers['content-type']?.split(';', 1)[0] !== 'application/json') {
+            return unavailable(reply, 400);
+        }
+        const input = ExportReviewRequestSchema.safeParse(request.body);
+        if (!input.success) {
+            return unavailable(reply, 400);
+        }
+        try {
+            const response = ExportReviewResultSchema.parse(await capabilities.exportReview(input.data));
+            switch (response.kind) {
+                case 'exported':
+                    return reply.code(201).send(response);
+                case 'publicationFailed':
+                case 'recoveryRequired':
+                    return reply.code(500).send(response);
+                case 'revisionConflict':
+                case 'driftAcknowledgementRequired':
+                case 'driftAcknowledgementStale':
+                case 'draftReadOnly':
+                case 'reExportUnsupported':
+                    return reply.code(409).send(response);
+            }
+        }
+        catch {
+            return unavailable(reply, 500);
+        }
+    });
+    app.get('/api/export/gitignore', { schema: { querystring: EMPTY_QUERY_SCHEMA } }, async (request, reply) => {
+        if (Object.keys(request.query).length !== 0 ||
+            request.body !== undefined ||
+            request.headers['content-length'] !== undefined ||
+            request.headers['content-type'] !== undefined) {
+            return unavailable(reply, 400);
+        }
+        return LoopnoteIgnoreStatusSchema.parse(await capabilities.inspectLoopnoteIgnore());
+    });
+    app.post('/api/export/gitignore', { schema: { querystring: EMPTY_QUERY_SCHEMA } }, async (request, reply) => {
+        if (Object.keys(request.query).length !== 0 ||
+            request.body !== undefined ||
+            request.headers['content-length'] !== undefined ||
+            request.headers['content-type'] !== undefined) {
+            return unavailable(reply, 400);
+        }
+        return reply.code(200).send(AppendLoopnoteIgnoreResultSchema.parse(await capabilities.appendLoopnoteIgnoreRule()));
+    });
+    app.post('/api/export/reveal', { schema: { querystring: EMPTY_QUERY_SCHEMA } }, async (request, reply) => {
+        if (capabilities.revealExportDirectory === undefined)
+            return unavailable(reply, 404);
+        if (Object.keys(request.query).length !== 0 ||
+            request.body !== undefined ||
+            request.headers['content-length'] !== undefined) {
+            return unavailable(reply, 400);
+        }
+        try {
+            await capabilities.revealExportDirectory();
+            return reply.code(200).send(ExportDirectoryRevealResultSchema.parse({ kind: 'revealed' }));
+        }
+        catch {
+            return reply.code(500).send(ExportDirectoryRevealResultSchema.parse({ kind: 'revealFailed' }));
+        }
+    });
+    app.post('/api/draft/recovery', { schema: { querystring: EMPTY_QUERY_SCHEMA } }, async (request, reply) => {
+        const input = DraftRecoveryRequestSchema.safeParse(request.body);
+        if (!input.success) {
+            return unavailable(reply, 400);
+        }
+        const result = await capabilities.draftStore.recover(input.data);
+        let response;
+        if (result.kind === 'recoveryUnavailable') {
+            response = DraftRecoveryResultSchema.parse({ kind: result.kind, load: publicLoad(result.load) });
+        }
+        else {
+            response = DraftRecoveryResultSchema.parse(result);
+        }
+        return reply.code(response.kind === 'recovered' ? 201 : response.kind === 'persistenceFailure' ? 500 : 409).send(response);
+    });
+    app.post('/api/draft/reveal', { schema: { querystring: EMPTY_QUERY_SCHEMA } }, async (request, reply) => {
+        if (Object.keys(request.query).length !== 0 || request.body !== undefined) {
+            return unavailable(reply, 400);
+        }
+        try {
+            await capabilities.revealDraftFile();
+            return reply.code(200).send(DraftRevealResultSchema.parse({ kind: 'revealed' }));
+        }
+        catch {
+            return reply.code(500).send(DraftRevealResultSchema.parse({ kind: 'revealFailed' }));
+        }
+    });
+}

package/dist/server/security.js

@@ -0,0 +1,123 @@
+import { randomBytes, timingSafeEqual } from 'node:crypto';
+import { ApiErrorSchema } from '../contracts/api.js';
+import { RENAME_MAP } from '../domain/product-identity.js';
+export const REQUEST_UNAVAILABLE_MESSAGE = `This request is not available in the current session. Relaunch ${RENAME_MAP.displayName} from the terminal.`;
+export const REQUEST_UNAVAILABLE_ERROR = ApiErrorSchema.parse({
+    code: 'request-unavailable',
+    message: REQUEST_UNAVAILABLE_MESSAGE,
+});
+const CONTENT_SECURITY_POLICY = [
+    "default-src 'self'",
+    "script-src 'self'",
+    "style-src 'self'",
+    "style-src-elem 'self' 'unsafe-inline'",
+    "style-src-attr 'unsafe-inline'",
+    "connect-src 'self'",
+    "img-src 'self'",
+    "font-src 'self'",
+    "object-src 'none'",
+    "frame-ancestors 'none'",
+    "base-uri 'none'",
+    "form-action 'none'",
+].join('; ');
+function applySecurityHeaders(reply) {
+    void reply
+        .header('cache-control', 'no-store')
+        .header('referrer-policy', 'no-referrer')
+        .header('x-content-type-options', 'nosniff')
+        .header('x-frame-options', 'DENY')
+        .header('content-security-policy', CONTENT_SECURITY_POLICY);
+}
+function isApiRequest(request) {
+    return request.url === '/api' || request.url.startsWith('/api/') || request.url.startsWith('/api?');
+}
+// The rendered Markdown preview's relative images (GAP-01, 16-UI-REVIEW) are loaded via a
+// literal <img src> tag, which structurally cannot attach an Authorization header. This
+// matches only the image content route so no other /api/* path accepts a query-string token.
+const IMAGE_ROUTE_PATTERN = /^\/api\/files\/[^/?]+\/image(?:\?.*)?$/u;
+function tokenMatches(candidate, expectedToken) {
+    if (candidate === undefined) {
+        return false;
+    }
+    const candidateBuffer = Buffer.from(candidate, 'utf8');
+    return candidateBuffer.length === expectedToken.length && timingSafeEqual(candidateBuffer, expectedToken);
+}
+function hasBearerToken(request, expectedToken) {
+    const authorization = request.headers.authorization;
+    if (authorization === undefined || !authorization.startsWith('Bearer ')) {
+        return false;
+    }
+    return tokenMatches(authorization.slice('Bearer '.length), expectedToken);
+}
+function hasImageRouteQueryToken(request, expectedToken) {
+    const queryIndex = request.url.indexOf('?');
+    if (queryIndex === -1) {
+        return false;
+    }
+    const candidate = new URLSearchParams(request.url.slice(queryIndex + 1)).get('token');
+    return tokenMatches(candidate ?? undefined, expectedToken);
+}
+export function registerSessionSecurity(app, options) {
+    const expectedToken = Buffer.from(options.sessionToken, 'utf8');
+    let target;
+    function diagnose(reason) {
+        options.diagnostics?.({
+            correlationId: randomBytes(12).toString('base64url'),
+            reason,
+        });
+    }
+    function deny(reply, statusCode, reason) {
+        diagnose(reason);
+        void reply.code(statusCode).send(REQUEST_UNAVAILABLE_ERROR);
+    }
+    app.addHook('onRequest', (request, reply, done) => {
+        applySecurityHeaders(reply);
+        if (target === undefined) {
+            deny(reply, 403, 'security-not-bound');
+            return;
+        }
+        if (request.headers.host !== target.expectedHost) {
+            deny(reply, 403, 'host-mismatch');
+            return;
+        }
+        const origin = request.headers.origin;
+        if (origin !== undefined && origin !== target.expectedOrigin) {
+            deny(reply, 403, 'origin-mismatch');
+            return;
+        }
+        const authorized = hasBearerToken(request, expectedToken)
+            || (IMAGE_ROUTE_PATTERN.test(request.url) && hasImageRouteQueryToken(request, expectedToken));
+        if (isApiRequest(request) && !authorized) {
+            deny(reply, 401, 'token-mismatch');
+            return;
+        }
+        done();
+    });
+    app.addHook('onSend', (_request, reply, payload, done) => {
+        applySecurityHeaders(reply);
+        done(null, payload);
+    });
+    app.setNotFoundHandler((_request, reply) => {
+        void reply.code(404).send(REQUEST_UNAVAILABLE_ERROR);
+    });
+    app.setErrorHandler((error, _request, reply) => {
+        const fastifyError = error;
+        diagnose(fastifyError.validation === undefined ? 'request-failed' : 'invalid-request');
+        const statusCode = fastifyError.validation === undefined && fastifyError.statusCode === undefined ? 500 : 400;
+        void reply.code(statusCode).send(REQUEST_UNAVAILABLE_ERROR);
+    });
+    return Object.freeze({
+        bind(nextTarget) {
+            if (target !== undefined) {
+                throw new Error('Session security is already bound.');
+            }
+            if (!/^127\.0\.0\.1:\d+$/.test(nextTarget.expectedHost)) {
+                throw new Error('Session security must bind to a loopback authority.');
+            }
+            if (nextTarget.expectedOrigin !== `http://${nextTarget.expectedHost}`) {
+                throw new Error('Session security origin must match its loopback authority.');
+            }
+            target = Object.freeze({ ...nextTarget });
+        },
+    });
+}

package/dist/server/snapshot-fs.js

@@ -0,0 +1,58 @@
+import { createHash } from 'node:crypto';
+import { chmod, open } from 'node:fs/promises';
+export const MAX_SIDE_BYTES = 2 * 1024 * 1024;
+export function digest(bytes) {
+    return createHash('sha256').update(bytes).digest('hex');
+}
+export function frame(value) {
+    const bytes = Buffer.from(value, 'utf8');
+    const length = Buffer.allocUnsafe(8);
+    length.writeBigUInt64BE(BigInt(bytes.byteLength));
+    return Buffer.concat([length, bytes]);
+}
+export function isMissing(error) {
+    return typeof error === 'object' && error !== null && 'code' in error && error.code === 'ENOENT';
+}
+export async function syncDirectory(path) {
+    const handle = await open(path, 'r');
+    try {
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+}
+export async function writeOwned(path, bytes) {
+    const handle = await open(path, 'wx', 0o600);
+    try {
+        await handle.writeFile(bytes);
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+    await chmod(path, 0o400);
+}
+export async function boundedFileBytes(path, expectedBytes) {
+    const handle = await open(path, 'r');
+    try {
+        const info = await handle.stat();
+        if (!info.isFile() || info.size !== expectedBytes || expectedBytes > MAX_SIDE_BYTES) {
+            throw new Error('Target file differs from its frozen size.');
+        }
+        const bytes = Buffer.allocUnsafe(expectedBytes + 1);
+        let offset = 0;
+        while (offset < bytes.byteLength) {
+            const { bytesRead } = await handle.read(bytes, offset, bytes.byteLength - offset, offset);
+            if (bytesRead === 0)
+                break;
+            offset += bytesRead;
+        }
+        if (offset !== expectedBytes)
+            throw new Error('Target file changed during observation.');
+        return bytes.subarray(0, expectedBytes);
+    }
+    finally {
+        await handle.close();
+    }
+}

package/dist/server/support-client.js

@@ -0,0 +1,76 @@
+import { RENAME_MAP } from '../domain/product-identity.js';
+import { z } from 'zod';
+const responseLimit = 8192;
+const timeoutMs = 5000;
+const installationStatusSchema = z.strictObject({ status: z.enum(['unverified', 'verified']) });
+const supportStartSchema = z.strictObject({ flowUrl: z.string().url() });
+async function responseJson(response) {
+    const contentLength = Number(response.headers.get('content-length') ?? '0');
+    if (!response.ok || contentLength > responseLimit)
+        return undefined;
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    if (bytes.length > responseLimit)
+        return undefined;
+    try {
+        return JSON.parse(new TextDecoder().decode(bytes));
+    }
+    catch {
+        return undefined;
+    }
+}
+export function createHostedSupportClient(options = {}) {
+    const configuredServiceUrl = options.serviceUrl ?? process.env[`${RENAME_MAP.envPrefix}SUPPORT_SERVICE_URL`];
+    let service;
+    try {
+        service = configuredServiceUrl === undefined ? undefined : new URL(configuredServiceUrl);
+    }
+    catch {
+        service = undefined;
+    }
+    if (service?.protocol !== 'https:')
+        service = undefined;
+    const fetcher = options.fetch ?? globalThis.fetch;
+    const lifetimeController = new AbortController();
+    const fetchJson = async (path, init) => {
+        if (service === undefined)
+            return undefined;
+        const requestController = new AbortController();
+        const timeout = setTimeout(() => requestController.abort(), timeoutMs);
+        try {
+            const signal = AbortSignal.any([lifetimeController.signal, requestController.signal]);
+            return await responseJson(await fetcher(new URL(path, service).toString(), { ...init, signal }));
+        }
+        catch {
+            return undefined;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    };
+    const validFlowUrl = (flowUrl) => {
+        try {
+            const flow = new URL(flowUrl);
+            return flow.protocol === 'https:' && flow.origin === service?.origin;
+        }
+        catch {
+            return false;
+        }
+    };
+    return Object.freeze({
+        async start(action, installationId) {
+            const result = supportStartSchema.safeParse(await fetchJson('/functions/v1/support-api/start', {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({ action, installationId }),
+            }));
+            return result.success && validFlowUrl(result.data.flowUrl) ? result.data : undefined;
+        },
+        async status(installationId) {
+            const result = installationStatusSchema.safeParse(await fetchJson(`/functions/v1/support-api/status?installationId=${encodeURIComponent(installationId)}`));
+            return result.success ? result.data.status : undefined;
+        },
+        close() {
+            lifetimeController.abort();
+        },
+    });
+}