Chore: Refactor away singleton pattern in runner

packages/background-charm-service/cast-admin.ts

@@ -1,11 +1,6 @@
 import { parseArgs } from "@std/cli/parse-args";
 import { CharmManager, compileRecipe } from "@commontools/charm";
-import {
-  getCell,
-  getEntityId,
-  setBlobbyServerUrl,
-  storage,
-} from "@commontools/runner";
+import { getEntityId, Runtime } from "@commontools/runner";
 import { type DID } from "@commontools/identity";
 import { createAdminSession } from "@commontools/identity";
 import {
@@ -42,16 +37,13 @@ const identity = await getIdentity(
   Deno.env.get("OPERATOR_PASS"),
 );
 
-storage.setRemoteStorage(new URL(toolshedUrl));
-setBlobbyServerUrl(toolshedUrl);
+// Storage and blobby server URL are now configured in Runtime constructor
 
 async function castRecipe() {
   const spaceId = BG_SYSTEM_SPACE_ID;
   const cause = BG_CELL_CAUSE;
   console.log(`Casting recipe from ${recipePath} in space ${spaceId}`);
 
-  storage.setSigner(identity);
-
   console.log("params:", {
     spaceId,
     recipePath,
@@ -60,6 +52,12 @@ async function castRecipe() {
     quit,
   });
 
+  // Create runtime with proper configuration
+  const runtime = new Runtime({
+    storageUrl: toolshedUrl,
+    signer: identity,
+  });
+
   try {
     // Load and compile the recipe first
     console.log("Loading recipe...");
@@ -69,15 +67,15 @@ async function castRecipe() {
       throw new Error("Cell ID is required");
     }
 
-    const targetCell = getCell(
+    const targetCell = runtime.getCell(
       spaceId as DID,
       cause,
       BGCharmEntriesSchema,
     );
 
     // Ensure the cell is synced
-    await storage.syncCell(targetCell, true);
-    await storage.synced();
+    await runtime.storage.syncCell(targetCell, true);
+    await runtime.storage.synced();
 
     console.log("Getting cell...");
 
@@ -92,8 +90,9 @@ async function castRecipe() {
     });
 
     // Create charm manager for the specified space
-    const charmManager = new CharmManager(session);
-    const recipe = await compileRecipe(recipeSrc, "recipe", charmManager);
+    const charmManager = new CharmManager(session, runtime);
+    await charmManager.ready;
+    const recipe = await compileRecipe(recipeSrc, "recipe", runtime, spaceId);
     console.log("Recipe compiled successfully");
 
     const charm = await charmManager.runPersistent(
@@ -104,13 +103,13 @@ async function castRecipe() {
     console.log("Recipe cast successfully!");
     console.log("Result charm ID:", getEntityId(charm));
 
-    await storage.synced();
+    await runtime.storage.synced();
     console.log("Storage synced, exiting");
     Deno.exit(0);
   } catch (error) {
     console.error("Error casting recipe:", error);
     if (quit) {
-      await storage.synced();
+      await runtime.storage.synced();
       Deno.exit(1);
     }
   }

packages/background-charm-service/src/main.ts

@@ -1,5 +1,5 @@
 import { parseArgs } from "@std/cli/parse-args";
-import { storage } from "@commontools/runner";
+import { Runtime } from "@commontools/runner";
 import { BackgroundCharmService } from "./service.ts";
 import { getIdentity, log } from "./utils.ts";
 import { env } from "./env.ts";
@@ -24,10 +24,14 @@ const workerTimeoutMs = (() => {
 })();
 
 const identity = await getIdentity(env.IDENTITY, env.OPERATOR_PASS);
+const runtime = new Runtime({
+  storageUrl: env.TOOLSHED_API_URL,
+  signer: identity,
+});
 const service = new BackgroundCharmService({
   identity,
   toolshedUrl: env.TOOLSHED_API_URL,
-  storage,
+  runtime,
   workerTimeoutMs,
 });
 

packages/background-charm-service/src/service.ts

@@ -1,5 +1,5 @@
 import { Identity } from "@commontools/identity";
-import { type Cell, type Storage } from "@commontools/runner";
+import { type Cell, type Runtime } from "@commontools/runner";
 import {
   BG_CELL_CAUSE,
   BG_SYSTEM_SPACE_ID,
@@ -12,7 +12,7 @@ import { useCancelGroup } from "@commontools/runner";
 export interface BackgroundCharmServiceOptions {
   identity: Identity;
   toolshedUrl: string;
-  storage: Storage;
+  runtime: Runtime;
   bgSpace?: string;
   bgCause?: string;
   workerTimeoutMs?: number;
@@ -24,30 +24,29 @@ export class BackgroundCharmService {
   private charmSchedulers: Map<string, SpaceManager> = new Map();
   private identity: Identity;
   private toolshedUrl: string;
-  private storage: Storage;
+  private runtime: Runtime;
   private bgSpace: string;
   private bgCause: string;
   private workerTimeoutMs?: number;
 
   constructor(options: BackgroundCharmServiceOptions) {
     this.identity = options.identity;
     this.toolshedUrl = options.toolshedUrl;
-    this.storage = options.storage;
+    this.runtime = options.runtime;
     this.bgSpace = options.bgSpace ?? BG_SYSTEM_SPACE_ID;
     this.bgCause = options.bgCause ?? BG_CELL_CAUSE;
     this.workerTimeoutMs = options.workerTimeoutMs;
   }
 
   async initialize() {
-    this.storage.setRemoteStorage(new URL(this.toolshedUrl));
-    this.storage.setSigner(this.identity);
+    // Storage URL and signer are already configured in the Runtime
     this.charmsCell = await getBGCharms({
       bgSpace: this.bgSpace,
       bgCause: this.bgCause,
-      storage: this.storage,
+      runtime: this.runtime,
     });
-    await this.storage.syncCell(this.charmsCell, true);
-    await this.storage.synced();
+    await this.runtime.storage.syncCell(this.charmsCell, true);
+    await this.runtime.storage.synced();
 
     if (this.isRunning) {
       log("Service is already running");

packages/background-charm-service/src/utils.ts

@@ -1,10 +1,5 @@
 import { Charm } from "@commontools/charm";
-import {
-  type Cell,
-  getCell,
-  getEntityId,
-  type Storage,
-} from "@commontools/runner";
+import { type Cell, getEntityId, type Runtime } from "@commontools/runner";
 import { Identity, type IdentityCreateConfig } from "@commontools/identity";
 import { ID, type JSONSchema } from "@commontools/builder";
 import {
@@ -104,21 +99,21 @@ export async function setBGCharm({
   space,
   charmId,
   integration,
-  storage,
+  runtime,
   bgSpace,
   bgCause,
 }: {
   space: string;
   charmId: string;
   integration: string;
-  storage: Storage;
+  runtime: Runtime;
   bgSpace?: string;
   bgCause?: string;
 }): Promise<boolean> {
   const charmsCell = await getBGCharms({
     bgSpace,
     bgCause,
-    storage,
+    runtime,
   });
 
   console.log(
@@ -148,7 +143,7 @@ export async function setBGCharm({
     } as unknown as Cell<BGCharmEntry>);
 
     // Ensure changes are synced
-    await storage.synced();
+    await runtime.storage.synced();
 
     return true;
   } else {
@@ -160,31 +155,28 @@ export async function setBGCharm({
       status: "Re-initializing",
     });
 
-    await storage.synced();
+    await runtime.storage.synced();
 
     return false;
   }
 }
 
 export async function getBGCharms(
-  { bgSpace, bgCause, storage }: {
+  { bgSpace, bgCause, runtime }: {
     bgSpace?: string;
     bgCause?: string;
-    storage: Storage;
+    runtime: Runtime;
   },
 ): Promise<
   Cell<Cell<BGCharmEntry>[]>
 > {
   bgSpace = bgSpace ?? BG_SYSTEM_SPACE_ID;
   bgCause = bgCause ?? BG_CELL_CAUSE;
 
-  if (!storage.hasSigner()) {
+  if (!runtime.storage.hasSigner()) {
     throw new Error("Storage has no signer");
   }
 
-  if (!storage.hasRemoteStorage()) {
-    throw new Error("Storage has no remote storage");
-  }
   const schema = {
     type: "array",
     items: {
@@ -194,7 +186,7 @@ export async function getBGCharms(
     default: [],
   } as const satisfies JSONSchema;
 
-  const charmsCell = getCell(bgSpace, bgCause, schema);
+  const charmsCell = runtime.getCell(bgSpace, bgCause, schema);
 
   // Ensure the cell is synced
   // FIXME(ja): does True do the right thing here? Does this mean: I REALLY REALLY
@@ -207,8 +199,8 @@ export async function getBGCharms(
     schema: privilegedSchema,
     rootSchema: privilegedSchema,
   };
-  await storage.syncCell(charmsCell, true, schemaContext);
-  await storage.synced();
+  await runtime.storage.syncCell(charmsCell, true, schemaContext);
+  await runtime.storage.synced();
 
   return charmsCell;
 }