zeitlich 0.2.28 → 0.2.30

package/src/adapters/sandbox/virtual/index.ts

@@ -1,92 +0,0 @@
-import type {
-  Sandbox,
-  SandboxCapabilities,
-  ExecOptions,
-  ExecResult,
-} from "../../../lib/sandbox/types";
-import { SandboxNotSupportedError } from "../../../lib/sandbox/types";
-import { VirtualSandboxFileSystem } from "./filesystem";
-import type {
-  FileEntry,
-  FileEntryMetadata,
-  FileResolver,
-  VirtualSandbox,
-} from "./types";
-
-// ============================================================================
-// VirtualSandbox
-// ============================================================================
-
-class VirtualSandboxImpl<
-  TCtx = unknown,
-  TMeta = FileEntryMetadata,
-> implements Sandbox
-{
-  readonly capabilities: SandboxCapabilities = {
-    filesystem: true,
-    execution: false,
-    persistence: true,
-  };
-
-  readonly fs: VirtualSandboxFileSystem<TCtx, TMeta>;
-
-  constructor(
-    readonly id: string,
-    tree: FileEntry<TMeta>[],
-    resolver: FileResolver<TCtx, TMeta>,
-    ctx: TCtx,
-    workspaceBase = "/",
-  ) {
-    this.fs = new VirtualSandboxFileSystem(tree, resolver, ctx, workspaceBase);
-  }
-
-  async exec(_command: string, _options?: ExecOptions): Promise<ExecResult> {
-    throw new SandboxNotSupportedError("exec");
-  }
-
-  async destroy(): Promise<void> {
-    // Ephemeral — nothing to clean up
-  }
-}
-
-// ============================================================================
-// Factory
-// ============================================================================
-
-/**
- * Create an ephemeral {@link Sandbox} from a file tree and resolver.
- *
- * Used internally by {@link withVirtualSandbox} and
- * {@link VirtualSandboxProvider}; consumers can also call this directly
- * if they need a sandbox outside the wrapper pattern.
- */
-export function createVirtualSandbox<
-  TCtx,
-  TMeta = FileEntryMetadata,
->(
-  id: string,
-  tree: FileEntry<TMeta>[],
-  resolver: FileResolver<TCtx, TMeta>,
-  ctx: TCtx,
-  workspaceBase = "/",
-): VirtualSandbox<TCtx, TMeta> {
-  return new VirtualSandboxImpl(id, tree, resolver, ctx, workspaceBase);
-}
-
-// Re-exports for convenience
-export { VirtualSandboxFileSystem } from "./filesystem";
-export { VirtualSandboxProvider } from "./provider";
-export { withVirtualSandbox } from "./with-virtual-sandbox";
-export { hasFileWithMimeType, filesWithMimeType, hasDirectory } from "./queries";
-export type { FileTreeAccessor } from "./queries";
-export type {
-  FileEntry,
-  FileEntryMetadata,
-  FileResolver,
-  VirtualFileTree,
-  VirtualSandboxCreateOptions,
-  VirtualSandboxState,
-  VirtualSandboxContext,
-  VirtualSandbox,
-  TreeMutation,
-} from "./types";

package/src/adapters/sandbox/virtual/provider.ts

@@ -1,121 +0,0 @@
-import type {
-  SandboxCapabilities,
-  SandboxCreateResult,
-  SandboxProvider,
-} from "../../../lib/sandbox/types";
-import { SandboxNotSupportedError } from "../../../lib/sandbox/types";
-import { getShortId } from "../../../lib/thread/id";
-import { createVirtualSandbox } from "./index";
-import type {
-  FileEntryMetadata,
-  FileResolver,
-  VirtualSandboxCreateOptions,
-} from "./types";
-
-/**
- * Stateless {@link SandboxProvider} backed by a {@link FileResolver}.
- *
- * The provider holds **no internal state**. All sandbox state (sandboxId,
- * fileTree, resolverContext, workspaceBase) is returned as a `stateUpdate` from
- * {@link create} and merged into the workflow's `AgentState` by the session.
- * {@link withVirtualSandbox} reads this state back on every tool invocation.
- *
- * @example
- * ```typescript
- * const provider = new VirtualSandboxProvider(resolver);
- * const manager = new SandboxManager(provider);
- *
- * export const activities = {
- *   ...manager.createActivities("CodingAgent"),
- *   readFile: withVirtualSandbox(client, provider, readHandler),
- * };
- * ```
- */
-export class VirtualSandboxProvider<
-  TCtx = unknown,
-  TMeta = FileEntryMetadata,
-> implements SandboxProvider<VirtualSandboxCreateOptions<TCtx>> {
-  readonly id = "virtual";
-  readonly capabilities: SandboxCapabilities = {
-    filesystem: true,
-    execution: false,
-    persistence: true,
-  };
-
-  readonly resolver: FileResolver<TCtx, TMeta>;
-
-  constructor(resolver: FileResolver<TCtx, TMeta>) {
-    this.resolver = resolver;
-  }
-
-  async create(
-    options?: VirtualSandboxCreateOptions<TCtx>
-  ): Promise<SandboxCreateResult> {
-    if (!options || !("resolverContext" in options)) {
-      throw new Error("VirtualSandboxProvider.create requires resolverContext");
-    }
-
-    const sandboxId = options.id ?? getShortId();
-    const fileTree = await this.resolver.resolveEntries(
-      options.resolverContext
-    );
-    const workspaceBase = options.workspaceBase ?? "/";
-
-    const sandbox = createVirtualSandbox(
-      sandboxId,
-      fileTree,
-      this.resolver,
-      options.resolverContext,
-      workspaceBase,
-    );
-
-    if (options.initialFiles) {
-      for (const [path, content] of Object.entries(options.initialFiles)) {
-        await sandbox.fs.writeFile(path, content);
-      }
-      for (const m of sandbox.fs.getMutations()) {
-        if (m.type === "add") fileTree.push(m.entry);
-      }
-    }
-
-    return {
-      sandbox,
-      stateUpdate: {
-        sandboxId,
-        fileTree,
-        resolverContext: options.resolverContext,
-        workspaceBase,
-      },
-    };
-  }
-
-  async get(): Promise<never> {
-    throw new SandboxNotSupportedError(
-      "get (virtual sandbox state lives in workflow AgentState)"
-    );
-  }
-
-  async destroy(): Promise<void> {
-    // No-op — no internal state to clean up
-  }
-
-  async pause(): Promise<void> {
-    // No-op — virtual sandbox state lives in workflow AgentState
-  }
-
-  async fork(_sandboxId: string): Promise<never> {
-    throw new Error("Not implemented");
-  }
-
-  async snapshot(): Promise<never> {
-    throw new SandboxNotSupportedError(
-      "snapshot (virtual sandbox state lives in workflow AgentState)"
-    );
-  }
-
-  async restore(): Promise<never> {
-    throw new SandboxNotSupportedError(
-      "restore (virtual sandbox state lives in workflow AgentState)"
-    );
-  }
-}

package/src/adapters/sandbox/virtual/proxy.ts

@@ -1,53 +0,0 @@
-/**
- * Workflow-safe proxy for virtual sandbox operations.
- *
- * Import this from `zeitlich/adapters/sandbox/virtual/workflow`
- * in your Temporal workflow files.
- *
- * By default the scope is derived from `workflowInfo().workflowType`,
- * so activities are automatically namespaced per workflow.
- *
- * @example
- * ```typescript
- * import { proxyVirtualSandboxOps } from 'zeitlich/adapters/sandbox/virtual/workflow';
- *
- * const sandbox = proxyVirtualSandboxOps();
- * ```
- */
-import { proxyActivities, workflowInfo } from "@temporalio/workflow";
-import type { SandboxOps } from "../../../lib/sandbox/types";
-import type { VirtualSandboxCreateOptions } from "./types";
-
-const ADAPTER_PREFIX = "virtual";
-
-export function proxyVirtualSandboxOps(
-  scope?: string,
-  options?: Parameters<typeof proxyActivities>[0]
-): SandboxOps<VirtualSandboxCreateOptions<unknown>> {
-  const resolvedScope = scope ?? workflowInfo().workflowType;
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const acts = proxyActivities<Record<string, (...args: any[]) => any>>(
-    options ?? {
-      startToCloseTimeout: "30s",
-      retry: {
-        maximumAttempts: 3,
-        initialInterval: "2s",
-        maximumInterval: "30s",
-        backoffCoefficient: 2,
-      },
-    }
-  );
-
-  const prefix = `${ADAPTER_PREFIX}${resolvedScope.charAt(0).toUpperCase()}${resolvedScope.slice(1)}`;
-  const p = (key: string): string =>
-    `${prefix}${key.charAt(0).toUpperCase()}${key.slice(1)}`;
-
-  return {
-    createSandbox: acts[p("createSandbox")],
-    destroySandbox: acts[p("destroySandbox")],
-    pauseSandbox: acts[p("pauseSandbox")],
-    snapshotSandbox: acts[p("snapshotSandbox")],
-    forkSandbox: acts[p("forkSandbox")],
-  } as SandboxOps<VirtualSandboxCreateOptions<unknown>>;
-}

package/src/adapters/sandbox/virtual/with-virtual-sandbox.ts

@@ -1,97 +0,0 @@
-import type { WorkflowClient } from "@temporalio/client";
-import { queryParentWorkflowState } from "../../../lib/activity";
-import type { JsonValue } from "../../../lib/state/types";
-import type { ActivityToolHandler, RouterContext } from "../../../lib/tool-router/types";
-import type {
-  FileEntryMetadata,
-  TreeMutation,
-  VirtualSandboxContext,
-  VirtualSandboxState,
-} from "./types";
-import type { VirtualSandboxProvider } from "./provider";
-import { createVirtualSandbox } from "./index";
-
-/**
- * Wraps a tool handler that needs a virtual sandbox, automatically querying
- * the parent workflow for the current file tree and resolver context.
- *
- * On each invocation the wrapper:
- * 1. Queries the workflow's `AgentState` for `fileTree`, `resolverContext`, and `workspaceBase`
- * 2. Creates an ephemeral {@link VirtualSandbox} from tree + provider's resolver
- * 3. Runs the inner handler
- * 4. Returns the handler's result together with any {@link TreeMutation}s
- *
- * The consumer applies mutations back to workflow state via a post-tool hook.
- *
- * @param client    - Temporal `WorkflowClient` for querying the parent workflow
- * @param agentName - Agent name (used to derive the state query name)
- * @param provider  - {@link VirtualSandboxProvider} (wraps the resolver)
- * @param handler   - Inner handler expecting a {@link VirtualSandboxContext}
- *
- * @example
- * ```typescript
- * import { withVirtualSandbox, type VirtualSandboxContext } from 'zeitlich';
- *
- * const readHandler: ActivityToolHandler<FileReadArgs, ReadResult, VirtualSandboxContext> =
- *   async (args, { sandbox }) => {
- *     const content = await sandbox.fs.readFile(args.path);
- *     return { toolResponse: content, data: { path: args.path, content } };
- *   };
- *
- * // At activity registration:
- * const provider = new VirtualSandboxProvider(resolver);
- * const handler = withVirtualSandbox(client, "myAgent", provider, readHandler);
- * ```
- */
-export function withVirtualSandbox<
-  TArgs,
-  TResult,
-  TCtx,
-  TMeta = FileEntryMetadata,
-  TToolResponse = JsonValue,
->(
-  client: WorkflowClient,
-  provider: VirtualSandboxProvider<TCtx, TMeta>,
-  handler: ActivityToolHandler<
-    TArgs,
-    TResult,
-    VirtualSandboxContext<TCtx, TMeta>,
-    TToolResponse
-  >
-): ActivityToolHandler<
-  TArgs,
-  (TResult & { treeMutations: TreeMutation<TMeta>[] }) | null,
-  RouterContext,
-  TToolResponse | string
-> {
-  return async (args, context) => {
-    const state =
-      await queryParentWorkflowState<VirtualSandboxState<TCtx, TMeta>>(client);
-
-    const { sandboxId, fileTree, resolverContext, workspaceBase } = state;
-    if (!fileTree || !sandboxId) {
-      return {
-        toolResponse: `Error: No fileTree/sandboxId in agent state. The ${context.toolName} tool requires a virtual sandbox.`,
-        data: null,
-      };
-    }
-
-    const sandbox = createVirtualSandbox(
-      sandboxId,
-      fileTree,
-      provider.resolver,
-      resolverContext,
-      workspaceBase ?? "/",
-    );
-    const response = await handler(args, { ...context, sandbox });
-    const mutations = sandbox.fs.getMutations();
-
-    return {
-      toolResponse: response.toolResponse,
-      data: {
-        ...(response.data ?? {}),
-        treeMutations: mutations,
-      } as TResult & { treeMutations: TreeMutation<TMeta>[] },
-    };
-  };
-}

package/src/lib/.env

@@ -1 +0,0 @@
-E2B_API_KEY=e2b_39af116424059782e2aee6942fd70237cc2126c9

package/src/tools/bash/.env

@@ -1 +0,0 @@
-E2B_API_KEY=e2b_39af116424059782e2aee6942fd70237cc2126c9