@captionbolt/mcp 0.0.0-stage → 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1681 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import {
+  InsufficientScopeError as InsufficientScopeError2,
+  UnauthorizedError as UnauthorizedError3
+} from "@modelcontextprotocol/client";
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+
+// ../integration-contracts/mcp.ts
+import {
+  McpServer,
+  requireScopes
+} from "@modelcontextprotocol/server";
+import { z as z2 } from "zod";
+
+// ../integration-contracts/index.ts
+import { z } from "zod";
+var integrationScopes = [
+  "projects:read",
+  "projects:write",
+  "exports:write",
+  "webhooks:manage"
+];
+var integrationEvents = [
+  "project.ready",
+  "project.completed",
+  "project.failed",
+  "project.cancelled"
+];
+var createApiKeySchema = z.object({
+  name: z.string().trim().min(1).max(80),
+  scopes: z.array(z.enum(integrationScopes)).min(1).max(4),
+  expiresInDays: z.number().int().min(1).max(365).nullable().default(90)
+}).strict();
+var endpointSchema = z.object({
+  url: z.string().url().max(2048),
+  events: z.array(z.enum(integrationEvents)).min(1).max(4).default(["project.completed", "project.failed"])
+}).strict();
+var pageSchema = z.object({
+  search: z.string().max(200).optional(),
+  offset: z.number().int().min(0).max(1e5).default(0),
+  limit: z.number().int().min(1).max(100).default(50)
+}).strict();
+var projectIdSchema = z.object({ projectId: z.string().uuid() }).strict();
+var outputFormatSchema = z.enum(["mp4", "srt", "vtt", "ass", "txt"]);
+var exportProjectSchema = projectIdSchema.extend({
+  outputFormats: z.array(outputFormatSchema).min(1).max(5).default(["mp4"])
+});
+var uploadIdSchema = z.object({ uploadId: z.string().uuid() }).strict();
+var createUploadSchema = z.object({
+  fileName: z.string().trim().min(1).max(512),
+  fileSize: z.number().int().positive().safe(),
+  lastModifiedMs: z.number().int().nonnegative().safe(),
+  fingerprint: z.string().regex(/^[a-f0-9]{64}$/u),
+  durationSec: z.number().positive().finite().optional(),
+  contentType: z.enum([
+    "video/mp4",
+    "video/quicktime",
+    "video/webm",
+    "video/x-msvideo"
+  ])
+}).strict();
+var createProjectSchema = z.object({
+  uploadSessionId: z.string().uuid(),
+  language: z.string().min(2).max(5).optional(),
+  styleId: z.string().min(1).max(100).optional(),
+  presetId: z.string().min(1).max(100).optional(),
+  mode: z.enum(["review", "auto-export"]).default("review")
+}).strict().refine((value) => !(value.styleId && value.presetId), {
+  message: "Choose a style or a preset"
+});
+var operationSchema = z.object({
+  id: z.string(),
+  resourceId: z.string(),
+  state: z.enum(["pending", "running", "completed", "failed"]),
+  error: z.string().nullable(),
+  pollAfterSeconds: z.number()
+});
+var projectSchema = z.object({
+  id: z.string(),
+  fileName: z.string().nullable(),
+  status: z.enum([
+    "processing",
+    "ready",
+    "exporting",
+    "completed",
+    "failed",
+    "cancelled"
+  ]),
+  progress: z.number(),
+  createdAt: z.string(),
+  expiresAt: z.string(),
+  error: z.string().nullable(),
+  pollAfterSeconds: z.number(),
+  autoExport: operationSchema.nullable().optional()
+});
+var uploadSchema = z.object({
+  id: z.string(),
+  projectId: z.string(),
+  status: z.enum([
+    "pending",
+    "uploading",
+    "completing",
+    "uploaded",
+    "consumed",
+    "aborted",
+    "expired"
+  ]),
+  fileName: z.string(),
+  fileSize: z.number(),
+  contentType: z.string(),
+  lastModifiedMs: z.number(),
+  fingerprint: z.string(),
+  partSize: z.number(),
+  partCount: z.number(),
+  completedPartNumbers: z.array(z.number()),
+  expiresAt: z.string()
+});
+var accountSchema = z.object({
+  credits: z.object({
+    totalCreditsSec: z.number(),
+    usedCreditsSec: z.number(),
+    reservedCreditsSec: z.number(),
+    availableCreditsSec: z.number(),
+    periodStart: z.string().nullable(),
+    periodEnd: z.string().nullable()
+  }),
+  upload: z.object({
+    maxFileSizeBytes: z.number(),
+    maxDurationSec: z.number()
+  }),
+  outputFormats: z.array(outputFormatSchema),
+  maxConcurrentJobs: z.number(),
+  watermark: z.boolean(),
+  projectAccessDays: z.number()
+});
+var styleListSchema = z.object({
+  items: z.array(
+    z.object({
+      id: z.string(),
+      name: z.string(),
+      description: z.string(),
+      category: z.string(),
+      tags: z.array(z.string())
+    })
+  ),
+  total: z.number()
+});
+var presetListSchema = z.object({
+  items: z.array(z.object({ id: z.string(), name: z.string() })),
+  total: z.number()
+});
+var projectListSchema = z.object({
+  items: z.array(projectSchema),
+  total: z.number().nullable()
+});
+var resultSchema = z.object({
+  projectId: z.string(),
+  files: z.array(
+    z.object({ format: outputFormatSchema, url: z.string().url() })
+  ),
+  expiresAt: z.string()
+});
+var signedPartsSchema = z.object({
+  completedPartNumbers: z.array(z.number()),
+  signedParts: z.array(
+    z.object({
+      partNumber: z.number(),
+      contentLength: z.number(),
+      url: z.string().url()
+    })
+  )
+});
+var webhookSchema = z.object({
+  id: z.string(),
+  url: z.string().url(),
+  events: z.array(z.string()),
+  enabled: z.boolean(),
+  createdAt: z.date()
+});
+var deliverySchema = z.object({
+  id: z.string(),
+  eventId: z.string(),
+  type: z.string(),
+  state: z.string(),
+  attempts: z.number(),
+  statusCode: z.number().nullable(),
+  errorCode: z.string().nullable(),
+  createdAt: z.date(),
+  nextAttemptAt: z.date(),
+  finishedAt: z.date().nullable()
+});
+
+// ../integration-contracts/mcp.ts
+var IntegrationRequestError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "IntegrationRequestError";
+    this.cause = options.cause;
+    this.kind = options.kind;
+    this.status = options.status;
+    this.code = options.code;
+    this.requestId = options.requestId;
+    this.retryAfterSeconds = options.retryAfterSeconds;
+  }
+};
+function getIntegrationRequestErrorDetails(error) {
+  if (error instanceof IntegrationRequestError) {
+    return {
+      message: error.message,
+      kind: error.kind,
+      ...error.status === void 0 ? {} : { status: error.status },
+      ...error.code === void 0 ? {} : { code: error.code },
+      ...error.requestId === void 0 ? {} : { requestId: error.requestId },
+      ...error.retryAfterSeconds === void 0 ? {} : { retryAfterSeconds: error.retryAfterSeconds }
+    };
+  }
+  return { message: "Request failed", kind: "invalid-response" };
+}
+function createIntegrationMcpErrorResult(error) {
+  const details = getIntegrationRequestErrorDetails(error);
+  return {
+    isError: true,
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({ error: details })
+      }
+    ],
+    structuredContent: { error: details }
+  };
+}
+function parseRetryAfterSeconds(value, now = Date.now()) {
+  if (!value) {
+    return void 0;
+  }
+  const numeric = Number(value);
+  if (Number.isFinite(numeric) && numeric >= 0) {
+    const seconds2 = Math.ceil(numeric);
+    return Number.isSafeInteger(seconds2) ? seconds2 : void 0;
+  }
+  const date = Date.parse(value);
+  if (!Number.isFinite(date)) {
+    return void 0;
+  }
+  const seconds = Math.max(0, Math.ceil((date - now) / 1e3));
+  return Number.isSafeInteger(seconds) ? seconds : void 0;
+}
+var commandId = {
+  idempotencyKey: z2.string().min(1).max(128).describe(
+    "Reuse this exact key when retrying the same request. Use a new key for a new action."
+  )
+};
+function createIntegrationMcpServer(request, options = {}) {
+  const server = new McpServer({ name: "captionbolt", version: "0.1.0" });
+  function tool(name, description, schema, method, path, readOnly) {
+    server.registerTool(
+      name,
+      {
+        description,
+        scopeChallenge: name === "retry_project" && options.retryScopeChallenge ? options.retryScopeChallenge : name === "create_project" ? (context) => requireScopes(
+          "projects:write",
+          ...context.request.params?.arguments?.mode === "auto-export" ? ["exports:write"] : []
+        )(context) : name === "export_project" ? requireScopes("exports:write") : requireScopes(
+          readOnly ? "projects:read" : "projects:write"
+        ),
+        inputSchema: schema,
+        annotations: {
+          readOnlyHint: readOnly,
+          destructiveHint: name === "cancel_project",
+          idempotentHint: true,
+          openWorldHint: true
+        }
+      },
+      async (raw) => {
+        if (options.executeTool) {
+          try {
+            return await options.executeTool(
+              name,
+              raw
+            );
+          } catch (error) {
+            return createIntegrationMcpErrorResult(error);
+          }
+        }
+        const { projectId, id, idempotencyKey, ...input } = raw;
+        const url = path.replace(
+          "{projectId}",
+          encodeURIComponent(String(projectId))
+        ).replace("{id}", encodeURIComponent(String(id)));
+        try {
+          let result = await request(
+            method,
+            url,
+            input,
+            typeof idempotencyKey === "string" ? idempotencyKey : void 0
+          );
+          if (options.editorBaseUrl && name === "get_project") {
+            result = {
+              ...result,
+              editorUrl: new URL(
+                `/editor/${encodeURIComponent(String(projectId))}`,
+                options.editorBaseUrl
+              ).href
+            };
+          }
+          return {
+            content: [
+              { type: "text", text: JSON.stringify(result) }
+            ],
+            structuredContent: result
+          };
+        } catch (error) {
+          return createIntegrationMcpErrorResult(error);
+        }
+      }
+    );
+  }
+  tool(
+    "get_account",
+    "Check the connected account's remaining processing minutes, upload limits and export formats. Safe to call during setup.",
+    z2.object({}).strict(),
+    "GET",
+    "/v1/account",
+    true
+  );
+  tool(
+    "list_styles",
+    "Find available caption styles. All plans have the full style catalog.",
+    pageSchema,
+    "GET",
+    "/v1/styles",
+    true
+  );
+  tool(
+    "list_presets",
+    "Find usable presets saved by this account.",
+    pageSchema,
+    "GET",
+    "/v1/presets",
+    true
+  );
+  tool(
+    "list_projects",
+    "List video projects within their 14-day access window.",
+    pageSchema,
+    "GET",
+    "/v1/projects",
+    true
+  );
+  tool(
+    "get_project",
+    "Check a project's processing status and editorUrl. Poll at pollAfterSeconds; processing continues when the agent disconnects.",
+    projectIdSchema,
+    "GET",
+    "/v1/projects/{projectId}",
+    true
+  );
+  tool(
+    "get_operation",
+    "Read an accepted command. Its resourceId identifies the upload or project; a completed command does not imply a completed video.",
+    z2.object({ id: z2.string().uuid() }).strict(),
+    "GET",
+    "/v1/operations/{id}",
+    true
+  );
+  tool(
+    "create_project",
+    "Create a project from a completed uploadSessionId. Prefer review so the user can inspect captions in the Editor; use auto-export only on explicit request.",
+    createProjectSchema.safeExtend(commandId),
+    "POST",
+    "/v1/projects",
+    false
+  );
+  tool(
+    "export_project",
+    "Export the latest saved project document. Completed projects return their existing result. Unsaved editor changes are excluded.",
+    exportProjectSchema.extend(commandId),
+    "POST",
+    "/v1/projects/{projectId}/export",
+    false
+  );
+  tool(
+    "retry_project",
+    "Explicitly retry a failed project after addressing the cause. Shares the account's current quota.",
+    projectIdSchema.extend(commandId),
+    "POST",
+    "/v1/projects/{projectId}/retry",
+    false
+  );
+  tool(
+    "cancel_project",
+    "Cancel the current project run. Completed outputs are preserved.",
+    projectIdSchema.extend(commandId),
+    "POST",
+    "/v1/projects/{projectId}/cancel",
+    false
+  );
+  tool(
+    "get_result",
+    "Get short-lived download URLs for a completed export. Download before expiresAt; request fresh URLs as needed.",
+    projectIdSchema,
+    "GET",
+    "/v1/projects/{projectId}/result",
+    true
+  );
+  return server;
+}
+
+// src/index.ts
+import { z as z4 } from "zod";
+
+// src/client.ts
+import {
+  InsufficientScopeError,
+  UnauthorizedError as UnauthorizedError2,
+  withOAuth
+} from "@modelcontextprotocol/client";
+
+// src/oauth.ts
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { createServer } from "node:http";
+import {
+  Client,
+  RegistrationRejectedError,
+  StreamableHTTPClientTransport,
+  UnauthorizedError
+} from "@modelcontextprotocol/client";
+function apiOrigin(value) {
+  const url = new URL(value);
+  const loopback = url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+  if (!loopback && url.protocol !== "https:" || url.username || url.password || url.pathname !== "/" || url.search || url.hash) {
+    throw new Error(
+      "CAPTIONBOLT_API_URL must be an HTTPS origin (HTTP loopback for development)"
+    );
+  }
+  return url;
+}
+async function entry(origin2) {
+  try {
+    const { Entry } = await import("@napi-rs/keyring");
+    return new Entry("captionbolt-mcp-oauth", origin2.origin);
+  } catch {
+    throw new IntegrationRequestError(
+      "OS credential store unavailable. Enable a desktop keyring before connecting CaptionBolt.",
+      { kind: "invalid-response", code: "CREDENTIAL_STORE_UNAVAILABLE" }
+    );
+  }
+}
+async function readSaved(origin2) {
+  const value = (await entry(origin2)).getPassword();
+  if (!value) {
+    return {};
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    throw new IntegrationRequestError(
+      "Saved CaptionBolt authorization is invalid. Run captionbolt-mcp logout, then login.",
+      { kind: "invalid-response", code: "CREDENTIAL_INVALID" }
+    );
+  }
+}
+function credentialStore(origin2) {
+  return {
+    read: () => readSaved(origin2),
+    async save(value) {
+      (await entry(origin2)).setPassword(JSON.stringify(value));
+    },
+    async clear() {
+      (await entry(origin2)).deletePassword();
+    }
+  };
+}
+async function hasAuthorization(origin2) {
+  return Boolean((await readSaved(origin2)).tokens?.access_token);
+}
+async function logout(origin2) {
+  await credentialStore(origin2).clear();
+}
+function oauthProvider(origin2, redirectUrl, onAuthorize, options = {}) {
+  let verifier = "";
+  let discovery;
+  const store = options.store ?? credentialStore(origin2);
+  const updateSaved = async (patch) => {
+    await store.save({ ...await store.read(), ...patch });
+  };
+  return {
+    redirectUrl,
+    clientMetadata: {
+      client_name: "CaptionBolt local MCP",
+      redirect_uris: [redirectUrl],
+      grant_types: ["authorization_code", "refresh_token"],
+      response_types: ["code"],
+      token_endpoint_auth_method: "none",
+      scope: "projects:read projects:write exports:write offline_access"
+    },
+    state: () => {
+      const state = randomUUID();
+      options.onState?.(state);
+      return state;
+    },
+    async clientInformation(ctx) {
+      const saved = await store.read();
+      return !ctx || saved.issuer === ctx.issuer ? saved.client : void 0;
+    },
+    async saveClientInformation(client, ctx) {
+      await updateSaved({
+        client,
+        ...ctx ? { issuer: ctx.issuer } : {}
+      });
+    },
+    async tokens(ctx) {
+      const saved = await store.read();
+      return !ctx || saved.issuer === ctx.issuer ? saved.tokens : void 0;
+    },
+    async saveTokens(tokens, ctx) {
+      await updateSaved({
+        tokens,
+        ...ctx ? { issuer: ctx.issuer } : {}
+      });
+    },
+    async invalidateCredentials(scope) {
+      if (scope === "all") {
+        verifier = "";
+        discovery = void 0;
+        await store.clear();
+        return;
+      }
+      if (scope === "verifier") {
+        verifier = "";
+        return;
+      }
+      if (scope === "discovery") {
+        discovery = void 0;
+        return;
+      }
+      const saved = await store.read();
+      delete saved.tokens;
+      if (scope === "client") {
+        delete saved.client;
+      }
+      await store.save(saved);
+    },
+    redirectToAuthorization: onAuthorize,
+    saveCodeVerifier(value) {
+      verifier = value;
+    },
+    codeVerifier() {
+      return verifier;
+    },
+    saveDiscoveryState(state) {
+      discovery = state;
+    },
+    discoveryState() {
+      return discovery;
+    }
+  };
+}
+function loginFailureMessage(error) {
+  if (error instanceof IntegrationRequestError) {
+    return error.message;
+  }
+  if (error instanceof RegistrationRejectedError) {
+    return error.status === 403 || error.status === 429 ? `CaptionBolt blocked this sign-in request (HTTP ${error.status}). If you use a VPN, proxy or managed network, try another network, then run captionbolt-mcp login again.` : `CaptionBolt could not register this client (HTTP ${error.status}). Run captionbolt-mcp login again later.`;
+  }
+  const message = error instanceof Error ? error.message.trim() : "";
+  return message && message.length <= 300 && !/[<\n]/u.test(message) ? `CaptionBolt authorization failed: ${message}` : "CaptionBolt authorization failed. Check your connection, then run captionbolt-mcp login again.";
+}
+async function createLoginCallback() {
+  const server = createServer();
+  let expectedState;
+  let accepted = false;
+  let resolvePending = () => {
+  };
+  const pending = new Promise((resolve2) => {
+    resolvePending = resolve2;
+  });
+  server.on("request", (request, response) => {
+    const url = new URL(request.url ?? "/", "http://127.0.0.1");
+    const state = url.searchParams.getAll("state");
+    const code = url.searchParams.getAll("code");
+    const error = url.searchParams.getAll("error");
+    const validResult = code.length === 1 && Boolean(code[0]) && error.length === 0 || error.length === 1 && Boolean(error[0]) && code.length === 0;
+    if (request.method !== "GET" || url.pathname !== "/callback" || !expectedState || state.length !== 1 || state[0] !== expectedState || !validResult) {
+      response.writeHead(400).end("Invalid authorization callback");
+      return;
+    }
+    if (accepted) {
+      response.writeHead(409).end("Authorization callback already received");
+      return;
+    }
+    accepted = true;
+    let responded = false;
+    resolvePending({
+      params: url.searchParams,
+      respond(success) {
+        if (responded) {
+          return;
+        }
+        responded = true;
+        response.writeHead(success ? 200 : 400, {
+          "Content-Type": "text/plain; charset=utf-8",
+          "Cache-Control": "no-store"
+        }).end(
+          success ? "CaptionBolt connected. You can close this tab." : "CaptionBolt authorization failed. Return to the terminal for details."
+        );
+      }
+    });
+  });
+  await new Promise((resolve2, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      server.off("error", reject);
+      resolve2();
+    });
+  });
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    server.close();
+    throw new Error("Loopback callback unavailable");
+  }
+  return {
+    redirectUrl: `http://127.0.0.1:${address.port}/callback`,
+    pending,
+    expectState(state) {
+      expectedState = state;
+    },
+    close() {
+      server.close();
+    }
+  };
+}
+function remoteClient(origin2, provider) {
+  const client = new Client({ name: "captionbolt-local", version: "0.1.0" });
+  const transport = new StreamableHTTPClientTransport(
+    new URL("/mcp", origin2),
+    {
+      authProvider: provider,
+      onInsufficientScope: "throw"
+    }
+  );
+  return { client, transport };
+}
+function openBrowser(url) {
+  const command2 = process.platform === "darwin" ? ["open", url.href] : process.platform === "win32" ? ["cmd", "/c", "start", "", url.href] : ["xdg-open", url.href];
+  const child = spawn(command2[0] ?? "xdg-open", command2.slice(1), {
+    stdio: "ignore",
+    detached: true
+  });
+  child.on("error", () => {
+  });
+  child.unref();
+  process.stderr.write(
+    `Authorize CaptionBolt in your browser: ${url.href}
+`
+  );
+}
+async function login(origin2) {
+  const callback = await createLoginCallback();
+  const provider = oauthProvider(origin2, callback.redirectUrl, openBrowser, {
+    onState: callback.expectState
+  });
+  const { client, transport } = remoteClient(origin2, provider);
+  try {
+    try {
+      await client.connect(transport);
+      const account = await client.callTool({
+        name: "get_account",
+        arguments: {}
+      });
+      if (account.isError) {
+        throw new Error("Connected but account verification failed");
+      }
+      process.stderr.write("CaptionBolt is already authorized.\n");
+      return;
+    } catch (error) {
+      if (!(error instanceof UnauthorizedError)) {
+        throw error;
+      }
+    }
+    let timeout;
+    let accepted;
+    try {
+      accepted = await Promise.race([
+        callback.pending,
+        new Promise((_, reject) => {
+          timeout = setTimeout(
+            () => reject(new Error("Authorization timed out")),
+            3e5
+          );
+        })
+      ]);
+    } finally {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+    }
+    try {
+      await transport.finishAuth(accepted.params);
+      const fresh = remoteClient(origin2, provider);
+      try {
+        await fresh.client.connect(fresh.transport);
+        const account = await fresh.client.callTool({
+          name: "get_account",
+          arguments: {}
+        });
+        if (account.isError) {
+          throw new Error(
+            "Connected but account verification failed"
+          );
+        }
+      } finally {
+        await fresh.client.close();
+      }
+      accepted.respond(true);
+      process.stderr.write(
+        "CaptionBolt connected and account verified.\n"
+      );
+    } catch (error) {
+      accepted.respond(false);
+      throw error;
+    }
+  } finally {
+    try {
+      await client.close();
+    } finally {
+      callback.close();
+    }
+  }
+}
+
+// src/client.ts
+var CaptionBoltApiError = class extends IntegrationRequestError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "CaptionBoltApiError";
+  }
+};
+function thrownRequestKind(error) {
+  const name = error instanceof Error ? error.name : "";
+  return name === "TimeoutError" ? "timeout" : name === "AbortError" ? "aborted" : null;
+}
+async function parseJsonResponse(response) {
+  let result;
+  try {
+    result = await response.json();
+  } catch (cause) {
+    const interruptedKind = thrownRequestKind(cause);
+    throw new CaptionBoltApiError(
+      interruptedKind === "timeout" ? "CaptionBolt response timed out" : interruptedKind === "aborted" ? "CaptionBolt response was cancelled" : response.ok ? "CaptionBolt returned an invalid JSON response" : `CaptionBolt request failed (${response.status})`,
+      {
+        kind: interruptedKind ?? (response.ok ? "invalid-response" : "http"),
+        status: response.status,
+        requestId: response.headers.get("x-request-id") ?? void 0,
+        retryAfterSeconds: parseRetryAfterSeconds(
+          response.headers.get("retry-after")
+        ),
+        cause
+      }
+    );
+  }
+  if (!result || typeof result !== "object" || Array.isArray(result)) {
+    throw new CaptionBoltApiError(
+      "CaptionBolt returned an invalid JSON response",
+      {
+        kind: "invalid-response",
+        status: response.status,
+        requestId: response.headers.get("x-request-id") ?? void 0,
+        retryAfterSeconds: parseRetryAfterSeconds(
+          response.headers.get("retry-after")
+        )
+      }
+    );
+  }
+  return result;
+}
+var MACHINE_CODE = /^[A-Z][A-Z0-9_]{0,63}$/u;
+function machineCode(value) {
+  for (const key of ["code", "error"]) {
+    const candidate = stringField(value, key);
+    if (candidate && MACHINE_CODE.test(candidate)) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
+function safeServerMessage(value, code) {
+  const message = code ? stringField(value, "message")?.trim() : void 0;
+  if (!message || message.length > 240 || message.includes("<") || message.includes(">") || Array.from(message).some((character) => character.charCodeAt(0) < 32) || message.includes("cb_live_")) {
+    return void 0;
+  }
+  return message;
+}
+function stringField(value, key) {
+  return typeof value[key] === "string" ? value[key] : void 0;
+}
+function createApiClient(baseUrl, provider) {
+  const base = apiOrigin(baseUrl);
+  const authorizedFetch = withOAuth(provider, new URL("/mcp", base))(fetch);
+  return async (method, path, input, idempotencyKey) => {
+    if (!path.startsWith("/v1/uploads") && !/^\/v1\/operations\/[0-9a-fA-F-]{36}$/u.test(path)) {
+      throw new Error("Invalid API path");
+    }
+    const url = new URL(path.replace(/^\/v1\//u, "/mcp/"), base);
+    if (url.origin !== base.origin || !url.pathname.startsWith("/mcp/")) {
+      throw new Error("Invalid API path");
+    }
+    if (method === "GET") {
+      for (const [key, value] of Object.entries(input ?? {})) {
+        if (value !== void 0) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    let response;
+    try {
+      response = await authorizedFetch(url, {
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          ...idempotencyKey ? { "Idempotency-Key": idempotencyKey } : {}
+        },
+        ...method === "GET" ? {} : { body: JSON.stringify(input ?? {}) },
+        redirect: "error",
+        signal: AbortSignal.timeout(3e4)
+      });
+    } catch (cause) {
+      if (cause instanceof IntegrationRequestError) {
+        throw cause;
+      }
+      if (cause instanceof UnauthorizedError2 || cause instanceof Error && cause.message.includes("captionbolt-mcp login")) {
+        await provider.invalidateCredentials?.("discovery");
+        throw new CaptionBoltApiError(
+          "Run captionbolt-mcp login to authorize this computer, then retry.",
+          {
+            kind: "http",
+            status: 401,
+            code: "AUTH_REQUIRED"
+          }
+        );
+      }
+      if (cause instanceof InsufficientScopeError) {
+        throw new CaptionBoltApiError(
+          "CaptionBolt connection lacks permission for this upload. Reconnect with projects:write.",
+          { kind: "http", status: 403, code: "INSUFFICIENT_SCOPE" }
+        );
+      }
+      const interruptedKind = thrownRequestKind(cause);
+      const kind = interruptedKind ?? "network";
+      throw new CaptionBoltApiError(
+        kind === "timeout" ? "CaptionBolt request timed out" : kind === "aborted" ? "CaptionBolt request was cancelled" : "CaptionBolt is unavailable",
+        { kind, cause }
+      );
+    }
+    const result = await parseJsonResponse(response);
+    if (!response.ok) {
+      const code = machineCode(result);
+      throw new CaptionBoltApiError(
+        safeServerMessage(result, code) ?? `CaptionBolt request failed (${response.status})`,
+        {
+          kind: "http",
+          status: response.status,
+          code,
+          requestId: response.headers.get("x-request-id") ?? void 0,
+          retryAfterSeconds: parseRetryAfterSeconds(
+            response.headers.get("retry-after")
+          )
+        }
+      );
+    }
+    return result;
+  };
+}
+
+// src/uploads.ts
+import { createHash, randomUUID as randomUUID2 } from "node:crypto";
+import { constants } from "node:fs";
+import { lstat, open, realpath } from "node:fs/promises";
+import { basename, isAbsolute, resolve } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { z as z3 } from "zod";
+
+// src/media-duration.ts
+import mediaInfoFactory from "mediainfo.js";
+var VideoDurationError = class extends Error {
+  constructor() {
+    super(
+      "The video duration could not be read. Select a readable original video or upload through CaptionBolt."
+    );
+  }
+};
+async function readVideoDuration(file, fileSize, signal) {
+  signal.throwIfAborted();
+  const mediaInfo = await mediaInfoFactory({
+    format: "object",
+    chunkSize: 256 * 1024
+  });
+  try {
+    let readBytes = 0;
+    const deadline = Date.now() + 3e4;
+    const result = await mediaInfo.analyzeData(
+      fileSize,
+      async (size, offset) => {
+        signal.throwIfAborted();
+        const length = Math.min(size, fileSize - offset);
+        if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(length) || length <= 0 || length > 256 * 1024) {
+          throw new Error("Invalid video metadata read");
+        }
+        if (readBytes + length > 32 * 1024 * 1024 || Date.now() > deadline) {
+          return new Uint8Array(0);
+        }
+        readBytes += length;
+        const bytes = Buffer.alloc(length);
+        const { bytesRead } = await file.read(bytes, 0, length, offset);
+        if (bytesRead !== length) {
+          throw new Error(
+            "The selected file changed while reading metadata"
+          );
+        }
+        return bytes;
+      }
+    );
+    signal.throwIfAborted();
+    const video = result.media?.track.find(
+      (track) => track["@type"] === "Video"
+    );
+    const general = result.media?.track.find(
+      (track) => track["@type"] === "General"
+    );
+    const durationSec = video?.Duration ?? general?.Duration;
+    if (!video || typeof durationSec !== "number" || !Number.isFinite(durationSec) || durationSec <= 0) {
+      throw new Error(
+        "Select a video with a readable, positive duration"
+      );
+    }
+    return durationSec;
+  } catch (error) {
+    if (signal.aborted) {
+      throw error;
+    }
+    throw new VideoDurationError();
+  } finally {
+    mediaInfo.close();
+  }
+}
+
+// src/uploads.ts
+var SIGNATURE_BATCH_SIZE = 8;
+var PART_UPLOAD_CONCURRENCY = 2;
+var PART_MAX_ATTEMPTS = 3;
+var API_RETRY_WAIT_BUDGET_SECONDS = 300;
+var R2_RETRY_WAIT_BUDGET_SECONDS = 30;
+var CONTENT_TYPES = {
+  mp4: "video/mp4",
+  mov: "video/quicktime",
+  webm: "video/webm",
+  avi: "video/x-msvideo"
+};
+var UploadError = class extends Error {
+  name = "UploadError";
+};
+function fileAccessError(error) {
+  const code = error instanceof Error && "code" in error ? String(error.code) : "";
+  return new UploadError(
+    code === "ENOENT" || code === "ENOTDIR" ? "The selected file was not found. Check its absolute path" : code === "EACCES" || code === "EPERM" ? "The selected file cannot be read. Check its permissions" : code === "ELOOP" ? "Select a regular file without symbolic links" : "The selected file cannot be opened"
+  );
+}
+async function openUploadFile(path) {
+  if (!isAbsolute(path) || /^\\\\[.?]\\/u.test(path)) {
+    throw new UploadError(
+      "Select one absolute path to a regular video file"
+    );
+  }
+  const normalized = resolve(path);
+  let canonical;
+  let beforeOpen;
+  try {
+    canonical = await realpath(normalized);
+    beforeOpen = await lstat(normalized);
+  } catch (error) {
+    throw fileAccessError(error);
+  }
+  const compare = (value) => process.platform === "win32" ? value.toLowerCase() : value;
+  if (beforeOpen.isDirectory()) {
+    throw new UploadError("Select a video file, not a folder");
+  }
+  if (compare(canonical) !== compare(normalized) || !beforeOpen.isFile()) {
+    throw new UploadError("Select a regular file without symbolic links");
+  }
+  let file;
+  try {
+    file = await open(
+      normalized,
+      constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0)
+    );
+  } catch (error) {
+    throw fileAccessError(error);
+  }
+  try {
+    const stat = await file.stat();
+    if (stat.dev !== beforeOpen.dev || stat.ino !== beforeOpen.ino || compare(await realpath(normalized)) !== compare(canonical)) {
+      throw new UploadError(
+        "The selected path changed while opening the file"
+      );
+    }
+    if (!stat.isFile() || stat.size <= 0) {
+      throw new UploadError("Select a nonempty regular file");
+    }
+    const fileName = basename(normalized);
+    const contentType = CONTENT_TYPES[fileName.split(".").pop()?.toLowerCase() ?? ""];
+    if (!contentType) {
+      throw new UploadError("Select an MP4, MOV, WebM or AVI file");
+    }
+    const lastModifiedMs = Math.floor(stat.mtimeMs);
+    const first = Buffer.alloc(Math.min(64 * 1024, stat.size));
+    await file.read(first, 0, first.length, 0);
+    const lastStart = Math.max(64 * 1024, stat.size - 64 * 1024);
+    const last = Buffer.alloc(Math.max(0, stat.size - lastStart));
+    if (last.length) {
+      await file.read(last, 0, last.length, lastStart);
+    }
+    const fingerprint = createHash("sha256").update(
+      `captionbolt-upload-v1\0${fileName}\0${stat.size}\0${lastModifiedMs}\0${contentType}`
+    ).update(first).update(last).digest("hex");
+    return {
+      file,
+      fileName,
+      fileSize: stat.size,
+      lastModifiedMs,
+      fingerprint,
+      contentType
+    };
+  } catch (error) {
+    await file.close();
+    throw error;
+  }
+}
+var signedPartsSchema2 = z3.object({
+  signedParts: z3.array(
+    z3.object({
+      partNumber: z3.number().int().positive(),
+      contentLength: z3.number().int().positive(),
+      url: z3.string().url()
+    })
+  ),
+  completedPartNumbers: z3.array(z3.number())
+});
+function isTransientStatus(status) {
+  return status === 408 || status === 429 || status !== void 0 && status >= 500;
+}
+async function runWithConcurrency(items, concurrency, run, onError) {
+  let nextIndex = 0;
+  let firstError;
+  await Promise.all(
+    Array.from(
+      { length: Math.min(concurrency, items.length) },
+      async () => {
+        try {
+          while (firstError === void 0 && nextIndex < items.length) {
+            const item = items[nextIndex];
+            nextIndex += 1;
+            if (item !== void 0) {
+              await run(item);
+            }
+          }
+        } catch (error) {
+          if (firstError === void 0) {
+            firstError = error;
+            onError?.();
+          }
+        }
+      }
+    )
+  );
+  if (firstError !== void 0) {
+    throw firstError;
+  }
+}
+function stoppedMessage(transfer, error) {
+  if (error instanceof UploadError || error instanceof VideoDurationError) {
+    return error.message;
+  }
+  const retry = transfer.uploadId ? "resume_upload with the same file and uploadId" : "upload_file with the same path and idempotencyKey";
+  return error instanceof IntegrationRequestError ? `Upload stopped by a CaptionBolt API error; see errorDetails. Retry with ${retry} after resolving it.` : `Upload stopped. Check the selected file and connection, then retry with ${retry}.`;
+}
+var LocalUploads = class {
+  constructor(request) {
+    this.request = request;
+  }
+  request;
+  transfers = /* @__PURE__ */ new Map();
+  start(path, idempotencyKey, uploadId) {
+    if ([...this.transfers.values()].some(
+      (item) => ["preparing", "uploading"].includes(item.state)
+    )) {
+      throw new UploadError("Wait for or pause the current local upload");
+    }
+    if (this.transfers.size >= 100) {
+      const oldest = this.transfers.keys().next().value;
+      if (oldest) {
+        this.transfers.delete(oldest);
+      }
+    }
+    const transfer = {
+      id: randomUUID2(),
+      state: "preparing",
+      uploadedBytes: 0,
+      uploadId,
+      controller: new AbortController(),
+      done: Promise.resolve()
+    };
+    this.transfers.set(transfer.id, transfer);
+    transfer.done = this.upload(transfer, path, idempotencyKey).catch(
+      (error) => {
+        const paused = transfer.controller.signal.aborted;
+        transfer.state = paused ? "paused" : "failed";
+        transfer.error = paused ? void 0 : stoppedMessage(transfer, error);
+        transfer.errorDetails = !paused && error instanceof IntegrationRequestError ? getIntegrationRequestErrorDetails(error) : void 0;
+      }
+    );
+    return this.status(transfer.id);
+  }
+  status(id) {
+    const transfer = this.transfers.get(id);
+    if (!transfer) {
+      throw new UploadError(
+        "Local transfer not found. Query the server uploadId or reselect the file to resume."
+      );
+    }
+    const {
+      id: transferId,
+      controller: _controller,
+      done: _done,
+      ...publicState
+    } = transfer;
+    return {
+      transferId,
+      ...publicState,
+      pollAfterSeconds: ["preparing", "uploading"].includes(
+        transfer.state
+      ) ? 2 : 0
+    };
+  }
+  async pause(id) {
+    const transfer = this.transfers.get(id);
+    if (!transfer) {
+      throw new UploadError("Local transfer not found");
+    }
+    transfer.controller.abort();
+    await transfer.done;
+    return this.status(id);
+  }
+  async close() {
+    await Promise.all(
+      [...this.transfers.values()].map(
+        (transfer) => this.pause(transfer.id)
+      )
+    );
+  }
+  async abort(uploadId) {
+    for (const transfer of this.transfers.values()) {
+      if (transfer.uploadId === uploadId && ["preparing", "uploading"].includes(transfer.state)) {
+        await this.pause(transfer.id);
+      }
+    }
+    return this.request("DELETE", `/v1/uploads/${uploadId}`);
+  }
+  async upload(transfer, path, idempotencyKey) {
+    const source = await openUploadFile(path);
+    try {
+      transfer.totalBytes = source.fileSize;
+      const { file, ...metadata } = source;
+      const signal = transfer.controller.signal;
+      signal.throwIfAborted();
+      if (!transfer.uploadId) {
+        const durationSec = await readVideoDuration(
+          file,
+          source.fileSize,
+          signal
+        );
+        const current = await file.stat();
+        if (current.size !== source.fileSize || Math.floor(current.mtimeMs) !== source.lastModifiedMs) {
+          throw new UploadError(
+            "The selected file changed while reading metadata"
+          );
+        }
+        let operation = operationSchema.parse(
+          await this.request(
+            "POST",
+            "/v1/uploads",
+            { ...metadata, durationSec },
+            idempotencyKey
+          )
+        );
+        transfer.operationId = operation.id;
+        while (["pending", "running"].includes(operation.state)) {
+          await delay(
+            Math.max(2, operation.pollAfterSeconds) * 1e3,
+            void 0,
+            { signal }
+          );
+          operation = operationSchema.parse(
+            await this.request(
+              "GET",
+              `/v1/operations/${operation.id}`
+            )
+          );
+        }
+        if (operation.state !== "completed") {
+          throw new UploadError(
+            operation.error ? `Upload reservation failed: ${operation.error}` : "Upload reservation failed"
+          );
+        }
+        transfer.uploadId = operation.resourceId;
+      }
+      let session = uploadSchema.parse(
+        await this.request("GET", `/v1/uploads/${transfer.uploadId}`)
+      );
+      if (session.fileName !== source.fileName || session.fileSize !== source.fileSize || session.lastModifiedMs !== source.lastModifiedMs || session.fingerprint !== source.fingerprint || session.contentType !== source.contentType) {
+        throw new UploadError(
+          "The selected file does not match this upload"
+        );
+      }
+      signal.throwIfAborted();
+      session = uploadSchema.parse(
+        await this.request(
+          "POST",
+          `/v1/uploads/${transfer.uploadId}/resume`
+        )
+      );
+      if (["uploaded", "consumed"].includes(session.status)) {
+        transfer.state = "uploaded";
+        transfer.uploadedBytes = source.fileSize;
+        return;
+      }
+      if (session.status !== "uploading") {
+        throw new UploadError(
+          `Upload session is ${session.status} and no longer accepts parts. Start a new upload with upload_file`
+        );
+      }
+      transfer.state = "uploading";
+      const confirmed = /* @__PURE__ */ new Set();
+      const partSize = (number) => Math.min(
+        session.partSize,
+        source.fileSize - (number - 1) * session.partSize
+      );
+      const markConfirmed = (partNumber) => {
+        if (!Number.isInteger(partNumber) || partNumber < 1 || partNumber > session.partCount) {
+          throw new Error("Invalid server upload plan");
+        }
+        if (!confirmed.has(partNumber)) {
+          confirmed.add(partNumber);
+          transfer.uploadedBytes += partSize(partNumber);
+        }
+      };
+      transfer.uploadedBytes = 0;
+      for (const completed of session.completedPartNumbers) {
+        markConfirmed(completed);
+      }
+      const requestParts = async (partNumbers, requestSignal = signal) => {
+        let lastError;
+        for (let attempt = 0; attempt < PART_MAX_ATTEMPTS; attempt++) {
+          requestSignal.throwIfAborted();
+          try {
+            return signedPartsSchema2.parse(
+              await this.request(
+                "POST",
+                `/v1/uploads/${session.id}/parts`,
+                { partNumbers }
+              )
+            );
+          } catch (error) {
+            lastError = error;
+            const retryable = error instanceof CaptionBoltApiError && (error.kind === "network" || error.kind === "timeout" || isTransientStatus(error.status));
+            if (!retryable || attempt + 1 >= PART_MAX_ATTEMPTS) {
+              throw error;
+            }
+            if (error.retryAfterSeconds !== void 0 && error.retryAfterSeconds > API_RETRY_WAIT_BUDGET_SECONDS) {
+              throw error;
+            }
+            await delay(
+              (error.retryAfterSeconds ?? 2 ** attempt / 4) * 1e3,
+              void 0,
+              { signal: requestSignal }
+            );
+          }
+        }
+        throw lastError;
+      };
+      const validatePart = (part, partNumber) => {
+        if (part.partNumber !== partNumber || part.contentLength !== partSize(partNumber)) {
+          throw new Error("Invalid server upload plan");
+        }
+        const target = new URL(part.url);
+        if (target.protocol !== "https:" || !target.hostname.endsWith(".r2.cloudflarestorage.com") || target.username || target.password) {
+          throw new Error("Invalid R2 upload target");
+        }
+        return target;
+      };
+      const uploadPart = async (initialPart, partSignal) => {
+        const partNumber = initialPart.partNumber;
+        let part = initialPart;
+        const bytes = Buffer.alloc(part.contentLength);
+        const { bytesRead } = await file.read(
+          bytes,
+          0,
+          bytes.length,
+          (partNumber - 1) * session.partSize
+        );
+        if (bytesRead !== bytes.length) {
+          throw new UploadError(
+            "The selected file changed during upload"
+          );
+        }
+        let lastError;
+        for (let attempt = 0; attempt < PART_MAX_ATTEMPTS; attempt++) {
+          partSignal.throwIfAborted();
+          const current = await file.stat();
+          if (current.size !== source.fileSize || Math.floor(current.mtimeMs) !== source.lastModifiedMs) {
+            throw new UploadError(
+              "The selected file changed during upload"
+            );
+          }
+          const target = validatePart(part, partNumber);
+          let response;
+          try {
+            response = await fetch(target, {
+              method: "PUT",
+              body: bytes,
+              headers: {
+                "Content-Length": String(bytes.length)
+              },
+              signal: AbortSignal.any([
+                partSignal,
+                AbortSignal.timeout(12e4)
+              ]),
+              redirect: "error"
+            });
+          } catch (error) {
+            lastError = error;
+            if (attempt + 1 >= PART_MAX_ATTEMPTS) {
+              throw error;
+            }
+            await delay(250 * 2 ** attempt, void 0, {
+              signal: partSignal
+            });
+            continue;
+          }
+          if (response.ok) {
+            await response.body?.cancel();
+            markConfirmed(partNumber);
+            return;
+          }
+          lastError = new Error("R2 rejected the upload part");
+          const needsFreshSignature = response.status === 401 || response.status === 403;
+          const retryable = needsFreshSignature || isTransientStatus(response.status);
+          const retryAfterSeconds = parseRetryAfterSeconds(
+            response.headers.get("retry-after")
+          );
+          await response.body?.cancel();
+          if (!retryable || attempt + 1 >= PART_MAX_ATTEMPTS) {
+            throw lastError;
+          }
+          if (retryAfterSeconds !== void 0 && retryAfterSeconds > R2_RETRY_WAIT_BUDGET_SECONDS) {
+            throw new IntegrationRequestError(
+              "Storage asked the upload to retry later",
+              {
+                kind: "http",
+                status: response.status,
+                code: "UPLOAD_RETRY_DEFERRED",
+                retryAfterSeconds
+              }
+            );
+          }
+          if (needsFreshSignature) {
+            const refreshed = await requestParts(
+              [partNumber],
+              partSignal
+            );
+            for (const completed of refreshed.completedPartNumbers) {
+              markConfirmed(completed);
+            }
+            if (confirmed.has(partNumber)) {
+              return;
+            }
+            const replacement = refreshed.signedParts.find(
+              (candidate) => candidate.partNumber === partNumber
+            );
+            if (!replacement) {
+              throw new Error("Invalid server upload plan");
+            }
+            part = replacement;
+          }
+          await delay(
+            retryAfterSeconds === void 0 ? 250 * 2 ** attempt : retryAfterSeconds * 1e3,
+            void 0,
+            { signal: partSignal }
+          );
+        }
+        throw lastError;
+      };
+      const missingPartNumbers = Array.from(
+        { length: session.partCount },
+        (_, index) => index + 1
+      ).filter((partNumber) => !confirmed.has(partNumber));
+      for (let offset = 0; offset < missingPartNumbers.length; offset += SIGNATURE_BATCH_SIZE) {
+        signal.throwIfAborted();
+        const requested = missingPartNumbers.slice(
+          offset,
+          offset + SIGNATURE_BATCH_SIZE
+        );
+        const response = await requestParts(requested);
+        for (const completed of response.completedPartNumbers) {
+          markConfirmed(completed);
+        }
+        const signedByNumber = new Map(
+          response.signedParts.map((part) => [part.partNumber, part])
+        );
+        const planned = requested.filter((partNumber) => !confirmed.has(partNumber)).map((partNumber) => {
+          const part = signedByNumber.get(partNumber);
+          if (!part) {
+            throw new Error("Invalid server upload plan");
+          }
+          validatePart(part, partNumber);
+          return part;
+        });
+        const batchController = new AbortController();
+        const batchSignal = AbortSignal.any([
+          signal,
+          batchController.signal
+        ]);
+        await runWithConcurrency(
+          planned,
+          PART_UPLOAD_CONCURRENCY,
+          (part) => uploadPart(part, batchSignal),
+          () => batchController.abort()
+        );
+      }
+      signal.throwIfAborted();
+      await this.request("POST", `/v1/uploads/${session.id}/complete`);
+      transfer.state = "uploaded";
+    } finally {
+      await source.file.close();
+    }
+  }
+};
+
+// src/index.ts
+var origin = apiOrigin(
+  process.env.CAPTIONBOLT_API_URL ?? "https://api.captionbolt.com"
+);
+var command = process.argv[2];
+if (command === "login") {
+  try {
+    await login(origin);
+  } catch (error) {
+    process.stderr.write(`${loginFailureMessage(error)}
+`);
+    process.exitCode = 1;
+  }
+} else if (command === "logout") {
+  await logout(origin);
+  process.stderr.write(
+    "Local CaptionBolt authorization removed. Revoke server access in account settings if needed.\n"
+  );
+} else {
+  if (command) {
+    throw new Error("Usage: captionbolt-mcp [login|logout]");
+  }
+  const provider = oauthProvider(
+    origin,
+    "http://127.0.0.1:1/callback",
+    () => {
+      throw new Error(
+        "Run captionbolt-mcp login to authorize this computer, then retry."
+      );
+    }
+  );
+  const request = createApiClient(origin.href, provider);
+  const uploads = new LocalUploads(request);
+  const handle = serveStdio(
+    () => {
+      const server = createIntegrationMcpServer(request, {
+        executeTool: async (name, input) => {
+          if (!await hasAuthorization(origin)) {
+            throw new IntegrationRequestError(
+              "Run captionbolt-mcp login to authorize this computer, then retry.",
+              {
+                kind: "http",
+                status: 401,
+                code: "AUTH_REQUIRED"
+              }
+            );
+          }
+          const { client, transport } = remoteClient(
+            origin,
+            provider
+          );
+          try {
+            await client.connect(transport);
+            const result = await client.callTool({
+              name,
+              arguments: input
+            });
+            return {
+              content: result.content.filter(
+                (item) => item.type === "text"
+              ),
+              structuredContent: result.structuredContent,
+              isError: result.isError
+            };
+          } catch (error) {
+            if (error instanceof UnauthorizedError3 || error instanceof Error && error.message.includes("captionbolt-mcp login")) {
+              await provider.invalidateCredentials?.("discovery");
+              throw new IntegrationRequestError(
+                "Run captionbolt-mcp login to authorize this computer, then retry.",
+                {
+                  kind: "http",
+                  status: 401,
+                  code: "AUTH_REQUIRED"
+                }
+              );
+            }
+            if (error instanceof InsufficientScopeError2) {
+              throw new IntegrationRequestError(
+                "CaptionBolt connection lacks permission for this action. Reconnect with the required scopes.",
+                {
+                  kind: "http",
+                  status: 403,
+                  code: "INSUFFICIENT_SCOPE"
+                }
+              );
+            }
+            throw error;
+          } finally {
+            await client.close();
+          }
+        }
+      });
+      function localTool(name, description, schema, readOnly, run) {
+        server.registerTool(
+          name,
+          {
+            description,
+            inputSchema: schema,
+            annotations: {
+              readOnlyHint: readOnly,
+              destructiveHint: name === "abort_upload",
+              openWorldHint: true
+            }
+          },
+          async (input) => {
+            try {
+              const result = await run(
+                input
+              );
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: JSON.stringify(result)
+                  }
+                ],
+                structuredContent: result
+              };
+            } catch (error) {
+              if (error instanceof IntegrationRequestError) {
+                return createIntegrationMcpErrorResult(error);
+              }
+              return createIntegrationMcpErrorResult(
+                new IntegrationRequestError(
+                  error instanceof UploadError ? error.message : "Upload action failed. Check the selected file and connection.",
+                  { kind: "invalid-response" }
+                )
+              );
+            }
+          }
+        );
+      }
+      localTool(
+        "upload_file",
+        "Upload one video explicitly selected by the user using its absolute local path. Returns transferId immediately; poll get_upload_progress until uploaded, then create_project with uploadId. Never scan directories or send video bytes to the model.",
+        z4.object({
+          path: z4.string().min(1),
+          idempotencyKey: z4.string().min(1).max(128)
+        }).strict(),
+        false,
+        async (input) => {
+          if (!await hasAuthorization(origin)) {
+            throw new IntegrationRequestError(
+              "Run captionbolt-mcp login to authorize this computer, then retry.",
+              {
+                kind: "http",
+                status: 401,
+                code: "AUTH_REQUIRED"
+              }
+            );
+          }
+          return uploads.start(
+            String(input.path),
+            String(input.idempotencyKey)
+          );
+        }
+      );
+      localTool(
+        "resume_upload",
+        "Resume an existing server upload after the user explicitly reselects the exact original file. Never read files automatically after restart.",
+        z4.object({
+          path: z4.string().min(1),
+          uploadId: z4.string().uuid()
+        }).strict(),
+        false,
+        async (input) => {
+          if (!await hasAuthorization(origin)) {
+            throw new IntegrationRequestError(
+              "Run captionbolt-mcp login to authorize this computer, then retry.",
+              {
+                kind: "http",
+                status: 401,
+                code: "AUTH_REQUIRED"
+              }
+            );
+          }
+          return uploads.start(
+            String(input.path),
+            `resume-${input.uploadId}`,
+            String(input.uploadId)
+          );
+        }
+      );
+      localTool(
+        "get_upload_progress",
+        "Read transfer state and uploadedBytes. Poll every few seconds while preparing/uploading; when uploaded, pass uploadId to create_project. The server uploadId survives this process.",
+        z4.object({ transferId: z4.string().uuid() }).strict(),
+        true,
+        (input) => uploads.status(String(input.transferId))
+      );
+      localTool(
+        "get_upload",
+        "Read a durable server upload without changing its state.",
+        z4.object({ uploadId: z4.string().uuid() }).strict(),
+        true,
+        (input) => request("GET", `/v1/uploads/${input.uploadId}`)
+      );
+      localTool(
+        "pause_upload",
+        "Stop local file transfer and keep its durable server session available for explicit resume.",
+        z4.object({ transferId: z4.string().uuid() }).strict(),
+        false,
+        (input) => uploads.pause(String(input.transferId))
+      );
+      localTool(
+        "abort_upload",
+        "Pause any matching local transfer, cancel the server upload and release its reservation.",
+        z4.object({ uploadId: z4.string().uuid() }).strict(),
+        false,
+        (input) => uploads.abort(String(input.uploadId))
+      );
+      return server;
+    },
+    {
+      legacy: "serve",
+      onerror: () => process.stderr.write("CaptionBolt MCP protocol error.\n")
+    }
+  );
+  let stopping = false;
+  async function shutdown() {
+    if (stopping) {
+      return;
+    }
+    stopping = true;
+    await uploads.close();
+    await handle.close();
+  }
+  process.once("SIGTERM", () => void shutdown());
+  process.once("SIGINT", () => void shutdown());
+  process.stdin.once("end", () => void shutdown());
+}