@rigkit/engine 0.2.2 → 0.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigkit/engine",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "type": "module",
   "repository": {
     "type": "git",

package/src/authoring.ts

@@ -1,3 +1,4 @@
+import { RESERVED_WORKFLOW_OPERATION_IDS } from "./types.ts";
 import type {
   EnvResolver,
   RigkitConfigDefinition,
@@ -5,14 +6,14 @@ import type {
   OutputSchema,
   OutputSchemaValue,
   WorkflowDefinition,
-  WorkflowCreateDefinition,
-  WorkflowCreateHandler,
   WorkflowInputFieldDefinition,
   WorkflowInputShape,
   WorkflowOperationDefinition,
   WorkflowOperationInputBuilder,
   WorkflowOperationInputHelpers,
   WorkflowOperationOptions,
+  WorkflowWorkspaceOperationDefinition,
+  WorkflowWorkspaceOperationOptions,
   WorkflowNodeDefinition,
   WorkflowProviderDefinition,
   WorkflowProviderMap,
@@ -25,7 +26,7 @@ import type {
 } from "./types.ts";
 
 const reservedTaskContextKeys = new Set(["ctx", "runtime", "providers"]);
-const reservedHostOperationIds = new Set(["init", "doctor", "projects", "run", "ls", "help", "version", "completion"]);
+const reservedHostOperationIds = new Set<string>(RESERVED_WORKFLOW_OPERATION_IDS);
 
 const readEnv = (name: string, fallback?: string): string => {
   const value = process.env[name];
@@ -90,12 +91,11 @@ export function defineProvider<
   const ProviderId extends string,
   const Config extends object,
   Runtime = unknown,
-  WorkspaceContext extends object = object,
 >(
   providerId: ProviderId,
-  config: WorkflowProviderDefinition<ProviderId, Config, Runtime, WorkspaceContext>["config"],
+  config: WorkflowProviderDefinition<ProviderId, Config, Runtime>["config"],
   plugin?: unknown,
-): WorkflowProviderDefinition<ProviderId, Config, Runtime, WorkspaceContext> {
+): WorkflowProviderDefinition<ProviderId, Config, Runtime> {
   return {
     kind: "rigkit.provider",
     providerId,
@@ -120,14 +120,28 @@ export function isProviderDefinition(value: unknown): value is WorkflowProviderD
   return Boolean(value && typeof value === "object" && getKind(value) === "rigkit.provider");
 }
 
-function createSequence<Providers extends WorkflowProviderMap, InputContext extends JsonObject, OutputContext extends JsonObject>(
+function createSequence<
+  Providers extends WorkflowProviderMap,
+  InputContext extends JsonObject,
+  OutputContext extends JsonObject,
+  WorkspaceData extends object = JsonObject,
+  OperationIds extends string = never,
+  WorkspaceOperationIds extends string = never,
+>(
   app: WorkflowDefinition<string, Providers>,
   name: string,
   children: readonly WorkflowNodeDefinition<Providers, any, any>[],
-  workspace?: WorkflowWorkspaceDefinition<Providers, OutputContext>,
-  create?: WorkflowCreateDefinition<Providers, OutputContext>,
+  workspace?: WorkflowWorkspaceDefinition<Providers, OutputContext, any>,
   operations: readonly WorkflowOperationDefinition<Providers, any>[] = [],
-): WorkflowSequenceBuilder<Providers, InputContext, OutputContext> {
+  workspaceOperations: readonly WorkflowWorkspaceOperationDefinition<Providers, OutputContext, WorkspaceData, any>[] = [],
+): WorkflowSequenceBuilder<
+  Providers,
+  InputContext,
+  OutputContext,
+  WorkspaceData,
+  OperationIds,
+  WorkspaceOperationIds
+> {
   const node = {
     kind: "rigkit.workflow-node" as const,
     nodeKind: "sequence" as const,
@@ -135,15 +149,15 @@ function createSequence<Providers extends WorkflowProviderMap, InputContext exte
     workflow: app,
     children,
     workspaceDefinition: workspace,
-    createDefinition: create,
     operations,
+    workspaceOperations,
     task: (
       taskName: string,
       optionsOrHandler: WorkflowTaskOptions | WorkflowTaskHandler<Providers, OutputContext, any>,
       maybeHandler?: WorkflowTaskHandler<Providers, OutputContext, any>,
     ) => {
       const task = createTask(app, taskName, optionsOrHandler as any, maybeHandler as any);
-      return createSequence(app, name, [...children, task], workspace, create, operations);
+      return createSequence(app, name, [...children, task], workspace, operations, workspaceOperations);
     },
     step: (
       taskName: string,
@@ -151,11 +165,11 @@ function createSequence<Providers extends WorkflowProviderMap, InputContext exte
       maybeHandler?: WorkflowTaskHandler<Providers, OutputContext, any>,
     ) => {
       const task = createTask(app, taskName, optionsOrHandler as any, maybeHandler as any);
-      return createSequence(app, name, [...children, task], workspace, create, operations);
+      return createSequence(app, name, [...children, task], workspace, operations, workspaceOperations);
     },
     add: (child: WorkflowNodeDefinition<Providers, any, any>) => {
       assertSameWorkflow(app, child);
-      return createSequence(app, name, [...children, child], workspace, create, operations);
+      return createSequence(app, name, [...children, child], workspace, operations, workspaceOperations);
     },
     parallel: (branches: Record<string, WorkflowNodeDefinition<Providers, any, any>>) => {
       for (const [branchName, branch] of Object.entries(branches)) {
@@ -173,17 +187,39 @@ function createSequence<Providers extends WorkflowProviderMap, InputContext exte
         workflow: app,
         branches,
       };
-      return createSequence(app, name, [...children, parallelNode], workspace, create, operations);
+      return createSequence(app, name, [...children, parallelNode], workspace, operations, workspaceOperations);
+    },
+    workspace: (definition: WorkflowWorkspaceDefinition<Providers, OutputContext, any>) =>
+      createSequence(app, name, children, definition, operations, workspaceOperations),
+    operation: (id: string, options: WorkflowOperationOptions<Providers, any>) => {
+      const operation = createOperation(id, options);
+      assertUniqueOperationId(operations, operation.id, "Operation");
+      return createSequence(app, name, children, workspace, [...operations, operation], workspaceOperations);
+    },
+    workspaceOperation: (id: string, options: WorkflowWorkspaceOperationOptions<Providers, OutputContext, any, any>) => {
+      const operation = createWorkspaceOperation(id, options);
+      assertUniqueOperationId(workspaceOperations, operation.id, "Workspace operation");
+      return createSequence(app, name, children, workspace, operations, [...workspaceOperations, operation]);
     },
-    workspace: (definition: WorkflowWorkspaceDefinition<Providers, OutputContext>) =>
-      createSequence(app, name, children, definition, create, operations),
-    create: (handler: WorkflowCreateHandler<Providers, OutputContext, any>) =>
-      createSequence(app, name, children, workspace, { handler }, operations),
-    operation: (id: string, options: WorkflowOperationOptions<Providers, any>) =>
-      createSequence(app, name, children, workspace, create, [...operations, createOperation(id, options)]),
   };
 
-  return node as unknown as WorkflowSequenceBuilder<Providers, InputContext, OutputContext>;
+  return node as unknown as WorkflowSequenceBuilder<
+    Providers,
+    InputContext,
+    OutputContext,
+    WorkspaceData,
+    OperationIds,
+    WorkspaceOperationIds
+  >;
+}
+
+function assertUniqueOperationId(
+  operations: readonly { id: string }[],
+  id: string,
+  label: string,
+): void {
+  if (!operations.some((operation) => operation.id === id)) return;
+  throw new Error(`${label} id ${id} is already defined`);
 }
 
 function createOperation<Providers extends WorkflowProviderMap, Input extends object>(
@@ -199,9 +235,6 @@ function createOperation<Providers extends WorkflowProviderMap, Input extends ob
     id: normalized,
     title: options.title,
     description: options.description,
-    createsWorkspace: options.createsWorkspace,
-    requiredHostMethods: normalizeHostMethodRequirements(options.requiredHostMethods),
-    requiredHostCapabilities: normalizeHostCapabilityRequirements(options.requiredHostCapabilities),
     input: typeof options.input === "function"
       ? options.input(createOperationInputHelpers())
       : options.input,
@@ -209,31 +242,30 @@ function createOperation<Providers extends WorkflowProviderMap, Input extends ob
   };
 }
 
-function normalizeHostMethodRequirements(
-  methods: WorkflowOperationOptions<any, any>["requiredHostMethods"],
-) {
-  return methods?.map((method) => {
-    const id = method.id.trim();
-    if (!id) throw new Error(`Host method requirements must have non-empty ids`);
-    return {
-      id,
-      ...(method.modes?.length ? { modes: [...method.modes] } : {}),
-    };
-  });
-}
-
-function normalizeHostCapabilityRequirements(
-  capabilities: WorkflowOperationOptions<any, any>["requiredHostCapabilities"],
-) {
-  return capabilities?.map((capability) => {
-    const id = capability.id.trim();
-    if (!id) throw new Error(`Host capability requirements must have non-empty ids`);
-    const schemaHash = capability.schemaHash?.trim();
-    return {
-      id,
-      ...(schemaHash ? { schemaHash } : {}),
-    };
-  });
+function createWorkspaceOperation<
+  Providers extends WorkflowProviderMap,
+  Context extends JsonObject,
+  Data extends JsonObject,
+  Input extends object,
+>(
+  id: string,
+  options: WorkflowWorkspaceOperationOptions<Providers, Context, Data, Input>,
+): WorkflowWorkspaceOperationDefinition<Providers, Context, Data, Input> {
+  const normalized = id.trim();
+  if (!normalized) throw new Error(`Workspace operation ids must be non-empty`);
+  if (normalized.includes("/")) throw new Error(`Workspace operation ids cannot contain "/"`);
+  if (reservedHostOperationIds.has(normalized)) {
+    throw new Error(`Workspace operation id ${normalized} is reserved by the Rigkit host`);
+  }
+  return {
+    id: normalized,
+    title: options.title,
+    description: options.description,
+    input: typeof options.input === "function"
+      ? options.input(createOperationInputHelpers())
+      : options.input,
+    run: options.run,
+  };
 }
 
 function createOperationInputHelpers(): WorkflowOperationInputHelpers {

package/src/authoring.typecheck.ts

@@ -0,0 +1,67 @@
+import { sequence } from "./authoring.ts";
+
+sequence("normal-operation-ids")
+  .operation("open" as const, {
+    run: async () => null,
+  })
+  // @ts-expect-error duplicate operation ids are rejected for literal ids
+  .operation("open" as const, {
+    run: async () => null,
+  });
+
+sequence("workspace-operation-ids")
+  .step("prepare", async () => ({ snapshotId: "snap-1" }))
+  .workspace({
+    create: async ({ workflow, workspace }) => {
+      const snapshotId: string = workflow.ctx.snapshotId;
+      const name: string = workspace.name;
+      void snapshotId;
+      void name;
+      return { vmId: "vm-1", test: "ok" };
+    },
+    remove: async ({ workspace }) => {
+      const vmId: string = workspace.ctx.vmId;
+      const test: string = workspace.ctx.test;
+      void vmId;
+      void test;
+      // @ts-expect-error workspace context is read-only
+      workspace.ctx.vmId = "next";
+      // @ts-expect-error provider resources are not part of the workspace authoring API
+      workspace.resources;
+    },
+  })
+  .workspaceOperation("open-cmux" as const, {
+    run: async ({ workspace }) => {
+      const vmId: string = workspace.ctx.vmId;
+      void vmId;
+      // @ts-expect-error missing data properties are rejected
+      workspace.ctx.missing;
+      return null;
+    },
+  })
+  // @ts-expect-error duplicate workspace operation ids are rejected for literal ids
+  .workspaceOperation("open-cmux" as const, {
+    run: async () => null,
+  });
+
+sequence("reserved-operation-id")
+  // @ts-expect-error reserved operation ids are rejected for literal ids
+  .operation("create" as const, {
+    run: async () => null,
+  });
+
+sequence("reserved-workspace-operation-id")
+  .workspace({
+    create: async () => ({}),
+    remove: async () => {},
+  })
+  // @ts-expect-error reserved workspace operation ids are rejected for literal ids
+  .workspaceOperation("remove" as const, {
+    run: async () => null,
+  });
+
+sequence("slash-operation-id")
+  // @ts-expect-error operation ids cannot contain slashes
+  .operation("workspace/open" as const, {
+    run: async () => null,
+  });

package/src/db/schema/core.ts

@@ -6,19 +6,15 @@ export const workspaces = sqliteTable(
   {
     id: text("id").primaryKey(),
     name: text("name").notNull(),
-    providerId: text("provider_id").notNull(),
     workflow: text("workflow").notNull(),
-    resourceId: text("resource_id").notNull(),
-    snapshotId: text("snapshot_id"),
-    sourceRef: text("source_ref_json", { mode: "json" }).$type<JsonValue>().notNull(),
-    context: text("context_json", { mode: "json" }).$type<Record<string, JsonValue>>().notNull(),
+    workflowCtx: text("workflow_ctx_json", { mode: "json" }).$type<Record<string, JsonValue>>().notNull(),
     createdAt: text("created_at").notNull(),
     updatedAt: text("updated_at").notNull(),
-    metadata: text("metadata_json", { mode: "json" }).$type<Record<string, JsonValue>>().notNull(),
+    ctx: text("ctx_json", { mode: "json" }).$type<Record<string, JsonValue>>().notNull(),
   },
   (table) => [
     uniqueIndex("workspaces_name_idx").on(table.name),
-    index("workspaces_provider_resource_idx").on(table.providerId, table.resourceId),
+    index("workspaces_workflow_idx").on(table.workflow),
   ],
 );
 

package/src/engine.test.ts

@@ -9,10 +9,9 @@ import { createStateStore } from "./state.ts";
 import type {
   BaseProviderPlugin,
   ProviderRuntimeContext,
-  SshConnection,
   WorkflowProviderController,
 } from "./provider/types.ts";
-import type { DevMachineEvent, ExecResult, JsonValue, WorkspaceRecord } from "./types.ts";
+import type { DevMachineEvent, ExecResult, JsonValue } from "./types.ts";
 
 describe("DevMachineEngine workflow runtime", () => {
   test("plans, applies graph nodes, reuses graph cache, and forks workspaces", async () => {
@@ -58,38 +57,48 @@ describe("DevMachineEngine workflow runtime", () => {
             return { vm: ctx.left.vm, summary: ctx.right.data };
           })
           .workspace({
-            source: (ctx) => ctx.vm,
-            cwd: "/workspace/repo",
-            onCreated: async ({ providers, workspace, ctx, local, providerContext }) => {
-              if (ctx.summary !== "right-ready") throw new Error("missing final context");
-              if (providerContext.authority !== "fake-authority") throw new Error("missing provider context");
-              const vm = providers.test.fromWorkspace(workspace);
+            create: async ({ providers, workflow, workspace, local }) => {
+              if (workflow.ctx.summary !== "right-ready") throw new Error("missing final context");
+              const vm = await providers.test.fromSnapshot(workflow.ctx.vm);
               await vm.exec("touch /tmp/workspace-" + workspace.name, { name: "mark workspace" });
-              await local.open("vscode://" + workspace.name);
+              await local.open("created://" + workspace.name);
+              return {
+                summary: workflow.ctx.summary,
+                repoPath: "/workspace/repo",
+                vmId: vm.vmId,
+              };
+            },
+            remove: async ({ providers, workspace, workflow }) => {
+              if (workflow.ctx.summary !== "right-ready") throw new Error("missing final context on remove");
+              const vm = providers.test.fromId(workspace.ctx.vmId);
+              await vm.exec("touch /tmp/remove-" + workspace.name, { name: "mark workspace remove" });
             },
-            onOpen: async ({ providers, workspace, ctx, providerContext }) => {
-              if (ctx.summary !== "right-ready") throw new Error("missing final context on open");
-              if (providerContext.authority !== "fake-authority") throw new Error("missing provider context on open");
-              const vm = providers.test.fromWorkspace(workspace);
+          })
+          .workspaceOperation("open", {
+            run: async ({ providers, workspace, workflow, local }) => {
+              if (workflow.ctx.summary !== "right-ready") throw new Error("missing final context on open");
+              if (workspace.ctx.summary !== "right-ready") throw new Error("missing workspace context");
+              const vm = providers.test.fromId(workspace.ctx.vmId);
               await vm.exec("touch /tmp/open-" + workspace.name, { name: "mark workspace open" });
+              await local.open("open://" + workspace.name);
             },
           })
           .operation("mark", {
-            requiredHostCapabilities: [{ id: "cmux.open", schemaHash: "sha256:cmux-open-schema" }],
             input: (workflow) =>
               workflow
                 .workspaceInput({ name: "workspace", position: 0 })
                 .extend({
                   label: workflow.string({ defaultValue: "marked" }),
-                }),
+            }),
             run: async ({ input, providers, local }) => {
-              const vm = providers.test.fromWorkspace(input.workspace);
+              const vm = providers.test.fromId(input.workspace.ctx.vmId);
               await vm.exec("touch /tmp/mark-" + input.workspace.name, { name: "mark via operation" });
               await local.open("mark://" + input.workspace.name);
               return {
                 workspace: input.workspace.name,
                 label: input.label,
-                cwd: input.workspace.cwd ?? null,
+                repoPath: input.workspace.ctx.repoPath,
+                summary: input.workspace.ctx.summary,
               };
             },
           });
@@ -124,7 +133,7 @@ describe("DevMachineEngine workflow runtime", () => {
     ]);
 
     const applied = await engine.apply();
-    expect(applied.snapshotId).toBe("snap-2");
+    expect(applied.context.vm).toEqual({ provider: "test", kind: "vmSnapshot", snapshotId: "snap-2" });
     expect(events).toContainEqual({
       type: "log.output",
       nodePath: "base.first",
@@ -140,37 +149,33 @@ describe("DevMachineEngine workflow runtime", () => {
     expect(cached.finalContext?.summary).toBe("right-ready");
 
     const workspace = await engine.fork({ name: "work" });
-    expect(workspace.snapshotId).toBe("snap-2");
     expect(workspace.name).toBe("work");
-    expect(workspace.resourceId).toBe("workspace-work");
+    expect(workspace.ctx).toMatchObject({
+      summary: "right-ready",
+      repoPath: "/workspace/repo",
+      vmId: "vm-3",
+    });
     expect(engine.listWorkspaces()).toHaveLength(1);
-    expect(opened).toEqual(["vscode://work"]);
-    expect(provider.workspaceContextResourceIds).toEqual(["workspace-work"]);
-    expect(provider.hasFile("workspace-work", "/tmp/workspace-work")).toBe(true);
+    expect(opened).toEqual(["created://work"]);
+    expect(provider.hasFile("vm-3", "/tmp/workspace-work")).toBe(true);
 
-    const markOperation = engine.listOperations().find((operation) => operation.id === "mark");
-    expect(markOperation?.requiredHostCapabilities).toEqual([
-      { id: "cmux.open", schemaHash: "sha256:cmux-open-schema" },
-    ]);
+    const openOperation = engine.listRuntimeWorkspaceOperations().find((operation) => operation.id === "open");
+    expect(openOperation?.id).toBe("open");
     const marked = await engine.runOperation({ operation: "mark", input: { workspace: "work" } });
-    expect(marked).toEqual({ workspace: "work", label: "marked", cwd: "/workspace/repo" });
-    expect(opened).toEqual(["vscode://work", "mark://work"]);
-    expect(provider.hasFile("workspace-work", "/tmp/mark-work")).toBe(true);
+    expect(marked).toEqual({ workspace: "work", label: "marked", repoPath: "/workspace/repo", summary: "right-ready" });
+    expect(opened).toEqual(["created://work", "mark://work"]);
+    expect(provider.hasFile("vm-3", "/tmp/mark-work")).toBe(true);
 
-    const terminal = await engine.attachTerminal({ workspaceOrVmId: "work", printOnly: true });
-    expect(terminal.command).toBe("ssh workspace-work");
-    expect(provider.workspaceContextResourceIds).toEqual(["workspace-work", "workspace-work"]);
-    expect(provider.hasFile("workspace-work", "/tmp/open-work")).toBe(true);
+    await engine.runRuntimeOperation({ operation: "work/open" });
+    expect(opened).toEqual(["created://work", "mark://work", "open://work"]);
+    expect(provider.hasFile("vm-3", "/tmp/open-work")).toBe(true);
 
-    const workspaceSnapshot = await engine.snapshotWorkspace({ workspace: "work", label: "verified-work" });
-    expect(workspaceSnapshot.metadata.snapshotId).toBe("snap-3");
-    expect(workspaceSnapshot.nodeName).toBe("verified-work");
-
-    await engine.deleteWorkspace({ workspace: "work" });
+    await engine.runRuntimeOperation({ operation: "work/remove" });
     expect(engine.listWorkspaces()).toHaveLength(0);
+    expect(provider.hasFile("vm-3", "/tmp/remove-work")).toBe(true);
   });
 
-  test("creates workspaces from config create callbacks and exposes persisted workspace data", async () => {
+  test("creates workspaces from workspace definitions and exposes persisted workspace context", async () => {
     const projectDir = mkdtempSync(join(tmpdir(), "rigkit-"));
     writeFileSync(
       join(projectDir, "rig.config.ts"),
@@ -188,27 +193,36 @@ describe("DevMachineEngine workflow runtime", () => {
               repoPath: "/workspace/repo",
             };
           })
-          .create(async ({ ctx, name, providers }) => {
-            const vm = await providers.test.fromSnapshot(ctx.vm);
-            await vm.exec("touch /tmp/create-" + name, { name: "create workspace" });
-            return {
-              name,
-              vmId: vm.vmId,
-              sourceSnapshot: ctx.vm,
-              repoPath: ctx.repoPath,
-              ready: true,
-            };
+          .workspace({
+            create: async ({ workflow, workspace, providers }) => {
+              const vm = await providers.test.fromSnapshot(workflow.ctx.vm);
+              await vm.exec("touch /tmp/create-" + workspace.name, { name: "create workspace" });
+              return {
+                name: workspace.name,
+                vmId: vm.vmId,
+                sourceSnapshot: workflow.ctx.vm,
+                repoPath: workflow.ctx.repoPath,
+                ready: true,
+              };
+            },
+            remove: async () => {},
           })
           .operation("inspect", {
             input: (workflow) => workflow.workspaceInput({ name: "workspace", position: 0 }),
             run: async ({ input, local }) => {
               await local.open("created://" + input.workspace.name);
               return {
-                vmId: input.workspace.data.vmId,
-                repoPath: input.workspace.data.repoPath,
-                ready: input.workspace.data.ready,
+                vmId: input.workspace.ctx.vmId,
+                repoPath: input.workspace.ctx.repoPath,
+                ready: input.workspace.ctx.ready,
               };
             },
+          })
+          .workspaceOperation("status", {
+            run: async ({ workspace }) => ({
+              workspace: workspace.name,
+              vmId: workspace.ctx.vmId,
+            }),
           });
 
         export default defineConfig({
@@ -238,9 +252,7 @@ describe("DevMachineEngine workflow runtime", () => {
 
     const workspace = await engine.fork({ name: "created" });
     expect(workspace.name).toBe("created");
-    expect(workspace.providerId).toBe("config");
-    expect(workspace.resourceId).toBe("vm-2");
-    expect(workspace.metadata).toMatchObject({
+    expect(workspace.ctx).toMatchObject({
       name: "created",
       vmId: "vm-2",
       repoPath: "/workspace/repo",
@@ -255,6 +267,9 @@ describe("DevMachineEngine workflow runtime", () => {
       ready: true,
     });
     expect(opened).toEqual(["created://created"]);
+
+    const status = await engine.runRuntimeOperation({ operation: "created/status" });
+    expect(status).toEqual({ workspace: "created", vmId: "vm-2" });
   });
 
   test("loads multiple workflows from defineConfig", async () => {
@@ -391,20 +406,16 @@ describe("DevMachineEngine workflow runtime", () => {
     state.saveWorkspace({
       id: "workspace-2",
       name: "demo",
-      providerId: "freestyle",
       workflow: "smoke",
-      resourceId: "resource-2",
-      snapshotId: "snap-2",
-      sourceRef: { snapshotId: "snap-2" },
-      context: { ready: true },
+      workflowCtx: { ready: true },
       createdAt: now,
       updatedAt: now,
-      metadata: { ready: true },
+      ctx: { ready: true },
     });
     expect(state.getWorkspace("demo")).toMatchObject({
       name: "demo",
       workflow: "smoke",
-      resourceId: "resource-2",
+      ctx: { ready: true },
     });
   });
 
@@ -775,14 +786,13 @@ type FakeVm = {
 type FakeRuntime = {
   createVm(): Promise<FakeVm>;
   fromSnapshot(ref: FakeSnapshotRef): Promise<FakeVm>;
-  fromWorkspace(workspace: Pick<WorkspaceRecord, "resourceId">): FakeVm;
+  fromId(vmId: string): FakeVm;
   openTerminal(label: string, command: string): Promise<{ finished: true }>;
 };
 
-class FakeWorkflowProvider implements WorkflowProviderController<FakeRuntime, { authority: string }> {
+class FakeWorkflowProvider implements WorkflowProviderController<FakeRuntime> {
   readonly providerId = "test";
   snapshots: FakeSnapshotRef[] = [];
-  workspaceContextResourceIds: string[] = [];
   private nextVm = 1;
   private files = new Map<string, Set<string>>();
   terminalStopped = 0;
@@ -797,7 +807,7 @@ class FakeWorkflowProvider implements WorkflowProviderController<FakeRuntime, {
     return {
       createVm: async () => this.createVm(context),
       fromSnapshot: async () => this.createVm(context),
-      fromWorkspace: (workspace) => this.vmRuntime({ vmId: workspace.resourceId }, context),
+      fromId: (vmId) => this.vmRuntime({ vmId }, context),
       openTerminal: async (label, command) => {
         const completed = this.options.terminalCompleted ?? Promise.resolve({ finished: true as const });
         return await context.interaction.present({
@@ -817,42 +827,6 @@ class FakeWorkflowProvider implements WorkflowProviderController<FakeRuntime, {
     return isFakeSnapshotRef(ref);
   }
 
-  workspace = {
-    canUse: (ref: JsonValue) => isFakeSnapshotRef(ref),
-    createWorkspace: async (ref: JsonValue, input: { name: string }) => {
-      if (!isFakeSnapshotRef(ref)) throw new Error("bad ref");
-      const resourceId = `workspace-${input.name}`;
-      this.files.set(resourceId, new Set());
-      return {
-        providerId: "test",
-        resourceId,
-        snapshotId: ref.snapshotId,
-        sourceRef: ref,
-      };
-    },
-    deleteWorkspace: async () => {},
-    snapshotWorkspace: async (workspace: WorkspaceRecord) => {
-      const ref = this.createSnapshot({ vmId: workspace.resourceId });
-      return {
-        providerId: "test",
-        resourceId: workspace.resourceId,
-        snapshotId: ref.snapshotId,
-        sourceRef: ref,
-      };
-    },
-    ssh: async (workspaceOrResourceId: string): Promise<SshConnection> => ({
-      kind: "ssh",
-      host: "fake",
-      username: workspaceOrResourceId,
-      auth: { type: "token", token: "fake" },
-      command: `ssh ${workspaceOrResourceId}`,
-    }),
-    workspaceContext: (workspace: WorkspaceRecord) => {
-      this.workspaceContextResourceIds.push(workspace.resourceId);
-      return { authority: "fake-authority" };
-    },
-  };
-
   hasFile(vmId: string, path: string): boolean {
     return this.files.get(vmId)?.has(path) ?? false;
   }