freestyle 0.1.49 → 0.1.51

package/cli.mjs

@@ -2,7 +2,7 @@
 import * as dotenv from 'dotenv';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
-import { Freestyle, VmSpec } from './index.mjs';
+import { Freestyle, VmSpec, readFiles } from './index.mjs';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
@@ -686,6 +686,94 @@ async function sshIntoVm(vmId, options = {}) {
     });
   });
 }
+function buildSubcommands(yargs, resolveBuild, idName) {
+  return yargs.command(
+    `get <${idName}>`,
+    "Show the build record",
+    (y) => y.positional(idName, { type: "string", demandOption: true }).option("json", { type: "boolean", default: false }),
+    async (argv) => {
+      loadEnv();
+      try {
+        const build = await resolveBuild(argv[idName]);
+        const record = await build.get();
+        console.log(JSON.stringify(record, null, 2));
+      } catch (e) {
+        handleError(e);
+      }
+    }
+  ).command(
+    `phases <${idName}>`,
+    "List build phases",
+    (y) => y.positional(idName, { type: "string", demandOption: true }).option("json", { type: "boolean", default: false }),
+    async (argv) => {
+      loadEnv();
+      try {
+        const build = await resolveBuild(argv[idName]);
+        const phases = await build.phases();
+        if (argv.json) {
+          console.log(JSON.stringify(phases, null, 2));
+          return;
+        }
+        console.log(
+          formatTable(
+            ["Phase ID", "Name", "Snapshot", "Started"],
+            phases.map((p) => [
+              p.phaseId,
+              p.name,
+              p.snapshotId ?? "\u2014",
+              p.startedAt
+            ])
+          )
+        );
+      } catch (e) {
+        handleError(e);
+      }
+    }
+  ).command(
+    `debug <${idName}>`,
+    "Boot a debug VM from the failed phase's snapshot and SSH in",
+    (y) => y.positional(idName, { type: "string", demandOption: true }),
+    async (argv) => {
+      loadEnv();
+      try {
+        const fs = await getFreestyleClient();
+        const build = await resolveBuild(argv[idName]);
+        const failed = await build.failedPhase();
+        if (!failed) {
+          console.error(
+            `No bookable failed-phase snapshot for build ${build.buildId} \u2014 nothing to debug.`
+          );
+          process.exit(1);
+        }
+        console.log(
+          `Failed phase: ${failed.name} (snapshot ${failed.snapshotId})`
+        );
+        console.log("Booting debug VM\u2026");
+        const result = await fs.vms.create({
+          snapshotId: failed.snapshotId
+        });
+        console.log(`\u2713 VM ${result.vmId} running`);
+        await sshIntoVm(result.vmId);
+      } catch (e) {
+        handleError(e);
+      }
+    }
+  ).command(
+    `wait <${idName}>`,
+    "Wait until the build reaches a terminal state",
+    (y) => y.positional(idName, { type: "string", demandOption: true }),
+    async (argv) => {
+      loadEnv();
+      try {
+        const build = await resolveBuild(argv[idName]);
+        const record = await build.wait();
+        console.log(JSON.stringify(record, null, 2));
+      } catch (e) {
+        handleError(e);
+      }
+    }
+  ).demandCommand(1, "Specify a build action");
+}
 const vmCommand = {
   command: "vm <action>",
   describe: "Manage Virtual Machines",
@@ -940,12 +1028,330 @@ Exit code: ${result.statusCode || 0}`);
           handleError(error);
         }
       }
+    ).command(
+      "build <action>",
+      "Inspect the build that produced a VM",
+      (yargs2) => buildSubcommands(yargs2, async (vmId) => {
+        const fs = await getFreestyleClient();
+        return fs.vms.ref({ vmId }).getBuild();
+      }, "vmId"),
+      () => {
+      }
+    ).command(
+      "snapshot <action>",
+      "Manage snapshots",
+      (yargs2) => yargs2.command(
+        "list",
+        "List snapshots",
+        (y) => y.option("show-failed", { type: "boolean", default: true }).option("show-deleted", { type: "boolean", default: false }).option("show-cancelled", {
+          type: "boolean",
+          default: false
+        }).option("show-lost", { type: "boolean", default: false }).option("json", { type: "boolean", default: false }),
+        async (argv) => {
+          loadEnv();
+          try {
+            const fs = await getFreestyleClient();
+            const result = await fs.vms.snapshots.list({
+              includeFailed: argv["show-failed"],
+              includeDeleted: argv["show-deleted"],
+              includeCancelled: argv["show-cancelled"],
+              includeLost: argv["show-lost"]
+            });
+            if (argv.json) {
+              console.log(JSON.stringify(result, null, 2));
+              return;
+            }
+            console.log(
+              formatTable(
+                ["Snapshot ID", "Name", "Source VM", "State", "Created"],
+                result.snapshots.map((s) => [
+                  s.snapshotId,
+                  s.name ?? "\u2014",
+                  s.sourceVmId ?? "\u2014",
+                  s.state ?? (s.failed ? "failed" : "ready"),
+                  s.createdAt
+                ])
+              )
+            );
+          } catch (e) {
+            handleError(e);
+          }
+        }
+      ).command(
+        "get <snapshotId>",
+        "Show a snapshot record",
+        (y) => y.positional("snapshotId", {
+          type: "string",
+          demandOption: true
+        }).option("json", { type: "boolean", default: false }),
+        async (argv) => {
+          loadEnv();
+          try {
+            const fs = await getFreestyleClient();
+            const info = await fs.vms.snapshots.ref({ snapshotId: argv.snapshotId }).get();
+            console.log(JSON.stringify(info, null, 2));
+          } catch (e) {
+            handleError(e);
+          }
+        }
+      ).command(
+        "delete <snapshotId>",
+        "Delete a snapshot",
+        (y) => y.positional("snapshotId", {
+          type: "string",
+          demandOption: true
+        }),
+        async (argv) => {
+          loadEnv();
+          try {
+            const fs = await getFreestyleClient();
+            await fs.vms.snapshots.ref({ snapshotId: argv.snapshotId }).delete();
+            console.log("\u2713 Snapshot deleted");
+          } catch (e) {
+            handleError(e);
+          }
+        }
+      ).command(
+        "rename <snapshotId>",
+        "Rename a snapshot",
+        (y) => y.positional("snapshotId", {
+          type: "string",
+          demandOption: true
+        }).option("name", {
+          type: "string",
+          demandOption: true,
+          description: "New name"
+        }),
+        async (argv) => {
+          loadEnv();
+          try {
+            const fs = await getFreestyleClient();
+            await fs.vms.snapshots.ref({ snapshotId: argv.snapshotId }).update({ name: argv.name });
+            console.log("\u2713 Snapshot renamed");
+          } catch (e) {
+            handleError(e);
+          }
+        }
+      ).command(
+        "boot <snapshotId>",
+        "Boot a VM from a snapshot",
+        (y) => y.positional("snapshotId", {
+          type: "string",
+          demandOption: true
+        }).option("ssh", { type: "boolean", default: false }),
+        async (argv) => {
+          loadEnv();
+          try {
+            const fs = await getFreestyleClient();
+            console.log(
+              `Booting VM from snapshot ${argv.snapshotId}...`
+            );
+            const result = await fs.vms.create({
+              snapshotId: argv.snapshotId
+            });
+            console.log(`\u2713 VM ${result.vmId} created`);
+            if (argv.ssh) {
+              await sshIntoVm(result.vmId);
+            }
+          } catch (e) {
+            handleError(e);
+          }
+        }
+      ).command(
+        "debug <snapshotId>",
+        "Boot a debug VM from a (possibly failed) snapshot and SSH in",
+        (y) => y.positional("snapshotId", {
+          type: "string",
+          demandOption: true
+        }),
+        async (argv) => {
+          loadEnv();
+          try {
+            const fs = await getFreestyleClient();
+            console.log(
+              `Booting debug VM from snapshot ${argv.snapshotId}...`
+            );
+            const result = await fs.vms.create({
+              snapshotId: argv.snapshotId
+            });
+            console.log(`\u2713 VM ${result.vmId} running`);
+            await sshIntoVm(result.vmId);
+          } catch (e) {
+            handleError(e);
+          }
+        }
+      ).command(
+        "build <action>",
+        "Inspect the build that produced a snapshot",
+        (yy) => buildSubcommands(
+          yy,
+          async (snapshotId) => {
+            const fs = await getFreestyleClient();
+            return fs.vms.snapshots.ref({ snapshotId }).getBuild();
+          },
+          "snapshotId"
+        ),
+        () => {
+        }
+      ).demandCommand(1, "Specify a snapshot action"),
+      () => {
+      }
     ).demandCommand(1, "You need to specify a vm action");
   },
   handler: () => {
   }
 };
 
+const ALWAYS_IGNORED_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  ".hg",
+  ".svn",
+  ".idea",
+  ".vscode",
+  "node_modules"
+]);
+const ALWAYS_IGNORED_FILES = /* @__PURE__ */ new Set([
+  ".DS_Store"
+]);
+function joinPosix(...parts) {
+  return path.posix.join(...parts.map((part) => part.replace(/\\/g, "/")));
+}
+function shouldIgnorePath(filePath, options) {
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  const segments = normalizedPath.split("/").filter(Boolean);
+  const basename = segments[segments.length - 1] || "";
+  for (const segment of segments.slice(0, -1)) {
+    if (ALWAYS_IGNORED_DIRS.has(segment)) {
+      return `ignored directory '${segment}'`;
+    }
+    if (options?.excludeNextArtifacts && segment === ".next") {
+      return "ignored build artifact directory '.next'";
+    }
+  }
+  if (ALWAYS_IGNORED_FILES.has(basename)) {
+    return `ignored file '${basename}'`;
+  }
+  if (basename === ".env" || basename.startsWith(".env.")) {
+    return "ignored sensitive env file";
+  }
+  if (options?.excludeNextArtifacts && basename === ".next") {
+    return "ignored build artifact directory '.next'";
+  }
+  return null;
+}
+function filterDeploymentFiles(files, options) {
+  const ignoredSummary = {};
+  const filtered = [];
+  for (const file of files) {
+    const reason = shouldIgnorePath(file.path, options);
+    if (reason) {
+      ignoredSummary[reason] = (ignoredSummary[reason] || 0) + 1;
+      continue;
+    }
+    filtered.push(file);
+  }
+  return {
+    files: filtered,
+    ignoredSummary
+  };
+}
+async function readFilesWithPrefix(dir, prefix) {
+  const files = await readFiles(dir);
+  return files.map((file) => ({
+    ...file,
+    path: joinPosix(prefix, file.path)
+  }));
+}
+function detectLockfile(projectRoot) {
+  const lockfiles = [
+    "package-lock.json",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "bun.lock",
+    "bun.lockb"
+  ];
+  return lockfiles.find(
+    (lockfile) => fs.existsSync(path.join(projectRoot, lockfile))
+  );
+}
+function detectNextJsProject(projectRoot) {
+  const nextConfigCandidates = [
+    "next.config.js",
+    "next.config.mjs",
+    "next.config.ts",
+    "next.config.cjs"
+  ];
+  if (nextConfigCandidates.some(
+    (fileName) => fs.existsSync(path.join(projectRoot, fileName))
+  )) {
+    return true;
+  }
+  const packageJsonPath = path.join(projectRoot, "package.json");
+  if (!fs.existsSync(packageJsonPath)) {
+    return false;
+  }
+  try {
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    return Boolean(
+      packageJson.dependencies?.next || packageJson.devDependencies?.next
+    );
+  } catch {
+    return false;
+  }
+}
+async function prepareNextJsBuiltFiles(projectRoot) {
+  const standaloneDir = path.join(projectRoot, ".next", "standalone");
+  const standaloneEntrypoint = path.join(standaloneDir, "server.js");
+  if (!fs.existsSync(standaloneDir) || !fs.statSync(standaloneDir).isDirectory() || !fs.existsSync(standaloneEntrypoint)) {
+    return null;
+  }
+  const files = await readFiles(standaloneDir);
+  const existingPaths = new Set(files.map((file) => file.path));
+  const projectPublicDir = path.join(projectRoot, "public");
+  if (fs.existsSync(projectPublicDir) && fs.statSync(projectPublicDir).isDirectory()) {
+    const publicFiles = await readFilesWithPrefix(projectPublicDir, "public");
+    for (const file of publicFiles) {
+      if (!existingPaths.has(file.path)) {
+        files.push(file);
+        existingPaths.add(file.path);
+      }
+    }
+  }
+  const projectStaticDir = path.join(projectRoot, ".next", "static");
+  if (fs.existsSync(projectStaticDir) && fs.statSync(projectStaticDir).isDirectory()) {
+    const staticFiles = await readFilesWithPrefix(
+      projectStaticDir,
+      ".next/static"
+    );
+    for (const file of staticFiles) {
+      if (!existingPaths.has(file.path)) {
+        files.push(file);
+        existingPaths.add(file.path);
+      }
+    }
+  }
+  const lockfile = detectLockfile(projectRoot);
+  if (lockfile && !existingPaths.has(lockfile)) {
+    const lockfileContent = fs.readFileSync(path.join(projectRoot, lockfile), "base64");
+    files.push({
+      path: lockfile,
+      content: lockfileContent,
+      encoding: "base64"
+    });
+  }
+  const freestyleJsonPath = path.join(projectRoot, "freestyle.json");
+  if (fs.existsSync(freestyleJsonPath) && !existingPaths.has("freestyle.json")) {
+    files.push({
+      path: "freestyle.json",
+      content: fs.readFileSync(freestyleJsonPath, "utf-8"),
+      encoding: "utf-8"
+    });
+  }
+  return {
+    files,
+    entrypointPath: "server.js"
+  };
+}
 const deployCommand = {
   command: "deploy",
   describe: "Deploy a serverless function",
@@ -958,15 +1364,36 @@ const deployCommand = {
       alias: "f",
       type: "string",
       description: "File path containing code to deploy"
+    }).option("dir", {
+      alias: "d",
+      type: "string",
+      description: "Directory path to deploy (prebuilt files, or source files when used with --build)"
     }).option("repo", {
       alias: "r",
       type: "string",
       description: "Git repository ID to deploy"
+    }).option("domain", {
+      type: "array",
+      description: "Domains to assign to the deployment (can be specified multiple times)",
+      default: []
     }).option("env", {
       alias: "e",
       type: "array",
       description: "Environment variables (KEY=VALUE)",
       default: []
+    }).option("build", {
+      type: "boolean",
+      description: "Enable server-side build (use with --repo or --dir source deployments)"
+    }).option("build-command", {
+      type: "string",
+      description: "Custom build command (for example: npm run build)"
+    }).option("build-out-dir", {
+      type: "string",
+      description: "Build output directory (for example: dist or .next/standalone)"
+    }).option("build-env", {
+      type: "array",
+      description: "Build environment variables (KEY=VALUE)",
+      default: []
     }).option("json", {
       type: "boolean",
       description: "Output as JSON",
@@ -974,15 +1401,41 @@ const deployCommand = {
     }).check((argv) => {
       const hasCode = !!argv.code;
       const hasFile = !!argv.file;
+      const hasDir = !!argv.dir;
       const hasRepo = !!argv.repo;
-      if (!hasCode && !hasFile && !hasRepo) {
-        throw new Error("You must specify one of --code, --file, or --repo");
+      const hasBuildConfig = !!argv.build || !!argv.buildCommand || !!argv.buildOutDir;
+      if (!hasCode && !hasFile && !hasDir && !hasRepo) {
+        throw new Error(
+          "You must specify one of --code, --file, --dir, or --repo"
+        );
+      }
+      if ([hasCode, hasFile, hasDir, hasRepo].filter(Boolean).length > 1) {
+        throw new Error(
+          "You can only specify one of --code, --file, --dir, or --repo"
+        );
+      }
+      if (hasBuildConfig && (hasCode || hasFile)) {
+        throw new Error(
+          "--build options are only supported with --repo or --dir"
+        );
       }
-      if ([hasCode, hasFile, hasRepo].filter(Boolean).length > 1) {
+      if (argv.buildEnv && argv.buildEnv.length > 0 && !hasBuildConfig) {
         throw new Error(
-          "You can only specify one of --code, --file, or --repo"
+          "--build-env requires --build, --build-command, or --build-out-dir"
         );
       }
+      if (!!argv.buildCommand && !argv.build) {
+        throw new Error("--build-command requires --build");
+      }
+      if (!!argv.buildOutDir && !argv.build) {
+        throw new Error("--build-out-dir requires --build");
+      }
+      if (!!argv.buildOutDir && !argv.buildCommand) {
+        throw new Error("--build-out-dir requires --build-command");
+      }
+      if (argv.buildEnv && argv.buildEnv.length > 0 && !argv.buildCommand) {
+        throw new Error("--build-env requires --build-command");
+      }
       return true;
     });
   },
@@ -992,11 +1445,55 @@ const deployCommand = {
     try {
       const freestyle = await getFreestyleClient();
       let code;
+      let files;
       let repo;
+      let entrypointPath;
+      let nextjsOptimization;
       if (args.code) {
         code = args.code;
       } else if (args.file) {
         code = fs.readFileSync(args.file, "utf-8");
+      } else if (args.dir) {
+        if (!fs.existsSync(args.dir)) {
+          throw new Error(`Directory not found: ${args.dir}`);
+        }
+        if (!fs.statSync(args.dir).isDirectory()) {
+          throw new Error(`Path is not a directory: ${args.dir}`);
+        }
+        const nextJsBuiltFiles = await prepareNextJsBuiltFiles(args.dir);
+        let ignoredSummary = {};
+        if (nextJsBuiltFiles) {
+          const filteredBuiltFiles = filterDeploymentFiles(nextJsBuiltFiles.files, {
+            excludeNextArtifacts: false
+          });
+          files = filteredBuiltFiles.files;
+          ignoredSummary = filteredBuiltFiles.ignoredSummary;
+          entrypointPath = nextJsBuiltFiles.entrypointPath;
+          nextjsOptimization = true;
+        } else {
+          const rawFiles = await readFiles(args.dir);
+          const filteredSourceFiles = filterDeploymentFiles(rawFiles, {
+            // When uploading source for server-side build, ignore stale local Next.js build output.
+            excludeNextArtifacts: !!args.build
+          });
+          files = filteredSourceFiles.files;
+          ignoredSummary = filteredSourceFiles.ignoredSummary;
+          if (detectNextJsProject(args.dir)) {
+            nextjsOptimization = true;
+          }
+        }
+        const ignoredEntries = Object.entries(ignoredSummary);
+        if (ignoredEntries.length > 0 && !args.json) {
+          console.log("Ignoring files not meant for deployment:");
+          for (const [reason, count] of ignoredEntries) {
+            console.log(`  - ${reason}: ${count}`);
+          }
+        }
+        if (files.length === 0) {
+          throw new Error(
+            `No deployable files found in directory: ${args.dir}. Check your path and ignore rules.`
+          );
+        }
       } else if (args.repo) {
         repo = args.repo;
       }
@@ -1009,19 +1506,53 @@ const deployCommand = {
           }
         }
       }
+      const buildEnvVars = {};
+      if (args.buildEnv) {
+        for (const envVar of args.buildEnv) {
+          const [key, ...valueParts] = envVar.split("=");
+          if (key) {
+            buildEnvVars[key] = valueParts.join("=");
+          }
+        }
+      }
+      let build;
+      if (args.build) {
+        if (args.buildCommand) {
+          build = {
+            command: args.buildCommand,
+            ...args.buildOutDir ? { outDir: args.buildOutDir } : {},
+            ...Object.keys(buildEnvVars).length > 0 ? { envVars: buildEnvVars } : {}
+          };
+        } else {
+          build = true;
+        }
+      }
       console.log("Creating deployment...");
-      const result = await freestyle.serverless.deployments.create({
+      const domains = args.domain?.filter(Boolean);
+      const createDeploymentRequest = {
         ...code ? { code } : {},
+        ...files ? { files } : {},
         ...repo ? { repo } : {},
-        env: Object.keys(env).length > 0 ? env : void 0
-      });
+        ...build ? { build } : {},
+        ...entrypointPath ? { entrypointPath } : {},
+        ...nextjsOptimization ? {
+          experimental: {
+            nextjsOptimization: true
+          }
+        } : {},
+        ...domains && domains.length > 0 ? { domains } : {},
+        envVars: Object.keys(env).length > 0 ? env : void 0
+      };
+      const result = await freestyle.serverless.deployments.create(
+        createDeploymentRequest
+      );
       if (args.json) {
         console.log(JSON.stringify(result, null, 2));
       } else {
         console.log("\n\u2713 Deployment created successfully!");
         console.log(`  Deployment ID: ${result.deploymentId}`);
-        if (result.url) {
-          console.log(`  URL: ${result.url}`);
+        if (result.domains.length > 0) {
+          console.log(`  Domains: ${result.domains.join(", ")}`);
         }
       }
     } catch (error) {
@@ -1708,6 +2239,9 @@ const cronCommand = {
           type: "string",
           description: "Cron expression",
           demandOption: true
+        }).option("name", {
+          type: "string",
+          description: "Optional display name for the cron schedule"
         }).option("timezone", {
           type: "string",
           description: "Timezone (default: UTC)",
@@ -1739,6 +2273,7 @@ const cronCommand = {
           }
           const { job } = await freestyle.cron.schedule({
             deploymentId: args.deploymentId,
+            name: args.name,
             cron: args.cron,
             timezone: args.timezone,
             payload: parsedPayload,
@@ -1750,6 +2285,7 @@ const cronCommand = {
             console.log("\u2713 Cron schedule created");
             console.log(`  Schedule ID: ${job.schedule.id}`);
             console.log(`  Deployment ID: ${job.schedule.deploymentId}`);
+            console.log(`  Name: ${job.schedule.name ?? "-"}`);
             console.log(`  Cron: ${job.schedule.cron}`);
             console.log(`  Timezone: ${job.schedule.timezone}`);
             console.log(`  Active: ${job.schedule.active ? "yes" : "no"}`);
@@ -1795,13 +2331,14 @@ const cronCommand = {
           }
           const rows = jobs.map((job) => [
             job.schedule.id,
+            job.schedule.name ?? "-",
             job.schedule.deploymentId,
             job.schedule.cron,
             job.schedule.timezone,
             job.schedule.active ? "active" : "disabled"
           ]);
           formatTable(
-            ["Schedule ID", "Deployment", "Cron", "Timezone", "Status"],
+            ["Schedule ID", "Name", "Deployment", "Cron", "Timezone", "Status"],
             rows
           );
         } catch (error) {
@@ -2096,6 +2633,287 @@ const whoamiCommand = {
   }
 };
 
+const FILTER_OPTIONS = [
+  "vm",
+  "deployment",
+  "domain",
+  "run",
+  "request",
+  "build"
+];
+function normalizeTimeOption(value) {
+  if (!value) {
+    return void 0;
+  }
+  const match = value.match(/^(\d+)(ms|s|m|h|d)$/);
+  if (!match) {
+    return value;
+  }
+  const amount = Number(match[1]);
+  const unit = match[2];
+  const multiplier = unit === "ms" ? 1 : unit === "s" ? 1e3 : unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5;
+  return new Date(Date.now() - amount * multiplier).toISOString();
+}
+function parseDurationMs(value) {
+  if (!value) {
+    return void 0;
+  }
+  const numericValue = Number(value);
+  if (Number.isFinite(numericValue)) {
+    return numericValue;
+  }
+  const match = value.match(/^(\d+)(ms|s|m|h|d)$/);
+  if (!match) {
+    throw new Error(
+      `Invalid --timeout value '${value}'. Use milliseconds or a duration like 30s, 5m, or 1h.`
+    );
+  }
+  const amount = Number(match[1]);
+  const unit = match[2];
+  const multiplier = unit === "ms" ? 1 : unit === "s" ? 1e3 : unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5;
+  return amount * multiplier;
+}
+function formatDurationMs(ms) {
+  if (ms % 864e5 === 0) {
+    return `${ms / 864e5}d`;
+  }
+  if (ms % 36e5 === 0) {
+    return `${ms / 36e5}h`;
+  }
+  if (ms % 6e4 === 0) {
+    return `${ms / 6e4}m`;
+  }
+  if (ms % 1e3 === 0) {
+    return `${ms / 1e3}s`;
+  }
+  return `${ms}ms`;
+}
+function buildLogsQuery(args) {
+  const query = {
+    pageSize: args.limit,
+    startTime: normalizeTimeOption(args.since),
+    endTime: normalizeTimeOption(args.until),
+    search: args.search,
+    instanceId: args.instance,
+    vmService: args.service,
+    resourceType: args.resourceType
+  };
+  if (args.vm) {
+    query.vmId = args.vm;
+  } else if (args.deployment) {
+    query.deploymentId = args.deployment;
+  } else if (args.domain) {
+    query.domain = args.domain;
+  } else if (args.run) {
+    query.runId = args.run;
+  } else if (args.request) {
+    query.requestId = args.request;
+  } else if (args.build) {
+    query.buildId = args.build;
+  }
+  return query;
+}
+function logEntryKey(entry) {
+  return [
+    entry.timestamp,
+    entry.resourceType ?? "",
+    entry.resourceId ?? "",
+    entry.instanceId ?? "",
+    entry.vmService ?? "",
+    entry.source ?? "",
+    entry.message
+  ].join("	");
+}
+function sortLogsAscending(logs) {
+  return [...logs].sort((left, right) => {
+    const leftTime = Date.parse(left.timestamp);
+    const rightTime = Date.parse(right.timestamp);
+    if (!Number.isNaN(leftTime) && !Number.isNaN(rightTime)) {
+      return leftTime - rightTime;
+    }
+    return left.timestamp.localeCompare(right.timestamp);
+  });
+}
+function formatLogEntry(entry) {
+  const labels = [
+    entry.resourceType && entry.resourceId ? `${entry.resourceType}:${entry.resourceId}` : entry.resourceId,
+    entry.instanceId ? `instance:${entry.instanceId}` : void 0,
+    entry.vmService ? `service:${entry.vmService}` : void 0,
+    entry.buildId ? `build:${entry.buildId}` : void 0,
+    entry.level,
+    entry.source
+  ].filter((value) => Boolean(value));
+  const prefix = labels.length > 0 ? ` [${labels.join(" ")}]` : "";
+  const message = entry.message.replace(/\n$/, "");
+  return `${entry.timestamp}${prefix} ${message}`;
+}
+function printLogEntry(entry, json) {
+  if (json) {
+    console.log(JSON.stringify(entry));
+    return;
+  }
+  console.log(formatLogEntry(entry));
+}
+const logsCommand = {
+  command: "logs",
+  describe: "Read observability logs",
+  builder: (yargs) => {
+    return yargs.option("vm", {
+      type: "string",
+      description: "VM ID to read logs for"
+    }).option("deployment", {
+      type: "string",
+      description: "Deployment ID to read logs for"
+    }).option("domain", {
+      type: "string",
+      description: "Domain to read deployment logs for"
+    }).option("run", {
+      type: "string",
+      description: "Run ID to read logs for"
+    }).option("request", {
+      type: "string",
+      description: "Background request ID to read logs for"
+    }).option("build", {
+      type: "string",
+      description: "Build ID to read logs for"
+    }).option("instance", {
+      type: "string",
+      description: "VM or deployment instance ID filter"
+    }).option("service", {
+      type: "string",
+      description: "VM systemd service name filter"
+    }).option("search", {
+      type: "string",
+      description: "Case-insensitive substring search"
+    }).option("since", {
+      type: "string",
+      description: "Start time as RFC3339 or duration like 5m, 2h, 1d"
+    }).option("until", {
+      type: "string",
+      description: "End time as RFC3339 or duration like 5m, 2h, 1d"
+    }).option("limit", {
+      type: "number",
+      description: "Maximum logs per poll",
+      default: 100
+    }).option("stream", {
+      type: "boolean",
+      description: "Poll for new logs until interrupted",
+      default: false
+    }).option("interval", {
+      type: "number",
+      description: "Polling interval in milliseconds when streaming",
+      default: 2e3
+    }).option("timeout", {
+      type: "string",
+      description: "Stop streaming after this long without new logs, like 30s, 5m, or milliseconds"
+    }).option("json", {
+      type: "boolean",
+      description: "Output JSON",
+      default: false
+    }).option("resource-type", {
+      choices: ["deployment", "run", "vm"],
+      description: "Account-wide resource type filter"
+    }).check((argv) => {
+      const filters = FILTER_OPTIONS.filter((option) => Boolean(argv[option]));
+      if (filters.length > 1) {
+        throw new Error(
+          `Use only one log target filter: ${filters.map((filter) => `--${filter}`).join(", ")}`
+        );
+      }
+      if (argv.service && !argv.vm) {
+        throw new Error("--service can only be used with --vm");
+      }
+      if (argv.until && argv.stream) {
+        throw new Error("--until cannot be used with --stream");
+      }
+      if (argv.timeout && !argv.stream) {
+        throw new Error("--timeout can only be used with --stream");
+      }
+      const timeoutMs = parseDurationMs(
+        typeof argv.timeout === "string" ? argv.timeout : void 0
+      );
+      if (timeoutMs !== void 0 && timeoutMs <= 0) {
+        throw new Error("--timeout must be greater than 0");
+      }
+      if (typeof argv.interval === "number" && argv.interval <= 0) {
+        throw new Error("--interval must be greater than 0");
+      }
+      if (typeof argv.limit === "number" && argv.limit <= 0) {
+        throw new Error("--limit must be greater than 0");
+      }
+      return true;
+    });
+  },
+  handler: async (argv) => {
+    loadEnv();
+    const args = argv;
+    try {
+      const freestyle = await getFreestyleClient();
+      const query = buildLogsQuery(args);
+      if (!args.stream) {
+        const response = await freestyle.observability.getLogs(query);
+        if (args.json) {
+          console.log(JSON.stringify(response, null, 2));
+          return;
+        }
+        for (const entry of sortLogsAscending(response.logs ?? [])) {
+          printLogEntry(entry, false);
+        }
+        return;
+      }
+      const abortController = new AbortController();
+      const timeoutMs = parseDurationMs(args.timeout);
+      const seenLogs = /* @__PURE__ */ new Set();
+      let timeout;
+      let stoppedAfterTimeout = false;
+      const resetTimeout = () => {
+        if (timeoutMs === void 0) {
+          return;
+        }
+        if (timeout) {
+          clearTimeout(timeout);
+        }
+        timeout = setTimeout(() => {
+          stoppedAfterTimeout = true;
+          abortController.abort();
+        }, timeoutMs);
+      };
+      const handleSigint = () => abortController.abort();
+      process.once("SIGINT", handleSigint);
+      if (!args.json) {
+        console.error("Streaming logs. Press Ctrl-C to stop.");
+      }
+      try {
+        resetTimeout();
+        for await (const entry of freestyle.observability.streamLogs({
+          ...query,
+          intervalMs: args.interval,
+          signal: abortController.signal,
+          includeExisting: Boolean(query.startTime)
+        })) {
+          const key = logEntryKey(entry);
+          if (seenLogs.has(key)) {
+            continue;
+          }
+          seenLogs.add(key);
+          printLogEntry(entry, Boolean(args.json));
+          resetTimeout();
+        }
+      } finally {
+        if (timeout) {
+          clearTimeout(timeout);
+        }
+        process.off("SIGINT", handleSigint);
+      }
+      if (stoppedAfterTimeout && !args.json && timeoutMs !== void 0) {
+        console.error(`No logs received for ${formatDurationMs(timeoutMs)}; stopped streaming.`);
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  }
+};
+
 dotenv.config({ quiet: true });
 yargs(hideBin(process.argv)).scriptName("freestyle").usage("$0 <command> [options]").option("team", {
   type: "string",
@@ -2105,4 +2923,4 @@ yargs(hideBin(process.argv)).scriptName("freestyle").usage("$0 <command> [option
   if (argv.team && typeof argv.team === "string") {
     process.env.FREESTYLE_TEAM_ID = argv.team;
   }
-}).command(vmCommand).command(gitCommand).command(domainsCommand).command(cronCommand).command(loginCommand).command(logoutCommand).command(whoamiCommand).command(deployCommand).command(runCommand).demandCommand(1, "You need to specify a command").help().alias("help", "h").version().alias("version", "v").strict().parse();
+}).command(vmCommand).command(gitCommand).command(domainsCommand).command(cronCommand).command(loginCommand).command(logoutCommand).command(whoamiCommand).command(logsCommand).command(deployCommand).command(runCommand).demandCommand(1, "You need to specify a command").help().alias("help", "h").version().alias("version", "v").strict().parse();