add custom code

Author: mertcelebi

src/client.ts

@@ -32,6 +32,7 @@ import { Browser, BrowserCreateSessionResponse } from './resources/browser';
 import { readEnv } from './internal/utils/env';
 import { formatRequestDetails, loggerFor } from './internal/utils/log';
 import { isEmptyObj } from './internal/utils/values';
+import { KernelApp, appRegistry, browsers as appBrowsers } from './core/app-framework';
 
 export interface ClientOptions {
   /**
@@ -480,7 +481,7 @@ export class Kernel {
 
     const isReadableBody =
       ((globalThis as any).ReadableStream && options.body instanceof (globalThis as any).ReadableStream) ||
-      (typeof options.body === 'object' && options.body !== null && Symbol.asyncIterator in options.body);
+      (typeof options.body === 'object' && options.body !== null && Symbol.asyncIterator in options.body));
 
     const fetchOptions: RequestInit = {
       signal: controller.signal as any,
@@ -680,6 +681,14 @@ export class Kernel {
     }
   }
 
+  public app(name: string): KernelApp {
+    return new KernelApp(name);
+  }
+
+  public static exportRegistry(entrypointRelpath: string): string {
+    return appRegistry.exportJSON(entrypointRelpath);
+  }
+
   static Kernel = this;
   static DEFAULT_TIMEOUT = 60000; // 1 minute
 
@@ -701,9 +710,11 @@ export class Kernel {
 
   apps: API.Apps = new API.Apps(this);
   browser: API.Browser = new API.Browser(this);
+  appFrameworkBrowsers = appBrowsers;
 }
 Kernel.Apps = Apps;
 Kernel.Browser = Browser;
+Kernel.exportRegistry = (entrypointRelpath: string) => appRegistry.exportJSON(entrypointRelpath);
 export declare namespace Kernel {
   export type RequestOptions = Opts.RequestOptions;
 

src/core/app-framework.ts

@@ -0,0 +1,160 @@
+// Type definitions for browser
+export interface Browser {
+  cdp_ws_url: string;
+}
+
+// Context definition
+export interface KernelContext {
+  invocationId: string;
+}
+
+// Action definition
+export interface KernelAction {
+  name: string;
+  handler: (context: KernelContext, input: any) => Promise<any>;
+}
+
+export interface KernelJson {
+  entrypoint: string;
+  apps: KernelAppJson[];
+}
+
+export interface KernelAppJson {
+  name: string;
+  actions: KernelActionJson[];
+}
+
+export interface KernelActionJson {
+  name: string;
+}
+
+// App definition
+export class KernelApp {
+  name: string;
+  actions: Map<string, KernelAction> = new Map();
+
+  constructor(name: string) {
+    this.name = name;
+    // Register this app in the global registry
+    appRegistry.registerApp(this);
+  }
+
+  /**
+   * Define an action
+   */
+  action<T, R>(
+    nameOrHandler:
+      | string
+      | ((input: T) => Promise<R>)
+      | ((context: KernelContext, input: T) => Promise<R>),
+    handler?: ((input: T) => Promise<R>) | ((context: KernelContext, input: T) => Promise<R>),
+  ) {
+    let actionName: string;
+    let actionHandler: (context: KernelContext, input: T) => Promise<R>;
+
+    if (typeof nameOrHandler === 'string' && handler) {
+      // Case: app.action("name", handler)
+      actionName = nameOrHandler;
+
+      // Create a handler that accepts context and input, adapting if needed
+      if (handler.length === 1) {
+        // Original handler only takes input, so we adapt it to the new signature
+        const singleArgHandler = handler as (input: T) => Promise<R>;
+        actionHandler = async (context: KernelContext, input: T) => singleArgHandler(input);
+      } else {
+        // Handler takes both context and input
+        actionHandler = handler as (context: KernelContext, input: T) => Promise<R>;
+      }
+    } else if (typeof nameOrHandler === 'function') {
+      // Case: app.action(handler)
+      actionName = nameOrHandler.name || 'default';
+
+      // Create a handler that accepts context and input, adapting if needed
+      if (nameOrHandler.length === 1) {
+        // Original handler only takes input, so we adapt it to the new signature
+        const singleArgHandler = nameOrHandler as (input: T) => Promise<R>;
+        actionHandler = async (context: KernelContext, input: T) => singleArgHandler(input);
+      } else {
+        // Handler takes both context and input
+        actionHandler = nameOrHandler as (context: KernelContext, input: T) => Promise<R>;
+      }
+    } else {
+      throw new Error('Invalid action definition');
+    }
+
+    // Register the action
+    this.actions.set(actionName, {
+      name: actionName,
+      handler: actionHandler,
+    });
+
+    return actionHandler;
+  }
+
+  /**
+   * Get all actions for this app
+   */
+  getActions(): KernelAction[] {
+    return Array.from(this.actions.values());
+  }
+
+  /**
+   * Get an action by name
+   */
+  getAction(name: string): KernelAction | undefined {
+    return this.actions.get(name);
+  }
+
+  /**
+   * Export app information without handlers
+   */
+  toJSON(): KernelAppJson {
+    return {
+      name: this.name,
+      actions: this.getActions().map((action) => ({
+        name: action.name,
+      })),
+    };
+  }
+}
+
+// Registry for storing all Kernel apps
+class KernelAppRegistry {
+  private apps: Map<string, KernelApp> = new Map();
+
+  registerApp(app: KernelApp): void {
+    this.apps.set(app.name, app);
+  }
+
+  getApps(): KernelApp[] {
+    return Array.from(this.apps.values());
+  }
+
+  getAppByName(name: string): KernelApp | undefined {
+    return this.apps.get(name);
+  }
+
+  /**
+   * Export the registry as JSON
+   */
+  exportJSON(entrypointRelpath: string): string {
+    const apps = this.getApps().map((app) => app.toJSON());
+    return JSON.stringify({ apps, entrypoint: entrypointRelpath } as KernelJson, null, 2);
+  }
+}
+
+// Create a singleton registry for apps
+export const appRegistry = new KernelAppRegistry();
+
+// Browser management module
+export const browsers = {
+  /**
+   * Create a new browser instance
+   */
+  create: async ({ invocationId }: { invocationId: string }): Promise<Browser> => {
+    return {
+      cdp_ws_url:
+        'wss://floral-morning-3s0r8t7x.iad-prod-apiukp-0.onkernel.app:9222/devtools/browser/4dc1cbf6-be0e-4612-bba3-8e399d9638c7',
+    };
+  },
+};