@cloudflare/workspace 0.0.0-alpha.0

package/dist/index.d.ts

@@ -0,0 +1,384 @@
+import { _ as Database, a as SQLiteWorkspaceProviderOptions, c as WriteFileOptions, d as ReadFileOptions, f as WorkspaceDirentResult, g as WorkspaceFoundEntry, h as WorkspaceGrepMatch, i as SQLiteWorkspaceProvider, l as WorkspaceStatResult, m as GrepOptions, n as SkippedEntry, o as WorkspaceFilesystem, p as MkdirOptions, r as ChangeEntry, s as WriteFileContent, t as ApplyResult, u as RmOptions, v as DurableObjectStorageLike } from "./shared-RIdME5uo.js";
+import { RpcTarget } from "capnweb";
+import { RpcTarget as RpcTarget$1, WorkerEntrypoint } from "cloudflare:workers";
+
+//#region ../rpc/dist/interface.d.ts
+interface SyncRPC {
+  push(input: {
+    senderRev: number;
+    changes: ReadableStream<ChangeEntry>;
+  }): Promise<{
+    rev: number;
+    appliedPushRev: number;
+  }>;
+  fetchChanges(input: {
+    sinceRev?: number;
+    ignore?: string[];
+  }): Promise<{
+    currentRev: number;
+    appliedPushRev: number;
+    stream: ReadableStream<ChangeEntry>;
+  }>;
+  watermarks(): Promise<{
+    currentRev: number;
+    pushRev: number;
+    fetchRev: number;
+  }>;
+  readEntry(path: string): Promise<ChangeEntry | null>;
+  hasObjects(hashes: Uint8Array[]): Promise<Uint8Array[]>;
+  fetchObjects(hashes: Uint8Array[]): ReadableStream<{
+    hash: Uint8Array;
+    bytes: Uint8Array;
+  }>;
+  pushObjects(objects: ReadableStream<{
+    hash: Uint8Array;
+    bytes: Uint8Array;
+  }>): Promise<void>;
+}
+interface ShellRPC {
+  exec(input: {
+    command: string;
+    cwd?: string;
+    id?: string;
+    timeoutMs?: number;
+  }): Promise<{
+    id: string;
+    events: ReadableStream<ExecEvent>;
+  }>;
+  getExec(input: {
+    id: string;
+    after?: number | "tail";
+  }): Promise<{
+    id: string;
+    events: ReadableStream<ExecEvent>;
+  }>;
+  killExec(input: {
+    id: string;
+    signal?: "SIGTERM" | "SIGKILL" | "SIGINT" | "SIGHUP";
+  }): Promise<void>;
+  disposeExec(input: {
+    id: string;
+  }): Promise<void>;
+}
+interface WorkspaceRPC {
+  sync: SyncRPC;
+  shell: ShellRPC;
+}
+type ExecEvent = {
+  id: string;
+  seq: number;
+  name: "stdout";
+  value: Uint8Array;
+} | {
+  id: string;
+  seq: number;
+  name: "stderr";
+  value: Uint8Array;
+} | {
+  id: string;
+  seq: number;
+  name: "exit";
+  value: number;
+};
+//#endregion
+//#region src/backend.d.ts
+interface WorkspaceBackend {
+  readonly id: string;
+  connect(): Promise<BackendHandle>;
+}
+interface BackendHandle {
+  rpc: WorkspaceRPC;
+  closed?: Promise<void>;
+  close(): Promise<void>;
+}
+//#endregion
+//#region src/backends/container-host.d.ts
+interface WorkspaceRef {
+  binding: string;
+  id: string;
+}
+interface IWorkspaceContainerAPI {
+  start(env: Record<string, string>): Promise<void>;
+  interceptOutboundHttp(host: string, workspace: WorkspaceRef): Promise<void>;
+  port(port: number): Fetcher;
+}
+declare class WorkspaceContainerAPI extends RpcTarget$1 implements IWorkspaceContainerAPI {
+  #private;
+  constructor(ctx: DurableObjectState);
+  start(env: Record<string, string>): Promise<void>;
+  interceptOutboundHttp(host: string, ref: WorkspaceRef): Promise<void>;
+  port(port: number): {
+    fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+    connect(address: SocketAddress | string, options?: SocketOptions): Socket;
+  };
+}
+type DOCtor = new (...args: any[]) => object;
+type WithWorkspaceContainerCtor<TBase extends DOCtor> = TBase & (new (...args: any[]) => InstanceType<TBase> & {
+  getWorkspaceContainer(): WorkspaceContainerAPI;
+});
+declare function withWorkspaceContainer<TBase extends DOCtor>(Base: TBase): WithWorkspaceContainerCtor<TBase>;
+//#endregion
+//#region src/backends/cloudflare-container.d.ts
+interface ContainerHostHolder {
+  getWorkspaceContainer(): IWorkspaceContainerAPI | Promise<IWorkspaceContainerAPI>;
+}
+interface CloudflareContainerBackendOptions {
+  container: () => ContainerHostHolder | Promise<ContainerHostHolder>;
+  workspace: WorkspaceRef;
+  egressHost?: string;
+  containerPort?: number;
+  containerEnv?: Record<string, string>;
+  connectTimeoutMs?: number;
+  heartbeatIntervalMs?: number;
+}
+declare class CloudflareContainerBackend implements WorkspaceBackend {
+  #private;
+  readonly id = "cloudflare-container";
+  constructor(options: CloudflareContainerBackendOptions);
+  connect(): Promise<BackendHandle>;
+  handleFetch(req: Request): Promise<Response>;
+}
+//#endregion
+//#region src/backends/test.d.ts
+interface TestBackendOptions {
+  url: string;
+}
+declare class TestBackend implements WorkspaceBackend {
+  #private;
+  readonly id = "test";
+  constructor(options: TestBackendOptions);
+  connect(): Promise<BackendHandle>;
+}
+//#endregion
+//#region src/mounts/types.d.ts
+interface MountBase {
+  readonly kind: string;
+  readonly mode: "read-only" | "read-write";
+  readonly maxBytes?: number;
+  readonly maxEntries?: number;
+}
+interface EagerMount extends MountBase {
+  readonly strategy: "eager";
+  materialize(api: MountWriteAPI): Promise<void>;
+}
+type Mount = EagerMount;
+type MountFactory = (ctx: MountContext) => Mount;
+interface MountContext {
+  sessionId: string;
+  root: string;
+  vfs: SQLiteWorkspaceProvider;
+}
+interface MountWriteAPI {
+  readonly root: string;
+  writeFile(absPath: string, source: ReadableStream<Uint8Array>, mode?: number): Promise<void>;
+  mkdir(absPath: string, mode?: number): Promise<void>;
+}
+//#endregion
+//#region src/mounts/providers/r2.d.ts
+interface R2BucketBinding {
+  list(options?: {
+    prefix?: string;
+    cursor?: string;
+    limit?: number;
+  }): Promise<{
+    objects: Array<{
+      key: string;
+      size: number;
+    }>;
+    truncated: boolean;
+    cursor?: string;
+  }>;
+  get(key: string): Promise<{
+    body: ReadableStream<Uint8Array>;
+    size: number;
+  } | null>;
+}
+interface R2BucketOptions {
+  prefix?: string;
+  mode?: "read-only" | "read-write";
+  listLimit?: number;
+  concurrency?: number;
+  maxBytes?: number;
+  maxEntries?: number;
+}
+declare function R2Bucket(bucket: R2BucketBinding, options?: R2BucketOptions): EagerMount;
+//#endregion
+//#region src/proxy.d.ts
+interface WorkspaceProxyProps {
+  binding: string;
+  id: string;
+}
+declare class WorkspaceProxy extends WorkerEntrypoint<unknown, WorkspaceProxyProps> {
+  fetch(request: Request): Promise<Response>;
+}
+//#endregion
+//#region src/shell.d.ts
+type ExecEncoding = "utf8" | undefined;
+type Chunk<E extends ExecEncoding> = E extends "utf8" ? string : Uint8Array;
+type WorkspaceExecEvent<E extends ExecEncoding = undefined> = {
+  id: string;
+  seq: number;
+  name: "stdout";
+  value: Chunk<E>;
+} | {
+  id: string;
+  seq: number;
+  name: "stderr";
+  value: Chunk<E>;
+} | {
+  id: string;
+  seq: number;
+  name: "exit";
+  value: number;
+};
+interface ExecResult<E extends ExecEncoding = undefined> {
+  exitCode: number;
+  stdout: Chunk<E>;
+  stderr: Chunk<E>;
+  pushed: number;
+  pulled: number;
+  skipped: SkippedEntry[];
+}
+type KillSignal = "SIGTERM" | "SIGKILL" | "SIGINT" | "SIGHUP";
+interface ExecHandle<E extends ExecEncoding = undefined> extends ReadableStream<WorkspaceExecEvent<E>> {
+  readonly id: string;
+  result(): Promise<ExecResult<E>>;
+  kill(signal?: KillSignal): Promise<void>;
+}
+interface ExecOptions<E extends ExecEncoding = undefined> {
+  id?: string;
+  cwd?: string;
+  encoding?: E;
+  timeoutMs?: number;
+}
+interface GetExecOptions<E extends ExecEncoding = undefined> {
+  encoding?: E;
+  resume?: "tail" | "full" | number;
+}
+interface Sync {
+  push(): Promise<number>;
+  pull(): Promise<ApplyResult>;
+}
+declare class WorkspaceShell {
+  #private;
+  constructor(shell: ShellRPC, sync: Sync);
+  exec(command: string): Promise<ExecHandle<undefined>>;
+  exec(command: string, options: ExecOptions<undefined>): Promise<ExecHandle<undefined>>;
+  exec(command: string, options: ExecOptions<"utf8">): Promise<ExecHandle<"utf8">>;
+  get(id: string): Promise<ExecHandle<undefined>>;
+  get(id: string, options: GetExecOptions<undefined>): Promise<ExecHandle<undefined>>;
+  get(id: string, options: GetExecOptions<"utf8">): Promise<ExecHandle<"utf8">>;
+}
+//#endregion
+//#region src/mounts/registry.d.ts
+type MountValue = Mount | MountFactory;
+//#endregion
+//#region src/workspace.d.ts
+interface WorkspaceOptions {
+  storage: DurableObjectStorageLike;
+  backends: WorkspaceBackend[];
+  now?: () => number;
+  sessionId?: string;
+  mounts?: Record<string, MountValue>;
+  reconnect?: ReconnectOptions;
+}
+interface ReconnectOptions {
+  attempts: number;
+  initialDelayMs: number;
+  maxDelayMs: number;
+}
+declare class Workspace {
+  #private;
+  constructor(options: WorkspaceOptions);
+  ensureMountsIndexed(): Promise<void>;
+  mounts(): Map<string, Mount>;
+  get db(): Database;
+  get fs(): WorkspaceFilesystem;
+  /**
+   * Underlying dofs `SQLiteWorkspaceProvider` over the local store.
+   *
+   * This is the `@platformatic/vfs`-shaped provider — a node:fs
+   * surface with full symlink support. Callers that want a
+   * `VirtualFileSystem` (e.g. to hand to isomorphic-git) wrap it
+   * themselves to keep `@platformatic/vfs` out of this package's
+   * dependency tree:
+   *
+   * ```ts
+   * import { create, VirtualProvider } from "@platformatic/vfs";
+   * import type { SQLiteWorkspaceProvider } from "@cloudflare/dofs";
+   *
+   * class Glue extends VirtualProvider {
+   *   constructor(private inner: SQLiteWorkspaceProvider) { super(); }
+   *   override get readonly()         { return this.inner.readonly; }
+   *   override get supportsSymlinks() { return this.inner.supportsSymlinks; }
+   *   override get supportsWatch()    { return this.inner.supportsWatch; }
+   * }
+   * // Forward every node:fs method to `inner` via a
+   * // `for (const name of [...]) Object.defineProperty(...)` loop.
+   * const vfs = create(new Glue(workspace.provider()));
+   * ```
+   *
+   * Available immediately; doesn't need `ready()` because the
+   * provider only reads/writes the local store, not the wire.
+   */
+  provider(): SQLiteWorkspaceProvider;
+  get shell(): WorkspaceShell;
+  ready(): Promise<void>;
+  stub(): WorkspaceStub;
+  push(): Promise<number>;
+  pull(): Promise<ApplyResult>;
+  close(): Promise<void>;
+}
+//#endregion
+//#region src/stub.d.ts
+interface WorkspaceExecOptions {
+  cwd?: string;
+  encoding?: "utf8";
+}
+interface WorkspaceExecResult<E extends "utf8" | undefined = undefined> {
+  exitCode: number;
+  stdout: E extends "utf8" ? string : Uint8Array;
+  stderr: E extends "utf8" ? string : Uint8Array;
+}
+declare class WorkspaceFilesystemStub extends RpcTarget {
+  #private;
+  constructor(ws: Workspace);
+  [Symbol.dispose](): void;
+  readFile(path: string): Promise<ReadableStream<Uint8Array>>;
+  readFile(path: string, encoding: "utf8"): Promise<string>;
+  readFile(path: string, options: ReadFileOptions): Promise<string | ReadableStream<Uint8Array>>;
+  stat(path: string): Promise<WorkspaceStatResult>;
+  readdir(path: string): Promise<WorkspaceDirentResult[]>;
+  find(directory: string, pattern?: string): Promise<WorkspaceFoundEntry[]>;
+  ls(prefix: string): Promise<string[]>;
+  grep(pattern: string, path: string, options?: GrepOptions): Promise<WorkspaceGrepMatch[]>;
+  writeFile(path: string, content: WriteFileContent, options?: WriteFileOptions): Promise<void>;
+  mkdir(path: string, options?: MkdirOptions): Promise<void>;
+  rm(path: string, options?: RmOptions): Promise<void>;
+}
+declare class WorkspaceExecHandleStub<E extends "utf8" | undefined = undefined> extends RpcTarget {
+  #private;
+  constructor(pending: Promise<ExecResult<E>>);
+  [Symbol.dispose](): void;
+  result(): Promise<WorkspaceExecResult<E>>;
+}
+declare class WorkspaceShellStub extends RpcTarget {
+  #private;
+  constructor(ws: Workspace);
+  [Symbol.dispose](): void;
+  exec(command: string): Promise<WorkspaceExecHandleStub<undefined>>;
+  exec(command: string, options: WorkspaceExecOptions & {
+    encoding: "utf8";
+  }): Promise<WorkspaceExecHandleStub<"utf8">>;
+  exec(command: string, options: WorkspaceExecOptions): Promise<WorkspaceExecHandleStub<undefined>>;
+}
+declare class WorkspaceStub extends RpcTarget {
+  #private;
+  constructor(ws: Workspace);
+  [Symbol.dispose](): void;
+  get fs(): WorkspaceFilesystemStub;
+  get shell(): WorkspaceShellStub;
+}
+//#endregion
+export { type ApplyResult, type BackendHandle, CloudflareContainerBackend, type CloudflareContainerBackendOptions, type DurableObjectStorageLike, type EagerMount, type ExecEncoding, type ExecHandle, type ExecOptions, type ExecResult, type GetExecOptions, type IWorkspaceContainerAPI, type KillSignal, type Mount, type MountBase, type MountContext, type MountFactory, type MountWriteAPI, R2Bucket, type R2BucketBinding, type R2BucketOptions, SQLiteWorkspaceProvider, type SQLiteWorkspaceProviderOptions, type SkippedEntry, TestBackend, type TestBackendOptions, Workspace, type WorkspaceBackend, WorkspaceContainerAPI, type WorkspaceExecEvent, WorkspaceExecHandleStub, type WorkspaceExecOptions, type WorkspaceExecResult, WorkspaceFilesystemStub, type WorkspaceOptions, WorkspaceProxy, type WorkspaceProxyProps, type WorkspaceRef, WorkspaceShell, WorkspaceShellStub, WorkspaceStub, withWorkspaceContainer };
+//# sourceMappingURL=index.d.ts.map