@rigkit/cli 0.2.7 → 0.2.8

package/src/completion.ts

@@ -1,5 +1,7 @@
+import { readdirSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { getOrStartRuntime } from "@rigkit/runtime-client";
+import { isRigConfigFileName } from "./project.ts";
 
 export type CompletionShell = "bash" | "fish" | "zsh";
 
@@ -7,6 +9,7 @@ export type CompletionItem = {
   value: string;
   description?: string;
   noSpace?: boolean;
+  group?: string;
 };
 
 type CompleteRigInput = {
@@ -15,78 +18,121 @@ type CompleteRigInput = {
   cwd?: string;
 };
 
-const COMMANDS: CompletionItem[] = [
+const GROUP_COMMANDS = "Commands";
+const GROUP_SUBCOMMANDS = "Subcommands";
+const GROUP_FLAGS = "Flags";
+const GROUP_GLOBAL = "Global flags";
+const GROUP_TARGETS = "Targets";
+const GROUP_WORKSPACES = "Workspaces";
+const GROUP_OPERATIONS = "Operations";
+const GROUP_VALUES = "Values";
+const GROUP_PATHS = "Paths";
+const GROUP_SHELLS = "Shells";
+
+const COMMANDS: CompletionItem[] = withGroup(GROUP_COMMANDS, [
   { value: "help", description: "show CLI help" },
   { value: "init", description: "initialize a Rigkit project" },
   { value: "plan", description: "plan project workflow changes" },
   { value: "apply", description: "apply project workflow changes" },
   { value: "create", description: "create a workspace" },
+  { value: "rm", description: "remove a workspace" },
   { value: "run", description: "run a workspace operation" },
   { value: "ls", description: "list project workspaces" },
+  { value: "cache", description: "inspect and clear Rigkit cache" },
   { value: "projects", description: "discover Rigkit projects" },
   { value: "doctor", description: "show runtime diagnostics" },
   { value: "version", description: "show CLI version" },
   { value: "completion", description: "generate shell completion" },
-];
+]);
 
 const COMMAND_ALIASES = new Map<string, string>();
 
-const GLOBAL_OPTIONS: CompletionItem[] = [
-  { value: "-C", description: "project directory" },
-  { value: "--project", description: "project directory" },
-  { value: "--config", description: "exact config file" },
-  { value: "--state", description: "local state database path" },
-  { value: "--json", description: "print JSON" },
-  { value: "--help", description: "show help" },
-  { value: "--version", description: "show version" },
-];
+const GLOBAL_OPTIONS: CompletionItem[] = withGroup(GROUP_GLOBAL, [
+  { value: "-chdir=", description: "working directory", noSpace: true },
+  { value: "-config=", description: "config file", noSpace: true },
+  { value: "-state=", description: "state database path", noSpace: true },
+  { value: "-json", description: "print JSON" },
+  { value: "-help", description: "show help" },
+  { value: "-version", description: "show version" },
+]);
 
 const COMMAND_OPTIONS: Record<string, CompletionItem[]> = {
-  init: [
+  init: withGroup(GROUP_FLAGS, [
     { value: "--name", description: "project and workflow name" },
     { value: "--api-key", description: "Freestyle API key" },
     { value: "--package-manager", description: "npm, bun, pnpm, or skip" },
     { value: "--force", description: "overwrite existing config" },
     { value: "--json", description: "print JSON" },
-  ],
-  plan: [
+  ]),
+  plan: withGroup(GROUP_FLAGS, [
     { value: "--all", description: "run against every discovered project" },
     { value: "--discover", description: "discover projects below the selected directory" },
     { value: "--json", description: "print JSON" },
-  ],
-  apply: [
+  ]),
+  apply: withGroup(GROUP_FLAGS, [
     { value: "--all", description: "run against every discovered project" },
     { value: "--discover", description: "discover projects below the selected directory" },
     { value: "--json", description: "print JSON" },
-  ],
-  create: [
+  ]),
+  create: withGroup(GROUP_FLAGS, [
     { value: "--json", description: "print JSON" },
-  ],
-  run: [
+  ]),
+  rm: withGroup(GROUP_FLAGS, [
+    { value: "-y", description: "skip confirmation" },
+    { value: "--yes", description: "skip confirmation" },
     { value: "--json", description: "print JSON" },
-  ],
-  ls: [
-    { value: "workspaces", description: "list workspaces" },
-    { value: "snapshots", description: "list snapshots" },
-    { value: "config", description: "show project config" },
+  ]),
+  run: withGroup(GROUP_FLAGS, [
     { value: "--json", description: "print JSON" },
+  ]),
+  ls: [
+    ...withGroup(GROUP_TARGETS, [
+      { value: "workspaces", description: "list workspaces" },
+      { value: "snapshots", description: "list snapshots" },
+      { value: "config", description: "show project config" },
+    ]),
+    ...withGroup(GROUP_FLAGS, [
+      { value: "--json", description: "print JSON" },
+    ]),
   ],
-  projects: [
+  projects: withGroup(GROUP_FLAGS, [
     { value: "--json", description: "print JSON" },
-  ],
-  completion: [
+  ]),
+  cache: withGroup(GROUP_SUBCOMMANDS, [
+    { value: "ls", description: "list cache entries" },
+    { value: "clear", description: "clear cache entries" },
+  ]),
+  completion: withGroup(GROUP_SHELLS, [
     { value: "bash", description: "Bash completion" },
     { value: "fish", description: "fish completion" },
     { value: "zsh", description: "zsh completion" },
-  ],
+  ]),
+};
+
+const CACHE_SUBCOMMAND_OPTIONS: Record<string, CompletionItem[]> = {
+  ls: withGroup(GROUP_FLAGS, [
+    { value: "--json", description: "print JSON" },
+  ]),
+  clear: withGroup(GROUP_FLAGS, [
+    { value: "--local", description: "clear local cache entries" },
+    { value: "--global", description: "clear global cache fragments" },
+    { value: "--all", description: "clear every global fragment" },
+    { value: "--json", description: "print JSON" },
+  ]),
 };
 
+function withGroup(group: string, items: Omit<CompletionItem, "group">[]): CompletionItem[] {
+  return items.map((item) => ({ ...item, group }));
+}
+
 const PROJECT_OPERATION_COMMANDS = new Set(["plan", "apply", "create"]);
 
 const OPTIONS_WITH_VALUES = new Set([
-  "-C",
-  "--project",
+  "-chdir",
+  "--chdir",
+  "-config",
   "--config",
+  "-state",
   "--state",
   "--name",
   "--api-key",
@@ -123,7 +169,26 @@ export async function completeRig(input: CompleteRigInput): Promise<CompletionIt
   const before = words.slice(1, currentIndex);
   const command = findCommand(before);
 
-  if (expectsOptionValue(before)) return [];
+  const inlineOption = parseInlineValueOption(current);
+  if (inlineOption) {
+    return await completeOptionValue({
+      option: inlineOption.option,
+      current: inlineOption.value,
+      cwd,
+      words,
+      inlinePrefix: inlineOption.prefix,
+    });
+  }
+
+  const valueOption = optionExpectingValue(before);
+  if (valueOption) {
+    return await completeOptionValue({
+      option: valueOption,
+      current,
+      cwd,
+      words,
+    });
+  }
 
   if (!command) {
     return filterItems(
@@ -135,14 +200,28 @@ export async function completeRig(input: CompleteRigInput): Promise<CompletionIt
   }
 
   if (current.startsWith("-")) {
+    if (command === "rm") {
+      const remove = parseRemoveCommand(before);
+      if (remove.workspace) {
+        const operation = await safeResolveWorkspaceOperation(resolveProjectDir(words, cwd), "remove");
+        return filterItems([
+          ...(operation?.cli?.options ?? []).flatMap((option) => [
+            { value: option.flag, description: option.name, group: GROUP_FLAGS },
+            ...(option.aliases ?? []).map((alias) => ({ value: alias, description: option.name, group: GROUP_FLAGS })),
+          ]),
+          ...COMMAND_OPTIONS.rm,
+          ...GLOBAL_OPTIONS,
+        ], current);
+      }
+    }
     if (command === "run") {
       const run = parseWorkspaceRunCommand(before);
       if (run.workspace && run.operation) {
         const operation = await safeResolveWorkspaceOperation(resolveProjectDir(words, cwd), run.operation);
         return filterItems([
           ...(operation?.cli?.options ?? []).flatMap((option) => [
-            { value: option.flag, description: option.name },
-            ...(option.aliases ?? []).map((alias) => ({ value: alias, description: option.name })),
+            { value: option.flag, description: option.name, group: GROUP_FLAGS },
+            ...(option.aliases ?? []).map((alias) => ({ value: alias, description: option.name, group: GROUP_FLAGS })),
           ]),
           ...COMMAND_OPTIONS.run,
           ...GLOBAL_OPTIONS,
@@ -160,6 +239,12 @@ export async function completeRig(input: CompleteRigInput): Promise<CompletionIt
         ...GLOBAL_OPTIONS,
       ], current);
     }
+    if (command === "cache") {
+      return filterItems([
+        ...cacheOptionTargets(before),
+        ...GLOBAL_OPTIONS,
+      ], current);
+    }
     return filterItems([...(COMMAND_OPTIONS[command] ?? []), ...GLOBAL_OPTIONS], current);
   }
 
@@ -171,6 +256,11 @@ export async function completeRig(input: CompleteRigInput): Promise<CompletionIt
     if (!run.operation) return filterItems(await safeWorkspaceOperationTargets(resolveProjectDir(words, cwd)), current);
   }
 
+  if (command === "rm") {
+    const remove = parseRemoveCommand(before);
+    if (!remove.workspace) return filterItems(await workspaceTargets(resolveProjectDir(words, cwd)), current);
+  }
+
   if (command === "completion" && positionalCount === 0) {
     return filterItems(COMMAND_OPTIONS.completion, current);
   }
@@ -179,15 +269,25 @@ export async function completeRig(input: CompleteRigInput): Promise<CompletionIt
     return filterItems(COMMAND_OPTIONS.ls, current);
   }
 
+  if (command === "cache") {
+    const cache = parseCacheCommand(before);
+    if (!cache.subcommand) return filterItems(COMMAND_OPTIONS.cache ?? [], current);
+    return filterItems(cacheOptionTargets(before), current);
+  }
+
   return [];
 }
 
 export function formatCompletionItems(items: CompletionItem[], shell: CompletionShell): string {
   const lines = items.map((item) => {
     if (shell === "bash") return item.value;
-    if (shell === "zsh" && item.noSpace) {
-      return `${item.value}\t${item.description ?? ""}\tnospace`;
+    if (shell === "zsh") {
+      const description = item.description ?? "";
+      const marker = item.noSpace ? "nospace" : "";
+      const group = item.group ?? "";
+      return `${item.value}\t${description}\t${marker}\t${group}`;
     }
+    // fish: legacy two-column format works fine; descriptions render dim by default
     return item.description ? `${item.value}\t${item.description}` : item.value;
   });
   return lines.join("\n");
@@ -228,37 +328,55 @@ complete -c rig -f -a "(__rig_complete)"
   }
 
 return `#compdef rig
-# rig zsh completion
+# rig zsh completion — auto-generated by \`rig completion zsh\`.
+# Visual defaults are scoped to :completion:*:rig:* so they don't override your
+# global completion theme. Group headers render bold blue; descriptions inherit
+# your usual style.
+
+() {
+  zstyle ':completion:*:rig:*:descriptions' format $'\\e[1;34m%d\\e[0m'
+  zstyle ':completion:*:rig:*' group-name ''
+  zstyle ':completion:*:rig:*' verbose true
+}
+
 _rig() {
-  local -a raw values displays nospace_values nospace_displays
-  local line value description rest marker display
+  local raw line value description marker group key tag
+  local -A bucket_specs bucket_groups bucket_data
   raw=("\${(@f)$(command rig __complete --shell zsh --index $((CURRENT - 1)) -- "\${words[@]}" 2>/dev/null)}")
+
   for line in "\${raw[@]}"; do
-    value="\${line%%$'\\t'*}"
-    description=""
-    marker=""
-    if [[ "$line" == *$'\\t'* ]]; then
-      rest="\${line#*$'\\t'}"
-      description="\${rest%%$'\\t'*}"
-      if [[ "$rest" == *$'\\t'* ]]; then
-        marker="\${rest#*$'\\t'}"
-      fi
-    fi
-    display="\${value}"
+    [[ -z "$line" ]] && continue
+    local -a parts
+    parts=("\${(@s:	:)line}")
+    value="\${parts[1]}"
+    description="\${parts[2]:-}"
+    marker="\${parts[3]:-}"
+    group="\${parts[4]:-}"
+    [[ -z "$group" ]] && group="rig"
+    key="\${group}|\${marker}"
+    bucket_groups[$key]="$group"
+    bucket_specs[$key]="$marker"
     if [[ -n "$description" ]]; then
-      display="\${value} -- \${description}"
+      bucket_data[$key]+="\${value}:\${description}"$'\\n'
+    else
+      bucket_data[$key]+="\${value}"$'\\n'
     fi
-    if [[ "$marker" == "nospace" ]]; then
-      nospace_values+=("\${value}")
-      nospace_displays+=("\${display}")
+  done
+
+  for key in "\${(@k)bucket_data}"; do
+    local -a matches
+    matches=("\${(@f)bucket_data[$key]}")
+    matches=("\${(@)matches:#}")
+    tag="\${bucket_groups[$key]//[^A-Za-z0-9]/_}"
+    [[ -z "$tag" ]] && tag="rig"
+    if [[ "\${bucket_specs[$key]}" == "nospace" ]]; then
+      _describe -t "$tag" "\${bucket_groups[$key]}" matches -S ''
     else
-      values+=("\${value}")
-      displays+=("\${display}")
+      _describe -t "$tag" "\${bucket_groups[$key]}" matches
     fi
   done
-  (( \${#nospace_values} )) && compadd -S '' -ld nospace_displays -a nospace_values
-  (( \${#values} )) && compadd -ld displays -a values
 }
+
 compdef _rig rig
 `;
 }
@@ -323,38 +441,269 @@ function parseWorkspaceRunCommand(words: string[]): { workspace?: string; operat
   return { workspace: args[0], operation: args[1], args: args.slice(2) };
 }
 
-function expectsOptionValue(words: string[]): boolean {
+function parseRemoveCommand(words: string[]): { workspace?: string; args: string[] } {
+  let foundRemove = false;
+  const args: string[] = [];
+  for (let index = 0; index < words.length; index += 1) {
+    const word = words[index]!;
+    if (OPTIONS_WITH_VALUES.has(word)) {
+      index += 1;
+      continue;
+    }
+    if (word.includes("=") && OPTIONS_WITH_VALUES.has(word.slice(0, word.indexOf("=")))) continue;
+    if (word.startsWith("-")) continue;
+    if (!foundRemove) {
+      if (word === "rm") foundRemove = true;
+      continue;
+    }
+    args.push(word);
+  }
+  return { workspace: args[0], args: args.slice(1) };
+}
+
+function parseCacheCommand(words: string[]): { subcommand?: string; args: string[] } {
+  let foundCache = false;
+  const args: string[] = [];
+  for (let index = 0; index < words.length; index += 1) {
+    const word = words[index]!;
+    if (OPTIONS_WITH_VALUES.has(word)) {
+      index += 1;
+      continue;
+    }
+    if (word.startsWith("--") && word.includes("=")) continue;
+    if (word.startsWith("-")) continue;
+    if (!foundCache) {
+      if (word === "cache") foundCache = true;
+      continue;
+    }
+    args.push(word);
+  }
+  return { subcommand: args[0], args: args.slice(1) };
+}
+
+function cacheOptionTargets(words: string[]): CompletionItem[] {
+  const subcommand = parseCacheCommand(words).subcommand;
+  return subcommand ? CACHE_SUBCOMMAND_OPTIONS[subcommand] ?? [] : [];
+}
+
+function optionExpectingValue(words: string[]): string | undefined {
   const previous = words.at(-1);
-  return Boolean(previous && OPTIONS_WITH_VALUES.has(previous));
+  return previous && OPTIONS_WITH_VALUES.has(previous) ? previous : undefined;
+}
+
+async function completeOptionValue(input: {
+  option: string;
+  current: string;
+  cwd: string;
+  words: string[];
+  inlinePrefix?: string;
+}): Promise<CompletionItem[]> {
+  let items: CompletionItem[];
+  switch (input.option) {
+    case "-chdir":
+    case "--chdir":
+      items = completeDirectories(input.cwd, input.current);
+      break;
+    case "-config":
+    case "--config":
+      items = completeConfigPaths(projectBaseDir(input.words, input.cwd), input.current);
+      break;
+    case "--package-manager":
+      items = filterItems([
+        { value: "npm", group: GROUP_VALUES },
+        { value: "bun", group: GROUP_VALUES },
+        { value: "pnpm", group: GROUP_VALUES },
+        { value: "skip", group: GROUP_VALUES },
+      ], input.current);
+      break;
+    case "-state":
+    case "--state":
+      items = completeFilesystemPaths(input.cwd, input.current);
+      break;
+    default:
+      items = [];
+  }
+
+  if (!input.inlinePrefix) return items;
+  return items.map((item) => ({
+    ...item,
+    value: `${input.inlinePrefix}${item.value}`,
+  }));
+}
+
+function parseInlineValueOption(current: string): { option: string; value: string; prefix: string } | undefined {
+  const index = current.indexOf("=");
+  if (index < 0) return undefined;
+  const option = current.slice(0, index);
+  if (!OPTIONS_WITH_VALUES.has(option)) return undefined;
+  return {
+    option,
+    value: current.slice(index + 1),
+    prefix: current.slice(0, index + 1),
+  };
 }
 
 function resolveProjectDir(words: string[], cwd: string): { projectDir: string; configPath: string } {
+  let chdir: string | undefined;
+  let config: string | undefined;
   for (let index = 0; index < words.length; index += 1) {
     const word = words[index]!;
-    if (word === "-C" || word === "--project") {
-      const value = words[index + 1];
-      if (value) return projectPaths(resolve(cwd, value));
+    if (word === "-chdir" || word === "--chdir") {
+      chdir = words[index + 1];
+      index += 1;
+      continue;
+    }
+    if (word.startsWith("-chdir=")) {
+      chdir = word.slice("-chdir=".length);
+      continue;
     }
-    if (word.startsWith("--project=")) {
-      return projectPaths(resolve(cwd, word.slice("--project=".length)));
+    if (word.startsWith("--chdir=")) {
+      chdir = word.slice("--chdir=".length);
+      continue;
     }
-    if (word === "--config") {
-      const value = words[index + 1];
-      if (value) return { projectDir: dirname(resolve(cwd, value)), configPath: resolve(cwd, value) };
+    if (word === "-config" || word === "--config") {
+      config = words[index + 1];
+      index += 1;
+      continue;
+    }
+    if (word.startsWith("-config=")) {
+      config = word.slice("-config=".length);
+      continue;
     }
     if (word.startsWith("--config=")) {
-      const configPath = resolve(cwd, word.slice("--config=".length));
-      return { projectDir: dirname(configPath), configPath };
+      config = word.slice("--config=".length);
+      continue;
     }
   }
 
-  return projectPaths(cwd);
+  const baseDir = resolve(cwd, chdir ?? ".");
+  if (config) {
+    const configPath = resolve(baseDir, config);
+    return { projectDir: dirname(configPath), configPath };
+  }
+  return projectPaths(baseDir);
+}
+
+function projectBaseDir(words: string[], cwd: string): string {
+  for (let index = 0; index < words.length; index += 1) {
+    const word = words[index]!;
+    if (word === "-chdir" || word === "--chdir") {
+      const value = words[index + 1];
+      if (value) return resolve(cwd, value);
+    }
+    if (word.startsWith("-chdir=")) {
+      return resolve(cwd, word.slice("-chdir=".length));
+    }
+    if (word.startsWith("--chdir=")) {
+      return resolve(cwd, word.slice("--chdir=".length));
+    }
+  }
+  return cwd;
 }
 
 function projectPaths(projectDir: string): { projectDir: string; configPath: string } {
   return { projectDir, configPath: join(projectDir, "rig.config.ts") };
 }
 
+function completeDirectories(baseDir: string, current: string): CompletionItem[] {
+  return completePathEntries(baseDir, current, {
+    includeFiles: false,
+    includeDirectories: true,
+  });
+}
+
+function completeConfigPaths(baseDir: string, current: string): CompletionItem[] {
+  return completePathEntries(baseDir, current, {
+    includeFiles: true,
+    includeDirectories: true,
+    fileFilter: isRigConfigFileName,
+  });
+}
+
+function completeFilesystemPaths(baseDir: string, current: string): CompletionItem[] {
+  return completePathEntries(baseDir, current, {
+    includeFiles: true,
+    includeDirectories: true,
+  });
+}
+
+function completePathEntries(
+  baseDir: string,
+  current: string,
+  options: {
+    includeFiles: boolean;
+    includeDirectories: boolean;
+    fileFilter?: (name: string) => boolean;
+  },
+): CompletionItem[] {
+  const { dirPart, namePrefix, dir } = splitCompletionPath(baseDir, current);
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  const items = entries
+    .filter((entry) => entry.name.startsWith(namePrefix))
+    .flatMap((entry): CompletionItem[] => {
+      if (entry.isDirectory()) {
+        if (!options.includeDirectories) return [];
+        if (shouldSkipCompletionDirectory(entry.name, namePrefix)) return [];
+        return [{
+          value: `${dirPart}${entry.name}/`,
+          description: "directory",
+          noSpace: true,
+          group: GROUP_PATHS,
+        }];
+      }
+
+      if (!entry.isFile() || !options.includeFiles) return [];
+      if (options.fileFilter && !options.fileFilter(entry.name)) return [];
+      return [{
+        value: `${dirPart}${entry.name}`,
+        description: "config",
+        group: GROUP_PATHS,
+      }];
+    })
+    .sort((left, right) => {
+      if (left.noSpace && !right.noSpace) return -1;
+      if (!left.noSpace && right.noSpace) return 1;
+      return left.value.localeCompare(right.value);
+    });
+
+  return dedupeItems(items);
+}
+
+function shouldSkipCompletionDirectory(name: string, namePrefix: string): boolean {
+  if (
+    name === ".git" ||
+    name === ".rigkit" ||
+    name === ".turbo" ||
+    name === "node_modules" ||
+    name === "dist" ||
+    name === "build"
+  ) {
+    return true;
+  }
+  return name.startsWith(".") && !namePrefix.startsWith(".");
+}
+
+function splitCompletionPath(baseDir: string, current: string): {
+  dirPart: string;
+  namePrefix: string;
+  dir: string;
+} {
+  const slashIndex = current.lastIndexOf("/");
+  const dirPart = slashIndex >= 0 ? current.slice(0, slashIndex + 1) : "";
+  const namePrefix = slashIndex >= 0 ? current.slice(slashIndex + 1) : current;
+  return {
+    dirPart,
+    namePrefix,
+    dir: resolve(baseDir, dirPart || "."),
+  };
+}
+
 async function workspaceTargets(
   paths: { projectDir: string; configPath: string },
 ): Promise<CompletionItem[]> {
@@ -362,6 +711,7 @@ async function workspaceTargets(
   const items = workspaces.map((workspace) => ({
     value: workspace.name,
     description: workspaceDescription(workspace),
+    group: GROUP_WORKSPACES,
   }));
 
   return dedupeItems(items);
@@ -391,10 +741,15 @@ async function safeWorkspaceOperationTargets(
 
 function workspaceOperationTargets(manifest: RuntimeOperationManifest): CompletionItem[] {
   return (manifest.workspaceOperations ?? []).flatMap((operation) => [
-    { value: operation.id, description: operation.description ?? "workspace operation" },
+    {
+      value: operation.id,
+      description: operation.description ?? "workspace operation",
+      group: GROUP_OPERATIONS,
+    },
     ...(operation.aliases ?? []).map((alias) => ({
       value: alias,
       description: operation.description ?? "workspace operation",
+      group: GROUP_OPERATIONS,
     })),
   ]);
 }

package/src/init.ts

@@ -113,10 +113,11 @@ const vmSpec = new VmSpec()
 const freestyleProvider = freestyle.provider();
 
 const dev = sequence(${workflowName})
-  .step("verify-node-22", async ({ providers, step }) => {
+  .step("verify-node-22", async ({ providers }) => {
+    console.log("creating verification vm");
     const { vm, vmId } = await providers.freestyle.client.vms.create({
       spec: vmSpec,
-      logger: step.log,
+      logger: console.log,
     });
     try {
       const result = await vm.exec("node --version");
@@ -130,11 +131,12 @@ const dev = sequence(${workflowName})
     }
   })
   .workspace({
-    create: async ({ workflow, providers, step }) => {
+    create: async ({ workflow, providers }) => {
+      console.log("booting workspace vm");
       const { vmId } = await providers.freestyle.client.vms.create({
         snapshotId: workflow.ctx.snapshotId,
         idleTimeoutSeconds: vmIdleTimeoutSeconds,
-        logger: step.log,
+        logger: console.log,
       });
       return {
         vmId,