@ricsam/isolate-daemon 0.0.1 → 0.1.0

package/dist/mjs/index.mjs

@@ -0,0 +1,101 @@
+// @bun
+// packages/isolate-daemon/src/index.ts
+import { createServer } from "net";
+import { unlink } from "fs/promises";
+import { handleConnection } from "./connection.mjs";
+var DEFAULT_OPTIONS = {
+  socketPath: "/tmp/isolate-daemon.sock",
+  host: "127.0.0.1",
+  port: 47891,
+  maxIsolates: 100,
+  defaultMemoryLimit: 128
+};
+async function startDaemon(options = {}) {
+  const resolvedOptions = {
+    ...DEFAULT_OPTIONS,
+    ...options
+  };
+  const state = {
+    isolates: new Map,
+    connections: new Map,
+    stats: {
+      activeIsolates: 0,
+      activeConnections: 0,
+      totalIsolatesCreated: 0,
+      totalRequestsProcessed: 0
+    },
+    options: resolvedOptions
+  };
+  const server = createServer((socket) => {
+    handleConnection(socket, state);
+    updateStats(state);
+  });
+  if (resolvedOptions.socketPath) {
+    try {
+      await unlink(resolvedOptions.socketPath);
+    } catch {}
+  }
+  await new Promise((resolve, reject) => {
+    server.on("error", reject);
+    if (resolvedOptions.socketPath) {
+      server.listen(resolvedOptions.socketPath, () => {
+        server.removeListener("error", reject);
+        resolve();
+      });
+    } else {
+      server.listen(resolvedOptions.port, resolvedOptions.host, () => {
+        server.removeListener("error", reject);
+        resolve();
+      });
+    }
+  });
+  const address = resolvedOptions.socketPath ? resolvedOptions.socketPath : `${resolvedOptions.host}:${resolvedOptions.port}`;
+  console.log(`Isolate daemon listening on ${address}`);
+  return {
+    address,
+    getStats: () => ({
+      ...state.stats,
+      activeIsolates: state.isolates.size,
+      activeConnections: state.connections.size
+    }),
+    close: async () => {
+      for (const [socket] of state.connections) {
+        socket.destroy();
+      }
+      for (const [, instance] of state.isolates) {
+        try {
+          instance.runtime.dispose();
+        } catch {}
+      }
+      state.isolates.clear();
+      state.connections.clear();
+      await closeServer(server);
+      if (resolvedOptions.socketPath) {
+        try {
+          await unlink(resolvedOptions.socketPath);
+        } catch {}
+      }
+      console.log("Isolate daemon stopped");
+    }
+  };
+}
+function closeServer(server) {
+  return new Promise((resolve, reject) => {
+    server.close((err) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve();
+      }
+    });
+  });
+}
+function updateStats(state) {
+  state.stats.activeIsolates = state.isolates.size;
+  state.stats.activeConnections = state.connections.size;
+}
+export {
+  startDaemon
+};
+
+//# debugId=FCA8B2807BBD0FBF64756E2164756E21

package/dist/mjs/index.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts"],
+  "sourcesContent": [
+    "/**\n * @ricsam/isolate-daemon\n *\n * Node.js daemon for running isolated-vm runtimes accessible via IPC.\n */\n\nimport { createServer, type Server } from \"node:net\";\nimport { unlink } from \"node:fs/promises\";\nimport { handleConnection } from \"./connection.mjs\";\nimport type {\n  DaemonOptions,\n  DaemonHandle,\n  DaemonState,\n  DaemonStats,\n} from \"./types.mjs\";\n\nexport type { DaemonOptions, DaemonHandle, DaemonStats };\n\nconst DEFAULT_OPTIONS: Required<DaemonOptions> = {\n  socketPath: \"/tmp/isolate-daemon.sock\",\n  host: \"127.0.0.1\",\n  port: 47891,\n  maxIsolates: 100,\n  defaultMemoryLimit: 128,\n};\n\n/**\n * Start the isolate daemon.\n *\n * @param options - Daemon configuration options\n * @returns Handle to control the daemon\n */\nexport async function startDaemon(\n  options: DaemonOptions = {}\n): Promise<DaemonHandle> {\n  const resolvedOptions: Required<DaemonOptions> = {\n    ...DEFAULT_OPTIONS,\n    ...options,\n  };\n\n  const state: DaemonState = {\n    isolates: new Map(),\n    connections: new Map(),\n    stats: {\n      activeIsolates: 0,\n      activeConnections: 0,\n      totalIsolatesCreated: 0,\n      totalRequestsProcessed: 0,\n    },\n    options: resolvedOptions,\n  };\n\n  const server = createServer((socket) => {\n    handleConnection(socket, state);\n    updateStats(state);\n  });\n\n  // Try to remove existing socket file\n  if (resolvedOptions.socketPath) {\n    try {\n      await unlink(resolvedOptions.socketPath);\n    } catch {\n      // Ignore if doesn't exist\n    }\n  }\n\n  // Start listening\n  await new Promise<void>((resolve, reject) => {\n    server.on(\"error\", reject);\n\n    if (resolvedOptions.socketPath) {\n      server.listen(resolvedOptions.socketPath, () => {\n        server.removeListener(\"error\", reject);\n        resolve();\n      });\n    } else {\n      server.listen(resolvedOptions.port, resolvedOptions.host, () => {\n        server.removeListener(\"error\", reject);\n        resolve();\n      });\n    }\n  });\n\n  const address = resolvedOptions.socketPath\n    ? resolvedOptions.socketPath\n    : `${resolvedOptions.host}:${resolvedOptions.port}`;\n\n  console.log(`Isolate daemon listening on ${address}`);\n\n  return {\n    address,\n    getStats: () => ({\n      ...state.stats,\n      activeIsolates: state.isolates.size,\n      activeConnections: state.connections.size,\n    }),\n    close: async () => {\n      // Close all connections\n      for (const [socket] of state.connections) {\n        socket.destroy();\n      }\n\n      // Dispose all isolates\n      for (const [, instance] of state.isolates) {\n        try {\n          instance.runtime.dispose();\n        } catch {\n          // Ignore\n        }\n      }\n\n      state.isolates.clear();\n      state.connections.clear();\n\n      // Close server\n      await closeServer(server);\n\n      // Remove socket file\n      if (resolvedOptions.socketPath) {\n        try {\n          await unlink(resolvedOptions.socketPath);\n        } catch {\n          // Ignore\n        }\n      }\n\n      console.log(\"Isolate daemon stopped\");\n    },\n  };\n}\n\nfunction closeServer(server: Server): Promise<void> {\n  return new Promise((resolve, reject) => {\n    server.close((err) => {\n      if (err) {\n        reject(err);\n      } else {\n        resolve();\n      }\n    });\n  });\n}\n\nfunction updateStats(state: DaemonState): void {\n  state.stats.activeIsolates = state.isolates.size;\n  state.stats.activeConnections = state.connections.size;\n}\n"
+  ],
+  "mappings": ";;AAMA;AACA;AACA;AAUA,IAAM,kBAA2C;AAAA,EAC/C,YAAY;AAAA,EACZ,MAAM;AAAA,EACN,MAAM;AAAA,EACN,aAAa;AAAA,EACb,oBAAoB;AACtB;AAQA,eAAsB,WAAW,CAC/B,UAAyB,CAAC,GACH;AAAA,EACvB,MAAM,kBAA2C;AAAA,OAC5C;AAAA,OACA;AAAA,EACL;AAAA,EAEA,MAAM,QAAqB;AAAA,IACzB,UAAU,IAAI;AAAA,IACd,aAAa,IAAI;AAAA,IACjB,OAAO;AAAA,MACL,gBAAgB;AAAA,MAChB,mBAAmB;AAAA,MACnB,sBAAsB;AAAA,MACtB,wBAAwB;AAAA,IAC1B;AAAA,IACA,SAAS;AAAA,EACX;AAAA,EAEA,MAAM,SAAS,aAAa,CAAC,WAAW;AAAA,IACtC,iBAAiB,QAAQ,KAAK;AAAA,IAC9B,YAAY,KAAK;AAAA,GAClB;AAAA,EAGD,IAAI,gBAAgB,YAAY;AAAA,IAC9B,IAAI;AAAA,MACF,MAAM,OAAO,gBAAgB,UAAU;AAAA,MACvC,MAAM;AAAA,EAGV;AAAA,EAGA,MAAM,IAAI,QAAc,CAAC,SAAS,WAAW;AAAA,IAC3C,OAAO,GAAG,SAAS,MAAM;AAAA,IAEzB,IAAI,gBAAgB,YAAY;AAAA,MAC9B,OAAO,OAAO,gBAAgB,YAAY,MAAM;AAAA,QAC9C,OAAO,eAAe,SAAS,MAAM;AAAA,QACrC,QAAQ;AAAA,OACT;AAAA,IACH,EAAO;AAAA,MACL,OAAO,OAAO,gBAAgB,MAAM,gBAAgB,MAAM,MAAM;AAAA,QAC9D,OAAO,eAAe,SAAS,MAAM;AAAA,QACrC,QAAQ;AAAA,OACT;AAAA;AAAA,GAEJ;AAAA,EAED,MAAM,UAAU,gBAAgB,aAC5B,gBAAgB,aAChB,GAAG,gBAAgB,QAAQ,gBAAgB;AAAA,EAE/C,QAAQ,IAAI,+BAA+B,SAAS;AAAA,EAEpD,OAAO;AAAA,IACL;AAAA,IACA,UAAU,OAAO;AAAA,SACZ,MAAM;AAAA,MACT,gBAAgB,MAAM,SAAS;AAAA,MAC/B,mBAAmB,MAAM,YAAY;AAAA,IACvC;AAAA,IACA,OAAO,YAAY;AAAA,MAEjB,YAAY,WAAW,MAAM,aAAa;AAAA,QACxC,OAAO,QAAQ;AAAA,MACjB;AAAA,MAGA,cAAc,aAAa,MAAM,UAAU;AAAA,QACzC,IAAI;AAAA,UACF,SAAS,QAAQ,QAAQ;AAAA,UACzB,MAAM;AAAA,MAGV;AAAA,MAEA,MAAM,SAAS,MAAM;AAAA,MACrB,MAAM,YAAY,MAAM;AAAA,MAGxB,MAAM,YAAY,MAAM;AAAA,MAGxB,IAAI,gBAAgB,YAAY;AAAA,QAC9B,IAAI;AAAA,UACF,MAAM,OAAO,gBAAgB,UAAU;AAAA,UACvC,MAAM;AAAA,MAGV;AAAA,MAEA,QAAQ,IAAI,wBAAwB;AAAA;AAAA,EAExC;AAAA;AAGF,SAAS,WAAW,CAAC,QAA+B;AAAA,EAClD,OAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AAAA,IACtC,OAAO,MAAM,CAAC,QAAQ;AAAA,MACpB,IAAI,KAAK;AAAA,QACP,OAAO,GAAG;AAAA,MACZ,EAAO;AAAA,QACL,QAAQ;AAAA;AAAA,KAEX;AAAA,GACF;AAAA;AAGH,SAAS,WAAW,CAAC,OAA0B;AAAA,EAC7C,MAAM,MAAM,iBAAiB,MAAM,SAAS;AAAA,EAC5C,MAAM,MAAM,oBAAoB,MAAM,YAAY;AAAA;",
+  "debugId": "FCA8B2807BBD0FBF64756E2164756E21",
+  "names": []
+}

package/dist/mjs/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "@ricsam/isolate-daemon",
+  "version": "0.1.0",
+  "type": "module"
+}

package/dist/mjs/types.mjs

@@ -0,0 +1,3 @@
+// @bun
+
+//# debugId=49211CCAF438507B64756E2164756E21

package/dist/mjs/types.mjs.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "49211CCAF438507B64756E2164756E21",
+  "names": []
+}

package/dist/types/callback-fs-handler.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Callback-based FileSystemHandler adapter.
+ *
+ * Adapts simple client callbacks (readFile, writeFile, etc.) to the
+ * FileSystemHandler interface used by @ricsam/isolate-fs.
+ */
+import type { FileSystemHandler } from "@ricsam/isolate-fs";
+import type { FsCallbackRegistrations } from "@ricsam/isolate-protocol";
+import type { ConnectionState } from "./types.ts";
+interface InvokeClientCallback {
+    (connection: ConnectionState, callbackId: number, args: unknown[]): Promise<unknown>;
+}
+interface CallbackFsHandlerOptions {
+    connection: ConnectionState;
+    callbacks: FsCallbackRegistrations;
+    invokeClientCallback: InvokeClientCallback;
+    basePath?: string;
+}
+/**
+ * Create a FileSystemHandler that invokes client callbacks.
+ *
+ * Maps WHATWG FileSystem API operations to simple POSIX-like callbacks.
+ */
+export declare function createCallbackFileSystemHandler(options: CallbackFsHandlerOptions): FileSystemHandler;
+export {};

package/dist/types/connection.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Connection handling for the isolate daemon.
+ */
+import type { Socket } from "node:net";
+import type { DaemonState } from "./types.ts";
+/**
+ * Handle a new client connection.
+ */
+export declare function handleConnection(socket: Socket, state: DaemonState): void;

package/dist/types/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @ricsam/isolate-daemon
+ *
+ * Node.js daemon for running isolated-vm runtimes accessible via IPC.
+ */
+import type { DaemonOptions, DaemonHandle, DaemonStats } from "./types.ts";
+export type { DaemonOptions, DaemonHandle, DaemonStats };
+/**
+ * Start the isolate daemon.
+ *
+ * @param options - Daemon configuration options
+ * @returns Handle to control the daemon
+ */
+export declare function startDaemon(options?: DaemonOptions): Promise<DaemonHandle>;

package/dist/types/types.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Internal types for the isolate daemon.
+ */
+import type { Socket } from "node:net";
+import type { RuntimeHandle } from "@ricsam/isolate-runtime";
+import type { CallbackRegistration } from "@ricsam/isolate-protocol";
+import type { Browser, BrowserContext, Page } from "playwright";
+import type { PlaywrightHandle } from "@ricsam/isolate-playwright";
+/**
+ * Options for starting the daemon.
+ */
+export interface DaemonOptions {
+    /** Unix socket path (preferred) */
+    socketPath?: string;
+    /** TCP host (fallback) */
+    host?: string;
+    /** TCP port (fallback) */
+    port?: number;
+    /** Maximum number of isolates */
+    maxIsolates?: number;
+    /** Default memory limit for isolates (MB) */
+    defaultMemoryLimit?: number;
+}
+/**
+ * Handle returned by startDaemon.
+ */
+export interface DaemonHandle {
+    /** Close the daemon and all connections */
+    close(): Promise<void>;
+    /** Get daemon statistics */
+    getStats(): DaemonStats;
+    /** Socket path or address the daemon is listening on */
+    address: string;
+}
+/**
+ * Daemon statistics.
+ */
+export interface DaemonStats {
+    activeIsolates: number;
+    activeConnections: number;
+    totalIsolatesCreated: number;
+    totalRequestsProcessed: number;
+}
+/**
+ * Internal state for a single isolate instance.
+ */
+export interface IsolateInstance {
+    isolateId: string;
+    runtime: RuntimeHandle;
+    ownerConnection: Socket;
+    callbacks: Map<number, CallbackRegistration>;
+    createdAt: number;
+    lastActivity: number;
+    /** Playwright browser instance (if setup) */
+    browser?: Browser;
+    /** Playwright browser context (if setup) */
+    browserContext?: BrowserContext;
+    /** Playwright page (if setup) */
+    page?: Page;
+    /** Playwright handle for event management (if setup) */
+    playwrightHandle?: PlaywrightHandle;
+}
+/**
+ * Pending request waiting for response.
+ */
+export interface PendingRequest {
+    resolve: (result: unknown) => void;
+    reject: (error: Error) => void;
+    timeoutId?: ReturnType<typeof setTimeout>;
+}
+/**
+ * Internal state for a client connection.
+ */
+export interface ConnectionState {
+    socket: Socket;
+    isolates: Set<string>;
+    pendingRequests: Map<number, PendingRequest>;
+    pendingCallbacks: Map<number, PendingRequest>;
+    nextRequestId: number;
+    nextCallbackId: number;
+    nextStreamId: number;
+}
+/**
+ * Global daemon state.
+ */
+export interface DaemonState {
+    isolates: Map<string, IsolateInstance>;
+    connections: Map<Socket, ConnectionState>;
+    stats: DaemonStats;
+    options: Required<DaemonOptions>;
+}

package/package.json

@@ -1,10 +1,59 @@
 {
   "name": "@ricsam/isolate-daemon",
-  "version": "0.0.1",
-  "description": "OIDC trusted publishing setup package for @ricsam/isolate-daemon",
+  "version": "0.1.0",
+  "main": "./dist/cjs/index.cjs",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "require": "./dist/cjs/index.cjs",
+      "import": "./dist/mjs/index.mjs"
+    }
+  },
+  "bin": {
+    "isolate-daemon": "./bin/daemon.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "node --test --experimental-strip-types 'src/**/*.test.ts'",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@ricsam/isolate-protocol": "*",
+    "@ricsam/isolate-runtime": "*",
+    "@ricsam/isolate-fs": "*",
+    "@ricsam/isolate-test-environment": "*",
+    "@ricsam/isolate-playwright": "*",
+    "playwright": "^1"
+  },
+  "author": "Richard Samuelsson",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ricsam/isolate.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ricsam/isolate/issues"
+  },
+  "homepage": "https://github.com/ricsam/isolate#readme",
   "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
+    "isolated-vm",
+    "sandbox",
+    "javascript",
+    "runtime",
+    "fetch",
+    "filesystem",
+    "streams",
+    "v8",
+    "isolate"
+  ],
+  "description": "Node.js daemon server for running isolated-vm runtimes via IPC",
+  "module": "./dist/mjs/index.mjs",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md"
   ]
-}
+}