@cursor/bdk 0.2.3 → 0.2.4

package/src/internal/reminder-schedule.ts

@@ -1,104 +0,0 @@
-/**
- * Schedule resolution for reminders (`every` / `cron` / `delay` / `at`).
- */
-
-import type { ReminderCreateInput, ReminderScheduleKind } from "../types.js";
-import { parseCron } from "./cron.js";
-import { parseDuration } from "./duration.js";
-
-export class ReminderValidationError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "ReminderValidationError";
-  }
-}
-
-/** Node setTimeout overflows past ~2^31-1 ms (~24.8d); chunk long waits. */
-export const MAX_TIMER_MS = 2_147_483_647;
-
-export interface ResolvedSchedule {
-  kind: ReminderScheduleKind;
-  value: string;
-  intervalMs?: number;
-  nextFireAtMs: number;
-}
-
-/**
- * Resolve create-input schedule fields into a concrete next-fire plan.
- * Pass `nowMs` for deterministic CP / test resolution; CP owns this call.
- */
-export function resolveSchedule(
-  input: Pick<ReminderCreateInput, "every" | "cron" | "delay" | "at">,
-  nowMs: number = Date.now(),
-): ResolvedSchedule {
-  const shapes = [
-    input.every !== undefined,
-    input.cron !== undefined,
-    input.delay !== undefined,
-    input.at !== undefined,
-  ].filter(Boolean);
-  if (shapes.length !== 1) {
-    throw new ReminderValidationError(
-      "reminders.create requires exactly one of every, cron, delay, or at",
-    );
-  }
-
-  if (input.every !== undefined) {
-    const intervalMs = parseDuration(input.every);
-    if (intervalMs <= 0) {
-      throw new ReminderValidationError(`every must be > 0 (got ${input.every})`);
-    }
-    return {
-      kind: "every",
-      value: String(input.every),
-      intervalMs,
-      nextFireAtMs: nowMs + intervalMs,
-    };
-  }
-  if (input.cron !== undefined) {
-    parseCron(input.cron); // validate
-    return {
-      kind: "cron",
-      value: input.cron,
-      nextFireAtMs: nextCronFireMs(input.cron, nowMs),
-    };
-  }
-  if (input.delay !== undefined) {
-    const delayMs = parseDuration(input.delay);
-    return {
-      kind: "delay",
-      value: String(input.delay),
-      nextFireAtMs: nowMs + delayMs,
-    };
-  }
-  const atMs =
-    typeof input.at === "number"
-      ? input.at
-      : input.at instanceof Date
-        ? input.at.getTime()
-        : Date.parse(String(input.at));
-  if (!Number.isFinite(atMs)) {
-    throw new ReminderValidationError(`Invalid at time: ${String(input.at)}`);
-  }
-  return {
-    kind: "at",
-    value: typeof input.at === "string" ? input.at : new Date(atMs).toISOString(),
-    nextFireAtMs: atMs,
-  };
-}
-
-/** Next UTC fire strictly after `afterMs` for a 5-field cron. */
-export function nextCronFireMs(cronSource: string, afterMs: number): number {
-  try {
-    return parseCron(cronSource).nextFire(new Date(afterMs)).getTime();
-  } catch (error) {
-    throw new ReminderValidationError(
-      error instanceof Error ? error.message : `Could not find next fire for cron "${cronSource}"`,
-    );
-  }
-}
-
-/** Default busy policy: recurring may skip; one-shots queue behind the turn. */
-export function defaultBusyPolicy(kind: ReminderScheduleKind): "skipIfBusy" | "queueBehindTurn" {
-  return kind === "every" || kind === "cron" ? "skipIfBusy" : "queueBehindTurn";
-}

package/src/internal/reminder-store.ts

@@ -1,176 +0,0 @@
-/**
- * Reminder document store used by the local control plane
- * (`<stateRoot>/control-plane/reminders/`).
- *
- * Anonymous `run` / function `until` handlers are not serializable — they live
- * only in the in-memory {@link ReminderRunner} registry. Named `handler` +
- * `args` and prompt-form reminders survive restart (handlers resolve from
- * `agent/reminders/` on every fire).
- */
-
-import { mkdir, readdir, readFile, rename, rm, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import type {
-  JsonObject,
-  ReminderBusyPolicy,
-  ReminderScheduleKind,
-  ReminderStatus,
-} from "../types.js";
-
-export const REMINDER_SNAPSHOT_VERSION = 1 as const;
-
-export type { ReminderBusyPolicy, ReminderScheduleKind, ReminderStatus } from "../types.js";
-
-/**
- * Internal record status. `firing` is CP claim state and must not appear on
- * public {@link ReminderStatus} / {@link ReminderInfo}.
- */
-export type ReminderRecordStatus = ReminderStatus | "firing";
-
-/** Serializable reminder record (no function bodies). */
-export interface ReminderRecord {
-  version: typeof REMINDER_SNAPSHOT_VERSION;
-  id: string;
-  purpose: string;
-  /** Channel that owns the target session (e.g. `drive`, `http`). */
-  channelId: string;
-  /** Channel-local continuation key (not the wire `channel:key` token). */
-  continuationToken: string;
-  /** Optional opaque target metadata (e.g. `{ prUrl }`). */
-  target?: Record<string, unknown>;
-  scheduleKind: ReminderScheduleKind;
-  /** Raw schedule value: every/delay string, cron expression, or ISO `at`. */
-  scheduleValue: string;
-  intervalMs?: number;
-  /** Prompt form — mutually exclusive with `handler` and in-memory `run`. */
-  prompt?: string;
-  /**
-   * Named handler stem (`agent/reminders/<name>.ts`). Mutually exclusive with
-   * `prompt` and in-memory `run`.
-   */
-  handler?: string;
-  /** Serializable args for {@link handler}. */
-  args?: JsonObject;
-  /**
-   * True when create() registered a `run` handler. Handlers are not
-   * serializable; after restart, armed records with this flag and no live
-   * handler are disarmed instead of falling back to a generic prompt.
-   */
-  hasRunHandler: boolean;
-  /** True when create() registered a function `until` (in-memory only). */
-  hasUntilFn: boolean;
-  /** Natural-language until (agent-facing); function until is in-memory only. */
-  untilPrompt?: string;
-  busyPolicy: ReminderBusyPolicy;
-  status: ReminderRecordStatus;
-  disarmReason?: string;
-  fireCount: number;
-  /**
-   * CAS generation. Cancel/rekey and successful outcome apply bump this so
-   * in-flight outcomes cannot resurrect a superseded reminder.
-   */
-  generation?: number;
-  nextFireAtMs: number;
-  createdAt: string;
-  updatedAt: string;
-}
-
-/** Narrow a sink value to a {@link ReminderRecord} (startup hydrate). */
-export function isReminderRecord(value: unknown): value is ReminderRecord {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) {
-    return false;
-  }
-  const record = value as Partial<ReminderRecord>;
-  return (
-    record.version === REMINDER_SNAPSHOT_VERSION &&
-    typeof record.id === "string" &&
-    record.id !== "" &&
-    typeof record.purpose === "string" &&
-    typeof record.channelId === "string" &&
-    typeof record.continuationToken === "string" &&
-    typeof record.scheduleKind === "string" &&
-    typeof record.scheduleValue === "string" &&
-    typeof record.status === "string" &&
-    typeof record.nextFireAtMs === "number" &&
-    Number.isFinite(record.nextFireAtMs)
-  );
-}
-
-export class ReminderStore {
-  constructor(private readonly rootDir: string) {}
-
-  private filePath(id: string): string {
-    return join(this.rootDir, `${id}.json`);
-  }
-
-  async ensureRoot(): Promise<void> {
-    await mkdir(this.rootDir, { recursive: true });
-  }
-
-  async list(): Promise<ReminderRecord[]> {
-    await this.ensureRoot();
-    let names: string[];
-    try {
-      names = await readdir(this.rootDir);
-    } catch {
-      return [];
-    }
-    const records: ReminderRecord[] = [];
-    for (const name of names) {
-      if (!name.endsWith(".json")) continue;
-      const record = await this.get(name.slice(0, -".json".length));
-      if (record !== undefined) {
-        records.push(record);
-      }
-    }
-    return records;
-  }
-
-  async listArmed(): Promise<ReminderRecord[]> {
-    const all = await this.list();
-    // Treat in-flight claims as still armed for restart / listing purposes.
-    return all.filter(r => r.status === "armed" || r.status === "firing");
-  }
-
-  async get(id: string): Promise<ReminderRecord | undefined> {
-    try {
-      const raw = await readFile(this.filePath(id), "utf8");
-      const parsed = JSON.parse(raw) as ReminderRecord;
-      if (parsed.version !== REMINDER_SNAPSHOT_VERSION) {
-        return undefined;
-      }
-      if (typeof parsed.id !== "string" || parsed.id !== id) {
-        return undefined;
-      }
-      return parsed;
-    } catch (error) {
-      if (
-        error !== null &&
-        typeof error === "object" &&
-        "code" in error &&
-        (error as { code?: string }).code === "ENOENT"
-      ) {
-        return undefined;
-      }
-      return undefined;
-    }
-  }
-
-  async save(record: ReminderRecord): Promise<void> {
-    await this.ensureRoot();
-    const path = this.filePath(record.id);
-    const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
-    const body = `${JSON.stringify(record, null, 2)}\n`;
-    try {
-      await writeFile(tmp, body, "utf8");
-      await rename(tmp, path);
-    } catch (error) {
-      await rm(tmp, { force: true }).catch(() => {});
-      throw error;
-    }
-  }
-
-  async delete(id: string): Promise<void> {
-    await rm(this.filePath(id), { force: true });
-  }
-}

package/src/internal/request-error-status.ts

@@ -1,95 +0,0 @@
-import { HttpSessionAdmitError } from "../types.js";
-import { InvalidAsOfError, VacuousTimeArgsError } from "./as-of.js";
-import { V2EngineError } from "./continuation-identity.js";
-import {
-  GUEST_CONNECT_STALLED,
-  GUEST_NETWORK_UNAVAILABLE,
-  GuestNetworkUnavailableError,
-  hasGuestNetworkErrno,
-  isQuietGuestConnectStall,
-} from "./guest-network.js";
-import {
-  HOSTED_GUEST_RETRY_TERMINAL,
-  HOSTED_GUEST_RETRY_TRANSIENT,
-  type HostedGuestRetryDisposition,
-} from "./hosted-delivery-protocol.js";
-import { SessionAuthError, SessionBusyError } from "./session-engine.js";
-
-export interface MappedRequestError {
-  status: 400 | 403 | 409 | 503;
-  code: string;
-  message: string;
-  retry: HostedGuestRetryDisposition;
-}
-
-/**
- * Expected throw → HTTP mapping used by `handleRequest` and hosted flush.
- * Undefined means a real 500 (caller logs and redacts).
- */
-export function mapThrownRequestError(error: unknown): MappedRequestError | undefined {
-  if (error instanceof SessionBusyError) {
-    return {
-      status: 409,
-      code: "session_busy",
-      message: error.message,
-      retry: HOSTED_GUEST_RETRY_TRANSIENT,
-    };
-  }
-  if (error instanceof V2EngineError) {
-    return {
-      status: 409,
-      code: "v2_identity_conflict",
-      message: "Control-plane session identity conflicts with existing state.",
-      retry: HOSTED_GUEST_RETRY_TERMINAL,
-    };
-  }
-  if (error instanceof SessionAuthError) {
-    return {
-      status: 403,
-      code: "forbidden",
-      message: error.message,
-      retry: HOSTED_GUEST_RETRY_TERMINAL,
-    };
-  }
-  if (error instanceof HttpSessionAdmitError) {
-    return {
-      status: 400,
-      code: "invalid_request",
-      message: error.message,
-      retry: HOSTED_GUEST_RETRY_TERMINAL,
-    };
-  }
-  if (error instanceof InvalidAsOfError || error instanceof VacuousTimeArgsError) {
-    return {
-      status: 400,
-      code: "invalid_request",
-      message: error.message,
-      retry: HOSTED_GUEST_RETRY_TERMINAL,
-    };
-  }
-  if (error instanceof GuestNetworkUnavailableError || hasGuestNetworkErrno(error)) {
-    return {
-      status: 503,
-      code: GUEST_NETWORK_UNAVAILABLE,
-      message:
-        error instanceof Error
-          ? error.message
-          : "Guest network is not ready for outbound requests.",
-      retry: HOSTED_GUEST_RETRY_TRANSIENT,
-    };
-  }
-  if (isQuietGuestConnectStall(error)) {
-    return {
-      status: 503,
-      code: GUEST_CONNECT_STALLED,
-      message:
-        error instanceof Error ? error.message : "Guest Connect stalled without a network errno.",
-      retry: HOSTED_GUEST_RETRY_TRANSIENT,
-    };
-  }
-  return undefined;
-}
-
-export function statusForThrownRequestError(error: unknown): number {
-  return mapThrownRequestError(error)?.status ?? 500;
-}

package/src/internal/request-headers.ts

@@ -1,21 +0,0 @@
-/**
- * Merge Authorization bearer + arbitrary request headers for agent HTTP
- * clients (local `--bearer-token`, hosted `engineAccess.headers`, etc.).
- */
-
-export interface RequestAuth {
-  bearerToken?: string;
-  /** Extra headers (e.g. X-Anyrun-Port-Token from engineAccess). */
-  headers?: Record<string, string>;
-}
-
-export function mergeRequestHeaders(auth: RequestAuth | undefined): Record<string, string> {
-  const out: Record<string, string> = {};
-  if (auth?.headers !== undefined) {
-    Object.assign(out, auth.headers);
-  }
-  if (auth?.bearerToken !== undefined) {
-    out.authorization = `Bearer ${auth.bearerToken}`;
-  }
-  return out;
-}