@buildinternet/uploads 0.42.1 → 0.43.0

package/dist/comment-config.js

@@ -1,181 +1,14 @@
 /**
- * Published-CLI COPY of the workspace parser/resolver (issue #307)
- * (packages/comment-config/src/index.ts). The published CLI imports no
- * @uploads/* package, so that private package cannot be shared here — its
- * parser/resolver is copied verbatim below. Kept in sync by
- * test/fixtures/comment-config-golden.json, asserted from both sides (this
- * package's comment-config.test.ts and the canonical package's
- * index.test.ts) — change both copies together. `readLocalRepoCommentConfig`
- * below is CLI-only: it reads the six candidate config paths off the working
- * tree (the server instead fetches them from GitHub's contents API —
- * apps/api/src/repo-comment-config.ts).
+ * CLI comment-config: shared parser from the generated copy of
+ * `@uploads/comment-config`, plus the local working-tree reader.
+ * `readLocalRepoCommentConfig` is CLI-only — it reads the six candidate
+ * config paths off the working tree (the server instead fetches them from
+ * GitHub's contents API — apps/api/src/repo-comment-config.ts).
  */
 import fs from "node:fs";
 import { join } from "node:path";
-import { parse as parseYaml } from "yaml";
-export const AUTO_COMMENT_OPTIONS = {
-    imageWidth: "auto",
-    maxInlineImages: 16, // MAX_INLINE_ATTACHMENT_IMAGES — renderer copies own the constant
-    metaPath: true,
-    metaState: true,
-    linkToFilePage: true,
-    note: null,
-    ingestGithubAttachments: false,
-};
-export const NOTE_MAX_CHARS = 500;
-const WIDTH_MIN = 160;
-const WIDTH_MAX = 1000;
-const MAX_INLINE_MIN = 1;
-const MAX_INLINE_MAX = 48;
-const clamp = (n, lo, hi) => Math.min(hi, Math.max(lo, Math.round(n)));
-export function parseRepoCommentConfig(text, format) {
-    const warnings = [];
-    let root;
-    try {
-        root = format === "json" ? JSON.parse(text) : parseYaml(text);
-    }
-    catch {
-        return { config: null, warnings: ["config file could not be parsed; ignoring it"] };
-    }
-    if (typeof root !== "object" || root === null || Array.isArray(root)) {
-        return { config: null, warnings };
-    }
-    const comment = root.comment;
-    if (typeof comment !== "object" || comment === null || Array.isArray(comment)) {
-        return { config: null, warnings };
-    }
-    const c = comment;
-    const config = {};
-    // imageWidth: "auto" | "full" | finite number (clamped)
-    if ("imageWidth" in c) {
-        const v = c.imageWidth;
-        if (v === "auto" || v === "full")
-            config.imageWidth = v;
-        else if (typeof v === "number" && Number.isFinite(v))
-            config.imageWidth = clamp(v, WIDTH_MIN, WIDTH_MAX);
-        else
-            warnings.push(`imageWidth: expected "auto", "full", or a number; dropped`);
-    }
-    // maxInlineImages: finite number (clamped)
-    if ("maxInlineImages" in c) {
-        const v = c.maxInlineImages;
-        if (typeof v === "number" && Number.isFinite(v))
-            config.maxInlineImages = clamp(v, MAX_INLINE_MIN, MAX_INLINE_MAX);
-        else
-            warnings.push(`maxInlineImages: expected a number; dropped`);
-    }
-    // linkToFilePage: boolean
-    if ("linkToFilePage" in c) {
-        const v = c.linkToFilePage;
-        if (typeof v === "boolean")
-            config.linkToFilePage = v;
-        else
-            warnings.push(`linkToFilePage: expected a boolean; dropped`);
-    }
-    // ingestGithubAttachments: boolean
-    if ("ingestGithubAttachments" in c) {
-        const v = c.ingestGithubAttachments;
-        if (typeof v === "boolean")
-            config.ingestGithubAttachments = v;
-        else
-            warnings.push(`ingestGithubAttachments: expected a boolean; dropped`);
-    }
-    // meta.path / meta.state: booleans nested under `meta`
-    if ("meta" in c) {
-        const v = c.meta;
-        if (typeof v === "object" && v !== null && !Array.isArray(v)) {
-            const meta = v;
-            if ("path" in meta) {
-                if (typeof meta.path === "boolean")
-                    config.metaPath = meta.path;
-                else
-                    warnings.push(`meta.path: expected a boolean; dropped`);
-            }
-            if ("state" in meta) {
-                if (typeof meta.state === "boolean")
-                    config.metaState = meta.state;
-                else
-                    warnings.push(`meta.state: expected a boolean; dropped`);
-            }
-        }
-        else {
-            warnings.push(`meta: expected an object; dropped`);
-        }
-    }
-    // note: non-empty trimmed string, max NOTE_MAX_CHARS (never truncated)
-    if ("note" in c) {
-        const v = c.note;
-        if (typeof v === "string") {
-            const trimmed = v.trim();
-            if (trimmed.length === 0) {
-                // empty/whitespace note is treated as absent
-            }
-            else if (trimmed.length > NOTE_MAX_CHARS) {
-                warnings.push(`note: longer than ${NOTE_MAX_CHARS} characters; dropped (not truncated)`);
-            }
-            else {
-                config.note = trimmed;
-            }
-        }
-        else {
-            warnings.push(`note: expected a string; dropped`);
-        }
-    }
-    return { config, warnings };
-}
-export function resolveCommentOptions(repo, ws) {
-    const wsAsRepo = {
-        ...(ws?.imageWidth !== undefined ? { imageWidth: ws.imageWidth } : {}),
-        ...(ws?.maxInlineImages !== undefined ? { maxInlineImages: ws.maxInlineImages } : {}),
-        ...(ws?.showMetadata !== undefined
-            ? { metaPath: ws.showMetadata, metaState: ws.showMetadata }
-            : {}),
-        ...(ws?.linkToFilePage !== undefined ? { linkToFilePage: ws.linkToFilePage } : {}),
-        ...(ws?.note ? { note: ws.note } : {}),
-        ...(ws?.ingestGithubAttachments !== undefined
-            ? { ingestGithubAttachments: ws.ingestGithubAttachments }
-            : {}),
-    };
-    const options = { ...AUTO_COMMENT_OPTIONS };
-    const source = Object.fromEntries(Object.keys(AUTO_COMMENT_OPTIONS).map((k) => [k, "auto"]));
-    const apply = (cfg, from) => {
-        for (const key of [
-            "imageWidth",
-            "maxInlineImages",
-            "metaPath",
-            "metaState",
-            "linkToFilePage",
-            "ingestGithubAttachments",
-        ]) {
-            if (cfg[key] !== undefined && source[key] === "auto") {
-                options[key] = cfg[key];
-                source[key] = from;
-            }
-        }
-        if (cfg.note !== undefined && source.note === "auto") {
-            options.note = cfg.note;
-            source.note = from;
-        }
-    };
-    if (repo)
-        apply(repo, "repo");
-    apply(wsAsRepo, "workspace");
-    return { options, source };
-}
-/**
- * Candidate paths, checked in this order — the first hit wins. Must match
- * the server's REPO_CONFIG_PATHS exactly (apps/api/src/repo-comment-config.ts)
- * so a committed config resolves identically whether the bot or the local
- * gh fallback renders the comment.
- */
-export const REPO_CONFIG_PATHS = [
-    ".uploads.yml",
-    ".uploads.yaml",
-    ".uploads.json",
-    ".github/uploads.yml",
-    ".github/uploads.yaml",
-    ".github/uploads.json",
-];
+import { parseRepoCommentConfig, REPO_CONFIG_PATHS, } from "./comment-config.generated.js";
+export { AUTO_COMMENT_OPTIONS, NOTE_MAX_CHARS, REPO_CONFIG_PATHS, parseRepoCommentConfig, resolveCommentOptions, } from "./comment-config.generated.js";
 /**
  * Read the repo's comment config off the local working tree — the CLI has no
  * GitHub App installation token to fetch via the contents API, so this reads

package/dist/comment-render.generated.d.ts

@@ -0,0 +1,151 @@
+/**
+ * GENERATED by packages/uploads/scripts/inline-shared.mjs — do not edit.
+ * Canonical source: packages/comment-render/src/index.ts
+ * The published CLI cannot import private @uploads/* packages, so this file
+ * is inlined into the tarball. Re-run the script after changing the source.
+ */
+export type GhTargetKind = "pull" | "issues";
+export interface GhTarget {
+    /** "owner/name" */
+    repo: string;
+    kind: GhTargetKind;
+    num: number;
+}
+/** Non-safe chars → `-` for a single R2 key segment (owner/name/branch/…).
+ * Exported for reuse by other GitHub-key builders (github-ingest.ts) that
+ * need the identical sanitization rule — github-promote.ts keeps its own
+ * byte-identical private copy rather than importing this one. */
+export declare function sanitizeKeySegment(s: string): string;
+export declare function ghKeyPrefix(target: GhTarget): string;
+/** Literal root under which every private-repo attachment key lives. */
+export declare const GH_PRIVATE_ROOT = "gh/private/";
+/**
+ * Private-repo key prefix: `gh/private/<32-hex-id>/<kind>/<num>/`.
+ * Deliberately omits the repo (unlike `ghKeyPrefix`) — the id is a random,
+ * unguessable per-repo prefix rather than an owner/name path, so callers
+ * that need the repo back must read `gh.repo` metadata (see
+ * `parseGhPrivateKey`, which cannot recover it from the key alone).
+ */
+export declare function ghPrivateKeyPrefix(prefixId: string, target: GhTarget): string;
+/** Private-repo attachment key: `ghPrivateKeyPrefix` + the sanitized filename. */
+export declare function ghPrivateAttachmentKey(prefixId: string, target: GhTarget, filename: string): string;
+/**
+ * Private-repo branch-staged key prefix: `gh/private/<32-hex-id>/branch/`.
+ * Unlike `ghBranchKeyPrefix`, there is deliberately NO branch-name segment —
+ * the branch name itself is not embedded in a private-repo key.
+ */
+export declare function ghPrivateBranchKeyPrefix(prefixId: string): string;
+/** Private-repo branch-staged attachment key: `ghPrivateBranchKeyPrefix` + the sanitized filename. */
+export declare function ghPrivateBranchAttachmentKey(prefixId: string, filename: string): string;
+/**
+ * Inverse of `ghPrivateKeyPrefix`: parse the prefix id/kind/number back out
+ * of a private-repo attachment key, or undefined for any other key shape.
+ * Cannot recover the repo — callers that need it read `gh.repo` metadata.
+ */
+export declare function parseGhPrivateKey(key: string): {
+    prefixId: string;
+    kind: GhTargetKind;
+    num: number;
+} | undefined;
+/** Hidden marker identifying the one comment this CLI manages. Never change it — existing comments are found by exact match. */
+export declare const ATTACHMENTS_MARKER = "<!-- uploads.sh:attachments -->";
+/**
+ * Per-workspace marker (`<!-- uploads.sh:attachments ws=<workspace> -->`) so
+ * two workspaces managing the same repo don't clobber each other's comment.
+ * Falls back to the shared legacy marker when `workspace` is missing or does
+ * not look like a safe slug — degrade, don't guess or risk breaking the
+ * comment's HTML.
+ */
+export declare function attachmentsMarker(workspace?: string): string;
+/** Max attachments embedded as inline `<img>` tags before the rest collapse
+ * into a `<details>` link list. Keeps very large threads from becoming a wall
+ * of images. */
+export declare const MAX_INLINE_ATTACHMENT_IMAGES = 16;
+/**
+ * Per-render knobs for the managed comment (issue #307), sourced from repo
+ * comment config. `imageWidth: "auto"` uses per-item filename heuristics plus
+ * density-aware sizing (solo/sparse/dense from the inlined count); `"full"`
+ * omits the `width` attribute entirely; a number overrides every width site.
+ */
+export interface CommentRenderOptions {
+    imageWidth: "auto" | "full" | number;
+    maxInlineImages: number;
+    metaPath: boolean;
+    metaState: boolean;
+    note: string | null;
+}
+/** Today's behavior, expressed as options — the default for every caller that
+ * hasn't opted into repo comment config. */
+export declare const AUTO_RENDER_OPTIONS: CommentRenderOptions;
+export interface AttachmentItem {
+    key: string;
+    url: string | null;
+    /** Prefer for `<img src>` on GitHub (Camo-friendly host). Falls back to `url`. */
+    embedUrl?: string | null;
+    /** Canonical `/f/` file-page URL (server-computed). Preferred click-through target; falls back to `url`. */
+    pageUrl?: string | null;
+    /**
+     * The only canonical metadata the managed comment renders (issue #365).
+     * Deliberately two named fields rather than `Record<string, string>`: the
+     * comment is posted publicly, and keeping the set narrow at the type level
+     * mirrors the server-side query filter that never fetches EXIF-derived
+     * keys like `device`/`software` for this path.
+     */
+    meta?: {
+        path?: string;
+        state?: string;
+    };
+    /**
+     * Poster frame for a video (issue #299), server-computed like `embedUrl` —
+     * never taken from client-settable metadata. Absent means "no poster", and
+     * the renderer falls back to the bullet link.
+     */
+    posterUrl?: string | null;
+    /** Derived video facts used for the caption and display width. */
+    videoMeta?: {
+        durationSeconds?: number;
+        width?: number;
+        height?: number;
+    };
+}
+/** A public gallery linked to the PR or issue whose managed comment is syncing. */
+export interface GalleryCommentItem {
+    title: string;
+    /** Canonical URL returned by the API; callers must not synthesize it. */
+    url: string;
+    /** A bounded set of available images; each links to its item page when known, else the gallery. */
+    previews?: {
+        url: string;
+        alt: string;
+        embedUrl?: string | null;
+        itemUrl?: string;
+    }[];
+}
+/**
+ * How crowded the managed comment is. Sparse comments (one shot, a single
+ * before/after) get larger embeds; dense comments keep compact historical sizes.
+ */
+export type AttachmentDensity = "solo" | "sparse" | "dense";
+/** Dense (historical) default max width for images in the managed comment. */
+export declare const ATTACHMENT_IMAGE_WIDTH_DEFAULT = 400;
+/** Portrait / device mockups — keep phones readable, not full-column. */
+export declare const ATTACHMENT_IMAGE_WIDTH_PORTRAIT = 280;
+/** Wide UI / browser chrome. */
+export declare const ATTACHMENT_IMAGE_WIDTH_WIDE = 640;
+/** Dense pair-cell cap (side-by-side before/after). */
+export declare const ATTACHMENT_IMAGE_WIDTH_PAIR = 320;
+/** Map an inlined-media count onto a density tier. */
+export declare function attachmentDensityForCount(inlinedCount: number): AttachmentDensity;
+/** Pair-cell cap for the given density. */
+export declare function attachmentPairWidth(density?: AttachmentDensity): number;
+/**
+ * Display width for a GitHub comment embed. Filenames are a weak but practical
+ * signal (we don't re-fetch dimensions when rebuilding the comment). `density`
+ * only affects managed-comment auto layout; other callers leave it `"dense"`.
+ */
+export declare function attachmentImageWidth(filename: string, density?: AttachmentDensity): number;
+/**
+ * Render the one marker-owned GitHub comment. When there are no galleries this
+ * intentionally preserves the legacy attachment-only body byte-for-byte.
+ */
+export declare function attachmentsCommentBody(items: AttachmentItem[], galleries?: GalleryCommentItem[], marker?: string, options?: CommentRenderOptions): string;