experimental-a2 0.21.1 → 0.22.0

package/examples/playground/app/a0/sandbox.ts

@@ -68,6 +68,7 @@ async function openApp(appId: string): Promise<Sandbox> {
       persistent: true,
       snapshotExpiration: SNAPSHOT_EXPIRATION_MS,
       keepLastSnapshots: { count: 1 },
+      onResume: startDev,
     })
   } catch (error) {
     // Another instance created it first. The API holds a racing create until
@@ -81,8 +82,54 @@ async function openApp(appId: string): Promise<Sandbox> {
   return sandbox
 }
 
-// Parallel tool calls on a new app share one create within this instance.
-const opening = new Map<string, Promise<Sandbox>>()
+// Each instance keeps one handle per app, so parallel tool calls share an
+// open and later ones skip the lookup. A handle resumes a stopped session on
+// its next call; a deleted sandbox fails with a 404 until it's forgotten.
+// An empty app's idle check deletes its sandbox from whichever instance runs
+// it, 10 minutes after the sandbox opened. By then the session's 15 minutes
+// leave less than KEEP_ALIVE_MS, so every call extends it, and the extension's
+// 404 is how a kept handle finds out.
+const handles = new Map<string, Promise<Sandbox>>()
+const MAX_HANDLES = 100
+
+const forget = (appId: string): void => {
+  handles.delete(appId)
+}
+
+const open = (appId: string): Promise<Sandbox> => {
+  const opened = openApp(appId)
+  opened.catch(() => {
+    if (handles.get(appId) === opened) forget(appId)
+  })
+  return opened
+}
+
+const kept = (appId: string): Promise<Sandbox> => {
+  const pending = handles.get(appId) ?? open(appId)
+  // Most recently used last, so the cap drops the stalest.
+  handles.delete(appId)
+  handles.set(appId, pending)
+  const stalest = handles.keys().next().value
+  if (handles.size > MAX_HANDLES && stalest !== undefined) forget(stalest)
+  return pending
+}
+
+/**
+ * Whether the sandbox is still there. Extends it only by the shortfall, so
+ * repeated calls never stack up time.
+ */
+const keepAlive = async (sandbox: Sandbox): Promise<boolean> => {
+  const shortfall =
+    Date.now() + KEEP_ALIVE_MS - (sandbox.expiresAt?.getTime() ?? 0)
+  if (shortfall <= 0) return true
+  try {
+    await sandbox.extendTimeout(shortfall)
+  } catch (error) {
+    // Throws past the plan's session limit; the sandbox still works until then.
+    return !notFound(error)
+  }
+  return true
+}
 
 /** The app's sandbox, created or resumed, and kept up while it's used. */
 export async function appSandbox({
@@ -90,16 +137,13 @@ export async function appSandbox({
 }: {
   appId: string
 }): Promise<Sandbox> {
-  const pending =
-    opening.get(appId) ?? openApp(appId).finally(() => opening.delete(appId))
-  opening.set(appId, pending)
+  const pending = kept(appId)
   const sandbox = await pending
-  // Extends only by the shortfall, so repeated calls never stack up time.
-  const shortfall =
-    Date.now() + KEEP_ALIVE_MS - (sandbox.expiresAt?.getTime() ?? 0)
-  // Throws past the plan's session limit; the sandbox still works until then.
-  if (shortfall > 0) await sandbox.extendTimeout(shortfall).catch(() => {})
-  return sandbox
+  if (await keepAlive(sandbox)) return sandbox
+  if (handles.get(appId) === pending) forget(appId)
+  const reopened = await kept(appId)
+  await keepAlive(reopened)
+  return reopened
 }
 
 // A server that's booting refuses connections for a moment, and a page
@@ -118,12 +162,12 @@ export async function ensureApp({
   appId: string
 }): Promise<{ up: boolean; createdAt: Date }> {
   const sandbox = await appSandbox({ appId })
-  const probe = await sandbox.runCommand({
+  const answer = await sandbox.runCommand({
     cmd: 'bash',
     args: ['-c', `${START_DEV}; ${PROBE}`],
   })
   return {
-    up: Number(await probe.stdout()) > 0,
+    up: Number(await answer.stdout()) > 0,
     createdAt: sandbox.createdAt,
   }
 }
@@ -145,6 +189,7 @@ export async function deleteAppSandbox({
 }: {
   appId: string
 }): Promise<void> {
+  forget(appId)
   try {
     const sandbox = await Sandbox.get({
       name: sandboxName(appId),

package/examples/playground/app/a2slack/db/a2.ts

@@ -7,9 +7,9 @@
  * your schema.
  *
  * Whatever creates them, A2 relies on the table and column names, the column
- * types, the primary keys, and the unique index on a2_events.event_id. The
- * other indexes keep its queries fast. Every name is spelled out, so Drizzle's
- * `casing` setting changes none of them.
+ * types, the primary keys, and the unique index on a2_events (session_id,
+ * event_id). The other indexes keep its queries fast. Every name is spelled
+ * out, so Drizzle's `casing` setting changes none of them.
  *
  * A2's tables change only when a release's changelog says so; compare your
  * copy with that release's file. Drizzle can't declare functions or
@@ -48,7 +48,10 @@ export const a2Events = pgTable(
       name: 'a2_events_pkey',
       columns: [table.sessionId, table.idx],
     }),
-    uniqueIndex('a2_events_event_id').on(table.eventId),
+    uniqueIndex('a2_events_session_event_id').on(
+      table.sessionId,
+      table.eventId,
+    ),
     index('a2_events_types').on(table.sessionId, table.eventType, table.idx),
   ],
 )

package/examples/playground/app/a2slack/db/migrations/0004_a2_session_event_ids.sql

@@ -0,0 +1,2 @@
+CREATE UNIQUE INDEX "a2_events_session_event_id" ON "a2_events" USING btree ("session_id","event_id");--> statement-breakpoint
+DROP INDEX "a2_events_event_id";