@h-ai/deploy 0.1.0-alpha5

package/dist/index.js

@@ -0,0 +1,1270 @@
+import { z } from 'zod';
+import { core, ok, err } from '@h-ai/core';
+import { existsSync, readFileSync, writeFileSync, readdirSync, mkdirSync, statSync } from 'fs';
+import { homedir } from 'os';
+import { join, dirname, relative } from 'path';
+import process from 'process';
+import { parse, stringify } from 'yaml';
+import { execSync } from 'child_process';
+import { createHash } from 'crypto';
+
+// src/deploy-config.ts
+
+// messages/en-US.json
+var en_US_default = {
+  deploy_notInitialized: "Deploy module not initialized, call deploy.init() first",
+  deploy_initFailed: "Deploy module initialization failed: {error}",
+  deploy_unsupportedProviderType: "Unsupported deploy provider type: {type}",
+  deploy_unsupportedProvisionerType: "Unsupported service provisioner type: {type}",
+  deploy_configTokenRequired: "Deploy provider token is required",
+  deploy_authRequired: "Authentication required",
+  deploy_authFailed: "Authentication failed: {error}",
+  deploy_projectCreateFailed: "Project creation failed: {error}",
+  deploy_buildFailed: "Application build failed: {error}",
+  deploy_uploadFailed: "Build output upload failed: {error}",
+  deploy_deployFailed: "Deployment failed: {error}",
+  deploy_provisionFailed: "Service provisioning failed: {service} - {error}",
+  deploy_adapterMissing: "Target platform adapter not found, please install {adapter}",
+  deploy_scanFailed: "Application scan failed: {error}",
+  deploy_envVarFailed: "Environment variable setup failed: {error}",
+  deploy_credentialError: "Credential read/write failed: {error}",
+  deploy_credentialSaved: "Credentials saved",
+  deploy_credentialLoaded: "Credentials loaded",
+  deploy_configError: "Deploy config error: {error}",
+  deploy_credentialMissing: "Missing credential fields: {fields}",
+  deploy_apiError: "{service} API error ({status}): {body}",
+  deploy_fileUploadFailed: "File upload failed ({status}): {body}",
+  deploy_provisionNoResult: "No connection info returned from {service}"
+};
+
+// messages/zh-CN.json
+var zh_CN_default = {
+  deploy_notInitialized: "Deploy \u6A21\u5757\u5C1A\u672A\u521D\u59CB\u5316\uFF0C\u8BF7\u5148\u8C03\u7528 deploy.init()",
+  deploy_initFailed: "Deploy \u6A21\u5757\u521D\u59CB\u5316\u5931\u8D25\uFF1A{error}",
+  deploy_unsupportedProviderType: "\u4E0D\u652F\u6301\u7684\u90E8\u7F72\u5E73\u53F0\u7C7B\u578B\uFF1A{type}",
+  deploy_unsupportedProvisionerType: "\u4E0D\u652F\u6301\u7684\u670D\u52A1 Provisioner \u7C7B\u578B\uFF1A{type}",
+  deploy_configTokenRequired: "\u90E8\u7F72\u5E73\u53F0 Token \u4E0D\u80FD\u4E3A\u7A7A",
+  deploy_authRequired: "\u8BF7\u5148\u5B8C\u6210\u8BA4\u8BC1",
+  deploy_authFailed: "\u8BA4\u8BC1\u5931\u8D25\uFF1A{error}",
+  deploy_projectCreateFailed: "\u9879\u76EE\u521B\u5EFA\u5931\u8D25\uFF1A{error}",
+  deploy_buildFailed: "\u5E94\u7528\u6784\u5EFA\u5931\u8D25\uFF1A{error}",
+  deploy_uploadFailed: "\u6784\u5EFA\u4EA7\u7269\u4E0A\u4F20\u5931\u8D25\uFF1A{error}",
+  deploy_deployFailed: "\u90E8\u7F72\u5931\u8D25\uFF1A{error}",
+  deploy_provisionFailed: "\u57FA\u7840\u8BBE\u65BD\u5F00\u901A\u5931\u8D25\uFF1A{service} - {error}",
+  deploy_adapterMissing: "\u672A\u68C0\u6D4B\u5230\u76EE\u6807\u5E73\u53F0 adapter\uFF0C\u8BF7\u5B89\u88C5 {adapter}",
+  deploy_scanFailed: "\u5E94\u7528\u626B\u63CF\u5931\u8D25\uFF1A{error}",
+  deploy_envVarFailed: "\u73AF\u5883\u53D8\u91CF\u8BBE\u7F6E\u5931\u8D25\uFF1A{error}",
+  deploy_credentialError: "\u51ED\u8BC1\u8BFB\u5199\u5931\u8D25\uFF1A{error}",
+  deploy_credentialSaved: "\u51ED\u8BC1\u5DF2\u4FDD\u5B58",
+  deploy_credentialLoaded: "\u51ED\u8BC1\u5DF2\u52A0\u8F7D",
+  deploy_configError: "\u90E8\u7F72\u914D\u7F6E\u9519\u8BEF\uFF1A{error}",
+  deploy_credentialMissing: "\u7F3A\u5C11\u51ED\u8BC1\u5B57\u6BB5\uFF1A{fields}",
+  deploy_apiError: "{service} API \u8BF7\u6C42\u5931\u8D25\uFF08{status}\uFF09\uFF1A{body}",
+  deploy_fileUploadFailed: "\u6587\u4EF6\u4E0A\u4F20\u5931\u8D25\uFF08{status}\uFF09\uFF1A{body}",
+  deploy_provisionNoResult: "{service} \u672A\u8FD4\u56DE\u8FDE\u63A5\u4FE1\u606F"
+};
+
+// src/deploy-i18n.ts
+var deployM = core.i18n.createMessageGetter({
+  "zh-CN": zh_CN_default,
+  "en-US": en_US_default
+});
+
+// src/deploy-config.ts
+var VercelProviderConfigSchema = z.object({
+  type: z.literal("vercel"),
+  token: z.string().min(1, deployM("deploy_configTokenRequired"))
+});
+var ProviderConfigSchema = z.discriminatedUnion("type", [
+  VercelProviderConfigSchema
+]);
+var NeonServiceSchema = z.object({
+  provisioner: z.literal("neon"),
+  apiKey: z.string().min(1)
+});
+var UpstashServiceSchema = z.object({
+  provisioner: z.literal("upstash"),
+  email: z.string().email(),
+  apiKey: z.string().min(1)
+});
+var R2ServiceSchema = z.object({
+  provisioner: z.literal("cloudflare-r2"),
+  accountId: z.string().min(1),
+  apiToken: z.string().min(1)
+});
+var ResendServiceSchema = z.object({
+  provisioner: z.literal("resend"),
+  apiKey: z.string().min(1)
+});
+var AliyunSmsServiceSchema = z.object({
+  provisioner: z.literal("aliyun"),
+  accessKeyId: z.string().min(1),
+  accessKeySecret: z.string().min(1)
+});
+var ServicesConfigSchema = z.object({
+  db: z.discriminatedUnion("provisioner", [NeonServiceSchema]).optional(),
+  cache: z.discriminatedUnion("provisioner", [UpstashServiceSchema]).optional(),
+  storage: z.discriminatedUnion("provisioner", [R2ServiceSchema]).optional(),
+  email: z.discriminatedUnion("provisioner", [ResendServiceSchema]).optional(),
+  sms: z.discriminatedUnion("provisioner", [AliyunSmsServiceSchema]).optional()
+}).optional();
+var DeployConfigSchema = z.object({
+  provider: ProviderConfigSchema,
+  services: ServicesConfigSchema
+});
+var DeployErrorInfo = {
+  DEPLOY_FAILED: "001:500",
+  PROJECT_CREATE_FAILED: "002:500",
+  BUILD_FAILED: "003:500",
+  UPLOAD_FAILED: "004:500",
+  AUTH_REQUIRED: "005:401",
+  AUTH_FAILED: "006:401",
+  PROVISION_FAILED: "007:500",
+  ADAPTER_MISSING: "008:500",
+  SCAN_FAILED: "009:500",
+  ENV_VAR_FAILED: "010:500",
+  NOT_INITIALIZED: "011:500",
+  UNSUPPORTED_TYPE: "012:400",
+  CONFIG_ERROR: "013:500",
+  CREDENTIAL_ERROR: "014:500"
+};
+var HaiDeployError = core.error.buildHaiErrorsDef("deploy", DeployErrorInfo);
+
+// src/deploy-credentials.ts
+var logger = core.logger.child({ module: "deploy", scope: "credentials" });
+function getCredentialsPath() {
+  return join(homedir(), ".hai", "credentials.yml");
+}
+function ensureDir(filePath) {
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+function readCredentialsFile() {
+  const filePath = getCredentialsPath();
+  if (!existsSync(filePath)) {
+    return {};
+  }
+  const content = readFileSync(filePath, "utf-8");
+  const parsed = parse(content);
+  if (parsed === null || parsed === void 0 || typeof parsed !== "object") {
+    return {};
+  }
+  return parsed;
+}
+function writeCredentialsFile(data) {
+  const filePath = getCredentialsPath();
+  ensureDir(filePath);
+  const header = "# Managed by hai cli - do not edit manually\n";
+  const content = header + stringify(data);
+  writeFileSync(filePath, content, { encoding: "utf-8", mode: 384 });
+}
+function loadCredentials() {
+  try {
+    const data = readCredentialsFile();
+    const keys = Object.keys(data);
+    for (const key of keys) {
+      process.env[key] = String(data[key]);
+    }
+    logger.debug("Credentials loaded", { count: keys.length });
+    return ok(keys);
+  } catch (error) {
+    logger.error("Failed to load credentials", { error });
+    return err(
+      HaiDeployError.CREDENTIAL_ERROR,
+      deployM("deploy_credentialError", {
+        params: { error: error instanceof Error ? error.message : String(error) }
+      }),
+      error
+    );
+  }
+}
+function saveCredential(key, value) {
+  try {
+    const data = readCredentialsFile();
+    data[key] = value;
+    writeCredentialsFile(data);
+    process.env[key] = value;
+    logger.debug("Credential saved", { key });
+    return ok(void 0);
+  } catch (error) {
+    logger.error("Failed to save credential", { key, error });
+    return err(
+      HaiDeployError.CREDENTIAL_ERROR,
+      deployM("deploy_credentialError", {
+        params: { error: error instanceof Error ? error.message : String(error) }
+      }),
+      error
+    );
+  }
+}
+function saveCredentials(entries) {
+  try {
+    const data = readCredentialsFile();
+    for (const [key, value] of Object.entries(entries)) {
+      data[key] = value;
+      process.env[key] = value;
+    }
+    writeCredentialsFile(data);
+    logger.debug("Credentials saved", { count: Object.keys(entries).length });
+    return ok(void 0);
+  } catch (error) {
+    logger.error("Failed to save credentials", { error });
+    return err(
+      HaiDeployError.CREDENTIAL_ERROR,
+      deployM("deploy_credentialError", {
+        params: { error: error instanceof Error ? error.message : String(error) }
+      }),
+      error
+    );
+  }
+}
+var logger2 = core.logger.child({ module: "deploy", scope: "functions" });
+function buildApp(appDir, buildCommand) {
+  logger2.info("Building application", { appDir, buildCommand });
+  try {
+    execSync(buildCommand, {
+      cwd: appDir,
+      stdio: "inherit",
+      env: { ...process.env }
+    });
+    return ok(void 0);
+  } catch (error) {
+    return err(
+      HaiDeployError.BUILD_FAILED,
+      deployM("deploy_buildFailed", {
+        params: { error: error instanceof Error ? error.message : String(error) }
+      }),
+      error
+    );
+  }
+}
+function resolveOutputDir(appDir, providerType) {
+  switch (providerType) {
+    case "vercel": {
+      const vercelOutput = join(appDir, ".vercel", "output");
+      if (existsSync(vercelOutput)) {
+        return vercelOutput;
+      }
+      return join(appDir, "build");
+    }
+    default:
+      return join(appDir, "build");
+  }
+}
+var logger3 = core.logger.child({ module: "deploy", scope: "scanner" });
+function readYaml(filePath) {
+  if (!existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const parsed = parse(content);
+    if (parsed === null || parsed === void 0 || typeof parsed !== "object") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function readJson(filePath) {
+  if (!existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function hasDependency(pkg, name) {
+  const deps = pkg.dependencies;
+  const devDeps = pkg.devDependencies;
+  return deps !== void 0 && name in deps || devDeps !== void 0 && name in devDeps;
+}
+function detectRequiredServices(configDir) {
+  const services = [];
+  if (!existsSync(configDir)) {
+    return services;
+  }
+  const files = readdirSync(configDir);
+  if (files.includes("_db.yml") || files.includes("_db.yaml")) {
+    const dbConfig = readYaml(join(configDir, files.find((f) => f.startsWith("_db."))));
+    if (dbConfig !== null) {
+      services.push("db");
+    }
+  }
+  if (files.includes("_cache.yml") || files.includes("_cache.yaml")) {
+    const cacheConfig = readYaml(join(configDir, files.find((f) => f.startsWith("_cache."))));
+    if (cacheConfig !== null) {
+      const cacheType = cacheConfig.type;
+      if (cacheType === "redis") {
+        services.push("cache");
+      }
+    }
+  }
+  if (files.includes("_storage.yml") || files.includes("_storage.yaml")) {
+    const storageConfig = readYaml(join(configDir, files.find((f) => f.startsWith("_storage."))));
+    if (storageConfig !== null) {
+      detectStorageServices(storageConfig, services);
+    }
+  }
+  if (files.includes("_reach.yml") || files.includes("_reach.yaml")) {
+    const reachConfig = readYaml(join(configDir, files.find((f) => f.startsWith("_reach."))));
+    if (reachConfig !== null) {
+      detectReachServices(reachConfig, services);
+    }
+  }
+  return services;
+}
+function detectStorageServices(config, services) {
+  if (config.type === "s3") {
+    services.push("storage");
+    return;
+  }
+  const providers = config.providers;
+  if (providers === void 0) {
+    return;
+  }
+  for (const providerConfig of Object.values(providers)) {
+    const typed = providerConfig;
+    if (typed?.type === "s3") {
+      services.push("storage");
+      return;
+    }
+  }
+}
+function detectReachServices(config, services) {
+  const providers = config.providers;
+  if (!Array.isArray(providers)) {
+    return;
+  }
+  let hasEmail = false;
+  let hasSms = false;
+  for (const provider of providers) {
+    const providerType = provider.type;
+    if (!hasEmail && (providerType === "smtp" || providerType === "api")) {
+      hasEmail = true;
+      services.push("email");
+    }
+    if (!hasSms && providerType === "aliyun-sms") {
+      hasSms = true;
+      services.push("sms");
+    }
+  }
+}
+async function scanApp(appDir) {
+  logger3.debug("Scanning application", { appDir });
+  try {
+    const pkg = readJson(join(appDir, "package.json"));
+    if (pkg === null) {
+      return err(
+        HaiDeployError.SCAN_FAILED,
+        deployM("deploy_scanFailed", { params: { error: "package.json not found" } })
+      );
+    }
+    const appName = extractAppName(pkg);
+    const isSvelteKit = existsSync(join(appDir, "svelte.config.js")) || existsSync(join(appDir, "svelte.config.ts"));
+    const adapterInstalled = hasDependency(pkg, "@sveltejs/adapter-vercel");
+    const configDir = join(appDir, "config");
+    const configServices = detectRequiredServices(configDir);
+    const depServices = detectServicesFromDependencies(pkg);
+    const requiredServices = Array.from(/* @__PURE__ */ new Set([...configServices, ...depServices]));
+    const scripts = pkg.scripts;
+    const buildCommand = scripts?.build ?? "pnpm build";
+    const scanResult = {
+      appName,
+      isSvelteKit,
+      adapterInstalled,
+      requiredServices,
+      buildCommand
+    };
+    logger3.info("Application scanned", {
+      appName,
+      isSvelteKit,
+      adapterInstalled,
+      requiredServices
+    });
+    return ok(scanResult);
+  } catch (error) {
+    logger3.error("Application scan failed", { appDir, error });
+    return err(
+      HaiDeployError.SCAN_FAILED,
+      deployM("deploy_scanFailed", {
+        params: { error: error instanceof Error ? error.message : String(error) }
+      }),
+      error
+    );
+  }
+}
+function detectServicesFromDependencies(pkg) {
+  const depMap = {
+    "@h-ai/reldb": "db",
+    "@h-ai/cache": "cache",
+    "@h-ai/storage": "storage"
+  };
+  const services = [];
+  for (const [depName, serviceType] of Object.entries(depMap)) {
+    if (hasDependency(pkg, depName)) {
+      services.push(serviceType);
+    }
+  }
+  return services;
+}
+function extractAppName(pkg) {
+  const name = pkg.name ?? "app";
+  const slashIndex = name.indexOf("/");
+  if (slashIndex >= 0) {
+    return name.slice(slashIndex + 1);
+  }
+  return name;
+}
+var logger4 = core.logger.child({ module: "deploy", scope: "provider-vercel" });
+var VERCEL_API = "https://api.vercel.com";
+var POLL_INTERVAL = 3e3;
+var MAX_POLL_ATTEMPTS = 60;
+function toDeployError(codeDef, messageKey, error) {
+  return {
+    ...codeDef,
+    message: deployM(messageKey, {
+      params: { error: error instanceof Error ? error.message : String(error) }
+    }),
+    cause: error
+  };
+}
+async function vercelFetch(token, path, options) {
+  const url = `${VERCEL_API}${path}`;
+  const response = await fetch(url, {
+    ...options,
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "Content-Type": "application/json",
+      ...options?.headers
+    }
+  });
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(deployM("deploy_apiError", { params: { service: "Vercel", status: String(response.status), body } }));
+  }
+  return response.json();
+}
+function collectFiles(dir, baseDir) {
+  const results = [];
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...collectFiles(fullPath, baseDir));
+    } else {
+      results.push(relative(baseDir, fullPath));
+    }
+  }
+  return results;
+}
+function createVercelProvider() {
+  let token = null;
+  return {
+    name: "vercel",
+    async authenticate(apiToken) {
+      logger4.debug("Authenticating with Vercel");
+      try {
+        const user = await vercelFetch(
+          apiToken,
+          "/v2/user"
+        );
+        token = apiToken;
+        const username = user.user.username || user.user.email;
+        logger4.info("Vercel authenticated", { user: username });
+        return ok(username);
+      } catch (error) {
+        logger4.error("Vercel authentication failed", { error });
+        return err(toDeployError(HaiDeployError.AUTH_FAILED, "deploy_authFailed", error));
+      }
+    },
+    async createProject(projectName) {
+      if (!token) {
+        return err(
+          HaiDeployError.AUTH_REQUIRED,
+          deployM("deploy_authRequired")
+        );
+      }
+      logger4.debug("Creating Vercel project", { projectName });
+      try {
+        const existingId = await findExistingProject(token, projectName);
+        if (existingId !== null) {
+          logger4.info("Vercel project found", { projectName, projectId: existingId });
+          return ok(existingId);
+        }
+        const project = await vercelFetch(
+          token,
+          "/v10/projects",
+          {
+            method: "POST",
+            body: JSON.stringify({
+              name: projectName,
+              framework: "sveltekit"
+            })
+          }
+        );
+        logger4.info("Vercel project created", { projectName, projectId: project.id });
+        return ok(project.id);
+      } catch (error) {
+        logger4.error("Vercel project creation failed", { projectName, error });
+        return err(toDeployError(HaiDeployError.PROJECT_CREATE_FAILED, "deploy_projectCreateFailed", error));
+      }
+    },
+    async setEnvVars(projectId, envVars) {
+      if (!token) {
+        return err(
+          HaiDeployError.AUTH_REQUIRED,
+          deployM("deploy_authRequired")
+        );
+      }
+      logger4.debug("Setting Vercel env vars", { projectId, count: Object.keys(envVars).length });
+      try {
+        const envEntries = Object.entries(envVars).map(([key, value]) => ({
+          key,
+          value,
+          type: "encrypted",
+          target: ["production", "preview", "development"]
+        }));
+        await vercelFetch(
+          token,
+          `/v10/projects/${projectId}/env`,
+          {
+            method: "POST",
+            body: JSON.stringify(envEntries)
+          }
+        );
+        logger4.info("Vercel env vars set", { projectId, count: envEntries.length });
+        return ok(void 0);
+      } catch (error) {
+        logger4.error("Vercel env vars setup failed", { projectId, error });
+        return err(toDeployError(HaiDeployError.ENV_VAR_FAILED, "deploy_envVarFailed", error));
+      }
+    },
+    async deploy(projectId, outputDir) {
+      if (!token) {
+        return err(
+          HaiDeployError.AUTH_REQUIRED,
+          deployM("deploy_authRequired")
+        );
+      }
+      logger4.debug("Deploying to Vercel", { projectId, outputDir });
+      try {
+        const filePaths = collectFiles(outputDir, outputDir);
+        const files = [];
+        for (const filePath of filePaths) {
+          const fullPath = join(outputDir, filePath);
+          const content = readFileSync(fullPath);
+          const sha = createHash("sha1").update(content).digest("hex");
+          const size = statSync(fullPath).size;
+          await uploadFile(token, content, sha);
+          files.push({ file: filePath, sha, size });
+        }
+        logger4.debug("Files uploaded", { count: files.length });
+        const deployment = await vercelFetch(
+          token,
+          "/v13/deployments",
+          {
+            method: "POST",
+            body: JSON.stringify({
+              name: projectId,
+              files,
+              projectSettings: { framework: "sveltekit" }
+            })
+          }
+        );
+        const finalStatus = await pollDeploymentStatus(token, deployment.id);
+        const result = {
+          url: `https://${deployment.url}`,
+          deploymentId: deployment.id,
+          status: finalStatus,
+          envVarsSet: []
+        };
+        logger4.info("Vercel deployment complete", {
+          deploymentId: deployment.id,
+          url: result.url,
+          status: finalStatus
+        });
+        return ok(result);
+      } catch (error) {
+        logger4.error("Vercel deployment failed", { projectId, error });
+        return err(toDeployError(HaiDeployError.UPLOAD_FAILED, "deploy_uploadFailed", error));
+      }
+    }
+  };
+}
+async function findExistingProject(token, projectName) {
+  try {
+    const project = await vercelFetch(token, `/v10/projects/${projectName}`);
+    return project.id;
+  } catch {
+    return null;
+  }
+}
+async function uploadFile(token, content, sha) {
+  const url = `${VERCEL_API}/v2/files`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "Content-Type": "application/octet-stream",
+      "x-vercel-digest": sha
+    },
+    body: new Blob([content.buffer])
+  });
+  if (!response.ok && response.status !== 409) {
+    const body = await response.text();
+    throw new Error(deployM("deploy_fileUploadFailed", { params: { status: String(response.status), body } }));
+  }
+}
+async function pollDeploymentStatus(token, deploymentId) {
+  for (let i = 0; i < MAX_POLL_ATTEMPTS; i++) {
+    const deployment = await vercelFetch(
+      token,
+      `/v13/deployments/${deploymentId}`
+    );
+    if (deployment.readyState === "READY") {
+      return "ready";
+    }
+    if (deployment.readyState === "ERROR" || deployment.readyState === "CANCELED") {
+      return "error";
+    }
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL));
+  }
+  return "building";
+}
+var logger5 = core.logger.child({ module: "deploy", scope: "provisioner-aliyun" });
+function createAliyunProvisioner() {
+  let accessKey = null;
+  let secretKey = null;
+  return {
+    name: "aliyun",
+    serviceType: "sms",
+    async authenticate(credentials) {
+      logger5.debug("Authenticating with Aliyun");
+      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" } }));
+        }
+        accessKey = akId;
+        secretKey = akSecret;
+        logger5.info("Aliyun authenticated", { accessKeyId: `${akId.slice(0, 6)}***` });
+        return ok(akId);
+      } catch (error) {
+        logger5.error("Aliyun authentication failed", { error });
+        return err(
+          HaiDeployError.AUTH_FAILED,
+          deployM("deploy_authFailed", {
+            params: { error: error instanceof Error ? error.message : String(error) }
+          }),
+          error
+        );
+      }
+    },
+    async provision(_appName) {
+      if (!accessKey || !secretKey) {
+        return err(
+          HaiDeployError.AUTH_REQUIRED,
+          deployM("deploy_authRequired")
+        );
+      }
+      logger5.debug("Provisioning Aliyun SMS service");
+      return ok({
+        serviceType: "sms",
+        provisionerName: "aliyun",
+        envVars: {
+          HAI_REACH_SMS_ACCESS_KEY: accessKey,
+          HAI_REACH_SMS_SECRET_KEY: secretKey
+        },
+        resourceInfo: "aliyun:verify-only"
+      });
+    }
+  };
+}
+var logger6 = core.logger.child({ module: "deploy", scope: "provisioner-neon" });
+var NEON_API = "https://console.neon.tech/api/v2";
+function createNeonProvisioner() {
+  let token = null;
+  return {
+    name: "neon",
+    serviceType: "db",
+    async authenticate(credentials) {
+      logger6.debug("Authenticating with Neon");
+      try {
+        const apiToken = credentials.apiKey ?? credentials.token ?? credentials.api_key ?? "";
+        if (!apiToken) {
+          throw new Error(deployM("deploy_credentialMissing", { params: { fields: "token" } }));
+        }
+        const res = await fetch(`${NEON_API}/projects`, {
+          headers: { Authorization: `Bearer ${apiToken}` }
+        });
+        if (!res.ok) {
+          throw new Error(deployM("deploy_apiError", { params: { service: "Neon", status: String(res.status), body: await res.text() } }));
+        }
+        token = apiToken;
+        logger6.info("Neon authenticated");
+        return ok("neon-user");
+      } catch (error) {
+        logger6.error("Neon authentication failed", { error });
+        return err(
+          HaiDeployError.AUTH_FAILED,
+          deployM("deploy_authFailed", {
+            params: { error: error instanceof Error ? error.message : String(error) }
+          }),
+          error
+        );
+      }
+    },
+    async provision(appName) {
+      if (!token) {
+        return err(
+          HaiDeployError.AUTH_REQUIRED,
+          deployM("deploy_authRequired")
+        );
+      }
+      logger6.debug("Provisioning Neon database", { appName });
+      try {
+        const res = await fetch(`${NEON_API}/projects`, {
+          method: "POST",
+          headers: {
+            "Authorization": `Bearer ${token}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            project: {
+              name: `${appName}-db`,
+              pg_version: 16
+            }
+          })
+        });
+        if (!res.ok) {
+          throw new Error(deployM("deploy_apiError", { params: { service: "Neon", status: String(res.status), body: await res.text() } }));
+        }
+        const data = await res.json();
+        const connectionUri = data.connection_uris?.[0]?.connection_uri;
+        if (!connectionUri) {
+          throw new Error(deployM("deploy_provisionNoResult", { params: { service: "Neon" } }));
+        }
+        logger6.info("Neon database provisioned", { projectId: data.project.id });
+        return ok({
+          serviceType: "db",
+          provisionerName: "neon",
+          envVars: {
+            HAI_RELDB_URL: connectionUri
+          },
+          resourceInfo: `neon-project:${data.project.id}`
+        });
+      } catch (error) {
+        logger6.error("Neon provisioning failed", { appName, error });
+        return err(
+          HaiDeployError.PROVISION_FAILED,
+          deployM("deploy_provisionFailed", {
+            params: {
+              service: "neon",
+              error: error instanceof Error ? error.message : String(error)
+            }
+          }),
+          error
+        );
+      }
+    }
+  };
+}
+var logger7 = core.logger.child({ module: "deploy", scope: "provisioner-r2" });
+var CF_API = "https://api.cloudflare.com/client/v4";
+function createR2Provisioner() {
+  let token = null;
+  let accountId = null;
+  return {
+    name: "r2",
+    serviceType: "storage",
+    async authenticate(credentials) {
+      logger7.debug("Authenticating with Cloudflare");
+      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" } }));
+        }
+        const res = await fetch(`${CF_API}/accounts/${acctId}/r2/buckets`, {
+          headers: { Authorization: `Bearer ${apiTok}` }
+        });
+        if (!res.ok) {
+          throw new Error(deployM("deploy_apiError", { params: { service: "Cloudflare", status: String(res.status), body: await res.text() } }));
+        }
+        accountId = acctId;
+        token = apiTok;
+        logger7.info("Cloudflare R2 authenticated", { accountId: acctId });
+        return ok(acctId);
+      } catch (error) {
+        logger7.error("Cloudflare R2 authentication failed", { error });
+        return err(
+          HaiDeployError.AUTH_FAILED,
+          deployM("deploy_authFailed", {
+            params: { error: error instanceof Error ? error.message : String(error) }
+          }),
+          error
+        );
+      }
+    },
+    async provision(appName) {
+      if (!token || !accountId) {
+        return err(
+          HaiDeployError.AUTH_REQUIRED,
+          deployM("deploy_authRequired")
+        );
+      }
+      const bucketName = `${appName}-storage`.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+      logger7.debug("Provisioning R2 bucket", { appName, bucketName });
+      try {
+        const createRes = await fetch(
+          `${CF_API}/accounts/${accountId}/r2/buckets`,
+          {
+            method: "POST",
+            headers: {
+              "Authorization": `Bearer ${token}`,
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({ name: bucketName })
+          }
+        );
+        if (!createRes.ok && createRes.status !== 409) {
+          throw new Error(deployM("deploy_apiError", { params: { service: "Cloudflare", status: String(createRes.status), body: await createRes.text() } }));
+        }
+        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}`]: "*" }
+              }]
+            })
+          }
+        );
+        let accessKey = "";
+        let secretKey = "";
+        if (tokenRes.ok) {
+          const tokenData = await tokenRes.json();
+          accessKey = tokenData.result.id;
+          secretKey = tokenData.result.value;
+        }
+        logger7.info("R2 bucket provisioned", { bucketName });
+        return ok({
+          serviceType: "storage",
+          provisionerName: "r2",
+          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
+          },
+          resourceInfo: `r2-bucket:${bucketName}`
+        });
+      } catch (error) {
+        logger7.error("R2 provisioning failed", { appName, error });
+        return err(
+          HaiDeployError.PROVISION_FAILED,
+          deployM("deploy_provisionFailed", {
+            params: {
+              service: "r2",
+              error: error instanceof Error ? error.message : String(error)
+            }
+          }),
+          error
+        );
+      }
+    }
+  };
+}
+var logger8 = core.logger.child({ module: "deploy", scope: "provisioner-resend" });
+var RESEND_API = "https://api.resend.com";
+function createResendProvisioner() {
+  let token = null;
+  return {
+    name: "resend",
+    serviceType: "email",
+    async authenticate(credentials) {
+      logger8.debug("Authenticating with Resend");
+      try {
+        const apiToken = credentials.apiKey ?? credentials.api_key ?? credentials.token ?? "";
+        if (!apiToken) {
+          throw new Error('Missing "api_key" in credentials');
+        }
+        const res = await fetch(`${RESEND_API}/domains`, {
+          headers: { Authorization: `Bearer ${apiToken}` }
+        });
+        if (!res.ok) {
+          throw new Error(`Resend API ${res.status}: ${await res.text()}`);
+        }
+        token = apiToken;
+        logger8.info("Resend authenticated");
+        return ok("resend-user");
+      } catch (error) {
+        logger8.error("Resend authentication failed", { error });
+        return err(
+          HaiDeployError.AUTH_FAILED,
+          deployM("deploy_authFailed", {
+            params: { error: error instanceof Error ? error.message : String(error) }
+          }),
+          error
+        );
+      }
+    },
+    async provision(_appName) {
+      if (!token) {
+        return err(
+          HaiDeployError.AUTH_REQUIRED,
+          deployM("deploy_authRequired")
+        );
+      }
+      logger8.debug("Provisioning Resend email service");
+      return ok({
+        serviceType: "email",
+        provisionerName: "resend",
+        envVars: {
+          HAI_REACH_RESEND_KEY: token
+        },
+        resourceInfo: "resend:verify-only"
+      });
+    }
+  };
+}
+var logger9 = core.logger.child({ module: "deploy", scope: "provisioner-upstash" });
+var UPSTASH_API = "https://api.upstash.com";
+function createUpstashProvisioner() {
+  let apiKey = null;
+  let email = null;
+  return {
+    name: "upstash",
+    serviceType: "cache",
+    async authenticate(credentials) {
+      logger9.debug("Authenticating with Upstash");
+      try {
+        const userEmail = credentials.email ?? "";
+        const userKey = credentials.apiKey ?? credentials.api_key ?? credentials.token ?? "";
+        if (!userEmail || !userKey) {
+          throw new Error(deployM("deploy_credentialMissing", { params: { fields: "email, api_key" } }));
+        }
+        const res = await fetch(`${UPSTASH_API}/v2/redis/databases`, {
+          headers: {
+            Authorization: `Basic ${btoa(`${userEmail}:${userKey}`)}`
+          }
+        });
+        if (!res.ok) {
+          throw new Error(deployM("deploy_apiError", { params: { service: "Upstash", status: String(res.status), body: await res.text() } }));
+        }
+        email = userEmail;
+        apiKey = userKey;
+        logger9.info("Upstash authenticated", { email: userEmail });
+        return ok(userEmail);
+      } catch (error) {
+        logger9.error("Upstash authentication failed", { error });
+        return err(
+          HaiDeployError.AUTH_FAILED,
+          deployM("deploy_authFailed", {
+            params: { error: error instanceof Error ? error.message : String(error) }
+          }),
+          error
+        );
+      }
+    },
+    async provision(appName) {
+      if (!apiKey || !email) {
+        return err(
+          HaiDeployError.AUTH_REQUIRED,
+          deployM("deploy_authRequired")
+        );
+      }
+      logger9.debug("Provisioning Upstash Redis", { appName });
+      try {
+        const res = await fetch(`${UPSTASH_API}/v2/redis/database`, {
+          method: "POST",
+          headers: {
+            "Authorization": `Basic ${btoa(`${email}:${apiKey}`)}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            name: `${appName}-cache`,
+            region: "global",
+            tls: true
+          })
+        });
+        if (!res.ok) {
+          throw new Error(deployM("deploy_apiError", { params: { service: "Upstash", status: String(res.status), body: await res.text() } }));
+        }
+        const data = await res.json();
+        logger9.info("Upstash Redis provisioned", { databaseId: data.database_id });
+        return ok({
+          serviceType: "cache",
+          provisionerName: "upstash",
+          envVars: {
+            HAI_CACHE_UPSTASH_URL: data.rest_url,
+            HAI_CACHE_UPSTASH_TOKEN: data.rest_token
+          },
+          resourceInfo: `upstash-db:${data.database_id}`
+        });
+      } catch (error) {
+        logger9.error("Upstash provisioning failed", { appName, error });
+        return err(
+          HaiDeployError.PROVISION_FAILED,
+          deployM("deploy_provisionFailed", {
+            params: {
+              service: "upstash",
+              error: error instanceof Error ? error.message : String(error)
+            }
+          }),
+          error
+        );
+      }
+    }
+  };
+}
+
+// src/deploy-main.ts
+var logger10 = core.logger.child({ module: "deploy", scope: "main" });
+var currentConfig = null;
+var currentProvider = null;
+var currentProvisioners = /* @__PURE__ */ new Map();
+var initInProgress = false;
+var notInitialized = core.module.createNotInitializedKit(
+  HaiDeployError.NOT_INITIALIZED,
+  () => deployM("deploy_notInitialized")
+);
+function createProviderByType(type) {
+  switch (type) {
+    case "vercel":
+      return createVercelProvider();
+    default:
+      throw new Error(deployM("deploy_unsupportedProviderType", { params: { type } }));
+  }
+}
+function createProvisionerByName(provisioner) {
+  switch (provisioner) {
+    case "neon":
+      return createNeonProvisioner();
+    case "upstash":
+      return createUpstashProvisioner();
+    case "cloudflare-r2":
+      return createR2Provisioner();
+    case "resend":
+      return createResendProvisioner();
+    case "aliyun":
+      return createAliyunProvisioner();
+    default:
+      throw new Error(deployM("deploy_unsupportedProvisionerType", { params: { type: provisioner } }));
+  }
+}
+function extractCredentials(serviceConfig) {
+  const result = {};
+  for (const [key, value] of Object.entries(serviceConfig)) {
+    if (key !== "provisioner" && typeof value === "string") {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+var deploy = {
+  async init(config) {
+    if (initInProgress) {
+      logger10.warn("Deploy init already in progress, skipping concurrent call");
+      return err(
+        HaiDeployError.CONFIG_ERROR,
+        deployM("deploy_configError", { params: { error: "init already in progress" } })
+      );
+    }
+    initInProgress = true;
+    try {
+      if (currentProvider) {
+        logger10.warn("Deploy module is already initialized, reinitializing");
+        await deploy.close();
+      }
+      logger10.info("Initializing deploy module");
+      const parseResult = DeployConfigSchema.safeParse(config);
+      if (!parseResult.success) {
+        logger10.error("Deploy config validation failed", { error: parseResult.error.message });
+        return err(
+          HaiDeployError.CONFIG_ERROR,
+          deployM("deploy_configError", { params: { error: parseResult.error.message } }),
+          parseResult.error
+        );
+      }
+      const parsed = parseResult.data;
+      try {
+        const provider = createProviderByType(parsed.provider.type);
+        const authResult = await provider.authenticate(parsed.provider.token);
+        if (!authResult.success) {
+          return err(authResult.error);
+        }
+        logger10.info("Provider authenticated", { provider: parsed.provider.type, user: authResult.data });
+        currentProvisioners.clear();
+        if (parsed.services) {
+          const serviceEntries = Object.entries(parsed.services);
+          for (const [serviceType, serviceConfig] of serviceEntries) {
+            if (!serviceConfig)
+              continue;
+            const provisioner = createProvisionerByName(serviceConfig.provisioner);
+            const credentials = extractCredentials(serviceConfig);
+            const provAuthResult = await provisioner.authenticate(credentials);
+            if (!provAuthResult.success) {
+              logger10.warn("Provisioner authentication failed", {
+                service: serviceType,
+                provisioner: serviceConfig.provisioner
+              });
+            } else {
+              logger10.info("Provisioner authenticated", {
+                service: serviceType,
+                user: provAuthResult.data
+              });
+            }
+            currentProvisioners.set(serviceType, provisioner);
+          }
+        }
+        currentProvider = provider;
+        currentConfig = parsed;
+        logger10.info("Deploy module initialized", {
+          provider: parsed.provider.type,
+          provisioners: [...currentProvisioners.keys()]
+        });
+        return ok(void 0);
+      } catch (error) {
+        currentProvider = null;
+        currentConfig = null;
+        currentProvisioners.clear();
+        logger10.error("Deploy module initialization failed", { error });
+        return err(
+          HaiDeployError.CONFIG_ERROR,
+          deployM("deploy_configError", {
+            params: { error: error instanceof Error ? error.message : String(error) }
+          }),
+          error
+        );
+      }
+    } finally {
+      initInProgress = false;
+    }
+  },
+  async close() {
+    if (!currentProvider) {
+      logger10.info("Deploy module already closed, skipping");
+      return;
+    }
+    logger10.info("Closing deploy module");
+    currentProvider = null;
+    currentConfig = null;
+    currentProvisioners.clear();
+    logger10.info("Deploy module closed");
+  },
+  get config() {
+    return currentConfig;
+  },
+  get isInitialized() {
+    return currentProvider !== null;
+  },
+  async scan(appDir) {
+    logger10.debug("Scanning application", { appDir });
+    return scanApp(appDir);
+  },
+  async provisionAll(projectName) {
+    if (!currentProvider) {
+      return notInitialized.result();
+    }
+    logger10.info("Provisioning all services", { projectName, count: currentProvisioners.size });
+    const results = [];
+    for (const [serviceType, provisioner] of currentProvisioners) {
+      logger10.debug("Provisioning service", { serviceType, provisioner: provisioner.name });
+      const provResult = await provisioner.provision(projectName);
+      if (!provResult.success) {
+        logger10.error("Service provisioning failed", {
+          serviceType,
+          provisioner: provisioner.name,
+          error: provResult.error
+        });
+        return err(provResult.error);
+      }
+      results.push(provResult.data);
+      logger10.info("Service provisioned", { serviceType, provisioner: provisioner.name });
+    }
+    return ok(results);
+  },
+  async deployApp(appDir, options) {
+    if (!currentProvider) {
+      return notInitialized.result();
+    }
+    logger10.info("Starting deployment", { appDir, options });
+    const scanResult = await scanApp(appDir);
+    if (!scanResult.success) {
+      return err(scanResult.error);
+    }
+    const scan = scanResult.data;
+    const projectName = options?.projectName ?? scan.appName;
+    if (scan.isSvelteKit && !scan.adapterInstalled) {
+      return err(
+        HaiDeployError.ADAPTER_MISSING,
+        deployM("deploy_adapterMissing", {
+          params: { adapter: "@sveltejs/adapter-vercel" }
+        })
+      );
+    }
+    let allEnvVars = {};
+    if (!options?.skipProvision) {
+      const provResults = await deploy.provisionAll(projectName);
+      if (!provResults.success) {
+        return err(provResults.error);
+      }
+      for (const prov of provResults.data) {
+        allEnvVars = { ...allEnvVars, ...prov.envVars };
+      }
+    }
+    const projectResult = await currentProvider.createProject(projectName);
+    if (!projectResult.success) {
+      return err(projectResult.error);
+    }
+    const projectId = projectResult.data;
+    if (Object.keys(allEnvVars).length > 0) {
+      const envResult = await currentProvider.setEnvVars(projectId, allEnvVars);
+      if (!envResult.success) {
+        return err(envResult.error);
+      }
+    }
+    if (!options?.skipBuild) {
+      const buildResult = buildApp(appDir, scan.buildCommand);
+      if (!buildResult.success) {
+        return err(buildResult.error);
+      }
+    }
+    const outputDir = resolveOutputDir(appDir, currentConfig?.provider.type ?? "vercel");
+    const deployResult = await currentProvider.deploy(projectId, outputDir);
+    if (!deployResult.success) {
+      return err(deployResult.error);
+    }
+    const result = {
+      ...deployResult.data,
+      envVarsSet: Object.keys(allEnvVars)
+    };
+    logger10.info("Deployment completed", {
+      url: result.url,
+      deploymentId: result.deploymentId,
+      status: result.status
+    });
+    return ok(result);
+  }
+};
+
+export { DeployConfigSchema, HaiDeployError, ProviderConfigSchema, deploy, getCredentialsPath, loadCredentials, saveCredential, saveCredentials, scanApp };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map