zeitlich 0.2.13 → 0.2.14

package/dist/types-CDubRtad.d.cts

@@ -0,0 +1,115 @@
+import { ApplicationFailure } from '@temporalio/common';
+
+interface DirentEntry {
+    name: string;
+    isFile: boolean;
+    isDirectory: boolean;
+    isSymbolicLink: boolean;
+}
+interface FileStat {
+    isFile: boolean;
+    isDirectory: boolean;
+    isSymbolicLink: boolean;
+    size: number;
+    mtime: Date;
+}
+/**
+ * Provider-agnostic filesystem interface.
+ *
+ * Implementations that don't support a method should throw
+ * {@link SandboxNotSupportedError}.
+ */
+interface SandboxFileSystem {
+    readFile(path: string): Promise<string>;
+    readFileBuffer(path: string): Promise<Uint8Array>;
+    writeFile(path: string, content: string | Uint8Array): Promise<void>;
+    appendFile(path: string, content: string | Uint8Array): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    stat(path: string): Promise<FileStat>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    readdir(path: string): Promise<string[]>;
+    readdirWithFileTypes(path: string): Promise<DirentEntry[]>;
+    rm(path: string, options?: {
+        recursive?: boolean;
+        force?: boolean;
+    }): Promise<void>;
+    cp(src: string, dest: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    mv(src: string, dest: string): Promise<void>;
+    readlink(path: string): Promise<string>;
+    resolvePath(base: string, path: string): string;
+}
+interface ExecOptions {
+    timeout?: number;
+    cwd?: string;
+    env?: Record<string, string>;
+}
+interface ExecResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+interface SandboxCapabilities {
+    /** Sandbox supports filesystem operations */
+    filesystem: boolean;
+    /** Sandbox supports shell/command execution */
+    execution: boolean;
+    /** Sandbox state can be persisted and restored */
+    persistence: boolean;
+}
+interface Sandbox {
+    readonly id: string;
+    readonly capabilities: SandboxCapabilities;
+    readonly fs: SandboxFileSystem;
+    exec(command: string, options?: ExecOptions): Promise<ExecResult>;
+    destroy(): Promise<void>;
+}
+interface SandboxSnapshot {
+    sandboxId: string;
+    providerId: string;
+    /** Provider-specific serialised state */
+    data: unknown;
+    createdAt: string;
+}
+interface SandboxCreateOptions {
+    /** Preferred sandbox ID (provider may ignore) */
+    id?: string;
+    /** Seed the filesystem with these files */
+    initialFiles?: Record<string, string | Uint8Array>;
+    /** Environment variables available inside the sandbox */
+    env?: Record<string, string>;
+}
+interface SandboxCreateResult {
+    sandbox: Sandbox;
+    /** Optional state to merge into the workflow's `AgentState` via the session. */
+    stateUpdate?: Record<string, unknown>;
+}
+interface SandboxProvider<TOptions extends SandboxCreateOptions = SandboxCreateOptions, TSandbox extends Sandbox = Sandbox> {
+    readonly id: string;
+    readonly capabilities: SandboxCapabilities;
+    create(options?: TOptions): Promise<SandboxCreateResult>;
+    get(sandboxId: string): Promise<TSandbox>;
+    destroy(sandboxId: string): Promise<void>;
+    snapshot(sandboxId: string): Promise<SandboxSnapshot>;
+    restore(snapshot: SandboxSnapshot): Promise<Sandbox>;
+}
+interface SandboxOps<TOptions extends SandboxCreateOptions = SandboxCreateOptions> {
+    createSandbox(options?: TOptions): Promise<{
+        sandboxId: string;
+        stateUpdate?: Record<string, unknown>;
+    }>;
+    destroySandbox(sandboxId: string): Promise<void>;
+    snapshotSandbox(sandboxId: string): Promise<SandboxSnapshot>;
+}
+
+declare class SandboxNotSupportedError extends ApplicationFailure {
+    constructor(operation: string);
+}
+declare class SandboxNotFoundError extends ApplicationFailure {
+    constructor(sandboxId: string);
+}
+
+export { type DirentEntry as D, type ExecResult as E, type FileStat as F, type Sandbox as S, type SandboxFileSystem as a, type SandboxProvider as b, type SandboxCapabilities as c, type SandboxCreateOptions as d, type SandboxCreateResult as e, type SandboxSnapshot as f, type SandboxOps as g, type ExecOptions as h, SandboxNotFoundError as i, SandboxNotSupportedError as j };

package/dist/types-CDubRtad.d.ts

@@ -0,0 +1,115 @@
+import { ApplicationFailure } from '@temporalio/common';
+
+interface DirentEntry {
+    name: string;
+    isFile: boolean;
+    isDirectory: boolean;
+    isSymbolicLink: boolean;
+}
+interface FileStat {
+    isFile: boolean;
+    isDirectory: boolean;
+    isSymbolicLink: boolean;
+    size: number;
+    mtime: Date;
+}
+/**
+ * Provider-agnostic filesystem interface.
+ *
+ * Implementations that don't support a method should throw
+ * {@link SandboxNotSupportedError}.
+ */
+interface SandboxFileSystem {
+    readFile(path: string): Promise<string>;
+    readFileBuffer(path: string): Promise<Uint8Array>;
+    writeFile(path: string, content: string | Uint8Array): Promise<void>;
+    appendFile(path: string, content: string | Uint8Array): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    stat(path: string): Promise<FileStat>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    readdir(path: string): Promise<string[]>;
+    readdirWithFileTypes(path: string): Promise<DirentEntry[]>;
+    rm(path: string, options?: {
+        recursive?: boolean;
+        force?: boolean;
+    }): Promise<void>;
+    cp(src: string, dest: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    mv(src: string, dest: string): Promise<void>;
+    readlink(path: string): Promise<string>;
+    resolvePath(base: string, path: string): string;
+}
+interface ExecOptions {
+    timeout?: number;
+    cwd?: string;
+    env?: Record<string, string>;
+}
+interface ExecResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+interface SandboxCapabilities {
+    /** Sandbox supports filesystem operations */
+    filesystem: boolean;
+    /** Sandbox supports shell/command execution */
+    execution: boolean;
+    /** Sandbox state can be persisted and restored */
+    persistence: boolean;
+}
+interface Sandbox {
+    readonly id: string;
+    readonly capabilities: SandboxCapabilities;
+    readonly fs: SandboxFileSystem;
+    exec(command: string, options?: ExecOptions): Promise<ExecResult>;
+    destroy(): Promise<void>;
+}
+interface SandboxSnapshot {
+    sandboxId: string;
+    providerId: string;
+    /** Provider-specific serialised state */
+    data: unknown;
+    createdAt: string;
+}
+interface SandboxCreateOptions {
+    /** Preferred sandbox ID (provider may ignore) */
+    id?: string;
+    /** Seed the filesystem with these files */
+    initialFiles?: Record<string, string | Uint8Array>;
+    /** Environment variables available inside the sandbox */
+    env?: Record<string, string>;
+}
+interface SandboxCreateResult {
+    sandbox: Sandbox;
+    /** Optional state to merge into the workflow's `AgentState` via the session. */
+    stateUpdate?: Record<string, unknown>;
+}
+interface SandboxProvider<TOptions extends SandboxCreateOptions = SandboxCreateOptions, TSandbox extends Sandbox = Sandbox> {
+    readonly id: string;
+    readonly capabilities: SandboxCapabilities;
+    create(options?: TOptions): Promise<SandboxCreateResult>;
+    get(sandboxId: string): Promise<TSandbox>;
+    destroy(sandboxId: string): Promise<void>;
+    snapshot(sandboxId: string): Promise<SandboxSnapshot>;
+    restore(snapshot: SandboxSnapshot): Promise<Sandbox>;
+}
+interface SandboxOps<TOptions extends SandboxCreateOptions = SandboxCreateOptions> {
+    createSandbox(options?: TOptions): Promise<{
+        sandboxId: string;
+        stateUpdate?: Record<string, unknown>;
+    }>;
+    destroySandbox(sandboxId: string): Promise<void>;
+    snapshotSandbox(sandboxId: string): Promise<SandboxSnapshot>;
+}
+
+declare class SandboxNotSupportedError extends ApplicationFailure {
+    constructor(operation: string);
+}
+declare class SandboxNotFoundError extends ApplicationFailure {
+    constructor(sandboxId: string);
+}
+
+export { type DirentEntry as D, type ExecResult as E, type FileStat as F, type Sandbox as S, type SandboxFileSystem as a, type SandboxProvider as b, type SandboxCapabilities as c, type SandboxCreateOptions as d, type SandboxCreateResult as e, type SandboxSnapshot as f, type SandboxOps as g, type ExecOptions as h, SandboxNotFoundError as i, SandboxNotSupportedError as j };

package/dist/types-CwwgQ_9H.d.ts

@@ -0,0 +1,121 @@
+import { a as SandboxFileSystem, F as FileStat, D as DirentEntry, S as Sandbox, d as SandboxCreateOptions } from './types-CDubRtad.js';
+import { R as RouterContext } from './types-BMXzv7TN.js';
+
+/**
+ * Ephemeral {@link SandboxFileSystem} backed by a {@link FileResolver}.
+ *
+ * Created fresh for each tool invocation from the current workflow file tree.
+ * Directory structure is inferred from file paths. All mutations are tracked
+ * and can be retrieved via {@link getMutations} after the handler completes.
+ */
+declare class VirtualSandboxFileSystem<TCtx = unknown, TMeta = FileEntryMetadata> implements SandboxFileSystem {
+    private resolver;
+    private ctx;
+    private entries;
+    private directories;
+    private mutations;
+    constructor(tree: FileEntry<TMeta>[], resolver: FileResolver<TCtx, TMeta>, ctx: TCtx);
+    /** Return all mutations accumulated during this invocation. */
+    getMutations(): TreeMutation<TMeta>[];
+    /** Look up a file entry by virtual path. */
+    getEntry(path: string): FileEntry<TMeta> | undefined;
+    readFile(path: string): Promise<string>;
+    readFileBuffer(path: string): Promise<Uint8Array>;
+    exists(path: string): Promise<boolean>;
+    stat(path: string): Promise<FileStat>;
+    readdir(path: string): Promise<string[]>;
+    readdirWithFileTypes(path: string): Promise<DirentEntry[]>;
+    writeFile(path: string, content: string | Uint8Array): Promise<void>;
+    appendFile(path: string, content: string | Uint8Array): Promise<void>;
+    mkdir(_path: string, _options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    rm(path: string, options?: {
+        recursive?: boolean;
+        force?: boolean;
+    }): Promise<void>;
+    cp(src: string, dest: string, _options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    mv(src: string, dest: string): Promise<void>;
+    readlink(_path: string): Promise<string>;
+    resolvePath(base: string, path: string): string;
+    private addParentDirectories;
+}
+
+/** Allowed value types for file-entry metadata. */
+type FileEntryMetadata = Record<string, string | number | boolean | null>;
+/** JSON-serializable metadata for a single file in the virtual tree. */
+interface FileEntry<TMeta = FileEntryMetadata> {
+    id: string;
+    /** Virtual path inside the sandbox, e.g. "/src/index.ts" */
+    path: string;
+    size: number;
+    /** ISO-8601 date string (JSON-safe) */
+    mtime: string;
+    metadata: TMeta;
+}
+/**
+ * Flat list of file entries.
+ * Directories are inferred from file paths at runtime.
+ */
+type VirtualFileTree<TMeta = FileEntryMetadata> = FileEntry<TMeta>[];
+type TreeMutation<TMeta = FileEntryMetadata> = {
+    type: "add";
+    entry: FileEntry<TMeta>;
+} | {
+    type: "remove";
+    path: string;
+} | {
+    type: "update";
+    path: string;
+    entry: Partial<FileEntry<TMeta>>;
+};
+/**
+ * Consumer-provided bridge to the existing DB / S3 / CRUD layer.
+ *
+ * Generic over `TCtx` so every call receives workflow-level context
+ * (e.g. `{ projectId: string }`) without the resolver holding state.
+ *
+ * Generic over `TMeta` so resolved entries carry typed metadata.
+ */
+interface FileResolver<TCtx = unknown, TMeta = FileEntryMetadata> {
+    resolveEntries(ctx: TCtx): Promise<FileEntry<TMeta>[]>;
+    readFile(id: string, ctx: TCtx): Promise<string>;
+    readFileBuffer(id: string, ctx: TCtx): Promise<Uint8Array>;
+    writeFile(id: string, content: string | Uint8Array, ctx: TCtx): Promise<void>;
+    createFile(path: string, content: string | Uint8Array, ctx: TCtx): Promise<FileEntry<TMeta>>;
+    deleteFile(id: string, ctx: TCtx): Promise<void>;
+}
+/**
+ * Options for {@link VirtualSandboxProvider.create}.
+ * Extends base options with resolver context.
+ */
+interface VirtualSandboxCreateOptions<TCtx> extends SandboxCreateOptions {
+    resolverContext: TCtx;
+}
+/**
+ * The portion of workflow `AgentState` that the virtual sandbox reads via
+ * {@link queryParentWorkflowState}. Populated automatically by the session
+ * from the provider's `stateUpdate` after `createSandbox`.
+ */
+interface VirtualSandboxState<TCtx = unknown, TMeta = FileEntryMetadata> {
+    sandboxId: string;
+    fileTree: FileEntry<TMeta>[];
+    resolverContext: TCtx;
+}
+/**
+ * A {@link Sandbox} whose filesystem is backed by a {@link VirtualSandboxFileSystem}.
+ */
+type VirtualSandbox<TCtx = unknown, TMeta = FileEntryMetadata> = Sandbox & {
+    fs: VirtualSandboxFileSystem<TCtx, TMeta>;
+};
+/**
+ * Extended router context injected by {@link withVirtualSandbox}.
+ * Guarantees a live (ephemeral) sandbox built from the workflow file tree.
+ */
+interface VirtualSandboxContext<TCtx = unknown, TMeta = FileEntryMetadata> extends RouterContext {
+    sandbox: VirtualSandbox<TCtx, TMeta>;
+}
+
+export { type FileEntryMetadata as F, type TreeMutation as T, type VirtualSandboxCreateOptions as V, type FileResolver as a, type VirtualSandboxContext as b, type FileEntry as c, type VirtualSandbox as d, type VirtualFileTree as e, VirtualSandboxFileSystem as f, type VirtualSandboxState as g };