@cursor/july 0.1.1 → 0.1.3

package/src/internal/reminder-runner.ts

@@ -121,6 +121,9 @@ export class ReminderRunner {
   async start(): Promise<void> {
     if (this.started) return;
     this.started = true;
+    // Materialize sink-backed reminders onto local disk before arming
+    // (local wins when both sides have the same id).
+    await this.hydrateFromStorage();
     const armed = await this.store.listArmed();
     let restored = 0;
     let disarmedOrphan = 0;
@@ -148,6 +151,47 @@ export class ReminderRunner {
     }
   }
 
+  /**
+   * Pull reminder records from `defineStorage` into `<stateRoot>/reminders`
+   * when local disk is empty for that id. Failures are logged and skipped.
+   */
+  private async hydrateFromStorage(): Promise<void> {
+    const storage = this.engine.storage;
+    if (storage === undefined || !storage.canBulkRestore) {
+      return;
+    }
+    let hydrated = 0;
+    try {
+      const remote = await storage.listReminders();
+      for (const record of remote) {
+        const local = await this.store.get(record.id);
+        if (local !== undefined) {
+          continue;
+        }
+        // Local write only — re-mirroring would just echo the sink.
+        await this.store.save(record);
+        hydrated += 1;
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger(
+        `[agent-serve] reminders: storage hydrate failed: ${message}`
+      );
+      return;
+    }
+    if (hydrated > 0) {
+      this.logger(
+        `[agent-serve] reminders: hydrated ${hydrated} reminder(s) from storage`
+      );
+    }
+  }
+
+  /** Persist locally and mirror into the authored storage sink when present. */
+  private async persist(record: ReminderRecord): Promise<void> {
+    await this.store.save(record);
+    this.engine.storage?.reminder(record);
+  }
+
   stop(): void {
     this.started = false;
     for (const timer of this.timers.values()) {
@@ -209,7 +253,7 @@ export class ReminderRunner {
       updatedAt: now,
     };
 
-    await this.store.save(record);
+    await this.persist(record);
     this.handlers.set(id, {
       run: input.run,
       untilFn,
@@ -273,7 +317,7 @@ export class ReminderRunner {
       disarmReason: reason,
       updatedAt: new Date().toISOString(),
     };
-    await this.store.save(updated);
+    await this.persist(updated);
     this.handlers.delete(id);
     return toInfo(updated);
   }
@@ -662,7 +706,7 @@ export class ReminderRunner {
       disarmReason: reason,
       updatedAt: new Date().toISOString(),
     };
-    await this.store.save(updated);
+    await this.persist(updated);
     this.handlers.delete(record.id);
   }
 
@@ -711,7 +755,7 @@ export class ReminderRunner {
             : String(reschedule.at),
         updatedAt: new Date().toISOString(),
       };
-      await this.store.save(updated);
+      await this.persist(updated);
       this.armTimer(updated);
       return;
     }
@@ -725,7 +769,7 @@ export class ReminderRunner {
         disarmReason: "one_shot_complete",
         updatedAt: new Date().toISOString(),
       };
-      await this.store.save(updated);
+      await this.persist(updated);
       this.handlers.delete(current.id);
       return;
     }
@@ -747,7 +791,7 @@ export class ReminderRunner {
       nextFireAtMs,
       updatedAt: new Date().toISOString(),
     };
-    await this.store.save(updated);
+    await this.persist(updated);
     this.armTimer(updated);
   }
 }

package/src/internal/reminder-store.ts

@@ -66,6 +66,27 @@ export interface ReminderRecord {
   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) {}
 

package/src/internal/request-headers.ts

@@ -0,0 +1,23 @@
+/**
+ * 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;
+}

package/src/internal/resolve-prod-target.ts

@@ -0,0 +1,150 @@
+/**
+ * Resolve a hosted (managed) agent-serve deployment into a base URL +
+ * request headers for chat/run/call/eval `--prod`.
+ *
+ * Uses short-lived `engineAccess` from the deployment status route
+ * (Cursor API key on the management API; `X-Anyrun-Port-Token` on the
+ * engine). Alias tokens are out of scope here.
+ */
+
+import { basename, resolve } from "node:path";
+import { resolveDeployAuth } from "./cli-deploy.js";
+import {
+  DeployApiError,
+  type DeploymentDetail,
+  slugFromDirectoryName,
+  validateDeploymentSlug,
+} from "./deploy-client.js";
+import { CLI_COMMAND_NAME as CLI } from "./distribution.js";
+import { stderrPalette } from "./terminal-style.js";
+
+/**
+ * Interactive CLI keep-alive for hosted engines. Without these, a hibernated
+ * Anyrun pod returns 417 `pod_hibernated` and never wakes. Matches the
+ * cloud-agent interactive keep-alive shape (lower ≤ upper, seconds).
+ */
+export const PROD_ENGINE_WAKE_HEADERS: Readonly<Record<string, string>> = {
+  "x-anyrun-hibernation-lower-bound-s": "1800",
+  "x-anyrun-hibernation-upper-bound-s": "3600",
+};
+
+export interface ResolveProdTargetOptions {
+  dir: string;
+  cwd?: string;
+  /** Explicit deployment slug; otherwise derived from `--dir` basename. */
+  slug?: string;
+  team?: string;
+  apiKey?: string;
+  fetchImpl?: typeof fetch;
+  err?: (text: string) => void;
+}
+
+export interface ResolvedProdTarget {
+  agentUrl: string;
+  headers: Record<string, string>;
+  slug: string;
+  expiresAt: string;
+}
+
+/**
+ * Look up a running deployment and return its engineAccess URL/headers.
+ * Throws {@link Error} with a CLI-ready message on failure.
+ */
+export async function resolveProdTarget(
+  options: ResolveProdTargetOptions
+): Promise<ResolvedProdTarget> {
+  const err =
+    options.err ?? ((text: string) => void process.stderr.write(text));
+  const slug = resolveProdSlug(options);
+  const auth = await resolveDeployAuth({
+    team: options.team,
+    apiKey: options.apiKey,
+    fetchImpl: options.fetchImpl,
+    err,
+  });
+  if (typeof auth === "number") {
+    throw new Error(
+      `Could not resolve Cursor credentials/team for --prod (see above).`
+    );
+  }
+
+  let detail: DeploymentDetail;
+  try {
+    detail = await auth.client.getDeployment({
+      teamId: auth.teamId,
+      slug,
+    });
+  } catch (error) {
+    if (error instanceof DeployApiError) {
+      throw new Error(
+        `Deployment "${slug}" (team ${auth.teamId}): ${error.message}`
+      );
+    }
+    throw error;
+  }
+
+  // `degraded` still serves the previous ACTIVE engine; allow runtime access
+  // when the control plane minted engineAccess for it.
+  const access = detail.engineAccess;
+  const statusOk = detail.status === "running" || detail.status === "degraded";
+  if (!statusOk) {
+    const lastError =
+      detail.lastError === null || detail.lastError === undefined
+        ? ""
+        : ` ${sanitizeCustomerFacingDetail(detail.lastError)}`;
+    throw new Error(
+      `Deployment "${slug}" is ${detail.status}, not running.${lastError}\n` +
+        `Deploy or wait: \`${CLI} deploy --slug ${slug}\` / \`${CLI} deployment ${slug}\``
+    );
+  }
+  if (access === null || access === undefined) {
+    throw new Error(
+      `Deployment "${slug}" is ${detail.status} but is not reachable yet. ` +
+        `Try \`${CLI} deployment ${slug}\` or redeploy.`
+    );
+  }
+
+  err(`${stderrPalette().dim(`Using hosted deployment "${slug}".`)}\n`);
+
+  return {
+    agentUrl: access.url.replace(/\/$/, ""),
+    headers: {
+      ...access.headers,
+      ...PROD_ENGINE_WAKE_HEADERS,
+    },
+    slug,
+    expiresAt: access.expiresAt,
+  };
+}
+
+/** Strip obvious hosting internals from customer-facing error fragments. */
+function sanitizeCustomerFacingDetail(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");
+}
+
+/** Resolve the deployment slug the same way `deploy` does for a single dir. */
+export function resolveProdSlug(options: {
+  dir: string;
+  cwd?: string;
+  slug?: string;
+}): string {
+  if (options.slug !== undefined && options.slug !== "") {
+    const slugError = validateDeploymentSlug(options.slug);
+    if (slugError !== undefined) {
+      throw new Error(slugError);
+    }
+    return options.slug;
+  }
+  const dir = resolve(options.cwd ?? process.cwd(), options.dir);
+  const derived = slugFromDirectoryName(basename(dir));
+  if (derived === undefined) {
+    throw new Error(
+      `Could not derive a deployment slug from the directory name ${JSON.stringify(basename(dir))}; pass --slug.`
+    );
+  }
+  return derived;
+}

package/src/internal/run-client.ts

@@ -7,6 +7,7 @@
  */
 
 import type { SessionEvent, SessionPurpose } from "../types.js";
+import { mergeRequestHeaders, type RequestAuth } from "./request-headers.js";
 import { buildTrajectory, type Trajectory } from "./trajectory.js";
 
 /** Thrown when a turn stream exceeds `timeoutMs`; carries the session id. */
@@ -19,9 +20,8 @@ export class RunSessionTimeoutError extends Error {
     this.name = "RunSessionTimeoutError";
   }
 }
-export interface RunClientOptions {
+export interface RunClientOptions extends RequestAuth {
   baseUrl: string;
-  bearerToken?: string;
   /** Abort a hung turn. */
   timeoutMs?: number;
   /** Called for each stream event as it arrives (for CLI progress). */
@@ -72,6 +72,11 @@ export async function runSession(
   const allEvents: SessionEvent[] = [];
   let nextEventIndex = 0;
 
+  const auth: RequestAuth = {
+    bearerToken: options.bearerToken,
+    headers: options.headers,
+  };
+
   for (const message of options.messages) {
     const turn = await runOneTurn({
       baseUrl,
@@ -79,18 +84,13 @@ export async function runSession(
       sessionId,
       continuationToken,
       startIndex: sessionId === undefined ? 0 : nextEventIndex,
-      bearerToken: options.bearerToken,
+      auth,
       timeoutMs: options.timeoutMs,
       onEvent: options.onEvent,
-      ...(sessionId === undefined && options.purpose !== undefined
-        ? { purpose: options.purpose }
-        : {}),
-      ...(sessionId === undefined && options.workspaceDir !== undefined
-        ? { workspaceDir: options.workspaceDir }
-        : {}),
-      ...(sessionId === undefined && options.workspaceFiles !== undefined
-        ? { workspaceFiles: options.workspaceFiles }
-        : {}),
+      purpose: sessionId === undefined ? options.purpose : undefined,
+      workspaceDir: sessionId === undefined ? options.workspaceDir : undefined,
+      workspaceFiles:
+        sessionId === undefined ? options.workspaceFiles : undefined,
     });
     sessionId = turn.sessionId;
     continuationToken = turn.continuationToken;
@@ -128,7 +128,7 @@ interface OneTurnArgs {
   workspaceDir?: string;
   workspaceFiles?: Record<string, string>;
   startIndex: number;
-  bearerToken?: string;
+  auth?: RequestAuth;
   timeoutMs?: number;
   onEvent?: (event: SessionEvent) => void;
 }
@@ -145,20 +145,21 @@ async function runOneTurn(args: OneTurnArgs): Promise<OneTurnResult> {
   let continuationToken = args.continuationToken;
 
   if (sessionId === undefined) {
+    const body: Record<string, unknown> = { message: args.message };
+    if (args.purpose !== undefined) {
+      body.purpose = args.purpose;
+    }
+    if (args.workspaceDir !== undefined) {
+      body.workspaceDir = args.workspaceDir;
+    }
+    if (args.workspaceFiles !== undefined) {
+      body.workspaceFiles = args.workspaceFiles;
+    }
     const created = await postJson(
       args.baseUrl,
       "/v1/session",
-      {
-        message: args.message,
-        ...(args.purpose === undefined ? {} : { purpose: args.purpose }),
-        ...(args.workspaceDir === undefined
-          ? {}
-          : { workspaceDir: args.workspaceDir }),
-        ...(args.workspaceFiles === undefined
-          ? {}
-          : { workspaceFiles: args.workspaceFiles }),
-      },
-      args.bearerToken
+      body,
+      args.auth
     );
     if (created.status >= 400 || created.body.ok === false) {
       throw new Error(
@@ -172,7 +173,7 @@ async function runOneTurn(args: OneTurnArgs): Promise<OneTurnResult> {
       args.baseUrl,
       `/v1/session/${sessionId}`,
       { message: args.message, continuationToken },
-      args.bearerToken
+      args.auth
     );
     if (resp.status >= 400 || resp.body.ok === false) {
       throw new Error(
@@ -190,7 +191,7 @@ async function runOneTurn(args: OneTurnArgs): Promise<OneTurnResult> {
     baseUrl: args.baseUrl,
     sessionId,
     startIndex: args.startIndex,
-    bearerToken: args.bearerToken,
+    auth: args.auth,
     timeoutMs: args.timeoutMs,
     onEvent: args.onEvent,
   });
@@ -209,7 +210,7 @@ async function collectStream(args: {
   baseUrl: string;
   sessionId: string;
   startIndex: number;
-  bearerToken?: string;
+  auth?: RequestAuth;
   timeoutMs?: number;
   onEvent?: (event: SessionEvent) => void;
 }): Promise<SessionEvent[]> {
@@ -223,7 +224,7 @@ async function collectStream(args: {
     const resp = await fetch(
       `${args.baseUrl}/v1/session/${args.sessionId}/stream?startIndex=${args.startIndex}`,
       {
-        headers: authHeaders(args.bearerToken),
+        headers: mergeRequestHeaders(args.auth),
         signal: controller.signal,
       }
     );
@@ -283,23 +284,17 @@ async function collectStream(args: {
   }
 }
 
-function authHeaders(bearerToken: string | undefined): Record<string, string> {
-  return bearerToken === undefined
-    ? {}
-    : { authorization: `Bearer ${bearerToken}` };
-}
-
 async function postJson(
   baseUrl: string,
   path: string,
   body: unknown,
-  bearerToken?: string
+  auth?: RequestAuth
 ): Promise<{ status: number; body: Record<string, unknown> }> {
   const resp = await fetch(`${baseUrl}${path}`, {
     method: "POST",
     headers: {
       "content-type": "application/json",
-      ...authHeaders(bearerToken),
+      ...mergeRequestHeaders(auth),
     },
     body: JSON.stringify(body),
   });
@@ -312,6 +307,14 @@ async function postJson(
       parsed = { message: text };
     }
   }
+  const anyrunReason = resp.headers.get("x-anyrun-failure-reason");
+  if (
+    anyrunReason !== null &&
+    anyrunReason !== "" &&
+    (parsed.message === undefined || parsed.message === "")
+  ) {
+    parsed.message = anyrunReason;
+  }
   return { status: resp.status, body: parsed };
 }