@h-ai/cli 0.1.0-alpha.53 → 0.1.0-alpha.54

package/dist/{src-QNEJJ3BV.js → src-6ZBWDBUB.js}

@@ -14542,7 +14542,9 @@ var en_US_default = {
   deploy_credentialMissing: "Missing credential fields: {fields}",
   deploy_apiError: "{service} API error ({status})",
   deploy_fileUploadFailed: "File upload failed ({status})",
-  deploy_provisionNoResult: "No connection info returned from {service}"
+  deploy_provisionNoResult: "No connection info returned from {service}",
+  deploy_recoveryFailure: "Deployment stopped at {stage}; inspect the recovery details.",
+  deploy_recoverySuggestion: "Inspect listed resources in the provider console before retrying with the same project name. Unknown means the request may have created a resource. Reused resources are never deleted automatically; remove newly created resources manually only after checking their use."
 };
 
 // ../deploy/messages/zh-CN.json
@@ -14570,7 +14572,9 @@ var zh_CN_default2 = {
   deploy_credentialMissing: "\u7F3A\u5C11\u51ED\u8BC1\u5B57\u6BB5\uFF1A{fields}",
   deploy_apiError: "{service} API \u8BF7\u6C42\u5931\u8D25\uFF08{status}\uFF09",
   deploy_fileUploadFailed: "\u6587\u4EF6\u4E0A\u4F20\u5931\u8D25\uFF08{status}\uFF09",
-  deploy_provisionNoResult: "{service} \u672A\u8FD4\u56DE\u8FDE\u63A5\u4FE1\u606F"
+  deploy_provisionNoResult: "{service} \u672A\u8FD4\u56DE\u8FDE\u63A5\u4FE1\u606F",
+  deploy_recoveryFailure: "\u90E8\u7F72\u5728 {stage} \u9636\u6BB5\u505C\u6B62\uFF0C\u8BF7\u67E5\u770B\u6062\u590D\u6E05\u5355\u3002",
+  deploy_recoverySuggestion: "\u91CD\u8BD5\u524D\u5728\u670D\u52A1\u5546\u63A7\u5236\u53F0\u6838\u5BF9\u6E05\u5355\uFF0C\u5E76\u4F7F\u7528\u76F8\u540C\u9879\u76EE\u540D\u3002unknown \u8868\u793A\u8BF7\u6C42\u53EF\u80FD\u5DF2\u521B\u5EFA\u8D44\u6E90\u3002\u590D\u7528\u8D44\u6E90\u4E0D\u4F1A\u81EA\u52A8\u5220\u9664\uFF1B\u65B0\u5EFA\u8D44\u6E90\u4EC5\u5728\u786E\u8BA4\u672A\u88AB\u4F7F\u7528\u540E\u4EBA\u5DE5\u6E05\u7406\u3002"
 };
 
 // ../deploy/src/deploy-i18n.ts
@@ -14598,15 +14602,19 @@ var UpstashServiceSchema = external_exports.object({
 });
 var R2ServiceSchema = external_exports.object({
   provisioner: external_exports.literal("cloudflare-r2"),
+  accessKeyId: external_exports.string().min(1),
+  secretAccessKey: external_exports.string().min(1),
   accountId: external_exports.string().min(1),
   apiToken: external_exports.string().min(1)
 });
 var ResendServiceSchema = external_exports.object({
   provisioner: external_exports.literal("resend"),
+  from: external_exports.string().email(),
   apiKey: external_exports.string().min(1)
 });
 var AliyunSmsServiceSchema = external_exports.object({
   provisioner: external_exports.literal("aliyun"),
+  signName: external_exports.string().min(1),
   accessKeyId: external_exports.string().min(1),
   accessKeySecret: external_exports.string().min(1)
 });
@@ -14761,13 +14769,13 @@ function saveCredentials(entries) {
   }
 }
 var logger2 = core.logger.child({ module: "deploy", scope: "functions" });
-function buildApp(appDir, buildCommand) {
+function buildApp(appDir, buildCommand, envVars = {}) {
   logger2.info("Building application", { appDir, buildCommand });
   try {
     execSync(buildCommand, {
       cwd: appDir,
       stdio: "inherit",
-      env: { ...process2.env }
+      env: { ...process2.env, ...envVars }
     });
     return ok(void 0);
   } catch (error51) {
@@ -14793,6 +14801,32 @@ function resolveOutputDir(appDir, providerType) {
       return join(appDir, "build");
   }
 }
+var RecoverySchema = external_exports.object({
+  projectName: external_exports.string(),
+  stage: external_exports.string(),
+  platformProjectId: external_exports.string().optional(),
+  resources: external_exports.array(external_exports.object({
+    serviceType: external_exports.enum(["db", "cache", "storage", "email", "sms"]),
+    provisionerName: external_exports.string(),
+    resourceInfo: external_exports.string(),
+    resourceStatus: external_exports.enum(["created", "reused", "unknown"])
+  }))
+});
+function getDeployRecovery(error51) {
+  const parsed = RecoverySchema.safeParse(error51.ext?.recovery);
+  return parsed.success ? parsed.data : void 0;
+}
+function recoveryFailure(error51, recovery) {
+  return err({
+    code: error51.code,
+    httpStatus: error51.httpStatus,
+    system: error51.system,
+    module: error51.module,
+    message: deployM("deploy_recoveryFailure", { params: { stage: recovery.stage } }),
+    suggestion: deployM("deploy_recoverySuggestion"),
+    ext: { recovery }
+  });
+}
 var logger3 = core.logger.child({ module: "deploy", scope: "scanner" });
 function readYaml(filePath) {
   if (!existsSync(filePath)) {
@@ -15204,6 +15238,7 @@ var logger5 = core.logger.child({ module: "deploy", scope: "provisioner-aliyun"
 function createAliyunProvisioner() {
   let accessKey = null;
   let secretKey = null;
+  let signName = "";
   return {
     name: "aliyun",
     serviceType: "sms",
@@ -15212,11 +15247,12 @@ function createAliyunProvisioner() {
       try {
         const akId = credentials.accessKeyId ?? credentials.access_key_id ?? credentials.access_key ?? "";
         const akSecret = credentials.accessKeySecret ?? credentials.access_key_secret ?? credentials.secret_key ?? "";
-        if (!akId || !akSecret) {
-          throw new Error(deployM("deploy_credentialMissing", { params: { fields: "access_key_id, access_key_secret" } }));
+        if (!akId || !akSecret || !credentials.signName) {
+          throw new Error(deployM("deploy_credentialMissing", { params: { fields: "accessKeyId, accessKeySecret, signName" } }));
         }
         accessKey = akId;
         secretKey = akSecret;
+        signName = credentials.signName;
         logger5.info("Aliyun authenticated", { accessKeyId: `${akId.slice(0, 6)}***` });
         return ok(akId);
       } catch (error51) {
@@ -15241,9 +15277,9 @@ function createAliyunProvisioner() {
       return ok({
         serviceType: "sms",
         provisionerName: "aliyun",
+        resourceStatus: "reused",
         envVars: {
-          HAI_REACH_SMS_ACCESS_KEY: accessKey,
-          HAI_REACH_SMS_SECRET_KEY: secretKey
+          HAI_REACH_PROVIDERS: JSON.stringify([{ name: "sms", type: "aliyun-sms", accessKeyId: accessKey, accessKeySecret: secretKey, signName }])
         },
         resourceInfo: "aliyun:verify-only"
       });
@@ -15292,12 +15328,13 @@ async function getNeonConnectionUri(token, projectId) {
   }
   return data.uri;
 }
-function buildNeonProvisionResult(projectId, connectionUri) {
+function buildNeonProvisionResult(projectId, connectionUri, resourceStatus) {
   return {
     serviceType: "db",
     provisionerName: "neon",
+    resourceStatus,
     envVars: {
-      HAI_RELDB_URL: connectionUri
+      HAI_DB: JSON.stringify({ type: "postgresql", url: connectionUri, database: decodeURIComponent(new URL(connectionUri).pathname.slice(1)) })
     },
     resourceInfo: `neon-project:${projectId}`
   };
@@ -15337,16 +15374,18 @@ function createNeonProvisioner() {
         );
       }
       logger6.debug("Provisioning Neon database", { appName });
+      let resource;
       try {
         const projectName = `${appName}-db`;
         const existingProject = await findExistingNeonProject(token, projectName);
         if (existingProject !== null) {
+          resource = { resourceInfo: `neon-project:${existingProject.id}`, resourceStatus: "reused" };
           const connectionUri2 = await getNeonConnectionUri(token, existingProject.id);
           logger6.info("Neon project reused", {
             projectId: existingProject.id,
             projectName
           });
-          return ok(buildNeonProvisionResult(existingProject.id, connectionUri2));
+          return ok(buildNeonProvisionResult(existingProject.id, connectionUri2, "reused"));
         }
         const data = await neonFetch(token, "/projects", {
           method: "POST",
@@ -15358,14 +15397,23 @@ function createNeonProvisioner() {
           })
         });
         const projectId = data.project?.id ?? "";
+        if (projectId)
+          resource = { resourceInfo: `neon-project:${projectId}`, resourceStatus: "created" };
         const connectionUri = data.connection_uris?.[0]?.connection_uri ?? "";
         if (!projectId || !connectionUri) {
           throw new Error(deployM("deploy_provisionNoResult", { params: { service: "Neon" } }));
         }
         logger6.info("Neon database provisioned", { projectId });
-        return ok(buildNeonProvisionResult(projectId, connectionUri));
+        return ok(buildNeonProvisionResult(projectId, connectionUri, "created"));
       } catch (error51) {
-        logger6.error("Neon provisioning failed", { appName, error: error51 });
+        logger6.error("Neon provisioning failed", { appName });
+        if (resource) {
+          return recoveryFailure({ ...HaiDeployError.PROVISION_FAILED}, {
+            projectName: appName,
+            stage: "provision:db",
+            resources: [{ serviceType: "db", provisionerName: "neon", ...resource }]
+          });
+        }
         return err(
           HaiDeployError.PROVISION_FAILED,
           deployM("deploy_provisionFailed", {
@@ -15385,6 +15433,8 @@ var CF_API = "https://api.cloudflare.com/client/v4";
 function createR2Provisioner() {
   let token = null;
   let accountId = null;
+  let accessKey = "";
+  let secretKey = "";
   return {
     name: "r2",
     serviceType: "storage",
@@ -15393,8 +15443,8 @@ function createR2Provisioner() {
       try {
         const acctId = credentials.accountId ?? credentials.account_id ?? "";
         const apiTok = credentials.apiToken ?? credentials.api_token ?? credentials.token ?? "";
-        if (!acctId || !apiTok) {
-          throw new Error(deployM("deploy_credentialMissing", { params: { fields: "account_id, api_token" } }));
+        if (!acctId || !apiTok || !credentials.accessKeyId || !credentials.secretAccessKey) {
+          throw new Error(deployM("deploy_credentialMissing", { params: { fields: "accountId, apiToken, accessKeyId, secretAccessKey" } }));
         }
         const res = await fetch(`${CF_API}/accounts/${acctId}/r2/buckets`, {
           headers: { Authorization: `Bearer ${apiTok}` }
@@ -15404,6 +15454,8 @@ function createR2Provisioner() {
         }
         accountId = acctId;
         token = apiTok;
+        accessKey = credentials.accessKeyId;
+        secretKey = credentials.secretAccessKey;
         logger7.info("Cloudflare R2 authenticated", { accountId: acctId });
         return ok(acctId);
       } catch (error51) {
@@ -15441,42 +15493,20 @@ function createR2Provisioner() {
         if (!createRes.ok && createRes.status !== 409) {
           throw new Error(deployM("deploy_apiError", { params: { service: "Cloudflare", status: String(createRes.status) } }));
         }
-        const tokenRes = await fetch(
-          `${CF_API}/user/tokens`,
-          {
-            method: "POST",
-            headers: {
-              "Authorization": `Bearer ${token}`,
-              "Content-Type": "application/json"
-            },
-            body: JSON.stringify({
-              name: `${appName}-r2-token`,
-              policies: [{
-                effect: "allow",
-                permission_groups: [{ id: "r2-read-write" }],
-                resources: { [`com.cloudflare.edge.r2.bucket.${accountId}_default_${bucketName}`]: "*" }
-              }]
-            })
-          }
-        );
-        if (!tokenRes.ok) {
-          throw new Error(deployM("deploy_apiError", { params: { service: "Cloudflare", status: String(tokenRes.status) } }));
-        }
-        const tokenData = await tokenRes.json();
-        const accessKey = tokenData.result?.id ?? "";
-        const secretKey = tokenData.result?.value ?? "";
-        if (!accessKey || !secretKey) {
-          throw new Error(deployM("deploy_provisionNoResult", { params: { service: "Cloudflare R2" } }));
-        }
         logger7.info("R2 bucket provisioned", { bucketName });
         return ok({
           serviceType: "storage",
           provisionerName: "r2",
+          resourceStatus: createRes.status === 409 ? "reused" : "created",
           envVars: {
-            HAI_STORAGE_S3_ENDPOINT: `https://${accountId}.r2.cloudflarestorage.com`,
-            HAI_STORAGE_S3_BUCKET: bucketName,
-            HAI_STORAGE_S3_ACCESS_KEY: accessKey,
-            HAI_STORAGE_S3_SECRET_KEY: secretKey
+            HAI_STORAGE: JSON.stringify({
+              type: "s3",
+              endpoint: `https://${accountId}.r2.cloudflarestorage.com`,
+              bucket: bucketName,
+              region: "auto",
+              accessKeyId: accessKey,
+              secretAccessKey: secretKey
+            })
           },
           resourceInfo: `r2-bucket:${bucketName}`
         });
@@ -15500,6 +15530,7 @@ var logger8 = core.logger.child({ module: "deploy", scope: "provisioner-resend"
 var RESEND_API = "https://api.resend.com";
 function createResendProvisioner() {
   let token = null;
+  let from = "";
   return {
     name: "resend",
     serviceType: "email",
@@ -15507,8 +15538,8 @@ function createResendProvisioner() {
       logger8.debug("Authenticating with Resend");
       try {
         const apiToken = credentials.apiKey ?? credentials.api_key ?? credentials.token ?? "";
-        if (!apiToken) {
-          throw new Error(deployM("deploy_credentialMissing", { params: { fields: "api_key" } }));
+        if (!apiToken || !credentials.from) {
+          throw new Error(deployM("deploy_credentialMissing", { params: { fields: "apiKey, from" } }));
         }
         const res = await fetch(`${RESEND_API}/domains`, {
           headers: { Authorization: `Bearer ${apiToken}` }
@@ -15517,6 +15548,7 @@ function createResendProvisioner() {
           throw new Error(deployM("deploy_apiError", { params: { service: "Resend", status: String(res.status) } }));
         }
         token = apiToken;
+        from = credentials.from;
         logger8.info("Resend authenticated");
         return ok("resend-user");
       } catch (error51) {
@@ -15541,8 +15573,9 @@ function createResendProvisioner() {
       return ok({
         serviceType: "email",
         provisionerName: "resend",
+        resourceStatus: "reused",
         envVars: {
-          HAI_REACH_RESEND_KEY: token
+          HAI_REACH_PROVIDERS: JSON.stringify([{ name: "email", type: "smtp", host: "smtp.resend.com", port: 465, secure: true, user: "resend", pass: token, from }])
         },
         resourceInfo: "resend:verify-only"
       });
@@ -15578,38 +15611,17 @@ async function findExistingUpstashDatabase(email3, apiKey, databaseName) {
 async function getUpstashDatabase(email3, apiKey, databaseId) {
   return upstashFetch(email3, apiKey, `/v2/redis/database/${databaseId}`);
 }
-function resolveUpstashRestUrl(database) {
-  if (typeof database.rest_url === "string" && database.rest_url.length > 0) {
-    return database.rest_url;
-  }
-  const endpoint = database.endpoint?.trim() ?? "";
-  if (!endpoint) {
-    return "";
-  }
-  if (endpoint.startsWith("http://") || endpoint.startsWith("https://")) {
-    return endpoint;
-  }
-  if (endpoint.includes(".")) {
-    return `https://${endpoint}`;
-  }
-  return `https://${endpoint}.upstash.io`;
-}
-function resolveUpstashRestToken(database) {
-  return database.rest_token ?? database.token ?? database.password ?? "";
-}
-function buildUpstashProvisionResult(database) {
+function buildUpstashProvisionResult(database, resourceStatus) {
   const databaseId = database.database_id ?? "";
-  const restUrl = resolveUpstashRestUrl(database);
-  const restToken = resolveUpstashRestToken(database);
-  if (!databaseId || !restUrl || !restToken) {
+  if (!databaseId || !database.endpoint || !database.password || !database.port) {
     throw new Error(deployM("deploy_provisionNoResult", { params: { service: "Upstash" } }));
   }
   return {
     serviceType: "cache",
     provisionerName: "upstash",
+    resourceStatus,
     envVars: {
-      HAI_CACHE_UPSTASH_URL: restUrl,
-      HAI_CACHE_UPSTASH_TOKEN: restToken
+      HAI_CACHE: JSON.stringify({ type: "redis", url: `rediss://default:${encodeURIComponent(database.password)}@${database.endpoint}:${database.port}` })
     },
     resourceInfo: `upstash-db:${databaseId}`
   };
@@ -15652,6 +15664,7 @@ function createUpstashProvisioner() {
         );
       }
       logger9.debug("Provisioning Upstash Redis", { appName });
+      let resource;
       try {
         const databaseName = `${appName}-cache`;
         const existingDatabase = await findExistingUpstashDatabase(email3, apiKey, databaseName);
@@ -15660,9 +15673,10 @@ function createUpstashProvisioner() {
           if (!databaseId) {
             throw new Error(deployM("deploy_provisionNoResult", { params: { service: "Upstash" } }));
           }
+          resource = { resourceInfo: `upstash-db:${databaseId}`, resourceStatus: "reused" };
           const detail = await getUpstashDatabase(email3, apiKey, databaseId);
           logger9.info("Upstash Redis reused", { databaseId, databaseName });
-          return ok(buildUpstashProvisionResult({ ...existingDatabase, ...detail }));
+          return ok(buildUpstashProvisionResult({ ...existingDatabase, ...detail }, "reused"));
         }
         const data = await upstashFetch(email3, apiKey, "/v2/redis/database", {
           method: "POST",
@@ -15672,10 +15686,19 @@ function createUpstashProvisioner() {
             tls: true
           })
         });
+        if (data.database_id)
+          resource = { resourceInfo: `upstash-db:${data.database_id}`, resourceStatus: "created" };
         logger9.info("Upstash Redis provisioned", { databaseId: data.database_id });
-        return ok(buildUpstashProvisionResult(data));
+        return ok(buildUpstashProvisionResult(data, "created"));
       } catch (error51) {
-        logger9.error("Upstash provisioning failed", { appName, error: error51 });
+        logger9.error("Upstash provisioning failed", { appName });
+        if (resource) {
+          return recoveryFailure({ ...HaiDeployError.PROVISION_FAILED}, {
+            projectName: appName,
+            stage: "provision:cache",
+            resources: [{ serviceType: "cache", provisionerName: "upstash", ...resource }]
+          });
+        }
         return err(
           HaiDeployError.PROVISION_FAILED,
           deployM("deploy_provisionFailed", {
@@ -15856,9 +15879,18 @@ var deploy = {
         logger10.error("Service provisioning failed", {
           serviceType,
           provisioner: provisioner.name,
-          error: provResult.error
+          code: provResult.error.code
+        });
+        return recoveryFailure(provResult.error, {
+          projectName,
+          stage: `provision:${serviceType}`,
+          resources: [
+            ...results.map(({ envVars: _envVars, ...resource }) => resource),
+            ...getDeployRecovery(provResult.error)?.resources ?? [
+              { serviceType, provisionerName: provisioner.name, resourceInfo: projectName, resourceStatus: "unknown" }
+            ]
+          ]
         });
-        return err(provResult.error);
       }
       results.push(provResult.data);
       logger10.info("Service provisioned", { serviceType, provisioner: provisioner.name });
@@ -15885,36 +15917,44 @@ var deploy = {
       );
     }
     let allEnvVars = {};
+    const recovery = { projectName, stage: "provision", resources: [] };
     if (!options?.skipProvision) {
       const provResults = await deploy.provisionAll(projectName);
       if (!provResults.success) {
         return err(provResults.error);
       }
+      recovery.resources = provResults.data.map(({ envVars: _envVars, ...resource }) => resource);
+      const reachProviders = [];
       for (const prov of provResults.data) {
+        if (prov.envVars.HAI_REACH_PROVIDERS)
+          reachProviders.push(...JSON.parse(prov.envVars.HAI_REACH_PROVIDERS));
         allEnvVars = { ...allEnvVars, ...prov.envVars };
       }
+      if (reachProviders.length > 0)
+        allEnvVars.HAI_REACH_PROVIDERS = JSON.stringify(reachProviders);
     }
     const projectResult = await currentProvider.createProject(projectName);
     if (!projectResult.success) {
-      return err(projectResult.error);
+      return recoveryFailure(projectResult.error, { ...recovery, stage: "create-project" });
     }
     const projectId = projectResult.data;
+    recovery.platformProjectId = projectId;
     if (Object.keys(allEnvVars).length > 0) {
       const envResult = await currentProvider.setEnvVars(projectId, allEnvVars);
       if (!envResult.success) {
-        return err(envResult.error);
+        return recoveryFailure(envResult.error, { ...recovery, stage: "set-env" });
       }
     }
     if (!options?.skipBuild) {
-      const buildResult = buildApp(appDir, scan.buildCommand);
+      const buildResult = buildApp(appDir, scan.buildCommand, allEnvVars);
       if (!buildResult.success) {
-        return err(buildResult.error);
+        return recoveryFailure(buildResult.error, { ...recovery, stage: "build" });
       }
     }
     const outputDir = resolveOutputDir(appDir, currentConfig?.provider.type ?? "vercel");
     const deployResult = await currentProvider.deploy(projectId, outputDir);
     if (!deployResult.success) {
-      return err(deployResult.error);
+      return recoveryFailure(deployResult.error, { ...recovery, stage: "deploy" });
     }
     const result = {
       ...deployResult.data,
@@ -15929,6 +15969,6 @@ var deploy = {
   }
 };
 
-export { DeployConfigSchema, HaiDeployError, ProviderConfigSchema, deploy };
-//# sourceMappingURL=src-QNEJJ3BV.js.map
-//# sourceMappingURL=src-QNEJJ3BV.js.map
+export { DeployConfigSchema, HaiDeployError, ProviderConfigSchema, deploy, getDeployRecovery };
+//# sourceMappingURL=src-6ZBWDBUB.js.map
+//# sourceMappingURL=src-6ZBWDBUB.js.map