gigadrive 2.7.4 → 2.8.0

package/dist/index.cjs

@@ -24,15 +24,15 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/index.ts
-var import_cli16 = require("@effect/cli");
+var import_cli17 = require("@effect/cli");
 var import_platform_node = require("@effect/platform-node");
 var import_network_config2 = require("@gigadrive/network-config");
-var import_effect30 = require("effect");
+var import_effect31 = require("effect");
 
 // package.json
 var package_default = {
   name: "gigadrive",
-  version: "2.7.4",
+  version: "2.8.0",
   repository: {
     type: "git",
     url: "https://github.com/Gigadrive/sdk.git",
@@ -355,6 +355,24 @@ var DeploymentFailedError = class extends import_effect.Schema.TaggedError()("De
   message: import_effect.Schema.String
 }) {
 };
+var InvalidMicroVmOptionsError = class extends import_effect.Schema.TaggedError()(
+  "InvalidMicroVmOptionsError",
+  { message: import_effect.Schema.String }
+) {
+};
+var InvalidCopyTargetError = class extends import_effect.Schema.TaggedError()("InvalidCopyTargetError", {
+  message: import_effect.Schema.String
+}) {
+};
+var LocalFileError = class extends import_effect.Schema.TaggedError()("LocalFileError", {
+  message: import_effect.Schema.String,
+  path: import_effect.Schema.String
+}) {
+};
+var TerminalRequiredError = class extends import_effect.Schema.TaggedError()("TerminalRequiredError", {
+  message: import_effect.Schema.String
+}) {
+};
 
 // src/services/api-client.ts
 var import_sdk = require("@gigadrive/sdk");
@@ -559,6 +577,13 @@ var CLI_SCOPES = [
   "network:deployments:trigger",
   "network:ai_gateway:chat",
   "network:ai_gateway:models",
+  "network:microvms:read",
+  "network:microvms:write",
+  "network:microvms:exec",
+  "network:microvms:delete",
+  "network:microvm_images:read",
+  "network:microvm_images:write",
+  "network:microvm_images:delete",
   // Provisioning local-dev API credentials
   "platform:api_keys:read",
   "platform:api_keys:write",
@@ -2953,23 +2978,889 @@ var logoutCommand = import_cli11.Command.make(
   )
 );
 
+// src/commands/microvms/index.ts
+var import_cli12 = require("@effect/cli");
+var import_platform8 = require("@effect/platform");
+var import_sdk2 = require("@gigadrive/sdk");
+var import_effect24 = require("effect");
+
+// src/lib/microvm.ts
+var REMOTE_PREFIX = "vm:";
+var parseCopyTarget = (value) => {
+  if (!value.startsWith(REMOTE_PREFIX)) {
+    return value.length === 0 ? "The path is empty." : { kind: "local", path: value };
+  }
+  const rest = value.slice(REMOTE_PREFIX.length);
+  const separator = rest.indexOf(":");
+  if (separator <= 0) return `"${value}" is not in the form vm:<id>:<path>.`;
+  const microvmId = rest.slice(0, separator);
+  const path2 = rest.slice(separator + 1);
+  return { kind: "remote", microvmId, path: path2.length === 0 ? "." : path2 };
+};
+var posixBasename = (path2) => {
+  const trimmed = path2.replace(/\/+$/, "");
+  const index = trimmed.lastIndexOf("/");
+  return index === -1 ? trimmed : trimmed.slice(index + 1);
+};
+var posixJoin = (...segments) => segments.filter((segment) => segment.length > 0).join("/").replace(/\/{2,}/g, "/");
+var relativeTo = (root, entry) => {
+  const base = root.replace(/\/+$/, "");
+  return entry.startsWith(`${base}/`) ? entry.slice(base.length + 1) : posixBasename(entry);
+};
+var parseKeyValues = (entries) => {
+  const value = {};
+  for (const entry of entries) {
+    const index = entry.indexOf("=");
+    if (index <= 0) return { ok: false, entry };
+    value[entry.slice(0, index)] = entry.slice(index + 1);
+  }
+  return { ok: true, value };
+};
+var SIGNAL_NUMBERS = {
+  SIGHUP: 1,
+  SIGINT: 2,
+  SIGQUIT: 3,
+  SIGABRT: 6,
+  SIGKILL: 9,
+  SIGUSR1: 10,
+  SIGSEGV: 11,
+  SIGUSR2: 12,
+  SIGPIPE: 13,
+  SIGTERM: 15
+};
+var exitStatusOf = (command) => {
+  if (command.exitCode !== null) return command.exitCode;
+  if (command.signal) return 128 + (SIGNAL_NUMBERS[command.signal] ?? 0);
+  return 1;
+};
+var formatMemory = (mb) => mb % 1024 === 0 ? `${mb / 1024} GiB` : `${mb} MiB`;
+var relativeTime = (iso, now = Date.now()) => {
+  if (!iso) return "-";
+  const delta = Date.parse(iso) - now;
+  if (!Number.isFinite(delta)) return iso;
+  const abs = Math.abs(delta);
+  const text = abs < 6e4 ? `${Math.round(abs / 1e3)}s` : abs < 36e5 ? `${Math.round(abs / 6e4)}m` : abs < 864e5 ? `${Math.round(abs / 36e5)}h` : `${Math.round(abs / 864e5)}d`;
+  return delta >= 0 ? `in ${text}` : `${text} ago`;
+};
+var formatTable = (rows) => {
+  const widths = [];
+  for (const row of rows) {
+    row.forEach((cell, index) => {
+      widths[index] = Math.max(widths[index] ?? 0, cell.length);
+    });
+  }
+  return rows.map(
+    (row) => row.map((cell, index) => index === row.length - 1 ? cell : cell.padEnd(widths[index] ?? 0)).join("  ").trimEnd()
+  );
+};
+var formatMicroVmTable = (vms, now = Date.now()) => formatTable([
+  ["ID", "STATUS", "IMAGE", "SIZE", "PORTS", "CREATED", "EXPIRES"],
+  ...vms.map((vm) => [
+    vm.id,
+    vm.status,
+    vm.image.name,
+    `${vm.vcpus} vCPU, ${formatMemory(vm.memoryMb)}`,
+    vm.ports.map((entry) => entry.port).join(",") || "-",
+    relativeTime(vm.createdAt, now),
+    vm.status === "running" || vm.status === "starting" ? relativeTime(vm.expiresAt, now) : "-"
+  ])
+]);
+var describeMicroVm = (vm, now = Date.now()) => {
+  const lines = [
+    `ID:          ${vm.id}`,
+    `Status:      ${vm.status}${vm.stopReason ? ` (${vm.stopReason})` : ""}`,
+    `Image:       ${vm.image.name}`,
+    `Size:        ${vm.vcpus} vCPU, ${formatMemory(vm.memoryMb)} memory, ${formatMemory(vm.diskMb)} disk`,
+    `Region:      ${vm.region}`,
+    `Network:     ${vm.network.egress === "deny" ? "outbound traffic blocked" : "internet access"}`,
+    `Application: ${vm.applicationId}`,
+    `Created:     ${vm.createdAt}`
+  ];
+  if (vm.expiresAt && (vm.status === "running" || vm.status === "starting")) {
+    lines.push(`Expires:     ${vm.expiresAt} (${relativeTime(vm.expiresAt, now)})`);
+  }
+  if (vm.stoppedAt) lines.push(`Stopped:     ${vm.stoppedAt}`);
+  const metadata = Object.entries(vm.metadata);
+  if (metadata.length > 0) lines.push(`Metadata:    ${metadata.map(([key, value]) => `${key}=${value}`).join(", ")}`);
+  if (vm.ports.length > 0) {
+    lines.push("Ports:");
+    for (const entry of vm.ports) lines.push(`  ${entry.port}  ${entry.url}`);
+  }
+  return lines;
+};
+var imageSource = (image) => {
+  if (image.builtin) return "built-in";
+  const source = image.source;
+  if (!source) return "-";
+  return source.type === "dockerfile" ? "Dockerfile" : source.ref;
+};
+var formatImageTable = (images) => formatTable([
+  ["NAME", "STATUS", "SOURCE", "ID"],
+  ...images.map((image) => [image.name, image.status, imageSource(image), image.id])
+]);
+var formatBytes = (bytes) => {
+  if (bytes < 1024) return `${bytes} B`;
+  const units = ["KiB", "MiB", "GiB", "TiB"];
+  let value = bytes / 1024;
+  let unit = 0;
+  while (value >= 1024 && unit < units.length - 1) {
+    value /= 1024;
+    unit += 1;
+  }
+  return `${value.toFixed(1)} ${units[unit]}`;
+};
+var concatBytes = (chunks) => {
+  if (chunks.length === 1) return chunks[0];
+  const total = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  const result = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+};
+var StdinBatcher = class {
+  constructor(send, options = {}) {
+    this.send = send;
+    this.options = options;
+    this.delayMs = options.delayMs ?? 8;
+    this.maxBytes = options.maxBytes ?? 64 * 1024;
+  }
+  send;
+  options;
+  pending = [];
+  pendingBytes = 0;
+  timer;
+  inFlight;
+  closed = false;
+  delayMs;
+  maxBytes;
+  /** Queues a chunk. Ignored after {@link close}. */
+  push(chunk) {
+    if (this.closed || chunk.length === 0) return;
+    this.pending.push(chunk);
+    this.pendingBytes += chunk.length;
+    if (this.pendingBytes >= this.maxBytes) this.schedule(0);
+    else if (this.timer === void 0) this.schedule(this.delayMs);
+  }
+  /** Sends everything queued so far, after any request already in flight. */
+  async flush() {
+    while (this.inFlight) await this.inFlight;
+    if (this.pending.length === 0) return;
+    const data = concatBytes(this.pending);
+    this.pending = [];
+    this.pendingBytes = 0;
+    this.inFlight = this.send(data).catch((error) => this.options.onError?.(error)).finally(() => {
+      this.inFlight = void 0;
+    });
+    await this.inFlight;
+  }
+  /** Stops accepting chunks and sends what is left. */
+  async close() {
+    this.closed = true;
+    if (this.timer !== void 0) clearTimeout(this.timer);
+    this.timer = void 0;
+    await this.flush();
+  }
+  schedule(delay) {
+    if (this.timer !== void 0) clearTimeout(this.timer);
+    this.timer = setTimeout(() => {
+      this.timer = void 0;
+      void this.flush();
+    }, delay);
+  }
+};
+
+// src/lib/microvm-session.ts
+async function attachCommand(command, io, options) {
+  const batcher = new StdinBatcher((data) => command.write(data), {
+    // Input after the command exited is expected to fail; nothing to report.
+    onError: () => void 0
+  });
+  const cleanups = [];
+  if (options.forwardInput) {
+    cleanups.push(
+      io.onInput(
+        (chunk) => batcher.push(chunk),
+        () => {
+          if (!options.endInputOnEof) return;
+          void batcher.close().then(() => command.end()).catch(() => void 0);
+        }
+      )
+    );
+  }
+  if (options.forwardResize) {
+    cleanups.push(
+      io.onResize(() => {
+        const size = io.size();
+        if (size) void command.resize(size.cols, size.rows).catch(() => void 0);
+      })
+    );
+  }
+  try {
+    for await (const chunk of command.logs()) io.write(chunk.data, chunk.stream);
+  } finally {
+    for (const cleanup of cleanups) cleanup();
+    await batcher.close();
+  }
+  return command.status === "exited" ? command.info : await command.wait();
+}
+var nodeSessionIo = () => ({
+  onInput: (listener, onEnd) => {
+    const encoder = new TextEncoder();
+    const onData = (chunk) => listener(typeof chunk === "string" ? encoder.encode(chunk) : chunk);
+    process.stdin.on("data", onData);
+    process.stdin.on("end", onEnd);
+    process.stdin.resume();
+    return () => {
+      process.stdin.off("data", onData);
+      process.stdin.off("end", onEnd);
+      process.stdin.pause();
+    };
+  },
+  write: (data, stream) => {
+    (stream === "stderr" ? process.stderr : process.stdout).write(data);
+  },
+  size: () => process.stdout.isTTY ? { cols: process.stdout.columns, rows: process.stdout.rows } : void 0,
+  onResize: (listener) => {
+    process.stdout.on("resize", listener);
+    return () => {
+      process.stdout.off("resize", listener);
+    };
+  }
+});
+
+// src/commands/microvms/index.ts
+var CONSOLE_URL2 = "https://console.gigadrive.de";
+var MICROVM_STATUSES = [
+  "pending",
+  "starting",
+  "running",
+  "stopping",
+  "stopped",
+  "failed"
+];
+var DEFAULT_SHELL = ["/bin/sh", "-c", "if command -v bash >/dev/null 2>&1; then exec bash -l; else exec sh -l; fi"];
+var appOption6 = import_cli12.Options.text("app").pipe(
+  import_cli12.Options.withAlias("a"),
+  import_cli12.Options.withDescription("Application ID (defaults to the linked application)"),
+  import_cli12.Options.optional
+);
+var jsonOption2 = import_cli12.Options.boolean("json").pipe(import_cli12.Options.withDescription("Print the result as JSON"));
+var microvmIdArg = import_cli12.Args.text({ name: "microvm-id" }).pipe(import_cli12.Args.withDescription("The microVM ID"));
+var envOption = import_cli12.Options.text("env").pipe(
+  import_cli12.Options.withAlias("e"),
+  import_cli12.Options.withDescription("Environment variable as KEY=VALUE (repeatable)"),
+  import_cli12.Options.repeated
+);
+var userOption = import_cli12.Options.text("user").pipe(
+  import_cli12.Options.withAlias("u"),
+  import_cli12.Options.withDescription("Run as this user (default: the image user)"),
+  import_cli12.Options.optional
+);
+var cwdOption = import_cli12.Options.text("cwd").pipe(
+  import_cli12.Options.withAlias("w"),
+  import_cli12.Options.withDescription("Working directory inside the microVM"),
+  import_cli12.Options.optional
+);
+var errorMessage2 = (action, error) => {
+  switch (error._tag) {
+    case "NotAuthenticatedError":
+      return 'You are not logged in. Run "gigadrive login" to authenticate.';
+    case "ApiRequestError":
+      if (error.code === "microvm_not_running") {
+        return `${error.message}
+The microVM has stopped. Create a new one with "gigadrive microvms create".`;
+      }
+      if (error.code === "quota_exceeded" || error.code === "plan_limit_exceeded") {
+        return `${error.message}
+Stop microVMs you no longer need, or raise your plan's limits at ${CONSOLE_URL2}.`;
+      }
+      if (error.code === "microvm_busy") {
+        return `${error.message}
+The microVM is busy. Wait a moment and try again.`;
+      }
+      if (error.code === "microvm_unreachable") {
+        return `${error.message}
+The microVM could not be reached. Try again; if it keeps failing, check "gigadrive microvms get <id>".`;
+      }
+      if (error.code === "image_not_ready") {
+        return `${error.message}
+The image is not built yet. Check it with "gigadrive microvms images ls".`;
+      }
+      return `Failed to ${action}: ${error.message}`;
+    default:
+      return error.message;
+  }
+};
+var reportErrors2 = (action) => (self) => import_effect24.Effect.tapError(self, (error) => import_effect24.Console.error(errorMessage2(action, error)));
+var parseDuration = (flag, value) => import_effect24.Effect.try({
+  try: () => {
+    if (/^\d+(\.\d+)?$/.test(value.trim())) throw new RangeError("missing unit");
+    return (0, import_sdk2.durationToMs)(value);
+  },
+  catch: () => new InvalidMicroVmOptionsError({
+    message: `${flag} must be a duration with a unit, such as 90s, 10m or 1h (got "${value}").`
+  })
+});
+var optionalDuration = (flag, value) => import_effect24.Option.match(value, {
+  onNone: () => import_effect24.Effect.succeed(void 0),
+  onSome: (text) => parseDuration(flag, text)
+});
+var parseLifetime = (flag, value) => parseDuration(flag, value).pipe(
+  import_effect24.Effect.filterOrFail(
+    (ms) => ms >= 1 && ms <= import_sdk2.MICROVM_MAX_TIMEOUT_MS,
+    () => new InvalidMicroVmOptionsError({ message: `${flag} can be at most 24h (got "${value}").` })
+  )
+);
+var keyValues = (flag, entries) => {
+  const parsed = parseKeyValues(entries);
+  return parsed.ok ? import_effect24.Effect.succeed(entries.length > 0 ? parsed.value : void 0) : import_effect24.Effect.fail(new InvalidMicroVmOptionsError({ message: `${flag} expects KEY=VALUE, got "${parsed.entry}".` }));
+};
+var resolveApplicationId = (app) => import_effect24.Option.match(app, {
+  onSome: (id) => import_effect24.Effect.succeed(id),
+  onNone: () => import_effect24.Effect.gen(function* () {
+    const projectLink = yield* ProjectLinkService;
+    const link = yield* projectLink.load(process.cwd());
+    return import_effect24.Option.match(link, { onNone: () => void 0, onSome: (value) => value.applicationId });
+  })
+});
+var withClient = (run) => import_effect24.Effect.gen(function* () {
+  const apiClient = yield* ApiClientService;
+  const client = yield* apiClient.getClient;
+  return yield* import_effect24.Effect.tryPromise({ try: () => run(client), catch: toApiRequestError });
+});
+var signalOnInterrupt = (signal) => (command, exit) => import_effect24.Exit.isInterrupted(exit) ? import_effect24.Effect.tryPromise(() => command.kill(signal)).pipe(import_effect24.Effect.timeout("2 seconds"), import_effect24.Effect.ignore) : import_effect24.Effect.void;
+var createInput = (flags) => import_effect24.Effect.gen(function* () {
+  const env = yield* keyValues("--env", flags.env);
+  const metadata = yield* keyValues("--metadata", flags.metadata);
+  const timeoutMs = yield* import_effect24.Option.match(flags.timeout, {
+    onNone: () => import_effect24.Effect.succeed(void 0),
+    onSome: (text) => parseLifetime("--timeout", text)
+  });
+  const badPort = flags.ports.find((port) => !Number.isInteger(port) || port < 1 || port > 65535);
+  if (badPort !== void 0) {
+    return yield* new InvalidMicroVmOptionsError({ message: `--port must be between 1 and 65535 (got ${badPort}).` });
+  }
+  const applicationId = yield* resolveApplicationId(flags.app);
+  const input = {
+    ...applicationId ? { applicationId } : {},
+    ...import_effect24.Option.match(flags.image, { onNone: () => ({}), onSome: (image) => ({ image }) }),
+    ...import_effect24.Option.match(flags.vcpus, {
+      onNone: () => ({}),
+      onSome: (vcpus) => ({ vcpus: Number(vcpus) })
+    }),
+    ...import_effect24.Option.match(flags.memory, { onNone: () => ({}), onSome: (memoryMb) => ({ memoryMb }) }),
+    ...import_effect24.Option.match(flags.disk, { onNone: () => ({}), onSome: (diskMb) => ({ diskMb }) }),
+    ...timeoutMs !== void 0 ? { timeoutMs } : {},
+    ...flags.ports.length > 0 ? { ports: [...flags.ports] } : {},
+    ...env ? { env } : {},
+    ...metadata ? { metadata } : {},
+    ...flags.denyEgress ? { network: { egress: "deny" } } : {},
+    ...import_effect24.Option.match(flags.region, { onNone: () => ({}), onSome: (region) => ({ region }) })
+  };
+  return input;
+});
+var createMicroVm = (flags) => import_effect24.Effect.gen(function* () {
+  const apiClient = yield* ApiClientService;
+  const input = yield* createInput(flags);
+  if (!flags.json) yield* import_effect24.Console.error(`Creating a microVM from ${input.image ?? "node22"}...`);
+  const vm = yield* apiClient.request((client) => client.microvms.create(input));
+  if (flags.json) {
+    yield* import_effect24.Console.log(JSON.stringify(vm, null, 2));
+    return vm;
+  }
+  for (const line of describeMicroVm(vm)) yield* import_effect24.Console.log(line);
+  yield* import_effect24.Console.log(`
+Run a command: gigadrive microvms exec ${vm.id} -- <command>`);
+  yield* import_effect24.Console.log(`Open a shell:  gigadrive microvms shell ${vm.id}`);
+  return vm;
+});
+var createCommand = import_cli12.Command.make(
+  "create",
+  {
+    app: appOption6,
+    image: import_cli12.Options.text("image").pipe(
+      import_cli12.Options.withAlias("i"),
+      import_cli12.Options.withDescription(
+        "Image name or ID: node22, node24, python3.13, python3.12, bun1, debian12, ubuntu24.04, or a custom image (default: node22)"
+      ),
+      import_cli12.Options.optional
+    ),
+    vcpus: import_cli12.Options.choice("vcpus", ["1", "2", "4"]).pipe(
+      import_cli12.Options.withDescription("Number of vCPUs (default: 1)"),
+      import_cli12.Options.optional
+    ),
+    memory: import_cli12.Options.integer("memory").pipe(import_cli12.Options.withDescription("Memory in MiB (default: 2048)"), import_cli12.Options.optional),
+    disk: import_cli12.Options.integer("disk").pipe(import_cli12.Options.withDescription("Disk in MiB (default: 10240)"), import_cli12.Options.optional),
+    timeout: import_cli12.Options.text("timeout").pipe(
+      import_cli12.Options.withAlias("t"),
+      import_cli12.Options.withDescription("Lifetime before it stops automatically, such as 30m or 2h (default: 5m)"),
+      import_cli12.Options.optional
+    ),
+    ports: import_cli12.Options.integer("port").pipe(
+      import_cli12.Options.withAlias("p"),
+      import_cli12.Options.withDescription("Port to expose on a public preview URL (repeatable, up to 8)"),
+      import_cli12.Options.repeated
+    ),
+    env: envOption,
+    metadata: import_cli12.Options.text("metadata").pipe(
+      import_cli12.Options.withAlias("m"),
+      import_cli12.Options.withDescription("Metadata as KEY=VALUE (repeatable)"),
+      import_cli12.Options.repeated
+    ),
+    denyEgress: import_cli12.Options.boolean("deny-egress").pipe(import_cli12.Options.withDescription("Block all outbound network traffic")),
+    region: import_cli12.Options.text("region").pipe(import_cli12.Options.withDescription("Region to place the microVM in"), import_cli12.Options.optional),
+    json: jsonOption2
+  },
+  (flags) => createMicroVm(flags).pipe(import_effect24.Effect.asVoid, reportErrors2("create the microVM"))
+).pipe(import_cli12.Command.withDescription("Create a microVM and wait until it runs"));
+var listMicroVms = (flags) => import_effect24.Effect.gen(function* () {
+  const apiClient = yield* ApiClientService;
+  const applicationId = yield* resolveApplicationId(flags.app);
+  const status = import_effect24.Option.getOrUndefined(flags.status);
+  const showAll = flags.all || status !== void 0;
+  const vms = yield* apiClient.request(async (client) => {
+    const items = [];
+    for await (const vm of client.microvms.listAll({ applicationId, status, limit: Math.min(flags.limit, 100) })) {
+      if (!showAll && (vm.status === "stopped" || vm.status === "failed")) continue;
+      items.push(vm);
+      if (items.length >= flags.limit) break;
+    }
+    return items;
+  });
+  if (flags.json) return yield* import_effect24.Console.log(JSON.stringify(vms, null, 2));
+  if (vms.length === 0) {
+    return yield* import_effect24.Console.log(
+      showAll ? "No microVMs found." : 'No running microVMs. Create one with "gigadrive microvms create".'
+    );
+  }
+  for (const line of formatMicroVmTable(vms)) yield* import_effect24.Console.log(line);
+});
+var listCommand2 = import_cli12.Command.make(
+  "ls",
+  {
+    app: appOption6,
+    status: import_cli12.Options.choice("status", MICROVM_STATUSES).pipe(
+      import_cli12.Options.withAlias("s"),
+      import_cli12.Options.withDescription("Only microVMs in this status"),
+      import_cli12.Options.optional
+    ),
+    all: import_cli12.Options.boolean("all").pipe(import_cli12.Options.withDescription("Include stopped and failed microVMs")),
+    limit: import_cli12.Options.integer("limit").pipe(
+      import_cli12.Options.withDescription("Show at most this many (default: 50)"),
+      import_cli12.Options.withDefault(50)
+    ),
+    json: jsonOption2
+  },
+  (flags) => listMicroVms(flags).pipe(reportErrors2("list microVMs"))
+).pipe(import_cli12.Command.withDescription("List microVMs"));
+var getCommand = import_cli12.Command.make(
+  "get",
+  { microvmId: microvmIdArg, json: jsonOption2 },
+  ({ microvmId, json }) => import_effect24.Effect.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    const vm = yield* apiClient.request((client) => client.microvms.get(microvmId));
+    if (json) return yield* import_effect24.Console.log(JSON.stringify(vm, null, 2));
+    for (const line of describeMicroVm(vm)) yield* import_effect24.Console.log(line);
+  }).pipe(reportErrors2("get the microVM"))
+).pipe(import_cli12.Command.withDescription("Show a microVM"));
+var execInMicroVm = (flags, io = nodeSessionIo()) => import_effect24.Effect.gen(function* () {
+  const env = yield* keyValues("--env", flags.env);
+  const timeout = yield* optionalDuration("--timeout", flags.timeout);
+  const [cmd, ...args] = flags.command;
+  const options = {
+    cwd: import_effect24.Option.getOrUndefined(flags.cwd),
+    env,
+    user: import_effect24.Option.getOrUndefined(flags.user),
+    sudo: flags.sudo,
+    timeout,
+    stdin: flags.interactive
+  };
+  const info = yield* import_effect24.Effect.acquireUseRelease(
+    withClient(async (client) => {
+      const vm = await import_sdk2.MicroVM.get(flags.microvmId, { client });
+      return args.length > 0 ? vm.spawn(cmd, args, options) : vm.spawn(cmd, options);
+    }),
+    (command) => import_effect24.Effect.tryPromise({
+      try: () => attachCommand(command, io, {
+        forwardInput: flags.interactive,
+        endInputOnEof: true,
+        forwardResize: false
+      }),
+      catch: toApiRequestError
+    }),
+    signalOnInterrupt("SIGINT")
+  );
+  return exitStatusOf(info);
+});
+var setExitCode = (status) => import_effect24.Effect.sync(() => {
+  process.exitCode = status;
+});
+var execCommand = import_cli12.Command.make(
+  "exec",
+  {
+    microvmId: microvmIdArg,
+    command: import_cli12.Args.text({ name: "command" }).pipe(
+      import_cli12.Args.withDescription('The command and its arguments, after "--". One quoted argument runs through /bin/sh -c'),
+      import_cli12.Args.atLeast(1)
+    ),
+    cwd: cwdOption,
+    env: envOption,
+    user: userOption,
+    sudo: import_cli12.Options.boolean("sudo").pipe(import_cli12.Options.withDescription("Run as root")),
+    timeout: import_cli12.Options.text("timeout").pipe(
+      import_cli12.Options.withAlias("t"),
+      import_cli12.Options.withDescription("Kill the command after this long, such as 30s or 10m"),
+      import_cli12.Options.optional
+    ),
+    interactive: import_cli12.Options.boolean("interactive").pipe(
+      import_cli12.Options.withAlias("i"),
+      import_cli12.Options.withDescription("Forward local stdin to the command")
+    )
+  },
+  (flags) => execInMicroVm(flags).pipe(import_effect24.Effect.flatMap(setExitCode), reportErrors2("run the command"))
+).pipe(import_cli12.Command.withDescription("Run a command in a microVM and exit with its exit code: exec <id> -- <command...>"));
+var openShell = (flags, io = nodeSessionIo()) => import_effect24.Effect.gen(function* () {
+  if (process.stdin.isTTY !== true || process.stdout.isTTY !== true) {
+    return yield* new TerminalRequiredError({
+      message: 'microvms shell needs an interactive terminal. Use "gigadrive microvms exec <id> -- <command>" in scripts.'
+    });
+  }
+  const term = yield* import_effect24.Config.string("TERM").pipe(import_effect24.Config.withDefault("xterm-256color"));
+  const size = io.size() ?? { cols: 80, rows: 24 };
+  const [cmd, ...args] = import_effect24.Option.match(flags.shell, { onNone: () => DEFAULT_SHELL, onSome: (shell) => [shell] });
+  const options = {
+    pty: { cols: size.cols, rows: size.rows },
+    env: { TERM: term },
+    cwd: import_effect24.Option.getOrUndefined(flags.cwd),
+    user: import_effect24.Option.getOrUndefined(flags.user)
+  };
+  const info = yield* import_effect24.Effect.acquireUseRelease(
+    withClient(async (client) => {
+      const vm = await import_sdk2.MicroVM.get(flags.microvmId, { client });
+      return args.length > 0 ? vm.spawn(cmd, args, options) : vm.spawn(cmd, options);
+    }),
+    (command) => import_effect24.Effect.acquireUseRelease(
+      import_effect24.Effect.sync(() => process.stdin.setRawMode(true)),
+      () => import_effect24.Effect.tryPromise({
+        try: () => attachCommand(command, io, { forwardInput: true, endInputOnEof: false, forwardResize: true }),
+        catch: toApiRequestError
+      }),
+      () => import_effect24.Effect.sync(() => process.stdin.setRawMode(false))
+    ),
+    signalOnInterrupt("SIGHUP")
+  );
+  return exitStatusOf(info);
+});
+var shellCommand = import_cli12.Command.make(
+  "shell",
+  {
+    microvmId: microvmIdArg,
+    shell: import_cli12.Options.text("shell").pipe(
+      import_cli12.Options.withDescription("Program to run instead of the login shell, such as python3"),
+      import_cli12.Options.optional
+    ),
+    cwd: cwdOption,
+    user: userOption
+  },
+  (flags) => openShell(flags).pipe(import_effect24.Effect.flatMap(setExitCode), reportErrors2("open a shell"))
+).pipe(import_cli12.Command.withDescription("Open an interactive shell in a microVM"));
+var localError = (path2, action) => () => new LocalFileError({ message: `Failed to ${action} ${path2}`, path: path2 });
+var parseTarget = (value) => {
+  const target = parseCopyTarget(value);
+  return typeof target === "string" ? import_effect24.Effect.fail(new InvalidCopyTargetError({ message: target })) : import_effect24.Effect.succeed(target);
+};
+var remoteStat = (client, microvmId, path2) => import_effect24.Effect.tryPromise({ try: () => client.microvms.files.stat(microvmId, path2), catch: toApiRequestError }).pipe(
+  import_effect24.Effect.map(import_effect24.Option.some),
+  import_effect24.Effect.catchIf(
+    (error) => error.statusCode === 404,
+    () => import_effect24.Effect.succeed(import_effect24.Option.none())
+  )
+);
+var upload = (client, source, target) => import_effect24.Effect.gen(function* () {
+  const fs = yield* import_platform8.FileSystem.FileSystem;
+  const path2 = yield* import_platform8.Path.Path;
+  const info = yield* fs.stat(source).pipe(import_effect24.Effect.mapError(localError(source, "read")));
+  const existing = yield* remoteStat(client, target.microvmId, target.path);
+  const intoDirectory = target.path.endsWith("/") || import_effect24.Option.exists(existing, (entry) => entry.type === "directory");
+  const destination = intoDirectory ? posixJoin(target.path, path2.basename(source)) : target.path;
+  const files = [];
+  if (info.type === "Directory") {
+    const entries = yield* fs.readDirectory(source, { recursive: true }).pipe(import_effect24.Effect.mapError(localError(source, "list")));
+    for (const entry of entries) {
+      const local = path2.join(source, entry);
+      const stat = yield* fs.stat(local).pipe(import_effect24.Effect.mapError(localError(local, "read")));
+      if (stat.type === "File")
+        files.push({ local, remote: posixJoin(destination, entry.split(path2.sep).join("/")) });
+    }
+  } else {
+    files.push({ local: source, remote: destination });
+  }
+  let bytes = 0;
+  for (const file of files) {
+    const content = yield* fs.readFile(file.local).pipe(import_effect24.Effect.mapError(localError(file.local, "read")));
+    const result = yield* import_effect24.Effect.tryPromise({
+      try: () => client.microvms.files.write(target.microvmId, file.remote, content),
+      catch: toApiRequestError
+    });
+    bytes += result.bytes;
+  }
+  return { files: files.length, bytes };
+});
+var download = (client, source, target) => import_effect24.Effect.gen(function* () {
+  const fs = yield* import_platform8.FileSystem.FileSystem;
+  const path2 = yield* import_platform8.Path.Path;
+  const entry = yield* import_effect24.Effect.tryPromise({
+    try: () => client.microvms.files.stat(source.microvmId, source.path),
+    catch: toApiRequestError
+  });
+  const targetExists = yield* fs.exists(target).pipe(import_effect24.Effect.mapError(localError(target, "check")));
+  const targetIsDirectory = targetExists ? (yield* fs.stat(target).pipe(import_effect24.Effect.mapError(localError(target, "read")))).type === "Directory" : false;
+  const intoDirectory = targetIsDirectory || target.endsWith(path2.sep) || target.endsWith("/");
+  const destination = intoDirectory ? path2.join(target, posixBasename(entry.path)) : target;
+  const files = [];
+  if (entry.type === "directory") {
+    const listing = yield* import_effect24.Effect.tryPromise({
+      try: () => client.microvms.files.list(source.microvmId, entry.path, { recursive: true }),
+      catch: toApiRequestError
+    });
+    if (listing.truncated) {
+      yield* import_effect24.Console.error(
+        `${entry.path} has too many files to list at once; only part of it is copied. Copy its subdirectories separately.`
+      );
+    }
+    for (const child of listing.entries) {
+      if (child.type !== "file") continue;
+      const segments = relativeTo(entry.path, child.path).split("/");
+      if (segments.some((segment) => segment === "" || segment === "." || segment === "..")) {
+        yield* import_effect24.Console.error(`Skipped ${child.path}: its path leaves ${entry.path}.`);
+        continue;
+      }
+      files.push({ remote: child.path, local: path2.join(destination, ...segments) });
+    }
+    yield* fs.makeDirectory(destination, { recursive: true }).pipe(import_effect24.Effect.mapError(localError(destination, "create")));
+  } else {
+    files.push({ remote: entry.path, local: destination });
+  }
+  let bytes = 0;
+  for (const file of files) {
+    const content = yield* import_effect24.Effect.tryPromise({
+      try: () => client.microvms.files.read(source.microvmId, file.remote),
+      catch: toApiRequestError
+    });
+    yield* fs.makeDirectory(path2.dirname(file.local), { recursive: true }).pipe(import_effect24.Effect.mapError(localError(file.local, "create the directory of")));
+    yield* fs.writeFile(file.local, content).pipe(import_effect24.Effect.mapError(localError(file.local, "write")));
+    bytes += content.length;
+  }
+  return { files: files.length, bytes };
+});
+var copyFiles = (sourceSpec, targetSpec) => import_effect24.Effect.gen(function* () {
+  const source = yield* parseTarget(sourceSpec);
+  const target = yield* parseTarget(targetSpec);
+  const apiClient = yield* ApiClientService;
+  const client = yield* apiClient.getClient;
+  if (source.kind === "local" && target.kind === "remote") return yield* upload(client, source.path, target);
+  if (source.kind === "remote" && target.kind === "local") return yield* download(client, source, target.path);
+  return yield* new InvalidCopyTargetError({
+    message: 'One side must be local and the other vm:<id>:<path>, e.g. "gigadrive microvms cp ./app vm:<id>:/app".'
+  });
+});
+var copyCommand = import_cli12.Command.make(
+  "cp",
+  {
+    source: import_cli12.Args.text({ name: "source" }).pipe(import_cli12.Args.withDescription("Local path or vm:<id>:<path>")),
+    target: import_cli12.Args.text({ name: "target" }).pipe(import_cli12.Args.withDescription("Local path or vm:<id>:<path>"))
+  },
+  ({ source, target }) => copyFiles(source, target).pipe(
+    import_effect24.Effect.flatMap(
+      (result) => import_effect24.Console.log(`Copied ${result.files} file${result.files === 1 ? "" : "s"} (${formatBytes(result.bytes)}).`)
+    ),
+    reportErrors2("copy")
+  )
+).pipe(import_cli12.Command.withDescription("Copy files between this machine and a microVM (vm:<id>:<path>)"));
+var microvmIdsArg = import_cli12.Args.text({ name: "microvm-id" }).pipe(
+  import_cli12.Args.withDescription("One or more microVM IDs"),
+  import_cli12.Args.atLeast(1)
+);
+var stopCommand = import_cli12.Command.make(
+  "stop",
+  { microvmIds: microvmIdsArg },
+  ({ microvmIds }) => import_effect24.Effect.forEach(
+    microvmIds,
+    (microvmId) => import_effect24.Effect.gen(function* () {
+      const apiClient = yield* ApiClientService;
+      yield* apiClient.request((client) => client.microvms.stop(microvmId));
+      yield* import_effect24.Console.log(`Stopped ${microvmId}.`);
+    }),
+    { discard: true }
+  ).pipe(reportErrors2("stop the microVM"))
+).pipe(import_cli12.Command.withDescription("Stop microVMs; their disk and memory are discarded"));
+var removeCommand2 = import_cli12.Command.make(
+  "rm",
+  { microvmIds: microvmIdsArg },
+  ({ microvmIds }) => import_effect24.Effect.forEach(
+    microvmIds,
+    (microvmId) => import_effect24.Effect.gen(function* () {
+      const apiClient = yield* ApiClientService;
+      yield* apiClient.request((client) => client.microvms.delete(microvmId));
+      yield* import_effect24.Console.log(`Deleted ${microvmId}.`);
+    }),
+    { discard: true }
+  ).pipe(reportErrors2("delete the microVM"))
+).pipe(import_cli12.Command.withDescription("Delete microVMs, stopping them first"));
+var extendMicroVm = (microvmId, duration) => import_effect24.Effect.gen(function* () {
+  const timeoutMs = yield* parseLifetime("The duration", duration);
+  const apiClient = yield* ApiClientService;
+  const vm = yield* apiClient.request((client) => client.microvms.extendTimeout(microvmId, timeoutMs));
+  yield* import_effect24.Console.log(`${vm.id} now stops at ${vm.expiresAt ?? "an unknown time"}.`);
+  return vm;
+});
+var extendCommand = import_cli12.Command.make(
+  "extend",
+  {
+    microvmId: microvmIdArg,
+    duration: import_cli12.Args.text({ name: "duration" }).pipe(
+      import_cli12.Args.withDescription("New remaining lifetime from now, such as 30m")
+    )
+  },
+  ({ microvmId, duration }) => extendMicroVm(microvmId, duration).pipe(import_effect24.Effect.asVoid, reportErrors2("extend the microVM"))
+).pipe(import_cli12.Command.withDescription("Set how long a microVM keeps running, counted from now"));
+var imagesListCommand = import_cli12.Command.make(
+  "ls",
+  { app: appOption6, json: jsonOption2 },
+  ({ app, json }) => import_effect24.Effect.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    const applicationId = yield* resolveApplicationId(app);
+    const images = yield* apiClient.request((client) => client.microvms.images.list({ applicationId }));
+    if (json) return yield* import_effect24.Console.log(JSON.stringify(images, null, 2));
+    for (const line of formatImageTable(images)) yield* import_effect24.Console.log(line);
+  }).pipe(reportErrors2("list images"))
+).pipe(import_cli12.Command.withDescription("List built-in and custom images"));
+var createImage = (flags) => import_effect24.Effect.gen(function* () {
+  const fs = yield* import_platform8.FileSystem.FileSystem;
+  const apiClient = yield* ApiClientService;
+  if (import_effect24.Option.isSome(flags.from) === import_effect24.Option.isSome(flags.dockerfile)) {
+    return yield* new InvalidMicroVmOptionsError({
+      message: "Pass exactly one of --from <registry reference> or --dockerfile <path>."
+    });
+  }
+  const from = import_effect24.Option.isSome(flags.from) ? flags.from.value : {
+    dockerfile: yield* fs.readFileString(import_effect24.Option.getOrElse(flags.dockerfile, () => "Dockerfile")).pipe(
+      import_effect24.Effect.mapError(
+        localError(
+          import_effect24.Option.getOrElse(flags.dockerfile, () => "Dockerfile"),
+          "read"
+        )
+      )
+    )
+  };
+  const applicationId = yield* resolveApplicationId(flags.app);
+  let image = yield* apiClient.request(
+    (client) => client.microvms.images.create({ name: flags.name, from, ...applicationId ? { applicationId } : {} })
+  );
+  if (flags.wait) {
+    if (!flags.json) yield* import_effect24.Console.error(`Building ${image.name}...`);
+    image = yield* apiClient.request(
+      (client) => client.microvms.images.waitUntilReady(image.id, {
+        onStatus: (current) => {
+          if (!flags.json) process.stderr.write(`  ${current.status}
+`);
+        }
+      })
+    );
+  }
+  if (flags.json) {
+    yield* import_effect24.Console.log(JSON.stringify(image, null, 2));
+  } else if (image.status === "ready") {
+    yield* import_effect24.Console.log(`${image.name} is ready. Use it with: gigadrive microvms create --image ${image.name}`);
+  } else {
+    yield* import_effect24.Console.log(
+      `${image.name} is ${image.status} (${image.id}). Check it with "gigadrive microvms images ls".`
+    );
+  }
+  return image;
+});
+var imagesCreateCommand = import_cli12.Command.make(
+  "create",
+  {
+    name: import_cli12.Args.text({ name: "name" }).pipe(
+      import_cli12.Args.withDescription('Image name: lowercase letters, digits, ".", "_", "-"')
+    ),
+    app: appOption6,
+    from: import_cli12.Options.text("from").pipe(
+      import_cli12.Options.withDescription("Public linux/amd64 registry image, such as python:3.13 or ghcr.io/acme/tool:1"),
+      import_cli12.Options.optional
+    ),
+    dockerfile: import_cli12.Options.text("dockerfile").pipe(
+      import_cli12.Options.withAlias("f"),
+      import_cli12.Options.withDescription("Build from this Dockerfile instead"),
+      import_cli12.Options.optional
+    ),
+    wait: import_cli12.Options.boolean("wait").pipe(import_cli12.Options.withDescription("Wait until the build finished")),
+    json: jsonOption2
+  },
+  (flags) => createImage(flags).pipe(import_effect24.Effect.asVoid, reportErrors2("create the image"))
+).pipe(import_cli12.Command.withDescription("Build a custom image from a registry image or a Dockerfile"));
+var removeImage = (idOrName, app) => import_effect24.Effect.gen(function* () {
+  const apiClient = yield* ApiClientService;
+  const applicationId = yield* resolveApplicationId(app);
+  const images = yield* apiClient.request((client) => client.microvms.images.list({ applicationId }));
+  const image = images.find((candidate) => candidate.id === idOrName) ?? images.find((candidate) => !candidate.builtin && candidate.name === idOrName) ?? { id: idOrName, name: idOrName };
+  yield* apiClient.request((client) => client.microvms.images.delete(image.id));
+  yield* import_effect24.Console.log(`Deleted image ${image.name}.`);
+});
+var imagesRemoveCommand = import_cli12.Command.make(
+  "rm",
+  {
+    image: import_cli12.Args.text({ name: "image" }).pipe(import_cli12.Args.withDescription("Image ID or name")),
+    app: appOption6
+  },
+  ({ image, app }) => removeImage(image, app).pipe(reportErrors2("delete the image"))
+).pipe(import_cli12.Command.withDescription("Delete a custom image"));
+var imagesCommand = import_cli12.Command.make("images", {}, () => import_effect24.Effect.void).pipe(
+  import_cli12.Command.withDescription("Built-in and custom microVM images"),
+  import_cli12.Command.withSubcommands([imagesListCommand, imagesCreateCommand, imagesRemoveCommand])
+);
+var SUBCOMMANDS = [
+  createCommand,
+  listCommand2,
+  getCommand,
+  execCommand,
+  shellCommand,
+  copyCommand,
+  stopCommand,
+  removeCommand2,
+  extendCommand,
+  imagesCommand
+];
+var microvmsCommand = import_cli12.Command.make("microvms", {}, () => import_effect24.Effect.void).pipe(
+  import_cli12.Command.withDescription("Isolated Linux machines for running code: create, exec, shell, cp, stop"),
+  import_cli12.Command.withSubcommands(SUBCOMMANDS)
+);
+var vmCommand = import_cli12.Command.make("vm", {}, () => import_effect24.Effect.void).pipe(
+  import_cli12.Command.withDescription('Alias of "gigadrive microvms"'),
+  import_cli12.Command.withSubcommands(SUBCOMMANDS)
+);
+
 // src/commands/platform/index.ts
-var import_cli13 = require("@effect/cli");
-var import_effect27 = require("effect");
+var import_cli14 = require("@effect/cli");
+var import_effect28 = require("effect");
 
 // src/commands/platform/deploy/index.ts
-var import_cli12 = require("@effect/cli");
-var import_platform9 = require("@effect/platform");
+var import_cli13 = require("@effect/cli");
+var import_platform10 = require("@effect/platform");
 var import_commons = require("@gigadrive/commons");
-var import_effect26 = require("effect");
+var import_effect27 = require("effect");
 var os4 = __toESM(require("os"), 1);
 var path = __toESM(require("path"), 1);
 
 // src/services/archive.ts
-var import_platform8 = require("@effect/platform");
+var import_platform9 = require("@effect/platform");
 var import_build_utils3 = require("@gigadrive/build-utils");
 var import_archiver = __toESM(require("archiver"), 1);
-var import_effect24 = require("effect");
+var import_effect25 = require("effect");
 var import_ignore = __toESM(require("ignore"), 1);
 var nodeFs = __toESM(require("fs"), 1);
 var nodeFsPromises = __toESM(require("fs/promises"), 1);
@@ -2994,15 +3885,15 @@ var CONTAINER_BUILD_FILE_PATTERNS = [
 ];
 var DOCKER_BUILD_IGNORE_FILE = ".dockerignore";
 var readIgnoreFile = (fs, ignorePath) => fs.readFileString(ignorePath, "utf8").pipe(
-  import_effect24.Effect.map((content) => content.split("\n").filter((line) => line.trim() !== "")),
-  import_effect24.Effect.catchAll(() => import_effect24.Effect.succeed([]))
+  import_effect25.Effect.map((content) => content.split("\n").filter((line) => line.trim() !== "")),
+  import_effect25.Effect.catchAll(() => import_effect25.Effect.succeed([]))
 );
-var collectIgnorePatterns = (fs, pathService, dir, baseDir, ignoreRules, ignoreFileNames) => import_effect24.Effect.gen(function* () {
-  const items = yield* fs.readDirectory(dir).pipe(import_effect24.Effect.mapError(() => new ArchiveCreateError({ message: `Failed to read directory: ${dir}` })));
+var collectIgnorePatterns = (fs, pathService, dir, baseDir, ignoreRules, ignoreFileNames) => import_effect25.Effect.gen(function* () {
+  const items = yield* fs.readDirectory(dir).pipe(import_effect25.Effect.mapError(() => new ArchiveCreateError({ message: `Failed to read directory: ${dir}` })));
   for (const item of items) {
     const fullPath = pathService.join(dir, item);
     const relativePath = pathService.relative(baseDir, fullPath);
-    const stat = yield* import_effect24.Effect.tryPromise({
+    const stat = yield* import_effect25.Effect.tryPromise({
       try: () => nodeFsPromises.lstat(fullPath),
       catch: () => new ArchiveCreateError({ message: `Failed to stat: ${fullPath}` })
     });
@@ -3022,8 +3913,8 @@ var collectIgnorePatterns = (fs, pathService, dir, baseDir, ignoreRules, ignoreF
       yield* collectIgnorePatterns(fs, pathService, fullPath, baseDir, ignoreRules, ignoreFileNames);
     }
   }
-}).pipe(import_effect24.Effect.catchAll(() => import_effect24.Effect.void));
-var initializeIgnoreRules = (fs, pathService, baseDir, useIgnoreFiles, useManagedIgnore, buildsContainerImages) => import_effect24.Effect.gen(function* () {
+}).pipe(import_effect25.Effect.catchAll(() => import_effect25.Effect.void));
+var initializeIgnoreRules = (fs, pathService, baseDir, useIgnoreFiles, useManagedIgnore, buildsContainerImages) => import_effect25.Effect.gen(function* () {
   const ignoreRules = (0, import_ignore.default)();
   const ignoreFileNames = buildsContainerImages ? IGNORE_FILE_NAMES.filter((name) => name !== DOCKER_BUILD_IGNORE_FILE) : IGNORE_FILE_NAMES;
   if (useManagedIgnore) {
@@ -3044,14 +3935,14 @@ var initializeIgnoreRules = (fs, pathService, baseDir, useIgnoreFiles, useManage
   }
   return ignoreRules;
 });
-var getFilesToInclude = (fs, pathService, dir, ignoreRules) => import_effect24.Effect.gen(function* () {
+var getFilesToInclude = (fs, pathService, dir, ignoreRules) => import_effect25.Effect.gen(function* () {
   const filesToInclude = [];
-  const walkDir = (currentDir) => import_effect24.Effect.gen(function* () {
-    const items = yield* fs.readDirectory(currentDir).pipe(import_effect24.Effect.mapError(() => new ArchiveCreateError({ message: `Failed to read directory: ${currentDir}` })));
+  const walkDir = (currentDir) => import_effect25.Effect.gen(function* () {
+    const items = yield* fs.readDirectory(currentDir).pipe(import_effect25.Effect.mapError(() => new ArchiveCreateError({ message: `Failed to read directory: ${currentDir}` })));
     for (const item of items) {
       const fullPath = pathService.join(currentDir, item);
       const relativePath = pathService.relative(dir, fullPath);
-      const stat = yield* import_effect24.Effect.tryPromise({
+      const stat = yield* import_effect25.Effect.tryPromise({
         try: () => nodeFsPromises.lstat(fullPath),
         catch: () => new ArchiveCreateError({ message: `Failed to stat: ${fullPath}` })
       });
@@ -3065,19 +3956,19 @@ var getFilesToInclude = (fs, pathService, dir, ignoreRules) => import_effect24.E
         }
       }
     }
-  }).pipe(import_effect24.Effect.catchAll(() => import_effect24.Effect.void));
+  }).pipe(import_effect25.Effect.catchAll(() => import_effect25.Effect.void));
   yield* walkDir(dir);
   return filesToInclude;
 });
-var ArchiveService = class extends import_effect24.Effect.Service()("ArchiveService", {
+var ArchiveService = class extends import_effect25.Effect.Service()("ArchiveService", {
   accessors: true,
-  effect: import_effect24.Effect.gen(function* () {
-    const fs = yield* import_platform8.FileSystem.FileSystem;
-    const pathService = yield* import_platform8.Path.Path;
-    const createZipArchive = import_effect24.Effect.fn("ArchiveService.createZipArchive")(function* (inputDir, outputFile, options = {}) {
-      yield* import_effect24.Effect.annotateCurrentSpan("inputDir", inputDir);
-      yield* import_effect24.Effect.annotateCurrentSpan("outputFile", outputFile);
-      yield* import_effect24.Effect.log("Creating zip archive", { inputDir, outputFile });
+  effect: import_effect25.Effect.gen(function* () {
+    const fs = yield* import_platform9.FileSystem.FileSystem;
+    const pathService = yield* import_platform9.Path.Path;
+    const createZipArchive = import_effect25.Effect.fn("ArchiveService.createZipArchive")(function* (inputDir, outputFile, options = {}) {
+      yield* import_effect25.Effect.annotateCurrentSpan("inputDir", inputDir);
+      yield* import_effect25.Effect.annotateCurrentSpan("outputFile", outputFile);
+      yield* import_effect25.Effect.log("Creating zip archive", { inputDir, outputFile });
       const ignoreRules = yield* initializeIgnoreRules(
         fs,
         pathService,
@@ -3086,7 +3977,7 @@ var ArchiveService = class extends import_effect24.Effect.Service()("ArchiveServ
         options.useManagedIgnore !== false,
         options.buildsContainerImages === true
       );
-      const filesToInclude = options.whitelist ? yield* import_effect24.Effect.tryPromise({
+      const filesToInclude = options.whitelist ? yield* import_effect25.Effect.tryPromise({
         try: () => Promise.all(
           options.whitelist.map((file) => (0, import_build_utils3.getFilesForPattern)(file, inputDir, options.excludeFiles ?? []))
         ),
@@ -3094,25 +3985,25 @@ var ArchiveService = class extends import_effect24.Effect.Service()("ArchiveServ
           message: "Failed to resolve whitelist patterns",
           cause: error instanceof Error ? error.message : String(error)
         })
-      }) : yield* import_effect24.Effect.gen(function* () {
+      }) : yield* import_effect25.Effect.gen(function* () {
         if (options.excludeFiles && options.excludeFiles.length > 0) {
           ignoreRules.add(options.excludeFiles);
         }
         return yield* getFilesToInclude(fs, pathService, inputDir, ignoreRules).pipe(
-          import_effect24.Effect.map((files) => [files])
+          import_effect25.Effect.map((files) => [files])
         );
       });
-      const archiveExists = yield* fs.exists(outputFile).pipe(import_effect24.Effect.catchAll(() => import_effect24.Effect.succeed(false)));
+      const archiveExists = yield* fs.exists(outputFile).pipe(import_effect25.Effect.catchAll(() => import_effect25.Effect.succeed(false)));
       if (archiveExists) {
         yield* fs.remove(outputFile).pipe(
-          import_effect24.Effect.mapError(
+          import_effect25.Effect.mapError(
             (error) => new ArchiveCreateError({
               message: `Failed to remove existing archive: ${String(error)}`
             })
           )
         );
       }
-      yield* import_effect24.Effect.tryPromise({
+      yield* import_effect25.Effect.tryPromise({
         try: () => new Promise((resolve, reject) => {
           const output = nodeFs.createWriteStream(outputFile);
           const archive = (0, import_archiver.default)("zip", { zlib: { level: 9 } });
@@ -3131,14 +4022,14 @@ var ArchiveService = class extends import_effect24.Effect.Service()("ArchiveServ
         })
       });
       const fileInfo = yield* fs.stat(outputFile).pipe(
-        import_effect24.Effect.mapError(
+        import_effect25.Effect.mapError(
           (error) => new ArchiveCreateError({
             message: `Failed to stat archive: ${String(error)}`
           })
         )
       );
       const size = Number(fileInfo.size);
-      yield* import_effect24.Effect.log("Archive created", { size });
+      yield* import_effect25.Effect.log("Archive created", { size });
       return { path: outputFile, size };
     });
     return { createZipArchive };
@@ -3147,32 +4038,32 @@ var ArchiveService = class extends import_effect24.Effect.Service()("ArchiveServ
 };
 
 // src/services/deployment-api.ts
-var import_effect25 = require("effect");
-var DeploymentApiService = class extends import_effect25.Effect.Service()("DeploymentApiService", {
+var import_effect26 = require("effect");
+var DeploymentApiService = class extends import_effect26.Effect.Service()("DeploymentApiService", {
   accessors: true,
   dependencies: [ApiClientService.Default],
-  effect: import_effect25.Effect.gen(function* () {
+  effect: import_effect26.Effect.gen(function* () {
     const apiClient = yield* ApiClientService;
     const getClient = apiClient.getClient.pipe(
-      import_effect25.Effect.mapError((err) => new DeploymentAuthError({ message: `Authentication failed: ${err.message}` }))
+      import_effect26.Effect.mapError((err) => new DeploymentAuthError({ message: `Authentication failed: ${err.message}` }))
     );
-    const createDeployment = import_effect25.Effect.fn("DeploymentApiService.createDeployment")(function* (applicationId) {
-      yield* import_effect25.Effect.annotateCurrentSpan("applicationId", applicationId);
-      yield* import_effect25.Effect.log("Creating deployment", { applicationId });
+    const createDeployment = import_effect26.Effect.fn("DeploymentApiService.createDeployment")(function* (applicationId) {
+      yield* import_effect26.Effect.annotateCurrentSpan("applicationId", applicationId);
+      yield* import_effect26.Effect.log("Creating deployment", { applicationId });
       const client = yield* getClient;
-      const deployment = yield* import_effect25.Effect.tryPromise({
+      const deployment = yield* import_effect26.Effect.tryPromise({
         try: () => client.deployments.create({ applicationId }),
         catch: (error) => new DeploymentCreateError({
           message: `Failed to create deployment: ${error instanceof Error ? error.message : String(error)}`
         })
       });
-      yield* import_effect25.Effect.log("Deployment created", { deploymentId: deployment.id });
+      yield* import_effect26.Effect.log("Deployment created", { deploymentId: deployment.id });
       return deployment.id;
     });
-    const startMultipartUpload = import_effect25.Effect.fn("DeploymentApiService.startMultipartUpload")(function* (deploymentId) {
-      yield* import_effect25.Effect.annotateCurrentSpan("deploymentId", deploymentId);
+    const startMultipartUpload = import_effect26.Effect.fn("DeploymentApiService.startMultipartUpload")(function* (deploymentId) {
+      yield* import_effect26.Effect.annotateCurrentSpan("deploymentId", deploymentId);
       const client = yield* getClient;
-      const result = yield* import_effect25.Effect.tryPromise({
+      const result = yield* import_effect26.Effect.tryPromise({
         try: () => client.deployments.startUpload(deploymentId),
         catch: (error) => new UploadStartError({
           message: `Failed to start multipart upload: ${error instanceof Error ? error.message : String(error)}`
@@ -3180,9 +4071,9 @@ var DeploymentApiService = class extends import_effect25.Effect.Service()("Deplo
       });
       return result.uploadId;
     });
-    const getPresignedUrl = import_effect25.Effect.fn("DeploymentApiService.getPresignedUrl")(function* (deploymentId, uploadId, partNumber) {
+    const getPresignedUrl = import_effect26.Effect.fn("DeploymentApiService.getPresignedUrl")(function* (deploymentId, uploadId, partNumber) {
       const client = yield* getClient;
-      const result = yield* import_effect25.Effect.tryPromise({
+      const result = yield* import_effect26.Effect.tryPromise({
         try: () => client.deployments.getPresignedUrl(deploymentId, uploadId, partNumber),
         catch: (error) => new PresignedUrlError({
           message: `Failed to get presigned URL: ${error instanceof Error ? error.message : String(error)}`,
@@ -3191,11 +4082,11 @@ var DeploymentApiService = class extends import_effect25.Effect.Service()("Deplo
       });
       return result.url;
     });
-    const uploadPart = import_effect25.Effect.fn("DeploymentApiService.uploadPart")(function* (presignedUrl, data, partNumber) {
-      yield* import_effect25.Effect.annotateCurrentSpan("partNumber", partNumber);
-      yield* import_effect25.Effect.annotateCurrentSpan("size", data.length);
+    const uploadPart = import_effect26.Effect.fn("DeploymentApiService.uploadPart")(function* (presignedUrl, data, partNumber) {
+      yield* import_effect26.Effect.annotateCurrentSpan("partNumber", partNumber);
+      yield* import_effect26.Effect.annotateCurrentSpan("size", data.length);
       const client = yield* getClient;
-      const result = yield* import_effect25.Effect.tryPromise({
+      const result = yield* import_effect26.Effect.tryPromise({
         try: () => client.deployments.uploadPart(presignedUrl, data, partNumber),
         catch: (error) => new UploadPartError({
           message: `Failed to upload part ${partNumber}: ${error instanceof Error ? error.message : String(error)}`,
@@ -3204,21 +4095,21 @@ var DeploymentApiService = class extends import_effect25.Effect.Service()("Deplo
       });
       return result;
     });
-    const completeUpload = import_effect25.Effect.fn("DeploymentApiService.completeUpload")(function* (deploymentId, uploadId, parts) {
-      yield* import_effect25.Effect.annotateCurrentSpan("deploymentId", deploymentId);
-      yield* import_effect25.Effect.annotateCurrentSpan("partsCount", parts.length);
+    const completeUpload = import_effect26.Effect.fn("DeploymentApiService.completeUpload")(function* (deploymentId, uploadId, parts) {
+      yield* import_effect26.Effect.annotateCurrentSpan("deploymentId", deploymentId);
+      yield* import_effect26.Effect.annotateCurrentSpan("partsCount", parts.length);
       const client = yield* getClient;
-      yield* import_effect25.Effect.tryPromise({
+      yield* import_effect26.Effect.tryPromise({
         try: () => client.deployments.completeUpload(deploymentId, uploadId, parts),
         catch: (error) => new UploadCompleteError({
           message: `Failed to complete upload: ${error instanceof Error ? error.message : String(error)}`
         })
       });
-      yield* import_effect25.Effect.log("Upload completed successfully");
+      yield* import_effect26.Effect.log("Upload completed successfully");
     });
-    const getDeploymentStatus = import_effect25.Effect.fn("DeploymentApiService.getDeploymentStatus")(function* (deploymentId) {
+    const getDeploymentStatus = import_effect26.Effect.fn("DeploymentApiService.getDeploymentStatus")(function* (deploymentId) {
       const client = yield* getClient;
-      const deployment = yield* import_effect25.Effect.tryPromise({
+      const deployment = yield* import_effect26.Effect.tryPromise({
         try: () => client.deployments.get(deploymentId),
         catch: (error) => new DeploymentStatusError({
           message: `Failed to get deployment status: ${error instanceof Error ? error.message : String(error)}`
@@ -3226,9 +4117,9 @@ var DeploymentApiService = class extends import_effect25.Effect.Service()("Deplo
       });
       return deployment.status;
     });
-    const getLogs = import_effect25.Effect.fn("DeploymentApiService.getLogs")(function* (deploymentId, options) {
+    const getLogs = import_effect26.Effect.fn("DeploymentApiService.getLogs")(function* (deploymentId, options) {
       const client = yield* getClient;
-      const result = yield* import_effect25.Effect.tryPromise({
+      const result = yield* import_effect26.Effect.tryPromise({
         try: () => client.deployments.getLogs(deploymentId, options),
         catch: (error) => new DeploymentLogsFetchError({
           message: `Failed to get logs: ${error instanceof Error ? error.message : String(error)}`
@@ -3236,9 +4127,9 @@ var DeploymentApiService = class extends import_effect25.Effect.Service()("Deplo
       });
       return result;
     });
-    const getHostnames = import_effect25.Effect.fn("DeploymentApiService.getHostnames")(function* (deploymentId) {
+    const getHostnames = import_effect26.Effect.fn("DeploymentApiService.getHostnames")(function* (deploymentId) {
       const client = yield* getClient;
-      const result = yield* import_effect25.Effect.tryPromise({
+      const result = yield* import_effect26.Effect.tryPromise({
         try: () => client.deployments.getHostnames(deploymentId),
         catch: (error) => new DeploymentHostnamesFetchError({
           message: `Failed to get hostnames: ${error instanceof Error ? error.message : String(error)}`
@@ -3261,39 +4152,39 @@ var DeploymentApiService = class extends import_effect25.Effect.Service()("Deplo
 };
 
 // src/commands/platform/deploy/index.ts
-var appOption6 = import_cli12.Options.text("app").pipe(
-  import_cli12.Options.withAlias("a"),
-  import_cli12.Options.withDescription("Application ID to deploy to (overrides the linked application)"),
-  import_cli12.Options.optional
+var appOption7 = import_cli13.Options.text("app").pipe(
+  import_cli13.Options.withAlias("a"),
+  import_cli13.Options.withDescription("Application ID to deploy to (overrides the linked application)"),
+  import_cli13.Options.optional
 );
-var orgOption6 = import_cli12.Options.text("org").pipe(
-  import_cli12.Options.withAlias("o"),
-  import_cli12.Options.withDescription("Organization ID to use when automatically creating an application"),
-  import_cli12.Options.optional
+var orgOption6 = import_cli13.Options.text("org").pipe(
+  import_cli13.Options.withAlias("o"),
+  import_cli13.Options.withDescription("Organization ID to use when automatically creating an application"),
+  import_cli13.Options.optional
 );
-var nameOption2 = import_cli12.Options.text("name").pipe(
-  import_cli12.Options.withAlias("n"),
-  import_cli12.Options.withDescription("Application name to use when automatically creating an application"),
-  import_cli12.Options.optional
+var nameOption2 = import_cli13.Options.text("name").pipe(
+  import_cli13.Options.withAlias("n"),
+  import_cli13.Options.withDescription("Application name to use when automatically creating an application"),
+  import_cli13.Options.optional
 );
-var createAndLinkDeploymentApplication = (input) => import_effect26.Effect.gen(function* () {
+var createAndLinkDeploymentApplication = (input) => import_effect27.Effect.gen(function* () {
   const projectLink = yield* ProjectLinkService;
   const apiClient = yield* ApiClientService;
   const { items: organizations } = yield* apiClient.request((client) => client.organizations.list());
-  const availableOrganizations = import_effect26.Option.match(input.org, {
+  const availableOrganizations = import_effect27.Option.match(input.org, {
     onNone: () => organizations,
     onSome: (organizationId) => organizations.filter((organization2) => organization2.id === organizationId)
   });
   if (availableOrganizations.length === 0) {
     return yield* new NoOrganizationsFoundError({
-      message: import_effect26.Option.match(input.org, {
+      message: import_effect27.Option.match(input.org, {
         onNone: () => 'No organization is available for this deployment. Create an organization, then run "gigadrive deploy" again.',
         onSome: (organizationId) => `Organization "${organizationId}" was not found among your organizations.`
       })
     });
   }
-  const organization = availableOrganizations.length === 1 ? availableOrganizations[0] : yield* import_cli12.Prompt.run(
-    import_cli12.Prompt.select({
+  const organization = availableOrganizations.length === 1 ? availableOrganizations[0] : yield* import_cli13.Prompt.run(
+    import_cli13.Prompt.select({
       message: "Select an organization for this application",
       choices: availableOrganizations.map((candidate) => ({
         title: candidate.name,
@@ -3302,7 +4193,7 @@ var createAndLinkDeploymentApplication = (input) => import_effect26.Effect.gen(f
     })
   );
   const inferredName = path.basename(input.cwd) || "Application";
-  const applicationName = import_effect26.Option.match(input.name, {
+  const applicationName = import_effect27.Option.match(input.name, {
     onNone: () => inferredName,
     onSome: (name) => name
   }).trim();
@@ -3316,37 +4207,37 @@ var createAndLinkDeploymentApplication = (input) => import_effect26.Effect.gen(f
     applicationId: application.id,
     organizationId: organization.id
   });
-  yield* import_effect26.Console.log(`Created and linked application ${application.name} (${application.id}).`);
+  yield* import_effect27.Console.log(`Created and linked application ${application.name} (${application.id}).`);
   return application.id;
 });
-var resolveLinkedDeploymentApplication = (input) => import_effect26.Effect.gen(function* () {
+var resolveLinkedDeploymentApplication = (input) => import_effect27.Effect.gen(function* () {
   const projectLink = yield* ProjectLinkService;
   const existingLink = yield* projectLink.load(input.cwd);
-  return yield* import_effect26.Option.match(existingLink, {
+  return yield* import_effect27.Option.match(existingLink, {
     onNone: () => createAndLinkDeploymentApplication(input),
-    onSome: (link) => import_effect26.Effect.succeed(link.applicationId)
+    onSome: (link) => import_effect27.Effect.succeed(link.applicationId)
   });
 });
-var resolveDeploymentApplication = (input) => import_effect26.Option.match(input.app, {
+var resolveDeploymentApplication = (input) => import_effect27.Option.match(input.app, {
   onNone: () => resolveLinkedDeploymentApplication(input),
-  onSome: import_effect26.Effect.succeed
+  onSome: import_effect27.Effect.succeed
 });
-var deployCommand = import_cli12.Command.make(
+var deployCommand = import_cli13.Command.make(
   "deploy",
-  { app: appOption6, org: orgOption6, name: nameOption2 },
-  ({ app, org, name }) => import_effect26.Effect.gen(function* () {
+  { app: appOption7, org: orgOption6, name: nameOption2 },
+  ({ app, org, name }) => import_effect27.Effect.gen(function* () {
     const projectConfig = yield* ProjectConfigService;
     const deploymentApi = yield* DeploymentApiService;
     const archiveService = yield* ArchiveService;
-    const pathService = yield* import_platform9.Path.Path;
+    const pathService = yield* import_platform10.Path.Path;
     const cwd = process.cwd();
-    yield* import_effect26.Effect.log("Starting deploy command");
+    yield* import_effect27.Effect.log("Starting deploy command");
     const { config } = yield* projectConfig.resolve(cwd);
     const applicationId = yield* resolveDeploymentApplication({ app, org, name, cwd });
-    yield* import_effect26.Console.log("Creating deployment...");
+    yield* import_effect27.Console.log("Creating deployment...");
     const deploymentId = yield* deploymentApi.createDeployment(applicationId);
-    yield* import_effect26.Console.log(`Deployment ID: ${deploymentId}`);
-    yield* import_effect26.Console.log("Creating archive...");
+    yield* import_effect27.Console.log(`Deployment ID: ${deploymentId}`);
+    yield* import_effect27.Console.log("Creating archive...");
     const archivePath = pathService.join(os4.tmpdir(), `project-${Date.now()}.zip`);
     const archive = yield* archiveService.createZipArchive(config.userArchive?.rootOverwrite || cwd, archivePath, {
       whitelist: config.userArchive?.fileWhitelist,
@@ -3356,68 +4247,68 @@ var deployCommand = import_cli12.Command.make(
         ...config.sidecars ?? []
       ].some((container) => container.source.type === "dockerfile")
     });
-    yield* import_effect26.Console.log(`Archive created (${(0, import_commons.formatFileSize)(archive.size)})`);
-    yield* import_effect26.Console.log("Uploading archive...");
+    yield* import_effect27.Console.log(`Archive created (${(0, import_commons.formatFileSize)(archive.size)})`);
+    yield* import_effect27.Console.log("Uploading archive...");
     yield* uploadArchive(deploymentId, archivePath, archive.size);
-    yield* import_effect26.Console.log("Upload complete.");
-    yield* import_effect26.Console.log("The deployment pipeline is now being provisioned. This may take a few seconds.");
+    yield* import_effect27.Console.log("Upload complete.");
+    yield* import_effect27.Console.log("The deployment pipeline is now being provisioned. This may take a few seconds.");
     yield* pollDeployment(deploymentId);
   }).pipe(
-    import_effect26.Effect.catchTags({
-      QuitException: () => import_effect26.Console.log("Cancelled."),
-      NotAuthenticatedError: (err) => import_effect26.Console.error('You are not logged in. Run "gigadrive login" to authenticate.').pipe(
-        import_effect26.Effect.andThen(import_effect26.Effect.fail(err))
+    import_effect27.Effect.catchTags({
+      QuitException: () => import_effect27.Console.log("Cancelled."),
+      NotAuthenticatedError: (err) => import_effect27.Console.error('You are not logged in. Run "gigadrive login" to authenticate.').pipe(
+        import_effect27.Effect.andThen(import_effect27.Effect.fail(err))
       ),
-      ApiRequestError: (err) => import_effect26.Console.error(`Application setup failed: ${err.message}`).pipe(import_effect26.Effect.andThen(import_effect26.Effect.fail(err))),
-      NoOrganizationsFoundError: (err) => import_effect26.Console.error(err.message).pipe(import_effect26.Effect.andThen(import_effect26.Effect.fail(err))),
-      ProjectLinkReadError: (err) => import_effect26.Console.error(err.message).pipe(import_effect26.Effect.andThen(import_effect26.Effect.fail(err))),
-      ProjectLinkWriteError: (err) => import_effect26.Console.error(err.message).pipe(import_effect26.Effect.andThen(import_effect26.Effect.fail(err))),
-      ConfigNotFoundError: (err) => import_effect26.Console.error(err.message).pipe(import_effect26.Effect.andThen(import_effect26.Effect.fail(err))),
-      ConfigParseError: (err) => import_effect26.Console.error(`Config parse error: ${err.message}`).pipe(import_effect26.Effect.andThen(import_effect26.Effect.fail(err))),
-      ConfigValidationError: (err) => import_effect26.Effect.gen(function* () {
+      ApiRequestError: (err) => import_effect27.Console.error(`Application setup failed: ${err.message}`).pipe(import_effect27.Effect.andThen(import_effect27.Effect.fail(err))),
+      NoOrganizationsFoundError: (err) => import_effect27.Console.error(err.message).pipe(import_effect27.Effect.andThen(import_effect27.Effect.fail(err))),
+      ProjectLinkReadError: (err) => import_effect27.Console.error(err.message).pipe(import_effect27.Effect.andThen(import_effect27.Effect.fail(err))),
+      ProjectLinkWriteError: (err) => import_effect27.Console.error(err.message).pipe(import_effect27.Effect.andThen(import_effect27.Effect.fail(err))),
+      ConfigNotFoundError: (err) => import_effect27.Console.error(err.message).pipe(import_effect27.Effect.andThen(import_effect27.Effect.fail(err))),
+      ConfigParseError: (err) => import_effect27.Console.error(`Config parse error: ${err.message}`).pipe(import_effect27.Effect.andThen(import_effect27.Effect.fail(err))),
+      ConfigValidationError: (err) => import_effect27.Effect.gen(function* () {
         for (const e of err.errors) {
-          yield* import_effect26.Console.error(e);
+          yield* import_effect27.Console.error(e);
         }
-        yield* import_effect26.Console.error(err.message);
-      }).pipe(import_effect26.Effect.andThen(import_effect26.Effect.fail(err))),
-      DeploymentCreateError: (err) => import_effect26.Console.error(`Deployment creation failed: ${err.message}`).pipe(import_effect26.Effect.andThen(import_effect26.Effect.fail(err))),
-      ArchiveCreateError: (err) => import_effect26.Console.error(`Archive creation failed: ${err.message}`).pipe(import_effect26.Effect.andThen(import_effect26.Effect.fail(err))),
-      UploadStartError: (err) => import_effect26.Console.error(`Upload failed: ${err.message}`).pipe(import_effect26.Effect.andThen(import_effect26.Effect.fail(err))),
-      UploadPartError: (err) => import_effect26.Console.error(`Upload failed: ${err.message}`).pipe(import_effect26.Effect.andThen(import_effect26.Effect.fail(err))),
-      UploadCompleteError: (err) => import_effect26.Console.error(`Upload failed: ${err.message}`).pipe(import_effect26.Effect.andThen(import_effect26.Effect.fail(err))),
-      PresignedUrlError: (err) => import_effect26.Console.error(`Upload failed: ${err.message}`).pipe(import_effect26.Effect.andThen(import_effect26.Effect.fail(err))),
-      DeploymentAuthError: (err) => import_effect26.Console.error(`Authentication failed: ${err.message}`).pipe(import_effect26.Effect.andThen(import_effect26.Effect.fail(err))),
-      DeploymentFailedError: (err) => import_effect26.Console.error(err.message).pipe(import_effect26.Effect.andThen(import_effect26.Effect.fail(err)))
+        yield* import_effect27.Console.error(err.message);
+      }).pipe(import_effect27.Effect.andThen(import_effect27.Effect.fail(err))),
+      DeploymentCreateError: (err) => import_effect27.Console.error(`Deployment creation failed: ${err.message}`).pipe(import_effect27.Effect.andThen(import_effect27.Effect.fail(err))),
+      ArchiveCreateError: (err) => import_effect27.Console.error(`Archive creation failed: ${err.message}`).pipe(import_effect27.Effect.andThen(import_effect27.Effect.fail(err))),
+      UploadStartError: (err) => import_effect27.Console.error(`Upload failed: ${err.message}`).pipe(import_effect27.Effect.andThen(import_effect27.Effect.fail(err))),
+      UploadPartError: (err) => import_effect27.Console.error(`Upload failed: ${err.message}`).pipe(import_effect27.Effect.andThen(import_effect27.Effect.fail(err))),
+      UploadCompleteError: (err) => import_effect27.Console.error(`Upload failed: ${err.message}`).pipe(import_effect27.Effect.andThen(import_effect27.Effect.fail(err))),
+      PresignedUrlError: (err) => import_effect27.Console.error(`Upload failed: ${err.message}`).pipe(import_effect27.Effect.andThen(import_effect27.Effect.fail(err))),
+      DeploymentAuthError: (err) => import_effect27.Console.error(`Authentication failed: ${err.message}`).pipe(import_effect27.Effect.andThen(import_effect27.Effect.fail(err))),
+      DeploymentFailedError: (err) => import_effect27.Console.error(err.message).pipe(import_effect27.Effect.andThen(import_effect27.Effect.fail(err)))
     })
   )
 );
-var uploadArchive = (deploymentId, archivePath, fileSize) => import_effect26.Effect.gen(function* () {
+var uploadArchive = (deploymentId, archivePath, fileSize) => import_effect27.Effect.gen(function* () {
   const deploymentApi = yield* DeploymentApiService;
-  const fs = yield* import_platform9.FileSystem.FileSystem;
+  const fs = yield* import_platform10.FileSystem.FileSystem;
   const uploadId = yield* deploymentApi.startMultipartUpload(deploymentId);
   const FILE_CHUNK_SIZE = 10 * 1024 * 1024;
   const numChunks = Math.ceil(fileSize / FILE_CHUNK_SIZE);
-  yield* import_effect26.Effect.log("Starting multipart upload", { uploadId, numChunks, fileSize });
-  const parts = yield* import_effect26.Effect.all(
+  yield* import_effect27.Effect.log("Starting multipart upload", { uploadId, numChunks, fileSize });
+  const parts = yield* import_effect27.Effect.all(
     Array.from({ length: numChunks }, (_, i) => {
       const partNumber = i + 1;
       const start = i * FILE_CHUNK_SIZE;
       const bytesToRead = partNumber < numChunks ? FILE_CHUNK_SIZE : fileSize - start;
-      return import_effect26.Effect.gen(function* () {
+      return import_effect27.Effect.gen(function* () {
         const presignedUrl = yield* deploymentApi.getPresignedUrl(deploymentId, uploadId, partNumber);
-        const chunkData = yield* import_effect26.Stream.runCollect(fs.stream(archivePath, { offset: start, bytesToRead })).pipe(
-          import_effect26.Effect.map((chunks) => {
+        const chunkData = yield* import_effect27.Stream.runCollect(fs.stream(archivePath, { offset: start, bytesToRead })).pipe(
+          import_effect27.Effect.map((chunks) => {
             const arrays = Array.from(chunks);
             return Buffer.concat(arrays);
           }),
-          import_effect26.Effect.mapError(
+          import_effect27.Effect.mapError(
             (error) => new UploadPartError({
               message: `Failed to read chunk ${partNumber}: ${String(error)}`,
               partNumber
             })
           )
         );
-        yield* import_effect26.Effect.log(`Uploading part ${partNumber}/${numChunks}`, { size: chunkData.length });
+        yield* import_effect27.Effect.log(`Uploading part ${partNumber}/${numChunks}`, { size: chunkData.length });
         return yield* deploymentApi.uploadPart(presignedUrl, chunkData, partNumber);
       });
     }),
@@ -3425,20 +4316,20 @@ var uploadArchive = (deploymentId, archivePath, fileSize) => import_effect26.Eff
   );
   yield* deploymentApi.completeUpload(deploymentId, uploadId, parts);
 });
-var pollDeployment = (deploymentId) => import_effect26.Effect.gen(function* () {
+var pollDeployment = (deploymentId) => import_effect27.Effect.gen(function* () {
   const deploymentApi = yield* DeploymentApiService;
   let lastStatus = "PENDING";
   let logOffset = 0;
-  yield* import_effect26.Console.log("Status: Pending");
-  yield* import_effect26.Effect.repeat(
-    import_effect26.Effect.gen(function* () {
-      const newStatus = yield* deploymentApi.getDeploymentStatus(deploymentId).pipe(import_effect26.Effect.catchTag("DeploymentStatusError", () => import_effect26.Effect.succeed(lastStatus)));
+  yield* import_effect27.Console.log("Status: Pending");
+  yield* import_effect27.Effect.repeat(
+    import_effect27.Effect.gen(function* () {
+      const newStatus = yield* deploymentApi.getDeploymentStatus(deploymentId).pipe(import_effect27.Effect.catchTag("DeploymentStatusError", () => import_effect27.Effect.succeed(lastStatus)));
       if (newStatus !== lastStatus) {
         lastStatus = newStatus;
         const label = newStatus.charAt(0) + newStatus.slice(1).toLowerCase();
-        yield* import_effect26.Console.log(`Status: ${label}`);
+        yield* import_effect27.Console.log(`Status: ${label}`);
       }
-      const logsPage = yield* deploymentApi.getLogs(deploymentId, { offset: logOffset, limit: 100 }).pipe(import_effect26.Effect.catchTag("DeploymentLogsFetchError", () => import_effect26.Effect.succeed(null)));
+      const logsPage = yield* deploymentApi.getLogs(deploymentId, { offset: logOffset, limit: 100 }).pipe(import_effect27.Effect.catchTag("DeploymentLogsFetchError", () => import_effect27.Effect.succeed(null)));
       if (logsPage) {
         for (const logEntry of logsPage.items) {
           logOffset++;
@@ -3446,86 +4337,86 @@ var pollDeployment = (deploymentId) => import_effect26.Effect.gen(function* () {
         }
       }
       if (newStatus === "ACTIVE") {
-        const hostnames = yield* deploymentApi.getHostnames(deploymentId).pipe(import_effect26.Effect.catchTag("DeploymentHostnamesFetchError", () => import_effect26.Effect.succeed([])));
+        const hostnames = yield* deploymentApi.getHostnames(deploymentId).pipe(import_effect27.Effect.catchTag("DeploymentHostnamesFetchError", () => import_effect27.Effect.succeed([])));
         const active = hostnames.find((h) => h.active) ?? hostnames.at(0);
         if (active) {
-          yield* import_effect26.Console.log(`Deployed to https://${active.hostname}`);
+          yield* import_effect27.Console.log(`Deployed to https://${active.hostname}`);
         } else {
-          yield* import_effect26.Console.log("Deployment is live.");
+          yield* import_effect27.Console.log("Deployment is live.");
         }
-        return yield* import_effect26.Effect.fail("done");
+        return yield* import_effect27.Effect.fail("done");
       }
       if (newStatus === "FAILED") {
-        return yield* import_effect26.Effect.fail(
+        return yield* import_effect27.Effect.fail(
           new DeploymentFailedError({
             message: "The deployment failed. Please check the logs for more information."
           })
         );
       }
     }),
-    import_effect26.Schedule.addDelay(import_effect26.Schedule.forever, () => import_effect26.Duration.seconds(1))
+    import_effect27.Schedule.addDelay(import_effect27.Schedule.forever, () => import_effect27.Duration.seconds(1))
   ).pipe(
-    import_effect26.Effect.catchAll((err) => {
-      if (err === "done") return import_effect26.Effect.void;
-      return import_effect26.Effect.fail(err);
+    import_effect27.Effect.catchAll((err) => {
+      if (err === "done") return import_effect27.Effect.void;
+      return import_effect27.Effect.fail(err);
     })
   );
 });
 var printLog = (logEntry) => {
   switch (logEntry.type) {
     case "ERROR":
-      return import_effect26.Console.error(logEntry.message);
+      return import_effect27.Console.error(logEntry.message);
     case "WARN":
-      return import_effect26.Console.warn(logEntry.message);
+      return import_effect27.Console.warn(logEntry.message);
     default:
-      return import_effect26.Console.log(logEntry.message);
+      return import_effect27.Console.log(logEntry.message);
   }
 };
 
 // src/commands/platform/index.ts
-var platformBase = import_cli13.Command.make("platform", {}, () => import_effect27.Effect.void);
-var platformCommand = platformBase.pipe(import_cli13.Command.withSubcommands([deployCommand]));
+var platformBase = import_cli14.Command.make("platform", {}, () => import_effect28.Effect.void);
+var platformCommand = platformBase.pipe(import_cli14.Command.withSubcommands([deployCommand]));
 
 // src/commands/setup/index.ts
-var import_cli14 = require("@effect/cli");
-var import_effect28 = require("effect");
-var fileArg2 = import_cli14.Args.text({ name: "file" }).pipe(
-  import_cli14.Args.withDescription("Output file to write (default: .env.local)"),
-  import_cli14.Args.optional
+var import_cli15 = require("@effect/cli");
+var import_effect29 = require("effect");
+var fileArg2 = import_cli15.Args.text({ name: "file" }).pipe(
+  import_cli15.Args.withDescription("Output file to write (default: .env.local)"),
+  import_cli15.Args.optional
 );
-var appOption7 = import_cli14.Options.text("app").pipe(
-  import_cli14.Options.withAlias("a"),
-  import_cli14.Options.withDescription("Application ID to set up (skips the interactive picker)"),
-  import_cli14.Options.optional
+var appOption8 = import_cli15.Options.text("app").pipe(
+  import_cli15.Options.withAlias("a"),
+  import_cli15.Options.withDescription("Application ID to set up (skips the interactive picker)"),
+  import_cli15.Options.optional
 );
-var orgOption7 = import_cli14.Options.text("org").pipe(
-  import_cli14.Options.withAlias("o"),
-  import_cli14.Options.withDescription("Only list applications belonging to this organization ID when picking"),
-  import_cli14.Options.optional
+var orgOption7 = import_cli15.Options.text("org").pipe(
+  import_cli15.Options.withAlias("o"),
+  import_cli15.Options.withDescription("Only list applications belonging to this organization ID when picking"),
+  import_cli15.Options.optional
 );
-var environmentOption2 = import_cli14.Options.text("environment").pipe(
-  import_cli14.Options.withAlias("e"),
-  import_cli14.Options.withDescription("Environment slug to resolve overrides for (e.g. preview)"),
-  import_cli14.Options.optional
+var environmentOption2 = import_cli15.Options.text("environment").pipe(
+  import_cli15.Options.withAlias("e"),
+  import_cli15.Options.withDescription("Environment slug to resolve overrides for (e.g. preview)"),
+  import_cli15.Options.optional
 );
-var yesOption3 = import_cli14.Options.boolean("yes").pipe(
-  import_cli14.Options.withAlias("y"),
-  import_cli14.Options.withDescription("Overwrite an existing file without confirmation")
+var yesOption3 = import_cli15.Options.boolean("yes").pipe(
+  import_cli15.Options.withAlias("y"),
+  import_cli15.Options.withDescription("Overwrite an existing file without confirmation")
 );
-var rotateOption2 = import_cli14.Options.boolean("rotate").pipe(
-  import_cli14.Options.withDescription("Force a fresh API key, revoking the previous one")
+var rotateOption2 = import_cli15.Options.boolean("rotate").pipe(
+  import_cli15.Options.withDescription("Force a fresh API key, revoking the previous one")
 );
-var setupCommand = import_cli14.Command.make(
+var setupCommand = import_cli15.Command.make(
   "setup",
   {
     file: fileArg2,
-    app: appOption7,
+    app: appOption8,
     org: orgOption7,
     environment: environmentOption2,
     yes: yesOption3,
     rotate: rotateOption2
   },
-  ({ file, app, org, environment, yes, rotate }) => import_effect28.Effect.gen(function* () {
+  ({ file, app, org, environment, yes, rotate }) => import_effect29.Effect.gen(function* () {
     const apiClient = yield* ApiClientService;
     const projectLink = yield* ProjectLinkService;
     const envFile = yield* EnvFileService;
@@ -3533,29 +4424,29 @@ var setupCommand = import_cli14.Command.make(
     const cwd = process.cwd();
     const existingLink = yield* projectLink.load(cwd);
     let applicationId;
-    if (import_effect28.Option.isSome(existingLink)) {
+    if (import_effect29.Option.isSome(existingLink)) {
       applicationId = existingLink.value.applicationId;
-      if (import_effect28.Option.isSome(app) || import_effect28.Option.isSome(org)) {
-        yield* import_effect28.Console.log(
+      if (import_effect29.Option.isSome(app) || import_effect29.Option.isSome(org)) {
+        yield* import_effect29.Console.log(
           `Note: this directory is already linked to ${applicationId}; ignoring --app/--org. Run "gigadrive unlink" first to target a different application.`
         );
       }
     } else {
-      const organizationId = import_effect28.Option.getOrUndefined(org);
+      const organizationId = import_effect29.Option.getOrUndefined(org);
       const { items: apps } = yield* apiClient.request((client) => client.applications.list({ organizationId }));
       if (apps.length === 0) {
-        return yield* import_effect28.Effect.fail(
+        return yield* import_effect29.Effect.fail(
           new NoApplicationsFoundError({
             message: 'No applications found. Create one in the Gigadrive console, then run "gigadrive setup" again.'
           })
         );
       }
-      const explicitAppId = import_effect28.Option.getOrUndefined(app);
+      const explicitAppId = import_effect29.Option.getOrUndefined(app);
       let chosen;
       if (explicitAppId !== void 0) {
         const match = apps.find((a) => a.id === explicitAppId);
         if (match === void 0) {
-          return yield* import_effect28.Effect.fail(
+          return yield* import_effect29.Effect.fail(
             new ApplicationNotFoundError({
               message: `Application "${explicitAppId}" was not found among your applications.`
             })
@@ -3565,8 +4456,8 @@ var setupCommand = import_cli14.Command.make(
       } else if (apps.length === 1) {
         chosen = apps[0];
       } else {
-        chosen = yield* import_cli14.Prompt.run(
-          import_cli14.Prompt.select({
+        chosen = yield* import_cli15.Prompt.run(
+          import_cli15.Prompt.select({
             message: "Select an application to set up",
             choices: apps.map((a) => ({ title: `${a.name} (${a.organization.name})`, value: a }))
           })
@@ -3574,83 +4465,83 @@ var setupCommand = import_cli14.Command.make(
       }
       applicationId = chosen.id;
       yield* projectLink.save(cwd, { applicationId, organizationId: chosen.organization.id });
-      yield* import_effect28.Console.log(`Linked this directory to application ${applicationId}.`);
+      yield* import_effect29.Console.log(`Linked this directory to application ${applicationId}.`);
     }
-    const target = import_effect28.Option.getOrElse(file, () => ".env.local");
-    const environmentSlug = import_effect28.Option.getOrUndefined(environment);
+    const target = import_effect29.Option.getOrElse(file, () => ".env.local");
+    const environmentSlug = import_effect29.Option.getOrUndefined(environment);
     const { items, omittedSensitive } = yield* apiClient.request(
       (client) => client.applications.envVars.pull(applicationId, environmentSlug ? { environment: environmentSlug } : void 0)
     );
     const existing = yield* envFile.read(target);
-    if (import_effect28.Option.isSome(existing) && !yes) {
-      const overwrite = yield* import_cli14.Prompt.run(
-        import_cli14.Prompt.confirm({ message: `${target} already exists. Overwrite?`, initial: false })
+    if (import_effect29.Option.isSome(existing) && !yes) {
+      const overwrite = yield* import_cli15.Prompt.run(
+        import_cli15.Prompt.confirm({ message: `${target} already exists. Overwrite?`, initial: false })
       );
       if (!overwrite) {
-        return yield* import_effect28.Console.log("Cancelled.");
+        return yield* import_effect29.Console.log("Cancelled.");
       }
     }
     const credentialEntries2 = yield* localCredentials.provision({
       applicationId,
       rotate,
-      existingContent: import_effect28.Option.getOrUndefined(existing)
+      existingContent: import_effect29.Option.getOrUndefined(existing)
     });
     const entries = [...items.map((v) => ({ key: v.key, value: v.value })), ...credentialEntries2];
     yield* envFile.write(target, entries);
     const gitignored = yield* envFile.ensureGitignored(cwd, target);
-    yield* import_effect28.Console.log("\nLocal dev environment ready.");
-    yield* import_effect28.Console.log(`  \u2022 Wrote ${items.length} variable(s) and API credentials to ${target}.`);
+    yield* import_effect29.Console.log("\nLocal dev environment ready.");
+    yield* import_effect29.Console.log(`  \u2022 Wrote ${items.length} variable(s) and API credentials to ${target}.`);
     if (omittedSensitive > 0) {
-      yield* import_effect28.Console.log(
+      yield* import_effect29.Console.log(
         `  \u2022 Skipped ${omittedSensitive} sensitive variable(s) (only production/preview hold secrets).`
       );
     }
     if (gitignored) {
-      yield* import_effect28.Console.log(`  \u2022 Added ${target} to .gitignore.`);
+      yield* import_effect29.Console.log(`  \u2022 Added ${target} to .gitignore.`);
     }
-    yield* import_effect28.Console.log("  \u2022 Your app can now call the Gigadrive API via the SDK (GIGADRIVE_CLIENT_ID/SECRET).");
+    yield* import_effect29.Console.log("  \u2022 Your app can now call the Gigadrive API via the SDK (GIGADRIVE_CLIENT_ID/SECRET).");
   }).pipe(
-    import_effect28.Effect.catchTags({
+    import_effect29.Effect.catchTags({
       // Ctrl+C during a prompt is a deliberate cancel — exit 0.
-      QuitException: () => import_effect28.Console.log("Cancelled."),
-      NotAuthenticatedError: (err) => import_effect28.Console.error('You are not logged in. Run "gigadrive login" to authenticate.').pipe(
-        import_effect28.Effect.andThen(import_effect28.Effect.fail(err))
+      QuitException: () => import_effect29.Console.log("Cancelled."),
+      NotAuthenticatedError: (err) => import_effect29.Console.error('You are not logged in. Run "gigadrive login" to authenticate.').pipe(
+        import_effect29.Effect.andThen(import_effect29.Effect.fail(err))
       ),
-      ApiRequestError: (err) => import_effect28.Console.error(`Setup failed: ${err.message}`).pipe(import_effect28.Effect.andThen(import_effect28.Effect.fail(err))),
-      NoApplicationsFoundError: (err) => import_effect28.Console.error(err.message).pipe(import_effect28.Effect.andThen(import_effect28.Effect.fail(err))),
-      ApplicationNotFoundError: (err) => import_effect28.Console.error(err.message).pipe(import_effect28.Effect.andThen(import_effect28.Effect.fail(err))),
-      ProjectLinkReadError: (err) => import_effect28.Console.error(err.message).pipe(import_effect28.Effect.andThen(import_effect28.Effect.fail(err))),
-      ProjectLinkWriteError: (err) => import_effect28.Console.error(err.message).pipe(import_effect28.Effect.andThen(import_effect28.Effect.fail(err))),
-      EnvFileReadError: (err) => import_effect28.Console.error(err.message).pipe(import_effect28.Effect.andThen(import_effect28.Effect.fail(err))),
-      EnvFileWriteError: (err) => import_effect28.Console.error(err.message).pipe(import_effect28.Effect.andThen(import_effect28.Effect.fail(err))),
-      DevCredentialsStoreReadError: (err) => import_effect28.Console.error(err.message).pipe(import_effect28.Effect.andThen(import_effect28.Effect.fail(err))),
-      DevCredentialsStoreWriteError: (err) => import_effect28.Console.error(err.message).pipe(import_effect28.Effect.andThen(import_effect28.Effect.fail(err)))
+      ApiRequestError: (err) => import_effect29.Console.error(`Setup failed: ${err.message}`).pipe(import_effect29.Effect.andThen(import_effect29.Effect.fail(err))),
+      NoApplicationsFoundError: (err) => import_effect29.Console.error(err.message).pipe(import_effect29.Effect.andThen(import_effect29.Effect.fail(err))),
+      ApplicationNotFoundError: (err) => import_effect29.Console.error(err.message).pipe(import_effect29.Effect.andThen(import_effect29.Effect.fail(err))),
+      ProjectLinkReadError: (err) => import_effect29.Console.error(err.message).pipe(import_effect29.Effect.andThen(import_effect29.Effect.fail(err))),
+      ProjectLinkWriteError: (err) => import_effect29.Console.error(err.message).pipe(import_effect29.Effect.andThen(import_effect29.Effect.fail(err))),
+      EnvFileReadError: (err) => import_effect29.Console.error(err.message).pipe(import_effect29.Effect.andThen(import_effect29.Effect.fail(err))),
+      EnvFileWriteError: (err) => import_effect29.Console.error(err.message).pipe(import_effect29.Effect.andThen(import_effect29.Effect.fail(err))),
+      DevCredentialsStoreReadError: (err) => import_effect29.Console.error(err.message).pipe(import_effect29.Effect.andThen(import_effect29.Effect.fail(err))),
+      DevCredentialsStoreWriteError: (err) => import_effect29.Console.error(err.message).pipe(import_effect29.Effect.andThen(import_effect29.Effect.fail(err)))
     })
   )
 );
 
 // src/commands/whoami/index.ts
-var import_cli15 = require("@effect/cli");
-var import_effect29 = require("effect");
-var whoamiCommand = import_cli15.Command.make(
+var import_cli16 = require("@effect/cli");
+var import_effect30 = require("effect");
+var whoamiCommand = import_cli16.Command.make(
   "whoami",
   {},
-  () => import_effect29.Effect.gen(function* () {
+  () => import_effect30.Effect.gen(function* () {
     const auth = yield* AuthService;
     const info = yield* auth.getUserInfo;
-    yield* import_effect29.Console.log(JSON.stringify(info, null, 2));
+    yield* import_effect30.Console.log(JSON.stringify(info, null, 2));
   }).pipe(
-    import_effect29.Effect.catchTags({
-      NotAuthenticatedError: () => import_effect29.Console.log('You are not logged in. Run "gigadrive login" to authenticate.'),
-      UserInfoFetchError: (err) => import_effect29.Console.error(`Failed to retrieve user info: ${err.message}`),
-      OAuthDiscoveryError: (err) => import_effect29.Console.error(`Failed to retrieve user info: ${err.message}`)
+    import_effect30.Effect.catchTags({
+      NotAuthenticatedError: () => import_effect30.Console.log('You are not logged in. Run "gigadrive login" to authenticate.'),
+      UserInfoFetchError: (err) => import_effect30.Console.error(`Failed to retrieve user info: ${err.message}`),
+      OAuthDiscoveryError: (err) => import_effect30.Console.error(`Failed to retrieve user info: ${err.message}`)
     })
   )
 );
 
 // src/index.ts
-var gigadrive = import_cli16.Command.make("gigadrive", {}, () => import_effect30.Effect.void).pipe(
-  import_cli16.Command.withSubcommands([
+var gigadrive = import_cli17.Command.make("gigadrive", {}, () => import_effect31.Effect.void).pipe(
+  import_cli17.Command.withSubcommands([
     loginCommand,
     logoutCommand,
     whoamiCommand,
@@ -3661,6 +4552,8 @@ var gigadrive = import_cli16.Command.make("gigadrive", {}, () => import_effect30
     deploymentsCommand,
     domainsCommand,
     aiCommand,
+    microvmsCommand,
+    vmCommand,
     buildCommand,
     debugCommand,
     deployCommand,
@@ -3668,11 +4561,11 @@ var gigadrive = import_cli16.Command.make("gigadrive", {}, () => import_effect30
     setupCommand
   ])
 );
-var cli = import_cli16.Command.run(gigadrive, {
+var cli = import_cli17.Command.run(gigadrive, {
   name: "Gigadrive CLI",
   version: package_default.version
 });
-var BaseServices = import_effect30.Layer.mergeAll(
+var BaseServices = import_effect31.Layer.mergeAll(
   OAuthConfigService.Default,
   AuthStorageService.Default,
   PackageManagerService.Default,
@@ -3682,13 +4575,13 @@ var BaseServices = import_effect30.Layer.mergeAll(
   ProjectLinkService.Default,
   EnvFileService.Default,
   DevCredentialsStore.Default
-).pipe(import_effect30.Layer.provideMerge(AuthService.Default));
-var ApiClientLive = import_effect30.Layer.provide(ApiClientService.Default, BaseServices);
-var DeploymentApiLive = import_effect30.Layer.provide(DeploymentApiService.Default, BaseServices);
-var LocalCredentialsLive = import_effect30.Layer.provide(LocalCredentialsService.Default, BaseServices);
-var ServicesLive = import_effect30.Layer.mergeAll(BaseServices, ApiClientLive, DeploymentApiLive, LocalCredentialsLive);
-var AppLive = import_effect30.Layer.mergeAll(ServicesLive, import_effect30.Logger.minimumLogLevel(import_effect30.LogLevel.Info)).pipe(
-  import_effect30.Layer.provideMerge(import_platform_node.NodeContext.layer)
-);
-import_platform_node.NodeRuntime.runMain(import_effect30.Effect.provide(cli(process.argv), AppLive));
+).pipe(import_effect31.Layer.provideMerge(AuthService.Default));
+var ApiClientLive = import_effect31.Layer.provide(ApiClientService.Default, BaseServices);
+var DeploymentApiLive = import_effect31.Layer.provide(DeploymentApiService.Default, BaseServices);
+var LocalCredentialsLive = import_effect31.Layer.provide(LocalCredentialsService.Default, BaseServices);
+var ServicesLive = import_effect31.Layer.mergeAll(BaseServices, ApiClientLive, DeploymentApiLive, LocalCredentialsLive);
+var AppLive = import_effect31.Layer.mergeAll(ServicesLive, import_effect31.Logger.minimumLogLevel(import_effect31.LogLevel.Info)).pipe(
+  import_effect31.Layer.provideMerge(import_platform_node.NodeContext.layer)
+);
+import_platform_node.NodeRuntime.runMain(import_effect31.Effect.provide(cli(process.argv), AppLive));
 //# sourceMappingURL=index.cjs.map