@adep/cli 0.0.1 → 0.0.2

package/dist/index.js

@@ -61,6 +61,77 @@ var init_credentials = __esm({
   }
 });
 
+// packages/cli/src/offline/errors.ts
+var NetworkRequiredError;
+var init_errors = __esm({
+  "packages/cli/src/offline/errors.ts"() {
+    "use strict";
+    NetworkRequiredError = class extends Error {
+      command;
+      reason;
+      constructor(command, reason) {
+        super(`\`${command}\` \u9700\u8981\u8054\u7F51\uFF1A${reason} \xB7 \u79BB\u7EBF\u53EF\u7528\u8303\u56F4\u89C1 \`adep doctor\``);
+        this.name = "NetworkRequiredError";
+        this.command = command;
+        this.reason = reason;
+      }
+    };
+  }
+});
+
+// packages/cli/src/offline/net.ts
+var net_exports = {};
+__export(net_exports, {
+  isOffline: () => isOffline,
+  requireNetwork: () => requireNetwork,
+  resetProbeCache: () => resetProbeCache
+});
+async function isOffline() {
+  const now = Date.now();
+  if (cachedResult !== null && now - cachedResult.timestamp < PROBE_TTL_MS) {
+    return cachedResult.offline;
+  }
+  let offline = true;
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
+    try {
+      const res = await fetch(PROBE_URL, {
+        method: "HEAD",
+        signal: controller.signal
+      });
+      offline = false;
+      void res;
+    } finally {
+      clearTimeout(timer);
+    }
+  } catch {
+    offline = true;
+  }
+  cachedResult = { offline, timestamp: now };
+  return offline;
+}
+function resetProbeCache() {
+  cachedResult = null;
+}
+async function requireNetwork(command) {
+  const offline = await isOffline();
+  if (offline) {
+    throw new NetworkRequiredError(command, "\u5F53\u524D\u7F51\u7EDC\u4E0D\u53EF\u8FBE\uFF08\u63A2\u6D4B registry.npmjs.org \u5931\u8D25\uFF09");
+  }
+}
+var PROBE_TTL_MS, PROBE_URL, PROBE_TIMEOUT_MS, cachedResult;
+var init_net = __esm({
+  "packages/cli/src/offline/net.ts"() {
+    "use strict";
+    init_errors();
+    PROBE_TTL_MS = 3e4;
+    PROBE_URL = "https://registry.npmjs.org/";
+    PROBE_TIMEOUT_MS = 5e3;
+    cachedResult = null;
+  }
+});
+
 // packages/cli/src/auth.ts
 function sessionCookieOf(setCookie) {
   const line = setCookie.find(
@@ -72,6 +143,7 @@ function sessionCookieOf(setCookie) {
   return line.split(";")[0];
 }
 async function login(paths, input) {
+  await requireNetwork("adep login");
   const server = input.server.replace(/\/+$/, "");
   let response;
   try {
@@ -98,6 +170,7 @@ async function login(paths, input) {
   return { email: input.email };
 }
 async function whoami(paths) {
+  await requireNetwork("adep whoami");
   const credentials = await loadCredentials(paths);
   if (credentials === null) {
     throw new CliError("NOT_LOGGED_IN", "\u672A\u767B\u5F55\uFF1A\u8BF7\u5148\u6267\u884C adep login");
@@ -133,6 +206,7 @@ var init_auth = __esm({
   "packages/cli/src/auth.ts"() {
     "use strict";
     init_credentials();
+    init_net();
     CliError = class extends Error {
       constructor(code, message, exitCode = 1) {
         super(message);
@@ -144,6 +218,20 @@ var init_auth = __esm({
   }
 });
 
+// packages/cli/src/config.ts
+function resolvePaths(env = process.env) {
+  const home = env["ADEP_HOME"] ?? `${env["HOME"] ?? ""}/.adep`;
+  return { home, credentialsFile: `${home}/credentials` };
+}
+function resolveServer(env = process.env) {
+  return (env["ADEP_SERVER"] ?? "https://adep.jajabjbj.top").replace(/\/+$/, "");
+}
+var init_config = __esm({
+  "packages/cli/src/config.ts"() {
+    "use strict";
+  }
+});
+
 // packages/cli/src/widget/build.ts
 import { createHash } from "node:crypto";
 import { join as join2, resolve as resolve2 } from "node:path";
@@ -454,50 +542,8 @@ var init_init = __esm({
   }
 });
 
-// packages/cli/src/prompt.ts
-var prompt_exports = {};
-__export(prompt_exports, {
-  createPrompt: () => createPrompt
-});
-import { createInterface } from "node:readline/promises";
-import { Writable } from "node:stream";
-function createPrompt(input = process.stdin) {
-  const rl = createInterface({ input, output: process.stdout, terminal: true });
-  let muted = null;
-  return {
-    async ask(question) {
-      const answer = await rl.question(question);
-      return answer.trim();
-    },
-    async askHidden(question) {
-      muted = createInterface({ input, output: new MutedStream(), terminal: true });
-      const answer = await muted.question(question);
-      muted.close();
-      muted = null;
-      process.stdout.write("\n");
-      return answer.trim();
-    },
-    close() {
-      muted?.close();
-      rl.close();
-    }
-  };
-}
-var MutedStream;
-var init_prompt = __esm({
-  "packages/cli/src/prompt.ts"() {
-    "use strict";
-    MutedStream = class extends Writable {
-      write(_chunk, ...rest) {
-        void rest;
-        return true;
-      }
-    };
-  }
-});
-
 // packages/runtime/src/shared/capability-keys.ts
-var RPC_CAPABILITY_KEY, CHAIN_CAPABILITY_KEY, DB_RPC;
+var RPC_CAPABILITY_KEY, CHAIN_CAPABILITY_KEY, DB_RPC, REALTIME_CAPABILITY_CODES, REALTIME_CAPABILITY_METHODS;
 var init_capability_keys = __esm({
   "packages/runtime/src/shared/capability-keys.ts"() {
     "use strict";
@@ -517,6 +563,20 @@ var init_capability_keys = __esm({
       /** 执行一条链：`chain, args=[ChainRequest]`。 */
       chain: "chain"
     };
+    REALTIME_CAPABILITY_CODES = {
+      invalidMethod: "REALTIME_INVALID_METHOD",
+      unsupportedArg: "REALTIME_UNSUPPORTED_ARG",
+      subscriptionNotFound: "REALTIME_SUBSCRIPTION_NOT_FOUND",
+      tooManySubscriptions: "REALTIME_TOO_MANY_SUBSCRIPTIONS",
+      /** 线上独有：订阅授权策略（RT-002 `SubscriptionPolicy`）拒绝该 channel。 */
+      channelDenied: "REALTIME_CHANNEL_DENIED"
+    };
+    REALTIME_CAPABILITY_METHODS = [
+      "publish",
+      "subscribe",
+      "receive",
+      "unsubscribe"
+    ];
   }
 });
 
@@ -743,7 +803,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((resolve12, reject) => {
+        return new Promise((resolve15, reject) => {
           let worker;
           try {
             worker = new Worker(resolveWorkerEntry(), {
@@ -805,7 +865,7 @@ var init_worker_executor = __esm({
               if (message.type === "result") {
                 clearTimeout(timer);
                 void worker.terminate();
-                resolve12({ body: message.body, logs });
+                resolve15({ body: message.body, logs });
                 return;
               }
               if (message.type === "error") {
@@ -1048,7 +1108,6 @@ var init_owned = __esm({
 });
 
 // packages/runtime/src/database/builder/ulid.ts
-import { randomFillSync } from "node:crypto";
 function encodeTime(now) {
   let ts = Math.trunc(now);
   let out = "";
@@ -1084,6 +1143,16 @@ function incrBase32(prev) {
   }
   return chars.join("");
 }
+function randomFill(bytes) {
+  const source = globalThis.crypto;
+  if (source !== void 0 && typeof source.getRandomValues === "function") {
+    return source.getRandomValues(bytes);
+  }
+  for (let i = 0; i < bytes.length; i += 1) {
+    bytes[i] = Math.floor(Math.random() * 256);
+  }
+  return bytes;
+}
 function ulid(now = Date.now()) {
   const time = encodeTime(now);
   let random;
@@ -1092,7 +1161,7 @@ function ulid(now = Date.now()) {
   } else {
     lastTime = now;
     const bytes = new Uint8Array(10);
-    randomFillSync(bytes);
+    randomFill(bytes);
     random = encodeRandom(bytes);
   }
   lastRandom = random;
@@ -1504,7 +1573,6 @@ var init_builder = __esm({
 });
 
 // packages/runtime/src/database/sdk/cloud.ts
-import { randomUUID } from "node:crypto";
 function errorWithCode(error) {
   const code = typeof error === "object" && error !== null && typeof error.code === "string" ? error.code : void 0;
   if (code !== void 0 && error instanceof Error) {
@@ -1563,7 +1631,7 @@ function createDbCapability(driver, options = {}) {
         case DB_RPC.begin: {
           if (activeTxs.size > 0) throw unsafeOperation("\u4E0D\u5141\u8BB8\u5D4C\u5957\u4E8B\u52A1");
           await driver.run("BEGIN");
-          const txId = randomUUID();
+          const txId = crypto.randomUUID();
           activeTxs.set(txId, true);
           return txId;
         }
@@ -2115,11 +2183,177 @@ var init_driver = __esm({
   }
 });
 
+// packages/runtime/src/storage/hmac-sha256.ts
+function compress(h, block, w) {
+  for (let i = 0; i < 16; i += 1) {
+    const j = i * 4;
+    w[i] = (block[j] ?? 0) << 24 | (block[j + 1] ?? 0) << 16 | (block[j + 2] ?? 0) << 8 | (block[j + 3] ?? 0);
+  }
+  for (let i = 16; i < 64; i += 1) {
+    const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ w[i - 15] >>> 3;
+    const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ w[i - 2] >>> 10;
+    w[i] = w[i - 16] + s0 + w[i - 7] + s1 | 0;
+  }
+  let [a, b, c, d, e, f, g, hh] = [h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7]];
+  for (let i = 0; i < 64; i += 1) {
+    const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+    const ch = e & f ^ ~e & g;
+    const t1 = hh + S1 + ch + K[i] + w[i] | 0;
+    const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+    const maj = a & b ^ a & c ^ b & c;
+    const t2 = S0 + maj | 0;
+    hh = g;
+    g = f;
+    f = e;
+    e = d + t1 | 0;
+    d = c;
+    c = b;
+    b = a;
+    a = t1 + t2 | 0;
+  }
+  h[0] = h[0] + a | 0;
+  h[1] = h[1] + b | 0;
+  h[2] = h[2] + c | 0;
+  h[3] = h[3] + d | 0;
+  h[4] = h[4] + e | 0;
+  h[5] = h[5] + f | 0;
+  h[6] = h[6] + g | 0;
+  h[7] = h[7] + hh | 0;
+}
+function sha256(data) {
+  const h = new Uint32Array([
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ]);
+  const bitLength = data.length * 8;
+  const paddedLength = Math.ceil((data.length + 9) / 64) * 64;
+  const padded = new Uint8Array(paddedLength);
+  padded.set(data);
+  padded[data.length] = 128;
+  const view = new DataView(padded.buffer);
+  view.setUint32(paddedLength - 4, bitLength >>> 0, false);
+  view.setUint32(paddedLength - 8, Math.floor(bitLength / 4294967296), false);
+  const w = new Uint32Array(64);
+  for (let offset = 0; offset < paddedLength; offset += 64) {
+    compress(h, padded.subarray(offset, offset + 64), w);
+  }
+  const out = new Uint8Array(32);
+  const outView = new DataView(out.buffer);
+  for (let i = 0; i < 8; i += 1) outView.setUint32(i * 4, h[i], false);
+  return out;
+}
+function toBytes(input) {
+  if (typeof input !== "string") return input;
+  return new TextEncoder().encode(input);
+}
+function hmacSha256(key, message) {
+  const blockSize = 64;
+  let keyBytes = toBytes(key);
+  if (keyBytes.length > blockSize) keyBytes = sha256(keyBytes);
+  const padded = new Uint8Array(blockSize);
+  padded.set(keyBytes);
+  const inner = new Uint8Array(blockSize);
+  const outer = new Uint8Array(blockSize);
+  for (let i = 0; i < blockSize; i += 1) {
+    inner[i] = padded[i] ^ 54;
+    outer[i] = padded[i] ^ 92;
+  }
+  const innerInput = new Uint8Array(blockSize + toBytes(message).length);
+  innerInput.set(inner);
+  innerInput.set(toBytes(message), blockSize);
+  const innerHash = sha256(innerInput);
+  const outerInput = new Uint8Array(blockSize + 32);
+  outerInput.set(outer);
+  outerInput.set(innerHash, blockSize);
+  return sha256(outerInput);
+}
+function hmacSha256Hex(key, message) {
+  return [...hmacSha256(key, message)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+var K, rotr;
+var init_hmac_sha256 = __esm({
+  "packages/runtime/src/storage/hmac-sha256.ts"() {
+    "use strict";
+    K = new Uint32Array([
+      1116352408,
+      1899447441,
+      3049323471,
+      3921009573,
+      961987163,
+      1508970993,
+      2453635748,
+      2870763221,
+      3624381080,
+      310598401,
+      607225278,
+      1426881987,
+      1925078388,
+      2162078206,
+      2614888103,
+      3248222580,
+      3835390401,
+      4022224774,
+      264347078,
+      604807628,
+      770255983,
+      1249150122,
+      1555081692,
+      1996064986,
+      2554220882,
+      2821834349,
+      2952996808,
+      3210313671,
+      3336571891,
+      3584528711,
+      113926993,
+      338241895,
+      666307205,
+      773529912,
+      1294757372,
+      1396182291,
+      1695183700,
+      1986661051,
+      2177026350,
+      2456956037,
+      2730485921,
+      2820302411,
+      3259730800,
+      3345764771,
+      3516065817,
+      3600352804,
+      4094571909,
+      275423344,
+      430227734,
+      506948616,
+      659060556,
+      883997877,
+      958139571,
+      1322822218,
+      1537002063,
+      1747873779,
+      1955562222,
+      2024104815,
+      2227730452,
+      2361852424,
+      2428436474,
+      2756734187,
+      3204031479,
+      3329325298
+    ]);
+    rotr = (x, n) => x >>> n | x << 32 - n;
+  }
+});
+
 // packages/runtime/src/storage/signature.ts
-import { createHmac, timingSafeEqual } from "node:crypto";
 function sign(secret, projectId, path, expires) {
   const payload = `${projectId}|${path}|${expires}`;
-  return createHmac("sha256", secret).update(payload).digest("hex");
+  return hmacSha256Hex(secret, payload);
 }
 function signDownloadUrl(config, projectId, path, ttlSeconds = DEFAULT_SIGN_TTL_SECONDS) {
   const expires = Math.floor(Date.now() / 1e3) + ttlSeconds;
@@ -2131,6 +2365,7 @@ var DEFAULT_SIGN_TTL_SECONDS, SIGN_EXPIRES_KEY, SIGN_SIGNATURE_KEY;
 var init_signature = __esm({
   "packages/runtime/src/storage/signature.ts"() {
     "use strict";
+    init_hmac_sha256();
     DEFAULT_SIGN_TTL_SECONDS = 15 * 60;
     SIGN_EXPIRES_KEY = "x-expires";
     SIGN_SIGNATURE_KEY = "x-signature";
@@ -2360,7 +2595,7 @@ function createLocalStorageDriver(options) {
       }
       const root = bucketDir(projectId);
       const metas = [];
-      const walk = async (dir, relative2) => {
+      const walk = async (dir, relative3) => {
         let entries;
         try {
           entries = await readdir(dir, { withFileTypes: true });
@@ -2371,7 +2606,7 @@ function createLocalStorageDriver(options) {
         for (const entry of entries) {
           if (entry.name.endsWith(META_SUFFIX)) continue;
           const full = join5(dir, entry.name);
-          const rel = relative2 === "" ? entry.name : `${relative2}/${entry.name}`;
+          const rel = relative3 === "" ? entry.name : `${relative3}/${entry.name}`;
           if (entry.isFile()) {
             if (prefix !== void 0 && !rel.startsWith(prefix)) continue;
             tasks.push(
@@ -2440,10 +2675,89 @@ var init_storage = __esm({
 });
 
 // packages/cli/src/sim/realtime.ts
-var SimRealtime;
+function realtimeError(code, message) {
+  return new Error(`[${code}] ${message}`);
+}
+function createSimRealtimeCapability() {
+  const sim = new SimRealtime();
+  const buffers = /* @__PURE__ */ new Map();
+  const disposers = /* @__PURE__ */ new Map();
+  let seq = 0;
+  const handler = async (method, args) => {
+    switch (method) {
+      case "publish": {
+        if (args.length > 2) {
+          throw realtimeError(
+            REALTIME_CODES.unsupportedArg,
+            "\u672C\u5730\u5355\u8FDB\u7A0B\u5185\u5B58\u5E7F\u64AD\u65E0\u8FDE\u63A5\u8EAB\u4EFD\uFF0C\u4E0D\u652F\u6301 publish \u7684 except \u5B9E\u53C2"
+          );
+        }
+        const [channel, data] = args;
+        return sim.publish(channel, data);
+      }
+      case "subscribe": {
+        if (buffers.size >= MAX_SUBSCRIPTIONS) {
+          throw realtimeError(
+            REALTIME_CODES.tooManySubscriptions,
+            `\u672C\u5730\u8BA2\u9605\u6570\u5DF2\u8FBE\u4E0A\u9650 ${String(MAX_SUBSCRIPTIONS)}\uFF0C\u8BF7\u5148 unsubscribe`
+          );
+        }
+        const [channel] = args;
+        seq += 1;
+        const id = `sub-${String(seq)}`;
+        const buffer = [];
+        const off = sim.subscribe(channel, (msg) => {
+          buffer.push(msg);
+          if (buffer.length > MAX_BUFFERED_MESSAGES) buffer.shift();
+        });
+        buffers.set(id, buffer);
+        disposers.set(id, off);
+        return { subscription: id, channel };
+      }
+      case "receive": {
+        const buffer = buffers.get(args[0]);
+        if (buffer === void 0) {
+          throw realtimeError(
+            REALTIME_CODES.subscriptionNotFound,
+            `\u672C\u5730\u8BA2\u9605 "${String(args[0])}" \u4E0D\u5B58\u5728\u6216\u5DF2\u9000\u8BA2`
+          );
+        }
+        return buffer.splice(0, buffer.length);
+      }
+      case "unsubscribe": {
+        const id = args[0];
+        const off = disposers.get(id);
+        if (off === void 0) {
+          throw realtimeError(
+            REALTIME_CODES.subscriptionNotFound,
+            `\u672C\u5730\u8BA2\u9605 "${id}" \u4E0D\u5B58\u5728\u6216\u5DF2\u9000\u8BA2`
+          );
+        }
+        off();
+        disposers.delete(id);
+        buffers.delete(id);
+        return { removed: true };
+      }
+      default:
+        throw realtimeError(
+          REALTIME_CODES.invalidMethod,
+          `\u672A\u77E5\u7684 cloud.realtime \u65B9\u6CD5 "${method}"\uFF08\u53EF\u7528\uFF1A${REALTIME_CAPABILITY_METHODS.join(" / ")}\uFF09`
+        );
+    }
+  };
+  return {
+    bundle: {
+      capabilities: [{ name: "realtime", value: { [RPC_CAPABILITY_KEY]: true } }],
+      rpcHandlers: { realtime: handler }
+    },
+    realtime: sim
+  };
+}
+var SimRealtime, MAX_BUFFERED_MESSAGES, MAX_SUBSCRIPTIONS, REALTIME_CODES;
 var init_realtime = __esm({
   "packages/cli/src/sim/realtime.ts"() {
     "use strict";
+    init_capability_keys();
     SimRealtime = class {
       seq = 0;
       subscribers = /* @__PURE__ */ new Map();
@@ -2483,6 +2797,9 @@ var init_realtime = __esm({
         return this.subscribers.size;
       }
     };
+    MAX_BUFFERED_MESSAGES = 64;
+    MAX_SUBSCRIPTIONS = 64;
+    REALTIME_CODES = REALTIME_CAPABILITY_CODES;
   }
 });
 
@@ -2538,12 +2855,12 @@ async function createSimRuntime(options) {
     ...options.baseUrl === void 0 ? {} : { baseUrl: options.baseUrl },
     projectId: options.projectId ?? "local"
   });
-  const realtime = new SimRealtime();
-  const bundle = mergeBundles([db.bundle, storage.bundle]);
+  const simRealtime = createSimRealtimeCapability();
+  const bundle = mergeBundles([db.bundle, storage.bundle, simRealtime.bundle]);
   await db.engine.load();
   return {
     bundle,
-    realtime,
+    realtime: simRealtime.realtime,
     db,
     dispose: async () => {
       await db.driver.close();
@@ -2647,7 +2964,12 @@ var init_boundary = __esm({
       {
         kind: "diff",
         title: "\u65E0\u8DE8\u5B9E\u4F8B\u5E7F\u64AD",
-        detail: "realtime \u4E3A\u5355\u8FDB\u7A0B\u5185\u5B58\u5E7F\u64AD\uFF1A\u4E0D\u652F\u6301\u8DE8\u8FDB\u7A0B / \u8DE8\u5B9E\u4F8B\uFF0C\u7EBF\u4E0A\u591A\u5B9E\u4F8B\u8BED\u4E49\u4E0D\u540C\u3002"
+        detail: "cloud.realtime \u5DF2\u6CE8\u5165\uFF0C\u4F46\u4E3A\u5355\u8FDB\u7A0B\u5185\u5B58\u5E7F\u64AD\uFF1A\u4E0D\u652F\u6301\u8DE8\u8FDB\u7A0B / \u8DE8\u5B9E\u4F8B\uFF0C\u7EBF\u4E0A\u591A\u5B9E\u4F8B\u8BED\u4E49\u4E0D\u540C\u3002"
+      },
+      {
+        kind: "capability",
+        title: "publish \u4E0D\u652F\u6301 except",
+        detail: "\u672C\u5730\u4E0D\u5EFA WS \u63E1\u624B\u3001\u65E0\u8FDE\u63A5\u8EAB\u4EFD\uFF0C\u6545 cloud.realtime.publish \u7684 except\uFF08\u4E0D\u53D1\u56DE\u53D1\u9001\u8005\uFF09\u65E0\u4ECE\u5B9E\u73B0\uFF0C\u4F20\u5165\u5373\u62A5\u9519\u3002"
       },
       {
         kind: "capability",
@@ -2928,6 +3250,11 @@ var init_dev = __esm({
 });
 
 // packages/cli/src/client.ts
+var client_exports = {};
+__export(client_exports, {
+  createClient: () => createClient,
+  resolveSlug: () => resolveSlug
+});
 async function envelopeError(response, fallbackCode, parsed) {
   const payload = parsed ?? null;
   return new CliError(
@@ -3050,13 +3377,14 @@ function sha256Hex(content) {
   return createHash3("sha256").update(content).digest("hex");
 }
 async function deploy(paths, options) {
-  const log = options.log ?? ((line) => process.stdout.write(`${line}
+  await requireNetwork("adep deploy");
+  const log = options.silent === true ? () => void 0 : options.log ?? ((line) => process.stdout.write(`${line}
 `));
   const client = await createClient(paths);
   const cwd = resolve6(options.cwd);
   const config = await loadConfig(cwd);
   const slug = options.slug ?? config.name;
-  const functionsDir = join10(cwd, config.functionsDir);
+  const functionsDir = options.functionsDir === void 0 ? join10(cwd, config.functionsDir) : resolve6(cwd, options.functionsDir);
   const local = await collectEntries(functionsDir);
   if (Object.keys(local).length === 0) {
     throw new CliError("NO_FUNCTIONS", `${functionsDir} \u4E0B\u6CA1\u6709\u51FD\u6570\u6587\u4EF6`);
@@ -3128,120 +3456,926 @@ var init_deploy = __esm({
     init_auth();
     init_client();
     init_dev();
+    init_net();
   }
 });
 
-// packages/cli/src/db.ts
-var db_exports = {};
-__export(db_exports, {
-  dbExec: () => dbExec,
-  dbRollback: () => dbRollback,
-  dbSnapshotCreate: () => dbSnapshotCreate,
-  dbSnapshotList: () => dbSnapshotList,
-  dbSnapshotRestore: () => dbSnapshotRestore,
-  dbStart: () => dbStart,
-  dbStatus: () => dbStatus,
-  dbStop: () => dbStop
+// packages/cli/src/prompt.ts
+var prompt_exports = {};
+__export(prompt_exports, {
+  createPrompt: () => createPrompt
 });
-import { resolve as resolve7 } from "node:path";
-async function open2(paths, options) {
-  const client = await createClient(paths);
-  const project2 = await resolveSlug(resolve7(options.cwd), options.slug);
-  return { client, project: project2 };
-}
-async function dbStart(paths, options) {
-  const { client, project: project2 } = await open2(paths, options);
-  return client.request(`/api/v1/projects/${project2}/database`, { method: "POST" });
-}
-async function dbStatus(paths, options) {
-  const { client, project: project2 } = await open2(paths, options);
-  return client.request(`/api/v1/projects/${project2}/database`);
-}
-async function dbStop(paths, options) {
-  const { client, project: project2 } = await open2(paths, options);
-  return client.request(`/api/v1/projects/${project2}/database`, {
-    method: "DELETE"
-  });
-}
-async function dbExec(paths, options) {
-  const { client, project: project2 } = await open2(paths, options);
-  return client.request(
-    `/api/v1/projects/${project2}/database/console/sql`,
-    {
-      method: "POST",
-      body: {
-        sql: options.sql,
-        ...options.params === void 0 ? {} : { params: options.params },
-        ...options.confirmTable === void 0 ? {} : { confirmTable: options.confirmTable }
-      }
+import { createInterface } from "node:readline/promises";
+import { Writable } from "node:stream";
+function createPrompt(input = process.stdin) {
+  const rl = createInterface({ input, output: process.stdout, terminal: true });
+  let muted = null;
+  return {
+    async ask(question) {
+      const answer = await rl.question(question);
+      return answer.trim();
     },
-    "SQL_EXEC_FAILED"
-  );
-}
-async function dbSnapshotList(paths, options) {
-  const { client, project: project2 } = await open2(paths, options);
-  return client.request(
-    `/api/v1/projects/${project2}/database/snapshots`
-  );
-}
-async function dbSnapshotCreate(paths, options) {
-  const { client, project: project2 } = await open2(paths, options);
-  return client.request(`/api/v1/projects/${project2}/database/snapshots`, {
-    method: "POST"
-  });
-}
-async function dbSnapshotRestore(paths, options) {
-  const { client, project: project2 } = await open2(paths, options);
-  return client.request(
-    `/api/v1/projects/${project2}/database/snapshots/${options.snapshotId}/restore`,
-    { method: "POST" }
-  );
-}
-async function dbRollback(paths, options) {
-  const { client, project: project2 } = await open2(paths, options);
-  return client.request(
-    `/api/v1/projects/${project2}/database/rollback`,
-    { method: "POST", body: { to: options.to } }
-  );
+    async askHidden(question) {
+      muted = createInterface({ input, output: new MutedStream(), terminal: true });
+      const answer = await muted.question(question);
+      muted.close();
+      muted = null;
+      process.stdout.write("\n");
+      return answer.trim();
+    },
+    close() {
+      muted?.close();
+      rl.close();
+    }
+  };
 }
-var init_db2 = __esm({
-  "packages/cli/src/db.ts"() {
+var MutedStream;
+var init_prompt = __esm({
+  "packages/cli/src/prompt.ts"() {
     "use strict";
-    init_client();
+    MutedStream = class extends Writable {
+      write(_chunk, ...rest) {
+        void rest;
+        return true;
+      }
+    };
   }
 });
 
-// packages/cli/src/storage.ts
-var storage_exports = {};
-__export(storage_exports, {
-  contentTypeOf: () => contentTypeOf,
-  storageDownload: () => storageDownload,
-  storageList: () => storageList,
-  storageRemove: () => storageRemove,
-  storageUpload: () => storageUpload
+// packages/cli/src/serve/banner.ts
+function isLoopback(host) {
+  return host === "127.0.0.1" || host === "localhost" || host === "::1" || host === "[::1]";
+}
+function renderBanner(options) {
+  const { host, port, projectName, functions, hasStatic, staticDir = "public/" } = options;
+  const baseUrl = `http://${host}:${port}`;
+  const loopback = isLoopback(host);
+  const lines = [];
+  lines.push("");
+  lines.push("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
+  lines.push("\u2551           adep serve \u2014 \u5F00\u53D1\u6001\u670D\u52A1\u5668                           \u2551");
+  lines.push("\u2551   \u26A0  \u8FD9\u4E0D\u662F\u751F\u4EA7\u670D\u52A1\u5668\uFF0C\u4E0D\u63D0\u4F9B TLS / \u96C6\u7FA4 / \u4F18\u96C5\u91CD\u542F          \u2551");
+  lines.push("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D");
+  lines.push("");
+  lines.push(`  \u9879\u76EE: ${projectName}`);
+  lines.push(`  \u5730\u5740: ${baseUrl}`);
+  lines.push(`  \u7ED1\u5B9A: ${host}${loopback ? "\uFF08\u4EC5\u672C\u673A\u53EF\u8BBF\u95EE\uFF09" : "\uFF08\u26A0 \u5BF9\u5916\u66B4\u9732\uFF09"}`);
+  lines.push("");
+  lines.push("  \u80FD\u529B:");
+  if (functions.length > 0) {
+    lines.push(
+      `    - \u51FD\u6570\u8DEF\u7531: ${baseUrl}/api/{fn}\uFF08${functions.length} \u4E2A\u51FD\u6570: ${functions.join(", ")}\uFF09`
+    );
+  } else {
+    lines.push("    - \u51FD\u6570\u8DEF\u7531: \u65E0\uFF08functions/ \u76EE\u5F55\u4E3A\u7A7A\uFF09");
+  }
+  if (hasStatic) {
+    lines.push(`    - \u9759\u6001\u6258\u7BA1: ${baseUrl}/ \u2192 ${staticDir}`);
+  } else {
+    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");
+  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:");
+  lines.push("    - \u65E0\u9274\u6743\uFF1A\u4EFB\u4F55\u4EBA\u53EF\u8C03\u7528\u6240\u6709\u51FD\u6570");
+  lines.push("    - \u65E0\u9650\u6D41\uFF1A\u65E0 QPS / \u5E76\u53D1\u9650\u5236");
+  lines.push("    - \u65E0\u914D\u989D\uFF1A\u65E0\u8C03\u7528\u6B21\u6570 / \u8D44\u6E90\u7528\u91CF\u9650\u5236");
+  lines.push("    - \u65E0 TLS\uFF1A\u660E\u6587 HTTP\uFF0C\u4E0D\u652F\u6301 HTTPS");
+  lines.push("    - \u65E0\u96C6\u7FA4\uFF1A\u5355\u8FDB\u7A0B\uFF0C\u4E0D\u652F\u6301\u591A\u5B9E\u4F8B");
+  lines.push("    - \u65E0\u4F18\u96C5\u91CD\u542F\uFF1A\u8FDB\u7A0B\u9000\u51FA\u5373\u4E2D\u65AD");
+  lines.push("");
+  if (!loopback) {
+    lines.push("  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
+    lines.push("  \u2502  \u26A0\u26A0\u26A0  \u5BF9\u5916\u66B4\u9732\u8B66\u544A                                          \u2502");
+    lines.push("  \u2502                                                              \u2502");
+    lines.push(`  \u2502  \u5F53\u524D\u7ED1\u5B9A ${host.padEnd(43)}\u2502`);
+    lines.push("  \u2502  \u5C40\u57DF\u7F51/\u516C\u7F51\u5185\u4EFB\u4F55\u4EBA\u90FD\u53EF\u8BBF\u95EE\u4F60\u7684\u51FD\u6570\u4E0E\u6570\u636E\u3002                \u2502");
+    lines.push("  \u2502  \u65E0\u9274\u6743\u3001\u65E0\u9650\u6D41\u3001\u65E0\u914D\u989D\u2014\u2014\u8BF7\u52FF\u5728\u4E0D\u53EF\u4FE1\u7F51\u7EDC\u4E2D\u4F7F\u7528\u3002          \u2502");
+    lines.push("  \u2502                                                              \u2502");
+    lines.push("  \u2502  \u9700\u8981\u751F\u4EA7\u90E8\u7F72\uFF1F\u4F7F\u7528 `adep deploy` \u90E8\u7F72\u5230\u5E73\u53F0\u3002              \u2502");
+    lines.push("  \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
+    lines.push("");
+  }
+  lines.push("  \u6309 Ctrl+C \u505C\u6B62\u670D\u52A1\u5668\u3002");
+  lines.push("");
+  return lines.join("\n");
+}
+var init_banner = __esm({
+  "packages/cli/src/serve/banner.ts"() {
+    "use strict";
+  }
 });
-import { mkdir as mkdir7, readFile as readFile7, stat as stat6, writeFile as writeFile6 } from "node:fs/promises";
-import { basename as basename3, dirname as dirname7, extname, join as join11, resolve as resolve8 } from "node:path";
-async function open3(paths, options) {
-  const client = await createClient(paths);
-  const project2 = await resolveSlug(resolve8(options.cwd), options.slug);
-  return { client, project: project2 };
-}
-function contentTypeOf(path) {
-  const map = {
-    ".html": "text/html; charset=utf-8",
-    ".htm": "text/html; charset=utf-8",
-    ".css": "text/css; charset=utf-8",
-    ".js": "text/javascript; charset=utf-8",
-    ".mjs": "text/javascript; charset=utf-8",
-    ".json": "application/json; charset=utf-8",
-    ".png": "image/png",
-    ".jpg": "image/jpeg",
-    ".jpeg": "image/jpeg",
-    ".gif": "image/gif",
-    ".svg": "image/svg+xml",
-    ".webp": "image/webp",
-    ".ico": "image/x-icon",
+
+// packages/cli/src/serve/server.ts
+var server_exports = {};
+__export(server_exports, {
+  isLoopback: () => isLoopback,
+  startServeServer: () => startServeServer
+});
+import { createServer as createServer2 } from "node:http";
+import { readdir as readdir4, readFile as readFile7, stat as stat6 } from "node:fs/promises";
+import { join as join11, relative, resolve as resolve7 } from "node:path";
+function envNumber(name) {
+  const raw = process.env[name];
+  if (raw === void 0 || raw.trim() === "") return void 0;
+  const value = Number(raw);
+  return Number.isInteger(value) && value >= 0 ? value : void 0;
+}
+function envString(name) {
+  const raw = process.env[name];
+  return raw === void 0 || raw.trim() === "" ? void 0 : raw.trim();
+}
+async function collectFunctions2(dir) {
+  const files = {};
+  const walk = async (sub, prefix) => {
+    let entries;
+    try {
+      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);
+      if (entry.isDirectory()) {
+        await walk(full, rel);
+      } else if (entry.isFile() && entry.name.endsWith(".ts")) {
+        files[rel] = await readFile7(full, "utf8");
+      }
+    }
+  };
+  await walk(dir, "");
+  return files;
+}
+function bodyOf2(req) {
+  return new Promise((resolveBody, rejectBody) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => {
+      const raw = Buffer.concat(chunks).toString("utf8");
+      if (raw.length === 0) {
+        resolveBody(void 0);
+        return;
+      }
+      try {
+        resolveBody(JSON.parse(raw));
+      } catch {
+        resolveBody(raw);
+      }
+    });
+    req.on("error", rejectBody);
+  });
+}
+function writeJson2(res, status, payload) {
+  res.writeHead(status, { "content-type": "application/json" });
+  res.end(JSON.stringify(payload));
+}
+function contentTypeFor(path) {
+  const ext = path.slice(path.lastIndexOf(".")).toLowerCase();
+  return MIME_TYPES[ext] ?? "application/octet-stream";
+}
+async function startServeServer(options) {
+  const cwd = resolve7(options.cwd);
+  const log = options.log ?? ((line) => process.stdout.write(`${line}
+`));
+  const host = options.host ?? envString("HOST") ?? "127.0.0.1";
+  const port = options.port ?? envNumber("PORT") ?? 8787;
+  const staticDir = resolve7(
+    cwd,
+    options.staticDir ?? envString("ADEP_SERVE_STATIC_DIR") ?? "public"
+  );
+  const config = await loadConfig(cwd);
+  const functionsDir = join11(cwd, config.functionsDir);
+  let hasStatic = false;
+  try {
+    const publicStat = await stat6(staticDir);
+    hasStatic = publicStat.isDirectory();
+  } catch {
+    hasStatic = false;
+  }
+  const files = await collectFunctions2(functionsDir);
+  const functionNames = Object.keys(files).filter((f) => f.endsWith(".ts")).map((f) => f.slice(0, -3));
+  const envText = await readFile7(join11(cwd, ".env.local"), "utf8").catch(() => "");
+  const env = parseEnvFile(envText);
+  const simEnv = await loadSimEnv(cwd).catch(() => ({}));
+  const runtime = await createSimRuntime({
+    cwd,
+    projectId: "local",
+    baseUrl: `http://${host}:${port}`,
+    log
+  });
+  const executor = new WorkerFunctionExecutor();
+  const dbBundle = runtime.bundle;
+  const invokeHandler = createSimInvokeHandler({ executor, files });
+  const buildInput = async (fnName, url, req) => {
+    const query = {};
+    for (const key of new Set(url.searchParams.keys())) {
+      const values = url.searchParams.getAll(key);
+      query[key] = values.length > 1 ? values.join(",") : values[0] ?? "";
+    }
+    const headers = {};
+    for (const [key, value] of Object.entries(req.headers)) {
+      if (typeof value === "string") headers[key] = value;
+    }
+    const body = req.method === "GET" || req.method === "HEAD" ? void 0 : await bodyOf2(req);
+    const hasEnv = Object.keys(env).length > 0 || Object.keys(simEnv).length > 0;
+    const mergedEnv = { ...simEnv, ...env };
+    return {
+      project: { id: "local", slug: config.name },
+      fn: { id: fnName, name: fnName },
+      files,
+      entry: `${fnName}.ts`,
+      request: {
+        method: req.method ?? "GET",
+        path: url.pathname,
+        query,
+        headers,
+        ...body === void 0 ? {} : { body }
+      },
+      capabilities: dbBundle.capabilities,
+      rpcHandlers: {
+        ...dbBundle.rpcHandlers,
+        invoke: invokeHandler
+      },
+      timeoutMs: 1e4,
+      ...hasEnv ? { env: mergedEnv } : {}
+    };
+  };
+  const serveStatic = async (pathname, res) => {
+    if (!hasStatic) return false;
+    const safePath = pathname.replace(/\.\.\//g, "").replace(/^\//, "");
+    const filePath = join11(staticDir, safePath);
+    const resolvedPath = safePath === "" || safePath === "/" ? join11(filePath, "index.html") : filePath;
+    try {
+      const fileStat = await stat6(resolvedPath);
+      if (fileStat.isDirectory()) {
+        const indexPath = join11(resolvedPath, "index.html");
+        try {
+          const indexStat = await stat6(indexPath);
+          if (indexStat.isFile()) {
+            const content2 = await readFile7(indexPath);
+            res.writeHead(200, { "content-type": contentTypeFor(indexPath) });
+            res.end(content2);
+            return true;
+          }
+        } catch {
+        }
+        return false;
+      }
+      const content = await readFile7(resolvedPath);
+      res.writeHead(200, { "content-type": contentTypeFor(resolvedPath) });
+      res.end(content);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const handle = async (req, res) => {
+    const url = new URL(req.url ?? "/", `http://${host}:${port}`);
+    const pathname = url.pathname;
+    if (pathname === "/api" || pathname.startsWith("/api/")) {
+      const fnName = pathname === "/api" ? "" : pathname.slice("/api/".length).split("/")[0];
+      if (fnName === void 0 || fnName.length === 0) {
+        writeJson2(res, 400, {
+          error: { code: "FN_NAME_REQUIRED", message: "\u4EE5 /api/{fnName} \u8C03\u7528\u51FD\u6570" }
+        });
+        return;
+      }
+      const entry = `${fnName}.ts`;
+      const source = files[entry];
+      if (source === void 0) {
+        log(`[serve] ${req.method ?? "GET"} ${pathname} -> 404\uFF08\u51FD\u6570\u4E0D\u5B58\u5728\uFF09`);
+        writeJson2(res, 404, { error: { code: "FN_NOT_FOUND", message: `\u51FD\u6570 "${fnName}" \u4E0D\u5B58\u5728` } });
+        return;
+      }
+      const input = await buildInput(fnName, url, req);
+      const startedAt = performance.now();
+      try {
+        const result = await executor.execute(input);
+        const durationMs = Math.round(performance.now() - startedAt);
+        log(`[serve] ${req.method ?? "GET"} ${pathname} -> 200 ${durationMs}ms`);
+        writeJson2(res, 200, result.body === void 0 ? null : result.body);
+      } catch (error) {
+        const durationMs = Math.round(performance.now() - startedAt);
+        if (error instanceof ExecutorError) {
+          log(
+            `[serve] ${req.method ?? "GET"} ${pathname} -> ${error.status} ${durationMs}ms (${error.code})`
+          );
+          writeJson2(res, error.status, { error: { code: error.code, message: error.message } });
+          return;
+        }
+        log(`[serve] ${req.method ?? "GET"} ${pathname} -> 500 ${durationMs}ms`);
+        writeJson2(res, 500, {
+          error: {
+            code: "FN_EXEC_ERROR",
+            message: error instanceof Error ? error.message : "\u51FD\u6570\u6267\u884C\u5931\u8D25"
+          }
+        });
+      }
+      return;
+    }
+    if (pathname === "/healthz") {
+      writeJson2(res, 200, {
+        status: "ok",
+        service: "adep-serve",
+        project: config.name
+      });
+      return;
+    }
+    const served = await serveStatic(pathname, res);
+    if (served) return;
+    if (pathname.startsWith("/_preview/")) {
+      const widgetName = pathname.slice("/_preview/".length).split("/")[0];
+      if (widgetName !== void 0 && widgetName.length > 0) {
+        const widgetDir = join11(cwd, ".adep", "widgets", widgetName);
+        try {
+          const widgetStat = await stat6(widgetDir);
+          if (widgetStat.isDirectory()) {
+            const indexPath = join11(widgetDir, "index.html");
+            try {
+              const content = await readFile7(indexPath, "utf8");
+              res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+              res.end(content);
+              return;
+            } catch {
+            }
+          }
+        } catch {
+        }
+      }
+      writeJson2(res, 404, { error: { code: "WIDGET_NOT_FOUND", message: "\u7EC4\u4EF6\u4EA7\u7269\u4E0D\u5B58\u5728" } });
+      return;
+    }
+    if (pathname === "/" || pathname === "") {
+      writeJson2(res, 200, {
+        service: "adep-serve",
+        mode: "development",
+        project: config.name,
+        functions: functionNames,
+        static: hasStatic,
+        endpoints: {
+          functions: "/api/{fn}",
+          static: `/ \u2192 ${staticDir}`,
+          preview: "/_preview/{widget}",
+          healthz: "/healthz"
+        },
+        warning: "\u8FD9\u662F\u5F00\u53D1\u6001\u670D\u52A1\u5668\uFF0C\u4E0D\u662F\u751F\u4EA7\u670D\u52A1\u5668"
+      });
+      return;
+    }
+    writeJson2(res, 404, { error: { code: "NOT_FOUND", message: `\u8DEF\u5F84 "${pathname}" \u4E0D\u5B58\u5728` } });
+  };
+  const server = createServer2((req, res) => {
+    void handle(req, res).catch((error) => {
+      log(`[serve] \u672A\u5904\u7406\u9519\u8BEF: ${error instanceof Error ? error.message : String(error)}`);
+      if (!res.headersSent) {
+        writeJson2(res, 500, { error: { code: "INTERNAL_ERROR", message: "\u670D\u52A1\u5668\u5185\u90E8\u9519\u8BEF" } });
+      }
+    });
+  });
+  const actualPort = await new Promise((resolveListen, rejectListen) => {
+    server.once("error", rejectListen);
+    server.listen(port, host, () => {
+      server.off("error", rejectListen);
+      const addr = server.address();
+      if (addr === null || typeof addr === "string") {
+        resolveListen(port);
+      } else {
+        resolveListen(addr.port);
+      }
+    });
+  });
+  const banner = renderBanner({
+    host,
+    port: actualPort,
+    projectName: config.name,
+    functions: functionNames,
+    hasStatic,
+    staticDir: relative(cwd, staticDir).length > 0 ? relative(cwd, staticDir) : staticDir
+  });
+  log(banner);
+  return {
+    port: actualPort,
+    host,
+    baseUrl: `http://${host}:${actualPort}`,
+    close: async () => {
+      await new Promise((resolveClose) => {
+        server.close(() => resolveClose());
+      });
+    }
+  };
+}
+var MIME_TYPES;
+var init_server = __esm({
+  "packages/cli/src/serve/server.ts"() {
+    "use strict";
+    init_executor();
+    init_worker_executor();
+    init_runtime();
+    init_env();
+    init_invoke();
+    init_dev();
+    init_banner();
+    MIME_TYPES = {
+      ".html": "text/html; charset=utf-8",
+      ".htm": "text/html; charset=utf-8",
+      ".css": "text/css; charset=utf-8",
+      ".js": "application/javascript; charset=utf-8",
+      ".mjs": "application/javascript; charset=utf-8",
+      ".json": "application/json; charset=utf-8",
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".gif": "image/gif",
+      ".svg": "image/svg+xml",
+      ".ico": "image/x-icon",
+      ".woff": "font/woff",
+      ".woff2": "font/woff2",
+      ".ttf": "font/ttf",
+      ".txt": "text/plain; charset=utf-8",
+      ".md": "text/markdown; charset=utf-8",
+      ".pdf": "application/pdf",
+      ".map": "application/json"
+    };
+  }
+});
+
+// packages/cli/src/projects.ts
+var projects_exports = {};
+__export(projects_exports, {
+  projectsCreate: () => projectsCreate,
+  projectsInfo: () => projectsInfo,
+  projectsList: () => projectsList
+});
+function requireSlug(slug, hint) {
+  if (slug === void 0 || slug.trim().length === 0) {
+    throw new CliError("INVALID_SLUG", `\u7F3A\u5C11\u9879\u76EE slug\uFF1A${hint}`);
+  }
+  return slug.trim();
+}
+async function projectsCreate(paths, options) {
+  await requireNetworkGuard();
+  const client = await createClient(paths);
+  const slug = requireSlug(options.slug, "adep projects create <slug>");
+  const name = options.name ?? slug;
+  const body = { slug, name };
+  if (options.spaceId !== void 0) body.spaceId = options.spaceId;
+  const created = await client.request(
+    "/api/v1/projects",
+    { body },
+    "PROJECT_CREATE_FAILED"
+  );
+  if (created.url === void 0 || created.url.length === 0) {
+    throw new CliError("PROJECT_CREATE_FAILED", "\u5E73\u53F0\u672A\u8FD4\u56DE\u9879\u76EE\u5730\u5740\uFF0C\u65E0\u6CD5\u8F93\u51FA\u5B50\u57DF URL");
+  }
+  return created;
+}
+async function projectsList(paths) {
+  await requireNetworkGuard();
+  const client = await createClient(paths);
+  const result = await client.request(
+    "/api/v1/projects",
+    {},
+    "PROJECT_LIST_FAILED"
+  );
+  return result.projects;
+}
+async function projectsInfo(paths, options) {
+  await requireNetworkGuard();
+  const slug = requireSlug(options.slug, "adep projects info <slug>");
+  const projects = await projectsList(paths);
+  const match = projects.find((project2) => project2.slug === slug);
+  if (match === void 0) {
+    throw new CliError("PROJECT_NOT_FOUND", `\u9879\u76EE "${slug}" \u4E0D\u5B58\u5728\u6216\u4F60\u6CA1\u6709\u8BBF\u95EE\u6743\u9650`);
+  }
+  return match;
+}
+async function requireNetworkGuard() {
+  const { requireNetwork: requireNetwork2 } = await Promise.resolve().then(() => (init_net(), net_exports));
+  await requireNetwork2("adep projects");
+}
+var init_projects = __esm({
+  "packages/cli/src/projects.ts"() {
+    "use strict";
+    init_auth();
+    init_client();
+  }
+});
+
+// packages/cli/src/functions.ts
+var functions_exports = {};
+__export(functions_exports, {
+  functionsDeploy: () => functionsDeploy,
+  functionsList: () => functionsList,
+  functionsLogs: () => functionsLogs
+});
+import { resolve as resolve8 } from "node:path";
+async function functionsDeploy(paths, options) {
+  const startedAt = Date.now();
+  const result = await deploy(paths, {
+    cwd: options.cwd,
+    ...options.slug === void 0 ? {} : { slug: options.slug },
+    ...options.dir === void 0 ? {} : { functionsDir: resolve8(options.cwd, options.dir) },
+    silent: true
+  });
+  return { ...result, elapsedSeconds: (Date.now() - startedAt) / 1e3 };
+}
+async function functionsList(paths, options) {
+  const client = await createClient(paths);
+  const project2 = await resolveProject(client, options);
+  const result = await client.request(
+    `/api/v1/projects/${project2.id}/functions`,
+    {},
+    "FUNCTION_LIST_FAILED"
+  );
+  return {
+    projectId: project2.id,
+    slug: project2.slug,
+    baseUrl: project2.url,
+    functions: result.functions
+  };
+}
+async function functionsLogs(paths, options) {
+  if (options.name === void 0 || options.name.trim().length === 0) {
+    throw new CliError("INVALID_ARGUMENT", "\u7F3A\u5C11\u51FD\u6570\u540D\uFF1Aadep functions logs <name>");
+  }
+  const client = await createClient(paths);
+  const project2 = await resolveProject(client, options);
+  const listed = await client.request(
+    `/api/v1/projects/${project2.id}/functions`,
+    {},
+    "FUNCTION_LIST_FAILED"
+  );
+  const target = listed.functions.find((fn) => fn.name === options.name);
+  if (target === void 0) {
+    throw new CliError("FN_NOT_FOUND", `\u51FD\u6570 "${options.name}" \u4E0D\u5B58\u5728\u4E8E\u9879\u76EE "${project2.slug}"`);
+  }
+  const tail = options.tail === void 0 ? "" : `?tail=${encodeURIComponent(String(options.tail))}`;
+  const result = await client.request(
+    `/api/v1/functions/${target.id}/logs${tail}`,
+    {},
+    "FUNCTION_LOGS_FAILED"
+  );
+  return { functionId: target.id, name: target.name, logs: result.logs };
+}
+async function resolveProject(client, options) {
+  const slug = await resolveSlug(resolve8(options.cwd), options.slug);
+  const projects = await projectsListFrom(client);
+  const match = projects.find((project2) => project2.slug === slug);
+  if (match === void 0) {
+    throw new CliError(
+      "PROJECT_NOT_FOUND",
+      `\u5E73\u53F0\u9879\u76EE "${slug}" \u4E0D\u5B58\u5728\u6216\u4F60\u6CA1\u6709\u8BBF\u95EE\u6743\u9650\uFF1A\u5148\u6267\u884C adep projects create ${slug}`
+    );
+  }
+  return match;
+}
+async function projectsListFrom(client) {
+  const result = await client.request("/api/v1/projects", {}, "PROJECT_LIST_FAILED");
+  return result.projects;
+}
+var init_functions = __esm({
+  "packages/cli/src/functions.ts"() {
+    "use strict";
+    init_auth();
+    init_client();
+    init_deploy();
+  }
+});
+
+// packages/cli/src/mcp.ts
+var mcp_exports = {};
+__export(mcp_exports, {
+  mcpList: () => mcpList,
+  mcpPublish: () => mcpPublish,
+  mcpUnpublish: () => mcpUnpublish
+});
+import { resolve as resolve9 } from "node:path";
+async function mcpPublish(paths, options) {
+  const fn = requireFunctionName(options.fn);
+  const client = await createClient(paths);
+  const project2 = await resolveProject2(client, options);
+  const target = await resolveFunction(client, project2, fn);
+  const body = {};
+  if (options.toolName !== void 0 && options.toolName.trim().length > 0) {
+    body.toolName = options.toolName.trim();
+  }
+  if (options.description !== void 0 && options.description.length > 0) {
+    body.description = options.description;
+  }
+  const tool = await client.request(
+    `/api/v1/functions/${target.id}/mcp-publish`,
+    { method: "POST", ...Object.keys(body).length === 0 ? {} : { body } },
+    "MCP_PUBLISH_FAILED"
+  );
+  return { projectId: project2.id, tool };
+}
+async function mcpUnpublish(paths, options) {
+  const fn = requireFunctionName(options.fn);
+  const client = await createClient(paths);
+  const project2 = await resolveProject2(client, options);
+  const target = await resolveFunction(client, project2, fn);
+  const toolName = options.toolName?.trim() || fn;
+  const result = await client.request(
+    `/api/v1/functions/${target.id}/mcp-publish?tool=${encodeURIComponent(toolName)}`,
+    { method: "DELETE" },
+    "MCP_UNPUBLISH_FAILED"
+  );
+  return { projectId: project2.id, toolName, removed: result.unpublished === true };
+}
+async function mcpList(paths, options) {
+  const client = await createClient(paths);
+  const project2 = await resolveProject2(client, options);
+  const endpoint = `${project2.url.replace(/\/+$/, "")}/mcp`;
+  let response;
+  try {
+    response = await fetch(endpoint, {
+      method: "POST",
+      headers: { "content-type": "application/json", cookie: client.cookie },
+      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/list" })
+    });
+  } catch (error) {
+    throw new CliError(
+      "SERVER_UNREACHABLE",
+      `\u65E0\u6CD5\u8FDE\u63A5 MCP \u7AEF\u70B9 ${endpoint}\uFF1A${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const parsed = await response.json().catch(() => null);
+  if (!response.ok) {
+    const envelope = parsed ?? null;
+    throw new CliError(
+      envelope?.error?.code ?? "MCP_LIST_FAILED",
+      envelope?.error?.message ?? `MCP \u7AEF\u70B9\u8FD4\u56DE HTTP ${response.status}`
+    );
+  }
+  const rpcError = parsed?.error;
+  if (rpcError !== void 0) {
+    throw new CliError(
+      rpcError.code ?? "MCP_LIST_FAILED",
+      rpcError.message ?? "MCP tools/list \u5931\u8D25"
+    );
+  }
+  return {
+    projectId: project2.id,
+    slug: project2.slug,
+    endpoint,
+    tools: parsed?.result?.tools ?? []
+  };
+}
+function requireFunctionName(fn) {
+  if (fn === void 0 || fn.trim().length === 0) {
+    throw new CliError("INVALID_ARGUMENT", "\u7F3A\u5C11\u51FD\u6570\u540D\uFF1Aadep mcp publish --function <fn>");
+  }
+  return fn.trim();
+}
+async function resolveProject2(client, options) {
+  const slug = await resolveSlug(resolve9(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) {
+    throw new CliError(
+      "PROJECT_NOT_FOUND",
+      `\u5E73\u53F0\u9879\u76EE "${slug}" \u4E0D\u5B58\u5728\u6216\u4F60\u6CA1\u6709\u8BBF\u95EE\u6743\u9650\uFF1A\u5148\u6267\u884C adep projects create ${slug}`
+    );
+  }
+  return { id: match.id, slug: match.slug, url: match.url };
+}
+async function resolveFunction(client, project2, name) {
+  const listed = await client.request(`/api/v1/projects/${project2.id}/functions`, {}, "FUNCTION_LIST_FAILED");
+  const target = listed.functions.find((fn) => fn.name === name);
+  if (target === void 0) {
+    throw new CliError("FN_NOT_FOUND", `\u51FD\u6570 "${name}" \u4E0D\u5B58\u5728\u4E8E\u9879\u76EE "${project2.slug}"`);
+  }
+  return { id: target.id, name: target.name };
+}
+var init_mcp = __esm({
+  "packages/cli/src/mcp.ts"() {
+    "use strict";
+    init_auth();
+    init_client();
+  }
+});
+
+// packages/cli/src/doctor.ts
+var doctor_exports = {};
+__export(doctor_exports, {
+  formatDoctorReport: () => formatDoctorReport,
+  runDoctor: () => runDoctor
+});
+import { stat as stat7 } from "node:fs/promises";
+async function probeServer(server) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), SERVER_PROBE_TIMEOUT_MS);
+  try {
+    const response = await fetch(`${server}/api/v1/health`, { signal: controller.signal });
+    return { reachable: true, status: response.status };
+  } catch (error) {
+    return {
+      reachable: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function credentialMode(file) {
+  try {
+    const info = await stat7(file);
+    return (info.mode & 511).toString(8).padStart(3, "0");
+  } catch {
+    return void 0;
+  }
+}
+async function runDoctor(paths) {
+  const credentials = await loadCredentials(paths);
+  const server = credentials?.server ?? resolveServer();
+  const mode = await credentialMode(paths.credentialsFile);
+  const offline = await isOffline();
+  const health = await probeServer(server);
+  const report = {
+    server,
+    credentials: {
+      file: paths.credentialsFile,
+      present: credentials !== null,
+      ...mode === void 0 ? {} : { mode }
+    },
+    network: { offline },
+    serverHealth: health,
+    offlineCommands: [...OFFLINE_COMMANDS],
+    boundaries: SIM_BOUNDARIES.map((b) => ({ kind: b.kind, title: b.title, detail: b.detail }))
+  };
+  if (credentials !== null) report.credentials.email = credentials.email;
+  if (mode !== void 0 && mode !== "600") {
+    report.credentials.warning = `\u6743\u9650 ${mode} \u5BBD\u4E8E 0600\uFF0C\u5EFA\u8BAE chmod 600 ${paths.credentialsFile}`;
+  }
+  return report;
+}
+function formatDoctorReport(report) {
+  const lines = ["adep doctor \xB7 \u73AF\u5883\u81EA\u68C0", ""];
+  lines.push("\u51ED\u636E\u4E0E\u8EAB\u4EFD");
+  if (report.credentials.present) {
+    lines.push(`  \u2713 \u5DF2\u767B\u5F55 ${report.credentials.email ?? "(\u672A\u77E5\u90AE\u7BB1)"} @ ${report.server}`);
+    lines.push(
+      `  \xB7 \u51ED\u636E\u6587\u4EF6 ${report.credentials.file}\uFF08${report.credentials.mode ?? "\u6743\u9650\u672A\u77E5"}\uFF09`
+    );
+    if (report.credentials.warning !== void 0) lines.push(`  ! ${report.credentials.warning}`);
+  } else {
+    lines.push(`  \u2717 \u672A\u767B\u5F55\uFF08\u65E0 ${report.credentials.file}\uFF09`);
+    lines.push("    \u63D0\u793A\uFF1A\u5148\u6267\u884C adep login");
+  }
+  lines.push("", "\u7F51\u7EDC\u4E0E\u670D\u52A1\u7AEF");
+  lines.push(
+    report.network.offline ? "  \u2717 \u5916\u7F51\u4E0D\u53EF\u8FBE\uFF08\u4F9D\u8D56\u5B89\u88C5 / \u90E8\u7F72\u7B49\u547D\u4EE4\u5C06\u660E\u786E\u5931\u8D25\uFF09" : "  \u2713 \u5916\u7F51\u53EF\u8FBE"
+  );
+  if (report.serverHealth.reachable) {
+    lines.push(`  \u2713 \u5E73\u53F0\u53EF\u8FBE ${report.server}\uFF08/api/v1/health \u2192 ${report.serverHealth.status}\uFF09`);
+  } else {
+    lines.push(
+      `  \u2717 \u5E73\u53F0\u4E0D\u53EF\u8FBE ${report.server}\uFF1A${report.serverHealth.error ?? "\u65E0\u5E94\u7B54"}`,
+      "    \u63D0\u793A\uFF1A\u68C0\u67E5 ADEP_SERVER / \u767B\u5F55\u65F6\u7684 --server\uFF0C\u6216\u5148\u8D77\u672C\u5730 pnpm run dev"
+    );
+  }
+  lines.push("", "\u79BB\u7EBF\u53EF\u7528\u8303\u56F4\uFF08\u65AD\u7F51\u65F6\u4ECD\u53EF\u6267\u884C\uFF09");
+  for (const command of report.offlineCommands) lines.push(`  \xB7 ${command}`);
+  lines.push("", "\u672C\u5730\u6A21\u62DF\u8FD0\u884C\u65F6\u7684\u80FD\u529B\u8FB9\u754C\uFF08\u4E0E adep dev \u542F\u52A8\u6A2A\u5E45\u540C\u6E90\uFF09");
+  for (const boundary of report.boundaries) {
+    lines.push(`  \xB7 [${boundary.kind}] ${boundary.title}\uFF1A${boundary.detail}`);
+  }
+  return lines;
+}
+var SERVER_PROBE_TIMEOUT_MS, OFFLINE_COMMANDS;
+var init_doctor = __esm({
+  "packages/cli/src/doctor.ts"() {
+    "use strict";
+    init_credentials();
+    init_config();
+    init_boundary();
+    init_net();
+    SERVER_PROBE_TIMEOUT_MS = 5e3;
+    OFFLINE_COMMANDS = [
+      "adep init",
+      "adep dev",
+      "adep serve",
+      "adep widget init",
+      "adep widget dev",
+      "adep db\uFF08\u672C\u5730\u6A21\u62DF\uFF09",
+      "adep doctor"
+    ];
+  }
+});
+
+// packages/cli/src/db.ts
+var db_exports = {};
+__export(db_exports, {
+  dbExec: () => dbExec,
+  dbRollback: () => dbRollback,
+  dbSnapshotCreate: () => dbSnapshotCreate,
+  dbSnapshotList: () => dbSnapshotList,
+  dbSnapshotRestore: () => dbSnapshotRestore,
+  dbStart: () => dbStart,
+  dbStatus: () => dbStatus,
+  dbStop: () => dbStop
+});
+import { resolve as resolve10 } from "node:path";
+async function open2(paths, options) {
+  const client = await createClient(paths);
+  const project2 = await resolveSlug(resolve10(options.cwd), options.slug);
+  return { client, project: project2 };
+}
+async function dbStart(paths, options) {
+  const { client, project: project2 } = await open2(paths, options);
+  return client.request(`/api/v1/projects/${project2}/database`, { method: "POST" });
+}
+async function dbStatus(paths, options) {
+  const { client, project: project2 } = await open2(paths, options);
+  return client.request(`/api/v1/projects/${project2}/database`);
+}
+async function dbStop(paths, options) {
+  const { client, project: project2 } = await open2(paths, options);
+  return client.request(`/api/v1/projects/${project2}/database`, {
+    method: "DELETE"
+  });
+}
+async function dbExec(paths, options) {
+  const { client, project: project2 } = await open2(paths, options);
+  return client.request(
+    `/api/v1/projects/${project2}/database/console/sql`,
+    {
+      method: "POST",
+      body: {
+        sql: options.sql,
+        ...options.params === void 0 ? {} : { params: options.params },
+        ...options.confirmTable === void 0 ? {} : { confirmTable: options.confirmTable }
+      }
+    },
+    "SQL_EXEC_FAILED"
+  );
+}
+async function dbSnapshotList(paths, options) {
+  const { client, project: project2 } = await open2(paths, options);
+  return client.request(
+    `/api/v1/projects/${project2}/database/snapshots`
+  );
+}
+async function dbSnapshotCreate(paths, options) {
+  const { client, project: project2 } = await open2(paths, options);
+  return client.request(`/api/v1/projects/${project2}/database/snapshots`, {
+    method: "POST"
+  });
+}
+async function dbSnapshotRestore(paths, options) {
+  const { client, project: project2 } = await open2(paths, options);
+  return client.request(
+    `/api/v1/projects/${project2}/database/snapshots/${options.snapshotId}/restore`,
+    { method: "POST" }
+  );
+}
+async function dbRollback(paths, options) {
+  const { client, project: project2 } = await open2(paths, options);
+  return client.request(
+    `/api/v1/projects/${project2}/database/rollback`,
+    { method: "POST", body: { to: options.to } }
+  );
+}
+var init_db2 = __esm({
+  "packages/cli/src/db.ts"() {
+    "use strict";
+    init_client();
+  }
+});
+
+// packages/cli/src/storage.ts
+var storage_exports = {};
+__export(storage_exports, {
+  contentTypeOf: () => contentTypeOf,
+  storageDownload: () => storageDownload,
+  storageList: () => storageList,
+  storageRemove: () => storageRemove,
+  storageUpload: () => storageUpload
+});
+import { mkdir as mkdir7, readFile as readFile8, stat as stat8, writeFile as writeFile6 } from "node:fs/promises";
+import { basename as basename3, dirname as dirname7, extname, join as join12, resolve as resolve11 } from "node:path";
+async function open3(paths, options) {
+  const client = await createClient(paths);
+  const project2 = await resolveSlug(resolve11(options.cwd), options.slug);
+  return { client, project: project2 };
+}
+function contentTypeOf(path) {
+  const map = {
+    ".html": "text/html; charset=utf-8",
+    ".htm": "text/html; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".js": "text/javascript; charset=utf-8",
+    ".mjs": "text/javascript; charset=utf-8",
+    ".json": "application/json; charset=utf-8",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".svg": "image/svg+xml",
+    ".webp": "image/webp",
+    ".ico": "image/x-icon",
     ".txt": "text/plain; charset=utf-8",
     ".md": "text/markdown; charset=utf-8",
     ".xml": "application/xml",
@@ -3257,13 +4391,13 @@ function contentTypeOf(path) {
 }
 async function storageUpload(paths, options) {
   const { client, project: project2 } = await open3(paths, options);
-  const local = resolve8(options.file);
-  const info = await stat6(local).catch(() => null);
+  const local = resolve11(options.file);
+  const info = await stat8(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 readFile7(local);
+  const bytes = await readFile8(local);
   const form = new FormData();
   form.set("path", options.path);
   form.set("visibility", visibility);
@@ -3304,7 +4438,7 @@ 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 = resolve8(options.output ?? join11(resolve8(options.cwd), basename3(options.path)));
+  const output = resolve11(options.output ?? join12(resolve11(options.cwd), basename3(options.path)));
   await mkdir7(dirname7(output), { recursive: true });
   await writeFile6(output, bytes);
   return { path: options.path, output, size: bytes.length };
@@ -3332,11 +4466,11 @@ __export(hosting_exports, {
   hostingInfo: () => hostingInfo,
   hostingPull: () => hostingPull
 });
-import { readdir as readdir4, readFile as readFile8, stat as stat7 } from "node:fs/promises";
-import { dirname as dirname8, join as join12, relative, resolve as resolve9, sep } from "node:path";
+import { readdir as readdir5, readFile as readFile9, stat as stat9 } from "node:fs/promises";
+import { dirname as dirname8, join as join13, relative as relative2, resolve as resolve12, sep } from "node:path";
 async function open4(paths, options) {
   const client = await createClient(paths);
-  const project2 = await resolveSlug(resolve9(options.cwd), options.slug);
+  const project2 = await resolveSlug(resolve12(options.cwd), options.slug);
   return { client, project: project2 };
 }
 async function hostingInfo(paths, options) {
@@ -3349,104 +4483,782 @@ async function hostingInfo(paths, options) {
   };
 }
 async function collectSiteFiles(dir) {
-  const root = resolve9(dir);
+  const root = resolve12(dir);
   const files = /* @__PURE__ */ new Map();
   const walk = async (sub) => {
     let entries;
     try {
-      entries = await readdir4(sub, { withFileTypes: true });
+      entries = await readdir5(sub, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const full = join12(sub, entry.name);
+      const full = join13(sub, entry.name);
       if (entry.isDirectory()) {
         await walk(full);
       } else if (entry.isFile()) {
-        const rel = relative(root, full).split(sep).join("/");
+        const rel = relative2(root, full).split(sep).join("/");
         files.set(rel, full);
       }
     }
   };
-  await walk(root);
-  return files;
+  await walk(root);
+  return files;
+}
+async function hostingDeploy(paths, options) {
+  const { client, project: project2 } = await open4(paths, options);
+  const log = options.log ?? ((line) => process.stdout.write(`${line}
+`));
+  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)}`);
+  }
+  const uploaded = [];
+  for (const [rel, full] of files) {
+    log(`[adep] \u4E0A\u4F20 site/${rel}`);
+    const info2 = await stat9(full);
+    const bytes = await readFile9(full);
+    const form = new FormData();
+    form.set("path", `site/${rel}`);
+    form.set("visibility", "public");
+    form.set(
+      "file",
+      new Blob([bytes], { type: contentTypeOf(rel) }),
+      rel.split("/").pop()
+    );
+    await client.upload(`/api/v1/projects/${project2}/files`, form, "HOSTING_UPLOAD_FAILED");
+    uploaded.push({ path: `site/${rel}`, size: info2.size });
+  }
+  const config = await client.request(
+    `/api/v1/projects/${project2}/hosting`,
+    {
+      method: "PUT",
+      body: options.spa === void 0 ? { enabled: true } : { enabled: true, spaMode: options.spa }
+    }
+  );
+  const info = await hostingInfo(paths, options);
+  return { config: config.config, siteUrl: info.siteUrl, uploaded };
+}
+async function hostingPull(paths, options) {
+  const { client } = await open4(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: mkdir9, writeFile: writeFile9 } = await import("node:fs/promises");
+  const files = [];
+  for (const entry of info.files) {
+    if (entry.visibility !== "public" || entry.path === HOSTING_CONFIG_PATH) continue;
+    const url = entry.url;
+    if (url === void 0 || url.length === 0) continue;
+    log(`[adep] \u4E0B\u8F7D ${entry.path}`);
+    const response = await client.download(url, "HOSTING_DOWNLOAD_FAILED");
+    const bytes = Buffer.from(await response.arrayBuffer());
+    const rel = entry.path.replace(/^site\//, "");
+    const target = join13(outputDir, ...rel.split("/"));
+    await mkdir9(dirname8(target), { recursive: true });
+    await writeFile9(target, bytes);
+    files.push({ path: entry.path, size: bytes.length });
+  }
+  return { siteUrl: info.siteUrl, outputDir, files };
+}
+async function hostingConfig(paths, options) {
+  const { client, project: project2 } = await open4(paths, options);
+  const body = {};
+  if (options.enabled !== void 0) body["enabled"] = options.enabled;
+  if (options.spa !== void 0) body["spaMode"] = options.spa;
+  const result = await client.request(
+    `/api/v1/projects/${project2}/hosting`,
+    { method: "PUT", body }
+  );
+  return result.config;
+}
+var HOSTING_CONFIG_PATH;
+var init_hosting = __esm({
+  "packages/cli/src/hosting.ts"() {
+    "use strict";
+    init_client();
+    init_auth();
+    init_storage2();
+    HOSTING_CONFIG_PATH = "site/.hosting.json";
+  }
+});
+
+// packages/cli/src/export/client.ts
+var client_exports2 = {};
+__export(client_exports2, {
+  createExportApiClient: () => createExportApiClient
+});
+import { writeFile as writeFile7 } from "node:fs/promises";
+function toExportJob(view) {
+  return {
+    id: view.id,
+    status: view.status,
+    progress: view.progress,
+    createdAt: view.createdAt,
+    ...view.stage === void 0 ? {} : { stage: view.stage },
+    ...view.error === void 0 ? {} : { error: view.error },
+    ...view.downloadUrl === void 0 ? {} : { downloadUrl: view.downloadUrl },
+    ...view.bundleSize === void 0 ? {} : { bundleSize: view.bundleSize },
+    ...view.completedAt === void 0 ? {} : { completedAt: view.completedAt }
+  };
+}
+async function createExportApiClient(paths) {
+  const client = await createClient(paths);
+  return {
+    async triggerExport(projectId, options) {
+      const view = await client.request(
+        `/api/v1/projects/${encodeURIComponent(projectId)}/export`,
+        { method: "POST", body: { withData: options.withData, withSource: options.withSource } },
+        "EXPORT_TRIGGER_FAILED"
+      );
+      return toExportJob(view);
+    },
+    async getJobStatus(jobId) {
+      const view = await client.request(
+        `/api/v1/exports/${encodeURIComponent(jobId)}`,
+        {},
+        "EXPORT_STATUS_FAILED"
+      );
+      return toExportJob(view);
+    },
+    async downloadBundle(jobId, outputPath) {
+      const download = await client.request(
+        `/api/v1/exports/${encodeURIComponent(jobId)}/download`,
+        {},
+        "EXPORT_DOWNLOAD_FAILED"
+      );
+      if (download.downloadUrl.length === 0) {
+        throw new CliError("EXPORT_BUNDLE_UNAVAILABLE", "\u5BFC\u51FA\u4EA7\u7269\u4E0B\u8F7D URL \u4E3A\u7A7A\uFF0C\u4EA7\u7269\u53EF\u80FD\u5C1A\u4E0D\u53EF\u7528");
+      }
+      const response = await client.download(download.downloadUrl, "EXPORT_DOWNLOAD_FAILED");
+      const bytes = Buffer.from(await response.arrayBuffer());
+      await writeFile7(outputPath, bytes);
+      return { path: outputPath, size: bytes.length };
+    }
+  };
+}
+var init_client2 = __esm({
+  "packages/cli/src/export/client.ts"() {
+    "use strict";
+    init_auth();
+    init_client();
+  }
+});
+
+// shared/deploy-bundle/zip.ts
+function zipRead(buf) {
+  const r = new Reader(buf);
+  const eocd = findEocd(buf);
+  if (eocd < 0) throw new ZipFormatError("\u627E\u4E0D\u5230 EOCD \u7B7E\u540D");
+  const total = r.u16(eocd + 10);
+  const centralOffset = r.u32(eocd + 16);
+  const decoder = new TextDecoder();
+  const out = /* @__PURE__ */ new Map();
+  let cursor = centralOffset;
+  for (let i = 0; i < total; i++) {
+    if (cursor + 46 > buf.length) throw new ZipFormatError("\u4E2D\u592E\u76EE\u5F55\u8BB0\u5F55\u8D8A\u754C");
+    if (r.u32(cursor) !== SIG_CENTRAL) throw new ZipFormatError("\u4E2D\u592E\u76EE\u5F55\u7B7E\u540D\u4E0D\u5339\u914D");
+    const method = r.u16(cursor + 10);
+    if (method !== 0) throw new ZipFormatError("\u4EC5\u652F\u6301 store \u578B\u6761\u76EE\u8BFB\u53D6");
+    const compSize = r.u32(cursor + 20);
+    const nameLen = r.u16(cursor + 28);
+    const extraLen = r.u16(cursor + 30);
+    const commentLen = r.u16(cursor + 32);
+    const localHeaderOffset = r.u32(cursor + 42);
+    if (localHeaderOffset + 30 > buf.length) throw new ZipFormatError("\u672C\u5730\u5934\u504F\u79FB\u8D8A\u754C");
+    const name = decoder.decode(r.slice(cursor + 46, nameLen));
+    const localNameLen = r.u16(localHeaderOffset + 26);
+    const localExtraLen = r.u16(localHeaderOffset + 28);
+    const dataStart = localHeaderOffset + 30 + localNameLen + localExtraLen;
+    if (dataStart + compSize > buf.length) throw new ZipFormatError("\u6761\u76EE\u6570\u636E\u8D8A\u754C");
+    if (!out.has(name)) out.set(name, r.slice(dataStart, compSize));
+    cursor += 46 + nameLen + extraLen + commentLen;
+  }
+  return out;
+}
+function findEocd(buf) {
+  const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+  const min = Math.max(0, buf.length - 65557);
+  for (let i = buf.length - 22; i >= min; i--) {
+    if (view.getUint32(i, true) === SIG_EOCD) return i;
+  }
+  return -1;
+}
+var SIG_CENTRAL, SIG_EOCD, CRC_TABLE, Reader, ZipFormatError;
+var init_zip = __esm({
+  "shared/deploy-bundle/zip.ts"() {
+    "use strict";
+    SIG_CENTRAL = 33639248;
+    SIG_EOCD = 101010256;
+    CRC_TABLE = (() => {
+      const table = new Uint32Array(256);
+      for (let i = 0; i < 256; i++) {
+        let c = i;
+        for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+        table[i] = c >>> 0;
+      }
+      return table;
+    })();
+    Reader = class {
+      constructor(buf) {
+        this.buf = buf;
+        this.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+      }
+      view;
+      u16(offset) {
+        return this.view.getUint16(offset, true);
+      }
+      u32(offset) {
+        return this.view.getUint32(offset, true);
+      }
+      slice(start, length) {
+        return this.buf.subarray(start, start + length);
+      }
+    };
+    ZipFormatError = class extends Error {
+      constructor(message) {
+        super(`[appexport] \u975E\u6CD5 zip\uFF1A${message}`);
+        this.name = "ZipFormatError";
+      }
+    };
+  }
+});
+
+// packages/cli/src/export/fs.ts
+var fs_exports = {};
+__export(fs_exports, {
+  createExportFileSystem: () => createExportFileSystem
+});
+import { mkdir as mkdir8, readFile as readFile10, rm as rm3, stat as stat10, writeFile as writeFile8 } from "node:fs/promises";
+import { dirname as dirname9, join as join14 } from "node:path";
+function createExportFileSystem() {
+  return {
+    readFile: (path) => readFile10(path),
+    writeFile: (path, content) => writeFile8(path, content),
+    // 同时用于清理解压临时目录（${zip}.tmp 是个目录）——递归强制删除，缺失不报错。
+    deleteFile: async (path) => {
+      await rm3(path, { recursive: true, force: true });
+    },
+    fileExists: async (path) => {
+      try {
+        await stat10(path);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    mkdir: async (path) => {
+      await mkdir8(path, { recursive: true });
+    },
+    unzip: async (zipPath, targetDir) => {
+      const entries = zipRead(await readFile10(zipPath));
+      for (const [name, data] of entries) {
+        const dest = join14(targetDir, name);
+        await mkdir8(dirname9(dest), { recursive: true });
+        await writeFile8(dest, data);
+      }
+    }
+  };
+}
+var init_fs = __esm({
+  "packages/cli/src/export/fs.ts"() {
+    "use strict";
+    init_zip();
+  }
+});
+
+// shared/deploy-bundle/manifest.ts
+var CURRENT_SCHEMA_VERSION, BundleContentKind, ALLOWED_CONTENT_KINDS;
+var init_manifest2 = __esm({
+  "shared/deploy-bundle/manifest.ts"() {
+    "use strict";
+    CURRENT_SCHEMA_VERSION = 1;
+    BundleContentKind = {
+      /** 云函数代码与配置。 */
+      Functions: "functions",
+      /** 数据库 schema 与种子数据。 */
+      Database: "database",
+      /** 前端静态资源。 */
+      Web: "web",
+      /** 运行时配置（Dockerfile / docker-compose.yml）。 */
+      Runtime: "runtime",
+      /** 启动 / 备份 / 恢复脚本。 */
+      Scripts: "scripts",
+      /** 文档（README / 部署手册）。 */
+      Docs: "docs"
+    };
+    ALLOWED_CONTENT_KINDS = Object.values(BundleContentKind);
+  }
+});
+
+// shared/deploy-bundle/validate.ts
+function validateBundleManifest(manifest) {
+  const errors = [];
+  const warnings = [];
+  if (typeof manifest !== "object" || manifest === null) {
+    return {
+      valid: false,
+      errors: [{ code: "INVALID_TYPE", message: "Manifest \u5FC5\u987B\u662F\u5BF9\u8C61" }],
+      warnings: []
+    };
+  }
+  const m = manifest;
+  const schemaVersion = m.schemaVersion;
+  if (typeof schemaVersion !== "number" || !Number.isInteger(schemaVersion)) {
+    errors.push({
+      code: "INVALID_SCHEMA_VERSION",
+      message: "schemaVersion \u5FC5\u987B\u662F\u6574\u6570",
+      field: "schemaVersion"
+    });
+  } else if (schemaVersion > CURRENT_SCHEMA_VERSION) {
+    errors.push({
+      code: "SCHEMA_VERSION_TOO_HIGH",
+      message: `schemaVersion ${schemaVersion} \u9AD8\u4E8E\u5F53\u524D\u652F\u6301\u7248\u672C ${CURRENT_SCHEMA_VERSION}\uFF0C\u9700\u5347\u7EA7\u5BFC\u51FA\u7AEF`,
+      field: "schemaVersion"
+    });
+  } else if (schemaVersion < CURRENT_SCHEMA_VERSION) {
+    warnings.push({
+      code: "SCHEMA_VERSION_LOW",
+      message: `schemaVersion ${schemaVersion} \u4F4E\u4E8E\u5F53\u524D\u7248\u672C ${CURRENT_SCHEMA_VERSION}\uFF0C\u5EFA\u8BAE\u91CD\u65B0\u5BFC\u51FA`,
+      field: "schemaVersion"
+    });
+  }
+  if (typeof m.platformVersion !== "string" || m.platformVersion.trim() === "") {
+    errors.push({
+      code: "MISSING_PLATFORM_VERSION",
+      message: "platformVersion \u5FC5\u987B\u975E\u7A7A",
+      field: "platformVersion"
+    });
+  }
+  if (typeof m.project !== "object" || m.project === null) {
+    errors.push({
+      code: "MISSING_PROJECT",
+      message: "project \u5FC5\u987B\u662F\u5BF9\u8C61",
+      field: "project"
+    });
+  } else {
+    const project2 = m.project;
+    if (typeof project2.id !== "string" || project2.id.trim() === "") {
+      errors.push({
+        code: "MISSING_PROJECT_ID",
+        message: "project.id \u5FC5\u987B\u975E\u7A7A",
+        field: "project.id"
+      });
+    }
+    if (typeof project2.name !== "string" || project2.name.trim() === "") {
+      errors.push({
+        code: "MISSING_PROJECT_NAME",
+        message: "project.name \u5FC5\u987B\u975E\u7A7A",
+        field: "project.name"
+      });
+    }
+    if (typeof project2.slug !== "string" || project2.slug.trim() === "") {
+      errors.push({
+        code: "MISSING_PROJECT_SLUG",
+        message: "project.slug \u5FC5\u987B\u975E\u7A7A",
+        field: "project.slug"
+      });
+    }
+    if (typeof project2.version !== "number" || !Number.isInteger(project2.version) || project2.version < 1) {
+      errors.push({
+        code: "INVALID_PROJECT_VERSION",
+        message: "project.version \u5FC5\u987B\u662F\u6B63\u6574\u6570",
+        field: "project.version"
+      });
+    }
+  }
+  if (!Array.isArray(m.contents)) {
+    errors.push({
+      code: "MISSING_CONTENTS",
+      message: "contents \u5FC5\u987B\u662F\u6570\u7EC4",
+      field: "contents"
+    });
+  } else if (m.contents.length === 0) {
+    errors.push({
+      code: "EMPTY_CONTENTS",
+      message: "contents \u4E0D\u80FD\u4E3A\u7A7A",
+      field: "contents"
+    });
+  } else {
+    m.contents.forEach((content, index) => {
+      validateContent(content, index, errors, warnings);
+    });
+  }
+  if (typeof m.runtime !== "object" || m.runtime === null) {
+    errors.push({
+      code: "MISSING_RUNTIME",
+      message: "runtime \u5FC5\u987B\u662F\u5BF9\u8C61",
+      field: "runtime"
+    });
+  } else {
+    const runtime = m.runtime;
+    if (typeof runtime.engine !== "string" || runtime.engine.trim() === "") {
+      errors.push({
+        code: "MISSING_ENGINE",
+        message: "runtime.engine \u5FC5\u987B\u975E\u7A7A",
+        field: "runtime.engine"
+      });
+    }
+    if (typeof runtime.engineVersion !== "string" || runtime.engineVersion.trim() === "") {
+      errors.push({
+        code: "MISSING_ENGINE_VERSION",
+        message: "runtime.engineVersion \u5FC5\u987B\u975E\u7A7A",
+        field: "runtime.engineVersion"
+      });
+    }
+    if (typeof runtime.port !== "number" || !Number.isInteger(runtime.port) || runtime.port < 1 || runtime.port > 65535) {
+      errors.push({
+        code: "INVALID_PORT",
+        message: "runtime.port \u5FC5\u987B\u662F 1-65535 \u7684\u6574\u6570",
+        field: "runtime.port"
+      });
+    }
+    if (typeof runtime.startCommand !== "string" || runtime.startCommand.trim() === "") {
+      errors.push({
+        code: "MISSING_START_COMMAND",
+        message: "runtime.startCommand \u5FC5\u987B\u975E\u7A7A",
+        field: "runtime.startCommand"
+      });
+    }
+  }
+  if (typeof m.exportedAt !== "string" || m.exportedAt.trim() === "") {
+    errors.push({
+      code: "MISSING_EXPORTED_AT",
+      message: "exportedAt \u5FC5\u987B\u975E\u7A7A",
+      field: "exportedAt"
+    });
+  } else {
+    const date = new Date(m.exportedAt);
+    if (Number.isNaN(date.getTime())) {
+      errors.push({
+        code: "INVALID_EXPORTED_AT",
+        message: "exportedAt \u5FC5\u987B\u662F\u6709\u6548\u7684 ISO 8601 \u65F6\u95F4",
+        field: "exportedAt"
+      });
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
 }
-async function hostingDeploy(paths, options) {
-  const { client, project: project2 } = await open4(paths, options);
-  const log = options.log ?? ((line) => process.stdout.write(`${line}
-`));
-  const files = await collectSiteFiles(options.dir);
-  if (files.size === 0) {
-    throw new CliError("NO_SITE_FILES", `\u7AD9\u70B9\u76EE\u5F55\u4E3A\u7A7A\uFF1A${resolve9(options.dir)}`);
+function validateContent(content, index, errors, _warnings) {
+  if (typeof content !== "object" || content === null) {
+    errors.push({
+      code: "INVALID_CONTENT",
+      message: `contents[${index}] \u5FC5\u987B\u662F\u5BF9\u8C61`,
+      field: `contents[${index}]`
+    });
+    return;
   }
-  const uploaded = [];
-  for (const [rel, full] of files) {
-    log(`[adep] \u4E0A\u4F20 site/${rel}`);
-    const info2 = await stat7(full);
-    const bytes = await readFile8(full);
-    const form = new FormData();
-    form.set("path", `site/${rel}`);
-    form.set("visibility", "public");
-    form.set(
-      "file",
-      new Blob([bytes], { type: contentTypeOf(rel) }),
-      rel.split("/").pop()
-    );
-    await client.upload(`/api/v1/projects/${project2}/files`, form, "HOSTING_UPLOAD_FAILED");
-    uploaded.push({ path: `site/${rel}`, size: info2.size });
+  const c = content;
+  if (typeof c.path !== "string" || c.path.trim() === "") {
+    errors.push({
+      code: "MISSING_CONTENT_PATH",
+      message: `contents[${index}].path \u5FC5\u987B\u975E\u7A7A`,
+      field: `contents[${index}].path`
+    });
   }
-  const config = await client.request(
-    `/api/v1/projects/${project2}/hosting`,
-    {
-      method: "PUT",
-      body: options.spa === void 0 ? { enabled: true } : { enabled: true, spaMode: options.spa }
-    }
-  );
-  const info = await hostingInfo(paths, options);
-  return { config: config.config, siteUrl: info.siteUrl, uploaded };
-}
-async function hostingPull(paths, options) {
-  const { client } = await open4(paths, options);
-  const log = options.log ?? ((line) => process.stdout.write(`${line}
-`));
-  const info = await hostingInfo(paths, options);
-  const outputDir = resolve9(options.output ?? resolve9(options.cwd));
-  const { mkdir: mkdir8, writeFile: writeFile7 } = await import("node:fs/promises");
-  const files = [];
-  for (const entry of info.files) {
-    if (entry.visibility !== "public" || entry.path === HOSTING_CONFIG_PATH) continue;
-    const url = entry.url;
-    if (url === void 0 || url.length === 0) continue;
-    log(`[adep] \u4E0B\u8F7D ${entry.path}`);
-    const response = await client.download(url, "HOSTING_DOWNLOAD_FAILED");
-    const bytes = Buffer.from(await response.arrayBuffer());
-    const rel = entry.path.replace(/^site\//, "");
-    const target = join12(outputDir, ...rel.split("/"));
-    await mkdir8(dirname8(target), { recursive: true });
-    await writeFile7(target, bytes);
-    files.push({ path: entry.path, size: bytes.length });
+  if (typeof c.sha256 !== "string" || c.sha256.trim() === "") {
+    errors.push({
+      code: "MISSING_CONTENT_SHA256",
+      message: `contents[${index}].sha256 \u5FC5\u987B\u975E\u7A7A`,
+      field: `contents[${index}].sha256`
+    });
+  } else if (!/^[a-fA-F0-9]{64}$/.test(c.sha256)) {
+    errors.push({
+      code: "INVALID_SHA256_FORMAT",
+      message: `contents[${index}].sha256 \u5FC5\u987B\u662F 64 \u5B57\u7B26\u5341\u516D\u8FDB\u5236`,
+      field: `contents[${index}].sha256`
+    });
+  }
+  if (typeof c.kind !== "string" || c.kind.trim() === "") {
+    errors.push({
+      code: "MISSING_CONTENT_KIND",
+      message: `contents[${index}].kind \u5FC5\u987B\u975E\u7A7A`,
+      field: `contents[${index}].kind`
+    });
+  } else if (!ALLOWED_CONTENT_KINDS.includes(c.kind)) {
+    errors.push({
+      code: "INVALID_CONTENT_KIND",
+      message: `contents[${index}].kind "${c.kind}" \u4E0D\u5728\u5141\u8BB8\u5217\u8868\u5185\uFF0C\u5141\u8BB8\u503C\uFF1A${ALLOWED_CONTENT_KINDS.join(", ")}`,
+      field: `contents[${index}].kind`
+    });
   }
-  return { siteUrl: info.siteUrl, outputDir, files };
 }
-async function hostingConfig(paths, options) {
-  const { client, project: project2 } = await open4(paths, options);
-  const body = {};
-  if (options.enabled !== void 0) body["enabled"] = options.enabled;
-  if (options.spa !== void 0) body["spaMode"] = options.spa;
-  const result = await client.request(
-    `/api/v1/projects/${project2}/hosting`,
-    { method: "PUT", body }
-  );
-  return result.config;
+function verifyContents(contents, actualContents, hashFunction) {
+  const errors = [];
+  const warnings = [];
+  for (const content of contents) {
+    const actual = actualContents.get(content.path);
+    if (actual === void 0) {
+      errors.push({
+        code: "CONTENT_NOT_FOUND",
+        message: `\u5185\u5BB9\u7269 ${content.path} \u5728\u5B9E\u9645\u5305\u4E2D\u4E0D\u5B58\u5728`,
+        field: `contents[${content.path}]`
+      });
+      continue;
+    }
+    const actualHash = hashFunction(actual);
+    if (actualHash.toLowerCase() !== content.sha256.toLowerCase()) {
+      errors.push({
+        code: "CHECKSUM_MISMATCH",
+        message: `\u5185\u5BB9\u7269 ${content.path} \u7684\u6821\u9A8C\u548C\u4E0D\u5339\u914D\uFF1A\u671F\u671B ${content.sha256}\uFF0C\u5B9E\u9645 ${actualHash}`,
+        field: `contents[${content.path}].sha256`
+      });
+    }
+  }
+  for (const path of actualContents.keys()) {
+    if (!contents.some((c) => c.path === path)) {
+      warnings.push({
+        code: "UNDECLARED_CONTENT",
+        message: `\u5B9E\u9645\u5305\u4E2D\u5B58\u5728 Manifest \u672A\u58F0\u660E\u7684\u5185\u5BB9\uFF1A${path}`,
+        field: `contents[${path}]`
+      });
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
 }
-var HOSTING_CONFIG_PATH;
-var init_hosting = __esm({
-  "packages/cli/src/hosting.ts"() {
+var init_validate = __esm({
+  "shared/deploy-bundle/validate.ts"() {
     "use strict";
-    init_client();
-    init_auth();
-    init_storage2();
-    HOSTING_CONFIG_PATH = "site/.hosting.json";
+    init_manifest2();
+  }
+});
+
+// packages/cli/src/export/command.ts
+var command_exports = {};
+__export(command_exports, {
+  ExportCommand: () => ExportCommand
+});
+import { createHash as createHash4 } from "node:crypto";
+var ExportCommand;
+var init_command = __esm({
+  "packages/cli/src/export/command.ts"() {
+    "use strict";
+    init_validate();
+    ExportCommand = class {
+      constructor(apiClient, fs, pollInterval = 2e3, maxPollAttempts = 300) {
+        this.apiClient = apiClient;
+        this.fs = fs;
+        this.pollInterval = pollInterval;
+        this.maxPollAttempts = maxPollAttempts;
+      }
+      /**
+       * 执行导出命令。
+       *
+       * @param options 命令选项
+       * @returns 导出结果
+       */
+      async execute(options) {
+        const projectId = options.project ?? "default";
+        const outputDir = options.out ?? "./exports";
+        const jsonOutput = options.json ?? false;
+        try {
+          if (!jsonOutput) {
+            console.log(`\u89E6\u53D1\u5BFC\u51FA\uFF1A\u9879\u76EE ${projectId}`);
+          }
+          const job = await this.apiClient.triggerExport(projectId, {
+            withData: options.withData,
+            withSource: options.withSource
+          });
+          if (!jsonOutput) {
+            console.log(`\u5BFC\u51FA\u4EFB\u52A1\u5DF2\u521B\u5EFA\uFF1A${job.id}`);
+          }
+          const completedJob = await this.pollJobStatus(job.id, jsonOutput);
+          if (completedJob.status === "failed") {
+            return {
+              success: false,
+              jobId: job.id,
+              status: "failed",
+              error: completedJob.error ?? "\u5BFC\u51FA\u5931\u8D25"
+            };
+          }
+          if (!jsonOutput) {
+            console.log("\u4E0B\u8F7D\u5BFC\u51FA\u4EA7\u7269...");
+          }
+          const outputPath = `${outputDir}/${projectId}-export-${Date.now()}.zip`;
+          await this.fs.mkdir(outputDir);
+          const downloadResult = await this.apiClient.downloadBundle(job.id, outputPath);
+          if (!jsonOutput) {
+            console.log(`\u4EA7\u7269\u5DF2\u4E0B\u8F7D\uFF1A${downloadResult.path}\uFF08${this.formatSize(downloadResult.size)}\uFF09`);
+          }
+          if (!jsonOutput) {
+            console.log("\u6267\u884C manifest \u81EA\u68C0...");
+          }
+          const manifest = await this.verifyManifest(downloadResult.path);
+          if (!jsonOutput) {
+            this.printContentList(manifest);
+          }
+          return {
+            success: true,
+            jobId: job.id,
+            status: "completed",
+            downloadPath: downloadResult.path,
+            manifest: {
+              projectName: manifest.project.name,
+              platformVersion: manifest.platformVersion,
+              exportedAt: manifest.exportedAt,
+              contents: this.countContents(manifest.contents)
+            }
+          };
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "unknown_error";
+          if (message.includes("ECONNREFUSED") || message.includes("ENOTFOUND") || message.includes("network")) {
+            return {
+              success: false,
+              error: `\u5E73\u53F0\u7AEF\u70B9\u4E0D\u53EF\u8FBE\uFF1A${message}\u3002\u8BF7\u68C0\u67E5\u7F51\u7EDC\u8FDE\u63A5\u548C\u5E73\u53F0\u5730\u5740\u914D\u7F6E\uFF0C\u7136\u540E\u91CD\u8BD5\u3002`
+            };
+          }
+          return {
+            success: false,
+            error: message
+          };
+        }
+      }
+      /**
+       * 轮询任务状态。
+       *
+       * @param jobId 任务 ID
+       * @param jsonOutput 是否 JSON 输出
+       * @returns 完成的任务
+       */
+      async pollJobStatus(jobId, jsonOutput) {
+        let attempts = 0;
+        let lastProgress = -1;
+        while (attempts < this.maxPollAttempts) {
+          const job = await this.apiClient.getJobStatus(jobId);
+          if (!jsonOutput && job.progress !== lastProgress) {
+            const stage = job.stage ? `\uFF08${job.stage}\uFF09` : "";
+            console.log(`\u8FDB\u5EA6\uFF1A${job.progress}%${stage}`);
+            lastProgress = job.progress;
+          }
+          if (job.status === "completed" || job.status === "failed") {
+            return job;
+          }
+          attempts++;
+          await this.sleep(this.pollInterval);
+        }
+        throw new Error(`\u5BFC\u51FA\u4EFB\u52A1\u8D85\u65F6\uFF1A\u8F6E\u8BE2 ${this.maxPollAttempts} \u6B21\u540E\u4ECD\u672A\u5B8C\u6210`);
+      }
+      /**
+       * 验证 Manifest：解压 → 契约校验 → 逐项 sha256 校验 → 清理临时目录。
+       *
+       * 逐项校验与导出端同法：内容物以 latin1 承载（逐字节双射，二进制条目不被解码改写），
+       * 比对时对原字节做真实 sha256；任一不匹配即判定包损坏并抛错，不静默放行。
+       * 无论成功失败，`${zip}.tmp` 临时目录都在 finally 里删除，不留残余。
+       *
+       * @param zipPath ZIP 文件路径
+       * @returns Manifest
+       */
+      async verifyManifest(zipPath) {
+        const tempDir = `${zipPath}.tmp`;
+        try {
+          await this.fs.mkdir(tempDir);
+          await this.fs.unzip(zipPath, tempDir);
+          const manifestPath = `${tempDir}/manifest.json`;
+          if (!await this.fs.fileExists(manifestPath)) {
+            throw new Error("manifest.json \u4E0D\u5B58\u5728\uFF0C\u5305\u53EF\u80FD\u5DF2\u635F\u574F");
+          }
+          const manifestContent = await this.fs.readFile(manifestPath);
+          const manifest = JSON.parse(manifestContent.toString("utf-8"));
+          const validationResult = validateBundleManifest(manifest);
+          if (!validationResult.valid) {
+            const errors = validationResult.errors.map((e) => `${e.field ?? ""}: ${e.message}`).join("\n");
+            throw new Error(`manifest \u6821\u9A8C\u5931\u8D25\uFF1A
+${errors}`);
+          }
+          const actual = /* @__PURE__ */ new Map();
+          for (const content of manifest.contents) {
+            const filePath = `${tempDir}/${content.path}`;
+            if (await this.fs.fileExists(filePath)) {
+              const bytes = await this.fs.readFile(filePath);
+              actual.set(content.path, bytes.toString("latin1"));
+            }
+          }
+          const contentResult = verifyContents(
+            manifest.contents,
+            actual,
+            (text) => createHash4("sha256").update(Buffer.from(text, "latin1")).digest("hex")
+          );
+          if (!contentResult.valid) {
+            const detail = contentResult.errors.map((e) => e.message).join("\n");
+            throw new Error(`\u5185\u5BB9\u7269\u6821\u9A8C\u548C\u4E0D\u5339\u914D\uFF1A
+${detail}`);
+          }
+          return manifest;
+        } finally {
+          await this.fs.deleteFile(tempDir);
+        }
+      }
+      /**
+       * 统计内容物数量。
+       *
+       * @param contents 内容物列表
+       * @returns 统计结果
+       */
+      countContents(contents) {
+        return {
+          functions: contents.filter((c) => c.kind === "functions").length,
+          database: contents.filter((c) => c.kind === "database").length,
+          web: contents.filter((c) => c.kind === "web").length,
+          runtime: contents.filter((c) => c.kind === "runtime").length,
+          scripts: contents.filter((c) => c.kind === "scripts").length,
+          docs: contents.filter((c) => c.kind === "docs").length,
+          total: contents.length
+        };
+      }
+      /**
+       * 打印内容清单。
+       *
+       * @param manifest Manifest
+       */
+      printContentList(manifest) {
+        const counts = this.countContents(manifest.contents);
+        console.log("");
+        console.log("==========================================");
+        console.log("\u5BFC\u51FA\u5185\u5BB9\u6E05\u5355");
+        console.log("==========================================");
+        console.log(`\u9879\u76EE\uFF1A${manifest.project.name}`);
+        console.log(`\u5E73\u53F0\u7248\u672C\uFF1A${manifest.platformVersion}`);
+        console.log(`\u5BFC\u51FA\u65F6\u95F4\uFF1A${manifest.exportedAt}`);
+        console.log("");
+        console.log(`\u51FD\u6570\u6587\u4EF6\uFF1A${counts.functions}`);
+        console.log(`\u6570\u636E\u5E93\u6587\u4EF6\uFF1A${counts.database}`);
+        console.log(`\u524D\u7AEF\u6587\u4EF6\uFF1A${counts.web}`);
+        console.log(`\u8FD0\u884C\u65F6\u6587\u4EF6\uFF1A${counts.runtime}`);
+        console.log(`\u811A\u672C\u6587\u4EF6\uFF1A${counts.scripts}`);
+        console.log(`\u6587\u6863\u6587\u4EF6\uFF1A${counts.docs}`);
+        console.log(`\u603B\u6587\u4EF6\u6570\uFF1A${counts.total}`);
+        console.log("==========================================");
+      }
+      /**
+       * 格式化文件大小。
+       *
+       * @param bytes 字节数
+       * @returns 格式化后的大小
+       */
+      formatSize(bytes) {
+        if (bytes < 1024) return `${bytes} B`;
+        if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+        if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+        return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+      }
+      /**
+       * 睡眠指定毫秒数。
+       *
+       * @param ms 毫秒数
+       */
+      sleep(ms) {
+        return new Promise((resolve15) => setTimeout(resolve15, ms));
+      }
+    };
   }
 });
 
@@ -3456,23 +5268,23 @@ __export(dev_exports2, {
   loadWidgetProject: () => loadWidgetProject,
   startWidgetDev: () => startWidgetDev
 });
-import { createServer as createServer2 } from "node:http";
+import { createServer as createServer3 } from "node:http";
 import { watch as watch2 } from "node:fs";
-import { readFile as readFile9, stat as stat8 } from "node:fs/promises";
-import { join as join13, resolve as resolve10 } from "node:path";
+import { readFile as readFile11, stat as stat11 } from "node:fs/promises";
+import { join as join15, resolve as resolve13 } from "node:path";
 async function loadWidgetProject(cwd) {
   const fallback = {
     name: "widget",
     framework: "vue3"
   };
-  const manifestPath = join13(resolve10(cwd), "manifest.json");
+  const manifestPath = join15(resolve13(cwd), "manifest.json");
   try {
-    await stat8(manifestPath);
+    await stat11(manifestPath);
   } catch {
     return fallback;
   }
   try {
-    const raw = await readFile9(manifestPath, "utf8");
+    const raw = await readFile11(manifestPath, "utf8");
     const parsed = JSON.parse(raw);
     return {
       name: typeof parsed["name"] === "string" ? parsed["name"] : fallback.name,
@@ -3547,7 +5359,7 @@ function sandboxHtml(name, framework) {
 `;
 }
 async function startWidgetDev(options) {
-  const cwd = resolve10(options.cwd);
+  const cwd = resolve13(options.cwd);
   const log = options.log ?? ((line) => process.stdout.write(`${line}
 `));
   const project2 = await loadWidgetProject(cwd);
@@ -3598,14 +5410,14 @@ data: ${version}
   }
   const readTheme = async () => {
     try {
-      return await readFile9(join13(cwd, "src", "theme.css"), "utf8");
+      return await readFile11(join15(cwd, "src", "theme.css"), "utf8");
     } catch {
       return null;
     }
   };
   const readProps = async () => {
     try {
-      return await readFile9(join13(cwd, "src", "mock-props.json"), "utf8");
+      return await readFile11(join15(cwd, "src", "mock-props.json"), "utf8");
     } catch {
       return null;
     }
@@ -3657,7 +5469,7 @@ data: ${version}
     }
     res.writeHead(404).end("not found");
   };
-  const server = createServer2((req, res) => {
+  const server = createServer3((req, res) => {
     void handle(req, res);
   });
   await new Promise((resolveListen, rejectListen) => {
@@ -3694,18 +5506,18 @@ var publish_exports = {};
 __export(publish_exports, {
   publishWidget: () => publishWidget
 });
-import { readFile as readFile10 } from "node:fs/promises";
-import { basename as basename4, join as join14, resolve as resolve11 } from "node:path";
+import { readFile as readFile12 } from "node:fs/promises";
+import { basename as basename4, join as join16, resolve as resolve14 } from "node:path";
 async function publishWidget(paths, options) {
   const log = options.log ?? ((line) => process.stdout.write(`${line}
 `));
   const client = await createClient(paths);
-  const root = resolve11(options.cwd);
+  const root = resolve14(options.cwd);
   const project2 = await loadWidgetProject(root);
   const framework = options.framework ?? project2.framework;
   let version = "0.1.0";
   try {
-    const pkg = JSON.parse(await readFile10(join14(root, "package.json"), "utf8"));
+    const pkg = JSON.parse(await readFile12(join16(root, "package.json"), "utf8"));
     if (typeof pkg["version"] === "string" && pkg["version"].length > 0) version = pkg["version"];
   } catch {
     version = "0.1.0";
@@ -3742,18 +5554,10 @@ var init_publish = __esm({
 
 // packages/cli/src/cli.ts
 init_auth();
+init_config();
 import { Command } from "commander";
 import { createRequire } from "node:module";
 
-// packages/cli/src/config.ts
-function resolvePaths(env = process.env) {
-  const home = env["ADEP_HOME"] ?? `${env["HOME"] ?? ""}/.adep`;
-  return { home, credentialsFile: `${home}/credentials` };
-}
-function resolveServer(env = process.env) {
-  return (env["ADEP_SERVER"] ?? "https://adep.jajabjbj.top").replace(/\/+$/, "");
-}
-
 // packages/cli/src/init.ts
 import { mkdir as mkdir2, stat as stat2, writeFile } from "node:fs/promises";
 import { dirname as dirname2, join, resolve } from "node:path";
@@ -3864,6 +5668,9 @@ init_build();
 init_init();
 var requireJson = createRequire(import.meta.url);
 var APP_VERSION = requireJson("../package.json").version;
+function needsRelogin(error) {
+  return error.code === "NOT_LOGGED_IN" || error.code === "AUTH_UNAUTHORIZED";
+}
 function emitError(output, command, json, error) {
   if (error instanceof CliError || error instanceof InitError || error instanceof WidgetError || error instanceof WidgetInitError) {
     if (json) {
@@ -3875,8 +5682,9 @@ function emitError(output, command, json, error) {
         })
       );
     } else {
-      output(`\u9519\u8BEF\uFF1A${error.message}`);
-      if (error instanceof CliError && error.code === "NOT_LOGGED_IN") {
+      const withCode = error.message.includes(error.code) || error.code.length === 0 ? error.message : `${error.message}\uFF08${error.code}\uFF09`;
+      output(`\u9519\u8BEF\uFF1A${withCode}`);
+      if (error instanceof CliError && needsRelogin(error)) {
         output("\u63D0\u793A\uFF1A\u5148\u6267\u884C adep login");
       }
     }
@@ -3917,6 +5725,45 @@ function parseBool(raw) {
   if (raw === "false") return false;
   throw new CliError("INVALID_BOOLEAN", `\u5E03\u5C14\u53C2\u6570\u987B\u4E3A true \u6216 false\uFF0C\u6536\u5230 "${raw}"`);
 }
+function formatSeconds(seconds) {
+  return `${Math.max(0.1, Math.round(seconds * 10) / 10)}s`;
+}
+async function runDeploy(paths, output, json, cwd, slug, dir) {
+  const { deploy: deploy2 } = await Promise.resolve().then(() => (init_deploy(), deploy_exports));
+  const startedAt = Date.now();
+  const result = await deploy2(paths, {
+    cwd,
+    ...slug === void 0 ? {} : { slug },
+    ...dir === void 0 ? {} : { functionsDir: dir },
+    // --json 下逐函数进度会破坏「stdout 恰好一个 JSON 对象」的信封约定（PRD §2.5.3）。
+    silent: json,
+    // 人读模式的进度也走注入的 output：deploy 内部缺省会直写 process.stdout，
+    // 那会让带 sink 的调用方漏收这部分行。
+    log: (line) => output(line)
+  });
+  const elapsedSeconds = (Date.now() - startedAt) / 1e3;
+  const deployedCount = result.functions.filter((fn) => fn.action !== "none").length;
+  if (json) {
+    output(
+      JSON.stringify({
+        ok: true,
+        command: "deploy",
+        data: { ...result, elapsedSeconds, deployedCount }
+      })
+    );
+    return;
+  }
+  for (const fn of result.functions) {
+    output(`${fn.name}  v${fn.version}  ${fn.url}`);
+  }
+  if (result.noChanges) {
+    output(
+      `\u2713 no changes \xB7 ${result.functions.length} functions up to date in ${formatSeconds(elapsedSeconds)}`
+    );
+    return;
+  }
+  output(`\u2713 ${deployedCount} functions deployed in ${formatSeconds(elapsedSeconds)}`);
+}
 function buildProgram(options = {}) {
   const output = options.output ?? ((line) => process.stdout.write(`${line}
 `));
@@ -4022,25 +5869,212 @@ function buildProgram(options = {}) {
       emitError(output, "dev", jsonMode(), error);
     }
   });
+  program2.command("serve").description(
+    "\u5F00\u53D1\u6001\u670D\u52A1\u5668\uFF1A\u51FD\u6570 /api/{fn} + /healthz + \u9759\u6001\u6258\u7BA1 + \u7EC4\u4EF6\u9884\u89C8\uFF08\u9ED8\u8BA4\u4EC5\u56DE\u73AF\uFF0C\u4E0D\u662F\u751F\u4EA7\u670D\u52A1\u5668\uFF09"
+  ).option("-p, --port <port>", "\u76D1\u542C\u7AEF\u53E3\uFF08\u7F3A\u7701\u53D6 PORT \u73AF\u5883\u53D8\u91CF\uFF0C\u518D\u7F3A\u7701 8787\uFF09").option(
+    "-H, --host <host>",
+    "\u76D1\u542C\u5730\u5740\uFF08\u7F3A\u7701\u53D6 HOST \u73AF\u5883\u53D8\u91CF\uFF0C\u518D\u7F3A\u7701 127.0.0.1\uFF1B\u7ED1\u5B9A\u975E\u56DE\u73AF\u65F6\u7ED9\u51FA\u5BF9\u5916\u66B4\u9732\u8B66\u544A\uFF09"
+  ).option(
+    "--static <dir>",
+    "\u9759\u6001\u6258\u7BA1\u76EE\u5F55\uFF08\u7F3A\u7701\u53D6 ADEP_SERVE_STATIC_DIR\uFF0C\u518D\u7F3A\u7701 public/\uFF1B\u81EA\u6258\u7BA1\u90E8\u7F72\u5305\u6307\u5411\u5305\u5185 web/\uFF09"
+  ).action(async (flags) => {
+    try {
+      const { startServeServer: startServeServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+      await startServeServer2({
+        cwd,
+        ...flags.port === void 0 ? {} : { port: Number(flags.port) },
+        ...flags.host === void 0 ? {} : { host: flags.host },
+        ...flags.static === void 0 ? {} : { staticDir: flags.static }
+      });
+      await new Promise(() => void 0);
+    } catch (error) {
+      emitError(output, "serve", jsonMode(), error);
+    }
+  });
   program2.command("deploy").description("\u589E\u91CF\u90E8\u7F72\uFF1A\u5BF9\u6BD4\u8FDC\u7AEF\u54C8\u5E0C \u2192 \u4EC5\u4E0A\u4F20\u53D8\u66F4 \u2192 \u53D1\u5E03 \u2192 \u8F93\u51FA\u8BBF\u95EE\u57DF\u540D").option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09").action(async (flags) => {
     try {
-      const { deploy: deploy2 } = await Promise.resolve().then(() => (init_deploy(), deploy_exports));
-      const result = await deploy2(paths, {
+      await runDeploy(paths, output, jsonMode(), cwd, flags.project);
+    } catch (error) {
+      emitError(output, "deploy", jsonMode(), error);
+    }
+  });
+  const projects = program2.command("projects").description("\u9879\u76EE\uFF1A\u521B\u5EFA / \u5217\u51FA / \u67E5\u770B\uFF08\u5B50\u57DF\u5730\u5740\u7531\u5E73\u53F0\u56DE\u663E\uFF0C\u4E0D\u5728 CLI \u4FA7\u62FC\uFF09");
+  projects.command("create").description("\u521B\u5EFA\u9879\u76EE\u5E76\u8F93\u51FA\u5B50\u57DF\u5730\u5740").argument("<slug>", "\u9879\u76EE slug\uFF08\u5168\u5C40\u552F\u4E00\uFF0C\u5373\u5B50\u57DF\u540D\uFF09").option("-n, --name <name>", "\u9879\u76EE\u5C55\u793A\u540D\uFF08\u7F3A\u7701\u53D6 slug\uFF09").option("--space <spaceId>", "\u5F52\u5C5E\u7A7A\u95F4\uFF08\u7F3A\u7701\u4E2A\u4EBA\u7A7A\u95F4\uFF09").action(async (slug, flags) => {
+    try {
+      const { projectsCreate: projectsCreate2 } = await Promise.resolve().then(() => (init_projects(), projects_exports));
+      const created = await projectsCreate2(paths, {
+        slug,
+        ...flags.name === void 0 ? {} : { name: flags.name },
+        ...flags.space === void 0 ? {} : { spaceId: flags.space }
+      });
+      if (jsonMode()) {
+        output(JSON.stringify({ ok: true, command: "projects create", data: created }));
+      } else {
+        output(`\u2713 Project created \xB7 ${created.url}`);
+      }
+    } catch (error) {
+      emitError(output, "projects create", jsonMode(), error);
+    }
+  });
+  projects.command("list").description("\u5217\u51FA\u5F53\u524D\u7528\u6237\u53EF\u8BBF\u95EE\u7684\u9879\u76EE").action(async () => {
+    try {
+      const { projectsList: projectsList2 } = await Promise.resolve().then(() => (init_projects(), projects_exports));
+      const list = await projectsList2(paths);
+      if (jsonMode()) {
+        output(JSON.stringify({ ok: true, command: "projects list", data: { projects: list } }));
+      } else {
+        if (list.length === 0) output("\uFF08\u8FD8\u6CA1\u6709\u9879\u76EE\uFF1Aadep projects create <slug>\uFF09");
+        for (const project2 of list) output(`${project2.slug}	${project2.name}	${project2.url}`);
+      }
+    } catch (error) {
+      emitError(output, "projects list", jsonMode(), error);
+    }
+  });
+  projects.command("info").description("\u67E5\u770B\u5355\u4E2A\u9879\u76EE\u7684 id / slug / \u5B50\u57DF\u5730\u5740").argument("<slug>", "\u9879\u76EE slug").action(async (slug) => {
+    try {
+      const { projectsInfo: projectsInfo2 } = await Promise.resolve().then(() => (init_projects(), projects_exports));
+      const project2 = await projectsInfo2(paths, { slug });
+      if (jsonMode()) {
+        output(JSON.stringify({ ok: true, command: "projects info", data: project2 }));
+      } else {
+        output(`${project2.id}	${project2.slug}	${project2.name}	${project2.url}`);
+      }
+    } catch (error) {
+      emitError(output, "projects info", jsonMode(), error);
+    }
+  });
+  const functions = program2.command("functions").description("\u4E91\u51FD\u6570\uFF1A\u90E8\u7F72\uFF08\u53EF\u6307\u5B9A\u76EE\u5F55\uFF09/ \u5217\u51FA / \u67E5\u65E5\u5FD7");
+  functions.command("deploy").description(
+    "\u90E8\u7F72\u51FD\u6570\u76EE\u5F55\uFF08`adep deploy` \u7684\u547D\u4EE4\u65CF\u5165\u53E3\uFF1Bdir \u8986\u76D6 adep.config.ts \u7684 functionsDir\uFF09"
+  ).argument("[dir]", "\u51FD\u6570\u76EE\u5F55\uFF08\u76F8\u5BF9\u9879\u76EE\u6839\u6216\u7EDD\u5BF9\u8DEF\u5F84\uFF0C\u7F3A\u7701\u53D6\u914D\u7F6E\u91CC\u7684 functionsDir\uFF09").option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09").action(async (dir, flags) => {
+    try {
+      await runDeploy(paths, output, jsonMode(), cwd, flags.project, dir);
+    } catch (error) {
+      emitError(output, "functions deploy", jsonMode(), error);
+    }
+  });
+  functions.command("list").description("\u5217\u51FA\u9879\u76EE\u4E0B\u7684\u4E91\u51FD\u6570\uFF08\u542B\u516C\u7F51\u8BBF\u95EE\u524D\u7F00\uFF09").option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09").action(async (flags) => {
+    try {
+      const { functionsList: functionsList2 } = await Promise.resolve().then(() => (init_functions(), functions_exports));
+      const result = await functionsList2(paths, {
         cwd,
         ...flags.project === void 0 ? {} : { slug: flags.project }
       });
       if (jsonMode()) {
-        output(JSON.stringify({ ok: true, command: "deploy", data: result }));
+        output(JSON.stringify({ ok: true, command: "functions list", data: result }));
       } else {
-        if (result.noChanges) {
-          output("no changes\uFF1A\u5168\u90E8\u51FD\u6570\u4E0E\u5DF2\u53D1\u5E03\u7248\u672C\u4E00\u81F4\uFF0C\u672A\u4EA7\u751F\u65B0\u7248\u672C");
-        }
+        if (result.functions.length === 0) output("\uFF08\u8BE5\u9879\u76EE\u4E0B\u8FD8\u6CA1\u6709\u51FD\u6570\uFF09");
         for (const fn of result.functions) {
-          output(`${fn.name}  v${fn.version}  ${fn.url}`);
+          output(`${fn.name}	${result.baseUrl}/${fn.name}`);
         }
       }
     } catch (error) {
-      emitError(output, "deploy", jsonMode(), error);
+      emitError(output, "functions list", jsonMode(), error);
+    }
+  });
+  functions.command("logs").description("\u67E5\u8BE2\u51FD\u6570\u6700\u8FD1\u6267\u884C\u65E5\u5FD7\uFF08\u7F13\u51B2\u5728\u5E73\u53F0\u8FDB\u7A0B\u5185\uFF0C\u672A\u6267\u884C\u8FC7\u7684\u51FD\u6570\u4E3A\u7A7A\uFF09").argument("<name>", "\u51FD\u6570\u540D").option("--tail <count>", "\u53D6\u6700\u8FD1\u591A\u5C11\u6761\uFF08\u7F3A\u7701 100\uFF0C\u670D\u52A1\u7AEF\u6709\u4E0A\u9650\uFF09").option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09").action(async (name, flags) => {
+    try {
+      const { functionsLogs: functionsLogs2 } = await Promise.resolve().then(() => (init_functions(), functions_exports));
+      const tail = flags.tail === void 0 ? void 0 : Number(flags.tail);
+      if (tail !== void 0 && (!Number.isFinite(tail) || tail <= 0)) {
+        throw new CliError("INVALID_TAIL", `--tail \u987B\u4E3A\u6B63\u6574\u6570\uFF0C\u6536\u5230 "${flags.tail}"`);
+      }
+      const result = await functionsLogs2(paths, {
+        cwd,
+        name,
+        ...tail === void 0 ? {} : { tail },
+        ...flags.project === void 0 ? {} : { slug: flags.project }
+      });
+      if (jsonMode()) {
+        output(JSON.stringify({ ok: true, command: "functions logs", data: result }));
+      } else {
+        if (result.logs.length === 0) {
+          output(`\uFF08\u51FD\u6570 ${name} \u6682\u65E0\u6267\u884C\u65E5\u5FD7\uFF1A\u5148\u7528 adep deploy \u53D1\u5E03\u5E76\u7ECF\u7F51\u5173\u6216\u8C03\u8BD5\u9762\u677F\u6267\u884C\u4E00\u6B21\uFF09`);
+        }
+        for (const log of result.logs) output(`${log.at}  [${log.level}]  ${log.message}`);
+      }
+    } catch (error) {
+      emitError(output, "functions logs", jsonMode(), error);
+    }
+  });
+  const mcp = program2.command("mcp").description("MCP Tool\uFF1A\u628A\u4E91\u51FD\u6570\u53D1\u5E03\u4E3A\u5DE5\u5177 / \u53D6\u6D88\u53D1\u5E03 / \u5217\u51FA");
+  mcp.command("publish").description("\u53D1\u5E03\u4E91\u51FD\u6570\u4E3A\u9879\u76EE MCP Tool\uFF08Tool \u540D\u7F3A\u7701\u53D6\u51FD\u6570\u540D\uFF0C--name \u53EF\u8986\u76D6\uFF09").requiredOption("--function <fn>", "\u8981\u53D1\u5E03\u7684\u51FD\u6570\u540D").option("--name <tool>", "\u6CE8\u518C\u7684 Tool \u540D\uFF08\u7F3A\u7701\u53D6\u51FD\u6570\u540D\uFF09").option(
+    "--description <text>",
+    "\u8986\u76D6\u9762\u5411 Agent \u7684\u5DE5\u5177\u63CF\u8FF0\uFF08\u7F3A\u7701\u7528\u6E90\u7801 @description / \u63A8\u5BFC\u63CF\u8FF0\uFF09"
+  ).option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09").action(
+    async (flags) => {
+      try {
+        const { mcpPublish: mcpPublish2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
+        const result = await mcpPublish2(paths, {
+          cwd,
+          fn: flags.function,
+          ...flags.name === void 0 ? {} : { toolName: flags.name },
+          ...flags.description === void 0 ? {} : { description: flags.description },
+          ...flags.project === void 0 ? {} : { slug: flags.project }
+        });
+        if (jsonMode()) {
+          output(JSON.stringify({ ok: true, command: "mcp publish", data: result }));
+        } else {
+          output(`\u2713 MCP tool published \xB7 ${result.tool.name}`);
+        }
+      } catch (error) {
+        emitError(output, "mcp publish", jsonMode(), error);
+      }
+    }
+  );
+  mcp.command("unpublish").description("\u53D6\u6D88\u53D1\u5E03\u4E91\u51FD\u6570\u5BF9\u5E94\u7684 MCP Tool\uFF08\u7ACB\u5373\u4ECE\u9879\u76EE tools/list \u79FB\u9664\uFF09").requiredOption("--function <fn>", "\u51FD\u6570\u540D").option("--name <tool>", "\u5DF2\u6CE8\u518C\u7684 Tool \u540D\uFF08\u7F3A\u7701\u53D6\u51FD\u6570\u540D\uFF1B\u53D1\u5E03\u65F6\u7528\u4E86\u522B\u540D\u624D\u9700\u7ED9\u51FA\uFF09").option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09").action(async (flags) => {
+    try {
+      const { mcpUnpublish: mcpUnpublish2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
+      const result = await mcpUnpublish2(paths, {
+        cwd,
+        fn: flags.function,
+        ...flags.name === void 0 ? {} : { toolName: flags.name },
+        ...flags.project === void 0 ? {} : { slug: flags.project }
+      });
+      if (jsonMode()) {
+        output(JSON.stringify({ ok: true, command: "mcp unpublish", data: result }));
+      } else if (result.removed) {
+        output(`\u2713 MCP tool unpublished \xB7 ${result.toolName}`);
+      } else {
+        output(`\uFF08\u9879\u76EE\u672A\u53D1\u5E03\u540D\u4E3A ${result.toolName} \u7684 MCP tool\uFF0C\u65E0\u9700\u53D6\u6D88\uFF09`);
+      }
+    } catch (error) {
+      emitError(output, "mcp unpublish", jsonMode(), error);
+    }
+  });
+  mcp.command("list").description("\u5217\u51FA\u9879\u76EE\u5DF2\u53D1\u5E03\u7684 MCP Tool \u4E0E\u7AEF\u70B9\u5730\u5740\uFF08\u8BFB\u9879\u76EE /mcp \u7684 tools/list\uFF09").option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09").action(async (flags) => {
+    try {
+      const { mcpList: mcpList2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
+      const result = await mcpList2(paths, {
+        cwd,
+        ...flags.project === void 0 ? {} : { slug: flags.project }
+      });
+      if (jsonMode()) {
+        output(JSON.stringify({ ok: true, command: "mcp list", data: result }));
+      } else {
+        output(`\u7AEF\u70B9\uFF1A${result.endpoint}`);
+        if (result.tools.length === 0) {
+          output("\uFF08\u8FD8\u6CA1\u6709\u5DF2\u53D1\u5E03\u7684 MCP tool\uFF1Aadep mcp publish --function <fn>\uFF09");
+        }
+        for (const tool of result.tools) {
+          output(`${tool.name}	${tool.description ?? ""}`);
+        }
+      }
+    } catch (error) {
+      emitError(output, "mcp list", jsonMode(), error);
+    }
+  });
+  program2.command("doctor").description("\u73AF\u5883\u81EA\u68C0\uFF1A\u51ED\u636E\u72B6\u6001 / \u5E73\u53F0\u53EF\u8FBE\u6027 / \u79BB\u7EBF\u53EF\u7528\u8303\u56F4\uFF08\u8865\u9F50\u65AD\u7F51\u6587\u6848\u5F15\u7528\u7684\u60AC\u7A7A\u547D\u4EE4\uFF09").action(async () => {
+    try {
+      const { runDoctor: runDoctor2, formatDoctorReport: formatDoctorReport2 } = await Promise.resolve().then(() => (init_doctor(), doctor_exports));
+      const report = await runDoctor2(paths);
+      if (jsonMode()) {
+        output(JSON.stringify({ ok: true, command: "doctor", data: report }));
+      } else {
+        for (const line of formatDoctorReport2(report)) output(line);
+      }
+    } catch (error) {
+      emitError(output, "doctor", jsonMode(), error);
     }
   });
   const db = program2.command("db").description("\u9879\u76EE\u6570\u636E\u5E93\u7EF4\u62A4\uFF1A\u542F\u52A8 / \u72B6\u6001 / \u505C\u6B62 / SQL / \u5FEB\u7167 / \u56DE\u6EDA").option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09");
@@ -4361,6 +6395,45 @@ function buildProgram(options = {}) {
       emitError(output, "hosting config", jsonMode(), error);
     }
   });
+  program2.command("export").description("\u5BFC\u51FA\u81EA\u6258\u7BA1\u90E8\u7F72\u5305\uFF1A\u89E6\u53D1\u957F\u4EFB\u52A1 \u2192 \u8F6E\u8BE2\u8FDB\u5EA6 \u2192 \u4E0B\u8F7D zip \u2192 manifest \u9010\u9879\u81EA\u68C0").option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09").option("--with-data", "\u5305\u542B\u6570\u636E\u5E93\u884C\u6570\u636E\uFF08\u7F3A\u7701\u4EC5 schema\uFF09").option("--with-source", "\u5305\u542B\u51FD\u6570\u6E90\u7801\uFF08\u7F3A\u7701\u5E73\u53F0\u5DF2\u542B\uFF0C\u663E\u5F0F\u7F6E\u6B64\u4E0D\u6539\u53D8\u9ED8\u8BA4\uFF09").option("--out <dir>", "\u8F93\u51FA\u76EE\u5F55\uFF08\u7F3A\u7701 ./exports\uFF09").action(
+    async (flags) => {
+      try {
+        const { createExportApiClient: createExportApiClient2 } = await Promise.resolve().then(() => (init_client2(), client_exports2));
+        const { createExportFileSystem: createExportFileSystem2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
+        const { ExportCommand: ExportCommand2 } = await Promise.resolve().then(() => (init_command(), command_exports));
+        const { resolveSlug: resolveSlug2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+        const project2 = await resolveSlug2(cwd, flags.project);
+        const apiClient = await createExportApiClient2(paths);
+        const command = new ExportCommand2(apiClient, createExportFileSystem2());
+        const result = await command.execute({
+          project: project2,
+          ...flags.withData === true ? { withData: true } : {},
+          ...flags.withSource === true ? { withSource: true } : {},
+          ...flags.out === void 0 ? {} : { out: flags.out },
+          json: jsonMode()
+        });
+        if (jsonMode()) {
+          if (result.success) {
+            output(JSON.stringify({ ok: true, command: "export", data: result }));
+          } else {
+            output(
+              JSON.stringify({
+                ok: false,
+                command: "export",
+                error: { code: "EXPORT_FAILED", message: result.error ?? "\u5BFC\u51FA\u5931\u8D25" }
+              })
+            );
+            process.exitCode = 1;
+          }
+        } else if (!result.success) {
+          output(`\u9519\u8BEF\uFF1A${result.error ?? "\u5BFC\u51FA\u5931\u8D25"}`);
+          process.exitCode = 1;
+        }
+      } catch (error) {
+        emitError(output, "export", jsonMode(), error);
+      }
+    }
+  );
   const widget = program2.command("widget").description("\u5FAE\u524D\u7AEF\u7EC4\u4EF6\uFF08widget\uFF09\uFF1A\u811A\u624B\u67B6 / \u672C\u5730\u6C99\u7BB1 / \u53D1\u5E03");
   widget.command("init").description("\u521D\u59CB\u5316 widget \u5DE5\u7A0B\uFF08\u6A21\u677F\uFF1Avue3-ts / react-ts\uFF09").argument("<name>", "widget \u540D\u79F0\uFF08\u5C0F\u5199\u5B57\u6BCD\u5F00\u5934\uFF0C\u4EC5\u5C0F\u5199\u5B57\u6BCD/\u6570\u5B57/\u8FDE\u5B57\u7B26\uFF09").option("-t, --template <template>", "\u6A21\u677F\uFF1Avue3-ts | react-ts", "vue3-ts").action(async (name, flags) => {
     try {