@cursor/july 0.1.8 → 0.1.10

package/docs/storage.md

@@ -113,13 +113,27 @@ propagate errors — unlike session mirrors, which are at-most-once.
 
 Without `agent/storage.ts`, `host.kv` falls back to files under
 `--state-root/kv`. That is fine for local dogfood; it does **not**
-survive replacing the host. For prod, author `defineStorage` (for example
-`@cursor/july/storage/postgres-kv`) so both sessions and author KV share
-the durable backend.
+survive replacing the host. For Cursor-managed hosting, prefer
+`@cursor/july/storage/cursor-hosted` so sessions and author KV share the
+platform Bugbot tables through a control-plane HTTP proxy (authenticated
+as the deployment pod credential — engines never receive a database URL).
+For self-hosted Postgres you own, use `@cursor/july/storage/postgres-kv`
+and supply `BUGBOTDB_URL` / `AGENT_SERVE_DEPLOYMENT_ID` yourself.
+
+```ts
+// agent/storage.ts — Cursor-managed hosting
+import { defineStorage } from "@cursor/july/storage";
+import { cursorHostedStorage } from "@cursor/july/storage/cursor-hosted";
+
+export default defineStorage({
+  ...cursorHostedStorage(),
+});
+```
 
 Built-in helpers:
 
 | Import | Backend |
 | --- | --- |
 | `@cursor/july/storage/file-kv` | File-per-key under `.agent-serve/kv` |
-| `@cursor/july/storage/postgres-kv` | `agent_serve_*` tables (`BUGBOTDB_URL`) |
+| `@cursor/july/storage/cursor-hosted` | Platform Bugbot `agent_serve_*` via control-plane proxy |
+| `@cursor/july/storage/postgres-kv` | Same tables; you supply `BUGBOTDB_URL` / `AGENT_SERVE_DEPLOYMENT_ID` |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cursor/july",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "(early alpha) Filesystem-first framework for defining Cursor agents as markdown and TypeScript and serving them over channels with the Cursor SDK.",
   "license": "SEE LICENSE IN LICENSE.md",
   "repository": {
@@ -138,6 +138,13 @@
       "import": "./dist/storage-backends/postgres-kv.js",
       "default": "./dist/storage-backends/postgres-kv.js"
     },
+    "./storage/cursor-hosted": {
+      "anysphere-source": "./src/storage-backends/cursor-hosted.ts",
+      "bun": "./src/storage-backends/cursor-hosted.ts",
+      "types": "./dist/storage-backends/cursor-hosted.d.ts",
+      "import": "./dist/storage-backends/cursor-hosted.js",
+      "default": "./dist/storage-backends/cursor-hosted.js"
+    },
     "./package.json": {
       "anysphere-source": "./package.json",
       "bun": "./package.json",

package/src/bin/agent-serve.ts

@@ -247,6 +247,11 @@ Options:
                      githubChannel({ cursorAccount }). Admitted callers can drive
                      sessions holding the account's repo-scoped GitHub credential,
                      so use only behind a trusted boundary (e.g. an SSO proxy).
+  --allow-anonymous-cursor-account-mcp
+                     serve: allow --allow-anonymous together with
+                     defineConnection({ cursorAccount: true }). Admitted callers
+                     can drive the account's MCP connectors, so use only behind
+                     a trusted boundary (e.g. an SSO proxy or hosted alias token).
   --public-url       serve: base URL where this host is reachable from outside
                      (e.g. https://agent-serve.example.com). Required for peer
                      connections (defineConnection({ agent })) on cloud-runtime
@@ -372,6 +377,7 @@ async function main(argv: string[]): Promise<number> {
       "bearer-token": { type: "string" },
       "allow-anonymous": { type: "boolean", default: false },
       "allow-anonymous-cursor-github": { type: "boolean", default: false },
+      "allow-anonymous-cursor-account-mcp": { type: "boolean", default: false },
       "no-schedules": { type: "boolean", default: false },
       "no-playground": { type: "boolean", default: false },
       "no-docs": { type: "boolean", default: false },
@@ -976,6 +982,10 @@ async function main(argv: string[]): Promise<number> {
         allowAnonymous: values["allow-anonymous"] === true ? true : undefined,
         allowAnonymousCursorGithub:
           values["allow-anonymous-cursor-github"] === true ? true : undefined,
+        allowAnonymousCursorAccountMcp:
+          values["allow-anonymous-cursor-account-mcp"] === true
+            ? true
+            : undefined,
         schedules: values["no-schedules"] === true ? false : undefined,
         playground: values["no-playground"] === true ? false : undefined,
         docs: values["no-docs"] === true ? false : undefined,

package/src/internal/cli-ax.ts

@@ -54,7 +54,7 @@ import { runSession } from "./run-client.js";
 import {
   fetchSessionEvents,
   formatSessionsTable,
-  listSessions,
+  listSessionsWithSource,
   resolvePreviousSessionId,
 } from "./sessions-client.js";
 import { createStreamProgress } from "./stream-progress.js";
@@ -1383,7 +1383,7 @@ export async function cmdSessions(options: AxCliOptions): Promise<number> {
     return target;
   }
   try {
-    const sessions = await listSessions({
+    const listed = await listSessionsWithSource({
       baseUrl: target.agentUrl,
       auth: {
         bearerToken: options.bearerToken,
@@ -1392,10 +1392,16 @@ export async function cmdSessions(options: AxCliOptions): Promise<number> {
       fetchImpl: options.fetchImpl,
     });
     if (options.json === true) {
-      process.stdout.write(`${JSON.stringify({ sessions }, null, 2)}\n`);
+      const payload =
+        listed.source === undefined
+          ? { sessions: listed.sessions }
+          : { sessions: listed.sessions, source: listed.source };
+      process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
       return 0;
     }
-    process.stdout.write(formatSessionsTable(sessions));
+    process.stdout.write(
+      formatSessionsTable(listed.sessions, { source: listed.source })
+    );
     return 0;
   } catch (error) {
     process.stderr.write(

package/src/internal/cli-deploy.ts

@@ -40,9 +40,11 @@ import {
 } from "./discovery.js";
 import { CLI_COMMAND_NAME as CLI } from "./distribution.js";
 import {
+  isReservedSecretName,
   isValidCursorEventRepo,
   validateSettableSecretName,
 } from "./hosting.js";
+import { deployProgressLabel, sanitizeCustomerError } from "./logs-client.js";
 import { stderrPalette } from "./terminal-style.js";
 
 const DEFAULT_POLL_INTERVAL_MS = 3_000;
@@ -554,6 +556,24 @@ async function deployOne(
     );
     return 1;
   }
+  // Repo-backed fields without a resolvable https origin become a static
+  // deploy body the control plane rejects. Fail here with a fix hint —
+  // common when origin is an unrecognized SSH shape (pass --repo).
+  if (
+    gitRepoUrl === undefined &&
+    (gitRef !== undefined ||
+      agentPath !== undefined ||
+      (options.cursorEventsRepos !== undefined &&
+        options.cursorEventsRepos.length > 0) ||
+      (options.allowDomains !== undefined && options.allowDomains.length > 0))
+  ) {
+    ctx.err(
+      `Could not resolve an https:// git repository URL for this deploy.\n` +
+        `  Pass --repo https://github.com/<owner>/<repo> (inferred from origin when possible).\n` +
+        `  Or omit --ref/--path/--cursor-events-repo/--allow-domain for a static engine.\n`
+    );
+    return 1;
+  }
   for (const repo of options.cursorEventsRepos ?? []) {
     if (!isValidCursorEventRepo(repo)) {
       ctx.err(`Invalid --cursor-events-repo: ${repo} (expected owner/name)\n`);
@@ -659,13 +679,11 @@ async function deployOne(
   }
 
   if (detail.status !== "running") {
-    ctx.err(
-      `Deployment ${slug} ended ${detail.status}${
-        detail.lastError === null || detail.lastError === undefined
-          ? ""
-          : `: ${detail.lastError}`
-      }\n`
-    );
+    const errorDetail =
+      detail.lastError === null || detail.lastError === undefined
+        ? ""
+        : `: ${sanitizeCustomerError(detail.lastError)}`;
+    ctx.err(`Deployment ${slug} ended ${detail.status}${errorDetail}\n`);
     return 1;
   }
   ctx.out(
@@ -709,7 +727,11 @@ function warnMissingSecrets(
     return;
   }
   const setNames = new Set(set ?? []);
-  const missing = declared.filter((name) => !setNames.has(name));
+  // Platform-managed names (CURSOR_*, hosted storage) are injected by the
+  // control plane and never appear in secrets list — do not warn on them.
+  const missing = declared.filter(
+    (name) => !setNames.has(name) && !isReservedSecretName(name)
+  );
   if (missing.length === 0) {
     return;
   }
@@ -793,11 +815,23 @@ export async function cmdDeploymentStatus(
   const lines = [
     `${detail.slug} (team ${detail.teamId})`,
     `  status:      ${detail.status}`,
+  ];
+  if (detail.progress !== undefined) {
+    lines.push(`  progress:    ${detail.progress}`);
+  }
+  if (
+    detail.statusMessage !== null &&
+    detail.statusMessage !== undefined &&
+    detail.statusMessage.trim() !== ""
+  ) {
+    lines.push(`  step:        ${detail.statusMessage}`);
+  }
+  lines.push(
     `  generation:  ${detail.generation}`,
     `  kind:        ${detail.deploymentKind}`,
     `  alias:       ${aliasUrl}`,
-    `  playground:  ${aliasUrl}/playground`,
-  ];
+    `  playground:  ${aliasUrl}/playground`
+  );
   if (detail.gitRepoUrl !== null && detail.gitRepoUrl !== undefined) {
     lines.push(`  repo:        ${detail.gitRepoUrl} @ ${detail.gitRef ?? ""}`);
   }
@@ -835,7 +869,7 @@ export async function cmdDeploymentStatus(
     );
   }
   if (detail.lastError !== null && detail.lastError !== undefined) {
-    lines.push(`  last error:  ${detail.lastError}`);
+    lines.push(`  last error:  ${sanitizeCustomerError(detail.lastError)}`);
   }
   if (detail.desiredUpdatedAt !== undefined) {
     lines.push(`  updated:     ${detail.desiredUpdatedAt}`);
@@ -1229,7 +1263,9 @@ function createLineReader(
 /**
  * Poll deployment status every `pollIntervalMs` until it lands in
  * `terminal` (single-line progress on a TTY, one line per transition
- * otherwise). Throws DeployApiError on request failures or timeout.
+ * otherwise). Prefers customer `statusMessage` / `progress` over raw
+ * status so create → checkout → start is visible. Throws DeployApiError
+ * on request failures or timeout.
  */
 async function pollUntil(
   ctx: DeployCliContext,
@@ -1238,21 +1274,22 @@ async function pollUntil(
 ): Promise<DeploymentDetail> {
   const startedAt = Date.now();
   const tty = process.stderr.isTTY === true;
-  let lastStatus: DeploymentStatus | undefined;
+  let lastLabel: string | undefined;
   let sawProgress = false;
 
-  const report = (status: DeploymentStatus): void => {
+  const report = (detail: DeploymentDetail): void => {
     if (ctx.json) {
       return;
     }
+    const label = deployProgressLabel(detail);
     const elapsed = Math.round((Date.now() - startedAt) / 1000);
     if (tty) {
-      ctx.err(`\r\x1b[2K${slug}: ${status} (${elapsed}s)`);
+      ctx.err(`\r\x1b[2K${slug}: ${label} (${elapsed}s)`);
       sawProgress = true;
-    } else if (status !== lastStatus) {
-      ctx.err(`${slug}: ${status}\n`);
+    } else if (label !== lastLabel) {
+      ctx.err(`${slug}: ${label}\n`);
     }
-    lastStatus = status;
+    lastLabel = label;
   };
   const finishProgressLine = (): void => {
     if (tty && sawProgress) {
@@ -1267,15 +1304,16 @@ async function pollUntil(
         finishProgressLine();
         throw error;
       });
-    report(detail.status);
+    report(detail);
     if (terminal.has(detail.status)) {
       finishProgressLine();
       return detail;
     }
     if (Date.now() - startedAt >= ctx.timeoutMs) {
       finishProgressLine();
+      const last = deployProgressLabel(detail);
       throw new DeployApiError(
-        `Timed out after ${Math.round(ctx.timeoutMs / 1000)}s waiting for ${slug} (last status: ${detail.status}). It may still converge — check \`${CLI} deployment ${slug} --team ${ctx.teamId}\`.`,
+        `Timed out after ${Math.round(ctx.timeoutMs / 1000)}s waiting for ${slug} (last: ${last}). It may still converge — check \`${CLI} deployment ${slug} --team ${ctx.teamId}\`.`,
         0
       );
     }

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

@@ -105,4 +105,5 @@ export const AUTHORING_ENTRY_FILES: ReadonlyArray<
   ["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/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/resolved-connections.ts

@@ -78,13 +78,23 @@ export function assertCloudCanHonorAccountServersFilters(args: {
 /** Fail closed when anonymous HTTP admission would expose account connectors. */
 export function assertAccountConnectionsNotAnonymous(args: {
   allowAnonymous?: boolean;
+  /**
+   * Opt in when every admitted caller is already trusted (e.g. behind an
+   * authenticating proxy / hosted alias token). Same trust model as
+   * `--allow-anonymous-cursor-github`.
+   */
+  allowAnonymousCursorAccountMcp?: boolean;
   hasAccountConnections: boolean;
 }): void {
-  if (args.allowAnonymous === true && args.hasAccountConnections) {
-    throw new Error(
-      "[agentkit] --allow-anonymous cannot be used with Cursor account MCP connections (defineConnection({ cursorAccount: true })); use --bearer-token or remove the account MCP connections."
-    );
+  if (args.allowAnonymous !== true || !args.hasAccountConnections) {
+    return;
+  }
+  if (args.allowAnonymousCursorAccountMcp === true) {
+    return;
   }
+  throw new Error(
+    "[agentkit] --allow-anonymous cannot be used with Cursor account MCP connections (defineConnection({ cursorAccount: true })); use --bearer-token, or opt in with --allow-anonymous-cursor-account-mcp behind a trusted boundary."
+  );
 }
 
 export function resolveMountConnections(args: {

package/src/internal/server.ts

@@ -307,8 +307,18 @@ export async function startServer(
   const accountRefsBySlug = collectCursorAccountConnections(mounts);
   assertAccountConnectionsNotAnonymous({
     allowAnonymous: options.allowAnonymous,
+    allowAnonymousCursorAccountMcp: options.allowAnonymousCursorAccountMcp,
     hasAccountConnections: accountRefsBySlug.size > 0,
   });
+  if (
+    options.allowAnonymous === true &&
+    options.allowAnonymousCursorAccountMcp === true &&
+    accountRefsBySlug.size > 0
+  ) {
+    logger(
+      "[agentkit] warning: --allow-anonymous-cursor-account-mcp — every admitted HTTP caller can drive Cursor account MCP connectors; serve this only behind a trusted boundary (e.g. an SSO proxy or hosted alias token)"
+    );
+  }
   let accountBridge: CursorAccountMcpBridge | undefined;
   if (accountRefsBySlug.size > 0) {
     if (accountKey === undefined) {
@@ -914,8 +924,12 @@ function mountAgentRoutes(
         (relaxSessionReadAuthBeyondLoopback ||
           (typeof ctx.requestIp === "string" &&
             isLoopbackAddress(ctx.requestIp)));
+      const listed = await engine.listSessionsWithSource(ctx.auth, {
+        includeAll,
+      });
       return jsonResponse({
-        sessions: await engine.listSessions(ctx.auth, { includeAll }),
+        sessions: listed.sessions,
+        source: listed.source,
       });
     },
   });