@supacloud/admin 0.10.0 → 0.10.2

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

@@ -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)
@@ -27073,7 +27092,7 @@ function buildRemotePreflightScript() {
     "test -d /run/lock || { echo '/run/lock is unavailable' >&2; exit 1; }",
     "test -d /var/lib/supacloud || { echo '/var/lib/supacloud is unavailable' >&2; exit 1; }",
     "test -f /etc/supabase/management-api.env || { echo 'EDGE_RUNTIME_MODE is unavailable' >&2; exit 1; }",
-    `EDGE_MODE=$(awk -F= '$1 == "EDGE_RUNTIME_MODE" { value=$2 } END { gsub(/^[[:space:]\\"'"']+|[[:space:]\\"'"']+$/, "", value); print value }' /etc/supabase/management-api.env)`,
+    `EDGE_MODE=$(awk -F= '$1 == "EDGE_RUNTIME_MODE" { value=substr($0, index($0, "=") + 1) } END { gsub(/^[[:space:]\\042\\047]+|[[:space:]\\042\\047]+$/, "", value); print value }' /etc/supabase/management-api.env)`,
     `test "$EDGE_MODE" = external || { echo 'Local component upgrade requires persisted external Edge Runtime mode' >&2; exit 1; }`,
     `case "$(uname -m)" in x86_64|amd64) echo ARCH=amd64 ;; aarch64|arm64) echo ARCH=arm64 ;; *) echo 'Unsupported remote architecture' >&2; exit 1 ;; esac`,
     "VERIFIER=bundled",
@@ -27722,8 +27741,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;
@@ -27902,7 +27923,7 @@ function componentBootstrapCommands(request) {
 function componentPreflightCommands(request) {
   return request.edgeRuntimeVersion ? [
     "test -f /etc/supabase/management-api.env || { echo 'EDGE_RUNTIME_MODE is unavailable; component upgrade requires external mode' >&2; exit 1; }",
-    `EDGE_RUNTIME_MODE_VALUE=$(awk -F= '$1 == "EDGE_RUNTIME_MODE" { value=$2 } END { gsub(/^[[:space:]\\"'"']+|[[:space:]\\"'"']+$/, "", value); print value }' /etc/supabase/management-api.env)`,
+    `EDGE_RUNTIME_MODE_VALUE=$(awk -F= '$1 == "EDGE_RUNTIME_MODE" { value=substr($0, index($0, "=") + 1) } END { gsub(/^[[:space:]\\042\\047]+|[[:space:]\\042\\047]+$/, "", value); print value }' /etc/supabase/management-api.env)`,
     `test "$EDGE_RUNTIME_MODE_VALUE" = external || { echo 'Edge Runtime component upgrade supports persisted external mode only' >&2; exit 1; }`
   ] : [];
 }
@@ -27996,11 +28017,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 +28089,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) {
@@ -30472,7 +30543,7 @@ Actions: routes, upsert_route, update_route, delete_route, config, get_certifica
 // package.json
 var package_default = {
   name: "@supacloud/admin",
-  version: "0.10.0",
+  version: "0.10.2",
   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.0",
+  "version": "0.10.2",
   "description": "Platform administration CLI for SupaCloud operators",
   "type": "module",
   "main": "./dist/index.js",