@sandblocks/cli 0.2.0 → 0.4.0-b.0

package/dist/cli.js

@@ -11117,7 +11117,7 @@ var EnvironmentValueSchema = exports_external.object({
   routing: exports_external.object({
     baseDomain: exports_external.string().min(1).max(253).default("sandblocks.dev"),
     domains: exports_external.record(id, exports_external.string().min(1).max(253)).default({}),
-    stableDomains: exports_external.record(id, exports_external.string().min(1).max(253)).default({}),
+    stableDomains: exports_external.record(id, exports_external.union([exports_external.string().min(1).max(253), exports_external.array(exports_external.string().min(1).max(253)).min(1)])).default({}),
     sso: exports_external.boolean().optional()
   }).strict().default({})
 }).strict();
@@ -11153,17 +11153,19 @@ function validateReferences(manifest, ctx) {
     validateReferencesTo(ctx, environment.checks, checkIds, ["environments", index, "checks"], "check");
     validateReferencesTo(ctx, Object.keys(environment.routing.domains), new Set(environment.services), ["environments", index, "routing", "domains"], "environment service");
     validateReferencesTo(ctx, Object.keys(environment.routing.stableDomains), new Set(environment.services), ["environments", index, "routing", "stableDomains"], "environment service");
-    for (const [service, template] of Object.entries({
+    for (const [service, configured] of Object.entries({
       ...environment.routing.domains,
       ...environment.routing.stableDomains
     })) {
-      const expanded = template.replaceAll(/\{(?:sandbox|revision|service)\}/g, "preview");
-      if (expanded.includes("{") || !/^[a-z0-9.-]+$/.test(expanded.toLowerCase())) {
-        ctx.addIssue({
-          code: exports_external.ZodIssueCode.custom,
-          path: ["environments", index, "routing", "domains", service],
-          message: "domain template may use only {sandbox}, {revision}, and {service}"
-        });
+      for (const template of Array.isArray(configured) ? configured : [configured]) {
+        const expanded = template.replaceAll(/\{(?:sandbox|revision|service)\}/g, "preview");
+        if (expanded.includes("{") || !/^[a-z0-9.-]+$/.test(expanded.toLowerCase())) {
+          ctx.addIssue({
+            code: exports_external.ZodIssueCode.custom,
+            path: ["environments", index, "routing", "domains", service],
+            message: "domain template may use only {sandbox}, {revision}, and {service}"
+          });
+        }
       }
     }
   }
@@ -11707,9 +11709,11 @@ async function up(args, dependencies) {
     try {
       await deployUnlocked(args, dependencies);
     } catch (error) {
-      await down(args, dependencies).catch(() => {
-        return;
-      });
+      if (process.env.SANDBLOCKS_RETAIN_FAILED !== "true") {
+        await down(args, dependencies).catch(() => {
+          return;
+        });
+      }
       throw error;
     }
   });
@@ -11831,9 +11835,9 @@ async function deployUnlocked(args, dependencies) {
   const loaded = await dependencies.load(context.root, dependencies.option(context.options, "config") ?? dependencies.option(context.options, "manifest"));
   const stack = loaded.manifest.name ?? context.state.repository;
   const preview = await applyManagedRoutingPolicy(context, stack, selectPreview(loaded, context.state.environment));
-  const targetHost = process.env.SANDBLOCKS_SANDBOX_TARGET_HOST ?? preview.targetHost;
+  const targetHost = await resolveAssignedTargetHost(context, process.env.SANDBLOCKS_SANDBOX_TARGET_HOST ?? preview.targetHost);
   if (!targetHost)
-    throw new Error("preview targetHost or SANDBLOCKS_SANDBOX_TARGET_HOST is required");
+    throw new Error("assigned host targetHost label or preview targetHost is required");
   const deploymentId = randomUUID();
   const environmentSnapshotId = await createEnvironmentSnapshot(context);
   const serviceUrls = expectedPreviewServiceUrls(context.state.sandboxId, deploymentId, context.state.repository, preview);
@@ -11901,6 +11905,7 @@ async function deployUnlocked(args, dependencies) {
   try {
     if (preview.steps.length) {
       const checkRoutes = sandbox.previewUrls ?? [];
+      await waitForPublishedRoutes(checkRoutes);
       const serviceUrls2 = Object.fromEntries(checkRoutes.flatMap((route) => route.service ? [
         [
           `SANDBLOCKS_SERVICE_${route.service.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_URL`,
@@ -11931,8 +11936,9 @@ async function deployUnlocked(args, dependencies) {
       });
       const checked = await wait(context.apiUrl, context.apiKey, check.operation.id, 60 * 60000);
       checkEvidence = checked.result?.checks ?? [];
-      if (checked.result?.passed !== true)
-        throw new Error("one or more post-deploy checks failed");
+      if (checked.result?.passed !== true) {
+        throw new Error(`one or more post-deploy checks failed: ${JSON.stringify(checkEvidence)}`);
+      }
       sandbox = await recordSandbox(context, loaded, preview, routes, [...operation.result?.healthEvidence ?? [], ...checkEvidence], images, "available");
     }
   } catch (error) {
@@ -12054,6 +12060,14 @@ async function down(args, dependencies) {
   await rm(context.file, { force: true });
   console.log(`sandbox ${context.state.sandboxId} destroyed`);
 }
+async function resolveAssignedTargetHost(context, fallback) {
+  if (fallback?.trim())
+    return fallback.trim();
+  const body = await request(context.apiUrl, context.apiKey, "/v1/hosts");
+  const host = Array.isArray(body.hosts) ? body.hosts.find((candidate) => candidate?.id === context.state.hostId) : undefined;
+  const targetHost = host?.labels?.targetHost;
+  return typeof targetHost === "string" && targetHost.trim() ? targetHost.trim() : undefined;
+}
 async function recordSandbox(context, loaded, preview, serviceRoutes, healthEvidence, images, status2) {
   const body = await request(context.apiUrl, context.apiKey, `/v1/projects/${encodeURIComponent(context.state.projectId)}/sandboxes`, {
     method: "POST",
@@ -12122,7 +12136,7 @@ async function destroyDeploymentById(context, deploymentId) {
   await wait(context.apiUrl, context.apiKey, body.operation.id);
 }
 async function destroyWorkspace(context, idempotencyKey) {
-  const response = await fetch(`${context.apiUrl}/v1/projects/${encodeURIComponent(context.state.projectId)}/workspaces/${encodeURIComponent(context.state.workspaceId)}`, {
+  const response = await fetchWithRetry(`${context.apiUrl}/v1/projects/${encodeURIComponent(context.state.projectId)}/workspaces/${encodeURIComponent(context.state.workspaceId)}`, {
     method: "DELETE",
     headers: {
       "content-type": "application/json",
@@ -12139,7 +12153,7 @@ async function destroyWorkspace(context, idempotencyKey) {
 }
 async function importSource(input) {
   const source = await input.source(input.root);
-  const response = await fetch(`${input.apiUrl}/v1/projects/${encodeURIComponent(input.projectId)}/workspaces/import`, {
+  const response = await fetchWithRetry(`${input.apiUrl}/v1/projects/${encodeURIComponent(input.projectId)}/workspaces/import`, {
     method: "POST",
     headers: {
       "content-type": "application/x-tar",
@@ -12202,7 +12216,7 @@ async function request(apiUrl, apiKey, pathname, init = {}) {
   headers.set("x-sandblocks-api-key", apiKey);
   if (init.body)
     headers.set("content-type", "application/json");
-  const response = await fetch(`${apiUrl}${pathname}`, { ...init, headers });
+  const response = await fetchWithRetry(`${apiUrl}${pathname}`, { ...init, headers });
   const body = await response.json().catch(() => ({}));
   if (!response.ok)
     throw new Error(String(body.error ?? `Sandblocks request failed (${response.status})`));
@@ -12213,12 +12227,61 @@ async function leaseRequest(context, pathname, init = {}) {
   headers.set("authorization", `Bearer ${context.state.leaseToken}`);
   if (init.body)
     headers.set("content-type", "application/json");
-  const response = await fetch(`${context.apiUrl}${pathname}`, { ...init, headers });
+  const response = await fetchWithRetry(`${context.apiUrl}${pathname}`, { ...init, headers });
   const body = await response.json().catch(() => ({}));
   if (!response.ok)
     throw new Error(String(body.error ?? `Sandblocks lease request failed (${response.status})`));
   return body;
 }
+async function waitForPublishedRoutes(routes, timeoutMs = 90000) {
+  const deadline = Date.now() + timeoutMs;
+  let pending = routes.map((route) => ({
+    label: route.url,
+    url: route.service === "api" ? new URL("/health", route.url).toString() : route.url
+  }));
+  while (pending.length && Date.now() < deadline) {
+    const checks = await Promise.all(pending.map(async (route) => {
+      try {
+        const response = await fetch(route.url, { redirect: "manual" });
+        await response.body?.cancel().catch(() => {
+          return;
+        });
+        return response.status >= 200 && response.status < 400 ? undefined : route;
+      } catch {
+        return route;
+      }
+    }));
+    pending = checks.filter((route) => typeof route === "object" && route !== null);
+    if (pending.length)
+      await Bun.sleep(2000);
+  }
+  if (pending.length) {
+    throw new Error(`preview routes did not become ready: ${pending.map((route) => route.label).join(", ")}`);
+  }
+}
+async function fetchWithRetry(url, init = {}) {
+  const method = (init.method ?? "GET").toUpperCase();
+  const headers = new Headers(init.headers);
+  const safeToRetry = method === "GET" || method === "HEAD" || headers.has("idempotency-key");
+  const attempts = safeToRetry ? 8 : 1;
+  let lastError;
+  for (let attempt = 0;attempt < attempts; attempt += 1) {
+    try {
+      const response = await fetch(url, init);
+      if (![409, 429, 502, 503, 504].includes(response.status) || attempt === attempts - 1)
+        return response;
+      await response.body?.cancel().catch(() => {
+        return;
+      });
+    } catch (error) {
+      lastError = error;
+      if (attempt === attempts - 1)
+        throw error;
+    }
+    await Bun.sleep(Math.min(5000, 250 * 2 ** attempt));
+  }
+  throw lastError instanceof Error ? lastError : new Error("Sandblocks request failed");
+}
 async function wait(apiUrl, apiKey, operationId, timeoutMs = 30 * 60000) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
@@ -12277,7 +12340,8 @@ function expectedPreviewServiceUrls(sandboxId, deploymentId, stack, preview) {
       return [];
     const name = service.id.toUpperCase().replace(/[^A-Z0-9]/g, "_");
     const host = resolvedServiceDomain(sandboxId, deploymentId, service.id, preview);
-    const stableHost = preview.stableDomains[service.id] ?? `${preview.deploymentType}-${stack}-${service.id}.${preview.baseDomain}`;
+    const configuredStableHosts = preview.stableDomains[service.id];
+    const stableHost = (Array.isArray(configuredStableHosts) ? configuredStableHosts[0] : configuredStableHosts) ?? `${preview.deploymentType}-${stack}-${service.id}.${preview.baseDomain}`;
     return [
       [`SANDBLOCKS_SERVICE_${name}_URL`, `https://${host}`],
       [`SANDBLOCKS_STABLE_SERVICE_${name}_URL`, `https://${stableHost}`]
@@ -14266,11 +14330,13 @@ var HELP = `Sandblocks CLI
   sandblocks register [directory] --project <id> [--repository-url <url>]
                   [--api-url <url>] [--api-key <key>] [--json]
   sandblocks doctor [directory] [--api-url <url>]
+  sandblocks whoami [directory] [--api-url <url>] [--api-key <key>] [--json]
   sandblocks sandbox up [directory] [--environment <id>] [--project <id>]
   sandblocks sandbox create [directory] [--environment <id>] [--project <id>]
   sandblocks sandbox deploy [directory] [--environment <id>]
   sandblocks sandbox redeploy [directory] [--environment <id>]
   sandblocks sandbox status [directory] [--environment <id>] [--json]
+  sandblocks sandbox promote --project <id> --sandbox <id> [--json]
   sandblocks sandbox renew [directory] [--environment <id>] [--ttl-seconds <n>]
   sandblocks sandbox exec [directory] [--environment <id>] -- <typed-command>
   sandblocks sandbox git [directory] [--environment <id>] <status|diff|stage|checkout>
@@ -14311,6 +14377,8 @@ async function run2(argv = process.argv.slice(2)) {
     await register(args);
   else if (command === "doctor")
     await doctor(args);
+  else if (command === "whoami")
+    await whoami(args);
   else if (command === "sandbox")
     await sandbox(args);
   else if (command === "sdk")
@@ -14415,6 +14483,30 @@ async function doctor(args) {
   const gitDetected = await stat3(path4.join(root, ".git")).then(() => true).catch(() => false);
   console.log(`git       ${gitDetected ? "ok" : "not detected"}`);
 }
+async function whoami(args) {
+  const options = parse(args);
+  const apiUrl = (option(options, "api-url") ?? process.env.SANDBLOCKS_API_URL ?? "").replace(/\/$/, "");
+  const apiKey = option(options, "api-key") ?? process.env.SANDBLOCKS_API_KEY;
+  if (!apiUrl)
+    throw new Error("whoami requires --api-url or SANDBLOCKS_API_URL");
+  if (!apiKey)
+    throw new Error("whoami requires --api-key or SANDBLOCKS_API_KEY");
+  const response = await fetch(`${apiUrl}/v1/session`, {
+    headers: { "x-sandblocks-api-key": apiKey }
+  });
+  const body = await response.json().catch(() => ({}));
+  if (!response.ok)
+    throw new Error(String(body.error ?? `session lookup failed (${response.status})`));
+  if (options.json) {
+    console.log(JSON.stringify(body, null, 2));
+    return;
+  }
+  const session = body.session ?? {};
+  console.log(`subject  ${session.subject ?? "unknown"}`);
+  console.log(`source   ${session.source ?? "unknown"}`);
+  console.log(`project  ${session.projectId ?? "unscoped"}`);
+  console.log(`scopes   ${(session.scopes ?? []).join(",") || "none"}`);
+}
 async function sandbox(args) {
   const [subcommand, ...rest] = args;
   if (isStatefulSandboxCommand(subcommand) && !(subcommand === "deploy" && rest.includes("--workspace"))) {
@@ -14430,6 +14522,8 @@ async function sandbox(args) {
   }
   if (subcommand === "deploy")
     return sandboxDeploy(rest);
+  if (subcommand === "promote")
+    return sandboxPromote(rest);
   if (subcommand !== "import")
     throw new Error("unsupported sandbox command");
   const options = parse(rest);
@@ -14474,6 +14568,26 @@ async function sandbox(args) {
       console.log(`container ${operation.result.container}`);
   }
 }
+async function sandboxPromote(args) {
+  const options = parse(args);
+  const projectId = option(options, "project");
+  const sandboxId = option(options, "sandbox");
+  const apiUrl = (option(options, "api-url") ?? process.env.SANDBLOCKS_API_URL ?? "").replace(/\/$/, "");
+  const apiKey = option(options, "api-key") ?? process.env.SANDBLOCKS_API_KEY;
+  if (!projectId)
+    throw new Error("sandbox promote requires --project");
+  if (!sandboxId)
+    throw new Error("sandbox promote requires --sandbox");
+  if (!apiUrl)
+    throw new Error("sandbox promote requires --api-url or SANDBLOCKS_API_URL");
+  if (!apiKey)
+    throw new Error("sandbox promote requires --api-key or SANDBLOCKS_API_KEY");
+  const result = await sandblocksRequest(apiUrl, apiKey, `/v1/projects/${encodeURIComponent(projectId)}/routing-aliases/promote`, { method: "POST", body: JSON.stringify({ sandboxId }) });
+  if (options.json)
+    console.log(JSON.stringify(result, null, 2));
+  else
+    console.log(`promoted ${sandboxId} to production`);
+}
 var sourceFileCount = 0;
 async function createSourceTar(root) {
   const process2 = Bun.spawn(["git", "ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
@@ -14785,4 +14899,4 @@ export {
   parse
 };
 
-//# debugId=AE8677F9C15C750D64756E2164756E21
+//# debugId=D1104053F8254F7864756E2164756E21