@cursor/july 0.1.49 → 0.1.52

package/src/internal/convert-automation/convert-workflow.ts

@@ -999,7 +999,7 @@ function emitSlackChannel(
   }
   if (socketMode) {
     out.setupSteps.push(
-      `Slack channel-watch / reaction / channel-created triggers need a dedicated Socket Mode Slack app (not the Cursor connection): run \`${CLI_COMMAND_NAME} slack setup\`, then \`${CLI_COMMAND_NAME} slack init --channel-posts\`, and set the generated tokens.`
+      `Slack channel-watch / reaction / channel-created triggers need a dedicated Socket Mode Slack app (not the Cursor connection): run \`${CLI_COMMAND_NAME} slack create --channel-posts\`, then finish in the dashboard wizard.`
     );
   }
 
@@ -1069,7 +1069,7 @@ function emitSlackChannel(
     body = [
       "//",
       "// This channel needs a dedicated Socket Mode Slack app (not the Cursor",
-      `// connection): run \`${CLI_COMMAND_NAME} slack setup\` and \`${CLI_COMMAND_NAME} slack init\`.`,
+      `// connection): run \`${CLI_COMMAND_NAME} slack create --channel-posts\`.`,
       "export default slackChannel({",
       ...engagement,
       "});",

package/src/internal/event-log.ts

@@ -1,20 +1,83 @@
 /**
- * Durable, replayable per-session event log. Events are held in memory for
- * live fan-out and appended to `events.ndjson` for durability; on process
- * restart the file is hydrated back so streams can replay from any
- * `startIndex`.
+ * Durable, replayable per-session event log. `events.ndjson` is the source
+ * of truth. The process keeps `nextIndex`, live subscribers, and a short
+ * unflushed tail — not a cache of the full transcript. Replay reads the
+ * file on demand; live streams subscribe first, then catch up by index.
+ *
+ * Hosted engines mint thousands of sessions (one per PR under
+ * agentic-owners). Retaining every streamed tool output in RAM for the
+ * process lifetime is what OOM'd those engines at the ~4 GB heap cap.
  */
 
-import { appendFile, mkdir, readFile } from "node:fs/promises";
+import { appendFile, type FileHandle, mkdir, open } from "node:fs/promises";
 import { dirname } from "node:path";
+import { createInterface } from "node:readline";
 import type { SessionEvent, SessionEventPayload } from "../types.js";
 
 export type AppendableEvent = SessionEventPayload & { turnId?: string };
 
+function isEnoent(error: unknown): boolean {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "code" in error &&
+    (error as { code: unknown }).code === "ENOENT"
+  );
+}
+
+function parseEventLine(line: string): SessionEvent | undefined {
+  const trimmed = line.trim();
+  if (trimmed === "") {
+    return undefined;
+  }
+  try {
+    return JSON.parse(trimmed) as SessionEvent;
+  } catch {
+    // Skip torn trailing writes from a crashed process.
+    return undefined;
+  }
+}
+
+async function readNdjsonEvents(
+  filePath: string,
+  onEvent: (event: SessionEvent) => void
+): Promise<void> {
+  let fh: FileHandle;
+  try {
+    fh = await open(filePath, "r");
+  } catch (error) {
+    if (isEnoent(error)) {
+      return;
+    }
+    throw error;
+  }
+  const stream = fh.createReadStream({ encoding: "utf8" });
+  const rl = createInterface({ input: stream, crlfDelay: Infinity });
+  try {
+    for await (const line of rl) {
+      const event = parseEventLine(line);
+      if (event !== undefined) {
+        onEvent(event);
+      }
+    }
+  } finally {
+    rl.close();
+    stream.destroy();
+    await fh.close().catch(() => {});
+  }
+}
+
 export class SessionEventLog {
-  private readonly events: SessionEvent[] = [];
+  private nextIndex = 0;
   private readonly listeners = new Set<(event: SessionEvent) => void>();
   private persistChain: Promise<void> = Promise.resolve();
+  /** Appended events whose `appendFile` has not finished. */
+  private readonly inflight: SessionEvent[] = [];
+  /**
+   * In-process patches (cloud cost backfill) that are not rewritten to
+   * `events.ndjson`. Applied on read.
+   */
+  private readonly replacements = new Map<number, SessionEvent>();
 
   private constructor(
     private readonly sessionId: string,
@@ -32,59 +95,52 @@ export class SessionEventLog {
       args.filePath,
       args.onPersistError ?? (() => {})
     );
-    await log.hydrate();
+    await log.readNextIndex();
     return log;
   }
 
-  private async hydrate(): Promise<void> {
-    let raw: string;
-    try {
-      raw = await readFile(this.filePath, "utf8");
-    } catch {
-      return;
-    }
-    for (const line of raw.split("\n")) {
-      if (line.trim() === "") {
-        continue;
+  private async readNextIndex(): Promise<void> {
+    let next = 0;
+    await readNdjsonEvents(this.filePath, (event) => {
+      if (typeof event.index === "number" && event.index >= next) {
+        next = event.index + 1;
       }
-      try {
-        this.events.push(JSON.parse(line) as SessionEvent);
-      } catch {
-        // Skip torn trailing writes from a crashed process.
-      }
-    }
+    });
+    this.nextIndex = next;
   }
 
   get count(): number {
-    return this.events.length;
+    return this.nextIndex;
   }
 
   /**
-   * In-process residency vs recorded length. Today those are the same
-   * (`events` is the cache). A later change can drop the cache and keep
-   * `eventsTotal` as the durable count while `eventsRetained` shrinks to
-   * the unflushed tail.
+   * In-process residency vs recorded length. `eventsTotal` is the durable
+   * count (`nextIndex`). `eventsRetained` is the unflushed tail — the
+   * transcript is not cached after `appendFile` lands.
    */
   memoryStats(): { eventsRetained: number; eventsTotal: number } {
-    const n = this.events.length;
-    return { eventsRetained: n, eventsTotal: n };
+    return {
+      eventsRetained: this.inflight.length,
+      eventsTotal: this.nextIndex,
+    };
   }
 
   /**
-   * Assign the next index, record the event, and fan out to live
-   * subscribers. Ordering is synchronous; file persistence is chained in
-   * the background and awaited by {@link flush}.
+   * Assign the next index and fan out to live subscribers. Ordering is
+   * synchronous; file persistence is chained in the background and awaited
+   * by {@link flush}. The event is not retained after the write lands.
    */
   append(payload: AppendableEvent): SessionEvent {
     const { turnId, ...rest } = payload;
     const event = {
-      index: this.events.length,
+      index: this.nextIndex,
       sessionId: this.sessionId,
       ...(turnId === undefined ? {} : { turnId }),
       at: new Date().toISOString(),
       ...rest,
     } as SessionEvent;
-    this.events.push(event);
+    this.nextIndex += 1;
+    this.inflight.push(event);
     for (const listener of [...this.listeners]) {
       try {
         listener(event);
@@ -93,35 +149,67 @@ export class SessionEventLog {
       }
     }
     const line = `${JSON.stringify(event)}\n`;
+    const index = event.index;
     this.persistChain = this.persistChain
       .then(() => appendFile(this.filePath, line, "utf8"))
+      .then(() => {
+        this.dropInflight(index);
+      })
       .catch((error) => this.onPersistError(error));
     return event;
   }
 
+  private dropInflight(index: number): void {
+    if (this.inflight[0]?.index === index) {
+      this.inflight.shift();
+      return;
+    }
+    const i = this.inflight.findIndex((event) => event.index === index);
+    if (i >= 0) {
+      this.inflight.splice(i, 1);
+    }
+  }
+
   /** Wait for pending file writes (used on close). */
   async flush(): Promise<void> {
     await this.persistChain;
   }
 
-  snapshot(startIndex = 0): SessionEvent[] {
-    return startIndex <= 0 ? [...this.events] : this.events.slice(startIndex);
+  /**
+   * Read recorded events from `startIndex`. Does not retain the result on
+   * the log; callers own the returned array.
+   */
+  async snapshot(startIndex = 0): Promise<SessionEvent[]> {
+    const byIndex = new Map<number, SessionEvent>();
+    await readNdjsonEvents(this.filePath, (event) => {
+      if (event.index >= startIndex) {
+        byIndex.set(event.index, event);
+      }
+    });
+    for (const event of this.inflight) {
+      if (event.index >= startIndex) {
+        byIndex.set(event.index, event);
+      }
+    }
+    for (const [index, event] of this.replacements) {
+      if (index >= startIndex) {
+        byIndex.set(index, event);
+      }
+    }
+    return [...byIndex.values()].sort((a, b) => a.index - b.index);
   }
 
   /**
-   * Replace one already-recorded event in memory. Used to backfill usage/cost
-   * onto historical `turn.completed` rows without rewriting `events.ndjson`.
-   * Live subscribers are not notified — patch before opening a replay stream.
+   * Replace one already-recorded event in this process. Used to backfill
+   * usage/cost onto historical `turn.completed` rows without rewriting
+   * `events.ndjson`. Live subscribers are not notified — patch before
+   * opening a replay stream.
    */
   replace(index: number, event: SessionEvent): boolean {
-    if (index < 0 || index >= this.events.length) {
+    if (index < 0 || index >= this.nextIndex || event.index !== index) {
       return false;
     }
-    const current = this.events[index];
-    if (current === undefined || current.index !== index) {
-      return false;
-    }
-    this.events[index] = event;
+    this.replacements.set(index, event);
     return true;
   }
 
@@ -135,12 +223,16 @@ export class SessionEventLog {
   /**
    * NDJSON stream: replays recorded events from `startIndex`, then follows
    * live events until the consumer cancels.
+   *
+   * Subscribe first (buffer live events), then read the file, then drain
+   * the buffer by index so an async file read cannot drop or duplicate
+   * events that arrive during catch-up.
    */
   stream(startIndex = 0): ReadableStream<Uint8Array> {
     const encoder = new TextEncoder();
     let unsubscribe: (() => void) | undefined;
     return new ReadableStream<Uint8Array>({
-      start: (controller) => {
+      start: async (controller) => {
         const push = (event: SessionEvent): void => {
           try {
             controller.enqueue(encoder.encode(`${JSON.stringify(event)}\n`));
@@ -148,15 +240,38 @@ export class SessionEventLog {
             unsubscribe?.();
           }
         };
-        // Synchronous snapshot + subscribe: no events can interleave.
-        for (const event of this.snapshot(startIndex)) {
-          push(event);
-        }
+        let following = false;
+        const buffered: SessionEvent[] = [];
         unsubscribe = this.subscribe((event) => {
-          if (event.index >= startIndex) {
+          if (event.index < startIndex) {
+            return;
+          }
+          if (following) {
             push(event);
+          } else {
+            buffered.push(event);
           }
         });
+        try {
+          const prefix = await this.snapshot(startIndex);
+          let maxSeen = startIndex - 1;
+          for (const event of prefix) {
+            push(event);
+            if (event.index > maxSeen) {
+              maxSeen = event.index;
+            }
+          }
+          following = true;
+          for (const event of buffered) {
+            if (event.index > maxSeen) {
+              push(event);
+              maxSeen = event.index;
+            }
+          }
+        } catch (error) {
+          unsubscribe?.();
+          controller.error(error);
+        }
       },
       cancel: () => {
         unsubscribe?.();

package/src/internal/session-engine.ts

@@ -3014,7 +3014,7 @@ export class SessionEngine {
 
   private async runCloudTurnCostBackfill(sessionId: string): Promise<void> {
     const log = await this.logs.get(sessionId);
-    const events = log.snapshot(0);
+    const events = await log.snapshot(0);
     if (!events.some((event) => isUnpricedCompletedTurn(event))) {
       if (
         !this.isTurnRunning(sessionId) &&
@@ -3049,7 +3049,9 @@ export class SessionEngine {
       }
       log.replace(i, next);
     }
-    if (!log.snapshot(0).some((event) => isUnpricedCompletedTurn(event))) {
+    if (
+      !(await log.snapshot(0)).some((event) => isUnpricedCompletedTurn(event))
+    ) {
       this.cloudCostBackfillDone.add(sessionId);
     }
   }

package/src/internal/slack-provision-client.ts

@@ -55,8 +55,8 @@ export type SlackAppIconInput =
  * Outcome of `POST /apps`. Credentials are returned exactly once and never
  * persisted server-side — the caller owns storing them. `appToken` can be
  * absent when Slack's install response omitted the app-level token.
- * `oauthAuthorizeUrl` is only minted on a fresh app create, so an update
- * that lands in admin approval omits it.
+ * `oauthAuthorizeUrl` is Slack's request-approval / reminder page. Fresh
+ * creates mint it; updates return it when Slack (or a persisted row) has one.
  */
 export type SlackAppProvisionResult =
   | {
@@ -176,6 +176,66 @@ const setIconResponseSchema = z
   })
   .passthrough();
 
+const mintWizardResponseSchema = z
+  .object({
+    wizardId: z.string().min(1),
+    url: z.string().min(1),
+  })
+  .passthrough();
+
+const wizardPollResponseSchema = z
+  .object({
+    wizardId: z.string(),
+    teamId: z.number(),
+    slug: z.string(),
+    env: z.string(),
+    status: z.string(),
+    appId: z.string().optional(),
+    oauthAuthorizeUrl: z.string().optional(),
+    error: z.string().optional(),
+    localEnv: z
+      .object({
+        botToken: z.string().min(1),
+        appToken: z.string().optional(),
+      })
+      .optional(),
+    localEnvClaimed: z.boolean().optional(),
+  })
+  .passthrough();
+
+export interface SlackWizardMintResult {
+  wizardId: string;
+  url: string;
+}
+
+export interface SlackWizardPollResult {
+  wizardId: string;
+  teamId: number;
+  slug: string;
+  env: string;
+  status: string;
+  appId?: string;
+  oauthAuthorizeUrl?: string;
+  error?: string;
+  localEnv?: { botToken: string; appToken?: string };
+  localEnvClaimed?: boolean;
+}
+
+export interface SlackWizardMintInput {
+  teamId: number;
+  slug: string;
+  env: SlackAppEnv;
+  envPrefix?: string;
+  name?: string;
+  gitRepoUrl?: string;
+  gitRef?: string;
+  agentPath?: string;
+  channelPosts?: boolean;
+  slackTeamId?: string;
+  iconUrl?: string;
+  force?: boolean;
+}
+
 // ============================================================================
 // Client
 // ============================================================================
@@ -224,6 +284,27 @@ export class AgentServeSlackClient {
     return connectResponseSchema.parse(raw).url;
   }
 
+  async mintWizard(
+    input: SlackWizardMintInput
+  ): Promise<SlackWizardMintResult> {
+    const raw = await this.request({
+      method: "POST",
+      path: "/internal/agent-serve/slack/wizard",
+      body: input,
+      context: { verb: "start Slack setup" },
+    });
+    return mintWizardResponseSchema.parse(raw);
+  }
+
+  async pollWizard(wizardId: string): Promise<SlackWizardPollResult> {
+    const raw = await this.request({
+      method: "GET",
+      path: `/internal/agent-serve/slack/wizard/${encodeURIComponent(wizardId)}`,
+      context: { verb: "poll Slack setup" },
+    });
+    return wizardPollResponseSchema.parse(raw);
+  }
+
   /**
    * Provision (create or update) and install one managed Slack app for
    * (slackTeamId, slug, env). Expected failures throw