@lightfish/cli 0.0.4 → 0.0.6

package/dist/lightfish.js

@@ -2,20 +2,42 @@
 
 // src/lightfish.ts
 import cac from "cac";
-import { execa as execa3 } from "execa";
+import { execa as execa4 } from "execa";
 
 // src/commands/create.ts
-import path4 from "path";
+import path6 from "path";
 import { execa as execa2 } from "execa";
-import fs4 from "fs-extra";
+import fs6 from "fs-extra";
 import prompts3 from "prompts";
 
-// src/utils/download-template.ts
+// src/utils/copy-template.ts
 import path from "path";
+import fs from "fs-extra";
+var SKIP_NAMES = /* @__PURE__ */ new Set([".git", "node_modules", "dist"]);
+async function copyLocalTemplate(srcDir, targetDir) {
+  await fs.ensureDir(targetDir);
+  const entries = await fs.readdir(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (SKIP_NAMES.has(entry.name)) continue;
+    const src = path.join(srcDir, entry.name);
+    const dest = path.join(targetDir, entry.name);
+    if (entry.isDirectory()) {
+      await copyLocalTemplate(src, dest);
+    } else if (entry.isSymbolicLink()) {
+      const linkTarget = await fs.readlink(src);
+      await fs.symlink(linkTarget, dest);
+    } else {
+      await fs.copy(src, dest);
+    }
+  }
+}
+
+// src/utils/download-template.ts
+import path2 from "path";
 import { tmpdir } from "os";
 import { randomUUID } from "crypto";
 import { execa } from "execa";
-import fs from "fs-extra";
+import fs2 from "fs-extra";
 function parseRepo(repo) {
   const [repoPart, branch] = repo.split("#");
   let url;
@@ -29,8 +51,8 @@ function parseRepo(repo) {
   return { url, branch: branch || void 0 };
 }
 async function gitClone(url, branch, targetDir) {
-  const tmpDir = path.join(tmpdir(), `lightfish-template-${randomUUID()}`);
-  await fs.ensureDir(tmpDir);
+  const tmpDir = path2.join(tmpdir(), `lightfish-template-${randomUUID()}`);
+  await fs2.ensureDir(tmpDir);
   const args = ["clone", "--depth", "1"];
   if (branch) {
     args.push("--branch", branch);
@@ -39,30 +61,30 @@ async function gitClone(url, branch, targetDir) {
   try {
     await execa("git", args, { stdio: "inherit" });
   } catch (error) {
-    await fs.remove(tmpDir).catch(() => {
+    await fs2.remove(tmpDir).catch(() => {
     });
     const detail = error instanceof Error ? error.message : String(error);
     throw new Error(`Git \u514B\u9686\u5931\u8D25\uFF08${url}\uFF09\uFF1A${detail}`);
   }
-  const entries = await fs.readdir(tmpDir);
+  const entries = await fs2.readdir(tmpDir);
   for (const entry of entries) {
     if (entry === ".git") continue;
-    const src = path.join(tmpDir, entry);
-    const dest = path.join(targetDir, entry);
-    await fs.move(src, dest, { overwrite: true });
+    const src = path2.join(tmpDir, entry);
+    const dest = path2.join(targetDir, entry);
+    await fs2.move(src, dest, { overwrite: true });
   }
-  await fs.remove(tmpDir).catch(() => {
+  await fs2.remove(tmpDir).catch(() => {
   });
 }
 async function downloadTemplate(repo, targetDir) {
-  await fs.ensureDir(targetDir);
+  await fs2.ensureDir(targetDir);
   const { url, branch } = parseRepo(repo);
   console.log(`\u6B63\u5728\u62C9\u53D6\u6A21\u677F: ${url}${branch ? ` (\u5206\u652F: ${branch})` : ""}`);
   await gitClone(url, branch, targetDir);
   console.log("\u6A21\u677F\u62C9\u53D6\u5B8C\u6210");
-  const gitDir = path.join(targetDir, ".git");
-  if (await fs.pathExists(gitDir)) {
-    await fs.remove(gitDir);
+  const gitDir = path2.join(targetDir, ".git");
+  if (await fs2.pathExists(gitDir)) {
+    await fs2.remove(gitDir);
     console.log("\u5DF2\u5220\u9664 .git \u76EE\u5F55");
   }
 }
@@ -86,26 +108,26 @@ function installCommand(packageManager) {
 }
 
 // src/utils/project.ts
-import path2 from "path";
-import fs2 from "fs-extra";
+import path3 from "path";
+import fs3 from "fs-extra";
 import prompts from "prompts";
 function normalizeProjectName(name) {
   return name.trim();
 }
 function resolveTargetDir(cwd, projectName) {
-  return path2.resolve(cwd, projectName);
+  return path3.resolve(cwd, projectName);
 }
 async function assertCanCreateProject(targetDir, yes) {
-  if (!await fs2.pathExists(targetDir)) {
+  if (!await fs3.pathExists(targetDir)) {
     return true;
   }
-  const files = await fs2.readdir(targetDir);
+  const files = await fs3.readdir(targetDir);
   if (files.length === 0) {
     return true;
   }
   if (yes) {
-    await fs2.remove(targetDir);
-    await fs2.ensureDir(targetDir);
+    await fs3.remove(targetDir);
+    await fs3.ensureDir(targetDir);
     return true;
   }
   const { overwrite } = await prompts(
@@ -124,8 +146,8 @@ async function assertCanCreateProject(targetDir, yes) {
   if (!overwrite) {
     return false;
   }
-  await fs2.remove(targetDir);
-  await fs2.ensureDir(targetDir);
+  await fs3.remove(targetDir);
+  await fs3.ensureDir(targetDir);
   return true;
 }
 function toPackageName(projectName) {
@@ -133,8 +155,8 @@ function toPackageName(projectName) {
 }
 
 // src/utils/replace-token.ts
-import path3 from "path";
-import fs3 from "fs-extra";
+import path4 from "path";
+import fs4 from "fs-extra";
 var SKIP_DIRS = /* @__PURE__ */ new Set([
   ".git",
   "node_modules",
@@ -166,22 +188,22 @@ var SKIP_EXTS = /* @__PURE__ */ new Set([
   ".lock"
 ]);
 async function replaceToken(targetDir, token, value) {
-  const entries = await fs3.readdir(targetDir);
+  const entries = await fs4.readdir(targetDir);
   for (const entry of entries) {
-    const fullPath = path3.join(targetDir, entry);
-    const stat = await fs3.stat(fullPath);
+    const fullPath = path4.join(targetDir, entry);
+    const stat = await fs4.stat(fullPath);
     if (stat.isDirectory()) {
       if (SKIP_DIRS.has(entry)) continue;
       await replaceToken(fullPath, token, value);
       continue;
     }
-    const ext = path3.extname(entry).toLowerCase();
+    const ext = path4.extname(entry).toLowerCase();
     if (SKIP_EXTS.has(ext)) continue;
     try {
-      const content = await fs3.readFile(fullPath, "utf8");
+      const content = await fs4.readFile(fullPath, "utf8");
       if (content.includes(token)) {
         const replaced = content.replaceAll(token, value);
-        await fs3.writeFile(fullPath, replaced, "utf8");
+        await fs4.writeFile(fullPath, replaced, "utf8");
         console.log(`  [replace] ${entry}`);
       }
     } catch {
@@ -197,6 +219,7 @@ var BUILTIN_TEMPLATES = [
   {
     id: "react-vite",
     label: "React + Vite",
+    localDir: "react-vite",
     repo: "QGtiger/template-vite-server#main"
   }
 ];
@@ -208,6 +231,21 @@ function listTemplateIds() {
   return BUILTIN_TEMPLATES.map((entry) => entry.id);
 }
 
+// src/utils/builtin-template-dir.ts
+import path5 from "path";
+import fs5 from "fs";
+import { fileURLToPath } from "url";
+var dirname = path5.dirname(fileURLToPath(import.meta.url));
+function resolveBuiltinTemplateDir(localDir) {
+  const candidates = [
+    // 产物模式：dirname=dist -> dist/templates/<localDir>
+    path5.resolve(dirname, "templates", localDir),
+    // 源码模式：dirname=src/utils -> packages/cli/templates/<localDir>
+    path5.resolve(dirname, "..", "..", "templates", localDir)
+  ];
+  return candidates.find((candidate) => fs5.existsSync(candidate));
+}
+
 // src/utils/resolve-template.ts
 async function promptTemplateId() {
   const { templateId } = await prompts2(
@@ -231,41 +269,59 @@ async function promptTemplateId() {
   }
   return templateId;
 }
-async function resolveTemplateRepo(options) {
-  if (options.templateRepo) {
-    return options.templateRepo;
-  }
+async function selectEntry(options) {
   if (options.template) {
     const entry2 = getTemplateById(options.template);
     if (!entry2) {
       throw new Error(`\u672A\u77E5\u6A21\u677F\uFF1A${options.template}\u3002\u53EF\u9009\uFF1A${listTemplateIds().join("\u3001")}`);
     }
-    return entry2.repo;
+    return entry2;
+  }
+  if (BUILTIN_TEMPLATES.length === 1) {
+    const entry2 = getTemplateById(DEFAULT_TEMPLATE_ID ?? BUILTIN_TEMPLATES[0].id);
+    if (!entry2) {
+      throw new Error("\u5185\u7F6E\u6A21\u677F\u5217\u8868\u4E3A\u7A7A");
+    }
+    return entry2;
   }
   if (options.yes) {
     const entry2 = getTemplateById(DEFAULT_TEMPLATE_ID ?? BUILTIN_TEMPLATES[0].id);
     if (!entry2) {
       throw new Error("\u5185\u7F6E\u6A21\u677F\u5217\u8868\u4E3A\u7A7A");
     }
-    return entry2.repo;
+    return entry2;
   }
   const templateId = await promptTemplateId();
   const entry = getTemplateById(templateId);
   if (!entry) {
     throw new Error(`\u672A\u77E5\u6A21\u677F\uFF1A${templateId}`);
   }
-  return entry.repo;
+  return entry;
+}
+async function resolveTemplate(options) {
+  const entry = await selectEntry(options);
+  if (!options.remote && entry.localDir) {
+    const dir = resolveBuiltinTemplateDir(entry.localDir);
+    if (dir) {
+      return { type: "local", dir, id: entry.id };
+    }
+    console.warn(`[template] \u5185\u7F6E\u6A21\u677F\u526F\u672C\u7F3A\u5931\uFF08${entry.localDir}\uFF09\uFF0C\u56DE\u9000\u5230 git \u62C9\u53D6\u3002`);
+  }
+  if (!entry.repo) {
+    throw new Error(`\u6A21\u677F ${entry.id} \u672A\u914D\u7F6E git \u6E90\uFF0C\u4E14\u672C\u5730\u526F\u672C\u4E0D\u53EF\u7528`);
+  }
+  return { type: "git", repo: entry.repo, id: entry.id };
 }
 
 // src/commands/create.ts
 async function patchPackageJsonName(targetDir, projectName) {
-  const packageJsonPath = path4.join(targetDir, "package.json");
-  if (!await fs4.pathExists(packageJsonPath)) {
+  const packageJsonPath = path6.join(targetDir, "package.json");
+  if (!await fs6.pathExists(packageJsonPath)) {
     throw new Error("\u6A21\u677F\u7F3A\u5C11 package.json");
   }
-  const packageJson = await fs4.readJson(packageJsonPath);
+  const packageJson = await fs6.readJson(packageJsonPath);
   packageJson.name = toPackageName(projectName);
-  await fs4.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+  await fs6.writeJson(packageJsonPath, packageJson, { spaces: 2 });
 }
 async function resolveCreateOptions(options) {
   const cwd = options.cwd ?? process.cwd();
@@ -305,9 +361,9 @@ async function resolveCreateOptions(options) {
   if (!isPackageManager(packageManager)) {
     throw new Error(`\u4E0D\u652F\u6301\u7684\u5305\u7BA1\u7406\u5668\uFF1A${String(packageManager)}`);
   }
-  const templateRepo = await resolveTemplateRepo({
+  const template = await resolveTemplate({
     template: options.template,
-    templateRepo: options.templateRepo,
+    remote: options.remote,
     yes: options.yes
   });
   const yesMode = options.yes === true;
@@ -316,7 +372,7 @@ async function resolveCreateOptions(options) {
     projectName,
     targetDir: resolveTargetDir(cwd, projectName),
     packageManager,
-    templateRepo,
+    template,
     install: options.skipInstall ? false : options.install ?? (yesMode ? true : answers.install ?? false),
     git: options.git ?? (yesMode ? true : answers.git ?? false)
   };
@@ -340,15 +396,25 @@ async function maybeInitGit(options) {
     stdio: "inherit"
   });
 }
+async function writeTemplate(template, targetDir) {
+  if (template.type === "local") {
+    console.log(`[create] \u4F7F\u7528\u5185\u7F6E\u6A21\u677F\uFF1A${template.id}`);
+    await copyLocalTemplate(template.dir, targetDir);
+    console.log("[create] \u5185\u7F6E\u6A21\u677F\u62F7\u8D1D\u5B8C\u6210");
+    return;
+  }
+  console.log(`[create] \u4F7F\u7528 git \u6A21\u677F\uFF1A${template.id}`);
+  await downloadTemplate(template.repo, targetDir);
+}
 async function createProject(options = {}) {
   const resolvedOptions = await resolveCreateOptions(options);
   const canCreate = await assertCanCreateProject(resolvedOptions.targetDir, options.yes);
   if (!canCreate) {
     throw new Error("\u5DF2\u53D6\u6D88\u521B\u5EFA\u9879\u76EE");
   }
-  console.log("[create] \u5F00\u59CB\u4E0B\u8F7D\u6A21\u677F...");
-  await downloadTemplate(resolvedOptions.templateRepo, resolvedOptions.targetDir);
-  console.log("[create] \u6A21\u677F\u4E0B\u8F7D\u5B8C\u6210");
+  console.log("[create] \u5F00\u59CB\u5199\u5165\u6A21\u677F...");
+  await writeTemplate(resolvedOptions.template, resolvedOptions.targetDir);
+  console.log("[create] \u6A21\u677F\u5199\u5165\u5B8C\u6210");
   console.log("[create] \u5F00\u59CB\u4FEE\u6539 package.json...");
   await patchPackageJsonName(resolvedOptions.targetDir, resolvedOptions.projectName);
   console.log("[create] package.json \u4FEE\u6539\u5B8C\u6210");
@@ -364,36 +430,415 @@ async function createProject(options = {}) {
   return resolvedOptions;
 }
 
+// src/commands/publish.ts
+import fs10 from "fs";
+import path10 from "path";
+
+// src/utils/env.ts
+import fs7 from "fs";
+import path7 from "path";
+import { parse } from "dotenv";
+var DEFAULT_BASE_ROOT = "https://lf-frontend.oss-cn-beijing.aliyuncs.com";
+function loadDotenv({ cwd, envPath }) {
+  let merged;
+  if (envPath) {
+    merged = readEnvFile(path7.resolve(cwd, envPath));
+  } else {
+    const base = readEnvFile(path7.resolve(cwd, ".env"));
+    const local = readEnvFile(path7.resolve(cwd, ".env.local"));
+    merged = { ...base, ...local };
+  }
+  for (const [key, value] of Object.entries(merged)) {
+    if (process.env[key] === void 0) {
+      process.env[key] = value;
+    }
+  }
+}
+function readEnvFile(file) {
+  if (!fs7.existsSync(file)) return {};
+  return parse(fs7.readFileSync(file, "utf8"));
+}
+function getRequiredEnvNames({ notify, serverDetected }) {
+  const required = ["OSS_REGION", "OSS_BUCKET", "OSS_ACCESS_KEYID", "OSS_ACCESS_KEYSECRECT"];
+  if (notify) required.push("DEPLOY_API_URL");
+  if (serverDetected) required.push("DATABASE_URL");
+  return required;
+}
+function resolvePublishEnv(options, env = process.env) {
+  const required = getRequiredEnvNames(options);
+  const missing = required.filter((name) => !env[name]);
+  if (missing.length > 0) {
+    throw new Error(
+      `\u7F3A\u5C11\u5FC5\u9700\u73AF\u5883\u53D8\u91CF:${missing.join(", ")}(\u8BF7\u5728 .env / .env.local \u6216\u73AF\u5883\u53D8\u91CF\u4E2D\u914D\u7F6E)`
+    );
+  }
+  return {
+    ossRegion: env.OSS_REGION,
+    ossBucket: env.OSS_BUCKET,
+    ossAccessKeyId: env.OSS_ACCESS_KEYID,
+    // 注意:变量名沿用 CI secrets 的拼写(SECRECT),保持 .env 兼容
+    ossAccessKeySecret: env.OSS_ACCESS_KEYSECRECT,
+    deployApiUrl: options.notify ? env.DEPLOY_API_URL : void 0,
+    databaseUrl: env.DATABASE_URL,
+    baseRoot: env.BASE_ROOT || DEFAULT_BASE_ROOT
+  };
+}
+
+// src/utils/build.ts
+import fs8 from "fs";
+import path8 from "path";
+import { execa as execa3 } from "execa";
+var SERVER_CONFIG_FILES = [
+  "lightfish-server.config.js",
+  "lightfish-server.config.ts",
+  "lightfish-server.config.mjs",
+  "lightfish-server.config.cjs"
+];
+var VITE_CONFIG_FILES = [
+  "vite.config.ts",
+  "vite.config.js",
+  "vite.config.mts",
+  "vite.config.mjs",
+  "vite.config.cjs"
+];
+function readPackageJson(cwd) {
+  const file = path8.join(cwd, "package.json");
+  if (!fs8.existsSync(file)) return void 0;
+  return JSON.parse(fs8.readFileSync(file, "utf8"));
+}
+function hasVite(cwd) {
+  if (VITE_CONFIG_FILES.some((f) => fs8.existsSync(path8.join(cwd, f)))) return true;
+  const pkg = readPackageJson(cwd);
+  if (pkg) {
+    const deps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+    if ("vite" in deps) return true;
+  }
+  return false;
+}
+function detectBuild(cwd) {
+  return {
+    vite: hasVite(cwd),
+    server: SERVER_CONFIG_FILES.some((f) => fs8.existsSync(path8.join(cwd, f)))
+  };
+}
+async function runBuildSteps(options) {
+  const detection = detectBuild(options.cwd);
+  if (!detection.vite && !detection.server) {
+    throw new Error("\u672A\u68C0\u6D4B\u5230 Vite \u6216 lightfish-server,\u65E0\u6CD5\u6784\u5EFA");
+  }
+  const execOptions = {
+    cwd: options.cwd,
+    preferLocal: true,
+    stdio: "inherit",
+    env: { ...process.env, ...options.env }
+  };
+  if (detection.vite) {
+    await execa3("vite", ["build"], execOptions);
+  }
+  if (detection.server) {
+    await execa3("lightfish-server", ["build"], execOptions);
+    await execa3("lightfish-server", ["db", "push"], execOptions);
+  }
+}
+
+// src/utils/oss.ts
+import OSS from "ali-oss";
+import fs9 from "fs";
+import path9 from "path";
+function withPrefix(prefix, key) {
+  const normalized = prefix.replace(/^\/+/, "").replace(/\/+$/, "");
+  if (!normalized) return key;
+  return `${normalized}/${key}`;
+}
+function walkDir(dir, base = "") {
+  if (!fs9.existsSync(dir)) return [];
+  const entries = fs9.readdirSync(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = path9.join(dir, entry.name);
+    const key = base ? `${base}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      files.push(...walkDir(fullPath, key));
+    } else {
+      files.push({ localPath: fullPath, key });
+    }
+  }
+  return files;
+}
+async function uploadDist(options, client) {
+  const oss = client ?? createClient(options);
+  const files = walkDir(options.distDir);
+  console.log(`[publish] Found ${files.length} files to upload`);
+  const results = await Promise.all(
+    files.map(({ localPath, key }) => {
+      const objectKey = withPrefix(options.objectPrefix, key);
+      return oss.put(objectKey, localPath).then((res) => ({ key: objectKey, ok: res.res.status === 200 })).catch((err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`[publish] ERROR ${objectKey}: ${message}`);
+        return { key: objectKey, ok: false };
+      });
+    })
+  );
+  for (const r of results.filter((r2) => r2.ok)) {
+    console.log(`[publish] ok ${r.key}`);
+  }
+  const ok = results.filter((r) => r.ok).length;
+  const fail = results.filter((r) => !r.ok).length;
+  console.log(`[publish] Done: ${ok} succeeded, ${fail} failed`);
+  return { ok, fail };
+}
+function createClient(options) {
+  return new OSS({
+    region: options.region,
+    accessKeyId: options.accessKeyId,
+    accessKeySecret: options.accessKeySecret,
+    bucket: options.bucket
+  });
+}
+
+// src/utils/notify.ts
+async function notifyDeploy(options) {
+  const fetchFn = options.fetchImpl ?? fetch;
+  const body = JSON.stringify(options.payload);
+  console.log(`[publish] POST ${options.apiUrl}`);
+  console.log(`[publish] body: ${body}`);
+  let res;
+  try {
+    res = await fetchFn(options.apiUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`\u90E8\u7F72 API \u8BF7\u6C42\u5931\u8D25:${message}`);
+  }
+  if (!res.ok) {
+    throw new Error(`\u90E8\u7F72 API \u8FD4\u56DE HTTP ${res.status}`);
+  }
+  let data;
+  try {
+    data = await res.json();
+  } catch {
+    throw new Error("\u90E8\u7F72 API \u54CD\u5E94\u975E JSON");
+  }
+  console.log(`[publish] response: ${JSON.stringify(data)}`);
+  if (typeof data?.success !== "boolean" || data.success !== true) {
+    throw new Error("\u90E8\u7F72 API \u672A\u8FD4\u56DE success=true");
+  }
+}
+
+// src/commands/publish.ts
+function generateVersion(date = /* @__PURE__ */ new Date()) {
+  return date.toISOString().replace(/[-T:.Z]/g, "").slice(0, 14);
+}
+function readPackageJsonName(cwd) {
+  const file = path10.join(cwd, "package.json");
+  if (!fs10.existsSync(file)) return void 0;
+  const pkg = JSON.parse(fs10.readFileSync(file, "utf8"));
+  return pkg.name;
+}
+function resolveAppName(options) {
+  if (options.app) return options.app;
+  const pkgName = readPackageJsonName(options.cwd);
+  if (pkgName) {
+    return pkgName.startsWith("@") ? pkgName.replace(/^@[^/]+\//, "") : pkgName;
+  }
+  throw new Error("\u65E0\u6CD5\u786E\u5B9A APP_NAME:\u8BF7\u901A\u8FC7 --app \u6307\u5B9A,\u6216\u786E\u4FDD package.json \u542B name \u5B57\u6BB5");
+}
+function assertNumericVersion(version) {
+  if (!/^\d+$/.test(version)) {
+    throw new Error(`version \u5FC5\u987B\u4E3A\u7EAF\u6570\u5B57(\u4E0E\u90E8\u7F72 API \u7684 number \u5951\u7EA6\u4E00\u81F4),\u6536\u5230:${version}`);
+  }
+}
+function resolveOptions(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const appName = resolveAppName({ cwd, app: options.app });
+  const version = options.version ?? generateVersion();
+  assertNumericVersion(version);
+  const distDir = path10.resolve(cwd, options.dist ?? "dist");
+  const notify = !options.noNotify;
+  const baseRoot = process.env.BASE_ROOT || DEFAULT_BASE_ROOT;
+  const root = baseRoot.replace(/\/+$/, "");
+  const viteBaseUrl = root ? `${root}/${appName}/${version}/` : `/${appName}/${version}/`;
+  const objectPrefix = `${appName}/${version}`;
+  const ossIndexUrl = `${root}/${appName}/${version}/index.html`;
+  return {
+    cwd,
+    appName,
+    version,
+    distDir,
+    baseRoot,
+    root,
+    viteBaseUrl,
+    objectPrefix,
+    ossIndexUrl,
+    notify,
+    skipBuild: options.skipBuild ?? false,
+    note: options.note
+  };
+}
+function printBuildPlanDryRun(detection) {
+  if (!detection.vite && !detection.server) {
+    console.log("[publish] (dry-run) \u672A\u68C0\u6D4B\u5230 Vite \u6216 lightfish-server,\u6784\u5EFA\u5C06\u5931\u8D25");
+    return;
+  }
+  console.log("[publish] (dry-run) \u5C06\u6267\u884C\u6784\u5EFA:");
+  if (detection.vite) console.log("[publish] (dry-run)   vite build");
+  if (detection.server) {
+    console.log("[publish] (dry-run)   lightfish-server build");
+    console.log("[publish] (dry-run)   lightfish-server db push");
+  }
+}
+function printEnvDryRun(serverDetected, notify) {
+  const required = getRequiredEnvNames({ notify, serverDetected });
+  console.log("[publish] (dry-run) \u73AF\u5883\u53D8\u91CF\u9884\u68C0:");
+  for (const name of required) {
+    const present = process.env[name] !== void 0 && process.env[name] !== "";
+    console.log(`[publish] (dry-run)   ${present ? "\u2713" : "\u2717"} ${name}`);
+  }
+}
+function printUploadPlanDryRun(options) {
+  const files = walkDir(options.distDir);
+  if (files.length === 0) {
+    console.log(`[publish] (dry-run) \u4EA7\u7269\u76EE\u5F55 ${options.distDir} \u4E3A\u7A7A\u6216\u4E0D\u5B58\u5728(\u6784\u5EFA\u540E\u5C06\u751F\u6210)`);
+    return;
+  }
+  console.log(`[publish] (dry-run) \u5C06\u4E0A\u4F20 ${files.length} \u4E2A\u6587\u4EF6\u5230 OSS \u524D\u7F00:${options.objectPrefix}/`);
+  for (const { key } of files) {
+    console.log(`[publish] (dry-run)   ${withPrefix(options.objectPrefix, key)}`);
+  }
+}
+function buildNotifyPayload(params) {
+  const payload = {
+    id: params.appName,
+    version: Number(params.version),
+    ossIndexUrl: params.ossIndexUrl,
+    domain: `${params.appName}.lightfish.top`
+  };
+  if (params.note) payload.note = params.note;
+  return payload;
+}
+function printNotifyPlanDryRun(options, pubEnv) {
+  if (!options.notify) {
+    console.log("[publish] (dry-run) \u901A\u77E5\u5DF2\u8DF3\u8FC7(--no-notify)");
+    return;
+  }
+  const payload = buildNotifyPayload({
+    appName: options.appName,
+    version: options.version,
+    ossIndexUrl: options.ossIndexUrl,
+    note: options.note
+  });
+  console.log("[publish] (dry-run) \u5C06 POST \u901A\u77E5:");
+  console.log(`[publish] (dry-run)   url: ${pubEnv.deployApiUrl ?? "(\u672A\u914D\u7F6E DEPLOY_API_URL)"}`);
+  console.log(`[publish] (dry-run)   body: ${JSON.stringify(payload)}`);
+}
+async function runPublish(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  loadDotenv({ cwd, envPath: options.envPath });
+  const resolved = resolveOptions(options);
+  console.log(`[publish] app=${resolved.appName} version=${resolved.version} dist=${resolved.distDir}`);
+  let serverDetected = false;
+  if (!resolved.skipBuild) {
+    const detection = detectBuild(resolved.cwd);
+    serverDetected = detection.server;
+    if (options.dryRun) {
+      printBuildPlanDryRun(detection);
+    } else {
+      console.log("[publish] \u5F00\u59CB\u6784\u5EFA...");
+      const buildEnv = {
+        VITE_BASE_URL: resolved.viteBaseUrl,
+        BASE_ROOT: resolved.baseRoot,
+        APP_NAME: resolved.appName,
+        BUILD_VERSION: resolved.version
+      };
+      if (process.env.DATABASE_URL) buildEnv.DATABASE_URL = process.env.DATABASE_URL;
+      await runBuildSteps({
+        cwd: resolved.cwd,
+        env: buildEnv
+      });
+      console.log("[publish] \u6784\u5EFA\u5B8C\u6210");
+    }
+  }
+  const pubEnv = options.dryRun ? softResolveEnv(resolved.notify, serverDetected) : resolvePublishEnv({ notify: resolved.notify, serverDetected });
+  if (options.dryRun) {
+    printEnvDryRun(serverDetected, resolved.notify);
+    printUploadPlanDryRun(resolved);
+    printNotifyPlanDryRun(resolved, pubEnv);
+    console.log("[publish] (dry-run) \u5B8C\u6210,\u672A\u6267\u884C\u4EFB\u4F55\u526F\u4F5C\u7528");
+    return;
+  }
+  if (!fs10.existsSync(resolved.distDir)) {
+    throw new Error(`\u4EA7\u7269\u76EE\u5F55\u4E0D\u5B58\u5728:${resolved.distDir}`);
+  }
+  console.log("[publish] \u5F00\u59CB\u4E0A\u4F20 OSS...");
+  const { fail } = await uploadDist({
+    region: pubEnv.ossRegion,
+    bucket: pubEnv.ossBucket,
+    accessKeyId: pubEnv.ossAccessKeyId,
+    accessKeySecret: pubEnv.ossAccessKeySecret,
+    objectPrefix: resolved.objectPrefix,
+    distDir: resolved.distDir
+  });
+  if (fail > 0) {
+    throw new Error(`OSS \u4E0A\u4F20\u6709 ${fail} \u4E2A\u6587\u4EF6\u5931\u8D25`);
+  }
+  console.log("[publish] OSS \u4E0A\u4F20\u5B8C\u6210");
+  if (resolved.notify) {
+    console.log("[publish] \u5F00\u59CB\u901A\u77E5\u90E8\u7F72 API...");
+    const payload = buildNotifyPayload({
+      appName: resolved.appName,
+      version: resolved.version,
+      ossIndexUrl: resolved.ossIndexUrl,
+      note: resolved.note
+    });
+    await notifyDeploy({ apiUrl: pubEnv.deployApiUrl, payload });
+    console.log("[publish] \u901A\u77E5\u5B8C\u6210");
+  }
+}
+function softResolveEnv(notify, serverDetected) {
+  return {
+    ossRegion: process.env.OSS_REGION ?? "",
+    ossBucket: process.env.OSS_BUCKET ?? "",
+    ossAccessKeyId: process.env.OSS_ACCESS_KEYID ?? "",
+    ossAccessKeySecret: process.env.OSS_ACCESS_KEYSECRECT ?? "",
+    deployApiUrl: notify ? process.env.DEPLOY_API_URL : void 0,
+    databaseUrl: process.env.DATABASE_URL,
+    baseRoot: process.env.BASE_ROOT || DEFAULT_BASE_ROOT
+  };
+}
+
 // src/utils/package-info.ts
-import fs5 from "fs";
-import path5 from "path";
-import { fileURLToPath } from "url";
-var dirname = path5.dirname(fileURLToPath(import.meta.url));
+import fs11 from "fs";
+import path11 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var dirname2 = path11.dirname(fileURLToPath2(import.meta.url));
 function readPackageVersion() {
   const packageJsonPathCandidates = [
     // 源码模式：src/utils/package-info.ts -> packages/cli/package.json
-    path5.resolve(dirname, "../../package.json"),
+    path11.resolve(dirname2, "../../package.json"),
     // 构建产物模式：dist/lightfish.js -> packages/cli/package.json
-    path5.resolve(dirname, "../package.json")
+    path11.resolve(dirname2, "../package.json")
   ];
-  const packageJsonPath = packageJsonPathCandidates.find((candidate) => fs5.existsSync(candidate));
+  const packageJsonPath = packageJsonPathCandidates.find((candidate) => fs11.existsSync(candidate));
   if (!packageJsonPath) {
     return "0.0.0";
   }
-  const packageJson = JSON.parse(fs5.readFileSync(packageJsonPath, "utf8"));
+  const packageJson = JSON.parse(fs11.readFileSync(packageJsonPath, "utf8"));
   return packageJson.version ?? "0.0.0";
 }
 
 // src/lightfish.ts
 var cli = cac("lightfish");
 async function runBuild() {
-  await execa3("vite", ["build"], {
+  await execa4("vite", ["build"], {
     cwd: process.cwd(),
     preferLocal: true,
     stdio: "inherit"
   });
 }
-cli.command("create [projectName]", "\u521B\u5EFA Lightfish React Vite \u9879\u76EE").option("--pm <pm>", "\u5305\u7BA1\u7406\u5668\uFF1Anpm\u3001yarn\u3001pnpm\u3001bun", { default: "pnpm" }).option("--template <id>", "\u5185\u7F6E\u6A21\u677F id\uFF0C\u4F8B\u5982 react-vite").option("--template-repo <repo>", "\u76F4\u63A5\u6307\u5B9A git \u4ED3\u5E93\u6E90\uFF0C\u5982 QGtiger/template-vite-server#main\uFF08\u4F18\u5148\u4E8E --template\uFF09").option("--skip-install", "\u8DF3\u8FC7\u4F9D\u8D56\u5B89\u88C5").option("--git", "\u521B\u5EFA\u540E\u521D\u59CB\u5316 git").option("-y, --yes", "\u4F7F\u7528\u9ED8\u8BA4\u9009\u9879\u5E76\u8DF3\u8FC7\u786E\u8BA4").action(async (projectName, options) => {
+cli.command("create [projectName]", "\u521B\u5EFA Lightfish React Vite \u9879\u76EE").option("--pm <pm>", "\u5305\u7BA1\u7406\u5668\uFF1Anpm\u3001yarn\u3001pnpm\u3001bun", { default: "pnpm" }).option("--template <id>", "\u5185\u7F6E\u6A21\u677F id\uFF0C\u4F8B\u5982 react-vite").option("--remote", "\u5F3A\u5236\u8D70 git \u62C9\u53D6\u5185\u7F6E\u6A21\u677F\uFF08\u5FFD\u7565\u672C\u5730\u526F\u672C\uFF09").option("--skip-install", "\u8DF3\u8FC7\u4F9D\u8D56\u5B89\u88C5").option("--git", "\u521B\u5EFA\u540E\u521D\u59CB\u5316 git").option("-y, --yes", "\u4F7F\u7528\u9ED8\u8BA4\u9009\u9879\u5E76\u8DF3\u8FC7\u786E\u8BA4").action(async (projectName, options) => {
   try {
     const packageManager = options.pm ?? "pnpm";
     if (!isPackageManager(packageManager)) {
@@ -403,7 +848,7 @@ cli.command("create [projectName]", "\u521B\u5EFA Lightfish React Vite \u9879\u7
       projectName,
       packageManager,
       template: options.template,
-      templateRepo: options.templateRepo,
+      remote: options.remote,
       skipInstall: options.skipInstall,
       git: options.git,
       yes: options.yes
@@ -424,9 +869,28 @@ cli.command("build", "\u6267\u884C Vite \u6784\u5EFA\uFF0C\u540E\u7EED\u4F1A\u53
     process.exitCode = 1;
   }
 });
+cli.command("publish", "\u6784\u5EFA\u5E76\u90E8\u7F72\u5230 OSS\uFF0C\u901A\u77E5\u90E8\u7F72 API").option("--app <name>", "\u8986\u76D6 APP_NAME\uFF08\u9ED8\u8BA4 package.json#name \u53BB scope\uFF09").option("--version <v>", "\u8986\u76D6 BUILD_VERSION\uFF08\u9ED8\u8BA4 UTC \u65F6\u95F4\u6233 YYYYMMDDHHmmss\uFF09").option("--dist <dir>", "\u4EA7\u7269\u76EE\u5F55", { default: "dist" }).option("--note <text>", "\u901A\u77E5 body \u7684 note \u5B57\u6BB5\uFF0C\u4E0D\u4F20\u5219\u7701\u7565").option("--env <path>", "\u6307\u5B9A .env \u6587\u4EF6\u8DEF\u5F84\uFF08\u9ED8\u8BA4 cwd/.env + .env.local\uFF09").option("--no-build", "\u8DF3\u8FC7\u6784\u5EFA\uFF0C\u4F7F\u7528\u5DF2\u6709 dist").option("--no-notify", "\u8DF3\u8FC7\u901A\u77E5\u90E8\u7F72 API").option("--dry-run", "\u53EA\u6253\u5370\u5C06\u505A\u4EC0\u4E48\uFF0C\u4E0D\u6267\u884C").action(async (options) => {
+  try {
+    await runPublish({
+      app: options.app,
+      version: options.version,
+      dist: options.dist,
+      note: options.note,
+      envPath: options.env,
+      skipBuild: options.build === false,
+      noNotify: options.notify === false,
+      dryRun: options.dryRun
+    });
+    process.exit(0);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`\u53D1\u5E03\u5931\u8D25\uFF1A${message}`);
+    process.exit(1);
+  }
+});
 cli.command("", "\u663E\u793A\u5E2E\u52A9").action(() => {
   cli.outputHelp();
 });
 cli.help();
-cli.version(readPackageVersion());
+cli.version(readPackageVersion(), "-v, --cli-version");
 cli.parse();