@adep/cli 0.1.11 → 0.1.12

package/dist/index.js

@@ -707,20 +707,20 @@ var init_resolve = __esm({
 // packages/runtime/src/functions/runtime/worker-executor.ts
 import { readFileSync as readFileSync2 } from "node:fs";
 import { fileURLToPath as fileURLToPath2, pathToFileURL } from "node:url";
-import { dirname as dirname5, join as join4 } from "node:path";
+import { dirname as dirname5, join as join5 } from "node:path";
 import { Worker } from "node:worker_threads";
 function resolveWorkerEntry(baseDir = fileURLToPath2(new URL(".", import.meta.url))) {
   const candidates = [
-    join4(baseDir, "worker-entry.js"),
-    join4(baseDir, "worker-entry.ts"),
-    join4(baseDir, "domains/functions/runtime/worker-entry.js"),
-    join4(baseDir, "domains/functions/runtime/worker-entry.ts")
+    join5(baseDir, "worker-entry.js"),
+    join5(baseDir, "worker-entry.ts"),
+    join5(baseDir, "domains/functions/runtime/worker-entry.js"),
+    join5(baseDir, "domains/functions/runtime/worker-entry.ts")
   ];
   let current = baseDir;
   for (let depth = 0; depth < 8; depth += 1) {
     candidates.push(
-      join4(current, "packages/runtime/src/functions/runtime/worker-entry.js"),
-      join4(current, "packages/runtime/src/functions/runtime/worker-entry.ts")
+      join5(current, "packages/runtime/src/functions/runtime/worker-entry.js"),
+      join5(current, "packages/runtime/src/functions/runtime/worker-entry.ts")
     );
     const parent = dirname5(current);
     if (parent === current) break;
@@ -764,7 +764,7 @@ var init_worker_executor = __esm({
         const entry = input.entry ?? "index.ts";
         const deps = this.depsConfig === void 0 ? void 0 : resolveExecutionDeps(this.depsConfig, input.project.id, input.files["package.json"]);
         const logs = [];
-        return new Promise((resolve13, reject) => {
+        return new Promise((resolve15, reject) => {
           let worker;
           try {
             worker = new Worker(resolveWorkerEntry(), {
@@ -826,7 +826,7 @@ var init_worker_executor = __esm({
               if (message.type === "result") {
                 clearTimeout(timer);
                 void worker.terminate();
-                resolve13({ body: message.body, logs });
+                resolve15({ body: message.body, logs });
                 return;
               }
               if (message.type === "error") {
@@ -2838,15 +2838,15 @@ var init_cloud2 = __esm({
 });
 
 // packages/runtime/src/storage/driver/local.ts
-import { mkdir as mkdir4, readFile as readFile3, readdir as readdir2, rm as rm2, stat as stat4, unlink, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname6, join as join5 } from "node:path";
+import { mkdir as mkdir5, readFile as readFile4, readdir as readdir3, rm as rm2, stat as stat5, unlink, writeFile as writeFile4 } from "node:fs/promises";
+import { dirname as dirname6, join as join6 } from "node:path";
 function createLocalStorageDriver(options) {
   const quotaBytes = options.quotaBytes ?? PROJECT_QUOTA_BYTES;
-  const bucketDir = (projectId) => join5(options.dir, projectId);
-  const objectPath = (projectId, path) => join5(bucketDir(projectId), path);
-  const metaPath = (projectId, path) => join5(dirname6(objectPath(projectId, path)), `${path.split("/").pop() ?? ""}${META_SUFFIX}`);
+  const bucketDir = (projectId) => join6(options.dir, projectId);
+  const objectPath = (projectId, path) => join6(bucketDir(projectId), path);
+  const metaPath = (projectId, path) => join6(dirname6(objectPath(projectId, path)), `${path.split("/").pop() ?? ""}${META_SUFFIX}`);
   const readStoredMeta = async (projectId, path) => {
-    const raw = await readFile3(metaPath(projectId, path), "utf8");
+    const raw = await readFile4(metaPath(projectId, path), "utf8");
     return JSON.parse(raw);
   };
   const writeStoredMeta = async (projectId, path, meta) => {
@@ -2856,7 +2856,7 @@ function createLocalStorageDriver(options) {
       updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
       ...meta.contentType === void 0 ? {} : { contentType: meta.contentType }
     };
-    await writeFile3(metaPath(projectId, path), JSON.stringify(payload), "utf8");
+    await writeFile4(metaPath(projectId, path), JSON.stringify(payload), "utf8");
   };
   const totalSize = async (projectId) => {
     const root = bucketDir(projectId);
@@ -2864,20 +2864,20 @@ function createLocalStorageDriver(options) {
     const walk = async (dir) => {
       let entries;
       try {
-        entries = await readdir2(dir, { withFileTypes: true });
+        entries = await readdir3(dir, { withFileTypes: true });
       } catch {
         return;
       }
       const tasks = [];
       for (const entry of entries) {
-        const full = join5(dir, entry.name);
+        const full = join6(dir, entry.name);
         if (entry.isDirectory()) {
           tasks.push(walk(full));
         } else if (entry.isFile() && !entry.name.endsWith(META_SUFFIX)) {
           tasks.push(
             (async () => {
               try {
-                const info = await stat4(full);
+                const info = await stat5(full);
                 total += info.size;
               } catch {
               }
@@ -2899,7 +2899,7 @@ function createLocalStorageDriver(options) {
       const used = await totalSize(projectId);
       let existingSize = 0;
       try {
-        existingSize = (await stat4(objectPath(projectId, path))).size;
+        existingSize = (await stat5(objectPath(projectId, path))).size;
       } catch {
         existingSize = 0;
       }
@@ -2914,8 +2914,8 @@ function createLocalStorageDriver(options) {
         );
       }
       const dest = objectPath(projectId, path);
-      await mkdir4(dirname6(dest), { recursive: true });
-      await writeFile3(dest, data);
+      await mkdir5(dirname6(dest), { recursive: true });
+      await writeFile4(dest, data);
       await writeStoredMeta(projectId, path, {
         visibility: putOptions.visibility,
         size: data.byteLength,
@@ -2938,7 +2938,7 @@ function createLocalStorageDriver(options) {
       } catch {
         throw new StorageError(404, STORAGE_CODES.notFound, `\u6587\u4EF6 "${path}" \u4E0D\u5B58\u5728`);
       }
-      const data = await readFile3(objectPath(projectId, path));
+      const data = await readFile4(objectPath(projectId, path));
       const result = {
         path,
         size: meta.size,
@@ -2969,7 +2969,7 @@ function createLocalStorageDriver(options) {
       assertSafeStoragePath(path);
       let exists = true;
       try {
-        await stat4(objectPath(projectId, path));
+        await stat5(objectPath(projectId, path));
       } catch {
         exists = false;
       }
@@ -2986,14 +2986,14 @@ function createLocalStorageDriver(options) {
       const walk = async (dir, relative6) => {
         let entries;
         try {
-          entries = await readdir2(dir, { withFileTypes: true });
+          entries = await readdir3(dir, { withFileTypes: true });
         } catch {
           return;
         }
         const tasks = [];
         for (const entry of entries) {
           if (entry.name.endsWith(META_SUFFIX)) continue;
-          const full = join5(dir, entry.name);
+          const full = join6(dir, entry.name);
           const rel = relative6 === "" ? entry.name : `${relative6}/${entry.name}`;
           if (entry.isFile()) {
             if (prefix !== void 0 && !rel.startsWith(prefix)) continue;
@@ -3001,7 +3001,7 @@ function createLocalStorageDriver(options) {
               (async () => {
                 try {
                   const payload = JSON.parse(
-                    await readFile3(full + META_SUFFIX, "utf8")
+                    await readFile4(full + META_SUFFIX, "utf8")
                   );
                   metas.push({
                     path: rel,
@@ -3043,9 +3043,9 @@ var init_local = __esm({
 });
 
 // packages/cli/src/sim/storage.ts
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 function createSimStorageCapability(options) {
-  const dir = join6(options.cwd, ".adep", "sim", "storage");
+  const dir = join7(options.cwd, ".adep", "sim", "storage");
   const driver = createLocalStorageDriver({ dir });
   const signer = {
     secret: options.secret ?? "adep-sim-secret",
@@ -3218,33 +3218,33 @@ var init_merge = __esm({
 });
 
 // packages/cli/src/sim/runtime.ts
-import { mkdir as mkdir5, readFile as readFile4, writeFile as writeFile4 } from "node:fs/promises";
-import { dirname as dirname7, join as join7 } from "node:path";
+import { mkdir as mkdir6, readFile as readFile5, writeFile as writeFile5 } from "node:fs/promises";
+import { dirname as dirname7, join as join8 } from "node:path";
 function simDir(cwd) {
-  return join7(cwd, ".adep", "sim");
+  return join8(cwd, ".adep", "sim");
 }
 function jsonStorage(cwd) {
-  const file = join7(simDir(cwd), "db.json");
+  const file = join8(simDir(cwd), "db.json");
   return {
     async load() {
       try {
-        const raw = await readFile4(file, "utf8");
+        const raw = await readFile5(file, "utf8");
         return JSON.parse(raw);
       } catch {
         return null;
       }
     },
     async save(tables) {
-      await mkdir5(dirname7(file), { recursive: true });
-      await writeFile4(file, JSON.stringify(tables), "utf8");
+      await mkdir6(dirname7(file), { recursive: true });
+      await writeFile5(file, JSON.stringify(tables), "utf8");
     }
   };
 }
 async function createSimRuntime(options) {
-  const db = createSimDbCapability({
+  const db = options.driver === void 0 ? createSimDbCapability({
     storage: options.dbStorage ?? jsonStorage(options.cwd),
     ...options.log === void 0 ? {} : { log: options.log }
-  });
+  }) : { bundle: createDbCapability(options.driver), driver: options.driver, engine: null };
   const storage = createSimStorageCapability({
     cwd: options.cwd,
     ...options.baseUrl === void 0 ? {} : { baseUrl: options.baseUrl },
@@ -3253,7 +3253,7 @@ async function createSimRuntime(options) {
   const simRealtime = createSimRealtimeCapability();
   const kvBundle = createKvCapability(db.driver);
   const bundle = mergeBundles([db.bundle, storage.bundle, kvBundle, simRealtime.bundle]);
-  await db.engine.load();
+  if (db.engine !== null) await db.engine.load();
   return {
     bundle,
     realtime: simRealtime.realtime,
@@ -3266,6 +3266,7 @@ async function createSimRuntime(options) {
 var init_runtime = __esm({
   "packages/cli/src/sim/runtime.ts"() {
     "use strict";
+    init_cloud();
     init_db();
     init_kv();
     init_storage();
@@ -3275,8 +3276,8 @@ var init_runtime = __esm({
 });
 
 // packages/cli/src/sim/env.ts
-import { readFile as readFile5 } from "node:fs/promises";
-import { join as join8 } from "node:path";
+import { readFile as readFile6 } from "node:fs/promises";
+import { join as join9 } from "node:path";
 function parseEnv(content) {
   const env = {};
   for (const raw of content.split(/\r?\n/)) {
@@ -3291,8 +3292,8 @@ function parseEnv(content) {
   return env;
 }
 async function loadSimEnv(cwd, config = {}) {
-  const envRoot = await readFile5(join8(cwd, ".env"), "utf8").catch(() => "");
-  const envLocal = await readFile5(join8(cwd, ".env.local"), "utf8").catch(() => "");
+  const envRoot = await readFile6(join9(cwd, ".env"), "utf8").catch(() => "");
+  const envLocal = await readFile6(join9(cwd, ".env.local"), "utf8").catch(() => "");
   const merged = { ...parseEnv(envRoot), ...parseEnv(envLocal) };
   for (const secret of config.secrets ?? []) {
     if (merged[secret] !== void 0) continue;
@@ -3435,12 +3436,12 @@ var init_boundary = __esm({
 });
 
 // packages/cli/src/ts-config.ts
-import { stat as stat5, readFile as readFile6 } from "node:fs/promises";
-import { join as join9 } from "node:path";
+import { stat as stat6, readFile as readFile7 } from "node:fs/promises";
+import { join as join10 } from "node:path";
 async function loadAdepConfigModule(cwd) {
-  const configPath = join9(cwd, "adep.config.ts");
+  const configPath = join10(cwd, "adep.config.ts");
   try {
-    await stat5(configPath);
+    await stat6(configPath);
   } catch {
     return null;
   }
@@ -3452,7 +3453,7 @@ async function loadAdepConfigModule(cwd) {
       rawDefault = mod.default;
     } else {
       const { transform } = await import("esbuild");
-      const source = await readFile6(configPath, "utf8");
+      const source = await readFile7(configPath, "utf8");
       const { code } = await transform(source, {
         loader: "ts",
         format: "esm",
@@ -4326,9 +4327,9 @@ function isChainCapability(value) {
   return typeof spec === "object" && spec !== null && Array.isArray(spec.stepMethods) && Array.isArray(spec.terminalMethods);
 }
 function createChainClient(capability, port, pending, nextId, spec) {
-  const call = (method, args) => new Promise((resolve13, reject) => {
+  const call = (method, args) => new Promise((resolve15, reject) => {
     const id = nextId();
-    pending.set(id, { resolve: resolve13, reject });
+    pending.set(id, { resolve: resolve15, reject });
     port.postMessage({ type: "rpc", id, capability, method, args });
   });
   const makeChainable = (rootArgs, steps, txId) => new Proxy(
@@ -4400,7 +4401,7 @@ var init_chain = __esm({
 // packages/runtime/src/functions/runtime/worker-entry.ts
 import { parentPort, workerData } from "node:worker_threads";
 import { createRequire } from "node:module";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 function isRpcCapability(value) {
   return typeof value === "object" && value !== null && value[RPC_CAPABILITY_KEY] === true;
 }
@@ -4412,8 +4413,8 @@ function createRpcClient(capability, port, pending, nextId) {
         if (typeof method !== "string") return void 0;
         return (...args) => {
           const id = nextId();
-          return new Promise((resolve13, reject) => {
-            pending.set(id, { resolve: resolve13, reject });
+          return new Promise((resolve15, reject) => {
+            pending.set(id, { resolve: resolve15, reject });
             port.postMessage({ type: "rpc", id, capability, method, args });
           });
         };
@@ -4449,7 +4450,7 @@ function errorMessageWithLocation(error, files) {
 }
 function createBareResolver(deps) {
   const platformRequire = createRequire(import.meta.url);
-  const depsRequire = deps.dir === null ? null : createRequire(join10(deps.dir, "__deps__.js"));
+  const depsRequire = deps.dir === null ? null : createRequire(join11(deps.dir, "__deps__.js"));
   return (request) => {
     if (deps.builtin.includes(request)) return platformRequire(request);
     const root = splitBareSpecifier(request);
@@ -4640,8 +4641,8 @@ var init_shared_source = __esm({
 });
 
 // packages/cli/src/dev-shared.ts
-import { readdir as readdir3, readFile as readFile7 } from "node:fs/promises";
-import { join as join11 } from "node:path";
+import { readdir as readdir4, readFile as readFile8 } from "node:fs/promises";
+import { join as join12 } from "node:path";
 function bearerUserResolverFromEnv() {
   const raw = process.env.ADEP_AUTH_ISSUER;
   if (raw === void 0 || raw.trim() === "") return void 0;
@@ -4676,17 +4677,17 @@ async function collectFunctions(dir) {
   const walk = async (sub, prefix) => {
     let entries;
     try {
-      entries = await readdir3(sub, { withFileTypes: true });
+      entries = await readdir4(sub, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       const rel = prefix.length === 0 ? entry.name : `${prefix}/${entry.name}`;
-      const full = join11(sub, entry.name);
+      const full = join12(sub, entry.name);
       if (entry.isDirectory()) {
         await walk(full, rel);
       } else if (entry.isFile() && isRuntimeSource(entry.name)) {
-        files[rel] = await readFile7(full, "utf8");
+        files[rel] = await readFile8(full, "utf8");
       }
     }
   };
@@ -4774,8 +4775,8 @@ __export(dev_exports, {
 });
 import { createServer } from "node:http";
 import { watch } from "node:fs";
-import { mkdir as mkdir6, readFile as readFile8, writeFile as writeFile5 } from "node:fs/promises";
-import { basename as basename2, join as join12, resolve as resolve4 } from "node:path";
+import { mkdir as mkdir7, readFile as readFile9, writeFile as writeFile6 } from "node:fs/promises";
+import { basename as basename2, join as join13, resolve as resolve4 } from "node:path";
 async function loadConfig(cwd) {
   const name = basename2(resolve4(cwd));
   const config = await loadAdepConfigModule(cwd);
@@ -4819,10 +4820,10 @@ function printBoundaries(log) {
   }
 }
 async function ensureGitignore(cwd) {
-  const gitignorePath = join12(cwd, ".gitignore");
-  const existing = await readFile8(gitignorePath, "utf8").catch(() => "");
+  const gitignorePath = join13(cwd, ".gitignore");
+  const existing = await readFile9(gitignorePath, "utf8").catch(() => "");
   if (existing.split(/\r?\n/).includes(".adep/")) return;
-  await writeFile5(gitignorePath, `${existing.replace(/\n+$/, "")}
+  await writeFile6(gitignorePath, `${existing.replace(/\n+$/, "")}
 .adep/
 `, "utf8");
 }
@@ -4834,13 +4835,13 @@ async function startDevServer(options) {
   if (options.prefix !== void 0) {
     config.functionsPrefix = options.prefix.replace(/^\/+|\/+$/g, "");
   }
-  const functionsDir = join12(cwd, config.functionsDir);
+  const functionsDir = join13(cwd, config.functionsDir);
   const coldStartAt = Date.now();
   const bearerUser = bearerUserResolverFromEnv();
   const executor = new WorkerFunctionExecutor({
     deps: { rootDir: cwd, builtin: LOCAL_BUILTIN_DEPS }
   });
-  await mkdir6(functionsDir, { recursive: true });
+  await mkdir7(functionsDir, { recursive: true });
   const runtime = await createSimRuntime({
     cwd,
     projectId: "local",
@@ -4927,12 +4928,12 @@ async function startDevServer(options) {
   const reload = async () => {
     const [nextFiles, envText2] = await Promise.all([
       collectFunctions(functionsDir).then(mergeSharedIntoFunctions),
-      readFile8(join12(cwd, ".env.local"), "utf8").catch(() => "")
+      readFile9(join13(cwd, ".env.local"), "utf8").catch(() => "")
     ]);
     files = nextFiles;
     env = { ...config.environment, ...parseEnvFile(envText2) };
   };
-  const envText = await readFile8(join12(cwd, ".env.local"), "utf8").catch(() => "");
+  const envText = await readFile9(join13(cwd, ".env.local"), "utf8").catch(() => "");
   env = { ...config.environment, ...parseEnvFile(envText) };
   let debounceTimer;
   let watcher;
@@ -5245,7 +5246,7 @@ __export(db_exports, {
   dbStop: () => dbStop,
   splitSqlStatements: () => splitSqlStatements
 });
-import { readFile as readFile9 } from "node:fs/promises";
+import { readFile as readFile10 } from "node:fs/promises";
 import { resolve as resolve5 } from "node:path";
 async function open2(paths, options) {
   const client = await createClient(paths);
@@ -5353,7 +5354,7 @@ function splitSqlStatements(source) {
   return statements;
 }
 async function dbMigrate(paths, options) {
-  const source = await readFile9(resolve5(options.file), "utf8");
+  const source = await readFile10(resolve5(options.file), "utf8");
   const statements = splitSqlStatements(source);
   if (statements.length === 0) {
     throw new Error(`\u8FC1\u79FB\u6587\u4EF6\u6CA1\u6709\u53EF\u6267\u884C\u8BED\u53E5\uFF1A${options.file}`);
@@ -5423,6 +5424,10 @@ function renderBanner(options) {
     lines.push(`    - \u9759\u6001\u6258\u7BA1: \u65E0\uFF08${staticDir} \u76EE\u5F55\u4E0D\u5B58\u5728\uFF09`);
   }
   lines.push("    - \u7EC4\u4EF6\u9884\u89C8: Widget / Page \u4EA7\u7269\uFF08\u5982\u5DF2\u6784\u5EFA\uFF09");
+  if (options.dbMode !== void 0) {
+    const label = options.dbMode === "sqlite" ? `SQLite \u771F\u5B9E\u5E93${options.dbDriver === void 0 ? "" : `\uFF08${options.dbDriver}\uFF09`}` : "sim \u5F15\u64CE\uFF08\u5185\u7F6E\u6A21\u62DF\uFF09";
+    lines.push(`    - \u6570\u636E\u5E93: ${label} \u2192 ${options.dbTarget ?? "\uFF08\u672A\u6807\u6CE8\uFF09"}`);
+  }
   lines.push(`    - \u5065\u5EB7\u68C0\u67E5: ${baseUrl}/healthz`);
   lines.push("");
   lines.push("  \u8FB9\u754C\uFF08\u5F00\u53D1\u6001\u9ED8\u8BA4\u503C\uFF0C\u4E0D\u53EF\u5728\u6B64\u6A21\u5F0F\u4E0B\u5F00\u542F\uFF09:");
@@ -5455,6 +5460,132 @@ var init_banner = __esm({
   }
 });
 
+// packages/cli/src/serve/db-mode.ts
+import { resolve as resolve6 } from "node:path";
+function isServeDbMode(value) {
+  return SERVE_DB_MODES.includes(value.trim().toLowerCase());
+}
+function parseServeDbMode(raw, source) {
+  const value = raw.trim().toLowerCase();
+  if (!isServeDbMode(value)) {
+    throw new Error(
+      `${source} \u7684\u6570\u636E\u5E93\u6A21\u5F0F "${raw}" \u65E0\u6548\uFF1A\u53EA\u652F\u6301 ${SERVE_DB_MODES.join(" | ")}\uFF08sim = \u5185\u7F6E\u6A21\u62DF\u5F15\u64CE\u4E0E .adep/sim/db.json\uFF1Bsqlite = \u771F\u5B9E SQLite \u5E93\u6587\u4EF6\uFF09`
+    );
+  }
+  return value;
+}
+function resolveServeDbMode(explicit) {
+  if (explicit !== void 0) return parseServeDbMode(explicit, "--db");
+  const fromEnv = process.env["ADEP_SERVE_DB"];
+  if (fromEnv !== void 0 && fromEnv.trim() !== "") {
+    return parseServeDbMode(fromEnv, "ADEP_SERVE_DB");
+  }
+  return DEFAULT_SERVE_DB_MODE;
+}
+function resolveServeDbFile(cwd, explicit) {
+  const raw = explicit ?? envDbFile() ?? DEFAULT_SQLITE_DB_FILE;
+  return raw === ":memory:" ? raw : resolve6(cwd, raw);
+}
+function envDbFile() {
+  const raw = process.env["ADEP_SERVE_DB_FILE"];
+  return raw === void 0 || raw.trim() === "" ? void 0 : raw.trim();
+}
+var SERVE_DB_MODES, DEFAULT_SERVE_DB_MODE, DEFAULT_SQLITE_DB_FILE;
+var init_db_mode = __esm({
+  "packages/cli/src/serve/db-mode.ts"() {
+    "use strict";
+    SERVE_DB_MODES = ["sim", "sqlite"];
+    DEFAULT_SERVE_DB_MODE = "sim";
+    DEFAULT_SQLITE_DB_FILE = ".adep/data/project.sqlite";
+  }
+});
+
+// packages/cli/src/serve/sqlite-driver.ts
+import { mkdir as mkdir8 } from "node:fs/promises";
+import { dirname as dirname8, resolve as resolve7 } from "node:path";
+function isBun(versions) {
+  return versions["bun"] !== void 0 && versions["bun"] !== "";
+}
+function detectSqliteRuntime(versions = process.versions) {
+  if (isBun(versions)) return "bun";
+  const raw = versions["node"];
+  if (raw === void 0) return null;
+  const [majorText, minorText] = raw.split(".");
+  const major = Number(majorText);
+  const minor = Number(minorText ?? "0");
+  if (!Number.isInteger(major) || !Number.isInteger(minor)) return null;
+  if (major > NODE_SQLITE_MIN.major) return "node";
+  if (major === NODE_SQLITE_MIN.major && minor >= NODE_SQLITE_MIN.minor) return "node";
+  return null;
+}
+function sqliteModuleName(runtime) {
+  return runtime === "bun" ? "bun:sqlite" : "node:sqlite";
+}
+function sqliteRuntimeRequirementMessage(versions = process.versions) {
+  const current = isBun(versions) ? `Bun ${versions["bun"] ?? ""}`.trim() : `Node ${versions["node"] ?? "\u672A\u77E5"}`;
+  return `--db sqlite \u9700\u8981 Bun\uFF08\u5185\u7F6E bun:sqlite\uFF09\u6216 Node \u2265 ${NODE_SQLITE_MIN.major}.${NODE_SQLITE_MIN.minor}\uFF08\u5185\u7F6E node:sqlite\uFF09\uFF1B\u5F53\u524D\u8FD0\u884C\u65F6 ${current} \u4E0D\u63D0\u4F9B SQLite \u5185\u5EFA\u6A21\u5757\u3002\u8BF7\u6539\u7528 \`--db sim\`\uFF08\u5185\u7F6E\u6A21\u62DF\u5F15\u64CE\uFF0C\u65E0\u9700\u989D\u5916\u8FD0\u884C\u65F6\uFF09\uFF0C\u6216\u5347\u7EA7 Node / \u7528 Bun \u8FD0\u884C\u3002`;
+}
+async function openSqliteProjectDriver(file, options = {}) {
+  const runtime = options.runtime ?? detectSqliteRuntime();
+  if (runtime === null) throw new Error(sqliteRuntimeRequirementMessage());
+  const moduleName = sqliteModuleName(runtime);
+  const ctorName = runtime === "bun" ? "Database" : "DatabaseSync";
+  let mod;
+  try {
+    const specifier = moduleName;
+    mod = await import(
+      /* @vite-ignore */
+      specifier
+    );
+  } catch (error) {
+    throw new Error(
+      `${sqliteRuntimeRequirementMessage()}
+\uFF08\u8F7D\u5165 ${moduleName} \u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}\uFF09`,
+      { cause: error }
+    );
+  }
+  const Ctor = mod[ctorName];
+  if (Ctor === void 0) {
+    throw new Error(`${moduleName} \u672A\u5BFC\u51FA ${ctorName}\uFF1A\u5F53\u524D\u8FD0\u884C\u65F6\u7684 SQLite \u5185\u5EFA\u6A21\u5757\u4E0D\u53EF\u7528`);
+  }
+  const target = file === ":memory:" ? file : resolve7(file);
+  if (target !== ":memory:") await mkdir8(dirname8(target), { recursive: true });
+  const database = new Ctor(target);
+  database.exec("PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON;");
+  return {
+    engine: "sqlite",
+    async run(sql, params = []) {
+      if (params.length === 0) {
+        database.exec(sql);
+        return { changes: 0 };
+      }
+      const result = database.prepare(sql).run(...params);
+      return { changes: Number(result.changes) };
+    },
+    async all(sql, params = []) {
+      const statement = database.prepare(sql);
+      statement.setReturnArrays?.(false);
+      return statement.all(...params);
+    },
+    async get(sql, params = []) {
+      const statement = database.prepare(sql);
+      statement.setReturnArrays?.(false);
+      const row = statement.get(...params);
+      return row ?? null;
+    },
+    async close() {
+      database.close();
+    }
+  };
+}
+var NODE_SQLITE_MIN;
+var init_sqlite_driver = __esm({
+  "packages/cli/src/serve/sqlite-driver.ts"() {
+    "use strict";
+    NODE_SQLITE_MIN = { major: 22, minor: 5 };
+  }
+});
+
 // packages/cli/src/serve/server.ts
 var server_exports = {};
 __export(server_exports, {
@@ -5464,8 +5595,8 @@ __export(server_exports, {
 });
 import { createServer as createServer2 } from "node:http";
 import { watch as watch2 } from "node:fs";
-import { mkdir as mkdir7, readFile as readFile10, stat as stat6 } from "node:fs/promises";
-import { extname, join as join13, relative as relative2, resolve as resolve6 } from "node:path";
+import { mkdir as mkdir9, readFile as readFile11, stat as stat7 } from "node:fs/promises";
+import { extname, join as join14, relative as relative2, resolve as resolve8 } from "node:path";
 function envNumber(name) {
   const raw = process.env[name];
   if (raw === void 0 || raw.trim() === "") return void 0;
@@ -5483,22 +5614,29 @@ function contentTypeFor(path) {
   const ext = path.slice(path.lastIndexOf(".")).toLowerCase();
   return MIME_TYPES[ext] ?? "application/octet-stream";
 }
+function displayPath(cwd, target) {
+  if (target === ":memory:") return target;
+  const rel = relative2(cwd, target);
+  return rel.startsWith("..") ? target : rel;
+}
 async function startServeServer(options) {
-  const cwd = resolve6(options.cwd);
+  const cwd = resolve8(options.cwd);
   const log = options.log ?? ((line) => process.stdout.write(`${line}
 `));
   const host = options.host ?? envString("HOST") ?? "127.0.0.1";
   const port = resolveServePort(options.port);
-  const staticDir = resolve6(
+  const staticDir = resolve8(
     cwd,
     options.staticDir ?? envString("ADEP_SERVE_STATIC_DIR") ?? "public"
   );
+  const dbMode = resolveServeDbMode(options.db);
+  const sqliteFile = dbMode === "sqlite" ? resolveServeDbFile(cwd, options.dbFile) : null;
   const config = await loadConfig(cwd);
-  const functionsDir = join13(cwd, config.functionsDir);
+  const functionsDir = join14(cwd, config.functionsDir);
   const bearerUser = bearerUserResolverFromEnv();
   let hasStatic = false;
   try {
-    const publicStat = await stat6(staticDir);
+    const publicStat = await stat7(staticDir);
     hasStatic = publicStat.isDirectory();
   } catch {
     hasStatic = false;
@@ -5506,18 +5644,27 @@ async function startServeServer(options) {
   const loadFunctionFiles = async () => mergeSharedIntoFunctions(await collectFunctions(functionsDir));
   let files = await loadFunctionFiles();
   let functionNames = listFunctionNames(files);
-  const envText = await readFile10(join13(cwd, ".env.local"), "utf8").catch(() => "");
+  const envText = await readFile11(join14(cwd, ".env.local"), "utf8").catch(() => "");
   let env = parseEnvFile(envText);
   let simEnv = await loadSimEnv(cwd).catch(() => ({}));
+  let sqliteModule = null;
+  let sqliteDriver = null;
+  if (sqliteFile !== null) {
+    const runtimeName = detectSqliteRuntime();
+    if (runtimeName === null) throw new Error(sqliteRuntimeRequirementMessage());
+    sqliteModule = sqliteModuleName(runtimeName);
+    sqliteDriver = await openSqliteProjectDriver(sqliteFile, { runtime: runtimeName });
+  }
   const runtime = await createSimRuntime({
     cwd,
     projectId: "local",
     baseUrl: `http://${host}:${port}`,
-    log
+    log,
+    ...sqliteDriver === null ? {} : { driver: sqliteDriver }
   });
   if (options.schemaFile !== void 0) {
-    const schemaPath = resolve6(cwd, options.schemaFile);
-    const schemaSource = await readFile10(schemaPath, "utf8").catch(
+    const schemaPath = resolve8(cwd, options.schemaFile);
+    const schemaSource = await readFile11(schemaPath, "utf8").catch(
       (error) => {
         if (error.code === "ENOENT") {
           throw new Error(`schema \u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${schemaPath}`);
@@ -5528,18 +5675,23 @@ async function startServeServer(options) {
     const statements = splitSqlStatements(schemaSource);
     let applied = 0;
     let skipped = 0;
-    for (const statement of statements) {
+    for (const [index, statement] of statements.entries()) {
       try {
-        await runtime.db.engine.run(statement);
+        await runtime.db.driver.run(statement);
         applied += 1;
       } catch (error) {
         const isUnsupported = error instanceof Error && "code" in error && error.code === "DB_UNSAFE_OP";
-        if (isUnsupported) {
+        if (dbMode === "sim" && isUnsupported) {
           skipped += 1;
           log(`[serve] \u8DF3\u8FC7 schema \u8BED\u53E5\uFF08sim \u5F15\u64CE\u4E0D\u652F\u6301\uFF09\uFF1A${statement.slice(0, 60)}\u2026`);
-        } else {
-          throw error;
+          continue;
         }
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(
+          `schema \u8BED\u53E5\u6267\u884C\u5931\u8D25\uFF08--schema ${options.schemaFile}\uFF0C\u7B2C ${index + 1} \u6761\uFF0Cdb \u6A21\u5F0F ${dbMode}\uFF09\uFF1A${detail}
+\u8BED\u53E5\uFF1A${statement.slice(0, 200)}` + (dbMode === "sqlite" ? "\n\uFF08sqlite \u6A21\u5F0F\u4E0D\u505A\u8BED\u53E5\u8DF3\u8FC7\uFF1B\u5982\u9700\u8DF3\u8FC7\u8BED\u4E49\u8BF7\u6539\u7528 --db sim\uFF09" : ""),
+          { cause: error }
+        );
       }
     }
     const skipNote = skipped > 0 ? `\uFF0C\u8DF3\u8FC7 ${skipped} \u6761` : "";
@@ -5555,7 +5707,7 @@ async function startServeServer(options) {
     const reload = async () => {
       const [nextFiles, envLocalText] = await Promise.all([
         loadFunctionFiles(),
-        readFile10(join13(cwd, ".env.local"), "utf8").catch(() => "")
+        readFile11(join14(cwd, ".env.local"), "utf8").catch(() => "")
       ]);
       files = nextFiles;
       env = parseEnvFile(envLocalText);
@@ -5572,7 +5724,7 @@ async function startServeServer(options) {
         void reload();
       }, 120);
     };
-    await mkdir7(functionsDir, { recursive: true }).catch(() => void 0);
+    await mkdir9(functionsDir, { recursive: true }).catch(() => void 0);
     try {
       watchers.push(watch2(functionsDir, { recursive: true }, scheduleReload));
     } catch {
@@ -5610,16 +5762,16 @@ async function startServeServer(options) {
   const serveStatic = async (pathname, res) => {
     if (!hasStatic) return false;
     const safePath = pathname.replace(/\.\.\//g, "").replace(/^\//, "");
-    const filePath = join13(staticDir, safePath);
-    const resolvedPath = safePath === "" || safePath === "/" ? join13(filePath, "index.html") : filePath;
+    const filePath = join14(staticDir, safePath);
+    const resolvedPath = safePath === "" || safePath === "/" ? join14(filePath, "index.html") : filePath;
     try {
-      const fileStat = await stat6(resolvedPath);
+      const fileStat = await stat7(resolvedPath);
       if (fileStat.isDirectory()) {
-        const indexPath = join13(resolvedPath, "index.html");
+        const indexPath = join14(resolvedPath, "index.html");
         try {
-          const indexStat = await stat6(indexPath);
+          const indexStat = await stat7(indexPath);
           if (indexStat.isFile()) {
-            const content2 = await readFile10(indexPath);
+            const content2 = await readFile11(indexPath);
             res.writeHead(200, { "content-type": contentTypeFor(indexPath) });
             res.end(content2);
             return true;
@@ -5628,7 +5780,7 @@ async function startServeServer(options) {
         }
         return false;
       }
-      const content = await readFile10(resolvedPath);
+      const content = await readFile11(resolvedPath);
       res.writeHead(200, { "content-type": contentTypeFor(resolvedPath) });
       res.end(content);
       return true;
@@ -5637,7 +5789,7 @@ async function startServeServer(options) {
         const ext = extname(pathname);
         if (ext === "" || ext === ".html") {
           try {
-            const indexContent = await readFile10(join13(staticDir, "index.html"));
+            const indexContent = await readFile11(join14(staticDir, "index.html"));
             res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
             res.end(indexContent);
             return true;
@@ -5724,6 +5876,8 @@ async function startServeServer(options) {
         project: config.name,
         functions: functionNames,
         static: hasStatic,
+        // CLI-020：当前数据面（换模式即换库，这里让脚本/e2e 有可断言的读数）。
+        db: sqliteFile === null ? { mode: "sim", file: displayPath(cwd, join14(simDir(cwd), "db.json")) } : { mode: "sqlite", file: displayPath(cwd, sqliteFile), driver: sqliteModule },
         endpoints: {
           functions: "/api/{fn}",
           static: `/ \u2192 ${staticDir}`,
@@ -5762,14 +5916,19 @@ async function startServeServer(options) {
     functions: functionNames,
     functionsPrefix: config.functionsPrefix,
     hasStatic,
-    staticDir: relative2(cwd, staticDir).length > 0 ? relative2(cwd, staticDir) : staticDir
+    staticDir: relative2(cwd, staticDir).length > 0 ? relative2(cwd, staticDir) : staticDir,
+    dbMode,
+    dbTarget: sqliteFile === null ? displayPath(cwd, join14(simDir(cwd), "db.json")) : displayPath(cwd, sqliteFile),
+    ...sqliteModule === null ? {} : { dbDriver: sqliteModule }
   });
   log(banner);
   if (options.watch === true) {
     log(`[serve] \u70ED\u91CD\u8F7D\u5DF2\u5F00\u542F\uFF1A\u6539 functions/ \u4E0E .env* \u5373\u751F\u6548\uFF0C\u51FD\u6570 console \u8F93\u51FA\u76F4\u8FBE\u7EC8\u7AEF\uFF08--watch\uFF09`);
   }
   if (bearerUser !== void 0) {
-    log(`[serve] \u767B\u5F55\u5373\u670D\u52A1\uFF1AADEP_AUTH_ISSUER \u5DF2\u914D\u7F6E\uFF0CBearer token \u5C06\u89E3\u6790\u4E3A\u7528\u6237\u8EAB\u4EFD\uFF08userinfo \u7AEF\u70B9\uFF09`);
+    log(
+      `[serve] \u767B\u5F55\u5373\u670D\u52A1\uFF1AADEP_AUTH_ISSUER \u5DF2\u914D\u7F6E\uFF0CBearer token \u5C06\u89E3\u6790\u4E3A\u7528\u6237\u8EAB\u4EFD\uFF08userinfo \u7AEF\u70B9\uFF09`
+    );
   }
   return {
     port: actualPort,
@@ -5780,6 +5939,7 @@ async function startServeServer(options) {
       await new Promise((resolveClose) => {
         server.close(() => resolveClose());
       });
+      await runtime.dispose();
     }
   };
 }
@@ -5797,6 +5957,8 @@ var init_server = __esm({
     init_invoke();
     init_dev();
     init_banner();
+    init_db_mode();
+    init_sqlite_driver();
     init_dev_shared();
     MIME_TYPES = {
       ".html": "text/html; charset=utf-8",
@@ -5831,8 +5993,8 @@ __export(deploy_exports, {
   deploy: () => deploy
 });
 import { createHash as createHash2 } from "node:crypto";
-import { readdir as readdir4, readFile as readFile11 } from "node:fs/promises";
-import { join as join14, resolve as resolve7, basename as basename3, relative as relative3, sep } from "node:path";
+import { readdir as readdir5, readFile as readFile12 } from "node:fs/promises";
+import { join as join15, resolve as resolve9, basename as basename3, relative as relative3, sep } from "node:path";
 function functionUrlBase(prefix) {
   const raw = (prefix ?? "/api").trim();
   const normalized = raw === "/" ? "/" : raw.replace(/\/+$/, "");
@@ -5844,7 +6006,7 @@ function isRuntimeSource2(name) {
 async function collectFunctionFiles(functionsDir) {
   let dirents;
   try {
-    dirents = await readdir4(functionsDir, { withFileTypes: true });
+    dirents = await readdir5(functionsDir, { withFileTypes: true });
   } catch {
     return {};
   }
@@ -5858,10 +6020,10 @@ async function collectFunctionFiles(functionsDir) {
   if (conflicting.length > 0) throw new AmbiguousFunctionError(functionsDir, conflicting);
   const out = {};
   for (const name of flatNames) {
-    out[name] = { "index.ts": await readFile11(join14(functionsDir, `${name}.ts`), "utf8") };
+    out[name] = { "index.ts": await readFile12(join15(functionsDir, `${name}.ts`), "utf8") };
   }
   for (const name of dirNames) {
-    const files = await collectFunctionDir(join14(functionsDir, name));
+    const files = await collectFunctionDir(join15(functionsDir, name));
     if (files["index.ts"] === void 0) continue;
     out[name] = files;
   }
@@ -5872,7 +6034,7 @@ async function collectFunctionDir(absDir) {
   const walk = async (dir, prefix) => {
     let entries;
     try {
-      entries = await readdir4(dir, { withFileTypes: true });
+      entries = await readdir5(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -5880,11 +6042,11 @@ async function collectFunctionDir(absDir) {
       const rel = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
       if (entry.isDirectory()) {
         if (entry.name === "__tests__" || IGNORED_DIRS.has(entry.name)) continue;
-        await walk(join14(dir, entry.name), rel);
+        await walk(join15(dir, entry.name), rel);
         continue;
       }
       if (!isRuntimeSource2(entry.name)) continue;
-      files[rel] = await readFile11(join14(dir, entry.name), "utf8");
+      files[rel] = await readFile12(join15(dir, entry.name), "utf8");
     }
   };
   await walk(absDir, "");
@@ -5894,25 +6056,25 @@ function sha256Hex(content) {
   return createHash2("sha256").update(content).digest("hex");
 }
 async function collectShared(functionsDir) {
-  const sharedDir = join14(functionsDir, "_shared");
+  const sharedDir = join15(functionsDir, "_shared");
   const files = {};
   const walk = async (dir) => {
     let entries;
     try {
-      entries = await readdir4(dir, { withFileTypes: true });
+      entries = await readdir5(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (entry.name === "__tests__" || entry.name === "node_modules") continue;
-        await walk(join14(dir, entry.name));
+        await walk(join15(dir, entry.name));
         continue;
       }
       if (!isRuntimeSource2(entry.name)) continue;
-      const full = join14(dir, entry.name);
+      const full = join15(dir, entry.name);
       const rel = relative3(sharedDir, full).split(sep).join("/");
-      files[`${SHARED_SOURCE_ROOT3}${rel}`] = await readFile11(full, "utf8");
+      files[`${SHARED_SOURCE_ROOT3}${rel}`] = await readFile12(full, "utf8");
     }
   };
   await walk(sharedDir);
@@ -5923,10 +6085,10 @@ async function deploy(paths, options) {
   const log = options.silent === true ? () => void 0 : options.log ?? ((line) => process.stdout.write(`${line}
 `));
   const client = await createClient(paths);
-  const cwd = resolve7(options.cwd);
+  const cwd = resolve9(options.cwd);
   const config = await loadConfig(cwd);
   const slug = options.slug ?? config.name;
-  const functionsDir = options.functionsDir === void 0 ? join14(cwd, config.functionsDir) : resolve7(cwd, options.functionsDir);
+  const functionsDir = options.functionsDir === void 0 ? join15(cwd, config.functionsDir) : resolve9(cwd, options.functionsDir);
   const local = await collectFunctionFiles(functionsDir);
   if (Object.keys(local).length === 0) {
     throw new CliError("NO_FUNCTIONS", `${functionsDir} \u4E0B\u6CA1\u6709\u51FD\u6570\u6587\u4EF6`);
@@ -6057,8 +6219,8 @@ var frontend_exports = {};
 __export(frontend_exports, {
   frontendSync: () => frontendSync
 });
-import { readdir as readdir5, readFile as readFile12, stat as stat7 } from "node:fs/promises";
-import { join as join15, relative as relative4, sep as sep2 } from "node:path";
+import { readdir as readdir6, readFile as readFile13, stat as stat8 } from "node:fs/promises";
+import { join as join16, relative as relative4, sep as sep2 } from "node:path";
 async function resolveProjectId(client, cwd, slug) {
   const resolvedSlug = await resolveSlug(cwd, slug);
   const listed = await client.request("/api/v1/projects", {}, "PROJECT_LIST_FAILED");
@@ -6074,24 +6236,24 @@ async function resolveProjectId(client, cwd, slug) {
 async function collectFiles(root, dir) {
   const files = /* @__PURE__ */ new Map();
   const skipped = [];
-  const entries = await readdir5(dir, { withFileTypes: true });
+  const entries = await readdir6(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isDirectory()) {
       if (IGNORED_DIRS2.has(entry.name)) continue;
-      const nested = await collectFiles(root, join15(dir, entry.name));
+      const nested = await collectFiles(root, join16(dir, entry.name));
       for (const [path, content] of nested.files) files.set(path, content);
       skipped.push(...nested.skipped);
       continue;
     }
-    const full = join15(dir, entry.name);
+    const full = join16(dir, entry.name);
     const rel = relative4(root, full).split(sep2).join("/");
-    const info = await stat7(full);
+    const info = await stat8(full);
     if (info.size > 1024 * 1024) {
       skipped.push(rel);
       continue;
     }
     try {
-      const content = await readFile12(full, "utf8");
+      const content = await readFile13(full, "utf8");
       if (content.includes("\0")) {
         skipped.push(rel);
         continue;
@@ -6106,8 +6268,8 @@ async function collectFiles(root, dir) {
 async function frontendSync(paths, options) {
   const log = options.silent === true ? () => void 0 : options.log ?? ((line) => process.stdout.write(`${line}
 `));
-  const webDir = options.dir ?? join15(options.cwd, "web");
-  const rootStat = await stat7(webDir).catch(() => null);
+  const webDir = options.dir ?? join16(options.cwd, "web");
+  const rootStat = await stat8(webDir).catch(() => null);
   if (rootStat === null || !rootStat.isDirectory()) {
     throw new CliError(
       "FRONTEND_DIR_MISSING",
@@ -6172,7 +6334,7 @@ var client_exports2 = {};
 __export(client_exports2, {
   createExportApiClient: () => createExportApiClient
 });
-import { writeFile as writeFile6 } from "node:fs/promises";
+import { writeFile as writeFile7 } from "node:fs/promises";
 function toExportJob(view) {
   return {
     id: view.id,
@@ -6223,7 +6385,7 @@ async function createExportApiClient(paths) {
       }
       const response = await client.download(download.downloadUrl, "EXPORT_DOWNLOAD_FAILED");
       const bytes = Buffer.from(await response.arrayBuffer());
-      await writeFile6(outputPath, bytes);
+      await writeFile7(outputPath, bytes);
       return { path: outputPath, size: bytes.length };
     }
   };
@@ -6320,33 +6482,33 @@ var fs_exports = {};
 __export(fs_exports, {
   createExportFileSystem: () => createExportFileSystem
 });
-import { mkdir as mkdir8, readFile as readFile13, rm as rm3, stat as stat9, writeFile as writeFile7 } from "node:fs/promises";
-import { dirname as dirname8, join as join17 } from "node:path";
+import { mkdir as mkdir10, readFile as readFile14, rm as rm3, stat as stat10, writeFile as writeFile8 } from "node:fs/promises";
+import { dirname as dirname9, join as join18 } from "node:path";
 function createExportFileSystem() {
   return {
-    readFile: (path) => readFile13(path),
-    writeFile: (path, content) => writeFile7(path, content),
+    readFile: (path) => readFile14(path),
+    writeFile: (path, content) => writeFile8(path, content),
     // 同时用于清理解压临时目录（${zip}.tmp 是个目录）——递归强制删除，缺失不报错。
     deleteFile: async (path) => {
       await rm3(path, { recursive: true, force: true });
     },
     fileExists: async (path) => {
       try {
-        await stat9(path);
+        await stat10(path);
         return true;
       } catch {
         return false;
       }
     },
     mkdir: async (path) => {
-      await mkdir8(path, { recursive: true });
+      await mkdir10(path, { recursive: true });
     },
     unzip: async (zipPath, targetDir) => {
-      const entries = zipRead(await readFile13(zipPath));
+      const entries = zipRead(await readFile14(zipPath));
       for (const [name, data] of entries) {
-        const dest = join17(targetDir, name);
-        await mkdir8(dirname8(dest), { recursive: true });
-        await writeFile7(dest, data);
+        const dest = join18(targetDir, name);
+        await mkdir10(dirname9(dest), { recursive: true });
+        await writeFile8(dest, data);
       }
     }
   };
@@ -6847,7 +7009,7 @@ ${detail}`);
        * @param ms 毫秒数
        */
       sleep(ms) {
-        return new Promise((resolve13) => setTimeout(resolve13, ms));
+        return new Promise((resolve15) => setTimeout(resolve15, ms));
       }
     };
   }
@@ -6862,11 +7024,11 @@ __export(storage_exports, {
   storageRemove: () => storageRemove,
   storageUpload: () => storageUpload
 });
-import { mkdir as mkdir9, readFile as readFile14, stat as stat10, writeFile as writeFile8 } from "node:fs/promises";
-import { basename as basename4, dirname as dirname9, extname as extname2, join as join18, resolve as resolve9 } from "node:path";
+import { mkdir as mkdir11, readFile as readFile15, stat as stat11, writeFile as writeFile9 } from "node:fs/promises";
+import { basename as basename4, dirname as dirname10, extname as extname2, join as join19, resolve as resolve11 } from "node:path";
 async function open3(paths, options) {
   const client = await createClient(paths);
-  const project2 = await resolveSlug(resolve9(options.cwd), options.slug);
+  const project2 = await resolveSlug(resolve11(options.cwd), options.slug);
   return { client, project: project2 };
 }
 function contentTypeOf(path) {
@@ -6899,13 +7061,13 @@ function contentTypeOf(path) {
 }
 async function storageUpload(paths, options) {
   const { client, project: project2 } = await open3(paths, options);
-  const local = resolve9(options.file);
-  const info = await stat10(local).catch(() => null);
+  const local = resolve11(options.file);
+  const info = await stat11(local).catch(() => null);
   if (info === null || !info.isFile()) {
     throw new CliError("FILE_NOT_FOUND", `\u672C\u5730\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${local}`);
   }
   const visibility = options.visibility ?? "private";
-  const bytes = await readFile14(local);
+  const bytes = await readFile15(local);
   const form = new FormData();
   form.set("path", options.path);
   form.set("visibility", visibility);
@@ -6946,9 +7108,9 @@ async function storageDownload(paths, options) {
   const url = await resolveDownloadUrl(client, project2, options.path);
   const response = await client.download(url, "STORAGE_DOWNLOAD_FAILED");
   const bytes = Buffer.from(await response.arrayBuffer());
-  const output = resolve9(options.output ?? join18(resolve9(options.cwd), basename4(options.path)));
-  await mkdir9(dirname9(output), { recursive: true });
-  await writeFile8(output, bytes);
+  const output = resolve11(options.output ?? join19(resolve11(options.cwd), basename4(options.path)));
+  await mkdir11(dirname10(output), { recursive: true });
+  await writeFile9(output, bytes);
   return { path: options.path, output, size: bytes.length };
 }
 async function storageRemove(paths, options) {
@@ -6972,7 +7134,7 @@ __export(doctor_exports, {
   formatDoctorReport: () => formatDoctorReport,
   runDoctor: () => runDoctor
 });
-import { stat as stat11 } from "node:fs/promises";
+import { stat as stat12 } from "node:fs/promises";
 async function probeServer(server) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), SERVER_PROBE_TIMEOUT_MS);
@@ -6990,7 +7152,7 @@ async function probeServer(server) {
 }
 async function credentialMode(file) {
   try {
-    const info = await stat11(file);
+    const info = await stat12(file);
     return (info.mode & 511).toString(8).padStart(3, "0");
   } catch {
     return void 0;
@@ -7079,7 +7241,7 @@ __export(mcp_exports, {
   mcpPublish: () => mcpPublish,
   mcpUnpublish: () => mcpUnpublish
 });
-import { resolve as resolve10 } from "node:path";
+import { resolve as resolve12 } from "node:path";
 async function mcpPublish(paths, options) {
   const fn = requireFunctionName(options.fn);
   const client = await createClient(paths);
@@ -7160,7 +7322,7 @@ function requireFunctionName(fn) {
   return fn.trim();
 }
 async function resolveProject(client, options) {
-  const slug = await resolveSlug(resolve10(options.cwd), options.slug);
+  const slug = await resolveSlug(resolve12(options.cwd), options.slug);
   const listed = await client.request("/api/v1/projects", {}, "PROJECT_LIST_FAILED");
   const match = listed.projects.find((project2) => project2.slug === slug);
   if (match === void 0) {
@@ -7360,7 +7522,7 @@ __export(functions_exports, {
   functionsList: () => functionsList,
   functionsLogs: () => functionsLogs
 });
-import { resolve as resolve11 } from "node:path";
+import { resolve as resolve13 } from "node:path";
 async function functionsList(paths, options) {
   const client = await createClient(paths);
   const project2 = await resolveProject2(client, options);
@@ -7402,7 +7564,7 @@ async function functionsLogs(paths, options) {
   return { functionId: target.id, name: target.name, logs: result.logs };
 }
 async function resolveProject2(client, options) {
-  const slug = await resolveSlug(resolve11(options.cwd), options.slug);
+  const slug = await resolveSlug(resolve13(options.cwd), options.slug);
   const projects = await projectsListFrom(client);
   const match = projects.find((project2) => project2.slug === slug);
   if (match === void 0) {
@@ -7433,11 +7595,11 @@ __export(hosting_exports, {
   hostingInfo: () => hostingInfo,
   hostingPull: () => hostingPull
 });
-import { readdir as readdir6, readFile as readFile15, stat as stat12 } from "node:fs/promises";
-import { dirname as dirname10, join as join19, relative as relative5, resolve as resolve12, sep as sep3 } from "node:path";
+import { readdir as readdir7, readFile as readFile16, stat as stat13 } from "node:fs/promises";
+import { dirname as dirname11, join as join20, relative as relative5, resolve as resolve14, sep as sep3 } from "node:path";
 async function open4(paths, options) {
   const client = await createClient(paths);
-  const project2 = await resolveSlug(resolve12(options.cwd), options.slug);
+  const project2 = await resolveSlug(resolve14(options.cwd), options.slug);
   return { client, project: project2 };
 }
 async function hostingInfo(paths, options) {
@@ -7450,17 +7612,17 @@ async function hostingInfo(paths, options) {
   };
 }
 async function collectSiteFiles(dir) {
-  const root = resolve12(dir);
+  const root = resolve14(dir);
   const files = /* @__PURE__ */ new Map();
   const walk = async (sub) => {
     let entries;
     try {
-      entries = await readdir6(sub, { withFileTypes: true });
+      entries = await readdir7(sub, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const full = join19(sub, entry.name);
+      const full = join20(sub, entry.name);
       if (entry.isDirectory()) {
         await walk(full);
       } else if (entry.isFile()) {
@@ -7478,13 +7640,13 @@ async function hostingDeploy(paths, options) {
 `));
   const files = await collectSiteFiles(options.dir);
   if (files.size === 0) {
-    throw new CliError("NO_SITE_FILES", `\u7AD9\u70B9\u76EE\u5F55\u4E3A\u7A7A\uFF1A${resolve12(options.dir)}`);
+    throw new CliError("NO_SITE_FILES", `\u7AD9\u70B9\u76EE\u5F55\u4E3A\u7A7A\uFF1A${resolve14(options.dir)}`);
   }
   const uploaded = [];
   for (const [rel, full] of files) {
     log(`[adep] \u4E0A\u4F20 site/${rel}`);
-    const info2 = await stat12(full);
-    const bytes = await readFile15(full);
+    const info2 = await stat13(full);
+    const bytes = await readFile16(full);
     const form = new FormData();
     form.set("path", `site/${rel}`);
     form.set("visibility", "public");
@@ -7511,8 +7673,8 @@ async function hostingPull(paths, options) {
   const log = options.log ?? ((line) => process.stdout.write(`${line}
 `));
   const info = await hostingInfo(paths, options);
-  const outputDir = resolve12(options.output ?? resolve12(options.cwd));
-  const { mkdir: mkdir10, writeFile: writeFile9 } = await import("node:fs/promises");
+  const outputDir = resolve14(options.output ?? resolve14(options.cwd));
+  const { mkdir: mkdir12, writeFile: writeFile10 } = await import("node:fs/promises");
   const files = [];
   for (const entry of info.files) {
     if (entry.visibility !== "public" || entry.path === HOSTING_CONFIG_PATH) continue;
@@ -7522,9 +7684,9 @@ async function hostingPull(paths, options) {
     const response = await client.download(url, "HOSTING_DOWNLOAD_FAILED");
     const bytes = Buffer.from(await response.arrayBuffer());
     const rel = entry.path.replace(/^site\//, "");
-    const target = join19(outputDir, ...rel.split("/"));
-    await mkdir10(dirname10(target), { recursive: true });
-    await writeFile9(target, bytes);
+    const target = join20(outputDir, ...rel.split("/"));
+    await mkdir12(dirname11(target), { recursive: true });
+    await writeFile10(target, bytes);
     files.push({ path: entry.path, size: bytes.length });
   }
   return { siteUrl: info.siteUrl, outputDir, files };
@@ -10808,19 +10970,30 @@ function cliVersionOf() {
   const pkg = JSON.parse(readFileSync(findCliPackageJson(), "utf8"));
   return pkg.version;
 }
+function cliPackageRoot() {
+  return dirname2(findCliPackageJson());
+}
+function localTemplateDir(code) {
+  return join(cliPackageRoot(), "src", "templates", code);
+}
 function templateFiles(code, name) {
   const generated = GENERATED_TEMPLATES[code];
   if (generated === void 0) {
     throw new Error(`\u672A\u77E5\u6A21\u677F "${code}"\uFF1A\u53EF\u9009 ${TEMPLATE_NAMES.join(" | ")}`);
   }
   const { manifest, files } = generated;
-  const vars = { name, template: code };
-  const dirFiles = renderTemplateFiles(files, vars, manifest);
+  return renderTemplatePackage({ code, version: manifest.version, manifest, files }, name);
+}
+function renderTemplatePackage(pkg, name) {
+  const manifest = pkg.manifest;
+  const vars = { name, template: pkg.code };
+  const dirFiles = renderTemplateFiles(pkg.files, vars, manifest);
+  const code = pkg.code;
   const ctx = { name, template: code, cliVersion: cliVersionOf() };
   const sharedFiles = (manifest.sharedAssets ?? []).flatMap((assetName) => {
     const asset = SHARED_ASSETS[assetName];
     if (asset === void 0) {
-      throw new Error(`\u6A21\u677F ${code} \u58F0\u660E\u4E86\u672A\u77E5\u5171\u4EAB\u8D44\u4EA7 "${assetName}"\uFF08shared-assets.ts \u672A\u6CE8\u518C\uFF09`);
+      throw new Error(`\u6A21\u677F ${pkg.code} \u58F0\u660E\u4E86\u672A\u77E5\u5171\u4EAB\u8D44\u4EA7 "${assetName}"\uFF08shared-assets.ts \u672A\u6CE8\u518C\uFF09`);
     }
     return asset(ctx);
   });
@@ -10835,7 +11008,7 @@ var InitError = class extends Error {
     this.name = "InitError";
   }
 };
-async function initProject(cwd, name, template) {
+async function initProject(cwd, name, template, filesOverride) {
   if (!/^[a-z][a-z0-9-]{0,62}$/.test(name)) {
     throw new InitError(
       "INVALID_NAME",
@@ -10858,7 +11031,7 @@ async function initProject(cwd, name, template) {
   if (existing !== null) {
     throw new InitError("DIR_EXISTS", `\u76EE\u5F55 ${projectPath} \u5DF2\u5B58\u5728\uFF1A\u8BF7\u6362\u4E00\u4E2A\u540D\u5B57\u6216\u5148\u5220\u9664`);
   }
-  const files = templateFiles(template, name);
+  const files = filesOverride ?? templateFiles(template, name);
   await mkdir2(projectPath, { recursive: true });
   await Promise.all(
     files.map(async (file) => {
@@ -11039,19 +11212,178 @@ async function fetchTemplates(server) {
   return templates ?? [];
 }
 
+// packages/cli/src/template-package.ts
+init_auth();
+init_credentials();
+import { mkdir as mkdir3, readFile as readFile2, readdir, stat as stat3, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join3 } from "node:path";
+function cachedPackagePath(paths, code, version) {
+  return join3(paths.home, "templates", `${code}-${version}.json`);
+}
+async function collectTemplateDir(dir) {
+  const files = [];
+  async function walk(current, prefix) {
+    const entries = await readdir(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = join3(current, entry.name);
+      const rel = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
+      if (entry.isDirectory()) {
+        await walk(full, rel);
+      } else {
+        files.push({ path: rel, content: await readFile2(full, "utf8") });
+      }
+    }
+  }
+  await walk(dir, "");
+  files.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+  return files;
+}
+async function loadCachedPackage(paths, code, version) {
+  let text;
+  try {
+    text = await readFile2(cachedPackagePath(paths, code, version), "utf8");
+  } catch {
+    return null;
+  }
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (typeof raw !== "object" || raw === null) return null;
+  const pkg = raw;
+  if (pkg.code !== code || pkg.version !== version || !Array.isArray(pkg.files)) return null;
+  return pkg;
+}
+async function saveCachedPackage(paths, pkg) {
+  await mkdir3(join3(paths.home, "templates"), { recursive: true });
+  await writeFile2(cachedPackagePath(paths, pkg.code, pkg.version), JSON.stringify(pkg), "utf8");
+}
+async function downloadTemplatePackage(server, code) {
+  let response;
+  try {
+    response = await fetch(`${server}/api/v1/templates/${code}/package`);
+  } catch (error) {
+    throw new CliError(
+      "SERVER_UNREACHABLE",
+      `\u65E0\u6CD5\u8FDE\u63A5\u5E73\u53F0 ${server}\uFF1A${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const text = await response.text();
+  let parsed = null;
+  try {
+    parsed = text.length === 0 ? null : JSON.parse(text);
+  } catch {
+    parsed = null;
+  }
+  if (response.status !== 200) {
+    const msg = parsed?.error;
+    throw new CliError(
+      "TEMPLATE_PACKAGE_FAILED",
+      msg ?? `\u5E73\u53F0\u8FD4\u56DE HTTP ${response.status}\uFF08\u6A21\u677F ${code} \u53EF\u80FD\u6682\u65E0\u6258\u7BA1\u5305\uFF09`
+    );
+  }
+  const pkg = parsed;
+  if (typeof pkg.code !== "string" || typeof pkg.version !== "string" || !Array.isArray(pkg.files)) {
+    throw new CliError("TEMPLATE_PACKAGE_FAILED", `\u5E73\u53F0\u8FD4\u56DE\u7684\u6A21\u677F\u5305 ${code} \u5F62\u72B6\u975E\u6CD5`);
+  }
+  return pkg;
+}
+async function uploadTemplatePackage(paths, pkg) {
+  const credentials = await loadCredentials(paths);
+  if (credentials === null) {
+    throw new CliError("NOT_LOGGED_IN", "\u672A\u767B\u5F55\uFF1A\u8BF7\u5148\u6267\u884C adep login\uFF08\u4E0A\u4F20\u6A21\u677F\u5305\u5230\u767B\u5F55\u7684\u5E73\u53F0\uFF09");
+  }
+  const server = credentials.server;
+  let response;
+  try {
+    response = await fetch(`${server}/api/v1/templates/${pkg.code}/package`, {
+      method: "PUT",
+      headers: {
+        "content-type": "application/json",
+        cookie: `better-auth.session_token=${decodeToken(credentials.encodedToken)}`
+      },
+      body: JSON.stringify(pkg)
+    });
+  } catch (error) {
+    throw new CliError(
+      "SERVER_UNREACHABLE",
+      `\u65E0\u6CD5\u8FDE\u63A5\u5E73\u53F0 ${server}\uFF1A${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const text = await response.text();
+  let parsed = null;
+  try {
+    parsed = text.length === 0 ? null : JSON.parse(text);
+  } catch {
+    parsed = null;
+  }
+  if (response.status !== 200) {
+    const msg = parsed?.error;
+    if (response.status === 401) {
+      throw new CliError("SESSION_EXPIRED", "\u4F1A\u8BDD\u5DF2\u5931\u6548\uFF1A\u8BF7\u91CD\u65B0\u6267\u884C adep login \u540E\u518D\u4E0A\u4F20");
+    }
+    throw new CliError("TEMPLATE_PUBLISH_FAILED", msg ?? `\u5E73\u53F0\u8FD4\u56DE HTTP ${response.status}`);
+  }
+}
+function packageManifestEntry(pkg) {
+  const entry = pkg.files.find((file) => file.path === "template.json");
+  if (entry === void 0) return null;
+  try {
+    const parsed = JSON.parse(entry.content);
+    return typeof parsed === "object" && parsed !== null ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+async function assertPublishableTemplate(dir, expectedCode) {
+  let info;
+  try {
+    info = await stat3(join3(dir, "template.json"));
+  } catch {
+    throw new CliError(
+      "TEMPLATE_NOT_PUBLISHABLE",
+      `\u76EE\u5F55 ${dir} \u7F3A template.json\uFF1A\u4E0D\u662F\u6A21\u677F\u5305\u76EE\u5F55\uFF08\u6A21\u677F = \u771F\u5B9E\u76EE\u5F55 + template.json \u6E05\u5355\uFF09`
+    );
+  }
+  if (!info.isFile()) {
+    throw new CliError("TEMPLATE_NOT_PUBLISHABLE", `\u76EE\u5F55 ${dir}/template.json \u4E0D\u662F\u6587\u4EF6`);
+  }
+  const manifest = packageManifestEntry({
+    code: expectedCode,
+    version: "",
+    manifest: {},
+    files: [{ path: "template.json", content: await readFile2(join3(dir, "template.json"), "utf8") }]
+  });
+  if (manifest === null) {
+    throw new CliError("TEMPLATE_NOT_PUBLISHABLE", `\u76EE\u5F55 ${dir}/template.json \u4E0D\u662F\u5408\u6CD5 JSON`);
+  }
+  if (manifest["code"] !== expectedCode) {
+    throw new CliError(
+      "TEMPLATE_NOT_PUBLISHABLE",
+      `\u6A21\u677F\u6E05\u5355 code "${String(manifest["code"])}" \u4E0E\u76EE\u5F55\u540D ${expectedCode} \u4E0D\u4E00\u81F4`
+    );
+  }
+  if (typeof manifest["version"] !== "string") {
+    throw new CliError("TEMPLATE_NOT_PUBLISHABLE", `\u6A21\u677F\u6E05\u5355 ${expectedCode} \u7F3A version \u5B57\u7B26\u4E32`);
+  }
+  return { manifest, version: manifest["version"] };
+}
+
 // packages/cli/src/commands/init.ts
 function registerInit(program2, ctx) {
   const templateHelp = `\u6A21\u677F\uFF1A${TEMPLATE_NAMES.join(" | ")}`;
   program2.command("init").description(`\u521D\u59CB\u5316\u9879\u76EE\uFF08${templateHelp}\uFF09\uFF0C\u6216 --list \u4ECE\u5E73\u53F0\u53D6\u6A21\u677F\u6E05\u5355`).argument("[name]", "\u9879\u76EE\u76EE\u5F55\u540D\uFF08\u914D\u5408 --list \u65F6\u53EF\u7701\u7565\uFF09").option("-t, --template <template>", templateHelp, "fullstack").option("-l, --list", "\u4ECE\u5E73\u53F0 /api/v1/templates \u5217\u51FA\u53EF\u7528\u6A21\u677F\uFF08\u4E0D\u811A\u624B\u67B6\uFF09", false).option(
     "-s, --server <url>",
-    "\u5E73\u53F0\u5730\u5740\uFF08--list \u7528\uFF1B\u7F3A\u7701\u8BFB ADEP_SERVER \u6216 http://localhost:3000\uFF09"
+    "\u5E73\u53F0\u5730\u5740\uFF08--list / \u5E73\u53F0\u6A21\u677F\u5305\u4E0B\u8F7D\u7528\uFF1B\u7F3A\u7701\u8BFB ADEP_SERVER \u6216 http://localhost:3000\uFF09"
   ).action(
     async (name, flags) => {
       const command = ctx.io("init");
       await command.run(async () => {
         if (flags.list === true) {
-          const server = flags.server ?? resolveServer();
-          const templates = await fetchTemplates(server);
+          const server2 = flags.server ?? resolveServer();
+          const templates = await fetchTemplates(server2);
           command.ok(
             { templates },
             (data) => data.templates.map(
@@ -11072,18 +11404,81 @@ function registerInit(program2, ctx) {
             `\u672A\u77E5\u6A21\u677F "${template}"\uFF1A\u53EF\u9009 ${TEMPLATE_NAMES.join(" | ")}`
           );
         }
-        const result = await initProject(ctx.cwd, name, template);
+        const server = flags.server ?? resolveServer();
+        let filesOverride;
+        try {
+          const summary = (await fetchTemplates(server)).find((tpl) => tpl.code === template);
+          if (summary?.hasPackage === true && summary.version !== void 0) {
+            const cached = await loadCachedPackage(ctx.paths, template, summary.version);
+            const pkg = cached ?? await downloadTemplatePackage(server, template);
+            if (cached === null) {
+              await saveCachedPackage(ctx.paths, pkg);
+              command.line(`\u5DF2\u4E0B\u8F7D\u5E73\u53F0\u6A21\u677F\u5305 ${pkg.code}@${pkg.version}\uFF08\u7F13\u5B58\u5230\u672C\u5730\uFF09`);
+            }
+            filesOverride = renderTemplatePackage(
+              {
+                code: pkg.code,
+                version: pkg.version,
+                manifest: pkg.manifest,
+                files: pkg.files
+              },
+              name
+            );
+          }
+        } catch (error) {
+          command.line(`\u5E73\u53F0\u6A21\u677F\u5305\u4E0D\u53EF\u7528\uFF0C\u56DE\u9000\u672C\u5730\u5185\u7F6E\u6A21\u677F\uFF1A${error instanceof Error ? error.message : String(error)}`);
+        }
+        const result = await initProject(ctx.cwd, name, template, filesOverride);
         command.ok(result, (data) => `\u5DF2\u521B\u5EFA ${data.projectPath}`);
       });
     }
   );
 }
 
+// packages/cli/src/commands/templates.ts
+init_auth();
+function registerTemplates(program2, ctx) {
+  program2.command("templates").description("\u5E73\u53F0\u6258\u7BA1\u6A21\u677F\u5305\u7BA1\u7406\uFF08\u5F53\u524D\u4EC5 publish\uFF1A\u4E0A\u4F20\u672C\u5730\u6A21\u677F\u5305\u5230\u767B\u5F55\u7684\u5E73\u53F0\uFF09").command("publish").description("\u4E0A\u4F20\u672C\u5730\u6A21\u677F\u5305\uFF08\u9700\u767B\u5F55\uFF1Bcode \u7F3A\u7701 = \u5168\u90E8\u5185\u7F6E\u6A21\u677F\uFF09").argument("[code]", "\u6A21\u677F code\uFF08\u7F3A\u7701\u5168\u90E8\u5185\u7F6E\uFF1A" + TEMPLATE_CODES.join(" | ") + "\uFF09").option(
+    "-d, --dir <dir>",
+    "\u6A21\u677F\u76EE\u5F55\uFF08\u8986\u76D6\u9ED8\u8BA4 src/templates/<code>\uFF0C\u53D1\u5E03\u81EA\u5B9A\u4E49\u76EE\u5F55\u65F6\u7528\uFF09"
+  ).action(
+    async (code, flags) => {
+      const command = ctx.io("templates");
+      await command.run(async () => {
+        const codes = code === void 0 ? [...TEMPLATE_CODES] : [code];
+        if (code !== void 0 && !TEMPLATE_CODES.includes(code)) {
+          throw new CliError(
+            "INVALID_TEMPLATE",
+            `\u672A\u77E5\u6A21\u677F "${code}"\uFF1A\u5185\u7F6E\u53EF\u9009 ${TEMPLATE_CODES.join(" | ")}\uFF08-d \u53D1\u5E03\u81EA\u5B9A\u4E49\u76EE\u5F55\u65F6\u4ECD\u987B\u662F\u5185\u7F6E code\uFF09`
+          );
+        }
+        const uploaded = [];
+        for (const templateCode of codes) {
+          const dir = flags.dir ?? localTemplateDir(templateCode);
+          const { manifest, version } = await assertPublishableTemplate(dir, templateCode);
+          const files = await collectTemplateDir(dir);
+          await uploadTemplatePackage(ctx.paths, {
+            code: templateCode,
+            version,
+            manifest,
+            files
+          });
+          uploaded.push(`${templateCode}@${version}`);
+        }
+        command.ok(
+          { uploaded },
+          (data) => `\u5DF2\u4E0A\u4F20\u6A21\u677F\u5305\uFF1A${data.uploaded.join("\u3001")}`
+        );
+      });
+    }
+  );
+}
+
 // packages/cli/src/import-cf.ts
 init_adep_config();
 init_regexp();
-import { copyFile, mkdir as mkdir3, readFile as readFile2, readdir, stat as stat3, writeFile as writeFile2 } from "node:fs/promises";
-import { basename, dirname as dirname4, join as join3, relative, resolve as resolve2 } from "node:path";
+import { copyFile, mkdir as mkdir4, readFile as readFile3, readdir as readdir2, stat as stat4, writeFile as writeFile3 } from "node:fs/promises";
+import { basename, dirname as dirname4, join as join4, relative, resolve as resolve2 } from "node:path";
 var TomlSyntaxError = class extends Error {
   constructor(message) {
     super(message);
@@ -11337,13 +11732,13 @@ var SKIP_COPY_NAMES = /* @__PURE__ */ new Set([
 async function copyWorkerDir(sourceDir, targetDir, mainFile) {
   const copied = [];
   const renamedIndex = [];
-  const entries = await readdir(sourceDir, { withFileTypes: true });
+  const entries = await readdir2(sourceDir, { withFileTypes: true });
   for (const entry of entries) {
-    const from = join3(sourceDir, entry.name);
-    const to = join3(targetDir, entry.name);
+    const from = join4(sourceDir, entry.name);
+    const to = join4(targetDir, entry.name);
     if (SKIP_COPY_NAMES.has(entry.name)) continue;
     if (entry.isDirectory()) {
-      await mkdir3(to, { recursive: true });
+      await mkdir4(to, { recursive: true });
       const sub = await copyWorkerDir(from, to, "");
       copied.push(...sub.copied);
       renamedIndex.push(...sub.renamedIndex);
@@ -11351,7 +11746,7 @@ async function copyWorkerDir(sourceDir, targetDir, mainFile) {
     }
     if (from === mainFile) continue;
     if (entry.name === "index.ts") {
-      await copyFile(from, join3(targetDir, "_index.ts"));
+      await copyFile(from, join4(targetDir, "_index.ts"));
       renamedIndex.push("_index.ts");
       continue;
     }
@@ -11362,7 +11757,7 @@ async function copyWorkerDir(sourceDir, targetDir, mainFile) {
 }
 async function readDevVars(sourceDir) {
   try {
-    const text = await readFile2(join3(sourceDir, ".dev.vars"), "utf8");
+    const text = await readFile3(join4(sourceDir, ".dev.vars"), "utf8");
     const vars = {};
     for (const line of text.split(/\r?\n/)) {
       const trimmed = line.trim();
@@ -11380,14 +11775,14 @@ async function readDevVars(sourceDir) {
 async function copyAssetsToWeb(sourceDir, assetsDir, outDir) {
   const files = [];
   const from = resolve2(sourceDir, assetsDir);
-  const target = join3(outDir, "web");
-  await mkdir3(target, { recursive: true });
-  const entries = await readdir(from, { withFileTypes: true });
+  const target = join4(outDir, "web");
+  await mkdir4(target, { recursive: true });
+  const entries = await readdir2(from, { withFileTypes: true });
   for (const entry of entries) {
-    const src = join3(from, entry.name);
-    const dst = join3(target, entry.name);
+    const src = join4(from, entry.name);
+    const dst = join4(target, entry.name);
     if (entry.isDirectory()) {
-      await mkdir3(dst, { recursive: true });
+      await mkdir4(dst, { recursive: true });
       const sub = await copyAssetsToWeb(src, ".", outDir);
       files.push(...sub);
       continue;
@@ -11634,11 +12029,11 @@ function renderImportPackageJson(name) {
 async function importCfProject(cwd, sourceDir, options = {}) {
   let tomlText;
   try {
-    tomlText = await readFile2(join3(sourceDir, "wrangler.toml"), "utf8");
+    tomlText = await readFile3(join4(sourceDir, "wrangler.toml"), "utf8");
   } catch {
     throw new ImportCfError(
       "NO_WRANGLER",
-      `\u627E\u4E0D\u5230 ${join3(sourceDir, "wrangler.toml")}\uFF1A\u9700\u5728 Cloudflare \u9879\u76EE\u6839\u6267\u884C\u5BFC\u5165`
+      `\u627E\u4E0D\u5230 ${join4(sourceDir, "wrangler.toml")}\uFF1A\u9700\u5728 Cloudflare \u9879\u76EE\u6839\u6267\u884C\u5BFC\u5165`
     );
   }
   let config;
@@ -11653,7 +12048,7 @@ async function importCfProject(cwd, sourceDir, options = {}) {
   const workerName = slugify(config.name ?? basename(sourceDir), "worker");
   const outDir = resolve2(cwd, options.out ?? `imported-${workerName}`);
   try {
-    await stat3(outDir);
+    await stat4(outDir);
     throw new ImportCfError("DIR_EXISTS", `\u8F93\u51FA\u76EE\u5F55 ${outDir} \u5DF2\u5B58\u5728\uFF1A\u8BF7\u6362 --out \u6216\u5148\u5220\u9664`);
   } catch (error) {
     if (error instanceof ImportCfError) throw error;
@@ -11673,26 +12068,26 @@ async function importCfProject(cwd, sourceDir, options = {}) {
   const configText = renderAdepConfig(adepConfig, {
     header: "// \u7531 adep import cf \u751F\u6210\uFF08CF-015\uFF09\uFF1A\u7ED1\u5B9A\u58F0\u660E\u4E0E wrangler.toml \u5BF9\u5E94"
   });
-  await mkdir3(outDir, { recursive: true });
-  await writeFile2(join3(outDir, "adep.config.ts"), configText, "utf8");
+  await mkdir4(outDir, { recursive: true });
+  await writeFile3(join4(outDir, "adep.config.ts"), configText, "utf8");
   files.push("adep.config.ts");
-  await writeFile2(join3(outDir, "package.json"), renderImportPackageJson(workerName), "utf8");
+  await writeFile3(join4(outDir, "package.json"), renderImportPackageJson(workerName), "utf8");
   files.push("package.json");
   let mainCopied = false;
   if (config.main !== void 0) {
     const mainAbs = resolve2(sourceDir, config.main);
     let mainStat;
     try {
-      mainStat = await stat3(mainAbs);
+      mainStat = await stat4(mainAbs);
     } catch {
       throw new ImportCfError("MAIN_MISSING", `main \u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${config.main}`);
     }
     if (!mainStat.isFile()) {
       throw new ImportCfError("MAIN_NOT_FILE", `main \u4E0D\u662F\u6587\u4EF6\uFF1A${config.main}`);
     }
-    const fnDir = join3(outDir, "functions", workerName);
-    await mkdir3(fnDir, { recursive: true });
-    await copyFile(mainAbs, join3(fnDir, "worker.ts"));
+    const fnDir = join4(outDir, "functions", workerName);
+    await mkdir4(fnDir, { recursive: true });
+    await copyFile(mainAbs, join4(fnDir, "worker.ts"));
     files.push(`functions/${workerName}/worker.ts`);
     mainCopied = true;
     const mainDir = dirname4(mainAbs);
@@ -11706,7 +12101,7 @@ async function importCfProject(cwd, sourceDir, options = {}) {
     if (copied.length > 0) {
       warnings.push(`\u5DF2\u590D\u5236\u540C\u76EE\u5F55\u4F9D\u8D56\u6A21\u5757 ${copied.length} \u4E2A\uFF08\u4FDD\u6301\u76F8\u5BF9 import\uFF09`);
     }
-    await writeFile2(join3(fnDir, "index.ts"), renderFunctionEntry("worker", cfBindings), "utf8");
+    await writeFile3(join4(fnDir, "index.ts"), renderFunctionEntry("worker", cfBindings), "utf8");
     files.push(`functions/${workerName}/index.ts`);
   }
   let dosMigrated = 0;
@@ -11721,20 +12116,20 @@ async function importCfProject(cwd, sourceDir, options = {}) {
       );
     }
     if (doBindings.length > 0) {
-      const fnDir = join3(outDir, "functions", workerName);
-      const workerPath = join3(fnDir, "worker.ts");
-      const workerText = await readFile2(workerPath, "utf8");
+      const fnDir = join4(outDir, "functions", workerName);
+      const workerPath = join4(fnDir, "worker.ts");
+      const workerText = await readFile3(workerPath, "utf8");
       const { text: stripped, removed } = stripDurableObjectClasses(
         workerText,
         doBindings.map((b) => b.className)
       );
-      await writeFile2(workerPath, stripped, "utf8");
+      await writeFile3(workerPath, stripped, "utf8");
       if (removed.length > 0) {
-        await mkdir3(join3(fnDir, "durable-objects"), { recursive: true });
+        await mkdir4(join4(fnDir, "durable-objects"), { recursive: true });
         await Promise.all(
           removed.map(async (r) => {
-            await writeFile2(
-              join3(fnDir, "durable-objects", `${r.className}.ts`),
+            await writeFile3(
+              join4(fnDir, "durable-objects", `${r.className}.ts`),
               `${r.source}
 `,
               "utf8"
@@ -11744,8 +12139,8 @@ async function importCfProject(cwd, sourceDir, options = {}) {
         );
       }
       if (removed.length > 0) {
-        await writeFile2(
-          join3(fnDir, "state-objects.ts"),
+        await writeFile3(
+          join4(fnDir, "state-objects.ts"),
           renderStateObjectDeclaration(doBindings, removed),
           "utf8"
         );
@@ -11790,7 +12185,7 @@ async function importCfProject(cwd, sourceDir, options = {}) {
     unsupported,
     warnings
   });
-  await writeFile2(join3(outDir, "MIGRATION.md"), migration, "utf8");
+  await writeFile3(join4(outDir, "MIGRATION.md"), migration, "utf8");
   files.push("MIGRATION.md");
   if (!mainCopied) {
     warnings.push("wrangler.toml \u672A\u58F0\u660E main\uFF1A\u672A\u751F\u6210\u51FD\u6570\uFF0C\u4EC5\u751F\u6210\u914D\u7F6E\u4E0E\u62A5\u544A");
@@ -11857,7 +12252,13 @@ function registerDevServers(program2, ctx) {
     "\u70ED\u91CD\u8F7D\uFF1A\u76D1\u542C functions/ \u4E0E .env* \u53D8\u66F4\u81EA\u52A8\u751F\u6548\uFF0C\u51FD\u6570 console \u8F93\u51FA\u76F4\u8FBE\u7EC8\u7AEF\uFF08\u5F00\u53D1\u6001\u8C03\u8BD5\u7528\uFF09"
   ).option(
     "--schema <file>",
-    "\u6570\u636E\u5E93\u7ED3\u6784\u6587\u4EF6\uFF1A\u542F\u52A8\u65F6\u5BF9\u672C\u5730\u6A21\u62DF\u5E93\u9010\u6761\u5E94\u7528\uFF08\u5EFA\u8868\u8BED\u53E5\u5EFA\u8BAE IF NOT EXISTS\uFF0C\u5E42\u7B49\u53EF\u91CD\u590D\u542F\u52A8\uFF09"
+    "\u6570\u636E\u5E93\u7ED3\u6784\u6587\u4EF6\uFF1A\u542F\u52A8\u65F6\u5BF9\u672C\u5730\u5E93\u9010\u6761\u5E94\u7528\uFF08\u5EFA\u8868\u8BED\u53E5\u5EFA\u8BAE IF NOT EXISTS\uFF0C\u5E42\u7B49\u53EF\u91CD\u590D\u542F\u52A8\uFF09"
+  ).option(
+    "--db <mode>",
+    "\u6570\u636E\u5E93\u6A21\u5F0F\uFF1Asim\uFF08\u7F3A\u7701\uFF0C\u5185\u7F6E\u6A21\u62DF\u5F15\u64CE + .adep/sim/db.json\uFF09| sqlite\uFF08\u771F\u5B9E SQLite \u5E93\u6587\u4EF6\uFF0C\u9700 Bun \u6216 Node \u2265 22.5\uFF09"
+  ).option(
+    "--db-file <path>",
+    "sqlite \u6A21\u5F0F\u7684\u5E93\u6587\u4EF6\uFF08\u7F3A\u7701\u53D6 ADEP_SERVE_DB_FILE\uFF0C\u518D\u7F3A\u7701 .adep/data/project.sqlite\uFF09"
   ).option(
     "--spa",
     "SPA \u56DE\u9000\uFF1A\u9759\u6001\u8D44\u6E90\u672A\u547D\u4E2D\u65F6\u56DE\u9000 index.html\uFF08\u524D\u7AEF\u8DEF\u7531\u76F4\u8BBF /profile \u7B49\u9875\u9762\u9700\u8981\uFF09"
@@ -11873,6 +12274,8 @@ function registerDevServers(program2, ctx) {
           ...flags.static === void 0 ? {} : { staticDir: flags.static },
           ...flags.watch === void 0 ? {} : { watch: true },
           ...flags.schema === void 0 ? {} : { schemaFile: flags.schema },
+          ...flags.db === void 0 ? {} : { db: flags.db },
+          ...flags.dbFile === void 0 ? {} : { dbFile: flags.dbFile },
           ...flags.spa === void 0 ? {} : { spaFallback: true }
         });
         await new Promise(() => void 0);
@@ -11885,10 +12288,10 @@ function registerDevServers(program2, ctx) {
 init_auth();
 init_client();
 init_deploy();
-import { stat as stat8 } from "node:fs/promises";
-import { join as join16, resolve as resolve8 } from "node:path";
+import { stat as stat9 } from "node:fs/promises";
+import { join as join17, resolve as resolve10 } from "node:path";
 async function resolveProjectId2(client, cwd, slug) {
-  const resolvedSlug = await resolveSlug(resolve8(cwd), slug);
+  const resolvedSlug = await resolveSlug(resolve10(cwd), slug);
   const listed = await client.request("/api/v1/projects", {}, "PROJECT_LIST_FAILED");
   const match = listed.projects.find((project2) => project2.slug === resolvedSlug);
   if (match === void 0) {
@@ -11952,8 +12355,8 @@ async function runPublish(paths, io, cwd, flags) {
     });
   }
   if (wantFrontend) {
-    const webDir = join16(cwd, "web");
-    const webStat = await stat8(webDir).catch(() => null);
+    const webDir = join17(cwd, "web");
+    const webStat = await stat9(webDir).catch(() => null);
     if (webStat !== null && webStat.isDirectory()) {
       const { frontendSync: frontendSync2 } = await Promise.resolve().then(() => (init_frontend(), frontend_exports));
       await frontendSync2(paths, {
@@ -12699,6 +13102,7 @@ function buildProgram(options = {}) {
   const jsonMode = () => program2.opts()["json"] === true;
   const ctx = createCliContext({ output, paths, cwd, json: jsonMode });
   registerInit(program2, ctx);
+  registerTemplates(program2, ctx);
   registerImport(program2, ctx);
   registerDevServers(program2, ctx);
   registerPublish(program2, ctx);