Separate deploy entrypoints from local runners and share lifecycle logging helpers.

rgarcia · rgarcia · commit 3f99e7f42d90 · 2026-03-11T22:47:11.000-04:00
Remove direct-run fallbacks from deployable app entrypoints and centralize duplicated browser lifecycle backend/session event emission in reusable Python and TypeScript logging helpers.

Made-with: Cursor
diff --git a/pkg/templates/python/openai-computer-use/agent/logging.py b/pkg/templates/python/openai-computer-use/agent/logging.py
@@ -283,3 +283,54 @@ def render_text(event: dict) -> None:
             sys.stderr.flush()
 
     return render_text
+
+
+def emit_browser_new_started(on_event: Callable[[dict], None]) -> None:
+    on_event({"event": "backend", "data": {"op": "browsers.new"}})
+
+
+def emit_browser_new_done(
+    on_event: Callable[[dict], None], started_at: datetime, live_view_url: str | None
+) -> None:
+    on_event(
+        {
+            "event": "backend",
+            "data": {
+                "op": "browsers.new.done",
+                "detail": live_view_url or "",
+                "elapsed_ms": int((datetime.now() - started_at).total_seconds() * 1000),
+            },
+        }
+    )
+
+
+def emit_session_state(
+    on_event: Callable[[dict], None], session_id: str, live_view_url: str | None
+) -> None:
+    on_event(
+        {
+            "event": "session_state",
+            "data": {
+                "session_id": session_id,
+                "live_view_url": live_view_url or "",
+            },
+        }
+    )
+
+
+def emit_browser_delete_started(on_event: Callable[[dict], None]) -> None:
+    on_event({"event": "backend", "data": {"op": "browsers.delete"}})
+
+
+def emit_browser_delete_done(
+    on_event: Callable[[dict], None], started_at: datetime
+) -> None:
+    on_event(
+        {
+            "event": "backend",
+            "data": {
+                "op": "browsers.delete.done",
+                "elapsed_ms": int((datetime.now() - started_at).total_seconds() * 1000),
+            },
+        }
+    )
diff --git a/pkg/templates/python/openai-computer-use/main.py b/pkg/templates/python/openai-computer-use/main.py
@@ -1,13 +1,18 @@
 import asyncio
 import datetime
 import os
-import subprocess
-import sys
 from typing import NotRequired, TypedDict
 
 import kernel
 from agent import Agent
-from agent.logging import create_event_logger
+from agent.logging import (
+    create_event_logger,
+    emit_browser_delete_done,
+    emit_browser_delete_started,
+    emit_browser_new_done,
+    emit_browser_new_started,
+    emit_session_state,
+)
 from computers.kernel_computer import KernelComputer
 from kernel import Kernel
 
@@ -56,31 +61,15 @@ async def cua_task(
     on_event = create_event_logger(output=output_mode)
 
     browser_create_started_at = datetime.datetime.now()
-    on_event({"event": "backend", "data": {"op": "browsers.new"}})
+    emit_browser_new_started(on_event)
     kernel_browser = await asyncio.to_thread(
         client.browsers.create, invocation_id=ctx.invocation_id, stealth=True
     )
-    on_event(
-        {
-            "event": "backend",
-            "data": {
-                "op": "browsers.new.done",
-                "detail": kernel_browser.browser_live_view_url or "",
-                "elapsed_ms": int(
-                    (datetime.datetime.now() - browser_create_started_at).total_seconds()
-                    * 1000
-                ),
-            },
-        }
+    emit_browser_new_done(
+        on_event, browser_create_started_at, kernel_browser.browser_live_view_url
     )
-    on_event(
-        {
-            "event": "session_state",
-            "data": {
-                "session_id": kernel_browser.session_id,
-                "live_view_url": kernel_browser.browser_live_view_url or "",
-            },
-        }
+    emit_session_state(
+        on_event, kernel_browser.session_id, kernel_browser.browser_live_view_url
     )
 
     def run_agent():
@@ -133,26 +122,10 @@ def run_agent():
         return await asyncio.to_thread(run_agent)
     finally:
         browser_delete_started_at = datetime.datetime.now()
-        on_event({"event": "backend", "data": {"op": "browsers.delete"}})
+        emit_browser_delete_started(on_event)
         try:
             await asyncio.to_thread(client.browsers.delete_by_id, kernel_browser.session_id)
         finally:
-            on_event(
-                {
-                    "event": "backend",
-                    "data": {
-                        "op": "browsers.delete.done",
-                        "elapsed_ms": int(
-                            (datetime.datetime.now() - browser_delete_started_at).total_seconds()
-                            * 1000
-                        ),
-                    },
-                }
-            )
-
-
-if __name__ == "__main__":
-    # `main.py` is the deployable Kernel app entrypoint.
-    # For local execution, forward to the existing local harness.
-    command = [sys.executable, "run_local.py", *sys.argv[1:]]
-    raise SystemExit(subprocess.call(command))
+            emit_browser_delete_done(on_event, browser_delete_started_at)
+
+
diff --git a/pkg/templates/python/openai-computer-use/run_local.py b/pkg/templates/python/openai-computer-use/run_local.py
@@ -16,7 +16,14 @@
 
 from kernel import Kernel
 from agent import Agent
-from agent.logging import create_event_logger
+from agent.logging import (
+    create_event_logger,
+    emit_browser_delete_done,
+    emit_browser_delete_started,
+    emit_browser_new_done,
+    emit_browser_new_started,
+    emit_session_state,
+)
 from computers.kernel_computer import KernelComputer
 
 
@@ -47,30 +54,12 @@ def main():
     on_event = create_event_logger(output=args.output, verbose=args.debug)
 
     browser_create_started_at = datetime.datetime.now()
-    on_event({"event": "backend", "data": {"op": "browsers.new"}})
+    emit_browser_new_started(on_event)
     browser = client.browsers.create(timeout_seconds=300)
-    on_event(
-        {
-            "event": "backend",
-            "data": {
-                "op": "browsers.new.done",
-                "detail": browser.browser_live_view_url or "",
-                "elapsed_ms": int(
-                    (datetime.datetime.now() - browser_create_started_at).total_seconds()
-                    * 1000
-                ),
-            },
-        }
-    )
-    on_event(
-        {
-            "event": "session_state",
-            "data": {
-                "session_id": browser.session_id,
-                "live_view_url": browser.browser_live_view_url or "",
-            },
-        }
+    emit_browser_new_done(
+        on_event, browser_create_started_at, browser.browser_live_view_url
     )
+    emit_session_state(on_event, browser.session_id, browser.browser_live_view_url)
 
     computer = KernelComputer(client, browser.session_id, on_event=on_event)
 
@@ -108,22 +97,11 @@ def main():
             raise ValueError("No response from agent")
     finally:
         browser_delete_started_at = datetime.datetime.now()
-        on_event({"event": "backend", "data": {"op": "browsers.delete"}})
+        emit_browser_delete_started(on_event)
         try:
             client.browsers.delete_by_id(browser.session_id)
         finally:
-            on_event(
-                {
-                    "event": "backend",
-                    "data": {
-                        "op": "browsers.delete.done",
-                        "elapsed_ms": int(
-                            (datetime.datetime.now() - browser_delete_started_at).total_seconds()
-                            * 1000
-                        ),
-                    },
-                }
-            )
+            emit_browser_delete_done(on_event, browser_delete_started_at)
         print("> Browser session deleted")
 
 
diff --git a/pkg/templates/typescript/openai-computer-use/index.ts b/pkg/templates/typescript/openai-computer-use/index.ts
@@ -1,11 +1,16 @@
 import { Kernel, type KernelContext } from '@onkernel/sdk';
 import * as dotenv from 'dotenv';
-import { resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
 import type { ResponseItem, ResponseOutputMessage } from 'openai/resources/responses/responses';
 import { Agent } from './lib/agent';
 import { KernelComputer } from './lib/kernel-computer';
-import { createEventLogger } from './lib/logging';
+import {
+  createEventLogger,
+  emitBrowserDeleteDone,
+  emitBrowserDeleteStarted,
+  emitBrowserNewDone,
+  emitBrowserNewStarted,
+  emitSessionState,
+} from './lib/logging';
 import type { OutputMode } from './lib/log-events';
 
 dotenv.config({ override: true, quiet: true });
@@ -48,21 +53,11 @@ app.action<CuaInput, CuaOutput>(
     const outputMode: OutputMode = payload.output === 'jsonl' ? 'jsonl' : 'text';
     const onEvent = createEventLogger({ output: outputMode });
 
-    onEvent({ event: 'backend', data: { op: 'browsers.new' } });
+    emitBrowserNewStarted(onEvent);
     const browserCreateStartedAt = Date.now();
     const kb = await kernel.browsers.create({ invocation_id: ctx.invocation_id });
-    onEvent({
-      event: 'backend',
-      data: {
-        op: 'browsers.new.done',
-        detail: kb.browser_live_view_url ?? '',
-        elapsed_ms: Date.now() - browserCreateStartedAt,
-      },
-    });
-    onEvent({
-      event: 'session_state',
-      data: { session_id: kb.session_id, live_view_url: kb.browser_live_view_url ?? '' },
-    });
+    emitBrowserNewDone(onEvent, browserCreateStartedAt, kb.browser_live_view_url);
+    emitSessionState(onEvent, kb.session_id, kb.browser_live_view_url);
 
     const computer = new KernelComputer(kernel, kb.session_id, onEvent);
 
@@ -119,34 +114,13 @@ app.action<CuaInput, CuaOutput>(
       console.error('Error in cua-task:', error);
       return { elapsed, answer: null };
     } finally {
-      onEvent({ event: 'backend', data: { op: 'browsers.delete' } });
+      emitBrowserDeleteStarted(onEvent);
       const browserDeleteStartedAt = Date.now();
       try {
         await kernel.browsers.deleteByID(kb.session_id);
       } finally {
-        onEvent({
-          event: 'backend',
-          data: {
-            op: 'browsers.delete.done',
-            elapsed_ms: Date.now() - browserDeleteStartedAt,
-          },
-        });
+        emitBrowserDeleteDone(onEvent, browserDeleteStartedAt);
       }
     }
   },
 );
-
-function isDirectRun(): boolean {
-  const entry = process.argv[1];
-  if (!entry) return false;
-  return resolve(entry) === resolve(fileURLToPath(import.meta.url));
-}
-
-if (isDirectRun()) {
-  void import('./run_local')
-    .then(({ runLocalTest }) => runLocalTest(process.argv.slice(2)))
-    .catch((error: unknown) => {
-      console.error(error);
-      process.exit(1);
-    });
-}
diff --git a/pkg/templates/typescript/openai-computer-use/lib/logging.ts b/pkg/templates/typescript/openai-computer-use/lib/logging.ts
@@ -25,6 +25,53 @@ function formatKernelOp(op: string): string {
   return `${op}()`;
 }
 
+export function emitBrowserNewStarted(onEvent: (event: AgentEvent) => void): void {
+  onEvent({ event: 'backend', data: { op: 'browsers.new' } });
+}
+
+export function emitBrowserNewDone(
+  onEvent: (event: AgentEvent) => void,
+  startedAtMs: number,
+  liveViewUrl?: string | null,
+): void {
+  onEvent({
+    event: 'backend',
+    data: {
+      op: 'browsers.new.done',
+      detail: liveViewUrl ?? '',
+      elapsed_ms: Date.now() - startedAtMs,
+    },
+  });
+}
+
+export function emitSessionState(
+  onEvent: (event: AgentEvent) => void,
+  sessionId: string,
+  liveViewUrl?: string | null,
+): void {
+  onEvent({
+    event: 'session_state',
+    data: { session_id: sessionId, live_view_url: liveViewUrl ?? '' },
+  });
+}
+
+export function emitBrowserDeleteStarted(onEvent: (event: AgentEvent) => void): void {
+  onEvent({ event: 'backend', data: { op: 'browsers.delete' } });
+}
+
+export function emitBrowserDeleteDone(
+  onEvent: (event: AgentEvent) => void,
+  startedAtMs: number,
+): void {
+  onEvent({
+    event: 'backend',
+    data: {
+      op: 'browsers.delete.done',
+      elapsed_ms: Date.now() - startedAtMs,
+    },
+  });
+}
+
 class ThinkingSpinner {
   private active = false;
   private timer: NodeJS.Timeout | null = null;
diff --git a/pkg/templates/typescript/openai-computer-use/run_local.ts b/pkg/templates/typescript/openai-computer-use/run_local.ts
