@cursor/bdk 0.2.2 → 0.2.4

package/src/internal/local-ingress.ts

@@ -1,90 +0,0 @@
-/**
- * Local control-plane ingest for v2 continuation.
- *
- * Twin of backend `routeVerifiedIngressContinuation`. Hosted Cursor runs
- * that copy after the webhook is verified. Self-hosted / `july serve`
- * runs this copy on the in-process local CP before the channel adapter
- * `send()`s. Channel adapters do not extract.
- */
-
-import type { ChannelHandlerArgs } from "../types.js";
-import {
-  bindMailboxContinuationSend,
-  type ContinuationIdentity,
-  continuationSource,
-  type MailboxContinuation,
-  normalizeIdentity,
-  stampMailboxContinuation,
-} from "./continuation-identity.js";
-
-export type LocalIngressContinuation = {
-  explicitContinuationKey?: string;
-  mailboxContinuation?: MailboxContinuation;
-};
-
-export type RouteLocalIngressContinuation = (
-  input: RouteLocalIngressContinuationInput,
-) => LocalIngressContinuation;
-
-export type RouteLocalIngressContinuationInput = {
-  identity?: ContinuationIdentity;
-  kind?: string;
-  eventType: string;
-  payload: unknown;
-  deterministicContinuationKey?: string;
-};
-
-/**
- * Selector + live payload → mailbox stamp. `/v1` and omitted identity
- * keep the caller-supplied deterministic key and do not stamp a mailbox.
- */
-export function routeLocalIngressContinuation(
-  input: RouteLocalIngressContinuationInput,
-): LocalIngressContinuation {
-  if (input.identity === undefined) {
-    return {
-      ...(input.deterministicContinuationKey === undefined
-        ? {}
-        : { explicitContinuationKey: input.deterministicContinuationKey }),
-    };
-  }
-  const identity = normalizeIdentity(input.identity, input.kind);
-  if (continuationSource(identity, input.kind) !== "control-plane") {
-    return {
-      ...(input.deterministicContinuationKey === undefined
-        ? {}
-        : { explicitContinuationKey: input.deterministicContinuationKey }),
-    };
-  }
-  const mailboxContinuation = stampMailboxContinuation(
-    identity,
-    input.eventType,
-    input.payload,
-    input.kind,
-  );
-  if (mailboxContinuation.key.startsWith("cont:")) {
-    return {
-      explicitContinuationKey: mailboxContinuation.key,
-      mailboxContinuation,
-    };
-  }
-  return { mailboxContinuation };
-}
-
-/**
- * Bind a CP mailbox stamp onto `args.send` so the channel adapter only
- * calls `send()` — it does not extract. No-op for `/v1`.
- */
-export function bindLocalIngressSend(
-  args: ChannelHandlerArgs,
-  input: RouteLocalIngressContinuationInput & {
-    routeContinuation?: RouteLocalIngressContinuation;
-  },
-): ChannelHandlerArgs {
-  const route = input.routeContinuation ?? routeLocalIngressContinuation;
-  const routed = route(input);
-  return {
-    ...args,
-    send: bindMailboxContinuationSend(args.send, routed.mailboxContinuation),
-  };
-}

package/src/internal/log-ring.ts

@@ -1,59 +0,0 @@
-/**
- * Bounded in-memory log buffer for the playground Logs tab.
- *
- * Wraps {@link ServeOptions.logger} so every channel/session line that hits
- * the console is also retained for `GET /v1/logs`.
- */
-
-export interface LogRingEntry {
-  index: number;
-  at: string;
-  line: string;
-}
-
-export interface LogRing {
-  /** Append a line (also called by {@link wrap}). */
-  push(line: string): void;
-  /** Snapshot entries with `index > after` (exclusive), oldest first. */
-  since(after?: number): LogRingEntry[];
-  /** Wrap a logger so each write is recorded then forwarded. */
-  wrap(inner: (line: string) => void): (line: string) => void;
-}
-
-export function createLogRing(options: { capacity?: number } = {}): LogRing {
-  const capacity = Math.max(1, options.capacity ?? 1000);
-  const entries: LogRingEntry[] = [];
-  let nextIndex = 0;
-
-  function push(line: string): void {
-    entries.push({
-      index: nextIndex,
-      at: new Date().toISOString(),
-      line,
-    });
-    nextIndex += 1;
-    while (entries.length > capacity) {
-      entries.shift();
-    }
-  }
-
-  return {
-    push,
-    since(after = -1): LogRingEntry[] {
-      if (entries.length === 0) {
-        return [];
-      }
-      const start = entries.findIndex(e => e.index > after);
-      if (start < 0) {
-        return [];
-      }
-      return entries.slice(start);
-    },
-    wrap(inner) {
-      return (line: string) => {
-        push(line);
-        inner(line);
-      };
-    },
-  };
-}

package/src/internal/logs-client.ts

@@ -1,477 +0,0 @@
-/**
- * `agent-sdk logs` — follow deploy progress (hosted) then runtime `/v1/logs`.
- *
- * Customer-facing output never includes hosting URLs, tokens, or infra jargon.
- */
-
-import { DeployApiError, type DeploymentDetail, type DeploymentProgress } from "./deploy-client.js";
-import { mergeRequestHeaders, type RequestAuth } from "./request-headers.js";
-import { resolveProdTarget } from "./resolve-prod-target.js";
-import { stderrPalette } from "./terminal-style.js";
-
-const DEFAULT_POLL_INTERVAL_MS = 1_000;
-
-/** Re-read abort state after await (loop narrowing would hide async abort). */
-function isAborted(signal: AbortSignal | undefined): boolean {
-  return signal?.aborted === true;
-}
-
-export interface LogRingEntry {
-  index: number;
-  at: string;
-  line: string;
-}
-
-export interface LogsResponse {
-  entries: LogRingEntry[];
-  nextAfter: number;
-}
-
-export type LogsProgress =
-  | DeploymentProgress
-  | "queued"
-  | "preparing"
-  | "creating"
-  | "building"
-  | "starting"
-  | "finalizing"
-  | "running"
-  | "failed"
-  | "stopping"
-  | "stopped"
-  | "deleting"
-  | "degraded";
-
-const PROGRESS_MESSAGES: Readonly<Record<LogsProgress, string>> = {
-  queued: "Waiting to start…",
-  preparing: "Preparing runtime…",
-  creating: "Creating runtime…",
-  building: "Checking out source…",
-  starting: "Starting agent and waiting for health…",
-  finalizing: "Finishing deployment…",
-  running: "Deployment running",
-  failed: "Deploy failed",
-  stopping: "Stopping deployment…",
-  stopped: "Deployment stopped",
-  deleting: "Deleting deployment…",
-  degraded: "Deployment degraded",
-};
-
-/**
- * Customer-facing line for the current deploy step. Prefer the live
- * `statusMessage` from the API when present; otherwise the progress
- * vocabulary. Failed/degraded always append sanitized `lastError`.
- */
-export function progressMessage(
-  progress: LogsProgress,
-  lastError?: string | null,
-  statusMessage?: string | null,
-): string {
-  if (progress === "failed") {
-    const detail =
-      lastError === null || lastError === undefined || lastError.trim() === ""
-        ? ""
-        : `: ${sanitizeCustomerError(lastError)}`;
-    return `Deploy failed${detail}`;
-  }
-  if (progress === "degraded") {
-    const detail =
-      lastError === null || lastError === undefined || lastError.trim() === ""
-        ? ""
-        : `: ${sanitizeCustomerError(lastError)}`;
-    return `Deployment degraded${detail}`;
-  }
-  if (statusMessage !== null && statusMessage !== undefined && statusMessage.trim() !== "") {
-    return statusMessage.trim();
-  }
-  return PROGRESS_MESSAGES[progress];
-}
-
-/** Strip obvious hosting internals from error text shown to customers. */
-export function sanitizeCustomerError(message: string): string {
-  return message
-    .replace(/https?:\/\/\S+/gi, "[url]")
-    .replace(/\bpod-[a-z0-9]+\b/gi, "[runtime]")
-    .replace(/\banyrun\b/gi, "runtime")
-    .replace(/\bcursorvm\.com\b/gi, "host")
-    .replace(/\bx-anyrun-[a-z0-9-]+\b/gi, "header")
-    .replace(/\bPROVISIONING\b/g, "building")
-    .replace(/\bPLANNED\b/g, "preparing")
-    .replace(/\bgitCloneCheckout\b/gi, "git clone")
-    .replace(/\bgitFetchCheckout\b/gi, "git fetch")
-    .replace(/\bgitCheckout:clone\b/gi, "checkout")
-    .replace(/\bgitCheckout:fetch\b/gi, "checkout");
-}
-
-/**
- * One-line label for `agent-sdk deploy` polling (TTY spinner / non-TTY
- * transitions). Uses statusMessage → progress → raw status.
- *
- * Deliberately does NOT include `lastError`. The spinner redraws with
- * `\r\x1b[2K`, which clears one physical row, so a reason long enough to
- * soft-wrap would leave the earlier rows on screen. Callers print the
- * reason once on the final line instead.
- */
-export function deployProgressLabel(detail: {
-  status: string;
-  progress?: DeploymentProgress;
-  statusMessage?: string | null;
-}): string {
-  if (
-    detail.statusMessage !== null &&
-    detail.statusMessage !== undefined &&
-    detail.statusMessage.trim() !== ""
-  ) {
-    return detail.statusMessage
-      .trim()
-      .replace(/…$/, "")
-      .replace(/\.\.\.$/, "");
-  }
-  if (detail.progress !== undefined) {
-    return PROGRESS_MESSAGES[detail.progress].replace(/…$/, "").replace(/\.\.\.$/, "");
-  }
-  return detail.status;
-}
-
-export async function fetchLogs(args: {
-  baseUrl: string;
-  after?: number;
-  auth?: RequestAuth;
-  fetchImpl?: typeof fetch;
-  signal?: AbortSignal;
-}): Promise<LogsResponse> {
-  const fetchImpl = args.fetchImpl ?? fetch;
-  const after = args.after ?? -1;
-  const url = new URL(`${args.baseUrl.replace(/\/$/, "")}/v1/logs`);
-  if (after >= 0) {
-    url.searchParams.set("after", String(after));
-  }
-  const resp = await fetchImpl(url, {
-    headers: mergeRequestHeaders(args.auth),
-    signal: args.signal,
-  });
-  if (!resp.ok) {
-    throw new Error(`Could not fetch logs (HTTP ${resp.status}).`);
-  }
-  const body = (await resp.json()) as {
-    entries?: LogRingEntry[];
-    nextAfter?: number;
-  };
-  const entries = Array.isArray(body.entries) ? body.entries : [];
-  const nextAfter =
-    typeof body.nextAfter === "number"
-      ? body.nextAfter
-      : entries.length === 0
-        ? after
-        : (entries[entries.length - 1]?.index ?? after);
-  return { entries, nextAfter };
-}
-
-export interface RunLogsTailOptions {
-  /** When true, use hosted deploy progress then runtime logs. */
-  prod?: boolean;
-  dir: string;
-  cwd?: string;
-  slug?: string;
-  team?: string;
-  apiKey?: string;
-  url?: string;
-  bearerToken?: string;
-  once?: boolean;
-  json?: boolean;
-  fetchImpl?: typeof fetch;
-  signal?: AbortSignal;
-  intervalMs?: number;
-  /** stdout writer (test seam). */
-  write?: (text: string) => void;
-  /** stderr writer (test seam). */
-  err?: (text: string) => void;
-  /**
-   * Deploy detail fetcher for `--prod` progress (test seam). Defaults to
-   * management API via resolveProdTarget's auth path.
-   */
-  getDeployment?: () => Promise<DeploymentDetail>;
-  /** After deploy is running, resolve runtime base URL + headers. */
-  resolveRuntime?: () => Promise<{
-    agentUrl: string;
-    headers?: Record<string, string>;
-  }>;
-  sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
-}
-
-export async function runLogsTail(options: RunLogsTailOptions): Promise<void> {
-  const write = options.write ?? ((text: string) => void process.stdout.write(text));
-  const err = options.err ?? ((text: string) => void process.stderr.write(text));
-  const sleep = options.sleep ?? sleepMs;
-  const intervalMs = options.intervalMs ?? DEFAULT_POLL_INTERVAL_MS;
-  const c = stderrPalette();
-
-  if (options.prod === true) {
-    await followProdLogs({
-      ...options,
-      write,
-      err,
-      sleep,
-      intervalMs,
-      palette: c,
-    });
-    return;
-  }
-
-  const baseUrl = (options.url ?? "http://127.0.0.1:3000").replace(/\/$/, "");
-  if (options.once !== true) {
-    err(c.dim("Tailing logs… (Ctrl-C to stop)\n"));
-  }
-  await followRuntimeLogs({
-    baseUrl,
-    auth: { bearerToken: options.bearerToken },
-    once: options.once === true,
-    json: options.json === true,
-    fetchImpl: options.fetchImpl,
-    signal: options.signal,
-    intervalMs,
-    write,
-    sleep,
-  });
-}
-
-async function followProdLogs(args: {
-  dir: string;
-  cwd?: string;
-  slug?: string;
-  team?: string;
-  apiKey?: string;
-  bearerToken?: string;
-  once?: boolean;
-  json?: boolean;
-  fetchImpl?: typeof fetch;
-  signal?: AbortSignal;
-  intervalMs: number;
-  write: (text: string) => void;
-  err: (text: string) => void;
-  getDeployment?: () => Promise<DeploymentDetail>;
-  resolveRuntime?: () => Promise<{
-    agentUrl: string;
-    headers?: Record<string, string>;
-  }>;
-  sleep: (ms: number, signal?: AbortSignal) => Promise<void>;
-  palette: ReturnType<typeof stderrPalette>;
-}): Promise<void> {
-  const resolveRuntime =
-    args.resolveRuntime ??
-    (async () => {
-      const target = await resolveProdTarget({
-        dir: args.dir,
-        cwd: args.cwd,
-        slug: args.slug,
-        team: args.team,
-        apiKey: args.apiKey,
-        fetchImpl: args.fetchImpl,
-        err: () => {},
-      });
-      return { agentUrl: target.agentUrl, headers: target.headers };
-    });
-
-  const getDeployment =
-    args.getDeployment ??
-    (async () => {
-      // Lazy import path via resolveProdTarget side: re-fetch through a
-      // one-shot resolve that throws if not running is wrong for progress.
-      // Callers that omit getDeployment must provide it in production via
-      // cmdLogs (which wires deploy auth).
-      throw new Error("Internal error: deploy progress requires a deployment lookup.");
-    });
-
-  let lastEmittedKey: string | undefined;
-  const slugHint = args.slug !== undefined && args.slug !== "" ? args.slug : "";
-  if (args.once !== true) {
-    const label = slugHint !== "" ? slugHint : "deployment";
-    args.err(args.palette.dim(`Tailing logs for ${label}… (Ctrl-C to stop)\n`));
-  }
-
-  while (!isAborted(args.signal)) {
-    let detail: DeploymentDetail;
-    try {
-      detail = await getDeployment();
-    } catch (error) {
-      if (isAborted(args.signal)) {
-        return;
-      }
-      throw customerDeployLookupError(error);
-    }
-
-    const progress = resolveProgress(detail);
-    const message = progressMessage(progress, detail.lastError, detail.statusMessage);
-    const emitKey = `${progress}\0${message}`;
-
-    if (progress === "failed") {
-      if (emitKey !== lastEmittedKey) {
-        lastEmittedKey = emitKey;
-        emitProgress(args.write, args.json === true, progress, message);
-      }
-      throw new Error(`Deployment "${detail.slug}" failed.`);
-    }
-    if (progress === "stopped") {
-      if (emitKey !== lastEmittedKey) {
-        lastEmittedKey = emitKey;
-        emitProgress(args.write, args.json === true, progress, message);
-      }
-      throw new Error(`Deployment "${detail.slug}" is stopped.`);
-    }
-    if (progress === "running" || progress === "degraded") {
-      // Hand off to runtime logs. Print degraded once; skip a "running" line.
-      if (progress === "degraded" && emitKey !== lastEmittedKey) {
-        lastEmittedKey = emitKey;
-        emitProgress(args.write, args.json === true, progress, message);
-      }
-      const runtime = await resolveRuntime();
-      await followRuntimeLogs({
-        baseUrl: runtime.agentUrl,
-        auth: {
-          bearerToken: args.bearerToken,
-          headers: runtime.headers,
-        },
-        once: args.once === true,
-        json: args.json === true,
-        fetchImpl: args.fetchImpl,
-        signal: args.signal,
-        intervalMs: args.intervalMs,
-        write: args.write,
-        sleep: args.sleep,
-      });
-      return;
-    }
-
-    if (emitKey !== lastEmittedKey) {
-      lastEmittedKey = emitKey;
-      emitProgress(args.write, args.json === true, progress, message);
-    }
-
-    if (args.once === true) {
-      return;
-    }
-
-    await args.sleep(args.intervalMs, args.signal);
-  }
-}
-
-function resolveProgress(detail: DeploymentDetail): LogsProgress {
-  if (detail.progress !== undefined) {
-    return detail.progress;
-  }
-  switch (detail.status) {
-    case "pending":
-      return "queued";
-    case "deploying":
-      return "building";
-    case "running":
-      return "running";
-    case "failed":
-      return "failed";
-    case "degraded":
-      return "degraded";
-    case "stopping":
-      return "stopping";
-    case "stopped":
-      return "stopped";
-    case "deleting":
-      return "deleting";
-    default:
-      return "queued";
-  }
-}
-
-function emitProgress(
-  write: (text: string) => void,
-  json: boolean,
-  progress: LogsProgress,
-  message: string,
-): void {
-  if (json) {
-    write(`${JSON.stringify({ type: "progress", progress, message })}\n`);
-    return;
-  }
-  write(`${message}\n`);
-}
-
-async function followRuntimeLogs(args: {
-  baseUrl: string;
-  auth?: RequestAuth;
-  once: boolean;
-  json: boolean;
-  fetchImpl?: typeof fetch;
-  signal?: AbortSignal;
-  intervalMs: number;
-  write: (text: string) => void;
-  sleep: (ms: number, signal?: AbortSignal) => Promise<void>;
-}): Promise<void> {
-  let after = -1;
-  for (;;) {
-    if (isAborted(args.signal)) {
-      return;
-    }
-    let batch: LogsResponse;
-    try {
-      batch = await fetchLogs({
-        baseUrl: args.baseUrl,
-        after,
-        auth: args.auth,
-        fetchImpl: args.fetchImpl,
-        signal: args.signal,
-      });
-    } catch (error) {
-      if (isAborted(args.signal)) {
-        return;
-      }
-      throw error instanceof Error ? error : new Error("Could not fetch logs.");
-    }
-
-    for (const entry of batch.entries) {
-      if (args.json) {
-        args.write(
-          `${JSON.stringify({
-            type: "log",
-            index: entry.index,
-            at: entry.at,
-            line: entry.line,
-          })}\n`,
-        );
-      } else {
-        args.write(`${entry.line}\n`);
-      }
-    }
-    after = batch.nextAfter;
-
-    if (args.once) {
-      return;
-    }
-    await args.sleep(args.intervalMs, args.signal);
-  }
-}
-
-function customerDeployLookupError(error: unknown): Error {
-  if (error instanceof DeployApiError) {
-    return new Error(`Could not look up deployment: ${sanitizeCustomerError(error.message)}`);
-  }
-  if (error instanceof Error) {
-    return new Error(sanitizeCustomerError(error.message));
-  }
-  return new Error("Could not look up deployment.");
-}
-
-async function sleepMs(ms: number, signal?: AbortSignal): Promise<void> {
-  if (isAborted(signal)) {
-    return;
-  }
-  await new Promise<void>(resolve => {
-    const timer = setTimeout(() => {
-      signal?.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-    const onAbort = (): void => {
-      clearTimeout(timer);
-      resolve();
-    };
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
-}

package/src/internal/map-pool.ts

@@ -1,39 +0,0 @@
-/**
- * Run `fn` over `items` with at most `concurrency` in flight; preserve order
- * of results (and of side-effect completion relative to index assignment).
- *
- * When `signal` aborts, workers stop claiming new items; in-flight `fn` calls
- * are responsible for honoring the same signal.
- */
-export async function mapPool<T, R>(
-  items: readonly T[],
-  concurrency: number,
-  fn: (item: T, index: number) => Promise<R>,
-  options?: { signal?: AbortSignal },
-): Promise<R[]> {
-  const results = new Array<R>(items.length);
-  let next = 0;
-  async function worker(): Promise<void> {
-    for (;;) {
-      if (options?.signal?.aborted) {
-        return;
-      }
-      const index = next;
-      next += 1;
-      if (index >= items.length) {
-        return;
-      }
-      const item = items[index];
-      if (item === undefined) {
-        return;
-      }
-      results[index] = await fn(item, index);
-    }
-  }
-  const workerCount = Math.min(Math.max(1, concurrency), items.length);
-  if (workerCount === 0) {
-    return results;
-  }
-  await Promise.all(Array.from({ length: workerCount }, () => worker()));
-  return results;
-}