Class HostDO

packages/computer/tests/script-runner-worker.ts:16–134

}

export class HostDO extends DurableObject<Env> {
  readonly #workspace: Workspace;

  constructor(ctx: DurableObjectState, env: Env) {
    super(ctx, env);
    this.#workspace = new Workspace({
      storage: ctx.storage as unknown as DurableObjectStorageLike,
      waitUntil: ctx.waitUntil.bind(ctx),
      git: createGitClient(),
      backends: [
        new WorkerJavaScriptBackend({
          loader: env.LOADER,
          maxStdioBytes: 64,
          maxCapabilityBytes: 1024,
          maxConcurrentCapabilityCalls: 2,
          modules: {
            "math-kit": "export const double = (value) => value * 2;",
          },
          trustedModules: {
            "ws:test-host": {
              async call(method, args) {
                if (method === "invalid-result") return new Date() as never;
                if (method === "large-error") throw new Error("x".repeat(5000));
                if (method === "slow") {
                  await new Promise((resolve) => setTimeout(resolve, 20));
                  return null;
                }
                if (method === "marker") {
                  return {
                    __workspace_codec__: { version: 1, type: "bytes", data: [1] },
                    keep: true,
                  };
                }
                return { method, args };
              },
            },
          },
        }),
      ],
    });
  }

  async writeFile(path: string, source: string) {
    await this.#workspace.fs.mkdir(path.slice(0, path.lastIndexOf("/")) || "/workspace", {
      recursive: true,
    });
    await this.#workspace.fs.writeFile(path, source);
  }

  async symlink(target: string, path: string) {
    await this.#workspace.fs.mkdir(path.slice(0, path.lastIndexOf("/")) || "/", {
      recursive: true,
    });
    await this.#workspace.fs.symlink(target, path);
  }

  getWorkspace(): WorkspaceStub {
    return this.#workspace.stub();