@supacloud/admin 0.10.1 → 0.11.0

package/README.md

@@ -137,9 +137,19 @@ With `--artifact_transport remote` (the default), omitting
 `--edge_runtime_version` retains the Management and Web Console-only upgrade
 behavior and reports that Edge Runtime was not upgraded. Local transport
 requires exact Management and Edge Runtime versions. Caddy and GoTrue are
-outside this transaction and are not replaced. After a capable Management
-release is active, an exact rollback can use that active upgrader with explicit
-older targets, for example:
+outside this transaction and are not replaced.
+
+The remote transport allows the same 30-minute transaction window plus bounded
+verifier/bootstrap downloads: 42 minutes for direct GitHub access, or 52
+minutes when each download may try direct GitHub before an explicit proxy. If
+the SSH command times out or its stream fails after dispatch, Admin reports
+`OUTCOME_UNKNOWN` and does not issue client-side helper cleanup. The remote
+command may finish later and then run its own cleanup. Reconcile the reported
+helper and trusted-root paths and read back deployed versions before deciding
+whether to retry.
+
+After a capable Management release is active, an exact rollback can use that
+active upgrader with explicit older targets, for example:
 
 ```bash
 npx @supacloud/admin ssh upgrade \

package/dist/index.js

@@ -4759,7 +4759,7 @@ var require_utils = __commonJS((exports, module) => {
 
 // node_modules/ssh2/lib/protocol/crypto/build/Release/sshcrypto.node
 var require_sshcrypto = __commonJS((exports, module) => {
-  module.exports = __require("./sshcrypto-8m50vnmb.node");
+  module.exports = __require("./sshcrypto-vd2k5hq9.node");
 });
 
 // node_modules/ssh2/lib/protocol/crypto/poly1305.js
@@ -24931,6 +24931,14 @@ function schemaProperties(schema) {
 var import_ssh2 = __toESM(require_lib3(), 1);
 import { randomUUID, timingSafeEqual } from "node:crypto";
 import { readFileSync } from "node:fs";
+
+class SshCommandOutcomeUnknownError extends Error {
+  code = "OUTCOME_UNKNOWN";
+  constructor(message) {
+    super(message);
+    this.name = "SshCommandOutcomeUnknownError";
+  }
+}
 var DEFAULT_MAX_OUTPUT_BYTES = 1024 * 1024;
 var MAX_CONFIGURABLE_OUTPUT_BYTES = 16 * 1024 * 1024;
 var DEFAULT_UPLOAD_TIMEOUT_MS = 10 * 60000;
@@ -25148,34 +25156,45 @@ class SshTransport {
         const stderr = new BoundedOutputCollector(outputLimit);
         const timer = setTimeout(() => {
           connectionReusable = false;
-          reject(new Error(`SSH command timed out after ${timeoutMs}ms`));
+          reject(new SshCommandOutcomeUnknownError(`SSH command timed out after ${timeoutMs}ms; remote outcome is unknown`));
         }, timeoutMs);
-        conn.exec(command, (err, stream) => {
-          if (err) {
-            clearTimeout(timer);
-            connectionReusable = false;
-            return reject(err);
-          }
-          stream.on("close", (code) => {
-            clearTimeout(timer);
-            resolve({
-              success: code === 0,
-              stdout: stdout.finalize(),
-              stderr: stderr.finalize(),
-              code,
-              stdoutTruncated: stdout.truncated,
-              stderrTruncated: stderr.truncated
+        try {
+          conn.exec(command, (err, stream) => {
+            if (err) {
+              clearTimeout(timer);
+              connectionReusable = false;
+              return reject(err);
+            }
+            stream.on("close", (code) => {
+              clearTimeout(timer);
+              if (code === undefined) {
+                connectionReusable = false;
+                reject(new SshCommandOutcomeUnknownError("SSH command stream closed without a terminal status; remote outcome is unknown"));
+                return;
+              }
+              resolve({
+                success: code === 0,
+                stdout: stdout.finalize(),
+                stderr: stderr.finalize(),
+                code: code ?? 128,
+                stdoutTruncated: stdout.truncated,
+                stderrTruncated: stderr.truncated
+              });
+            }).on("error", () => {
+              clearTimeout(timer);
+              connectionReusable = false;
+              reject(new SshCommandOutcomeUnknownError("SSH command stream failed after dispatch; remote outcome is unknown"));
+            }).on("data", (data) => {
+              stdout.append(data);
+            }).stderr.on("data", (data) => {
+              stderr.append(data);
             });
-          }).on("error", (streamError) => {
-            clearTimeout(timer);
-            connectionReusable = false;
-            reject(streamError);
-          }).on("data", (data) => {
-            stdout.append(data);
-          }).stderr.on("data", (data) => {
-            stderr.append(data);
           });
-        });
+        } catch (error) {
+          clearTimeout(timer);
+          connectionReusable = false;
+          reject(error);
+        }
       });
     } finally {
       if (connectionReusable)
@@ -26011,12 +26030,74 @@ function validatedPostTimeout(options) {
   }
   return timeoutMs;
 }
+function validatedGetResponseLimit(options) {
+  const maxBytes = options.maxResponseBytes;
+  if (maxBytes === undefined)
+    return;
+  if (!Number.isSafeInteger(maxBytes) || maxBytes <= 0) {
+    throw new RangeError("HTTP response limit must be a positive safe integer");
+  }
+  return maxBytes;
+}
+function responseExceedsDeclaredLimit(response, maxBytes) {
+  const contentLength = response.headers.get("content-length");
+  return contentLength !== null && /^\d+$/u.test(contentLength) && Number(contentLength) > maxBytes;
+}
+function joinedResponseBytes(chunks, totalBytes) {
+  const responseBytes = new Uint8Array(totalBytes);
+  let offset = 0;
+  for (const chunk of chunks) {
+    responseBytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return responseBytes;
+}
+async function boundedResponseBytes(response, maxBytes) {
+  if (responseExceedsDeclaredLimit(response, maxBytes)) {
+    response.body?.cancel().catch(() => {
+      return;
+    });
+    return null;
+  }
+  if (!response.body)
+    return new Uint8Array;
+  const reader = response.body.getReader();
+  const chunks = [];
+  let totalBytes = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done)
+      return joinedResponseBytes(chunks, totalBytes);
+    totalBytes += value.byteLength;
+    if (totalBytes > maxBytes) {
+      reader.cancel().catch(() => {
+        return;
+      });
+      return null;
+    }
+    chunks.push(value);
+  }
+}
+async function boundedResponseJson(response, maxBytes) {
+  const responseBytes = await boundedResponseBytes(response, maxBytes);
+  if (responseBytes === null)
+    return null;
+  try {
+    const responseText = new TextDecoder("utf-8", { fatal: true }).decode(responseBytes);
+    return JSON.parse(responseText);
+  } catch (error) {
+    if (error instanceof SyntaxError || error instanceof TypeError)
+      return null;
+    throw error;
+  }
+}
 async function fetchWithTimeout(url, options, timeoutMs = DEFAULT_TIMEOUT) {
   const controller = new AbortController;
   const timeout = setTimeout(() => controller.abort(), timeoutMs);
   try {
     return await fetch(url, {
       ...options,
+      redirect: "error",
       signal: controller.signal
     });
   } finally {
@@ -26059,13 +26140,14 @@ class HttpTransport {
       "Content-Type": "application/json"
     };
   }
-  async get(path) {
+  async get(path, options = {}) {
+    const maxResponseBytes = validatedGetResponseLimit(options);
     try {
       const res = await fetchWithRetry(`${this.baseUrl}${path}`, {
         method: "GET",
         headers: this.headers()
       });
-      const data = await res.json().catch(() => null);
+      const data = maxResponseBytes === undefined ? await res.json().catch(() => null) : await boundedResponseJson(res, maxResponseBytes);
       return { ok: res.ok, status: res.status, data };
     } catch (error) {
       return transportFailure(error);
@@ -27722,8 +27804,10 @@ var SAFE_HOSTNAME = /^(?=.{1,253}$)(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9
 var SAFE_SYSTEMD_UNIT = /^[a-zA-Z0-9][a-zA-Z0-9_.@:-]{0,127}$/;
 var SAFE_DB_IDENTIFIER = /^[a-zA-Z_][a-zA-Z0-9_-]{0,62}$/;
 var MINIMUM_COMPONENT_UPGRADE_VERSION = "0.50.27";
-var DIRECT_UPGRADE_SSH_TIMEOUT_MS = 720000;
-var PROXIED_UPGRADE_SSH_TIMEOUT_MS = 1320000;
+var DIRECT_BOOTSTRAP_TRANSFER_BUDGET_MS = 12 * 60000;
+var PROXIED_BOOTSTRAP_TRANSFER_BUDGET_MS = 22 * 60000;
+var DIRECT_UPGRADE_SSH_TIMEOUT_MS = UPGRADE_OBSERVATION_TIMEOUT_MS + DIRECT_BOOTSTRAP_TRANSFER_BUDGET_MS;
+var PROXIED_UPGRADE_SSH_TIMEOUT_MS = UPGRADE_OBSERVATION_TIMEOUT_MS + PROXIED_BOOTSTRAP_TRANSFER_BUDGET_MS;
 var PLATFORM_PROBE_TIMEOUT_MS = 1e4;
 var PLATFORM_HASH_TIMEOUT_MS = 30000;
 var WEB_CONSOLE_PROBE_TIMEOUT_MS = 60000;
@@ -27996,11 +28080,58 @@ async function removeRemoteUpgradeHelper(ssh, helperPath) {
     throw new Error(`Failed to remove remote upgrade helper (exit ${cleanup.code}): ${cleanup.stderr.slice(-300)}`);
   }
 }
+
+class RemoteUpgradeOutcomeUnknownError extends AggregateError {
+  code = "OUTCOME_UNKNOWN";
+}
+function boundedUpgradeError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const diagnostic = redactSshOutput(message).replace(/[\r\n\t]+/g, " ").trim().slice(0, 500);
+  return new Error(diagnostic || "Remote operation ended without a diagnostic");
+}
+function remoteUpgradeEvidence(helperPath) {
+  const trustedRootPath = join2(dirname(helperPath), SIGSTORE_PUBLIC_GOOD_TRUSTED_ROOT_FILENAME);
+  return `helper=${helperPath} trusted_root=${trustedRootPath}`;
+}
+function remoteUpgradeReconciliationFailure(message, failures, helperPath) {
+  return new RemoteUpgradeOutcomeUnknownError(failures.map(boundedUpgradeError), `${message} Reconcile ${remoteUpgradeEvidence(helperPath)}; do not retry blindly`);
+}
+function remoteUpgradeOutcomeUnknown(transportError, helperPath) {
+  return remoteUpgradeReconciliationFailure("OUTCOME_UNKNOWN: Remote upgrade transport ended after dispatch; client cleanup was suppressed " + "because the remote command may still be running. Verify deployed versions before retrying.", [transportError], helperPath);
+}
 function remoteUpgradeFailure(execution) {
   const diagnostic = execution.stderr.trim() || execution.stdout.trim() || "no remote diagnostic";
   return new Error(`Remote upgrade failed (exit ${execution.code}): ${diagnostic.slice(-500)}`);
 }
+function remoteHelperSetupOutcomeUnknown(outcome) {
+  const cleanupStatus = outcome.cleanupFailed ? "the helper cleanup did not complete" : "the cleanup command completed, but setup may finish later";
+  const failures = outcome.cleanupFailed ? [outcome.executionError, outcome.cleanupError] : [outcome.executionError];
+  return remoteUpgradeReconciliationFailure(`OUTCOME_UNKNOWN: Remote helper setup ended without terminal status; ${cleanupStatus}. ` + "The upgrade command was not dispatched.", failures, outcome.helperPath);
+}
+function completedUpgradeCleanupOutcomeUnknown(outcome) {
+  if (!outcome.execution) {
+    return remoteUpgradeReconciliationFailure("OUTCOME_UNKNOWN: Upgrade execution returned no result, and helper cleanup outcome is unknown.", [outcome.cleanupError], outcome.helperPath);
+  }
+  const message = outcome.execution.success ? "OUTCOME_UNKNOWN: Remote upgrade succeeded, but helper cleanup outcome is unknown." : "OUTCOME_UNKNOWN: Remote upgrade failed with a terminal result, and helper cleanup outcome is unknown.";
+  const failures = outcome.execution.success ? [outcome.cleanupError] : [remoteUpgradeFailure(outcome.execution), outcome.cleanupError];
+  return remoteUpgradeReconciliationFailure(message, failures, outcome.helperPath);
+}
+function remoteHelperCleanupOutcomeUnknown(outcome) {
+  if (!outcome.upgradeExecutionRequested) {
+    return remoteUpgradeReconciliationFailure("OUTCOME_UNKNOWN: Remote helper setup failed, and helper cleanup outcome is unknown. " + "The upgrade command was not dispatched.", [outcome.executionError, outcome.cleanupError], outcome.helperPath);
+  }
+  if (outcome.executionFailed) {
+    return remoteUpgradeReconciliationFailure("OUTCOME_UNKNOWN: Upgrade execution request failed, and helper cleanup outcome is unknown.", [outcome.executionError, outcome.cleanupError], outcome.helperPath);
+  }
+  return completedUpgradeCleanupOutcomeUnknown(outcome);
+}
 function officialUpgradeOutcome(outcome) {
+  if (!outcome.upgradeExecutionRequested && outcome.executionError instanceof SshCommandOutcomeUnknownError) {
+    throw remoteHelperSetupOutcomeUnknown(outcome);
+  }
+  if (outcome.cleanupFailed && outcome.cleanupError instanceof SshCommandOutcomeUnknownError) {
+    throw remoteHelperCleanupOutcomeUnknown(outcome);
+  }
   if (outcome.executionFailed && outcome.cleanupFailed) {
     throw new AggregateError([outcome.executionError, outcome.cleanupError], "Upgrade execution failed and helper cleanup did not complete");
   }
@@ -28021,34 +28152,37 @@ async function executeOfficialUpgrade(ssh, helperPath, command, timeoutMs) {
   let execution;
   let executionFailed = false;
   let executionError;
-  let helperPrepared = false;
+  let upgradeExecutionRequested = false;
   try {
     await prepareRemoteUpgradeHelperDirectory(ssh, helperPath);
-    helperPrepared = true;
     await ssh.uploadText(helperPath, release_assets_default, 384);
     const trustedRootPath = join2(dirname(helperPath), SIGSTORE_PUBLIC_GOOD_TRUSTED_ROOT_FILENAME);
     await ssh.uploadText(trustedRootPath, SIGSTORE_PUBLIC_GOOD_TRUSTED_ROOT_JSONL, 384);
+    upgradeExecutionRequested = true;
     execution = await ssh.exec(command, timeoutMs);
   } catch (error) {
+    if (upgradeExecutionRequested && error instanceof SshCommandOutcomeUnknownError) {
+      throw remoteUpgradeOutcomeUnknown(error, helperPath);
+    }
     executionFailed = true;
     executionError = error;
   }
   let cleanupFailed = false;
   let cleanupError;
-  if (helperPrepared) {
-    try {
-      await removeRemoteUpgradeHelper(ssh, helperPath);
-    } catch (error) {
-      cleanupFailed = true;
-      cleanupError = error;
-    }
+  try {
+    await removeRemoteUpgradeHelper(ssh, helperPath);
+  } catch (error) {
+    cleanupFailed = true;
+    cleanupError = error;
   }
   return officialUpgradeOutcome({
     execution,
     executionFailed,
     executionError,
     cleanupFailed,
-    cleanupError
+    cleanupError,
+    helperPath,
+    upgradeExecutionRequested
   });
 }
 function assertSafeGithubProxy(value) {
@@ -29646,6 +29780,229 @@ function parseProjectCreateCredentials(responsePayload, expectedApiOrigin, expec
   return isServiceRoleKey(serviceRoleKey) ? { ...identity, serviceRoleKey } : null;
 }
 
+// ../cli/src/shared/tools/project-read-projection.ts
+var PROJECT_READ_RESPONSE_MAX_BYTES = 1048576;
+var PROJECT_REF_PATTERN = /^[a-z0-9-]{1,20}$/;
+var SAFE_IDENTIFIER_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
+var REGION_PATTERN = /^[A-Za-z0-9._-]{1,64}$/;
+var STATUS_PATTERN = /^[A-Z][A-Z0-9_]{0,63}$/;
+var DNS_LABEL_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?$/;
+var DATABASE_VERSION_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._+-]{0,63}$/;
+var MAX_PROJECTS = 1e4;
+var PROJECT_SUMMARY_KEYS = new Set([
+  "id",
+  "ref",
+  "organization_id",
+  "organization_slug",
+  "name",
+  "region",
+  "created_at",
+  "status"
+]);
+var PROJECT_DETAILS_KEYS = new Set([
+  ...PROJECT_SUMMARY_KEYS,
+  "database",
+  "api",
+  "studio",
+  "config",
+  "anon_key",
+  "services"
+]);
+var PROJECT_DATABASE_KEYS = new Set([
+  "host",
+  "version",
+  "postgres_engine",
+  "release_channel"
+]);
+var PROJECT_ENDPOINT_KEYS = new Set(["url"]);
+function plainRecord(candidate) {
+  if (!candidate || typeof candidate !== "object" || Array.isArray(candidate))
+    return null;
+  const prototype = Object.getPrototypeOf(candidate);
+  return prototype === Object.prototype || prototype === null ? candidate : null;
+}
+function hasOnlyKeys(record, allowedKeys) {
+  return Object.keys(record).every((key) => allowedKeys.has(key));
+}
+function hasWellFormedUnicode(text) {
+  for (let index = 0;index < text.length; index++) {
+    const codeUnit = text.charCodeAt(index);
+    if (codeUnit >= 55296 && codeUnit <= 56319) {
+      if (index + 1 >= text.length)
+        return false;
+      const lowSurrogate = text.charCodeAt(index + 1);
+      if (lowSurrogate < 56320 || lowSurrogate > 57343)
+        return false;
+      index++;
+    } else if (codeUnit >= 56320 && codeUnit <= 57343) {
+      return false;
+    }
+  }
+  return true;
+}
+function boundedText(candidate, maxLength) {
+  return typeof candidate === "string" && candidate.length > 0 && candidate.length <= maxLength && !/[\u0000-\u001f\u007f]/u.test(candidate) && hasWellFormedUnicode(candidate) ? candidate : null;
+}
+function matchingText(candidate, maxLength, pattern) {
+  const candidateText = boundedText(candidate, maxLength);
+  return candidateText && pattern.test(candidateText) ? candidateText : null;
+}
+function canonicalTimestamp(candidate) {
+  const timestamp = boundedText(candidate, 64);
+  if (!timestamp)
+    return null;
+  const milliseconds = Date.parse(timestamp);
+  return Number.isFinite(milliseconds) && new Date(milliseconds).toISOString() === timestamp ? timestamp : null;
+}
+function projectedSummary(project) {
+  const summary = {
+    id: matchingText(project.id, 128, SAFE_IDENTIFIER_PATTERN),
+    ref: matchingText(project.ref, 20, PROJECT_REF_PATTERN),
+    organization_id: matchingText(project.organization_id, 128, SAFE_IDENTIFIER_PATTERN),
+    organization_slug: matchingText(project.organization_slug, 128, SAFE_IDENTIFIER_PATTERN),
+    name: boundedText(project.name, 100),
+    region: matchingText(project.region, 64, REGION_PATTERN),
+    created_at: canonicalTimestamp(project.created_at),
+    status: matchingText(project.status, 64, STATUS_PATTERN)
+  };
+  return Object.values(summary).every((field) => field !== null) ? summary : null;
+}
+function projectSummary(candidate) {
+  const project = plainRecord(candidate);
+  return project && hasOnlyKeys(project, PROJECT_SUMMARY_KEYS) ? projectedSummary(project) : null;
+}
+function databaseHost(candidate) {
+  const host = boundedText(candidate, 255);
+  if (!host)
+    return null;
+  if (host.startsWith("[") && host.endsWith("]")) {
+    try {
+      const parsedHost = new URL(`http://${host}`);
+      return parsedHost.host === host ? host : null;
+    } catch (error) {
+      if (error instanceof TypeError)
+        return null;
+      throw error;
+    }
+  }
+  const ipv4Parts = host.split(".");
+  if (ipv4Parts.length === 4 && ipv4Parts.every((part) => /^\d{1,3}$/u.test(part))) {
+    return ipv4Parts.every((part) => Number(part) <= 255) ? host : null;
+  }
+  return ipv4Parts.every((label) => DNS_LABEL_PATTERN.test(label)) ? host : null;
+}
+function projectDatabase(candidate) {
+  const database = plainRecord(candidate);
+  if (!database || !hasOnlyKeys(database, PROJECT_DATABASE_KEYS))
+    return null;
+  const host = databaseHost(database.host);
+  const version = matchingText(database.version, 64, DATABASE_VERSION_PATTERN);
+  const postgresEngine = matchingText(database.postgres_engine, 64, DATABASE_VERSION_PATTERN);
+  const releaseChannel = matchingText(database.release_channel, 64, DATABASE_VERSION_PATTERN);
+  return host && version && postgresEngine && releaseChannel ? { host, version, postgres_engine: postgresEngine, release_channel: releaseChannel } : null;
+}
+function rawUrlHasNoPath(candidate) {
+  if (candidate.trim() !== candidate || candidate.includes("\\"))
+    return false;
+  const schemeEnd = candidate.indexOf("://");
+  const pathStart = candidate.indexOf("/", schemeEnd + 3);
+  return pathStart === -1;
+}
+function projectEndpoint(candidate) {
+  const endpoint = plainRecord(candidate);
+  if (!endpoint || !hasOnlyKeys(endpoint, PROJECT_ENDPOINT_KEYS))
+    return null;
+  const endpointUrl = boundedText(endpoint.url, 2048);
+  if (!endpointUrl || !rawUrlHasNoPath(endpointUrl))
+    return null;
+  try {
+    const url = new URL(endpointUrl);
+    if (url.protocol !== "http:" && url.protocol !== "https:" || url.username || url.password || url.search || url.hash || url.pathname !== "/")
+      return null;
+    return { url: url.origin };
+  } catch (error) {
+    if (error instanceof TypeError)
+      return null;
+    throw error;
+  }
+}
+function discardedDetailFieldsAreValid(project) {
+  if (project.config !== undefined && plainRecord(project.config) === null)
+    return false;
+  if (project.anon_key !== undefined && boundedText(project.anon_key, 16384) === null)
+    return false;
+  return project.services === undefined || Array.isArray(project.services);
+}
+function projectDetails(candidate, expectedRef) {
+  const project = plainRecord(candidate);
+  if (!project || !hasOnlyKeys(project, PROJECT_DETAILS_KEYS))
+    return null;
+  const summary = projectedSummary(project);
+  const database = projectDatabase(project.database);
+  const api = project.api === undefined ? undefined : projectEndpoint(project.api);
+  const studio = project.studio === undefined ? undefined : projectEndpoint(project.studio);
+  if (!summary || summary.ref !== expectedRef || !database || !discardedDetailFieldsAreValid(project) || project.api !== undefined && !api || project.studio !== undefined && !studio)
+    return null;
+  return {
+    ...summary,
+    database,
+    ...api ? { api } : {},
+    ...studio ? { studio } : {}
+  };
+}
+function payloadWithinLimit(candidate) {
+  try {
+    const serializedPayload = JSON.stringify(candidate);
+    return serializedPayload !== undefined && new TextEncoder().encode(serializedPayload).byteLength <= PROJECT_READ_RESPONSE_MAX_BYTES;
+  } catch {
+    return false;
+  }
+}
+function safeProjectList(candidate) {
+  if (!payloadWithinLimit(candidate) || !Array.isArray(candidate) || candidate.length > MAX_PROJECTS)
+    return null;
+  const safeProjects = [];
+  const ids = new Set;
+  const refs = new Set;
+  for (const projectCandidate of candidate) {
+    const project = projectSummary(projectCandidate);
+    if (!project || ids.has(project.id) || refs.has(project.ref))
+      return null;
+    ids.add(project.id);
+    refs.add(project.ref);
+    safeProjects.push(project);
+  }
+  return safeProjects;
+}
+function validHttpStatus(status) {
+  return Number.isSafeInteger(status) && status >= 100 && status <= 599;
+}
+function successfulResponse(response) {
+  return response.ok === true && validHttpStatus(response.status) && response.status >= 200 && response.status <= 299;
+}
+function failedResult(message) {
+  return { text: `❌ ${message}`, isError: true };
+}
+function failedHttpResult(label, status) {
+  return failedResult(validHttpStatus(status) ? `${label} request failed (${status})` : `${label} request failed`);
+}
+function successfulResult(payload) {
+  return { text: JSON.stringify(payload, null, 2), isError: false };
+}
+function projectListRead(response) {
+  if (!successfulResponse(response))
+    return failedHttpResult("Project list", response.status);
+  const projects = safeProjectList(response.data);
+  return projects ? successfulResult(projects) : failedResult("Invalid project list response");
+}
+function projectGetRead(response, expectedRef) {
+  if (!successfulResponse(response))
+    return failedHttpResult("Project get", response.status);
+  if (!payloadWithinLimit(response.data))
+    return failedResult("Invalid project response");
+  const project = projectDetails(response.data, expectedRef);
+  return project ? successfulResult(project) : failedResult("Invalid project response");
+}
 // src/shared/tools/project-cli-tools.ts
 var PROJECT_SERVICE_NAMES = [
   "postgrest",
@@ -29695,6 +30052,10 @@ var SUPPORTED_PROJECT_SERVICE_ACTIONS = {
 function projectToolResponse(text) {
   return { content: [{ type: "text", text }] };
 }
+function projectReadResponse(readResult) {
+  const response = projectToolResponse(readResult.text);
+  return readResult.isError ? { ...response, isError: true } : response;
+}
 function failedProjectServiceResponse(message) {
   return {
     content: [{ type: "text", text: `❌ ${message}` }],
@@ -30027,8 +30388,9 @@ function registerAdminProjectCliTools(server, http, options = {}) {
     let text;
     switch (action) {
       case "list":
-        text = ok(await http.get("/v1/projects"));
-        break;
+        return projectReadResponse(projectListRead(await http.get("/v1/projects", {
+          maxResponseBytes: PROJECT_READ_RESPONSE_MAX_BYTES
+        })));
       case "create": {
         if (!name)
           throw new Error("'name' is required for create");
@@ -30066,9 +30428,12 @@ function registerAdminProjectCliTools(server, http, options = {}) {
           createRequest.credential_delivery = "response";
         return projectCreateResponse(await http.post("/v1/projects", createRequest), preparedEnvFile, { projectName: name, apiOrigin: boundApiOrigin }, fileOperations);
       }
-      case "get":
-        text = ok(await http.get(`/v1/projects/${resolveRef(ref)}`));
-        break;
+      case "get": {
+        const resolvedRef = resolveRef(ref);
+        return projectReadResponse(projectGetRead(await http.get(`/v1/projects/${resolvedRef}`, {
+          maxResponseBytes: PROJECT_READ_RESPONSE_MAX_BYTES
+        }), resolvedRef));
+      }
       case "delete": {
         const resolvedRef = resolveRef(ref);
         text = simple(await http.delete(`/v1/projects/${resolvedRef}`), `Project ${resolvedRef} deleted`);
@@ -30472,7 +30837,7 @@ Actions: routes, upsert_route, update_route, delete_route, config, get_certifica
 // package.json
 var package_default = {
   name: "@supacloud/admin",
-  version: "0.10.1",
+  version: "0.11.0",
   description: "Platform administration CLI for SupaCloud operators",
   type: "module",
   main: "./dist/index.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supacloud/admin",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "description": "Platform administration CLI for SupaCloud operators",
   "type": "module",
   "main": "./dist/index.js",