gigadrive 2.13.0 → 2.15.0

package/dist/index.mjs

@@ -9,7 +9,7 @@ import { Effect as Effect29, Layer, LogLevel, Logger } from "effect";
 // package.json
 var package_default = {
   name: "gigadrive",
-  version: "2.13.0",
+  version: "2.15.0",
   repository: {
     type: "git",
     url: "https://github.com/Gigadrive/sdk.git",
@@ -3089,6 +3089,37 @@ var formatImageTable = (images) => formatTable([
   ["NAME", "STATUS", "SOURCE", "ID"],
   ...images.map((image) => [image.name, image.status, imageSource(image), image.id])
 ]);
+var formatWebhookTable = (webhooks) => formatTable([
+  ["URL", "EVENTS", "STATUS", "ID"],
+  ...webhooks.map((webhook) => [
+    webhook.url,
+    webhook.events.join(","),
+    webhook.enabled ? "enabled" : "disabled",
+    webhook.id
+  ])
+]);
+var formatVolumeTable = (volumes) => formatTable([
+  ["NAME", "SIZE", "STORED", "STATUS", "LAST SAVED", "ID"],
+  ...volumes.map((volume) => [
+    volume.name,
+    `${String(volume.sizeMb)} MiB`,
+    volume.storedBytes === null ? "-" : formatBytes(volume.storedBytes),
+    volume.attachedMicrovmId ? `${volume.status} (${volume.attachedMicrovmId})` : volume.status,
+    volume.lastSaveError ? `failed: ${volume.lastSaveError}` : volume.lastSavedAt ?? "never",
+    volume.id
+  ])
+]);
+var formatDeliveryTable = (deliveries) => formatTable([
+  ["CREATED", "EVENT", "STATUS", "ATTEMPTS", "RESPONSE", "MICROVM"],
+  ...deliveries.map((delivery) => [
+    delivery.createdAt,
+    delivery.eventType,
+    delivery.status,
+    String(delivery.attempts),
+    delivery.lastStatusCode === null ? delivery.lastError ?? "-" : String(delivery.lastStatusCode),
+    delivery.microvmId
+  ])
+]);
 var formatBytes = (bytes) => {
   if (bytes < 1024) return `${bytes} B`;
   const units = ["KiB", "MiB", "GiB", "TiB"];
@@ -3323,6 +3354,25 @@ var withClient = (run) => Effect22.gen(function* () {
   return yield* Effect22.tryPromise({ try: () => run(client), catch: toApiRequestError });
 });
 var signalOnInterrupt = (signal) => (command, exit) => Exit.isInterrupted(exit) ? Effect22.tryPromise(() => command.kill(signal)).pipe(Effect22.timeout("2 seconds"), Effect22.ignore) : Effect22.void;
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var parseVolumeFlags = (values) => Effect22.gen(function* () {
+  if (values.length > 4) {
+    return yield* new InvalidMicroVmOptionsError({ message: "--volume takes at most 4 volumes." });
+  }
+  const volumes = [];
+  for (const value of values) {
+    const separator = value.indexOf(":");
+    const volumeId = separator > 0 ? value.slice(0, separator) : "";
+    const mountPath = separator > 0 ? value.slice(separator + 1) : "";
+    if (volumeId === "" || !mountPath.startsWith("/")) {
+      return yield* new InvalidMicroVmOptionsError({
+        message: `--volume must be VOLUME:PATH with an absolute path, such as cache:/cache (got ${value}).`
+      });
+    }
+    volumes.push({ volumeId, mountPath });
+  }
+  return volumes;
+});
 var checkEgressFlags = (denyEgress, allowEgress) => Effect22.gen(function* () {
   if (denyEgress && allowEgress.length > 0) {
     return yield* new InvalidMicroVmOptionsError({
@@ -3353,6 +3403,10 @@ var createInput = (flags) => Effect22.gen(function* () {
   if (badPort !== void 0) {
     return yield* new InvalidMicroVmOptionsError({ message: `--port must be between 1 and 65535 (got ${badPort}).` });
   }
+  const volumes = yield* parseVolumeFlags(flags.volumes);
+  if (volumes.length > 0 && flags.pauseOnTimeout) {
+    return yield* new InvalidMicroVmOptionsError({ message: "--volume cannot be combined with --pause-on-timeout." });
+  }
   const applicationId = yield* resolveApplicationId(flags.app);
   const input = {
     ...applicationId ? { applicationId } : {},
@@ -3369,6 +3423,7 @@ var createInput = (flags) => Effect22.gen(function* () {
     ...flags.ports.length > 0 ? { ports: [...flags.ports] } : {},
     ...env ? { env } : {},
     ...metadata ? { metadata } : {},
+    ...volumes.length > 0 ? { volumes } : {},
     ...flags.denyEgress || flags.privatePreviews || flags.allowEgress.length > 0 ? {
       network: {
         egress: flags.denyEgress ? "deny" : "allow",
@@ -3382,7 +3437,26 @@ var createInput = (flags) => Effect22.gen(function* () {
 });
 var createMicroVm = (flags) => Effect22.gen(function* () {
   const apiClient = yield* ApiClientService;
-  const input = yield* createInput(flags);
+  const parsed = yield* createInput(flags);
+  const named = (parsed.volumes ?? []).filter((volume) => !UUID.test(volume.volumeId));
+  const known = named.length > 0 ? yield* apiClient.request(
+    (client) => client.microvms.volumes.list({ ...parsed.applicationId ? { applicationId: parsed.applicationId } : {} })
+  ) : [];
+  const volumes = [];
+  for (const volume of parsed.volumes ?? []) {
+    if (UUID.test(volume.volumeId)) {
+      volumes.push(volume);
+      continue;
+    }
+    const match = known.find((entry) => entry.name === volume.volumeId);
+    if (match === void 0) {
+      return yield* new InvalidMicroVmOptionsError({
+        message: `No volume is named ${volume.volumeId}. Create it with "gigadrive microvms volumes create ${volume.volumeId}".`
+      });
+    }
+    volumes.push({ volumeId: match.id, mountPath: volume.mountPath });
+  }
+  const input = volumes.length > 0 ? { ...parsed, volumes } : parsed;
   if (!flags.json) yield* Console12.error(`Creating a microVM from ${input.image ?? "node22"}...`);
   const vm = yield* apiClient.request((client) => client.microvms.create(input));
   if (flags.json) {
@@ -3453,6 +3527,13 @@ var createCommand = Command12.make(
         "Resume the paused microVM when a command, file call or public preview request reaches it"
       )
     ),
+    volumes: Options7.text("volume").pipe(
+      Options7.withAlias("v"),
+      Options7.withDescription(
+        "Attach a volume as VOLUME:PATH, by ID or name, such as cache:/cache (repeatable, up to 4; saved when the microVM stops)"
+      ),
+      Options7.repeated
+    ),
     region: Options7.text("region").pipe(Options7.withDescription("Region to place the microVM in"), Options7.optional),
     json: jsonOption2
   },
@@ -3935,6 +4016,205 @@ var imagesCommand = Command12.make("images", {}, () => Effect22.void).pipe(
   Command12.withDescription("Built-in and custom microVM images"),
   Command12.withSubcommands([imagesListCommand, imagesCreateCommand, imagesRemoveCommand])
 );
+var volumeIdArg = Args5.text({ name: "volume-id" }).pipe(Args5.withDescription("The volume ID"));
+var volumesListCommand = Command12.make(
+  "ls",
+  { app: appOption6, json: jsonOption2 },
+  ({ app, json }) => Effect22.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    const applicationId = yield* resolveApplicationId(app);
+    const volumes = yield* apiClient.request((client) => client.microvms.volumes.list({ applicationId }));
+    if (json) return yield* Console12.log(JSON.stringify(volumes, null, 2));
+    if (volumes.length === 0)
+      return yield* Console12.log('No volumes yet. Create one with "gigadrive microvms volumes create <name>".');
+    for (const line of formatVolumeTable(volumes)) yield* Console12.log(line);
+  }).pipe(reportErrors2("list volumes"))
+).pipe(Command12.withDescription("List the application's volumes"));
+var createVolume = (flags) => Effect22.gen(function* () {
+  const apiClient = yield* ApiClientService;
+  const applicationId = yield* resolveApplicationId(flags.app);
+  const volume = yield* apiClient.request(
+    (client) => client.microvms.volumes.create({
+      name: flags.name,
+      ...Option14.match(flags.size, { onNone: () => ({}), onSome: (sizeMb) => ({ sizeMb }) }),
+      ...applicationId ? { applicationId } : {}
+    })
+  );
+  if (flags.json) {
+    yield* Console12.log(JSON.stringify(volume, null, 2));
+  } else {
+    yield* Console12.log(`Created volume ${volume.name} (${String(volume.sizeMb)} MiB, ${volume.id}).`);
+    yield* Console12.log(`Attach it: gigadrive microvms create --volume ${volume.name}:/data`);
+  }
+  return volume;
+});
+var volumesCreateCommand = Command12.make(
+  "create",
+  {
+    name: Args5.text({ name: "name" }).pipe(
+      Args5.withDescription("Lowercase letters, digits and -, unique per application")
+    ),
+    size: Options7.integer("size").pipe(
+      Options7.withDescription("Size in MiB, 1024 to 51200 (default: 10240)"),
+      Options7.optional
+    ),
+    app: appOption6,
+    json: jsonOption2
+  },
+  (flags) => createVolume(flags).pipe(Effect22.asVoid, reportErrors2("create the volume"))
+).pipe(Command12.withDescription("Create an empty volume"));
+var volumesRenameCommand = Command12.make(
+  "rename",
+  { volumeId: volumeIdArg, name: Args5.text({ name: "name" }).pipe(Args5.withDescription("The new name")) },
+  ({ volumeId, name }) => Effect22.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    const volume = yield* apiClient.request((client) => client.microvms.volumes.rename(volumeId, name));
+    yield* Console12.log(`Renamed the volume to ${volume.name}.`);
+  }).pipe(reportErrors2("rename the volume"))
+).pipe(Command12.withDescription("Rename a volume"));
+var volumesSaveCommand = Command12.make(
+  "save",
+  { microvmId: Args5.text({ name: "microvm-id" }).pipe(Args5.withDescription("A running microVM with volumes")) },
+  ({ microvmId }) => Effect22.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    yield* apiClient.request((client) => client.microvms.saveVolumes(microvmId));
+    yield* Console12.log(`Saved the volumes of ${microvmId}.`);
+  }).pipe(reportErrors2("save the volumes"))
+).pipe(Command12.withDescription("Save a running microVM's volumes without stopping it"));
+var volumesRemoveCommand = Command12.make(
+  "rm",
+  { volumeId: volumeIdArg },
+  ({ volumeId }) => Effect22.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    yield* apiClient.request((client) => client.microvms.volumes.delete(volumeId));
+    yield* Console12.log(`Deleted volume ${volumeId}.`);
+  }).pipe(reportErrors2("delete the volume"))
+).pipe(Command12.withDescription("Delete a volume and its contents (it must not be attached)"));
+var volumesCommand = Command12.make("volumes", {}, () => Effect22.void).pipe(
+  Command12.withDescription("Persistent filesystems that outlive the microVMs they are attached to"),
+  Command12.withSubcommands([
+    volumesListCommand,
+    volumesCreateCommand,
+    volumesRenameCommand,
+    volumesSaveCommand,
+    volumesRemoveCommand
+  ])
+);
+var WEBHOOK_EVENTS = [
+  "microvm.created",
+  "microvm.running",
+  "microvm.paused",
+  "microvm.stopped",
+  "microvm.failed"
+];
+var webhookIdArg = Args5.text({ name: "webhook-id" }).pipe(Args5.withDescription("The webhook ID"));
+var webhooksListCommand = Command12.make(
+  "ls",
+  { app: appOption6, json: jsonOption2 },
+  ({ app, json }) => Effect22.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    const applicationId = yield* resolveApplicationId(app);
+    const webhooks = yield* apiClient.request((client) => client.microvms.webhooks.list({ applicationId }));
+    if (json) return yield* Console12.log(JSON.stringify(webhooks, null, 2));
+    if (webhooks.length === 0)
+      return yield* Console12.log('No webhooks yet. Add one with "gigadrive microvms webhooks add".');
+    for (const line of formatWebhookTable(webhooks)) yield* Console12.log(line);
+  }).pipe(reportErrors2("list webhooks"))
+).pipe(Command12.withDescription("List the application's microVM webhooks"));
+var addWebhook = (flags) => Effect22.gen(function* () {
+  const apiClient = yield* ApiClientService;
+  const unknown = flags.events.find((event) => !WEBHOOK_EVENTS.includes(event));
+  if (unknown !== void 0) {
+    return yield* new InvalidMicroVmOptionsError({
+      message: `${unknown} is not a microVM event. Use ${WEBHOOK_EVENTS.join(", ")}.`
+    });
+  }
+  const events = flags.events.length > 0 ? [...new Set(flags.events)] : WEBHOOK_EVENTS;
+  const applicationId = yield* resolveApplicationId(flags.app);
+  const webhook = yield* apiClient.request(
+    (client) => client.microvms.webhooks.create({
+      url: flags.url,
+      events,
+      ...Option14.isSome(flags.description) ? { description: flags.description.value } : {},
+      ...applicationId ? { applicationId } : {}
+    })
+  );
+  if (flags.json) {
+    yield* Console12.log(JSON.stringify(webhook, null, 2));
+  } else {
+    yield* Console12.log(`Added webhook ${webhook.id} for ${webhook.events.join(", ")}.`);
+    yield* Console12.log(`Signing secret (shown only now): ${webhook.secret}`);
+  }
+  return webhook;
+});
+var webhooksAddCommand = Command12.make(
+  "add",
+  {
+    url: Args5.text({ name: "url" }).pipe(Args5.withDescription("HTTPS URL on a public host")),
+    events: Options7.text("event").pipe(
+      Options7.withDescription(`Event to send (repeatable; default: all of ${WEBHOOK_EVENTS.join(", ")})`),
+      Options7.repeated
+    ),
+    description: Options7.text("description").pipe(Options7.withDescription("A note for yourself"), Options7.optional),
+    app: appOption6,
+    json: jsonOption2
+  },
+  (flags) => addWebhook(flags).pipe(Effect22.asVoid, reportErrors2("add the webhook"))
+).pipe(Command12.withDescription("Add an endpoint for microVM lifecycle events and print its signing secret"));
+var webhooksEnableCommand = (enabled) => Command12.make(
+  enabled ? "enable" : "disable",
+  { webhookId: webhookIdArg },
+  ({ webhookId }) => Effect22.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    const webhook = yield* apiClient.request((client) => client.microvms.webhooks.update(webhookId, { enabled }));
+    yield* Console12.log(`${webhook.url} is ${webhook.enabled ? "enabled" : "disabled"}.`);
+  }).pipe(reportErrors2(enabled ? "enable the webhook" : "disable the webhook"))
+).pipe(
+  Command12.withDescription(
+    enabled ? "Send events to a webhook again" : "Stop sending events to a webhook; waiting retries are held"
+  )
+);
+var webhooksSecretCommand = Command12.make(
+  "rotate-secret",
+  { webhookId: webhookIdArg },
+  ({ webhookId }) => Effect22.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    const webhook = yield* apiClient.request((client) => client.microvms.webhooks.rotateSecret(webhookId));
+    yield* Console12.log(`New signing secret (shown only now): ${webhook.secret}`);
+  }).pipe(reportErrors2("replace the signing secret"))
+).pipe(Command12.withDescription("Replace the signing secret; the old one stops signing at once"));
+var webhooksDeliveriesCommand = Command12.make(
+  "deliveries",
+  { webhookId: webhookIdArg, json: jsonOption2 },
+  ({ webhookId, json }) => Effect22.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    const deliveries = yield* apiClient.request((client) => client.microvms.webhooks.listDeliveries(webhookId));
+    if (json) return yield* Console12.log(JSON.stringify(deliveries, null, 2));
+    if (deliveries.length === 0) return yield* Console12.log("Nothing has been sent yet.");
+    for (const line of formatDeliveryTable(deliveries)) yield* Console12.log(line);
+  }).pipe(reportErrors2("list the deliveries"))
+).pipe(Command12.withDescription("Show a webhook's 50 most recent deliveries"));
+var webhooksRemoveCommand = Command12.make(
+  "rm",
+  { webhookId: webhookIdArg },
+  ({ webhookId }) => Effect22.gen(function* () {
+    const apiClient = yield* ApiClientService;
+    yield* apiClient.request((client) => client.microvms.webhooks.delete(webhookId));
+    yield* Console12.log(`Deleted webhook ${webhookId}.`);
+  }).pipe(reportErrors2("delete the webhook"))
+).pipe(Command12.withDescription("Delete a webhook"));
+var webhooksCommand = Command12.make("webhooks", {}, () => Effect22.void).pipe(
+  Command12.withDescription("Signed HTTPS requests when a microVM is created, starts, pauses, stops or fails"),
+  Command12.withSubcommands([
+    webhooksListCommand,
+    webhooksAddCommand,
+    webhooksEnableCommand(true),
+    webhooksEnableCommand(false),
+    webhooksSecretCommand,
+    webhooksDeliveriesCommand,
+    webhooksRemoveCommand
+  ])
+);
 var SUBCOMMANDS = [
   createCommand,
   listCommand2,
@@ -3947,7 +4227,9 @@ var SUBCOMMANDS = [
   removeCommand2,
   extendCommand,
   networkCommand,
-  imagesCommand
+  imagesCommand,
+  volumesCommand,
+  webhooksCommand
 ];
 var microvmsCommand = Command12.make("microvms", {}, () => Effect22.void).pipe(
   Command12.withDescription("Isolated Linux machines for running code: create, exec, shell, cp, stop"),