@supacloud/cli 0.19.0 → 0.20.0

package/dist/index.js

@@ -6572,6 +6572,15 @@ var RELEASE_MUTATION_RESPONSE_TIMEOUT = 5000;
 var RELEASE_MUTATION_RESPONSE_MAX_BYTES = 64 * 1024;
 var MAX_RETRIES = 2;
 var RETRY_BASE_DELAY = 500;
+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 isRetryableMethod(method) {
   const normalizedMethod = (method ?? "GET").toUpperCase();
   return normalizedMethod === "GET" || normalizedMethod === "HEAD";
@@ -6787,12 +6796,13 @@ class HttpTransport {
     }
   }
   async get(path, options = {}) {
+    const maxResponseBytes = validatedGetResponseLimit(options);
     try {
       const res = await fetchWithRetry(`${this.baseUrl}${path}`, {
         method: "GET",
         headers: this.headers()
       });
-      const data = options.maxResponseBytes === undefined ? await res.json().catch(() => null) : await boundedResponseJson(res, options.maxResponseBytes);
+      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);
@@ -7957,14 +7967,15 @@ ${JSON.stringify(r.data, null, 2)}` : `❌ Failed (${r.status}): ${JSON.stringif
 var RELEASE_CONTROL_RESPONSE_SCHEMA = "supacloud.cli.release-control.v1";
 function releaseControlSuccess(operation, payload) {
   return releaseControlResponse({
+    ...payload,
     schema: RELEASE_CONTROL_RESPONSE_SCHEMA,
     ok: true,
-    operation,
-    ...payload
+    operation
   });
 }
-function releaseControlFailure(operation, code, httpStatus) {
+function releaseControlFailure(operation, code, httpStatus, safeState = {}) {
   return releaseControlErrorResponse({
+    ...safeState,
     schema: RELEASE_CONTROL_RESPONSE_SCHEMA,
     ok: false,
     operation,
@@ -9395,7 +9406,210 @@ Actions: list, get, create, update, delete, deploy_git, deploy_upload, redeploy,
   });
 }
 
+// src/shared/tools/project-read-projection.ts
+var PROJECT_READ_RESPONSE_MAX_BYTES = 1048576;
+var PROJECT_REF_PATTERN3 = /^[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 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_PATTERN3),
+    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 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 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 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
+function projectReadResponse(readResult) {
+  return {
+    content: [{ type: "text", text: readResult.text }],
+    ...readResult.isError ? { isError: true } : {}
+  };
+}
 var formatTasks = (data) => {
   if (!Array.isArray(data))
     return JSON.stringify(data, null, 2);
@@ -9551,8 +9765,9 @@ Actions: get, health, logs, api_keys, settings, tasks, task_detail, task_cancel,
     let text;
     switch (action) {
       case "get":
-        text = ok(await http.get(`/v1/projects/${resolvedRef}`));
-        break;
+        return projectReadResponse(projectGetRead(await http.get(`/v1/projects/${resolvedRef}`, {
+          maxResponseBytes: PROJECT_READ_RESPONSE_MAX_BYTES
+        }), resolvedRef));
       case "health":
         text = ok(await http.get(`/v1/projects/${resolvedRef}/health`));
         break;
@@ -11366,11 +11581,14 @@ var SCHEDULE_TOOL_SCHEMA = {
 var MUTATION_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
 var FINGERPRINT_PATTERN = /^[0-9a-f]{64}$/;
 var OPERATION_PATTERN = /^[a-z0-9][a-z0-9._:-]{0,127}$/;
-var RESOURCE_KEY_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,254}$/;
+var RESOURCE_KEY_PATTERN = /^v1\/(?:[a-z0-9][a-z0-9._-]{0,63})\/([A-Za-z0-9_-]{2,171})$/;
+var RESOURCE_ID_CONTROL_PATTERN = /[\u0000-\u001f\u007f-\u009f]/u;
 var FAILURE_CODE_PATTERN = /^[A-Z][A-Z0-9_]{0,63}$/;
 var LEASE_OWNER_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:@/-]{0,254}$/;
 var TIMESTAMP_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
 var MAX_STATUS_RESPONSE_BYTES = 196608;
+var MAX_RESOURCE_ID_BYTES = 128;
+var FATAL_UTF8_DECODER = new TextDecoder("utf-8", { fatal: true });
 var MUTATION_STATUSES = new Set([
   "pending",
   "running",
@@ -11415,14 +11633,14 @@ function emptyProjection(candidate) {
   const record = objectRecord3(candidate);
   return record && Object.keys(record).length === 0 ? record : null;
 }
-function canonicalTimestamp(candidate) {
+function canonicalTimestamp2(candidate) {
   if (typeof candidate !== "string" || !TIMESTAMP_PATTERN.test(candidate))
     return false;
   const milliseconds = Date.parse(candidate);
   return Number.isFinite(milliseconds) && new Date(milliseconds).toISOString() === candidate;
 }
 function nullableTimestamp(candidate) {
-  return candidate === null || canonicalTimestamp(candidate);
+  return candidate === null || canonicalTimestamp2(candidate);
 }
 function safePrincipal(candidate) {
   const principal = exactRecord(candidate, PRINCIPAL_KEYS);
@@ -11471,12 +11689,32 @@ function validMutationLifecycle(mutation, receipt, responseStatus) {
   }
   return true;
 }
+function canonicalMutationResourceKey(candidate) {
+  if (typeof candidate !== "string")
+    return false;
+  const match = RESOURCE_KEY_PATTERN.exec(candidate);
+  if (!match)
+    return false;
+  const encodedResourceId = match[1];
+  const resourceIdBytes = Buffer.from(encodedResourceId, "base64url");
+  if (resourceIdBytes.byteLength < 1 || resourceIdBytes.byteLength > MAX_RESOURCE_ID_BYTES || resourceIdBytes.toString("base64url") !== encodedResourceId)
+    return false;
+  let resourceId;
+  try {
+    resourceId = FATAL_UTF8_DECODER.decode(resourceIdBytes);
+  } catch (decodeError) {
+    if (decodeError instanceof TypeError)
+      return false;
+    throw decodeError;
+  }
+  return resourceId.trim() === resourceId && !RESOURCE_ID_CONTROL_PATTERN.test(resourceId) && Buffer.from(resourceId, "utf8").equals(resourceIdBytes);
+}
 function validMutationIdentity(mutation) {
   if (!isMutationId(mutation.mutation_id) || typeof mutation.project_ref !== "string")
     return false;
   if (typeof mutation.operation !== "string" || !OPERATION_PATTERN.test(mutation.operation))
     return false;
-  if (mutation.resource_key !== null && (typeof mutation.resource_key !== "string" || !RESOURCE_KEY_PATTERN.test(mutation.resource_key)))
+  if (mutation.resource_key !== null && !canonicalMutationResourceKey(mutation.resource_key))
     return false;
   return typeof mutation.request_fingerprint === "string" && FINGERPRINT_PATTERN.test(mutation.request_fingerprint);
 }
@@ -11485,7 +11723,7 @@ function validMutationTerminalFields(mutation) {
     return false;
   if (mutation.failure_code !== null && (typeof mutation.failure_code !== "string" || !FAILURE_CODE_PATTERN.test(mutation.failure_code)))
     return false;
-  return nullableTimestamp(mutation.completed_at) && canonicalTimestamp(mutation.created_at) && canonicalTimestamp(mutation.updated_at);
+  return nullableTimestamp(mutation.completed_at) && canonicalTimestamp2(mutation.created_at) && canonicalTimestamp2(mutation.updated_at);
 }
 function safeMutationStatus(candidate) {
   const mutation = exactRecord(candidate, MUTATION_KEYS);
@@ -11557,6 +11795,12 @@ async function mutationStatus(http, args) {
   if (readback.kind === "invalid") {
     return releaseControlFailure("mutations.status", "INVALID_RESPONSE", null);
   }
+  if (readback.mutation.status !== "succeeded") {
+    return releaseControlFailure("mutations.status", "MUTATION_NOT_SUCCEEDED", null, {
+      project_ref: ref,
+      mutation: readback.mutation
+    });
+  }
   return releaseControlSuccess("mutations.status", { project_ref: ref, mutation: readback.mutation });
 }
 function registerMutationTools(server, http) {
@@ -11570,7 +11814,7 @@ var MUTATION_TOOL_SCHEMA = {
 // package.json
 var package_default = {
   name: "@supacloud/cli",
-  version: "0.19.0",
+  version: "0.20.0",
   description: "Project-scoped CLI for SupaCloud users",
   type: "module",
   main: "./dist/index.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supacloud/cli",
-  "version": "0.19.0",
+  "version": "0.20.0",
   "description": "Project-scoped CLI for SupaCloud users",
   "type": "module",
   "main": "./dist/index.js",