freestyle-sandboxes 0.1.19 → 0.1.20

package/cli.mjs

@@ -509,4 +509,753 @@ const runCommand = {
   }
 };
 
-yargs(hideBin(process.argv)).scriptName("freestyle").usage("$0 <command> [options]").command(vmCommand).command(deployCommand).command(runCommand).demandCommand(1, "You need to specify a command").help().alias("help", "h").version().alias("version", "v").strict().parse();
+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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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: () => {
+  }
+};
+
+yargs(hideBin(process.argv)).scriptName("freestyle").usage("$0 <command> [options]").command(vmCommand).command(gitCommand).command(domainsCommand).command(cronCommand).command(deployCommand).command(runCommand).demandCommand(1, "You need to specify a command").help().alias("help", "h").version().alias("version", "v").strict().parse();