effect-cf 0.26.0 → 0.27.0

package/dist/ComputerWorkspace.d.mts

@@ -0,0 +1,279 @@
+import { ComputerArtifactsClient } from "./ComputerArtifacts.mjs";
+import { t as DurableObjectState } from "./DurableObjectState-biHrHwrh.mjs";
+import { Context, Effect, Layer, Schema, Scope, Stream } from "effect";
+import { CommitView, GitClient, GitCloneOptions, GitCommitOptions, GitDiffOptions, GitFetchOptions, GitLogOptions, GitUpdateRefOptions } from "@cloudflare/computer/git";
+import { ExecSyncResult, RuntimeExecOptions, RuntimeGetOptions, RuntimeKillOptions, ShellValue, SkippedEntry, ThinkWorkspaceCompatibility, WorkspaceClient, WorkspaceRuntimeResult, WorkspaceRuntimeValue as WorkspaceRuntimeValue$1 } from "@cloudflare/computer";
+import { ShareOptions } from "@cloudflare/computer/assets";
+//#region src/ComputerWorkspace.d.ts
+type CloudflareWorkspaceFilesystem = WorkspaceClient["fs"];
+type CloudflareReadFileOptions = Parameters<CloudflareWorkspaceFilesystem["readFile"]>[1];
+type CloudflareReaddirOptions = Parameters<CloudflareWorkspaceFilesystem["readdir"]>[1];
+type CloudflareFindOptions = Parameters<CloudflareWorkspaceFilesystem["find"]>[2];
+type CloudflareGrepOptions = Parameters<CloudflareWorkspaceFilesystem["grep"]>[2];
+type CloudflareRmOptions = Parameters<CloudflareWorkspaceFilesystem["rm"]>[1];
+type CloudflareMkdirOptions = Parameters<CloudflareWorkspaceFilesystem["mkdir"]>[1];
+type CloudflareWriteFileContent = Parameters<CloudflareWorkspaceFilesystem["writeFile"]>[1];
+type CloudflareWriteFileOptions = Parameters<CloudflareWorkspaceFilesystem["writeFile"]>[2];
+type CloudflareWorkspaceDirentResult = Awaited<ReturnType<CloudflareWorkspaceFilesystem["readdir"]>>[number];
+type CloudflareWorkspaceStatResult = Awaited<ReturnType<CloudflareWorkspaceFilesystem["stat"]>>;
+type CloudflareWorkspaceFoundEntry = Awaited<ReturnType<CloudflareWorkspaceFilesystem["find"]>>[number];
+type CloudflareWorkspaceGrepMatch = Awaited<ReturnType<CloudflareWorkspaceFilesystem["grep"]>>[number];
+declare const WorkspaceFsError_base: Schema.Class<WorkspaceFsError, Schema.TaggedStruct<"WorkspaceFsError", {
+  readonly operation: Schema.String;
+  readonly path: Schema.String;
+  readonly message: Schema.String;
+  readonly code: Schema.optionalKey<Schema.String>;
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Workspace errors use `Schema.TaggedError`, unlike most local binding errors,
+ * because workspace operations commonly sit behind Durable Object RPC methods.
+ * The schema form preserves the operation-family tags across that boundary.
+ */
+declare class WorkspaceFsError extends WorkspaceFsError_base {}
+declare const WorkspaceGitError_base: Schema.Class<WorkspaceGitError, Schema.TaggedStruct<"WorkspaceGitError", {
+  readonly operation: Schema.String;
+  readonly message: Schema.String;
+  readonly code: Schema.optionalKey<Schema.String>;
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/** Schema-serializable error for a workspace Git operation. */
+declare class WorkspaceGitError extends WorkspaceGitError_base {}
+declare const WorkspaceExecError_base: Schema.Class<WorkspaceExecError, Schema.TaggedStruct<"WorkspaceExecError", {
+  readonly operation: Schema.String;
+  readonly message: Schema.String;
+  readonly code: Schema.optionalKey<Schema.String>;
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/** Schema-serializable error for a workspace runtime operation. */
+declare class WorkspaceExecError extends WorkspaceExecError_base {}
+declare const WorkspaceAssetsError_base: Schema.Class<WorkspaceAssetsError, Schema.TaggedStruct<"WorkspaceAssetsError", {
+  readonly operation: Schema.String;
+  readonly path: Schema.String;
+  readonly message: Schema.String;
+  readonly code: Schema.optionalKey<Schema.String>;
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/** Schema-serializable error for a workspace Assets operation. */
+declare class WorkspaceAssetsError extends WorkspaceAssetsError_base {}
+type WorkspaceReadFileOptions = Omit<CloudflareReadFileOptions, "encoding">;
+type ReadTextFileOptions = WorkspaceReadFileOptions;
+type ListDirectoryOptions = CloudflareReaddirOptions;
+type WorkspaceDirectoryEntry = CloudflareWorkspaceDirentResult;
+type WorkspaceEntryStat = CloudflareWorkspaceStatResult;
+type WorkspaceFindOptions = CloudflareFindOptions;
+type WorkspaceFoundEntry = CloudflareWorkspaceFoundEntry;
+type WorkspaceGrepOptions = CloudflareGrepOptions;
+type WorkspaceGrepMatch = CloudflareWorkspaceGrepMatch;
+type RemovePathOptions = CloudflareRmOptions;
+type WorkspaceMkdirOptions = CloudflareMkdirOptions;
+type WorkspaceWriteFileContent = CloudflareWriteFileContent;
+type WorkspaceWriteFileOptions = CloudflareWriteFileOptions;
+/** Explicit read mode. Text remains the default for consumer-port compatibility. */
+type WorkspaceReadEncoding = "utf8" | "stream";
+interface WorkspaceReadFile {
+  (path: string, options?: WorkspaceReadFileOptions & {
+    readonly encoding?: "utf8";
+  }): Effect.Effect<string, WorkspaceFsError>;
+  (path: string, options: WorkspaceReadFileOptions & {
+    readonly encoding: "stream";
+  }): Effect.Effect<ReadableStream<Uint8Array>, WorkspaceFsError>;
+}
+/** Complete Effect wrapper of `WorkspaceClient.fs`. */
+interface ComputerWorkspaceFilesystem {
+  readonly readFile: WorkspaceReadFile;
+  readonly stat: (path: string) => Effect.Effect<WorkspaceEntryStat, WorkspaceFsError>;
+  readonly lstat: (path: string) => Effect.Effect<WorkspaceEntryStat, WorkspaceFsError>;
+  readonly exists: (path: string) => Effect.Effect<boolean, WorkspaceFsError>;
+  readonly readlink: (path: string) => Effect.Effect<string, WorkspaceFsError>;
+  readonly readdir: (path: string, options?: ListDirectoryOptions) => Effect.Effect<ReadonlyArray<WorkspaceDirectoryEntry>, WorkspaceFsError>;
+  readonly find: (directory: string, pattern?: string, options?: WorkspaceFindOptions) => Effect.Effect<ReadonlyArray<WorkspaceFoundEntry>, WorkspaceFsError>;
+  readonly ls: (prefix: string) => Effect.Effect<ReadonlyArray<string>, WorkspaceFsError>;
+  readonly grep: (pattern: string, path: string, options?: WorkspaceGrepOptions) => Effect.Effect<ReadonlyArray<WorkspaceGrepMatch>, WorkspaceFsError>;
+  readonly writeFile: (path: string, content: WorkspaceWriteFileContent, options?: WorkspaceWriteFileOptions) => Effect.Effect<void, WorkspaceFsError>;
+  readonly mkdir: (path: string, options?: WorkspaceMkdirOptions) => Effect.Effect<void, WorkspaceFsError>;
+  readonly rm: (path: string, options?: RemovePathOptions) => Effect.Effect<void, WorkspaceFsError>;
+  readonly chmod: (path: string, mode: number) => Effect.Effect<void, WorkspaceFsError>;
+  readonly symlink: (target: string, path: string) => Effect.Effect<void, WorkspaceFsError>;
+}
+type WorkspaceGitCloneOptions = GitCloneOptions;
+type WorkspaceGitFetchOptions = GitFetchOptions;
+type WorkspaceGitFetchResult = Awaited<ReturnType<GitClient["fetch"]>>;
+type WorkspaceGitCheckoutOptions = Parameters<GitClient["checkout"]>[0];
+type WorkspaceGitUpdateRefOptions = GitUpdateRefOptions;
+type WorkspaceGitDiffOptions = GitDiffOptions;
+type WorkspaceGitCommitOptions = GitCommitOptions;
+interface WorkspaceGitLogOptions extends Omit<GitLogOptions, "depth"> {
+  /** Preferred upstream name for the history bound. */
+  readonly depth?: number;
+  /** Consumer-port compatibility alias for `depth`. */
+  readonly maxCount?: number;
+}
+type WorkspaceGitPerson = CommitView["author"] & {
+  /** Consumer-port compatibility alias for `timestamp`. */
+  readonly timestampSeconds: number;
+};
+interface WorkspaceGitCommit {
+  readonly oid: string;
+  readonly message: string;
+  readonly tree: string;
+  readonly parent: ReadonlyArray<string>;
+  /** Consumer-port compatibility alias for `parent`. */
+  readonly parents: ReadonlyArray<string>;
+  readonly author: WorkspaceGitPerson;
+  readonly committer: WorkspaceGitPerson;
+}
+type EffectGitMethod<Method> = Method extends ((...args: infer Args) => Promise<infer Success>) ? (...args: Args) => Effect.Effect<Success, WorkspaceGitError> : never;
+type EffectGitClient = { readonly [Name in keyof GitClient]: EffectGitMethod<GitClient[Name]>; };
+/** Complete Effect wrapper of the `@cloudflare/computer/git` client. */
+type ComputerWorkspaceGit = Omit<EffectGitClient, "log" | "revParse"> & {
+  readonly log: (options?: WorkspaceGitLogOptions) => Effect.Effect<ReadonlyArray<WorkspaceGitCommit>, WorkspaceGitError>;
+  readonly revParse: {
+    (ref: string): Effect.Effect<string, WorkspaceGitError>;
+    (options: Parameters<GitClient["revParse"]>[0]): Effect.Effect<string, WorkspaceGitError>;
+  };
+};
+type WorkspaceExecSignal = NonNullable<RuntimeKillOptions["signal"]>;
+type WorkspaceRuntimeValue = WorkspaceRuntimeValue$1;
+type WorkspaceExecEncoding = "utf8" | "binary";
+type WorkspaceExecSyncResult = ExecSyncResult;
+type WorkspaceExecSkippedEntry = SkippedEntry;
+type CloudflareEncoding<Encoding extends WorkspaceExecEncoding> = Encoding extends "utf8" ? "utf8" : undefined;
+type WorkspaceExecChunk<Encoding extends WorkspaceExecEncoding> = Encoding extends "utf8" ? string : Uint8Array;
+type WorkspaceExecOptions<Encoding extends WorkspaceExecEncoding = "utf8"> = Omit<RuntimeExecOptions, "encoding" | "timeoutMs"> & {
+  readonly encoding?: Encoding;
+  /** Upstream runtime option name. */
+  readonly timeoutMs?: number;
+  /** Consumer-port compatibility alias for `timeoutMs`. */
+  readonly timeoutMillis?: number;
+};
+type WorkspaceGetExecOptions<Encoding extends WorkspaceExecEncoding = "utf8"> = Omit<RuntimeGetOptions, "encoding"> & {
+  readonly encoding?: Encoding;
+};
+type WorkspaceExecEvent<Encoding extends WorkspaceExecEncoding = "utf8"> = ({
+  readonly _tag: "Stdout";
+  readonly id: string;
+  readonly sequence: number;
+  readonly chunk: WorkspaceExecChunk<Encoding>;
+} & (Encoding extends "utf8" ? {
+  readonly text: string;
+} : {
+  readonly bytes: Uint8Array;
+})) | ({
+  readonly _tag: "Stderr";
+  readonly id: string;
+  readonly sequence: number;
+  readonly chunk: WorkspaceExecChunk<Encoding>;
+} & (Encoding extends "utf8" ? {
+  readonly text: string;
+} : {
+  readonly bytes: Uint8Array;
+})) | {
+  readonly _tag: "Exit";
+  readonly id: string;
+  readonly sequence: number;
+  readonly exitCode: number;
+  readonly value?: WorkspaceRuntimeValue;
+};
+interface WorkspaceExecResult<Encoding extends WorkspaceExecEncoding = "utf8"> {
+  readonly status: WorkspaceRuntimeResult<CloudflareEncoding<Encoding>>["status"];
+  readonly exitCode: number;
+  readonly stdout: WorkspaceExecChunk<Encoding>;
+  readonly stderr: WorkspaceExecChunk<Encoding>;
+  readonly value?: WorkspaceRuntimeValue;
+  readonly pushed: number;
+  readonly pulled: number;
+  readonly skipped: ReadonlyArray<WorkspaceExecSkippedEntry>;
+  readonly sync: WorkspaceExecSyncResult;
+}
+interface WorkspaceExecRun<Encoding extends WorkspaceExecEncoding = "utf8"> {
+  readonly id: string;
+  readonly backend: string;
+  /**
+   * Live output. Like the upstream handle, `events` and `result` are mutually
+   * exclusive consumers of a run.
+   */
+  readonly events: Stream.Stream<WorkspaceExecEvent<Encoding>, WorkspaceExecError>;
+  readonly result: Effect.Effect<WorkspaceExecResult<Encoding>, WorkspaceExecError>;
+  readonly kill: (signal?: WorkspaceExecSignal) => Effect.Effect<void, WorkspaceExecError>;
+}
+interface WorkspaceExec {
+  (strings: TemplateStringsArray, ...values: Array<ShellValue>): Effect.Effect<WorkspaceExecRun<"utf8">, WorkspaceExecError, Scope.Scope>;
+  (command: string, options?: WorkspaceExecOptions<"utf8">): Effect.Effect<WorkspaceExecRun<"utf8">, WorkspaceExecError, Scope.Scope>;
+  (command: string, options: WorkspaceExecOptions<"binary">): Effect.Effect<WorkspaceExecRun<"binary">, WorkspaceExecError, Scope.Scope>;
+}
+interface WorkspaceGetExec {
+  (id: string, options?: WorkspaceGetExecOptions<"utf8">): Effect.Effect<WorkspaceExecRun<"utf8">, WorkspaceExecError, Scope.Scope>;
+  (id: string, options: WorkspaceGetExecOptions<"binary">): Effect.Effect<WorkspaceExecRun<"binary">, WorkspaceExecError, Scope.Scope>;
+}
+interface WorkspaceExecCollect {
+  (strings: TemplateStringsArray, ...values: Array<ShellValue>): Effect.Effect<WorkspaceExecResult<"utf8">, WorkspaceExecError>;
+  (command: string, options?: WorkspaceExecOptions<"utf8">): Effect.Effect<WorkspaceExecResult<"utf8">, WorkspaceExecError>;
+  (command: string, options: WorkspaceExecOptions<"binary">): Effect.Effect<WorkspaceExecResult<"binary">, WorkspaceExecError>;
+}
+/** Complete Effect wrapper of `WorkspaceClient.runtime`. */
+interface ComputerWorkspaceRuntime {
+  readonly exec: WorkspaceExec;
+  readonly execCollect: WorkspaceExecCollect;
+  readonly getExec: WorkspaceGetExec;
+  readonly killExec: (id: string, options?: RuntimeKillOptions) => Effect.Effect<void, WorkspaceExecError>;
+  readonly disposeExec: (id: string, options?: {
+    readonly backend?: string;
+  }) => Effect.Effect<void, WorkspaceExecError>;
+}
+/** Effect wrapper over a configured local `Workspace.assets` client. */
+interface ComputerWorkspaceAssets {
+  readonly share: (path: string, options: ShareOptions) => Effect.Effect<string, WorkspaceAssetsError>;
+}
+type EffectThinkMethod<Method> = Method extends ((...args: infer Args) => Promise<infer Success>) ? (...args: Args) => Effect.Effect<Success, WorkspaceFsError> : never;
+/** Effect wrapper of the optional Think compatibility surface. */
+type ComputerWorkspaceThink = { readonly [Name in keyof ThinkWorkspaceCompatibility]: EffectThinkMethod<ThinkWorkspaceCompatibility[Name]>; };
+/** Effect service over every client surface exposed by Cloudflare Computer. */
+interface ComputerWorkspaceShape {
+  readonly fs: ComputerWorkspaceFilesystem;
+  readonly git: ComputerWorkspaceGit;
+  readonly runtime: ComputerWorkspaceRuntime;
+  readonly artifacts: ComputerArtifactsClient;
+  readonly assets: ComputerWorkspaceAssets | undefined;
+  readonly think: ComputerWorkspaceThink | undefined;
+  /** Flat filesystem aliases retained for mechanical consumer migration. */
+  readonly readFile: WorkspaceReadFile;
+  readonly stat: ComputerWorkspaceFilesystem["stat"];
+  readonly lstat: ComputerWorkspaceFilesystem["lstat"];
+  readonly exists: ComputerWorkspaceFilesystem["exists"];
+  readonly readlink: ComputerWorkspaceFilesystem["readlink"];
+  readonly readdir: ComputerWorkspaceFilesystem["readdir"];
+  readonly listDirectory: ComputerWorkspaceFilesystem["readdir"];
+  readonly find: ComputerWorkspaceFilesystem["find"];
+  readonly ls: ComputerWorkspaceFilesystem["ls"];
+  readonly grep: ComputerWorkspaceFilesystem["grep"];
+  readonly writeFile: ComputerWorkspaceFilesystem["writeFile"];
+  readonly mkdir: ComputerWorkspaceFilesystem["mkdir"];
+  readonly rm: ComputerWorkspaceFilesystem["rm"];
+  readonly removePath: ComputerWorkspaceFilesystem["rm"];
+  readonly chmod: ComputerWorkspaceFilesystem["chmod"];
+  readonly symlink: ComputerWorkspaceFilesystem["symlink"];
+  /** Flat runtime aliases retained for mechanical consumer migration. */
+  readonly exec: WorkspaceExec;
+  readonly execCollect: WorkspaceExecCollect;
+  readonly getExec: WorkspaceGetExec;
+  readonly killExec: ComputerWorkspaceRuntime["killExec"];
+  readonly disposeExec: ComputerWorkspaceRuntime["disposeExec"];
+}
+/**
+ * Wraps a client whose lifetime is owned by the caller. Prefer
+ * {@link ComputerWorkspace.layer} in Durable Objects so the parent client and
+ * every runtime handle are disposed by Effect `Scope`.
+ */
+declare const fromWorkspaceClient: (client: WorkspaceClient) => ComputerWorkspaceShape;
+declare const ComputerWorkspace_base: Context.ServiceClass<ComputerWorkspace, "effect-cf/ComputerWorkspace", ComputerWorkspaceShape>;
+/** Effect service for the workspace owned by the enclosing Durable Object. */
+declare class ComputerWorkspace extends ComputerWorkspace_base {
+  /**
+   * Acquires the single workspace registered by `withComputerWorkspace` and
+   * releases its RPC client when the layer scope closes.
+   */
+  static readonly layer: Layer.Layer<ComputerWorkspace, never, DurableObjectState>;
+}
+//#endregion
+export { ComputerWorkspace, ComputerWorkspaceAssets, ComputerWorkspaceFilesystem, ComputerWorkspaceGit, ComputerWorkspaceRuntime, ComputerWorkspaceShape, ComputerWorkspaceThink, ListDirectoryOptions, ReadTextFileOptions, RemovePathOptions, WorkspaceAssetsError, WorkspaceDirectoryEntry, WorkspaceEntryStat, WorkspaceExec, WorkspaceExecChunk, WorkspaceExecCollect, WorkspaceExecEncoding, WorkspaceExecError, WorkspaceExecEvent, WorkspaceExecOptions, WorkspaceExecResult, WorkspaceExecRun, WorkspaceExecSignal, WorkspaceExecSkippedEntry, WorkspaceExecSyncResult, WorkspaceFindOptions, WorkspaceFoundEntry, WorkspaceFsError, WorkspaceGetExec, WorkspaceGetExecOptions, WorkspaceGitCheckoutOptions, WorkspaceGitCloneOptions, WorkspaceGitCommit, WorkspaceGitCommitOptions, WorkspaceGitDiffOptions, WorkspaceGitError, WorkspaceGitFetchOptions, WorkspaceGitFetchResult, WorkspaceGitLogOptions, WorkspaceGitPerson, WorkspaceGitUpdateRefOptions, WorkspaceGrepMatch, WorkspaceGrepOptions, WorkspaceMkdirOptions, WorkspaceReadEncoding, WorkspaceReadFile, WorkspaceReadFileOptions, WorkspaceRuntimeValue, WorkspaceWriteFileContent, WorkspaceWriteFileOptions, fromWorkspaceClient };