@cursor/july 0.1.7 → 0.1.9

package/src/internal/deploy-client.ts

@@ -31,7 +31,9 @@ export type DeploymentStatus =
 export type DeploymentProgress =
   | "queued"
   | "preparing"
+  | "creating"
   | "building"
+  | "starting"
   | "finalizing"
   | "running"
   | "failed"
@@ -135,6 +137,12 @@ export interface Deployment {
    * backends; older responses omit it.
    */
   progress?: DeploymentProgress;
+  /**
+   * Live step while the deploy converges (e.g. "Checking out source…").
+   * Null when running / stopped or when only a failure is on the row.
+   * Present on newer backends; older responses omit it.
+   */
+  statusMessage?: string | null;
   generation: number;
   observedGeneration?: number | null;
   engineGeneration?: number | null;
@@ -218,7 +226,9 @@ const deploymentSchema = z.object({
     .enum([
       "queued",
       "preparing",
+      "creating",
       "building",
+      "starting",
       "finalizing",
       "running",
       "failed",
@@ -227,6 +237,7 @@ const deploymentSchema = z.object({
       "degraded",
     ])
     .optional(),
+  statusMessage: z.string().nullable().optional(),
   generation: z.number(),
   observedGeneration: z.number().nullable().optional(),
   engineGeneration: z.number().nullable().optional(),

package/src/internal/deploy-source.ts

@@ -39,17 +39,35 @@ const defaultGitRunner: GitRunner = async (args, cwd) => {
  * Normalize a git remote URL to the https form the control plane accepts
  * (`https://host/owner/repo`, no `.git` suffix). Returns undefined for
  * unrecognized shapes.
+ *
+ * Accepts HTTPS, `git@host:path`, GitHub org-scoped SSH
+ * (`org-123@github.com:owner/repo.git`), and `ssh://user@host[:port]/path`.
  */
 export function httpsGitRepoUrlFromRemote(remote: string): string | undefined {
   let url = remote.trim();
   if (url === "") {
     return undefined;
   }
-  if (url.startsWith("git@")) {
-    // git@host:owner/repo.git → https://host/owner/repo.git
-    url = `https://${url.slice("git@".length).replace(":", "/")}`;
-  } else if (url.startsWith("ssh://git@")) {
-    url = `https://${url.slice("ssh://git@".length)}`;
+
+  // SCP-like SSH: user@host:owner/repo(.git) — includes git@ and GitHub
+  // org deploy keys (org-NNNN@github.com:…).
+  const scpMatch = /^([^@/\s]+)@([^:/\s]+):(.+)$/.exec(url);
+  if (scpMatch !== null) {
+    const host = scpMatch[2]!;
+    const path = scpMatch[3]!;
+    url = `https://${host}/${path}`;
+  } else if (/^ssh:\/\//i.test(url)) {
+    // ssh://user@host[:port]/owner/repo → https://host/owner/repo
+    try {
+      const ssh = new URL(url);
+      const path = ssh.pathname.replace(/^\/+/, "");
+      if (ssh.hostname === "" || path === "") {
+        return undefined;
+      }
+      url = `https://${ssh.hostname}/${path}`;
+    } catch {
+      return undefined;
+    }
   } else if (!/^https?:\/\//i.test(url)) {
     return undefined;
   }
@@ -67,7 +85,7 @@ export function httpsGitRepoUrlFromRemote(remote: string): string | undefined {
   if (path === "" || !path.includes("/")) {
     return undefined;
   }
-  // Use hostname (not host) so ssh://git@github.com:22/… does not keep :22.
+  // Use hostname (not host) so ssh://…@github.com:22/… does not keep :22.
   return `https://${parsed.hostname}/${path}`;
 }
 

package/src/internal/discovery.ts

@@ -454,7 +454,7 @@ function resolveHosting(
       warn(`hosting.secretNames: ${nameError}`);
     } else if (isReservedSecretName(name)) {
       warn(
-        `hosting.secretNames: ${JSON.stringify(name)} is platform-reserved (CURSOR_*) and injected automatically; it cannot be set with \`secrets set\`.`
+        `hosting.secretNames: ${JSON.stringify(name)} is platform-managed (CURSOR_* / Cursor-hosted storage) and injected automatically; omit it from secretNames.`
       );
     }
   }

package/src/internal/distribution.ts

@@ -103,4 +103,7 @@ export const AUTHORING_ENTRY_FILES: ReadonlyArray<
   ["evals", "evals.js"],
   ["ab", "ab.js"],
   ["storage", "storage.js"],
+  ["storage/file-kv", "storage-backends/file-kv.js"],
+  ["storage/postgres-kv", "storage-backends/postgres-kv.js"],
+  ["storage/cursor-hosted", "storage-backends/cursor-hosted.js"],
 ];

package/src/internal/host-kv.ts

@@ -0,0 +1,85 @@
+/**
+ * Author-facing durable JSON KV for {@link HostContext.kv}.
+ *
+ * When `defineStorage` is authored and exposes `get`, values live in that
+ * sink under {@link storageKeys.kv}. Otherwise they land as one JSON file
+ * per key under `--state-root/kv` (local dogfood / no durable plug-in).
+ */
+
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { storageKeys } from "../storage.js";
+import type { HostKvApi, JsonValue } from "../types.js";
+import type { StorageCoordinator } from "./storage-coordinator.js";
+
+export interface CreateHostKvApiOptions {
+  agentName: string;
+  stateRoot: string;
+  storage?: StorageCoordinator;
+}
+
+/** Build the host KV API for one agent process. */
+export function createHostKvApi(options: CreateHostKvApiOptions): HostKvApi {
+  const storage = options.storage;
+  if (storage?.supportsAuthorKv === true) {
+    return {
+      get: (key) => storage.kvGet(normalizeAuthorKey(key)),
+      put: (key, value) => storage.kvPut(normalizeAuthorKey(key), value),
+      delete: (key) => storage.kvDelete(normalizeAuthorKey(key)),
+    };
+  }
+  return createFilesystemKvApi({
+    agentName: options.agentName,
+    stateRoot: options.stateRoot,
+  });
+}
+
+function createFilesystemKvApi(options: {
+  agentName: string;
+  stateRoot: string;
+}): HostKvApi {
+  const dir = join(options.stateRoot, "kv");
+  const filePath = (authorKey: string): string =>
+    join(
+      dir,
+      `${encodeURIComponent(storageKeys.kv(options.agentName, authorKey))}.json`
+    );
+
+  return {
+    async get(key): Promise<JsonValue | undefined> {
+      const authorKey = normalizeAuthorKey(key);
+      try {
+        return JSON.parse(
+          await readFile(filePath(authorKey), "utf8")
+        ) as JsonValue;
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+          return undefined;
+        }
+        throw error;
+      }
+    },
+
+    async put(key, value): Promise<void> {
+      const authorKey = normalizeAuthorKey(key);
+      await mkdir(dir, { recursive: true });
+      const target = filePath(authorKey);
+      const tmp = join(dir, `.tmp-${randomUUID()}`);
+      await writeFile(tmp, JSON.stringify(value), "utf8");
+      await rename(tmp, target);
+    },
+
+    async delete(key): Promise<void> {
+      const authorKey = normalizeAuthorKey(key);
+      await rm(filePath(authorKey), { force: true });
+    },
+  };
+}
+
+function normalizeAuthorKey(key: string): string {
+  if (typeof key !== "string" || key.trim() === "") {
+    throw new Error("host.kv key must be a non-empty string");
+  }
+  return key;
+}

package/src/internal/hosting.ts

@@ -18,6 +18,17 @@ export const MAX_SECRET_NAME_LENGTH = 64;
 /** Secret names the platform injects; user writes are rejected. */
 export const RESERVED_SECRET_NAME_PREFIX = "CURSOR_";
 
+/**
+ * Additional platform-managed env names for Cursor-hosted durable storage
+ * (Bugbot `agent_serve_*`). Mirrored from
+ * `@cursor/july/storage/cursor-hosted` so validate/secrets CLI stay in sync
+ * without importing the storage backend into the CLI graph.
+ */
+export const PLATFORM_HOSTED_STORAGE_SECRET_NAMES = [
+  "BUGBOTDB_URL",
+  "AGENT_SERVE_DEPLOYMENT_ID",
+] as const;
+
 const SECRET_NAME_PATTERN = /^[A-Z][A-Z0-9_]*$/;
 
 // Lowercase hostname with >=2 labels, an alphabetic TLD, and at most one
@@ -49,14 +60,23 @@ export function validateSecretName(name: string): string | undefined {
   return undefined;
 }
 
-/** True when the platform reserves this name (`CURSOR_*`); writes are rejected. */
+/**
+ * True when the platform manages this name (`CURSOR_*` or hosted-storage
+ * env vars); user writes / deletes are rejected.
+ */
 export function isReservedSecretName(name: string): boolean {
-  return name.startsWith(RESERVED_SECRET_NAME_PREFIX);
+  if (name.startsWith(RESERVED_SECRET_NAME_PREFIX)) {
+    return true;
+  }
+  const upper = name.toUpperCase();
+  return (PLATFORM_HOSTED_STORAGE_SECRET_NAMES as readonly string[]).some(
+    (managed) => managed === upper
+  );
 }
 
 /**
  * Human error for a secret name a user is trying to write or delete:
- * grammar plus the reserved `CURSOR_*` prefix.
+ * grammar plus platform-managed names (`CURSOR_*`, hosted storage).
  */
 export function validateSettableSecretName(name: string): string | undefined {
   const nameError = validateSecretName(name);
@@ -64,7 +84,7 @@ export function validateSettableSecretName(name: string): string | undefined {
     return nameError;
   }
   if (isReservedSecretName(name)) {
-    return `Secret name ${JSON.stringify(name)} is platform-reserved (CURSOR_*); the platform injects those values automatically.`;
+    return `Secret name ${JSON.stringify(name)} is platform-managed; the platform injects CURSOR_* and Cursor-hosted storage values automatically.`;
   }
   return undefined;
 }

package/src/internal/logs-client.ts

@@ -35,7 +35,9 @@ export type LogsProgress =
   | DeploymentProgress
   | "queued"
   | "preparing"
+  | "creating"
   | "building"
+  | "starting"
   | "finalizing"
   | "running"
   | "failed"
@@ -46,7 +48,9 @@ export type LogsProgress =
 const PROGRESS_MESSAGES: Readonly<Record<LogsProgress, string>> = {
   queued: "Waiting to start…",
   preparing: "Preparing runtime…",
-  building: "Building and starting agent…",
+  creating: "Creating runtime…",
+  building: "Checking out source and installing dependencies…",
+  starting: "Starting agent and waiting for health…",
   finalizing: "Finishing deployment…",
   running: "Deployment running",
   failed: "Deploy failed",
@@ -55,9 +59,15 @@ const PROGRESS_MESSAGES: Readonly<Record<LogsProgress, string>> = {
   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
+  lastError?: string | null,
+  statusMessage?: string | null
 ): string {
   if (progress === "failed") {
     const detail =
@@ -73,6 +83,13 @@ export function progressMessage(
         : `: ${sanitizeCustomerError(lastError)}`;
     return `Deployment degraded${detail}`;
   }
+  if (
+    statusMessage !== null &&
+    statusMessage !== undefined &&
+    statusMessage.trim() !== ""
+  ) {
+    return statusMessage.trim();
+  }
   return PROGRESS_MESSAGES[progress];
 }
 
@@ -85,7 +102,38 @@ export function sanitizeCustomerError(message: string): string {
     .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(/\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 `agentkit deploy` polling (TTY spinner / non-TTY
+ * transitions). Uses statusMessage → progress → raw status.
+ */
+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: {
@@ -241,7 +289,7 @@ async function followProdLogs(args: {
       );
     });
 
-  let lastProgress: string | undefined;
+  let lastEmittedKey: string | undefined;
   const slugHint = args.slug !== undefined && args.slug !== "" ? args.slug : "";
   if (args.once !== true) {
     const label = slugHint !== "" ? slugHint : "deployment";
@@ -260,33 +308,32 @@ async function followProdLogs(args: {
     }
 
     const progress = resolveProgress(detail);
+    const message = progressMessage(
+      progress,
+      detail.lastError,
+      detail.statusMessage
+    );
+    const emitKey = `${progress}\0${message}`;
 
     if (progress === "failed") {
-      const message = progressMessage(progress, detail.lastError);
-      if (progress !== lastProgress) {
-        lastProgress = progress;
+      if (emitKey !== lastEmittedKey) {
+        lastEmittedKey = emitKey;
         emitProgress(args.write, args.json === true, progress, message);
       }
       throw new Error(`Deployment "${detail.slug}" failed.`);
     }
     if (progress === "stopped") {
-      const message = progressMessage(progress, detail.lastError);
-      if (progress !== lastProgress) {
-        lastProgress = progress;
+      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" && progress !== lastProgress) {
-        lastProgress = progress;
-        emitProgress(
-          args.write,
-          args.json === true,
-          progress,
-          progressMessage(progress, detail.lastError)
-        );
+      if (progress === "degraded" && emitKey !== lastEmittedKey) {
+        lastEmittedKey = emitKey;
+        emitProgress(args.write, args.json === true, progress, message);
       }
       const runtime = await resolveRuntime();
       await followRuntimeLogs({
@@ -306,9 +353,8 @@ async function followProdLogs(args: {
       return;
     }
 
-    const message = progressMessage(progress, detail.lastError);
-    if (progress !== lastProgress) {
-      lastProgress = progress;
+    if (emitKey !== lastEmittedKey) {
+      lastEmittedKey = emitKey;
       emitProgress(args.write, args.json === true, progress, message);
     }
 

package/src/internal/server.ts

@@ -423,6 +423,17 @@ export async function startServer(
           },
           resolveApproval: (sessionId, callId, decision, auth) =>
             engine.resolveApproval(sessionId, callId, decision, auth),
+          hasContinuationSession: (continuationToken) =>
+            engine.hasContinuationSession(channel.id, continuationToken),
+          isContinuationBusy: (continuationToken) =>
+            engine.isContinuationBusy(channel.id, continuationToken),
+          getContinuationLastBotMessageTs: (continuationToken) =>
+            engine.getContinuationLastBotMessageTs(
+              channel.id,
+              continuationToken
+            ),
+          interruptContinuation: (continuationToken) =>
+            engine.interruptContinuation(channel.id, continuationToken),
           logger,
         };
         try {
@@ -1624,6 +1635,26 @@ async function startCursorSlackRelay(input: {
         envelope,
         send: args.send,
         host: args.host,
+        hasContinuationSession: (continuationToken) =>
+          target.runtime.engine.hasContinuationSession(
+            target.channelId,
+            continuationToken
+          ),
+        isContinuationBusy: (continuationToken) =>
+          target.runtime.engine.isContinuationBusy(
+            target.channelId,
+            continuationToken
+          ),
+        getContinuationLastBotMessageTs: (continuationToken) =>
+          target.runtime.engine.getContinuationLastBotMessageTs(
+            target.channelId,
+            continuationToken
+          ),
+        interruptContinuation: (continuationToken) =>
+          target.runtime.engine.interruptContinuation(
+            target.channelId,
+            continuationToken
+          ),
       });
     },
   });