gigadrive 2.11.0 → 2.13.0

package/README.md

@@ -36,6 +36,7 @@ gigadrive vm cp vm:<id>:/app/dist ./dist                        # and out
 gigadrive vm shell <id>                                         # interactive terminal
 gigadrive vm ls                                                 # running microVMs (--all includes stopped)
 gigadrive vm extend <id> 1h                                     # stop it one hour from now
+gigadrive vm network <id> --deny-egress                         # cut its internet while it runs
 gigadrive vm stop <id> && gigadrive vm rm <id>
 gigadrive vm images create py-ml --from python:3.13 --wait      # custom images (or --dockerfile ./Dockerfile)
 ```

package/dist/index.cjs

@@ -32,7 +32,7 @@ var import_effect31 = require("effect");
 // package.json
 var package_default = {
   name: "gigadrive",
-  version: "2.11.0",
+  version: "2.13.0",
   repository: {
     type: "git",
     url: "https://github.com/Gigadrive/sdk.git",
@@ -3333,29 +3333,32 @@ var withClient = (run) => import_effect24.Effect.gen(function* () {
   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)
-  });
-  if (flags.denyEgress && flags.allowEgress.length > 0) {
+var checkEgressFlags = (denyEgress, allowEgress) => import_effect24.Effect.gen(function* () {
+  if (denyEgress && allowEgress.length > 0) {
     return yield* new InvalidMicroVmOptionsError({
       message: "--allow-egress cannot be combined with --deny-egress."
     });
   }
-  if (flags.allowEgress.length > 32) {
+  if (allowEgress.length > 32) {
     return yield* new InvalidMicroVmOptionsError({ message: "--allow-egress takes at most 32 entries." });
   }
   const network = /^\d{1,3}(\.\d{1,3}){3}\/\d{1,2}$/;
   const domain = /^(\*\.)?([a-z0-9-]+\.)+[a-z0-9-]*[a-z][a-z0-9-]*\.?$/i;
-  const badEntry = flags.allowEgress.find((entry) => !network.test(entry.trim()) && !domain.test(entry.trim()));
+  const badEntry = allowEgress.find((entry) => !network.test(entry.trim()) && !domain.test(entry.trim()));
   if (badEntry !== void 0) {
     return yield* new InvalidMicroVmOptionsError({
       message: `--allow-egress must be a domain name such as api.openai.com or *.github.com, or an IPv4 network such as 140.82.112.0/20 (got ${badEntry}).`
     });
   }
+});
+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)
+  });
+  yield* checkEgressFlags(flags.denyEgress, flags.allowEgress);
   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}).` });
@@ -3371,6 +3374,8 @@ var createInput = (flags) => import_effect24.Effect.gen(function* () {
     ...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.pauseOnTimeout ? { onTimeout: "pause" } : {},
+    ...flags.autoResume ? { autoResume: true } : {},
     ...flags.ports.length > 0 ? { ports: [...flags.ports] } : {},
     ...env ? { env } : {},
     ...metadata ? { metadata } : {},
@@ -3378,7 +3383,7 @@ var createInput = (flags) => import_effect24.Effect.gen(function* () {
       network: {
         egress: flags.denyEgress ? "deny" : "allow",
         ...flags.privatePreviews ? { previews: "private" } : {},
-        ...flags.allowEgress.length > 0 ? { allow: [...flags.allowEgress] } : {}
+        ...flags.allowEgress.length > 0 ? { allow: flags.allowEgress.map((entry) => entry.trim()) } : {}
       }
     } : {},
     ...import_effect24.Option.match(flags.region, { onNone: () => ({}), onSome: (region) => ({ region }) })
@@ -3450,6 +3455,14 @@ var createCommand = import_cli12.Command.make(
       ),
       import_cli12.Options.repeated
     ),
+    pauseOnTimeout: import_cli12.Options.boolean("pause-on-timeout").pipe(
+      import_cli12.Options.withDescription("Pause the microVM when its timeout ends instead of stopping it")
+    ),
+    autoResume: import_cli12.Options.boolean("auto-resume").pipe(
+      import_cli12.Options.withDescription(
+        "Resume the paused microVM when a command, file call or public preview request reaches it"
+      )
+    ),
     region: import_cli12.Options.text("region").pipe(import_cli12.Options.withDescription("Region to place the microVM in"), import_cli12.Options.optional),
     json: jsonOption2
   },
@@ -3505,6 +3518,36 @@ var getCommand = import_cli12.Command.make(
     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 formatGigabytes = (bytes) => `${(bytes / 1e9).toFixed(1)} GB`;
+var describeMicroVmMetrics = (metrics) => {
+  const latest = metrics.cpu.at(-1);
+  const peak = metrics.cpu.reduce((max, point) => Math.max(max, point.cpuPercent), 0);
+  return [
+    `CPU (last ${metrics.windowMinutes} min, ${metrics.vcpus} vCPU): ${latest ? `${latest.cpuPercent}% at ${latest.time}, peak ${peak}%` : "no samples"}`,
+    metrics.current ? `Memory: ${formatGigabytes(metrics.current.memoryUsedBytes)} of ${formatGigabytes(metrics.current.memoryTotalBytes)}` : "Memory: unavailable (not running, or no answer)",
+    metrics.current ? `Disk:   ${formatGigabytes(metrics.current.diskUsedBytes)} of ${formatGigabytes(metrics.current.diskTotalBytes)}` : "Disk:   unavailable (not running, or no answer)"
+  ];
+};
+var metricsCommand = import_cli12.Command.make(
+  "metrics",
+  {
+    microvmId: microvmIdArg,
+    window: import_cli12.Options.integer("window").pipe(
+      import_cli12.Options.withDescription("Minutes of CPU history, 1 to 1440 (default: 15)"),
+      import_cli12.Options.optional
+    ),
+    json: jsonOption2
+  },
+  ({ microvmId, window, json }) => import_effect24.Effect.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    const windowMinutes = import_effect24.Option.getOrUndefined(window);
+    const metrics = yield* apiClient.request(
+      (client) => client.microvms.getMetrics(microvmId, windowMinutes === void 0 ? {} : { windowMinutes })
+    );
+    if (json) return yield* import_effect24.Console.log(JSON.stringify(metrics, null, 2));
+    for (const line of describeMicroVmMetrics(metrics)) yield* import_effect24.Console.log(line);
+  }).pipe(reportErrors2("read the microVM metrics"))
+).pipe(import_cli12.Command.withDescription("Show a microVM's CPU, memory and disk use"));
 var execInMicroVm = (flags, io = nodeSessionIo()) => import_effect24.Effect.gen(function* () {
   const env = yield* keyValues("--env", flags.env);
   const timeout = yield* optionalDuration("--timeout", flags.timeout);
@@ -3766,6 +3809,46 @@ var extendCommand = import_cli12.Command.make(
   },
   ({ 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 updateMicroVmNetwork = (microvmId, flags) => import_effect24.Effect.gen(function* () {
+  const chosen = [flags.denyEgress, flags.allowEgress.length > 0, flags.allowAllEgress].filter(Boolean).length;
+  if (chosen !== 1) {
+    return yield* new InvalidMicroVmOptionsError({
+      message: "Pass exactly one of --deny-egress, --allow-egress or --allow-all-egress."
+    });
+  }
+  yield* checkEgressFlags(flags.denyEgress, flags.allowEgress);
+  const apiClient = yield* ApiClientService;
+  const vm = yield* apiClient.request(
+    (client) => client.microvms.updateNetwork(
+      microvmId,
+      flags.denyEgress ? { egress: "deny" } : flags.allowEgress.length > 0 ? { egress: "allow", allow: flags.allowEgress.map((entry) => entry.trim()) } : { egress: "allow" }
+    )
+  );
+  const reach = vm.network.egress === "deny" ? "no outbound traffic" : vm.network.allow ? vm.network.allow.join(", ") : "the whole internet";
+  yield* import_effect24.Console.log(`${vm.id} now reaches ${reach}.`);
+  return vm;
+});
+var networkCommand = import_cli12.Command.make(
+  "network",
+  {
+    microvmId: microvmIdArg,
+    denyEgress: import_cli12.Options.boolean("deny-egress").pipe(import_cli12.Options.withDescription("Block all outbound network traffic")),
+    allowEgress: import_cli12.Options.text("allow-egress").pipe(
+      import_cli12.Options.withDescription(
+        "Only reach this domain name (api.openai.com, *.github.com for every subdomain) or public IPv4 network (140.82.112.0/20) (repeatable, up to 32)"
+      ),
+      import_cli12.Options.repeated
+    ),
+    allowAllEgress: import_cli12.Options.boolean("allow-all-egress").pipe(
+      import_cli12.Options.withDescription("Reach the whole internet again (private networks stay blocked)")
+    )
+  },
+  ({ microvmId, ...flags }) => updateMicroVmNetwork(microvmId, flags).pipe(import_effect24.Effect.asVoid, reportErrors2("update the microVM network"))
+).pipe(
+  import_cli12.Command.withDescription(
+    "Change what a running or paused microVM may reach; connections the new rules no longer allow are closed"
+  )
+);
 var imagesListCommand = import_cli12.Command.make(
   "ls",
   { app: appOption6, json: jsonOption2 },
@@ -3866,12 +3949,14 @@ var SUBCOMMANDS = [
   createCommand,
   listCommand2,
   getCommand,
+  metricsCommand,
   execCommand,
   shellCommand,
   copyCommand,
   stopCommand,
   removeCommand2,
   extendCommand,
+  networkCommand,
   imagesCommand
 ];
 var microvmsCommand = import_cli12.Command.make("microvms", {}, () => import_effect24.Effect.void).pipe(