@supacloud/admin 0.10.2 → 0.11.0

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
@@ -26030,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 {
@@ -26078,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);
@@ -29717,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",
@@ -29766,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}` }],
@@ -30098,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");
@@ -30137,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`);
@@ -30543,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.2",
+  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.2",
+  "version": "0.11.0",
   "description": "Platform administration CLI for SupaCloud operators",
   "type": "module",
   "main": "./dist/index.js",