@buildinternet/uploads 0.44.0 → 0.45.0

package/dist/commands.js

@@ -14,7 +14,7 @@ import { parseMetaFlags, validateMetaMap } from "./metadata.js";
 import { mergeDerivedMeta, nearMissMetaWarnings, validateStateValue } from "./metadata-vocab.js";
 import { mergeSidecarMeta } from "./sidecar.js";
 import { ghAttachmentKeyForMode, ghBranchAttachmentKeyForMode, ghBranchKeyPrefix, ghKeyPrefix, ghPrivateKeyPrefix, ghPrivateBranchKeyPrefix, ghMetadataFromTarget, parseGhKey, parseGhPrivateKey, ghMetadataForBranch, attachmentsCommentBody, attachmentsMarker, AUTO_RENDER_OPTIONS, GH_FALLBACK_AUTHOR_NOTE, normalizeGithubCoordinate, } from "./github.js";
-import { resolveRepo, resolveCurrentPullRequest, resolveCurrentBranch, resolveDefaultBranch, classifyGhNumber, execRunner, timedExecRunner, ghMetadataFromTargetWithTitle, upsertAttachmentsComment, } from "./github-gh.js";
+import { resolveRepo, resolveCurrentPullRequest, resolveCurrentBranch, resolveDefaultBranch, classifyGhNumber, execRunner, timedExecRunner, ghMetadataFromTargetWithTitle, upsertAttachmentsComment, hasLinkCandidate, extractCandidateUrls, fetchAdoptionCandidateText, } from "./github-gh.js";
 import { deriveRepoFromGit, deriveRepoSlugFromGit } from "./keys.js";
 import { noProjectContextNudge } from "./project-context-nudge.js";
 import { resolvePutPrefix } from "./destinations.js";
@@ -564,6 +564,59 @@ export async function syncAttachmentsComment(client, target, run, workspace, opt
                 `Posting via local gh in the meantime.\n`);
         }
     }
+    // Link adoption (issue #708): local-gh fallback parity with the bot's own
+    // adoption (issue #701, apps/api/src/github-link-adopt.ts). When the bot
+    // already handled this target the server already adopted for us, so this
+    // only runs once we've fallen through to gh. Scans the PR/issue body and
+    // every comment for pasted uploads.sh URLs and adopts each one that
+    // resolves (server-side, inside `POST .../github/attach`) to a file in
+    // THIS workspace's own bound-repo attachment prefix — copy, never move,
+    // same as the bot path. Best-effort end to end: any failure (not a git
+    // repo, `gh` unavailable/unauthenticated, config unreadable) degrades to
+    // "adopt nothing" rather than blocking the comment sync it rides along
+    // with.
+    let adoptedCount = 0;
+    let preAdoptionAttachmentCount;
+    try {
+        const root = run("git", ["rev-parse", "--show-toplevel"]).trim();
+        const { config: adoptConfig } = readLocalRepoCommentConfig(root);
+        const { options: adoptOptions } = resolveCommentOptions(adoptConfig, null);
+        if (adoptOptions.adoptLinkedFiles) {
+            const text = fetchAdoptionCandidateText(target, run);
+            if (hasLinkCandidate(text)) {
+                const urls = extractCandidateUrls(text);
+                if (urls.length > 0) {
+                    // Baseline BEFORE this pass's adoptions land (mirrors the bot
+                    // path's `gatherCommentBody` call before its own copies) — feeds
+                    // the noise guard below without a lone adoption inflating its own
+                    // count. Plain prefix only (not the private-prefix listing done
+                    // for the final render below) — good enough for a guard decision.
+                    preAdoptionAttachmentCount = (await client.listAll({ prefix: ghKeyPrefix(target) }))
+                        .length;
+                    for (const url of urls) {
+                        try {
+                            await client.attachExisting({
+                                source: url,
+                                repo: target.repo,
+                                ...(target.kind === "pull" ? { pr: target.num } : { issue: target.num }),
+                            });
+                            adoptedCount++;
+                        }
+                        catch {
+                            // Not a resolvable uploads.sh URL, belongs to a different
+                            // workspace, or the source was deleted — silently dropped,
+                            // matching the bot path's contract (a throw from
+                            // `resolveAttachSourceKey` is caught per-URL there too).
+                        }
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // Not a git repo, `.uploads.yml` unreadable, or `gh` unavailable for the
+        // PR/comments fetch — degrade to no adoption this pass.
+    }
     // gh fallback: gather from this workspace's own data and post via local `gh`.
     // Note (issues #304, #365): this CLI process has no server-side
     // WorkspaceRecord in scope, so it cannot honor a workspace's
@@ -658,11 +711,21 @@ export async function syncAttachmentsComment(client, target, run, workspace, opt
     // bot identity, so this note would be wrong there.
     const body = `${attachmentsCommentBody(items, previewGalleries, marker, renderOptions, target)}\n${GH_FALLBACK_AUTHOR_NOTE}`;
     const count = items.length + previewGalleries.length;
+    // Noise guard (issue #708, mirrors the bot's `shouldSyncAfterAdopt`): a
+    // lone adopted link with nothing else already attached is already fully
+    // visible inline in the PR/comment — don't create a brand-new comment just
+    // to repeat it. `upsertAttachmentsComment` still PATCHes an existing
+    // managed comment unconditionally (its own `if (existing)` branch runs
+    // regardless of `createIfMissing`), so "a managed comment already exists"
+    // and "other attachments are already present" both heal/sync for free
+    // here without any extra condition — this only ever suppresses a fresh
+    // create.
+    const skipLoneAdoptionCreate = adoptedCount === 1 && (preAdoptionAttachmentCount ?? 0) === 0;
     // Empty (count 0) renders the neutral empty-state body but must not create a
     // comment — it only rewrites one that already exists (`action: "skipped"`
     // when none does).
     const { action } = upsertAttachmentsComment(target, body, run, marker, {
-        createIfMissing: count > 0,
+        createIfMissing: count > 0 && !skipLoneAdoptionCreate,
     });
     return { action, count, via: "gh" };
 }

package/dist/github-gh.d.ts

@@ -98,3 +98,30 @@ export declare function upsertAttachmentsComment(target: GhTarget, body: string,
 }): {
     action: "created" | "updated" | "skipped";
 };
+/** Cheap, regex-only reject: no http(s) URL at all means nothing to scan for.
+ * Mirrors `hasLinkCandidate` in apps/api/src/github-link-adopt.ts. */
+export declare function hasLinkCandidate(text: string): boolean;
+/**
+ * Distinct http(s) URLs found in `text`, trailing prose punctuation
+ * stripped, order preserved, first occurrence wins on duplicates. Ported
+ * verbatim from apps/api/src/github-link-adopt.ts's `extractCandidateUrls`
+ * so the two paths recognize the same URL spellings — resolution itself
+ * (storage host / embed host / `/f/` page → key, and the bound-workspace
+ * check) happens server-side inside `POST .../github/attach`, so this file
+ * doesn't need its own copy of that logic.
+ */
+export declare function extractCandidateUrls(text: string): string[];
+/**
+ * Best-effort concatenation of a PR/issue's current body plus every comment's
+ * current body, for link-adoption scanning. Returns "" on any `gh` failure
+ * (not authenticated, network, repo/number not found) — adoption degrades to
+ * a no-op rather than blocking the comment sync it rides along with.
+ *
+ * Unlike the webhook path (which re-scans one specific body/comment ref per
+ * event), the CLI has no per-event ref to key off of — `uploads comment` is
+ * one ad-hoc invocation — so this scans the PR/issue body and every comment
+ * on the thread in one pass every time it runs. That's a documented
+ * divergence: harmless (adoption is idempotent) but does mean a link posted
+ * in comment #1 gets rescanned on every later `uploads comment` run too.
+ */
+export declare function fetchAdoptionCandidateText(target: GhTarget, run: CommandRunner): string;

package/dist/github-gh.js

@@ -344,6 +344,72 @@ function reconcileAfterCreate(target, body, run, marker, createdRaw) {
         return null;
     }
 }
+// --- link adoption (issue #708, local-gh fallback parity with the bot's
+// #701/apps/api/src/github-link-adopt.ts) ---
+/** Cheap, regex-only reject: no http(s) URL at all means nothing to scan for.
+ * Mirrors `hasLinkCandidate` in apps/api/src/github-link-adopt.ts. */
+export function hasLinkCandidate(text) {
+    return /https?:\/\//i.test(text);
+}
+const URL_RE = /https?:\/\/[^\s)"'<>\]]+/gi;
+/**
+ * Distinct http(s) URLs found in `text`, trailing prose punctuation
+ * stripped, order preserved, first occurrence wins on duplicates. Ported
+ * verbatim from apps/api/src/github-link-adopt.ts's `extractCandidateUrls`
+ * so the two paths recognize the same URL spellings — resolution itself
+ * (storage host / embed host / `/f/` page → key, and the bound-workspace
+ * check) happens server-side inside `POST .../github/attach`, so this file
+ * doesn't need its own copy of that logic.
+ */
+export function extractCandidateUrls(text) {
+    const seen = new Set();
+    const out = [];
+    for (const m of text.matchAll(URL_RE)) {
+        const url = m[0].replace(/[.,;:]+$/, "");
+        if (seen.has(url))
+            continue;
+        seen.add(url);
+        out.push(url);
+    }
+    return out;
+}
+/**
+ * Best-effort concatenation of a PR/issue's current body plus every comment's
+ * current body, for link-adoption scanning. Returns "" on any `gh` failure
+ * (not authenticated, network, repo/number not found) — adoption degrades to
+ * a no-op rather than blocking the comment sync it rides along with.
+ *
+ * Unlike the webhook path (which re-scans one specific body/comment ref per
+ * event), the CLI has no per-event ref to key off of — `uploads comment` is
+ * one ad-hoc invocation — so this scans the PR/issue body and every comment
+ * on the thread in one pass every time it runs. That's a documented
+ * divergence: harmless (adoption is idempotent) but does mean a link posted
+ * in comment #1 gets rescanned on every later `uploads comment` run too.
+ */
+export function fetchAdoptionCandidateText(target, run) {
+    let body = "";
+    try {
+        body = run("gh", ["api", `repos/${target.repo}/issues/${target.num}`, "--jq", '.body // ""']);
+    }
+    catch {
+        // Not found / no access — fall through with an empty body; comments may
+        // still be readable.
+    }
+    let comments = "";
+    try {
+        comments = run("gh", [
+            "api",
+            `repos/${target.repo}/issues/${target.num}/comments?per_page=100`,
+            "--paginate",
+            "--jq",
+            '[.[].body] | join("\\n")',
+        ]);
+    }
+    catch {
+        // Same degrade — an empty comments blob just means nothing more to scan.
+    }
+    return `${body}\n${comments}`;
+}
 /** PATCH one comment's body via stdin, so the body is never shell-interpolated. */
 function patchComment(target, run, id, body) {
     run("gh", ["api", `repos/${target.repo}/issues/comments/${id}`, "-X", "PATCH", "-F", "body=@-"], body);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buildinternet/uploads",
-  "version": "0.44.0",
+  "version": "0.45.0",
   "description": "CLI and client for uploads.sh — workspace-scoped image hosting for GitHub embeds",
   "type": "module",
   "sideEffects": false,