freestyle 0.0.3 → 0.1.44

package/cli.mjs

@@ -0,0 +1,1994 @@
+#!/usr/bin/env node
+import * as dotenv from 'dotenv';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { Freestyle, VmSpec } from './index.mjs';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { spawn } from 'child_process';
+
+const DEFAULT_STACK_API_URL = "https://api.stack-auth.com";
+const DEFAULT_STACK_APP_URL = "https://dash.freestyle.sh";
+const DEFAULT_STACK_PROJECT_ID = "0edf478c-f123-46fb-818f-34c0024a9f35";
+const DEFAULT_STACK_PUBLISHABLE_CLIENT_KEY = "pck_h2aft7g9pqjzrkdnzs199h1may5wjtdtdxeex7m2wzp1r";
+const CLI_AUTH_TIMEOUT_MILLIS = 10 * 60 * 1e3;
+const POLL_INTERVAL_MILLIS = 2e3;
+const STACK_REFRESH_TOKEN_ENV_KEY = "FREESTYLE_STACK_REFRESH_TOKEN";
+const STACK_SAVE_TO_DOTENV_ENV_KEY = "FREESTYLE_STACK_SAVE_TO_DOTENV";
+function isTruthy(value) {
+  if (!value) {
+    return false;
+  }
+  const normalized = value.trim().toLowerCase();
+  return normalized === "1" || normalized === "true" || normalized === "yes";
+}
+function loadRefreshTokenFromDotenv() {
+  const refreshToken = process.env[STACK_REFRESH_TOKEN_ENV_KEY];
+  if (!refreshToken || typeof refreshToken !== "string") {
+    return null;
+  }
+  const trimmed = refreshToken.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function shouldSaveToDotenv(options) {
+  if (typeof options?.saveToDotenv === "boolean") {
+    return options.saveToDotenv;
+  }
+  return isTruthy(process.env[STACK_SAVE_TO_DOTENV_ENV_KEY]);
+}
+function persistRefreshTokenToDotenv(refreshToken, options) {
+  if (!shouldSaveToDotenv(options)) {
+    return;
+  }
+  const envPath = path.join(process.cwd(), ".env");
+  const line = `${STACK_REFRESH_TOKEN_ENV_KEY}=${refreshToken}`;
+  let existing = "";
+  if (fs.existsSync(envPath)) {
+    existing = fs.readFileSync(envPath, "utf-8");
+  }
+  const pattern = new RegExp(`^${STACK_REFRESH_TOKEN_ENV_KEY}=.*$`, "m");
+  let next;
+  if (pattern.test(existing)) {
+    next = existing.replace(pattern, line);
+  } else if (existing.length === 0) {
+    next = `${line}
+`;
+  } else if (existing.endsWith("\n")) {
+    next = `${existing}${line}
+`;
+  } else {
+    next = `${existing}
+${line}
+`;
+  }
+  fs.writeFileSync(envPath, next, { encoding: "utf-8" });
+}
+function removeRefreshTokenFromDotenv() {
+  const envPath = path.join(process.cwd(), ".env");
+  if (!fs.existsSync(envPath)) {
+    return false;
+  }
+  const existing = fs.readFileSync(envPath, "utf-8");
+  const lines = existing.split(/\r?\n/);
+  const nextLines = lines.filter(
+    (line) => !line.startsWith(`${STACK_REFRESH_TOKEN_ENV_KEY}=`)
+  );
+  if (nextLines.length === lines.length) {
+    return false;
+  }
+  const next = nextLines.filter((line) => line.length > 0).join("\n");
+  fs.writeFileSync(envPath, next.length > 0 ? `${next}
+` : "", {
+    encoding: "utf-8"
+  });
+  return true;
+}
+function walkUpDirectories(startDir) {
+  const result = [];
+  let current = path.resolve(startDir);
+  while (true) {
+    result.push(current);
+    const parent = path.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return result;
+}
+function readEnvFileValue(filePath, key) {
+  if (!fs.existsSync(filePath)) {
+    return void 0;
+  }
+  const content = fs.readFileSync(filePath, "utf-8");
+  const pattern = new RegExp(`^${key}=(.*)$`, "m");
+  const match = content.match(pattern);
+  if (!match?.[1]) {
+    return void 0;
+  }
+  return match[1].trim().replace(/^['\"]|['\"]$/g, "");
+}
+function readYamlEnvValue(filePath, envName) {
+  if (!fs.existsSync(filePath)) {
+    return void 0;
+  }
+  const content = fs.readFileSync(filePath, "utf-8");
+  const escapedEnv = envName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(
+    `-\\s+name:\\s+${escapedEnv}\\s*[\\r\\n]+\\s*value:\\s*([^\\r\\n#]+)`,
+    "m"
+  );
+  const match = content.match(pattern);
+  if (!match?.[1]) {
+    return void 0;
+  }
+  return match[1].trim().replace(/^['\"]|['\"]$/g, "");
+}
+function discoverStackConfigFromWorkspace() {
+  const discovered = {};
+  const roots = walkUpDirectories(process.cwd());
+  for (const root of roots) {
+    if (!discovered.projectId || !discovered.publishableClientKey) {
+      const dashboardEnv = path.join(root, "freestyle-dashboard", ".env.local");
+      discovered.projectId ||= readEnvFileValue(
+        dashboardEnv,
+        "VITE_STACK_PROJECT_ID"
+      );
+      discovered.publishableClientKey ||= readEnvFileValue(
+        dashboardEnv,
+        "VITE_STACK_PUBLISHABLE_CLIENT_KEY"
+      );
+    }
+    if (!discovered.projectId || !discovered.publishableClientKey) {
+      const adminEnv = path.join(root, "freestyle-sandbox-admin", ".env.local");
+      discovered.projectId ||= readEnvFileValue(
+        adminEnv,
+        "NEXT_PUBLIC_STACK_PROJECT_ID"
+      );
+      discovered.publishableClientKey ||= readEnvFileValue(
+        adminEnv,
+        "NEXT_PUBLIC_STACK_PUBLISHABLE_CLIENT_KEY"
+      );
+    }
+    if (!discovered.projectId || !discovered.publishableClientKey) {
+      const dashK8s = path.join(root, "k8s", "freestyle-dash.yml");
+      discovered.projectId ||= readYamlEnvValue(
+        dashK8s,
+        "VITE_STACK_PROJECT_ID"
+      );
+      discovered.publishableClientKey ||= readYamlEnvValue(
+        dashK8s,
+        "VITE_STACK_PUBLISHABLE_CLIENT_KEY"
+      );
+    }
+    if (discovered.projectId && discovered.publishableClientKey) {
+      break;
+    }
+  }
+  return discovered;
+}
+function resolveAuthFilePath() {
+  return process.env.FREESTYLE_STACK_AUTH_FILE ?? path.join(os.homedir(), ".freestyle", "stack-auth.json");
+}
+function resolveStackConfig() {
+  const discovered = discoverStackConfigFromWorkspace();
+  const projectId = process.env.FREESTYLE_STACK_PROJECT_ID ?? process.env.NEXT_PUBLIC_STACK_PROJECT_ID ?? process.env.VITE_STACK_PROJECT_ID ?? discovered.projectId ?? DEFAULT_STACK_PROJECT_ID;
+  const publishableClientKey = process.env.FREESTYLE_STACK_PUBLISHABLE_CLIENT_KEY ?? process.env.NEXT_PUBLIC_STACK_PUBLISHABLE_CLIENT_KEY ?? process.env.VITE_STACK_PUBLISHABLE_CLIENT_KEY ?? discovered.publishableClientKey ?? DEFAULT_STACK_PUBLISHABLE_CLIENT_KEY;
+  if (!projectId || !publishableClientKey) {
+    return null;
+  }
+  const stackApiUrl = (process.env.FREESTYLE_STACK_API_URL ?? DEFAULT_STACK_API_URL).replace(/\/+$/, "");
+  const appUrl = (process.env.FREESTYLE_STACK_APP_URL ?? process.env.FREESTYLE_DASHBOARD_URL ?? DEFAULT_STACK_APP_URL).replace(/\/+$/, "");
+  const authFilePath = process.env.FREESTYLE_STACK_AUTH_FILE ?? resolveAuthFilePath();
+  return {
+    stackApiUrl,
+    appUrl,
+    projectId,
+    publishableClientKey,
+    authFilePath
+  };
+}
+function clientHeaders(config) {
+  return {
+    "Content-Type": "application/json",
+    "x-stack-project-id": config.projectId,
+    "x-stack-access-type": "client",
+    "x-stack-publishable-client-key": config.publishableClientKey
+  };
+}
+function loadStoredAuth(config) {
+  try {
+    if (!fs.existsSync(config.authFilePath)) {
+      return null;
+    }
+    const auth = JSON.parse(fs.readFileSync(config.authFilePath, "utf-8"));
+    if (!auth.refreshToken || typeof auth.refreshToken !== "string") {
+      return null;
+    }
+    return {
+      refreshToken: auth.refreshToken,
+      updatedAt: typeof auth.updatedAt === "number" ? auth.updatedAt : Date.now(),
+      defaultTeamId: typeof auth.defaultTeamId === "string" ? auth.defaultTeamId : void 0
+    };
+  } catch {
+    return null;
+  }
+}
+function persistAuth(config, auth) {
+  const dirPath = path.dirname(config.authFilePath);
+  fs.mkdirSync(dirPath, { recursive: true });
+  fs.writeFileSync(
+    config.authFilePath,
+    JSON.stringify(
+      {
+        refreshToken: auth.refreshToken,
+        updatedAt: auth.updatedAt,
+        defaultTeamId: auth.defaultTeamId
+      },
+      null,
+      2
+    ),
+    { encoding: "utf-8", mode: 384 }
+  );
+}
+function clearStoredAuth(config) {
+  try {
+    if (fs.existsSync(config.authFilePath)) {
+      fs.unlinkSync(config.authFilePath);
+    }
+  } catch {
+  }
+}
+function logoutCliAuth(options) {
+  const authFilePath = resolveAuthFilePath();
+  let clearedStored = false;
+  try {
+    if (fs.existsSync(authFilePath)) {
+      fs.unlinkSync(authFilePath);
+      clearedStored = true;
+    }
+  } catch {
+  }
+  let clearedDotenv = false;
+  if (options?.removeFromDotenv) {
+    clearedDotenv = removeRefreshTokenFromDotenv();
+  }
+  delete process.env[STACK_REFRESH_TOKEN_ENV_KEY];
+  return { clearedStored, clearedDotenv };
+}
+function tryOpenBrowser(url) {
+  try {
+    if (process.platform === "darwin") {
+      const child2 = spawn("open", [url], {
+        stdio: "ignore",
+        detached: true
+      });
+      child2.unref();
+      return true;
+    }
+    if (process.platform === "win32") {
+      const child2 = spawn("cmd", ["/c", "start", "", url], {
+        stdio: "ignore",
+        detached: true
+      });
+      child2.unref();
+      return true;
+    }
+    const child = spawn("xdg-open", [url], {
+      stdio: "ignore",
+      detached: true
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function startCliLogin(config) {
+  const initResponse = await fetch(`${config.stackApiUrl}/api/v1/auth/cli`, {
+    method: "POST",
+    headers: clientHeaders(config),
+    body: JSON.stringify({
+      expires_in_millis: CLI_AUTH_TIMEOUT_MILLIS
+    })
+  });
+  if (!initResponse.ok) {
+    const errorText = await initResponse.text();
+    throw new Error(
+      `Failed to start authentication login (${initResponse.status}). ${errorText || "Check project ID and client key configuration."}`
+    );
+  }
+  const initData = await initResponse.json();
+  if (!initData.polling_code || !initData.login_code) {
+    throw new Error("Authentication login did not return polling/login codes.");
+  }
+  const loginUrl = `${config.appUrl}/handler/cli-auth-confirm?login_code=${encodeURIComponent(initData.login_code)}`;
+  console.log("\nAuthentication is required.");
+  console.log(`Open this URL to continue:
+${loginUrl}
+`);
+  const opened = tryOpenBrowser(loginUrl);
+  if (opened) {
+    console.log("Opened your browser for authentication...");
+  } else {
+    console.log("Could not open browser automatically. Open the URL manually.");
+  }
+  const deadline = Date.now() + CLI_AUTH_TIMEOUT_MILLIS;
+  while (Date.now() < deadline) {
+    const pollResponse = await fetch(
+      `${config.stackApiUrl}/api/v1/auth/cli/poll`,
+      {
+        method: "POST",
+        headers: clientHeaders(config),
+        body: JSON.stringify({
+          polling_code: initData.polling_code
+        })
+      }
+    );
+    if (![200, 201].includes(pollResponse.status)) {
+      throw new Error(
+        `Failed while polling authentication login (${pollResponse.status}).`
+      );
+    }
+    const pollData = await pollResponse.json();
+    if (pollData.status && pollData.status !== "pending") {
+      console.log("Auth poll status:", pollData.status);
+    }
+    if (pollData.status === "completed" || pollData.status === "success") {
+      if (!pollData.refresh_token) {
+        throw new Error("Login completed without a refresh token response.");
+      }
+      return pollData.refresh_token;
+    }
+    if (pollData.status && pollData.status !== "pending" && pollData.status !== "waiting") {
+      throw new Error(
+        pollData.error || `Authentication ${pollData.status}. Please retry.`
+      );
+    }
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MILLIS));
+  }
+  throw new Error("Timed out waiting for authentication.");
+}
+async function refreshStackAccessToken(config, refreshToken) {
+  const response = await fetch(
+    `${config.stackApiUrl}/api/v1/auth/sessions/current/refresh`,
+    {
+      method: "POST",
+      headers: {
+        ...clientHeaders(config),
+        "x-stack-refresh-token": refreshToken
+      },
+      body: "{}"
+    }
+  );
+  if (!response.ok) {
+    return null;
+  }
+  const data = await response.json();
+  if (!data.access_token) {
+    return null;
+  }
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token
+  };
+}
+async function getStackAccessTokenForCli(options) {
+  const config = resolveStackConfig();
+  if (!config) {
+    return null;
+  }
+  let refreshTokenFromEnv = loadRefreshTokenFromDotenv();
+  const stored = loadStoredAuth(config);
+  if (options?.forceRelogin) {
+    refreshTokenFromEnv = null;
+    clearStoredAuth(config);
+  }
+  let refreshToken = refreshTokenFromEnv ?? stored?.refreshToken;
+  if (!refreshToken) {
+    refreshToken = await startCliLogin(config);
+    const auth = {
+      refreshToken,
+      updatedAt: Date.now()
+    };
+    persistAuth(config, auth);
+    persistRefreshTokenToDotenv(refreshToken, options);
+  }
+  let refreshed = await refreshStackAccessToken(config, refreshToken);
+  if (!refreshed) {
+    if (!refreshTokenFromEnv) {
+      clearStoredAuth(config);
+    }
+    refreshToken = await startCliLogin(config);
+    const auth = {
+      refreshToken,
+      updatedAt: Date.now(),
+      defaultTeamId: stored?.defaultTeamId
+    };
+    persistAuth(config, auth);
+    persistRefreshTokenToDotenv(refreshToken, options);
+    refreshed = await refreshStackAccessToken(config, refreshToken);
+  }
+  if (!refreshed) {
+    throw new Error("Failed to authenticate.");
+  }
+  if (refreshed.refreshToken && refreshed.refreshToken !== refreshToken) {
+    const auth = {
+      refreshToken: refreshed.refreshToken,
+      updatedAt: Date.now(),
+      defaultTeamId: stored?.defaultTeamId
+    };
+    persistAuth(config, auth);
+    persistRefreshTokenToDotenv(refreshed.refreshToken, options);
+  }
+  return refreshed.accessToken;
+}
+function getDashboardApiUrl() {
+  return process.env.FREESTYLE_DASHBOARD_URL || "https://dash.freestyle.sh";
+}
+async function callDashboardApi(endpoint, accessToken, body) {
+  const response = await fetch(`${getDashboardApiUrl()}${endpoint}`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      data: {
+        accessToken,
+        ...body
+      }
+    })
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Dashboard API call failed: ${response.status} ${response.statusText}`
+    );
+  }
+  return response.json();
+}
+async function getTeamsForCli() {
+  const config = resolveStackConfig();
+  if (!config) {
+    throw new Error(
+      "Stack Auth is not configured. Please check your environment variables."
+    );
+  }
+  const stored = loadStoredAuth(config);
+  if (!stored?.refreshToken) {
+    throw new Error(
+      "No authentication found. Please run 'npx freestyle-sandboxes@latest login' first."
+    );
+  }
+  const tokenResponse = await refreshStackAccessToken(
+    config,
+    stored.refreshToken
+  );
+  if (!tokenResponse) {
+    throw new Error("Failed to refresh access token.");
+  }
+  const teams = await callDashboardApi("/api/cli/teams", tokenResponse.accessToken);
+  return teams;
+}
+async function setDefaultTeam(teamId) {
+  const config = resolveStackConfig();
+  if (!config) {
+    throw new Error(
+      "Stack Auth is not configured. Please check your environment variables."
+    );
+  }
+  const stored = loadStoredAuth(config);
+  if (!stored?.refreshToken) {
+    throw new Error(
+      "No authentication found. Please run 'npx freestyle-sandboxes@latest login' first."
+    );
+  }
+  const auth = {
+    refreshToken: stored.refreshToken,
+    updatedAt: Date.now(),
+    defaultTeamId: teamId
+  };
+  persistAuth(config, auth);
+}
+function getDefaultTeamId() {
+  const config = resolveStackConfig();
+  if (!config) {
+    return void 0;
+  }
+  const stored = loadStoredAuth(config);
+  return stored?.defaultTeamId;
+}
+
+function normalizeCliProxyErrorWithStatus(errorText, status) {
+  const fallbackCode = status === 400 ? "BAD_REQUEST" : status === 401 ? "UNAUTHORIZED_ERROR" : status === 403 ? "FORBIDDEN" : "INTERNAL_ERROR";
+  try {
+    const parsed = JSON.parse(errorText);
+    if (typeof parsed.code === "string" && typeof parsed.message === "string") {
+      return {
+        body: JSON.stringify(parsed),
+        contentType: "application/json"
+      };
+    }
+    const message2 = [parsed.error, parsed.message, parsed.reason].find(
+      (value) => typeof value === "string" && value.length > 0
+    );
+    if (message2) {
+      const normalized2 = fallbackCode === "UNAUTHORIZED_ERROR" ? {
+        code: fallbackCode,
+        message: message2,
+        route: "/api/proxy/request",
+        reason: message2
+      } : {
+        code: fallbackCode,
+        message: message2
+      };
+      return {
+        body: JSON.stringify(normalized2),
+        contentType: "application/json"
+      };
+    }
+  } catch {
+  }
+  const message = errorText || "Request failed";
+  const normalized = fallbackCode === "UNAUTHORIZED_ERROR" ? {
+    code: fallbackCode,
+    message,
+    route: "/api/proxy/request",
+    reason: message
+  } : {
+    code: fallbackCode,
+    message
+  };
+  return {
+    body: JSON.stringify(normalized),
+    contentType: "application/json"
+  };
+}
+function createProxyFetch(accessToken, teamId) {
+  const dashboardApiUrl = process.env.FREESTYLE_DASHBOARD_URL || "https://dash.freestyle.sh";
+  return async (url, init) => {
+    const urlObj = typeof url === "string" ? new URL(url) : url instanceof URL ? url : new URL(url.url);
+    const path2 = urlObj.pathname + urlObj.search;
+    const proxyResponse = await fetch(`${dashboardApiUrl}/api/proxy/request`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        data: {
+          accessToken,
+          teamId,
+          path: path2.startsWith("/") ? path2.substring(1) : path2,
+          method: init?.method || "GET",
+          headers: init?.headers ? Object.fromEntries(new Headers(init.headers).entries()) : {},
+          body: init?.body ? init.body.toString() : void 0
+        }
+      })
+    });
+    if (!proxyResponse.ok) {
+      const errorText = await proxyResponse.text();
+      const normalizedError = normalizeCliProxyErrorWithStatus(
+        errorText,
+        proxyResponse.status
+      );
+      return new Response(normalizedError.body, {
+        status: proxyResponse.status,
+        statusText: proxyResponse.statusText,
+        headers: {
+          "Content-Type": normalizedError.contentType
+        }
+      });
+    }
+    const data = await proxyResponse.json();
+    return new Response(JSON.stringify(data), {
+      status: 200,
+      headers: { "Content-Type": "application/json" }
+    });
+  };
+}
+async function getFreestyleClient(teamId) {
+  const directApiKey = process.env.FREESTYLE_API_KEY;
+  if (directApiKey) {
+    const baseUrl2 = process.env.FREESTYLE_API_URL;
+    return new Freestyle({ apiKey: directApiKey, baseUrl: baseUrl2 });
+  }
+  const accessToken = await getStackAccessTokenForCli();
+  if (!accessToken) {
+    console.error(
+      "Error: No API key found. Please run 'npx freestyle-sandboxes@latest login' or set FREESTYLE_API_KEY in your .env file."
+    );
+    process.exit(1);
+  }
+  const resolvedTeamId = process.env.FREESTYLE_TEAM_ID ?? getDefaultTeamId();
+  if (!resolvedTeamId) {
+    console.error(
+      "Error: No team selected. Please run 'npx freestyle-sandboxes@latest login' to set a default team."
+    );
+    process.exit(1);
+  }
+  const baseUrl = process.env.FREESTYLE_API_URL || "https://api.freestyle.sh";
+  return new Freestyle({
+    apiKey: "placeholder",
+    // Need something to pass validation
+    baseUrl,
+    fetch: createProxyFetch(accessToken, resolvedTeamId)
+  });
+}
+function handleError(error) {
+  if (error.response) {
+    console.error("API Error:", error.response.data);
+  } else if (error.message) {
+    console.error("Error:", error.message);
+  } else {
+    console.error("Error:", error);
+  }
+  process.exit(1);
+}
+function loadEnv() {
+  const envPath = path.join(process.cwd(), ".env");
+  if (fs.existsSync(envPath)) {
+    dotenv.config({ path: envPath, quiet: true });
+  }
+}
+function formatTable(headers, rows) {
+  const colWidths = headers.map((h, i) => {
+    const maxRowWidth = Math.max(...rows.map((r) => (r[i] || "").length));
+    return Math.max(h.length, maxRowWidth);
+  });
+  const headerRow = headers.map((h, i) => h.padEnd(colWidths[i] || 0)).join("  ");
+  const separator = colWidths.map((w) => "-".repeat(w)).join("  ");
+  console.log(headerRow);
+  console.log(separator);
+  rows.forEach((row) => {
+    console.log(
+      row.map((cell, i) => (cell || "").padEnd(colWidths[i] || 0)).join("  ")
+    );
+  });
+}
+
+async function sshIntoVm(vmId, options = {}) {
+  const freestyle = await getFreestyleClient();
+  console.log("Setting up SSH connection...");
+  const { identity, identityId } = await freestyle.identities.create();
+  console.log(`Created identity: ${identityId}`);
+  await identity.permissions.vms.grant({ vmId });
+  const { token, tokenId } = await identity.tokens.create();
+  const sshCommand = `ssh ${vmId}:${token}@vm-ssh.freestyle.sh -p 22`;
+  console.log(`Connecting to VM ${vmId}...`);
+  console.log(`Command: ${sshCommand}
+`);
+  return new Promise((resolve, reject) => {
+    const sshProcess = spawn(sshCommand, {
+      shell: true,
+      stdio: "inherit"
+    });
+    sshProcess.on("close", async (code) => {
+      console.log("\nSSH session ended.");
+      try {
+        console.log("Cleaning up identity and token...");
+        await identity.tokens.revoke({ tokenId });
+        await freestyle.identities.delete({ identityId });
+        console.log("\u2713 Cleanup complete");
+        if (options.deleteOnExit) {
+          console.log(`Deleting VM ${vmId}...`);
+          await freestyle.vms.delete({ vmId });
+          console.log("\u2713 VM deleted");
+        }
+        resolve();
+      } catch (error) {
+        console.error("Error during cleanup:", error);
+        reject(error);
+      }
+    });
+    sshProcess.on("error", (error) => {
+      console.error("Error starting SSH:", error);
+      reject(error);
+    });
+  });
+}
+const vmCommand = {
+  command: "vm <action>",
+  describe: "Manage Virtual Machines",
+  builder: (yargs) => {
+    return yargs.command(
+      "create",
+      "Create a new VM",
+      (yargs2) => {
+        return yargs2.option("name", {
+          alias: "n",
+          type: "string",
+          description: "VM name/discriminator"
+        }).option("domain", {
+          alias: "d",
+          type: "string",
+          description: "Custom domain to attach"
+        }).option("port", {
+          alias: "p",
+          type: "number",
+          description: "VM port to expose (default: 3000)",
+          default: 3e3
+        }).option("apt", {
+          type: "array",
+          description: "APT packages to install",
+          default: []
+        }).option("snapshot", {
+          alias: "s",
+          type: "string",
+          description: "Snapshot ID to create VM from"
+        }).option("exec", {
+          alias: "e",
+          type: "string",
+          description: "Execute a command on the VM after creation"
+        }).option("ssh", {
+          type: "boolean",
+          description: "SSH into VM after creation and delete VM on exit (for debugging)",
+          default: false
+        }).option("delete", {
+          type: "boolean",
+          description: "Delete VM after exec completes or when SSH session ends",
+          default: false
+        }).option("json", {
+          type: "boolean",
+          description: "Output as JSON",
+          default: false
+        });
+      },
+      async (argv) => {
+        loadEnv();
+        const args = argv;
+        try {
+          const freestyle = await getFreestyleClient();
+          let createOptions = {};
+          if (args.snapshot) {
+            createOptions.snapshotId = args.snapshot;
+          } else {
+            const spec = new VmSpec({
+              discriminator: args.name,
+              aptDeps: args.apt
+            });
+            createOptions.snapshot = spec;
+          }
+          if (args.domain) {
+            createOptions.domains = [
+              {
+                domain: args.domain,
+                vmPort: args.port
+              }
+            ];
+          }
+          console.log("Creating VM...");
+          const result = await freestyle.vms.create(createOptions);
+          let execResult;
+          if (args.exec) {
+            const vm = freestyle.vms.ref({ vmId: result.vmId });
+            console.log(`Executing command on VM ${result.vmId}...`);
+            execResult = await vm.exec({
+              command: args.exec
+            });
+          }
+          if (args.json && !args.ssh) {
+            if (execResult) {
+              console.log(
+                JSON.stringify(
+                  {
+                    vm: result,
+                    exec: execResult
+                  },
+                  null,
+                  2
+                )
+              );
+            } else {
+              console.log(JSON.stringify(result, null, 2));
+            }
+          } else {
+            console.log("\n\u2713 VM created successfully!");
+            console.log(`  VM ID: ${result.vmId}`);
+            const domainStr = result.domains?.[0];
+            if (domainStr) {
+              console.log(`  Domain: https://${domainStr}`);
+            }
+            if (execResult) {
+              if (execResult.stdout) {
+                console.log("\nExec output:");
+                console.log(execResult.stdout);
+              }
+              if (execResult.stderr) {
+                console.error("\nExec errors:");
+                console.error(execResult.stderr);
+              }
+              console.log(`
+Exec exit code: ${execResult.statusCode || 0}`);
+            }
+          }
+          if (args.ssh) {
+            console.log("");
+            await sshIntoVm(result.vmId, { deleteOnExit: args.delete });
+          } else if (args.delete) {
+            console.log(`Deleting VM ${result.vmId}...`);
+            await freestyle.vms.delete({ vmId: result.vmId });
+            console.log("\u2713 VM deleted");
+          }
+        } catch (error) {
+          handleError(error);
+        }
+      }
+    ).command(
+      "list",
+      "List all VMs",
+      (yargs2) => {
+        return yargs2.option("json", {
+          type: "boolean",
+          description: "Output as JSON",
+          default: false
+        });
+      },
+      async (argv) => {
+        loadEnv();
+        const args = argv;
+        try {
+          const freestyle = await getFreestyleClient();
+          const vms = await freestyle.vms.list();
+          if (args.json) {
+            console.log(JSON.stringify(vms, null, 2));
+          } else {
+            if (vms.vms.length === 0) {
+              console.log("No VMs found.");
+              return;
+            }
+            const rows = vms.vms.map((vm) => [
+              vm.id,
+              vm.state || "unknown",
+              vm.createdAt ? new Date(vm.createdAt).toLocaleString() : "N/A"
+            ]);
+            formatTable(["VM ID", "Status", "Created"], rows);
+          }
+        } catch (error) {
+          handleError(error);
+        }
+      }
+    ).command(
+      "ssh <vmId>",
+      "SSH into a VM",
+      (yargs2) => {
+        return yargs2.positional("vmId", {
+          type: "string",
+          description: "VM ID to SSH into",
+          demandOption: true
+        }).option("delete", {
+          type: "boolean",
+          description: "Delete VM when SSH session ends",
+          default: false
+        });
+      },
+      async (argv) => {
+        loadEnv();
+        const args = argv;
+        try {
+          await sshIntoVm(args.vmId, {
+            deleteOnExit: args.delete
+          });
+        } catch (error) {
+          handleError(error);
+        }
+      }
+    ).command(
+      "exec <vmId> <command>",
+      "Execute a command on a VM",
+      (yargs2) => {
+        return yargs2.positional("vmId", {
+          type: "string",
+          description: "VM ID",
+          demandOption: true
+        }).positional("command", {
+          type: "string",
+          description: "Command to execute",
+          demandOption: true
+        }).option("json", {
+          type: "boolean",
+          description: "Output as JSON",
+          default: false
+        });
+      },
+      async (argv) => {
+        loadEnv();
+        const args = argv;
+        try {
+          const freestyle = await getFreestyleClient();
+          const vm = freestyle.vms.ref({ vmId: args.vmId });
+          console.log(`Executing command on VM ${args.vmId}...`);
+          const result = await vm.exec({
+            command: args.command
+          });
+          if (args.json) {
+            console.log(JSON.stringify(result, null, 2));
+          } else {
+            if (result.stdout) {
+              console.log("\nOutput:");
+              console.log(result.stdout);
+            }
+            if (result.stderr) {
+              console.error("\nErrors:");
+              console.error(result.stderr);
+            }
+            console.log(`
+Exit code: ${result.statusCode || 0}`);
+          }
+        } catch (error) {
+          handleError(error);
+        }
+      }
+    ).command(
+      "delete <vmId>",
+      "Delete a VM",
+      (yargs2) => {
+        return yargs2.positional("vmId", {
+          type: "string",
+          description: "VM ID to delete",
+          demandOption: true
+        });
+      },
+      async (argv) => {
+        loadEnv();
+        const args = argv;
+        try {
+          const freestyle = await getFreestyleClient();
+          console.log(`Deleting VM ${args.vmId}...`);
+          await freestyle.vms.delete({ vmId: args.vmId });
+          console.log("\u2713 VM deleted successfully!");
+        } catch (error) {
+          handleError(error);
+        }
+      }
+    ).demandCommand(1, "You need to specify a vm action");
+  },
+  handler: () => {
+  }
+};
+
+const deployCommand = {
+  command: "deploy",
+  describe: "Deploy a serverless function",
+  builder: (yargs) => {
+    return yargs.option("code", {
+      alias: "c",
+      type: "string",
+      description: "Inline code to deploy"
+    }).option("file", {
+      alias: "f",
+      type: "string",
+      description: "File path containing code to deploy"
+    }).option("repo", {
+      alias: "r",
+      type: "string",
+      description: "Git repository ID to deploy"
+    }).option("env", {
+      alias: "e",
+      type: "array",
+      description: "Environment variables (KEY=VALUE)",
+      default: []
+    }).option("json", {
+      type: "boolean",
+      description: "Output as JSON",
+      default: false
+    }).check((argv) => {
+      const hasCode = !!argv.code;
+      const hasFile = !!argv.file;
+      const hasRepo = !!argv.repo;
+      if (!hasCode && !hasFile && !hasRepo) {
+        throw new Error("You must specify one of --code, --file, or --repo");
+      }
+      if ([hasCode, hasFile, hasRepo].filter(Boolean).length > 1) {
+        throw new Error(
+          "You can only specify one of --code, --file, or --repo"
+        );
+      }
+      return true;
+    });
+  },
+  handler: async (argv) => {
+    loadEnv();
+    const args = argv;
+    try {
+      const freestyle = await getFreestyleClient();
+      let code;
+      let repo;
+      if (args.code) {
+        code = args.code;
+      } else if (args.file) {
+        code = fs.readFileSync(args.file, "utf-8");
+      } else if (args.repo) {
+        repo = args.repo;
+      }
+      const env = {};
+      if (args.env) {
+        for (const envVar of args.env) {
+          const [key, ...valueParts] = envVar.split("=");
+          if (key) {
+            env[key] = valueParts.join("=");
+          }
+        }
+      }
+      console.log("Creating deployment...");
+      const result = await freestyle.serverless.deployments.create({
+        ...code ? { code } : {},
+        ...repo ? { repo } : {},
+        env: Object.keys(env).length > 0 ? env : void 0
+      });
+      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}`);
+        }
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  }
+};
+
+const runCommand = {
+  command: "run",
+  describe: "Execute a one-off serverless function",
+  builder: (yargs) => {
+    return yargs.option("code", {
+      alias: "c",
+      type: "string",
+      description: "Inline code to execute"
+    }).option("file", {
+      alias: "f",
+      type: "string",
+      description: "File path containing code to execute"
+    }).option("env", {
+      alias: "e",
+      type: "array",
+      description: "Environment variables (KEY=VALUE)",
+      default: []
+    }).option("json", {
+      type: "boolean",
+      description: "Output as JSON",
+      default: false
+    }).check((argv) => {
+      const hasCode = !!argv.code;
+      const hasFile = !!argv.file;
+      if (!hasCode && !hasFile) {
+        throw new Error("You must specify either --code or --file");
+      }
+      if (hasCode && hasFile) {
+        throw new Error("You can only specify one of --code or --file");
+      }
+      return true;
+    });
+  },
+  handler: async (argv) => {
+    loadEnv();
+    const args = argv;
+    try {
+      const freestyle = await getFreestyleClient();
+      let code;
+      if (args.code) {
+        code = args.code;
+      } else if (args.file) {
+        code = fs.readFileSync(args.file, "utf-8");
+      } else {
+        throw new Error("Code is required");
+      }
+      const env = {};
+      if (args.env) {
+        for (const envVar of args.env) {
+          const [key, ...valueParts] = envVar.split("=");
+          if (key) {
+            env[key] = valueParts.join("=");
+          }
+        }
+      }
+      console.log("Executing serverless function...");
+      const result = await freestyle.serverless.runs.create({
+        code,
+        env: Object.keys(env).length > 0 ? env : void 0
+      });
+      if (args.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.log("\n\u2713 Function executed successfully!");
+        console.log(`  Run ID: ${result.runId}`);
+        if (result.output) {
+          console.log(`  Output: ${result.output}`);
+        }
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  }
+};
+
+const gitCommand = {
+  command: "git <action>",
+  describe: "Manage Git repositories",
+  builder: (yargs) => {
+    return yargs.command(
+      "create",
+      "Create a git repository",
+      (yargs2) => {
+        return yargs2.option("name", {
+          alias: "n",
+          type: "string",
+          description: "Internal repository name"
+        }).option("public", {
+          type: "boolean",
+          description: "Create as public repository",
+          default: false
+        }).option("default-branch", {
+          type: "string",
+          description: "Default branch name"
+        }).option("source-url", {
+          type: "string",
+          description: "Fork/import from existing git URL"
+        }).option("source-rev", {
+          type: "string",
+          description: "Revision (branch/tag/sha) for source URL"
+        }).option("json", {
+          type: "boolean",
+          description: "Output as JSON",
+          default: false
+        });
+      },
+      async (argv) => {
+        loadEnv();
+        const args = argv;
+        try {
+          const freestyle = await getFreestyleClient();
+          const body = {
+            public: args.public
+          };
+          if (args.name) body.name = args.name;
+          if (args.defaultBranch) body.defaultBranch = args.defaultBranch;
+          if (args.sourceUrl) {
+            body.source = {
+              url: args.sourceUrl,
+              ...args.sourceRev ? { rev: args.sourceRev } : {}
+            };
+          }
+          console.log("Creating git repository...");
+          const result = await freestyle.git.repos.create(body);
+          if (args.json) {
+            console.log(JSON.stringify(result, null, 2));
+          } else {
+            console.log("\n\u2713 Repository created successfully!");
+            console.log(`  Repo ID: ${result.repoId}`);
+            console.log(
+              `  Clone URL: https://git.freestyle.sh/${result.repoId}`
+            );
+          }
+        } catch (error) {
+          handleError(error);
+        }
+      }
+    ).command(
+      "list",
+      "List git repositories",
+      (yargs2) => {
+        return yargs2.option("limit", {
+          type: "number",
+          description: "Maximum repositories to return",
+          default: 20
+        }).option("cursor", {
+          type: "string",
+          description: "Offset cursor"
+        }).option("json", {
+          type: "boolean",
+          description: "Output as JSON",
+          default: false
+        });
+      },
+      async (argv) => {
+        loadEnv();
+        const args = argv;
+        try {
+          const freestyle = await getFreestyleClient();
+          const repos = await freestyle.git.repos.list({
+            limit: args.limit,
+            cursor: args.cursor
+          });
+          if (args.json) {
+            console.log(JSON.stringify(repos, null, 2));
+            return;
+          }
+          if (!repos.repositories || repos.repositories.length === 0) {
+            console.log("No repositories found.");
+            return;
+          }
+          const rows = repos.repositories.map((repo, idx) => {
+            const repoId = repo.repoId || repo.id || "N/A";
+            const branchCount = Object.keys(repo.branches || {}).length;
+            const tagCount = Object.keys(repo.tags || {}).length;
+            return [
+              String(idx + 1),
+              repoId,
+              repo.defaultBranch || "main",
+              String(branchCount),
+              String(tagCount)
+            ];
+          });
+          formatTable(
+            ["#", "Repo ID", "Default Branch", "Branches", "Tags"],
+            rows
+          );
+          console.log(`
+Total: ${repos.total}`);
+          console.log(`Offset: ${repos.offset}`);
+        } catch (error) {
+          handleError(error);
+        }
+      }
+    ).command(
+      "delete <repoId>",
+      "Delete a git repository",
+      (yargs2) => {
+        return yargs2.positional("repoId", {
+          type: "string",
+          description: "Repository ID",
+          demandOption: true
+        });
+      },
+      async (argv) => {
+        loadEnv();
+        const args = argv;
+        try {
+          const freestyle = await getFreestyleClient();
+          console.log(`Deleting repository ${args.repoId}...`);
+          await freestyle.git.repos.delete({ repoId: args.repoId });
+          console.log("\u2713 Repository deleted");
+        } catch (error) {
+          handleError(error);
+        }
+      }
+    ).demandCommand(1, "You need to specify a git action");
+  },
+  handler: () => {
+  }
+};
+
+const domainsCommand = {
+  command: "domains <action>",
+  describe: "Manage domains, verifications, and mappings",
+  builder: (yargs) => {
+    return yargs.command(
+      "list",
+      "List verified domains",
+      (yargs2) => {
+        return yargs2.option("limit", {
+          type: "number",
+          description: "Maximum domains to return",
+          default: 50
+        }).option("cursor", {
+          type: "string",
+          description: "Offset cursor"
+        }).option("json", {
+          type: "boolean",
+          description: "Output as JSON",
+          default: false
+        });
+      },
+      async (argv) => {
+        loadEnv();
+        const args = argv;
+        try {
+          const freestyle = await getFreestyleClient();
+          const domains = await freestyle.domains.list({
+            limit: args.limit,
+            cursor: args.cursor
+          });
+          if (args.json) {
+            console.log(JSON.stringify(domains, null, 2));
+            return;
+          }
+          if (domains.length === 0) {
+            console.log("No verified domains found.");
+            return;
+          }
+          const rows = domains.map((domain) => [
+            domain.domain,
+            domain.verifiedDns ? "yes" : "no",
+            domain.createdAt ? new Date(domain.createdAt).toLocaleString() : "N/A"
+          ]);
+          formatTable(["Domain", "DNS Verified", "Created"], rows);
+        } catch (error) {
+          handleError(error);
+        }
+      }
+    ).command(
+      "verify <domain>",
+      "Create a domain verification request",
+      (yargs2) => {
+        return yargs2.positional("domain", {
+          type: "string",
+          description: "Domain to verify",
+          demandOption: true
+        }).option("json", {
+          type: "boolean",
+          description: "Output as JSON",
+          default: false
+        });
+      },
+      async (argv) => {
+        loadEnv();
+        const args = argv;
+        try {
+          const freestyle = await getFreestyleClient();
+          const result = await freestyle.domains.verifications.create({
+            domain: args.domain
+          });
+          if (args.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+          }
+          console.log("\n\u2713 Verification created!");
+          console.log(`  Verification ID: ${result.verificationId}`);
+          console.log("\nAdd this DNS record:");
+          console.log(`  Type: ${result.record.type}`);
+          console.log(`  Name: ${result.record.name}`);
+          console.log(`  Value: ${result.record.value}`);
+        } catch (error) {
+          handleError(error);
+        }
+      }
+    ).command(
+      "complete",
+      "Complete a domain verification",
+      (yargs2) => {
+        return yargs2.option("domain", {
+          type: "string",
+          description: "Domain to complete verification for"
+        }).option("verification-id", {
+          type: "string",
+          description: "Verification ID to complete"
+        }).option("json", {
+          type: "boolean",
+          description: "Output as JSON",
+          default: false
+        }).check((argv) => {
+          const hasDomain = !!argv.domain;
+          const hasVerificationId = !!argv["verification-id"];
+          if (!hasDomain && !hasVerificationId) {
+            throw new Error("Specify one of --domain or --verification-id");
+          }
+          if (hasDomain && hasVerificationId) {
+            throw new Error(
+              "Specify only one of --domain or --verification-id"
+            );
+          }
+          return true;
+        });
+      },
+      async (argv) => {
+        loadEnv();
+        const args = argv;
+        try {
+          const freestyle = await getFreestyleClient();
+          const result = args.verificationId ? await freestyle.domains.verifications.complete({
+            verificationId: args.verificationId
+          }) : await freestyle.domains.verifications.complete({
+            domain: args.domain
+          });
+          if (args.json) {
+            console.log(JSON.stringify(result, null, 2));
+          } else {
+            console.log("\u2713 Domain verification completed");
+            console.log(`  Domain: ${result.domain}`);
+          }
+        } catch (error) {
+          handleError(error);
+        }
+      }
+    ).command(
+      "verifications",
+      "List pending/verifiable domain verifications",
+      (yargs2) => {
+        return yargs2.option("json", {
+          type: "boolean",
+          description: "Output as JSON",
+          default: false
+        });
+      },
+      async (argv) => {
+        loadEnv();
+        const args = argv;
+        try {
+          const freestyle = await getFreestyleClient();
+          const verifications = await freestyle.domains.verifications.list();
+          if (args.json) {
+            console.log(JSON.stringify(verifications, null, 2));
+            return;
+          }
+          if (verifications.length === 0) {
+            console.log("No verifications found.");
+            return;
+          }
+          const rows = verifications.map((verification) => [
+            verification.domain,
+            verification.verificationCode,
+            new Date(verification.createdAt).toLocaleString()
+          ]);
+          formatTable(["Domain", "Verification Code", "Created"], rows);
+        } catch (error) {
+          handleError(error);
+        }
+      }
+    ).command(
+      "map <domain>",
+      "Create a domain mapping",
+      (yargs2) => {
+        return yargs2.positional("domain", {
+          type: "string",
+          description: "Domain to map",
+          demandOption: true
+        }).option("deployment-id", {
+          type: "string",
+          description: "Deployment ID target"
+        }).option("vm-id", {
+          type: "string",
+          description: "VM ID target"
+        }).option("vm-port", {
+          type: "number",
+          description: "VM port target (required with --vm-id)"
+        }).option("json", {
+          type: "boolean",
+          description: "Output as JSON",
+          default: false
+        }).check((argv) => {
+          const hasDeploymentId = !!argv["deployment-id"];
+          const hasVmId = !!argv["vm-id"];
+          const hasVmPort = typeof argv["vm-port"] === "number";
+          if (hasDeploymentId && hasVmId) {
+            throw new Error(
+              "Specify either --deployment-id or --vm-id (not both)"
+            );
+          }
+          if (!hasDeploymentId && !hasVmId) {
+            throw new Error("Specify one of --deployment-id or --vm-id");
+          }
+          if (hasVmId && !hasVmPort) {
+            throw new Error("--vm-port is required when using --vm-id");
+          }
+          return true;
+        });
+      },
+      async (argv) => {
+        loadEnv();
+        const args = argv;
+        try {
+          const freestyle = await getFreestyleClient();
+          const result = args.deploymentId ? await freestyle.domains.mappings.create({
+            domain: args.domain,
+            deploymentId: args.deploymentId
+          }) : await freestyle.domains.mappings.create({
+            domain: args.domain,
+            vmId: args.vmId,
+            vmPort: args.vmPort
+          });
+          if (args.json) {
+            console.log(JSON.stringify(result, null, 2));
+          } else {
+            console.log("\u2713 Domain mapping created");
+            console.log(`  Domain: ${result.domain}`);
+            if (result.deploymentId) {
+              console.log(`  Deployment ID: ${result.deploymentId}`);
+            }
+            if (result.vmId) {
+              console.log(`  VM ID: ${result.vmId}`);
+            }
+            if (result.vmPort) {
+              console.log(`  VM Port: ${result.vmPort}`);
+            }
+          }
+        } catch (error) {
+          handleError(error);
+        }
+      }
+    ).command(
+      "unmap <domain>",
+      "Delete a domain mapping",
+      (yargs2) => {
+        return yargs2.positional("domain", {
+          type: "string",
+          description: "Domain to unmap",
+          demandOption: true
+        });
+      },
+      async (argv) => {
+        loadEnv();
+        const args = argv;
+        try {
+          const freestyle = await getFreestyleClient();
+          await freestyle.domains.mappings.delete({ domain: args.domain });
+          console.log("\u2713 Domain mapping deleted");
+        } catch (error) {
+          handleError(error);
+        }
+      }
+    ).command(
+      "mappings",
+      "List domain mappings",
+      (yargs2) => {
+        return yargs2.option("domain", {
+          type: "string",
+          description: "Filter by domain"
+        }).option("limit", {
+          type: "number",
+          description: "Maximum mappings to return",
+          default: 50
+        }).option("cursor", {
+          type: "string",
+          description: "Offset cursor"
+        }).option("json", {
+          type: "boolean",
+          description: "Output as JSON",
+          default: false
+        });
+      },
+      async (argv) => {
+        loadEnv();
+        const args = argv;
+        try {
+          const freestyle = await getFreestyleClient();
+          const { mappings } = await freestyle.domains.mappings.list({
+            domain: args.domain,
+            limit: args.limit,
+            cursor: args.cursor
+          });
+          if (args.json) {
+            console.log(JSON.stringify(mappings, null, 2));
+            return;
+          }
+          if (mappings.length === 0) {
+            console.log("No domain mappings found.");
+            return;
+          }
+          const rows = mappings.map((mapping) => [
+            mapping.domain,
+            mapping.deploymentId || "-",
+            mapping.vmId || "-",
+            mapping.vmPort != null ? String(mapping.vmPort) : "-",
+            new Date(mapping.createdAt).toLocaleString()
+          ]);
+          formatTable(
+            ["Domain", "Deployment", "VM", "VM Port", "Created"],
+            rows
+          );
+        } catch (error) {
+          handleError(error);
+        }
+      }
+    ).demandCommand(1, "You need to specify a domains action");
+  },
+  handler: () => {
+  }
+};
+
+async function getCronJobById(scheduleId) {
+  const freestyle = await getFreestyleClient();
+  const { jobs } = await freestyle.cron.list();
+  const job = jobs.find((candidate) => candidate.schedule.id === scheduleId);
+  if (!job) {
+    throw new Error(`Cron schedule not found: ${scheduleId}`);
+  }
+  return job;
+}
+const cronCommand = {
+  command: "cron <action>",
+  describe: "Manage cron schedules for deployments",
+  builder: (yargs) => {
+    return yargs.command(
+      "schedule",
+      "Create a cron schedule",
+      (yargs2) => {
+        return yargs2.option("deployment-id", {
+          type: "string",
+          description: "Deployment ID to schedule",
+          demandOption: true
+        }).option("cron", {
+          type: "string",
+          description: "Cron expression",
+          demandOption: true
+        }).option("timezone", {
+          type: "string",
+          description: "Timezone (default: UTC)",
+          default: "UTC"
+        }).option("payload", {
+          type: "string",
+          description: "JSON payload string passed to scheduled handler"
+        }).option("path", {
+          type: "string",
+          description: "Optional path for scheduled trigger"
+        }).option("json", {
+          type: "boolean",
+          description: "Output as JSON",
+          default: false
+        });
+      },
+      async (argv) => {
+        loadEnv();
+        const args = argv;
+        try {
+          const freestyle = await getFreestyleClient();
+          let parsedPayload = {};
+          if (args.payload) {
+            try {
+              parsedPayload = JSON.parse(args.payload);
+            } catch {
+              throw new Error("--payload must be valid JSON");
+            }
+          }
+          const { job } = await freestyle.cron.schedule({
+            deploymentId: args.deploymentId,
+            cron: args.cron,
+            timezone: args.timezone,
+            payload: parsedPayload,
+            path: args.path
+          });
+          if (args.json) {
+            console.log(JSON.stringify(job.schedule, null, 2));
+          } else {
+            console.log("\u2713 Cron schedule created");
+            console.log(`  Schedule ID: ${job.schedule.id}`);
+            console.log(`  Deployment ID: ${job.schedule.deploymentId}`);
+            console.log(`  Cron: ${job.schedule.cron}`);
+            console.log(`  Timezone: ${job.schedule.timezone}`);
+            console.log(`  Active: ${job.schedule.active ? "yes" : "no"}`);
+          }
+        } catch (error) {
+          handleError(error);
+        }
+      }
+    ).command(
+      "list",
+      "List cron schedules",
+      (yargs2) => {
+        return yargs2.option("deployment-id", {
+          type: "string",
+          description: "Filter by deployment ID"
+        }).option("json", {
+          type: "boolean",
+          description: "Output as JSON",
+          default: false
+        });
+      },
+      async (argv) => {
+        loadEnv();
+        const args = argv;
+        try {
+          const freestyle = await getFreestyleClient();
+          const { jobs } = await freestyle.cron.list({
+            deploymentId: args.deploymentId
+          });
+          if (args.json) {
+            console.log(
+              JSON.stringify(
+                jobs.map((job) => job.schedule),
+                null,
+                2
+              )
+            );
+            return;
+          }
+          if (jobs.length === 0) {
+            console.log("No cron schedules found.");
+            return;
+          }
+          const rows = jobs.map((job) => [
+            job.schedule.id,
+            job.schedule.deploymentId,
+            job.schedule.cron,
+            job.schedule.timezone,
+            job.schedule.active ? "active" : "disabled"
+          ]);
+          formatTable(
+            ["Schedule ID", "Deployment", "Cron", "Timezone", "Status"],
+            rows
+          );
+        } catch (error) {
+          handleError(error);
+        }
+      }
+    ).command(
+      "enable <scheduleId>",
+      "Enable a cron schedule",
+      (yargs2) => {
+        return yargs2.positional("scheduleId", {
+          type: "string",
+          description: "Schedule ID",
+          demandOption: true
+        });
+      },
+      async (argv) => {
+        loadEnv();
+        const args = argv;
+        try {
+          const job = await getCronJobById(args.scheduleId);
+          await job.enable();
+          console.log(`\u2713 Enabled schedule ${args.scheduleId}`);
+        } catch (error) {
+          handleError(error);
+        }
+      }
+    ).command(
+      "disable <scheduleId>",
+      "Disable a cron schedule",
+      (yargs2) => {
+        return yargs2.positional("scheduleId", {
+          type: "string",
+          description: "Schedule ID",
+          demandOption: true
+        });
+      },
+      async (argv) => {
+        loadEnv();
+        const args = argv;
+        try {
+          const job = await getCronJobById(args.scheduleId);
+          await job.disable();
+          console.log(`\u2713 Disabled schedule ${args.scheduleId}`);
+        } catch (error) {
+          handleError(error);
+        }
+      }
+    ).command(
+      "executions <scheduleId>",
+      "List executions for a cron schedule",
+      (yargs2) => {
+        return yargs2.positional("scheduleId", {
+          type: "string",
+          description: "Schedule ID",
+          demandOption: true
+        }).option("limit", {
+          type: "number",
+          description: "Maximum executions to return",
+          default: 20
+        }).option("cursor", {
+          type: "string",
+          description: "Offset cursor"
+        }).option("json", {
+          type: "boolean",
+          description: "Output as JSON",
+          default: false
+        });
+      },
+      async (argv) => {
+        loadEnv();
+        const args = argv;
+        try {
+          const job = await getCronJobById(args.scheduleId);
+          const result = await job.executions({
+            limit: args.limit,
+            cursor: args.cursor
+          });
+          if (args.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+          }
+          if (result.executions.length === 0) {
+            console.log("No executions found.");
+            return;
+          }
+          const rows = result.executions.map((execution) => [
+            execution.id,
+            execution.status,
+            execution.attempts.toString(),
+            execution.runAt,
+            execution.lastError || "-"
+          ]);
+          formatTable(
+            ["Execution ID", "Status", "Attempts", "Run At", "Last Error"],
+            rows
+          );
+          const byStatus = result.executions.reduce(
+            (acc, execution) => {
+              acc[execution.status] = (acc[execution.status] || 0) + 1;
+              return acc;
+            },
+            {}
+          );
+          console.log("\nSummary:");
+          console.log(`  queued: ${byStatus.queued || 0}`);
+          console.log(`  running: ${byStatus.running || 0}`);
+          console.log(`  succeeded: ${byStatus.succeeded || 0}`);
+          console.log(`  failed: ${byStatus.failed || 0}`);
+          console.log(`  retry: ${byStatus.retry || 0}`);
+        } catch (error) {
+          handleError(error);
+        }
+      }
+    ).command(
+      "success-rate <scheduleId>",
+      "Get success rate for a cron schedule over a time range",
+      (yargs2) => {
+        return yargs2.positional("scheduleId", {
+          type: "string",
+          description: "Schedule ID",
+          demandOption: true
+        }).option("start", {
+          type: "string",
+          description: "Range start (ISO datetime)",
+          demandOption: true
+        }).option("end", {
+          type: "string",
+          description: "Range end (ISO datetime)",
+          demandOption: true
+        }).option("json", {
+          type: "boolean",
+          description: "Output as JSON",
+          default: false
+        });
+      },
+      async (argv) => {
+        loadEnv();
+        const args = argv;
+        try {
+          const job = await getCronJobById(args.scheduleId);
+          const result = await job.successRate({
+            start: args.start,
+            end: args.end
+          });
+          if (args.json) {
+            console.log(JSON.stringify(result, null, 2));
+          } else {
+            console.log("Cron success rate");
+            console.log(`  Schedule ID: ${args.scheduleId}`);
+            console.log(`  Range: ${result.start} -> ${result.end}`);
+            console.log(`  Total: ${result.total}`);
+            console.log(`  Succeeded: ${result.succeeded}`);
+            console.log(`  Failed: ${result.failed}`);
+            console.log(`  Success Rate: ${result.successRate}`);
+          }
+        } catch (error) {
+          handleError(error);
+        }
+      }
+    ).demandCommand(1, "You need to specify a cron action");
+  },
+  handler: () => {
+  }
+};
+
+const loginCommand = {
+  command: "login",
+  describe: "Authenticate the CLI",
+  builder: (yargs) => {
+    return yargs.option("save-to-dotenv", {
+      type: "boolean",
+      description: "Save the refresh token into the current folder's .env as FREESTYLE_STACK_REFRESH_TOKEN",
+      default: false
+    }).option("force", {
+      type: "boolean",
+      description: "Force a fresh login flow even if a stored token exists",
+      default: false
+    }).option("stack-project-id", {
+      type: "string",
+      description: "Project ID (overrides environment for this run)"
+    }).option("stack-publishable-client-key", {
+      type: "string",
+      description: "Publishable client key (overrides environment for this run)"
+    }).option("stack-app-url", {
+      type: "string",
+      description: "App URL for browser confirmation (default: https://freestyle.sh)"
+    });
+  },
+  handler: async (argv) => {
+    loadEnv();
+    const args = argv;
+    if (args.stackProjectId) {
+      process.env.FREESTYLE_STACK_PROJECT_ID = args.stackProjectId;
+    }
+    if (args.stackPublishableClientKey) {
+      process.env.FREESTYLE_STACK_PUBLISHABLE_CLIENT_KEY = args.stackPublishableClientKey;
+    }
+    if (args.stackAppUrl) {
+      process.env.FREESTYLE_STACK_APP_URL = args.stackAppUrl;
+    }
+    try {
+      const accessToken = await getStackAccessTokenForCli({
+        saveToDotenv: args.saveToDotenv,
+        forceRelogin: args.force
+      });
+      if (!accessToken) {
+        throw new Error(
+          "Authentication is not configured. Set FREESTYLE_STACK_PROJECT_ID and FREESTYLE_STACK_PUBLISHABLE_CLIENT_KEY."
+        );
+      }
+      console.log("\u2713 Authenticated");
+      if (args.saveToDotenv) {
+        console.log("\u2713 Saved refresh token to .env in current directory");
+      } else {
+        console.log("\u2713 Saved refresh token to global CLI auth store");
+      }
+      console.log("Fetching teams...");
+      const teams = await getTeamsForCli();
+      if (teams.length === 0) {
+        console.log(
+          "\u26A0\uFE0F  No teams found. You may need to create a team in the dashboard."
+        );
+        return;
+      }
+      const defaultTeam = teams[0];
+      console.log(`Setting up default team: ${defaultTeam.displayName}`);
+      await setDefaultTeam(defaultTeam.id);
+      console.log(
+        `\u2713 Default team configured: ${defaultTeam.displayName} (${defaultTeam.id})`
+      );
+      console.log("You can now use the CLI to manage resources.");
+      if (teams.length > 1) {
+        console.log(
+          `
+\u2139\uFE0F  You have ${teams.length} teams. Use 'freestyle team switch' to change teams.`
+        );
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  }
+};
+
+const logoutCommand = {
+  command: "logout",
+  describe: "Sign out the CLI",
+  builder: (yargs) => {
+    return yargs.option("dotenv", {
+      type: "boolean",
+      description: "Remove the refresh token from the current folder's .env",
+      default: false
+    });
+  },
+  handler: async (argv) => {
+    loadEnv();
+    const args = argv;
+    try {
+      const result = logoutCliAuth({ removeFromDotenv: args.dotenv });
+      if (!result.clearedStored && !result.clearedDotenv) {
+        console.log("No stored credentials found.");
+        return;
+      }
+      if (result.clearedStored) {
+        console.log("\u2713 Cleared CLI credentials");
+      }
+      if (result.clearedDotenv) {
+        console.log("\u2713 Removed refresh token from .env");
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  }
+};
+
+const whoamiCommand = {
+  command: "whoami",
+  describe: "Display information about the currently authenticated user",
+  builder: (yargs) => yargs,
+  handler: async (_argv) => {
+    loadEnv();
+    try {
+      const client = await getFreestyleClient();
+      const info = await client.whoami();
+      console.log(`Account ID: ${info.accountId}`);
+      if (info.identityId) {
+        console.log(`Identity ID: ${info.identityId}`);
+      }
+    } catch (e) {
+      handleError(e);
+    }
+  }
+};
+
+dotenv.config({ quiet: true });
+yargs(hideBin(process.argv)).scriptName("freestyle").usage("$0 <command> [options]").option("team", {
+  type: "string",
+  describe: "Override team ID for this command",
+  global: true
+}).middleware((argv) => {
+  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();