@buildinternet/uploads 0.52.1 → 0.53.0

package/README.md

@@ -45,7 +45,7 @@ global `uploads` form above.
 
 Commands: `attach`, `put`, `screenshot`, `annotate`, `gallery`, `comment`, `list`, `find`, `meta`, `delete`, `usage`,
 `reconcile`, `purge-expired`, `setup`, `install`, `login`, `whoami` (alias `status`),
-`logout`, `invite`, `admin`, `config`, `telemetry`, `report`, `doctor`, `health`, `mcp`,
+`logout`, `invite`, `admin`, `config`, `telemetry`, `report`, `doctor`, `health`, `changelog`, `mcp`,
 `completion`.
 
 **Help:** bare `uploads` / `uploads help` / `--help` shows essentials; use

package/dist/changelog.d.ts

@@ -0,0 +1,36 @@
+export declare const CHANGELOG_PAGE_URL = "https://uploads.sh/changelog";
+export declare const CHANGELOG_JSON_URL = "https://uploads.sh/changelog.json";
+export declare const CHANGELOG_XML_URL = "https://uploads.sh/changelog.xml";
+export declare const DEFAULT_CHANGELOG_LIMIT = 5;
+export declare const MAX_CHANGELOG_LIMIT = 50;
+export type ChangelogKind = "platform" | "cli";
+export type ChangelogJsonEntry = {
+    id: string;
+    kind: ChangelogKind;
+    title: string;
+    date: string;
+    url: string;
+    tags: string[];
+    summary: string;
+    body: string;
+};
+export type ChangelogDocument = {
+    url: string;
+    feed?: string;
+    entries: ChangelogJsonEntry[];
+};
+export type FetchChangelogOptions = {
+    limit?: number;
+    url?: string;
+    fetchImpl?: typeof fetch;
+    timeoutMs?: number;
+    userAgent?: string;
+};
+/** Parse the Atom twin at /changelog.xml (fallback when JSON is not deployed yet). */
+export declare function parseChangelogAtom(xml: string): ChangelogDocument;
+export declare function parseChangelogJson(raw: unknown): ChangelogDocument;
+export declare function clampChangelogLimit(limit: number | undefined): number;
+export declare function selectChangelogEntries(doc: ChangelogDocument, limit?: number): ChangelogDocument;
+/** Human terminal output: recent titles + summaries, then a link to the page. */
+export declare function formatChangelogHuman(doc: ChangelogDocument): string;
+export declare function fetchChangelog(opts?: FetchChangelogOptions): Promise<ChangelogDocument>;

package/dist/changelog.js

@@ -0,0 +1,240 @@
+/**
+ * Fetch and format the public uploads.sh changelog for `uploads changelog`
+ * and the MCP `changelog` tool.
+ */
+import { UploadsError } from "./errors.js";
+import { packageVersion } from "./package-version.js";
+export const CHANGELOG_PAGE_URL = "https://uploads.sh/changelog";
+export const CHANGELOG_JSON_URL = "https://uploads.sh/changelog.json";
+export const CHANGELOG_XML_URL = "https://uploads.sh/changelog.xml";
+export const DEFAULT_CHANGELOG_LIMIT = 5;
+export const MAX_CHANGELOG_LIMIT = 50;
+const FETCH_TIMEOUT_MS = 8000;
+function isKind(value) {
+    return value === "platform" || value === "cli";
+}
+function asString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function asHttpUrl(value) {
+    const raw = asString(value);
+    if (!raw)
+        return undefined;
+    try {
+        const parsed = new URL(raw);
+        if (parsed.protocol === "https:" || parsed.protocol === "http:")
+            return raw;
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+function parseEntry(raw) {
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    const rec = raw;
+    const id = asString(rec.id);
+    const title = asString(rec.title);
+    const date = asString(rec.date);
+    const url = asHttpUrl(rec.url);
+    const summary = asString(rec.summary);
+    if (!id || !title || !date || !url || !summary)
+        return undefined;
+    const kind = isKind(rec.kind) ? rec.kind : "platform";
+    const tags = Array.isArray(rec.tags)
+        ? rec.tags.filter((t) => typeof t === "string" && t.length > 0)
+        : [];
+    return {
+        id,
+        kind,
+        title,
+        date,
+        url,
+        tags,
+        summary,
+        body: typeof rec.body === "string" ? rec.body : "",
+    };
+}
+function decodeXml(value) {
+    return value
+        .replaceAll("&lt;", "<")
+        .replaceAll("&gt;", ">")
+        .replaceAll("&quot;", '"')
+        .replaceAll("&apos;", "'")
+        .replaceAll("&amp;", "&");
+}
+function stripHtml(html) {
+    return html
+        .replace(/<script[\s\S]*?<\/script>/gi, " ")
+        .replace(/<style[\s\S]*?<\/style>/gi, " ")
+        .replace(/<[^>]+>/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function tagMatch(block, tag) {
+    const m = block.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`));
+    return m?.[1] === undefined ? undefined : decodeXml(m[1]).trim();
+}
+function attrMatch(block, tag, attr) {
+    const m = block.match(new RegExp(`<${tag}[^>]*\\s${attr}="([^"]+)"`));
+    return m?.[1] === undefined ? undefined : decodeXml(m[1]).trim();
+}
+function truncateSummary(text, maxChars = 280) {
+    if (text.length <= maxChars)
+        return text;
+    const cut = text.slice(0, maxChars - 1);
+    const atSpace = cut.lastIndexOf(" ");
+    return `${atSpace > 40 ? cut.slice(0, atSpace) : cut}…`;
+}
+/** Parse the Atom twin at /changelog.xml (fallback when JSON is not deployed yet). */
+export function parseChangelogAtom(xml) {
+    const entries = [];
+    const entryRe = /<entry>([\s\S]*?)<\/entry>/g;
+    let match;
+    while ((match = entryRe.exec(xml))) {
+        const block = match[1] ?? "";
+        const title = tagMatch(block, "title");
+        const date = tagMatch(block, "updated");
+        const url = attrMatch(block, "link", "href") ?? tagMatch(block, "id");
+        const idHref = tagMatch(block, "id") ?? url ?? "";
+        const hash = idHref.indexOf("#");
+        const id = hash >= 0 ? idHref.slice(hash + 1) : undefined;
+        const tags = [...block.matchAll(/<category\s+term="([^"]+)"/g)].map((m) => decodeXml(m[1] ?? ""));
+        const html = tagMatch(block, "content") ?? "";
+        const plain = stripHtml(html);
+        if (!title || !date || !url || !id || !plain)
+            continue;
+        const kind = tags.includes("cli") && !tags.includes("platform") ? "cli" : "platform";
+        entries.push({
+            id,
+            kind,
+            title,
+            date,
+            url,
+            tags,
+            summary: truncateSummary(plain),
+            body: plain,
+        });
+    }
+    if (entries.length === 0) {
+        throw new UploadsError("changelog Atom feed had no usable entries", "API_ERROR");
+    }
+    return { url: CHANGELOG_PAGE_URL, feed: CHANGELOG_XML_URL, entries };
+}
+export function parseChangelogJson(raw) {
+    if (!raw || typeof raw !== "object") {
+        throw new UploadsError("changelog response was not a JSON object", "API_ERROR");
+    }
+    const rec = raw;
+    if (!Array.isArray(rec.entries)) {
+        throw new UploadsError("changelog response is missing an entries array", "API_ERROR");
+    }
+    const entries = rec.entries
+        .map(parseEntry)
+        .filter((e) => e !== undefined);
+    if (rec.entries.length > 0 && entries.length === 0) {
+        throw new UploadsError("changelog response had no usable entries", "API_ERROR");
+    }
+    const feed = asHttpUrl(rec.feed);
+    return {
+        url: asHttpUrl(rec.url) ?? CHANGELOG_PAGE_URL,
+        ...(feed ? { feed } : {}),
+        entries,
+    };
+}
+export function clampChangelogLimit(limit) {
+    const n = limit ?? DEFAULT_CHANGELOG_LIMIT;
+    if (n > MAX_CHANGELOG_LIMIT)
+        return MAX_CHANGELOG_LIMIT;
+    if (n < 1)
+        return DEFAULT_CHANGELOG_LIMIT;
+    return n;
+}
+export function selectChangelogEntries(doc, limit) {
+    const n = clampChangelogLimit(limit);
+    return { ...doc, entries: doc.entries.slice(0, n) };
+}
+function formatDate(iso) {
+    const d = new Date(iso);
+    if (Number.isNaN(d.getTime()))
+        return iso;
+    return d.toLocaleDateString("en-US", {
+        year: "numeric",
+        month: "short",
+        day: "numeric",
+        timeZone: "UTC",
+    });
+}
+function indent(text, prefix = "  ") {
+    return text
+        .split("\n")
+        .map((line) => (line.length === 0 ? prefix.trimEnd() : `${prefix}${line}`))
+        .join("\n");
+}
+/** Human terminal output: recent titles + summaries, then a link to the page. */
+export function formatChangelogHuman(doc) {
+    const lines = ["What's new", ""];
+    if (doc.entries.length === 0) {
+        lines.push("No changelog entries.");
+    }
+    else {
+        for (const entry of doc.entries) {
+            lines.push(entry.title);
+            lines.push(`${formatDate(entry.date)}  ·  ${entry.url}`);
+            lines.push("");
+            lines.push(indent(entry.summary));
+            lines.push("");
+        }
+    }
+    lines.push(`See all updates: ${doc.url}`);
+    return `${lines.join("\n")}\n`;
+}
+async function fetchUrl(fetchImpl, url, headers, timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetchImpl(url, { signal: controller.signal, headers });
+    }
+    catch (err) {
+        const aborted = err instanceof Error && err.name === "AbortError";
+        throw new UploadsError(aborted
+            ? `timed out fetching changelog (${timeoutMs}ms)`
+            : `couldn't reach changelog (${err instanceof Error ? err.message : String(err)})`, "NETWORK");
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export async function fetchChangelog(opts = {}) {
+    const explicitUrl = opts.url;
+    const fetchImpl = opts.fetchImpl ?? fetch;
+    const timeoutMs = opts.timeoutMs ?? FETCH_TIMEOUT_MS;
+    const userAgent = opts.userAgent ?? `uploads/${packageVersion()}`;
+    const headers = { "user-agent": userAgent };
+    const jsonUrl = explicitUrl ?? CHANGELOG_JSON_URL;
+    const jsonRes = await fetchUrl(fetchImpl, jsonUrl, { ...headers, accept: "application/json" }, timeoutMs);
+    if (jsonRes.ok) {
+        try {
+            const payload = await jsonRes.json();
+            return selectChangelogEntries(parseChangelogJson(payload), opts.limit);
+        }
+        catch (err) {
+            if (explicitUrl) {
+                throw err instanceof UploadsError
+                    ? err
+                    : new UploadsError("changelog response was not valid JSON", "API_ERROR", jsonRes.status);
+            }
+        }
+    }
+    else if (explicitUrl) {
+        throw new UploadsError(`changelog returned HTTP ${jsonRes.status}; see ${CHANGELOG_PAGE_URL}`, "API_ERROR", jsonRes.status);
+    }
+    // JSON twin is new; fall back to the Atom feed that already ships.
+    const xmlRes = await fetchUrl(fetchImpl, CHANGELOG_XML_URL, { ...headers, accept: "application/atom+xml, application/xml, text/xml" }, timeoutMs);
+    if (!xmlRes.ok) {
+        throw new UploadsError(`changelog returned HTTP ${xmlRes.status}; see ${CHANGELOG_PAGE_URL}`, "API_ERROR", xmlRes.status);
+    }
+    const xml = await xmlRes.text();
+    return selectChangelogEntries(parseChangelogAtom(xml), opts.limit);
+}

package/dist/cli-catalog.js

@@ -233,6 +233,10 @@ export const ROOT_COMMANDS = [
         summary: "Update the CLI, then refresh the agent skills + MCP registration",
         essential: true,
     },
+    {
+        name: "changelog",
+        summary: "Show recent product updates (and a link to the full changelog)",
+    },
     {
         name: "login",
         summary: "Sign in via browser (or an enrollment code) and save credentials",

package/dist/cli.js

@@ -16,6 +16,7 @@ import { runMcp } from "./commands/mcp.js";
 import { runInstall } from "./commands/install.js";
 import { runHook } from "./commands/hook.js";
 import { runUpdate } from "./commands/update.js";
+import { runChangelog } from "./commands/changelog.js";
 import { runCompletion } from "./commands/completion.js";
 import { runLogout, runWhoami } from "./commands/session.js";
 import { runTelemetry } from "./commands/telemetry.js";
@@ -238,6 +239,10 @@ export async function runCli(argv) {
             case "health":
                 code = await runHealth({ apiUrl, json }, cmdArgs, showHelp);
                 break;
+            case "changelog":
+                // Public feed — no token, independent of the API origin.
+                code = await runChangelog(cmdArgs, { json }, showHelp);
+                break;
             case "config":
                 code = await runConfig(cmdArgs, { json, envFile: parsed.globals.envFile }, showHelp);
                 break;

package/dist/commands/changelog.d.ts

@@ -0,0 +1,7 @@
+import { type FetchChangelogOptions } from "../changelog.js";
+export interface RunChangelogOptions {
+    json?: boolean;
+    fetch?: FetchChangelogOptions["fetchImpl"];
+    url?: string;
+}
+export declare function runChangelog(args: string[], opts?: RunChangelogOptions, help?: boolean): Promise<number>;

package/dist/commands/changelog.js

@@ -0,0 +1,49 @@
+import { flagBool, flagInt, parseCommandArgs, UsageError } from "../cli-args.js";
+import { DEFAULT_CHANGELOG_LIMIT, MAX_CHANGELOG_LIMIT, fetchChangelog, formatChangelogHuman, } from "../changelog.js";
+import { writeCommandHelp } from "../cli-style.js";
+import { writeJson, writeStdout } from "../io.js";
+const CHANGELOG_HELP = `uploads changelog — recent product updates
+
+Prints the latest updates from uploads.sh, then a link to the full changelog.
+
+Usage:
+  uploads changelog [options]
+
+Options:
+  --limit <n>   Number of entries to show (default: ${DEFAULT_CHANGELOG_LIMIT}, max: ${MAX_CHANGELOG_LIMIT})
+  --json        JSON on stdout (also accepts global --json)
+
+Examples:
+  uploads changelog
+  uploads changelog --limit 10
+  uploads changelog --json
+`;
+export async function runChangelog(args, opts = {}, help = false) {
+    const parsed = parseCommandArgs(args);
+    if (help || parsed.help) {
+        writeCommandHelp(CHANGELOG_HELP);
+        return 0;
+    }
+    if (parsed.positionals.length > 0) {
+        throw new UsageError(`changelog takes no arguments (got ${parsed.positionals[0]})`, {
+            example: "uploads changelog",
+        });
+    }
+    const json = Boolean(opts.json) || flagBool(parsed.flags, "--json");
+    const limit = flagInt(parsed.flags, "--limit", "--limit") ?? DEFAULT_CHANGELOG_LIMIT;
+    if (limit > MAX_CHANGELOG_LIMIT) {
+        throw new UsageError(`--limit must be ${MAX_CHANGELOG_LIMIT} or less (got ${limit})`, {
+            example: `uploads changelog --limit ${MAX_CHANGELOG_LIMIT}`,
+        });
+    }
+    const doc = await fetchChangelog({
+        limit,
+        fetchImpl: opts.fetch,
+        url: opts.url,
+    });
+    if (json)
+        await writeJson(doc);
+    else
+        await writeStdout(formatChangelogHuman(doc));
+    return 0;
+}

package/dist/index.d.ts

@@ -4,6 +4,7 @@ export { sanitizeKeySegment, sha256Short, deriveRepoFromGit, buildScreenshotKey
 export { BUILTIN_DESTINATIONS, isBuiltinDestination, keyMatchesDestination, resolveDestinationRoot, resolvePutPrefix, type BuiltinDestinationId, } from "./destinations.js";
 export { DEFAULT_API_URL, DEFAULT_WORKSPACE, UPLOADS_CONFIG_KEYS, defaultConfigPath, resolveConfigPath, loadConfigFile, loadEnvFile, resolveApiUrl, resolveConfig, describeConfigSources, redactToken, writeConfigKeys, configValuesFromClient, putDefaultsToConfigValues, resolvePutDefaults, mergePutDefaults, workspaceFromToken, workspaceMismatch, type UploadsClientConfig, type ResolvedConfig, type WorkspaceSource, type ConfigValueSource, type ConfigSources, type UploadsConfigKey, type UploadsConfigValues, type PutDefaults, } from "./config.js";
 export { UploadsError, type UploadsErrorCode } from "./errors.js";
+export { CHANGELOG_JSON_URL, CHANGELOG_PAGE_URL, CHANGELOG_XML_URL, DEFAULT_CHANGELOG_LIMIT, MAX_CHANGELOG_LIMIT, fetchChangelog, formatChangelogHuman, parseChangelogAtom, parseChangelogJson, selectChangelogEntries, type ChangelogDocument, type ChangelogJsonEntry, type FetchChangelogOptions, } from "./changelog.js";
 export { assertFetchableUploadUrl, fetchUploadSource, filenameFromUploadUrl, resolveUploadFilename, FETCH_UPLOAD_SOURCE_DEFAULT_MAX_BYTES, FETCH_UPLOAD_SOURCE_MAX_REDIRECTS, FETCH_UPLOAD_SOURCE_TIMEOUT_MS, } from "./fetch-upload-source.js";
 export { createUploadsClient, type UploadsClient, type PutOptions, type ProvenanceInput, type ListOptions, type PutResult, type ListItem, type ListResult, type HeadResult, type DeleteResult, type GalleryItem, type Gallery, type GallerySummary, type GalleryListOptions, type GalleryListResult, type CreateGalleryOptions, type AddGalleryItemOptions, type DeleteGalleryOptions, type HealthResult, type UsageResult, type ReconcileResult, type PurgeExpiredResult, type PurgeExpiredResponse, type FindFilesOptions, type FindFilesItem, type FindFilesResult, type MetadataKeysResult, type MetadataValuesResult, type GetMetadataResult, type PatchMetadataOptions, type ResolveGhPrefixOptions, type ResolveGhPrefixResult, } from "./client.js";
 export { buildCliProvenance } from "./provenance.js";

package/dist/index.js

@@ -4,6 +4,7 @@ export { sanitizeKeySegment, sha256Short, deriveRepoFromGit, buildScreenshotKey
 export { BUILTIN_DESTINATIONS, isBuiltinDestination, keyMatchesDestination, resolveDestinationRoot, resolvePutPrefix, } from "./destinations.js";
 export { DEFAULT_API_URL, DEFAULT_WORKSPACE, UPLOADS_CONFIG_KEYS, defaultConfigPath, resolveConfigPath, loadConfigFile, loadEnvFile, resolveApiUrl, resolveConfig, describeConfigSources, redactToken, writeConfigKeys, configValuesFromClient, putDefaultsToConfigValues, resolvePutDefaults, mergePutDefaults, workspaceFromToken, workspaceMismatch, } from "./config.js";
 export { UploadsError } from "./errors.js";
+export { CHANGELOG_JSON_URL, CHANGELOG_PAGE_URL, CHANGELOG_XML_URL, DEFAULT_CHANGELOG_LIMIT, MAX_CHANGELOG_LIMIT, fetchChangelog, formatChangelogHuman, parseChangelogAtom, parseChangelogJson, selectChangelogEntries, } from "./changelog.js";
 export { assertFetchableUploadUrl, fetchUploadSource, filenameFromUploadUrl, resolveUploadFilename, FETCH_UPLOAD_SOURCE_DEFAULT_MAX_BYTES, FETCH_UPLOAD_SOURCE_MAX_REDIRECTS, FETCH_UPLOAD_SOURCE_TIMEOUT_MS, } from "./fetch-upload-source.js";
 export { createUploadsClient, } from "./client.js";
 export { buildCliProvenance } from "./provenance.js";

package/dist/mcp/output-schemas.d.ts

@@ -21,6 +21,7 @@ export declare const usageResultSchema: JsonSchema;
 export declare const reconcileResultSchema: JsonSchema;
 export declare const purgeExpiredResultSchema: JsonSchema;
 export declare const whoamiResultSchema: JsonSchema;
+export declare const changelogResultSchema: JsonSchema;
 export declare const promoteToolResultSchema: JsonSchema;
 export declare const galleryResultSchema: JsonSchema;
 export declare const galleryFindResultSchema: JsonSchema;

package/dist/mcp/output-schemas.js

@@ -248,6 +248,21 @@ export const whoamiResultSchema = objectSchema({
     signedIn: { type: "boolean" },
     apiUrl: { type: "string" },
 }, ["ok", "workspace"]);
+const changelogEntrySchema = objectSchema({
+    id: { type: "string" },
+    kind: { type: "string", enum: ["platform", "cli"] },
+    title: { type: "string" },
+    date: { type: "string" },
+    url: { type: "string" },
+    tags: { type: "array", items: { type: "string" } },
+    summary: { type: "string" },
+    body: { type: "string" },
+}, ["id", "kind", "title", "date", "url", "tags", "summary", "body"]);
+export const changelogResultSchema = objectSchema({
+    url: { type: "string" },
+    feed: { type: "string" },
+    entries: { type: "array", items: changelogEntrySchema },
+}, ["url", "entries"]);
 export const promoteToolResultSchema = objectSchema({
     // `promotion` is optional (issue #702): a `keys`-only call (no `branch`)
     // never runs the branch sweep, so there's nothing to report under it.
@@ -329,6 +344,7 @@ export const hostedOutputSchemas = {
     reconcile: reconcileResultSchema,
     purge_expired: purgeExpiredResultSchema,
     whoami: whoamiResultSchema,
+    changelog: changelogResultSchema,
 };
 /** Shared-shape stdio tools. Hosted-only tools (`promote`, `repo_link_status`) omitted. */
 export const stdioOutputSchemas = {
@@ -362,6 +378,7 @@ export const stdioOutputSchemas = {
     reconcile: reconcileResultSchema,
     purge_expired: purgeExpiredResultSchema,
     whoami: whoamiResultSchema,
+    changelog: changelogResultSchema,
     report: objectSchema({
         ok: { type: "boolean" },
         id: { type: "string" },

package/dist/mcp/tools.d.ts

@@ -1,6 +1,6 @@
 /**
  * MCP tool set mirroring the CLI commands (put, attach, list, delete,
- * usage, reconcile, purge_expired, comment, whoami, doctor). Config is
+ * usage, reconcile, purge_expired, comment, whoami, doctor, changelog). Config is
  * resolved fresh per tool call so a
  * per-call `workspace` argument behaves like the CLI's --workspace flag, and
  * a missing token surfaces as a tool error rather than a startup failure.

package/dist/mcp/tools.js

@@ -14,6 +14,7 @@ import { appProp, canonicalMetaFromArgs, METADATA_PATH_CUE, metadataArgWithCanon
 import { batchFailureMessage, mcpDestroyPublic, mcpNoAuth, mcpOAuthAny, mcpOAuthDelete, mcpOAuthRead, mcpOAuthWrite, mcpRead, mcpWriteInternal, mcpWritePublic, stdioOutputSchemas, withOutputSchemas, ToolBatchError, } from "./server.js";
 import { attachmentFromText, buildReportPayload, parseReportType, REPORT_TYPES, submitReport, validateReportMessage, } from "../report.js";
 import { resolveApiUrl } from "../config.js";
+import { DEFAULT_CHANGELOG_LIMIT, MAX_CHANGELOG_LIMIT, fetchChangelog } from "../changelog.js";
 function mcpOptimizeOptions(args, defaults) {
     const quality = optPosInt(args, "optimizeQuality");
     if (quality !== undefined && quality > 100)
@@ -1552,6 +1553,33 @@ export function createUploadsMcpTools(opts) {
                 return { ...target, ...result };
             },
         },
+        {
+            name: "changelog",
+            title: "Product changelog",
+            annotations: {
+                readOnlyHint: true,
+                destructiveHint: false,
+                openWorldHint: true,
+            },
+            securitySchemes: mcpNoAuth,
+            description: "Read recent uploads.sh product updates (platform and CLI). Returns the latest entries with titles, dates, summaries, and a link to the full changelog at https://uploads.sh/changelog. Same as `uploads changelog`. Use this to discover new features before recommending uploads.sh workflows.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    limit: {
+                        type: "number",
+                        description: `How many entries to return (default ${DEFAULT_CHANGELOG_LIMIT}, max ${MAX_CHANGELOG_LIMIT}).`,
+                    },
+                },
+                additionalProperties: false,
+            },
+            async handler(args) {
+                const limit = optPosInt(args, "limit") ?? DEFAULT_CHANGELOG_LIMIT;
+                if (limit > MAX_CHANGELOG_LIMIT)
+                    usage(`limit must be ${MAX_CHANGELOG_LIMIT} or less`);
+                return fetchChangelog({ limit });
+            },
+        },
         {
             name: "whoami",
             title: "Who am I",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buildinternet/uploads",
-  "version": "0.52.1",
+  "version": "0.53.0",
   "mcpName": "sh.uploads/mcp",
   "description": "CLI and client for uploads.sh — workspace-scoped image hosting for GitHub embeds",
   "type": "module",
@@ -39,7 +39,7 @@
     "node": ">=22"
   },
   "peerDependencies": {
-    "files-sdk": "^2.2.4"
+    "files-sdk": "^2.3.1"
   },
   "peerDependenciesMeta": {
     "files-sdk": {
@@ -49,7 +49,7 @@
   "devDependencies": {
     "@types/node": "^26.1.0",
     "ai": "^6.0.0",
-    "files-sdk": "^2.2.5",
+    "files-sdk": "^2.3.1",
     "typescript": "^7.0.2",
     "vitest": "^4.1.10"
   },