@cueai/omni-reader-mcp 1.0.1 → 1.1.0

package/dist/iiis-client.js

@@ -1,8 +1,8 @@
 import { createHash } from "node:crypto";
-import { GRANTED_STREAM_PROTOCOL_VERSION, RESULT_CHUNK_MAX_BYTES, } from "./constants.js";
+import { DEFAULT_IIIS_GRANTED_BASE_URL, GRANTED_STREAM_PROTOCOL_VERSION, RESULT_CHUNK_MAX_BYTES, } from "./constants.js";
 import { OmniBridgeError } from "./errors.js";
 import { createMultipartBody } from "./multipart-body.js";
-import { NOOP_PROGRESS } from "./progress.js";
+import { NOOP_PROGRESS, } from "./progress.js";
 class TransportFailure extends Error {
 }
 const ACTIVE_STATUSES = new Set(["CLAIMED", "UPLOADING", "PROCESSING", "SETTLING"]);
@@ -14,6 +14,15 @@ const TERMINAL_STATUSES = new Set([
     "DELIVERY_EXPIRED",
     "DELIVERED",
 ]);
+const OPERATION_STATUSES = new Set([
+    "ISSUED",
+    "CLAIMED",
+    "UPLOADING",
+    "PROCESSING",
+    "SETTLING",
+    "RELEASED",
+    ...TERMINAL_STATUSES,
+]);
 const RECOVERABLE_SETTLEMENT_ERRORS = new Set([
     "SETTLEMENT_IN_PROGRESS",
     "SETTLEMENT_RETRYABLE",
@@ -24,11 +33,24 @@ const RECOVERABLE_SETTLEMENT_ERRORS = new Set([
 ]);
 const BASE64URL_PATTERN = /^[A-Za-z0-9_-]+$/;
 const SHA256_PATTERN = /^sha256:[0-9a-f]{64}$/;
+const ERROR_CODE_PATTERN = /^[A-Z][A-Z0-9_]{0,127}$/;
+const RFC3339_PATTERN = /^(\d{4})-(\d{2})-(\d{2})[Tt](?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?(?:[Zz]|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/u;
+const PROGRESS_UNITS = new Set([
+    "page",
+    "sheet",
+    "slide",
+    "frame",
+    "segment",
+]);
 function bridgeError(code, message, facts = {}) {
     return new OmniBridgeError({
         code,
         message,
+        operationCreated: facts.operationCreated ?? true,
         fileUploaded: facts.fileUploaded ?? false,
+        parserStarted: (facts.parserStarted ?? false) ||
+            facts.billed === true ||
+            facts.contentReleased === true,
         billed: facts.billed ?? false,
         contentReleased: facts.contentReleased ?? false,
         retryable: facts.retryable ?? false,
@@ -66,11 +88,17 @@ function throwIfCanceled(input) {
     if (input.signal?.aborted)
         throw canceledAfterUpload();
 }
-function operationUrl(input, suffix = "") {
-    const base = new URL(input.uploadUrl);
-    if (base.protocol !== "https:" || base.username !== "" || base.password !== "") {
-        throw bridgeError("INSECURE_IIIS_URL", "The IIIS upload endpoint must use credential-free HTTPS.");
+function secureIiisUrl(value) {
+    const url = new URL(value);
+    if (url.protocol !== "https:" || url.username !== "" || url.password !== "") {
+        throw bridgeError("INSECURE_IIIS_URL", "The IIIS endpoint must use credential-free HTTPS.");
     }
+    return url;
+}
+function operationUrl(input, operationBaseUrl, suffix = "") {
+    const base = input.uploadUrl === undefined
+        ? secureIiisUrl(operationBaseUrl)
+        : secureIiisUrl(input.uploadUrl);
     return new URL(`operations/${encodeURIComponent(input.operationId)}${suffix}`, base).toString();
 }
 function operationHeaders(input) {
@@ -84,37 +112,108 @@ function safeInteger(value, minimum = 0) {
         && Number.isSafeInteger(value)
         && value >= minimum;
 }
+function isRfc3339(value) {
+    if (typeof value !== "string")
+        return false;
+    const match = RFC3339_PATTERN.exec(value);
+    if (match === null)
+        return false;
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    if (month < 1 || month > 12 || day < 1)
+        return false;
+    const monthDays = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    const leapYear = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+    const days = month === 2 && leapYear ? 29 : monthDays[month - 1];
+    return day <= days;
+}
 function validateProtocol(event) {
     if (event.protocol_version !== GRANTED_STREAM_PROTOCOL_VERSION) {
         throw bridgeError("PROTOCOL_MISMATCH", "IIIS returned an unsupported protocol version.");
     }
 }
+function stableErrorCode(value, fallback) {
+    return typeof value === "string" && ERROR_CODE_PATTERN.test(value)
+        ? value
+        : fallback;
+}
+function stableErrorMessage(code) {
+    if (code === "SETTLEMENT_DENIED")
+        return "Billing did not authorize content release.";
+    if (code === "DELIVERY_EXPIRED")
+        return "The temporary delivery result has expired.";
+    if (code === "CLEANUP_PENDING")
+        return "Omni cleanup is still pending.";
+    if (code === "CANCELED")
+        return "The Omni operation was canceled.";
+    return "The Omni parsing service could not complete the operation.";
+}
+function stableProgressMessage(stage) {
+    if (stage === "parse" || stage === "parsing")
+        return "Parsing document";
+    if (stage === "settling" || stage === "settlement")
+        return "Finalizing result";
+    return "Processing document";
+}
 function progressValue(event) {
     validateProtocol(event);
-    if (!safeInteger(event.done) || !safeInteger(event.total)) {
+    if (!safeInteger(event.done) ||
+        !safeInteger(event.total) ||
+        event.done > event.total) {
         throw bridgeError("INVALID_PROGRESS_EVENT", "IIIS returned an invalid progress event.");
     }
+    const unit = typeof event.unit === "string" &&
+        PROGRESS_UNITS.has(event.unit)
+        ? event.unit
+        : undefined;
     return {
         done: event.done,
         total: event.total,
-        message: String(event.message ?? event.stage ?? "Parsing"),
+        message: stableProgressMessage(event.stage),
+        ...(unit === undefined || event.total <= 0
+            ? {}
+            : {
+                detail: {
+                    unit,
+                    completed: Math.min(event.done, event.total),
+                    total: event.total,
+                },
+            }),
     };
 }
 function monotonicProgress(sink) {
     let last = 0;
+    let lastDetail;
     return {
-        async report(progress, total, message) {
+        async report(progress, total, message, detail) {
             const next = Math.min(total, Math.max(last, progress));
             last = next;
-            await sink.report(next, total, message);
+            const nextDetail = detail === undefined
+                ? undefined
+                : lastDetail?.unit === detail.unit
+                    ? {
+                        ...detail,
+                        completed: Math.min(detail.total, Math.max(lastDetail.completed, detail.completed)),
+                    }
+                    : detail;
+            if (nextDetail !== undefined)
+                lastDetail = nextDetail;
+            await sink.report(next, total, message, nextDetail);
         },
     };
 }
+function parserProgress(done, total) {
+    return total > 0
+        ? 40 + Math.floor(Math.min(done / total, 1) * 59)
+        : 40;
+}
 async function errorFromResponse(response, input) {
     try {
         const body = await response.json();
-        if (isRecord(body) && typeof body.code === "string" && typeof body.message === "string") {
-            return bridgeError(body.code, body.message, {
+        if (isRecord(body) && typeof body.code === "string") {
+            const code = stableErrorCode(body.code, "IIIS_UNAVAILABLE");
+            return bridgeError(code, stableErrorMessage(code), {
                 fileUploaded: body.file_uploaded === true,
                 billed: body.billed === true,
                 contentReleased: body.content_released === true,
@@ -139,6 +238,33 @@ async function protocolJson(response, input, description) {
         throw bridgeError("PROTOCOL_MISMATCH", `IIIS returned invalid ${description} JSON.`);
     }
 }
+function operationStatusValue(value, operationId) {
+    if (!isRecord(value)
+        || value.protocol_version !== GRANTED_STREAM_PROTOCOL_VERSION
+        || value.operation_id !== operationId
+        || typeof value.status !== "string"
+        || !OPERATION_STATUSES.has(value.status)
+        || typeof value.parser_started !== "boolean"
+        || typeof value.file_uploaded !== "boolean"
+        || typeof value.billed !== "boolean"
+        || typeof value.content_released !== "boolean"
+        || typeof value.retryable !== "boolean"
+        || !(value.expires_at === null || isRfc3339(value.expires_at))) {
+        throw bridgeError("PROTOCOL_MISMATCH", "IIIS returned an invalid operation status.");
+    }
+    return value;
+}
+function operationSnapshot(status) {
+    return {
+        status: status.status,
+        parserStarted: status.parser_started,
+        fileUploaded: status.file_uploaded,
+        billed: status.billed,
+        contentReleased: status.content_released,
+        retryable: status.retryable,
+        expiresAt: status.expires_at,
+    };
+}
 async function* sseEvents(response) {
     if (response.body === null)
         throw new TransportFailure("missing SSE body");
@@ -193,10 +319,17 @@ export class IiisClient {
     #fetch;
     #pollIntervalMs;
     #maxPolls;
+    #operationBaseUrl;
     constructor(options = {}) {
         this.#fetch = options.fetchImpl ?? fetch;
         this.#pollIntervalMs = Math.max(0, options.pollIntervalMs ?? 250);
         this.#maxPolls = Math.max(1, options.maxPolls ?? 240);
+        const operationBase = secureIiisUrl(options.operationBaseUrl ?? DEFAULT_IIIS_GRANTED_BASE_URL);
+        operationBase.search = "";
+        operationBase.hash = "";
+        if (!operationBase.pathname.endsWith("/"))
+            operationBase.pathname += "/";
+        this.#operationBaseUrl = operationBase.toString();
     }
     async uploadAndWait(input) {
         const progress = monotonicProgress(input.progress ?? NOOP_PROGRESS);
@@ -217,7 +350,35 @@ export class IiisClient {
             return this.#recover(input, true, progress);
         }
     }
-    async downloadResult(input) {
+    async recoverAndWait(input) {
+        return this.#recover(input, false, monotonicProgress(input.progress ?? NOOP_PROGRESS));
+    }
+    async inspectOperation(input) {
+        return operationSnapshot(await this.#status({ ...input, signal: undefined }));
+    }
+    async cancelOperation(input) {
+        throwIfCanceled(input);
+        let response;
+        try {
+            response = await this.#fetch(operationUrl(input, this.#operationBaseUrl, "/cancel"), {
+                method: "POST",
+                headers: operationHeaders(input),
+                signal: input.signal,
+            });
+        }
+        catch {
+            throwIfCanceled(input);
+            throw bridgeError("IIIS_UNAVAILABLE", "IIIS operation cancellation is unavailable.", { retryable: true });
+        }
+        if (!response.ok)
+            throw await errorFromResponse(response, input);
+        if (response.status === 202 || response.status === 204) {
+            return this.inspectOperation(input);
+        }
+        const value = await protocolJson(response, input, "operation cancellation");
+        return operationSnapshot(operationStatusValue(value, input.operationId));
+    }
+    async downloadResult(input, progress = NOOP_PROGRESS) {
         throwIfCanceled(input);
         const confirmedFacts = recoveryFacts({
             fileUploaded: true,
@@ -244,7 +405,7 @@ export class IiisClient {
         }
         let response;
         try {
-            response = await this.#fetch(operationUrl(input, "/result"), {
+            response = await this.#fetch(operationUrl(input, this.#operationBaseUrl, "/result"), {
                 headers: operationHeaders(input),
                 signal: input.signal,
             });
@@ -316,6 +477,7 @@ export class IiisClient {
             };
             await input.retention.complete(metadata);
             throwIfCanceled(input);
+            await progress.report(100, 100, "Completed");
             completed = true;
             return metadata;
         }
@@ -341,7 +503,7 @@ export class IiisClient {
         throwIfCanceled(input);
         let response;
         try {
-            response = await this.#fetch(operationUrl(input, "/ack"), {
+            response = await this.#fetch(operationUrl(input, this.#operationBaseUrl, "/ack"), {
                 method: "POST",
                 headers: operationHeaders(input),
                 signal: input.signal,
@@ -360,21 +522,27 @@ export class IiisClient {
             throw await errorFromResponse(response, input);
     }
     async #uploadOnce(input, progress) {
-        const body = createMultipartBody(input.openedFile, {
+        const openedFile = input.openedFile;
+        const parseGrant = input.parseGrant;
+        const uploadUrl = input.uploadUrl;
+        if (openedFile === undefined || parseGrant === undefined || uploadUrl === undefined) {
+            throw bridgeError("UPLOAD_CONTEXT_UNAVAILABLE", "The local upload context is unavailable for this recovery operation.", { retryable: true });
+        }
+        const body = createMultipartBody(openedFile, {
             signal: input.signal,
             onProgress: async (bytes) => {
-                const scaled = input.openedFile.size === 0
+                const scaled = openedFile.size === 0
                     ? 40
-                    : Math.floor(bytes * 40 / input.openedFile.size);
-                await progress.report(scaled, 100, `Uploading ${bytes}/${input.openedFile.size} bytes`);
+                    : Math.floor(bytes * 40 / openedFile.size);
+                await progress.report(scaled, 100, `Uploading ${bytes}/${openedFile.size} bytes`);
             },
         });
         let response;
         try {
-            response = await this.#fetch(input.uploadUrl, {
+            response = await this.#fetch(uploadUrl, {
                 method: "POST",
                 headers: {
-                    authorization: `Bearer ${input.parseGrant}`,
+                    authorization: `Bearer ${parseGrant}`,
                     "content-type": body.contentType,
                     "content-length": String(body.contentLength),
                 },
@@ -415,14 +583,12 @@ export class IiisClient {
                 }
                 if (event.type === "progress") {
                     const parsed = progressValue(event);
-                    const scaled = parsed.total > 0
-                        ? 40 + Math.floor(Math.min(parsed.done / parsed.total, 1) * 60)
-                        : 40;
-                    await progress.report(scaled, 100, parsed.message);
+                    await progress.report(parserProgress(parsed.done, parsed.total), 100, parsed.message, parsed.detail);
                     continue;
                 }
                 if (event.type === "error") {
-                    throw bridgeError(String(event.code ?? "IIIS_PARSE_FAILED"), String(event.message ?? "IIIS parsing failed."), {
+                    const code = stableErrorCode(event.code, "IIIS_PARSE_FAILED");
+                    throw bridgeError(code, stableErrorMessage(code), {
                         fileUploaded: event.file_uploaded === true,
                         billed: event.billed === true,
                         contentReleased: event.content_released === true,
@@ -519,8 +685,11 @@ export class IiisClient {
                 }
                 throw bridgeError("INVALID_SSE_EVENT", "IIIS returned an unsupported progress event.");
             }
-            if (completedMetadata !== undefined)
+            if (completedMetadata !== undefined) {
+                throwIfCanceled(input);
+                await progress.report(100, 100, "Completed");
                 return completedMetadata;
+            }
             throw new TransportFailure("SSE ended before completion");
         }
         catch (error) {
@@ -549,7 +718,7 @@ export class IiisClient {
         throwIfCanceled(input);
         let response;
         try {
-            response = await this.#fetch(operationUrl(input), {
+            response = await this.#fetch(operationUrl(input, this.#operationBaseUrl), {
                 headers: operationHeaders(input),
                 signal: input.signal,
             });
@@ -561,25 +730,13 @@ export class IiisClient {
         if (!response.ok)
             throw await errorFromResponse(response, input);
         const value = await protocolJson(response, input, "operation status");
-        if (!isRecord(value)
-            || value.protocol_version !== GRANTED_STREAM_PROTOCOL_VERSION
-            || value.operation_id !== input.operationId
-            || typeof value.status !== "string"
-            || typeof value.parser_started !== "boolean"
-            || typeof value.file_uploaded !== "boolean"
-            || typeof value.billed !== "boolean"
-            || typeof value.content_released !== "boolean"
-            || typeof value.retryable !== "boolean"
-            || !(value.expires_at === null || typeof value.expires_at === "string")) {
-            throw bridgeError("PROTOCOL_MISMATCH", "IIIS returned an invalid operation status.");
-        }
-        return value;
+        return operationStatusValue(value, input.operationId);
     }
     async #events(input, afterSequence) {
         throwIfCanceled(input);
         let response;
         try {
-            response = await this.#fetch(operationUrl(input, `/events?after_sequence=${afterSequence}`), { headers: operationHeaders(input), signal: input.signal });
+            response = await this.#fetch(operationUrl(input, this.#operationBaseUrl, `/events?after_sequence=${afterSequence}`), { headers: operationHeaders(input), signal: input.signal });
         }
         catch {
             throwIfCanceled(input);
@@ -631,7 +788,10 @@ export class IiisClient {
                     await progress.report(45, 100, "Parser started");
                     parserStartedReported = true;
                 }
-                if (status.status === "ISSUED" && mayRetryUpload && Date.parse(input.expiresAt) > Date.now()) {
+                if (status.status === "ISSUED" &&
+                    mayRetryUpload &&
+                    input.expiresAt !== undefined &&
+                    Date.parse(input.expiresAt) > Date.now()) {
                     try {
                         return await this.#uploadOnce(input, progress);
                     }
@@ -643,21 +803,18 @@ export class IiisClient {
                     }
                 }
                 else if (status.status === "RELEASED") {
-                    return await this.downloadResult(input);
+                    return await this.downloadResult(input, progress);
                 }
                 else if (ACTIVE_STATUSES.has(status.status)) {
                     const page = await this.#events(input, eventCursor);
                     for (const event of page.events) {
                         const parsed = progressValue(event);
-                        const scaled = parsed.total > 0
-                            ? 40 + Math.floor(Math.min(parsed.done / parsed.total, 1) * 60)
-                            : 40;
-                        await progress.report(scaled, 100, parsed.message);
+                        await progress.report(parserProgress(parsed.done, parsed.total), 100, parsed.message, parsed.detail);
                     }
                     eventCursor = page.nextSequence;
                 }
                 else if (TERMINAL_STATUSES.has(status.status)) {
-                    throw bridgeError(status.status, `The IIIS operation ended with status ${status.status}.`, {
+                    throw bridgeError(status.status, stableErrorMessage(status.status), {
                         fileUploaded: status.file_uploaded,
                         billed: status.billed,
                         contentReleased: status.content_released,

package/dist/index.d.ts

@@ -8,10 +8,13 @@ export interface RunCliOptions {
     readonly cwd?: string;
     readonly artifactRoot?: string;
     readonly platform?: NodeJS.Platform;
+    readonly temporaryDirectory?: string;
+    readonly stdinIsTTY?: boolean;
     readonly now?: () => Date;
     readonly npmVersion?: string;
     readonly packageVersion?: string;
     readonly fetchImpl?: typeof fetch;
+    readonly iiisOperationBaseUrl?: string;
     readonly stdout?: WritableLike;
     readonly stderr?: WritableLike;
     readonly ask?: (question: string) => Promise<string>;

package/dist/index.js

@@ -1,27 +1,33 @@
 #!/usr/bin/env node
 import { execFile as execFileCallback } from "node:child_process";
 import { readFile, realpath } from "node:fs/promises";
+import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { createInterface } from "node:readline/promises";
 import { stdin, stdout as processStdout } from "node:process";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { ArtifactStore, defaultArtifactRoot } from "./artifact-store.js";
+import { ArtifactStore, selectArtifactRoot, } from "./artifact-store.js";
+import { CliUsageError, parseCliArguments } from "./cli/arguments.js";
 import { runClean } from "./cli/clean.js";
-import { runDoctor } from "./cli/doctor.js";
+import { renderDoctor, runDoctor } from "./cli/doctor.js";
 import { runSetup } from "./cli/setup.js";
+import { runUninstall } from "./cli/uninstall.js";
 import { CubeGrantClient } from "./cube-client.js";
 import { IiisClient } from "./iiis-client.js";
+import { createLocalParseOperationManager } from "./operation-manager.js";
 import { OperationJournal } from "./operation-journal.js";
 import { splitAllowedRoots } from "./path-security.js";
+import { HttpRemoteOmniClient } from "./remote-client.js";
 import { createOmniMcpServer } from "./server.js";
 function helpText() {
     return [
-        "Usage: omni-reader-mcp [setup|doctor|clean|--help|--version]",
+        "Usage: omni-reader-mcp [setup|doctor|clean|uninstall|--help|--version]",
         "",
         "No arguments start the stdio MCP server.",
         "setup   Configure a supported user-scope Agent",
         "doctor  Check local configuration and protocol health",
         "clean   Delete Bridge-created local artifacts and expired records",
+        "uninstall Restore a trusted URL-only Agent entry without deleting artifacts",
         "",
     ].join("\n");
 }
@@ -60,16 +66,26 @@ async function installedNpmVersion(env) {
         });
     });
 }
+async function artifactSelectionFor(options, env, homeDirectory, cwd, platform) {
+    if (options.artifactRoot !== undefined) {
+        return { mode: "default", rootDirectory: options.artifactRoot };
+    }
+    return await selectArtifactRoot({
+        platform,
+        homeDirectory,
+        env,
+        projectDirectory: cwd,
+        temporaryDirectory: options.temporaryDirectory ?? tmpdir(),
+    });
+}
 export async function startStdioServer(options = {}) {
     const env = options.env ?? process.env;
+    const homeDirectory = options.homeDirectory ?? (await import("node:os")).homedir();
     const cwd = options.cwd ?? process.cwd();
-    const artifactRoot = options.artifactRoot ?? defaultArtifactRoot({
-        platform: options.platform,
-        homeDirectory: options.homeDirectory,
-        env,
-    });
+    const platform = options.platform ?? process.platform;
+    const artifactSelection = await artifactSelectionFor(options, env, homeDirectory, cwd, platform);
     const artifactStore = await ArtifactStore.open({
-        rootDirectory: artifactRoot,
+        rootDirectory: artifactSelection.rootDirectory,
         projectDirectory: cwd,
         now: options.now,
     });
@@ -79,12 +95,33 @@ export async function startStdioServer(options = {}) {
         environment: { CUE_API_KEY: env.CUE_API_KEY },
         fetchImpl: options.fetchImpl,
     });
+    const iiisClient = new IiisClient({
+        fetchImpl: options.fetchImpl,
+        operationBaseUrl: options.iiisOperationBaseUrl,
+    });
+    const extraRoots = splitAllowedRoots(env.OMNI_ALLOWED_ROOTS);
+    const remoteClient = new HttpRemoteOmniClient({
+        apiKey: env.CUE_API_KEY,
+        fetchImpl: options.fetchImpl,
+    });
+    const operationManager = createLocalParseOperationManager({
+        journal,
+        workspace: cwd,
+        extraRoots,
+        cubeClient,
+        iiisClient,
+        artifactStore,
+        remoteClient,
+        now: options.now,
+    });
     const server = createOmniMcpServer({
         workspace: cwd,
-        extraRoots: splitAllowedRoots(env.OMNI_ALLOWED_ROOTS),
+        extraRoots,
         cubeClient,
-        iiisClient: new IiisClient({ fetchImpl: options.fetchImpl }),
+        iiisClient,
         artifactStore,
+        operationManager,
+        remoteClient,
     });
     const close = async () => {
         await server.close().catch(() => undefined);
@@ -99,7 +136,6 @@ export async function runCli(args, options = {}) {
     const homeDirectory = options.homeDirectory ?? (await import("node:os")).homedir();
     const cwd = options.cwd ?? process.cwd();
     const platform = options.platform ?? process.platform;
-    const artifactRoot = options.artifactRoot ?? defaultArtifactRoot({ platform, homeDirectory, env });
     const fetchImpl = options.fetchImpl ?? fetch;
     const output = options.stdout ?? process.stdout;
     const errorOutput = options.stderr ?? process.stderr;
@@ -107,57 +143,82 @@ export async function runCli(args, options = {}) {
     const write = (text) => { output.write(text); };
     const packageVersion = options.packageVersion ?? await installedPackageVersion();
     try {
-        if (args.length === 0) {
+        const parsed = parseCliArguments(args, platform);
+        if (parsed.command === "server") {
             await (options.startServer ?? (() => startStdioServer({
                 ...options,
                 env,
                 homeDirectory,
                 cwd,
                 platform,
-                artifactRoot,
                 fetchImpl,
             })))();
             return 0;
         }
-        const command = args[0];
-        if (command === "--help" || command === "-h" || command === "help") {
+        if (parsed.command === "help") {
             write(helpText());
             return 0;
         }
-        if (command === "--version" || command === "-v") {
+        if (parsed.command === "version") {
             write(`${packageVersion}\n`);
             return 0;
         }
-        if (command === "setup") {
-            await runSetup({ env, homeDirectory, platform, fetchImpl, ask, write });
+        if (parsed.command === "setup") {
+            await runSetup({
+                env,
+                homeDirectory,
+                platform,
+                fetchImpl,
+                ask,
+                write,
+                stdinIsTTY: options.stdinIsTTY ?? stdin.isTTY === true,
+                arguments: parsed.arguments,
+            });
+            return 0;
+        }
+        if (parsed.command === "uninstall") {
+            await runUninstall({
+                args: [
+                    ...(parsed.yes ? ["--yes"] : []),
+                    ...(parsed.json ? ["--json"] : []),
+                ],
+                env,
+                homeDirectory,
+                platform,
+                write,
+            });
             return 0;
         }
-        if (command === "doctor") {
-            const lines = await runDoctor({
+        if (parsed.command === "doctor") {
+            const artifactSelection = await artifactSelectionFor(options, env, homeDirectory, cwd, platform);
+            const report = await runDoctor({
                 env,
                 homeDirectory,
                 platform,
-                artifactRoot,
+                artifactRoot: artifactSelection.rootDirectory,
+                cacheMode: artifactSelection.mode,
                 fetchImpl,
                 npmVersion: options.npmVersion ?? await installedNpmVersion(env),
                 packageVersion,
             });
-            write(`${lines.join("\n")}\n`);
-            return 0;
-        }
-        if (command === "clean") {
-            const result = await runClean({ artifactRoot, projectDirectory: cwd, now: options.now });
-            write(`Removed ${result.removed} Bridge cache item(s).\n`);
+            write(parsed.json
+                ? `${JSON.stringify(report)}\n`
+                : `${renderDoctor(report).join("\n")}\n`);
             return 0;
         }
-        errorOutput.write(`Unknown command: ${command}\n`);
-        errorOutput.write(helpText());
-        return 1;
+        const artifactSelection = await artifactSelectionFor(options, env, homeDirectory, cwd, platform);
+        const result = await runClean({
+            artifactRoot: artifactSelection.rootDirectory,
+            projectDirectory: cwd,
+            now: options.now,
+        });
+        write(`Removed ${result.removed} Bridge cache item(s).\n`);
+        return 0;
     }
     catch (error) {
         const message = error instanceof Error ? error.message : "The Bridge command failed.";
         errorOutput.write(`Error: ${message}\n`);
-        return 1;
+        return error instanceof CliUsageError ? error.exitCode : 1;
     }
 }
 async function main() {

package/dist/multipart-body.js

@@ -4,7 +4,9 @@ function bridgeError(code, message, retryable) {
     return new OmniBridgeError({
         code,
         message,
+        operationCreated: true,
         fileUploaded: false,
+        parserStarted: false,
         billed: false,
         contentReleased: false,
         retryable,