@adep/cli 0.4.11 → 0.5.1

package/dist/index.js

@@ -1,8 +1,13 @@
 #!/usr/bin/env node
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -50,16 +55,16 @@ function openBrowser(url2, options = {}) {
   const spawnImpl = options.spawnImpl ?? spawn;
   if (!shouldOpenBrowser(options)) return Promise.resolve(false);
   const { command, args } = browserOpenCommand(url2, platform);
-  return new Promise((resolve20) => {
+  return new Promise((resolve21) => {
     try {
       const child = spawnImpl(command, args, { stdio: "ignore", detached: true });
-      child.once("error", () => resolve20(false));
+      child.once("error", () => resolve21(false));
       child.once("spawn", () => {
         child.unref();
-        resolve20(true);
+        resolve21(true);
       });
     } catch {
-      resolve20(false);
+      resolve21(false);
     }
   });
 }
@@ -455,7 +460,7 @@ async function loginWithDevice(paths, input2) {
     expiresInSeconds: code.expires_in,
     browserOpened
   });
-  const sleep = input2.sleep ?? ((ms) => new Promise((resolve20) => setTimeout(resolve20, ms)));
+  const sleep = input2.sleep ?? ((ms) => new Promise((resolve21) => setTimeout(resolve21, ms)));
   const token = await pollDeviceToken({
     server,
     deviceCode: code.device_code,
@@ -549,6 +554,8 @@ var init_auth = __esm({
         this.exitCode = exitCode;
         this.name = "CliError";
       }
+      code;
+      exitCode;
     };
     CLI_DEVICE_CLIENT_ID = "adep-cli";
   }
@@ -883,6 +890,8 @@ var init_executor_runtime = __esm({
         this.code = code;
         this.name = "ExecutorError";
       }
+      status;
+      code;
     };
     TIMEOUT_CODE = "FN_EXEC_TIMEOUT";
     OOM_CODE = "FN_EXEC_OOM";
@@ -1172,7 +1181,7 @@ var init_worker_executor = __esm({
         const entry = input2.entry ?? resolveDraftEntry(input2.fn.name, input2.files) ?? "index.ts";
         const deps = this.depsConfig === void 0 ? void 0 : resolveExecutionDeps(this.depsConfig, input2.project.id, input2.files["package.json"]);
         const logs = [];
-        return new Promise((resolve20, reject) => {
+        return new Promise((resolve21, reject) => {
           let worker;
           try {
             worker = new Worker(resolveWorkerEntry(), {
@@ -1234,7 +1243,7 @@ var init_worker_executor = __esm({
               if (message.type === "result") {
                 clearTimeout(timer);
                 void worker.terminate();
-                resolve20({ body: message.body, logs });
+                resolve21({ body: message.body, logs });
                 return;
               }
               if (message.type === "error") {
@@ -1319,6 +1328,8 @@ var init_identifier = __esm({
         this.code = code;
         this.name = "DbError";
       }
+      status;
+      code;
     };
     IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]{0,62}$/;
   }
@@ -2548,11 +2559,13 @@ var init_sql_engine = __esm({
         this.code = code;
         this.name = "SimDbError";
       }
+      code;
     };
     ParamCursor = class {
       constructor(params) {
         this.params = params;
       }
+      params;
       index = 0;
       take() {
         const v = this.params[this.index];
@@ -2564,16 +2577,19 @@ var init_sql_engine = __esm({
       constructor(column) {
         this.column = column;
       }
+      column;
     };
     ColumnRef = class {
       constructor(column) {
         this.column = column;
       }
+      column;
     };
     ExprRef = class {
       constructor(source) {
         this.source = source;
       }
+      source;
     };
     SimSqlEngine = class {
       tables = {};
@@ -3055,9 +3071,12 @@ var init_driver = __esm({
         this.code = code;
         this.name = "StorageError";
       }
+      status;
+      code;
     };
     STORAGE_CODES = {
       invalidPath: "STORAGE_INVALID_PATH",
+      invalidData: "STORAGE_INVALID_DATA",
       notFound: "STORAGE_NOT_FOUND",
       quotaExceeded: "STORAGE_QUOTA_EXCEEDED"
     };
@@ -3281,11 +3300,33 @@ var init_signature = __esm({
 // packages/runtime/src/storage/cloud.ts
 function asBytes(data) {
   if (typeof data === "string") return new TextEncoder().encode(data);
-  if (data instanceof ArrayBuffer) return new Uint8Array(data);
-  if (data instanceof Uint8Array) return data;
-  const candidate = data;
-  if (candidate.data instanceof Uint8Array) return candidate.data;
-  throw new StorageError(400, STORAGE_CODES.invalidPath, "\u4E0D\u652F\u6301\u7684\u5B58\u50A8\u6570\u636E\u7C7B\u578B");
+  if (isArrayBufferLike(data)) return new Uint8Array(data);
+  if (isBytes(data)) return toByteView(data);
+  if (isFunctionFile(data)) {
+    if (isBytes(data.data)) return toByteView(data.data);
+    if (isArrayBufferLike(data.data)) return new Uint8Array(data.data);
+    if (typeof data.data === "string") return new TextEncoder().encode(data.data);
+  }
+  throw new StorageError(400, STORAGE_CODES.invalidData, describeUnsupportedUploadData(data));
+}
+function isArrayBufferLike(value) {
+  return Object.prototype.toString.call(value) === "[object ArrayBuffer]";
+}
+function isBytes(value) {
+  return ArrayBuffer.isView(value) && !(Object.prototype.toString.call(value) === "[object DataView]");
+}
+function toByteView(view) {
+  return new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+}
+function isFunctionFile(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  return typeof candidate.name === "string" && "data" in candidate;
+}
+function describeUnsupportedUploadData(data) {
+  const tag = Object.prototype.toString.call(data);
+  const constructorName = typeof data === "object" && data !== null ? data.constructor?.name ?? "unknown" : "none";
+  return `\u4E0D\u652F\u6301\u7684\u5B58\u50A8\u6570\u636E\u7C7B\u578B\uFF08\u80FD\u529B cloud.storage\uFF0C\u65B9\u6CD5 upload\uFF09\uFF1Atypeof=${typeof data}\uFF0CtoString=${tag}\uFF0Cconstructor=${constructorName}\u3002\u652F\u6301\uFF1Astring / Uint8Array / ArrayBuffer / ctx.files\uFF08FunctionFile\uFF09\u3002\u82E5\u6570\u636E\u6765\u81EA\u5BB9\u5668\u6267\u884C\u5668\uFF0C\u8BF7\u786E\u8BA4\u5DF2\u5347\u7EA7\u5230\u5305\u542B RPC typed-array \u7F16\u89E3\u7801\u7684\u8FD0\u884C\u65F6\u955C\u50CF\u3002`;
 }
 function toStoredFile(meta3) {
   return {
@@ -3965,8 +4006,11 @@ var init_sql_split = __esm({
 var db_exports = {};
 __export(db_exports, {
   dbExec: () => dbExec,
+  dbExecBatch: () => dbExecBatch,
   dbMigrate: () => dbMigrate,
   dbRollback: () => dbRollback,
+  dbSchemaDiff: () => dbSchemaDiff,
+  dbSchemaMigrate: () => dbSchemaMigrate,
   dbSnapshotCreate: () => dbSnapshotCreate,
   dbSnapshotList: () => dbSnapshotList,
   dbSnapshotRestore: () => dbSnapshotRestore,
@@ -4062,6 +4106,36 @@ async function dbRollback(paths, options) {
     { method: "POST", body: { to: options.to } }
   );
 }
+async function dbSchemaDiff(paths, options) {
+  const { client, project: project2 } = await open2(paths, options);
+  return client.request(
+    `/api/v1/projects/${project2}/database/schema/diff${envQuery(options)}`,
+    { method: "POST", body: { sql: options.sql } },
+    "SCHEMA_DIFF_FAILED"
+  );
+}
+async function dbSchemaMigrate(paths, options) {
+  const { client, project: project2 } = await open2(paths, options);
+  return client.request(
+    `/api/v1/projects/${project2}/database/schema/migrate${envQuery(options)}`,
+    { method: "POST", body: { sql: options.sql } },
+    "SCHEMA_MIGRATE_FAILED"
+  );
+}
+async function dbExecBatch(paths, options) {
+  const { client, project: project2 } = await open2(paths, options);
+  return client.request(
+    `/api/v1/projects/${project2}/database/console/sql-batch${envQuery(options)}`,
+    {
+      method: "POST",
+      body: {
+        statements: options.statements,
+        ...options.confirmTables === void 0 ? {} : { confirmTables: options.confirmTables }
+      }
+    },
+    "SQL_EXEC_FAILED"
+  );
+}
 async function dbMigrate(paths, options) {
   const queue = [];
   for (const file2 of options.files) {
@@ -4070,35 +4144,101 @@ async function dbMigrate(paths, options) {
     if (statements.length === 0) {
       throw new Error(`\u8FC1\u79FB\u6587\u4EF6\u6CA1\u6709\u53EF\u6267\u884C\u8BED\u53E5\uFF1A${file2}`);
     }
-    for (const statement of statements) queue.push({ file: file2, statement });
+    queue.push({ file: file2, sql: source });
   }
   const { project: project2 } = await open2(paths, options);
   const applied = [];
   const changes = [];
-  for (const { file: file2, statement } of queue) {
+  let createdTables = 0;
+  let addedColumns = 0;
+  let skippedTables = 0;
+  let drift;
+  const mergeDrift = (next) => {
+    if (next === void 0) return;
+    if (drift === void 0) {
+      drift = { ...next };
+      return;
+    }
+    drift = {
+      ...drift,
+      missingTables: [...drift.missingTables, ...next.missingTables],
+      missingColumns: [...drift.missingColumns, ...next.missingColumns],
+      typeMismatches: [...drift.typeMismatches, ...next.typeMismatches],
+      extraTables: [.../* @__PURE__ */ new Set([...drift.extraTables, ...next.extraTables])],
+      extraColumns: [...drift.extraColumns, ...next.extraColumns],
+      destructiveStatements: [...drift.destructiveStatements, ...next.destructiveStatements],
+      applicable: drift.applicable && next.applicable
+    };
+  };
+  if (options.plan === true) {
+    for (const { file: file2, sql } of queue) {
+      try {
+        const next = await dbSchemaDiff(paths, {
+          cwd: options.cwd,
+          sql,
+          ...options.slug === void 0 ? {} : { slug: options.slug },
+          ...options.environment === void 0 ? {} : { environment: options.environment }
+        });
+        mergeDrift(next);
+      } catch (error62) {
+        return {
+          projectId: project2,
+          applied,
+          changes,
+          createdTables,
+          addedColumns,
+          skippedTables,
+          failed: toFailed(file2, error62)
+        };
+      }
+    }
+    return { projectId: project2, applied, changes, createdTables, addedColumns, skippedTables, drift };
+  }
+  for (const { file: file2, sql } of queue) {
     try {
-      const result = await dbExec(paths, {
+      const result = await dbSchemaMigrate(paths, {
         cwd: options.cwd,
+        sql,
         ...options.slug === void 0 ? {} : { slug: options.slug },
-        // 环境必须一路透传：漏掉这一步，`--env dev` 的迁移会**逐条落到生产库**
-        // （每条语句自己按 prod 打），而且前几条已经提交、失败即停也救不回来。
-        ...options.environment === void 0 ? {} : { environment: options.environment },
-        sql: statement
+        // 环境必须一路透传：漏掉这一步，`--env dev` 的迁移会落到生产库。
+        ...options.environment === void 0 ? {} : { environment: options.environment }
       });
-      applied.push(statement);
-      changes.push(result.changes);
+      applied.push(...result.applied);
+      changes.push(...result.applied.map(() => 0));
+      createdTables += result.createdTables;
+      addedColumns += result.addedColumns;
+      skippedTables += result.skippedTables;
+      mergeDrift(result.diff);
     } catch (error62) {
-      const code = error62 instanceof CliError ? error62.code : "MIGRATE_FAILED";
-      const message = error62 instanceof Error ? error62.message : String(error62);
       return {
         projectId: project2,
         applied,
         changes,
-        failed: { file: file2, statement, code, message }
+        createdTables,
+        addedColumns,
+        skippedTables,
+        drift,
+        failed: toFailed(file2, error62)
       };
     }
   }
-  return { projectId: project2, applied, changes };
+  return {
+    projectId: project2,
+    applied,
+    changes,
+    createdTables,
+    addedColumns,
+    skippedTables,
+    drift
+  };
+}
+function toFailed(file2, error62) {
+  return {
+    file: file2,
+    statement: "",
+    code: error62 instanceof CliError ? error62.code : "MIGRATE_FAILED",
+    message: error62 instanceof Error ? error62.message : String(error62)
+  };
 }
 var init_db2 = __esm({
   "packages/cli/src/db.ts"() {
@@ -4320,6 +4460,202 @@ var init_db_mode = __esm({
   }
 });
 
+// packages/runtime/src/shared/fetch-blocked-ports.ts
+function isFetchBlockedPort(port) {
+  if (!Number.isInteger(port)) {
+    throw new TypeError(`[fetch-blocked-ports] \u7AEF\u53E3\u5FC5\u987B\u662F\u6574\u6570\uFF1A\u6536\u5230 ${String(port)}`);
+  }
+  return FETCH_BLOCKED_PORTS.has(port);
+}
+var FETCH_BLOCKED_PORTS;
+var init_fetch_blocked_ports = __esm({
+  "packages/runtime/src/shared/fetch-blocked-ports.ts"() {
+    "use strict";
+    FETCH_BLOCKED_PORTS = /* @__PURE__ */ new Set([
+      1,
+      7,
+      9,
+      11,
+      13,
+      15,
+      17,
+      19,
+      20,
+      21,
+      22,
+      23,
+      25,
+      37,
+      42,
+      43,
+      53,
+      69,
+      77,
+      79,
+      87,
+      95,
+      101,
+      102,
+      103,
+      104,
+      109,
+      110,
+      111,
+      113,
+      115,
+      117,
+      119,
+      123,
+      135,
+      137,
+      139,
+      143,
+      161,
+      179,
+      389,
+      427,
+      465,
+      512,
+      513,
+      514,
+      515,
+      526,
+      530,
+      531,
+      532,
+      540,
+      548,
+      554,
+      556,
+      563,
+      587,
+      601,
+      636,
+      989,
+      990,
+      993,
+      995,
+      1719,
+      1720,
+      1723,
+      2049,
+      3659,
+      4045,
+      4190,
+      5060,
+      5061,
+      6e3,
+      6566,
+      6665,
+      6666,
+      6667,
+      6668,
+      6669,
+      6679,
+      6697,
+      10080
+    ]);
+  }
+});
+
+// packages/cli/src/serve/fetch-safe-port.ts
+function listenOnce(server, port, host) {
+  return new Promise((resolve21, reject) => {
+    const onError = (error62) => {
+      server.off("error", onError);
+      reject(error62);
+    };
+    server.once("error", onError);
+    server.listen(port, host, () => {
+      server.off("error", onError);
+      resolve21();
+    });
+  });
+}
+function closeServer(server) {
+  return new Promise((resolve21, reject) => {
+    server.close((error62) => error62 === void 0 ? resolve21() : reject(error62));
+  });
+}
+async function closeQuietly(server) {
+  try {
+    await closeServer(server);
+  } catch (error62) {
+    if (error62.code !== "ERR_SERVER_NOT_RUNNING") throw error62;
+  }
+}
+function readTcpPort(server, host) {
+  const address = server.address();
+  if (address === null || typeof address === "string") {
+    throw new Error(
+      `[adep] ${host} listen \u6210\u529F\u540E address() \u8FD4\u56DE ${JSON.stringify(address)}\uFF0C\u65E0\u6CD5\u5224\u5B9A\u7AEF\u53E3\uFF1B\u672C\u5730 dev / serve \u5FC5\u987B\u662F Internet \u57DF socket\u3002`
+    );
+  }
+  return address.port;
+}
+function buildExhaustedMessage(input2) {
+  return [
+    `[adep] ${input2.host} \u4E0A\u8FDE\u7EED ${input2.maxAttempts} \u6B21 listen(0) \u90FD\u843D\u5728 undici \u62D2\u7EDD\u8BBF\u95EE\u7684\u7AEF\u53E3\u5185\uFF08\u547D\u4E2D\uFF1A${input2.hits.join(", ")}\uFF09\uFF0C\u6700\u540E\u4E00\u6B21\u5DF2 close\u3002`,
+    "\u8FD9\u4E9B\u7AEF\u53E3\u7684\u8BF7\u6C42\u5728\u5EFA\u7ACB\u8FDE\u63A5\u4E4B\u524D\u5C31\u4F1A\u88AB fetch \u62D2\u7EDD\uFF08TypeError: fetch failed / cause: bad port\uFF09\uFF0C\u6D4F\u89C8\u5668\u5BFC\u822A\u5219\u662F ERR_UNSAFE_PORT\u2014\u2014\u670D\u52A1\u8D77\u6765\u4E86\u4F46\u9875\u9762\u6253\u4E0D\u5F00\u3002",
+    "\u53EF\u80FD\u539F\u56E0\uFF1A\u7CFB\u7EDF\u4E34\u65F6\u7AEF\u53E3\u8D77\u59CB\u503C\u88AB\u8C03\u4F4E\uFF08Windows \u7528 netsh int ipv4 show dynamicport tcp \u6838\u5BF9\uFF0CHyper-V / \u5BB9\u5668\u7F51\u7EDC\u4F1A\u6539\u5B83\uFF09\u3002\u53EF\u7528 --port \u6307\u5B9A\u4E00\u4E2A\u672A\u5360\u7528\u7684\u7AEF\u53E3\u7ED5\u8FC7\u3002"
+  ].join("\n");
+}
+async function listenOnFetchSafePort(server, options) {
+  const isBlocked = options.isBlocked ?? isFetchBlockedPort;
+  const warn = options.warn ?? (() => {
+  });
+  const notifyListenError = async (error62) => {
+    try {
+      await options.onListenError?.(error62);
+    } catch {
+    }
+  };
+  if (options.port !== 0) {
+    try {
+      await listenOnce(server, options.port, options.host);
+    } catch (error62) {
+      await notifyListenError(error62);
+      throw error62;
+    }
+    const actual = readTcpPort(server, options.host);
+    if (isBlocked(actual)) {
+      warn(
+        `[adep] \u7AEF\u53E3 ${actual} \u5728 undici / \u6D4F\u89C8\u5668\u7684\u300C\u4E0D\u5B89\u5168\u7AEF\u53E3\u300D\u540D\u5355\u5185\uFF1A\u670D\u52A1\u53EF\u4EE5\u8D77\u6765\uFF0C\u4F46 fetch \u4F1A\u5728\u5EFA\u7ACB\u8FDE\u63A5\u524D\u62A5 bad port\u3001\u6D4F\u89C8\u5668\u5BFC\u822A\u62A5 ERR_UNSAFE_PORT\u3002\u5EFA\u8BAE\u6362\u4E2A\u7AEF\u53E3\u3002`
+      );
+    }
+    return actual;
+  }
+  const maxAttempts = options.maxAttempts ?? MAX_FETCH_SAFE_LISTEN_ATTEMPTS;
+  const hits = [];
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    try {
+      await listenOnce(server, 0, options.host);
+    } catch (error62) {
+      await notifyListenError(error62);
+      throw error62;
+    }
+    let actual;
+    try {
+      actual = readTcpPort(server, options.host);
+    } catch (error62) {
+      await closeQuietly(server);
+      throw error62;
+    }
+    if (!isBlocked(actual)) return actual;
+    hits.push(actual);
+    await closeQuietly(server);
+  }
+  throw new Error(buildExhaustedMessage({ host: options.host, hits, maxAttempts }));
+}
+var MAX_FETCH_SAFE_LISTEN_ATTEMPTS;
+var init_fetch_safe_port = __esm({
+  "packages/cli/src/serve/fetch-safe-port.ts"() {
+    "use strict";
+    init_fetch_blocked_ports();
+    MAX_FETCH_SAFE_LISTEN_ATTEMPTS = 8;
+  }
+});
+
 // packages/cli/src/sim/env.ts
 import { readFile as readFile6 } from "node:fs/promises";
 import { join as join9 } from "node:path";
@@ -5775,8 +6111,8 @@ function isRpcCapability(value) {
 function createRpcClient(capability, port, pending, nextId) {
   return createFlatRpcProxy((method, args) => {
     const id = nextId();
-    return new Promise((resolve20, reject) => {
-      pending.set(id, { resolve: resolve20, reject });
+    return new Promise((resolve21, reject) => {
+      pending.set(id, { resolve: resolve21, reject });
       port.postMessage({ type: "rpc", id, capability, method, args });
     });
   });
@@ -5789,6 +6125,96 @@ var init_rpc_client = __esm({
   }
 });
 
+// packages/runtime/src/functions/runtime/rpc-codec.ts
+function base64ToBytes(base643) {
+  const binary = atob(base643);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+  return bytes;
+}
+function decodeRpcValue(value) {
+  if (Array.isArray(value)) return value.map((entry) => decodeRpcValue(entry));
+  if (typeof value !== "object" || value === null) return value;
+  const nativeTag = Object.prototype.toString.call(value);
+  if (ArrayBuffer.isView(value) || nativeTag === "[object ArrayBuffer]" || nativeTag === "[object Date]" || nativeTag === "[object Map]" || nativeTag === "[object Set]") {
+    return value;
+  }
+  const candidate = value;
+  const tag = candidate[RPC_VALUE_TAG_KEY];
+  if (typeof tag !== "string") {
+    const output2 = {};
+    for (const [key, entry] of Object.entries(candidate)) output2[key] = decodeRpcValue(entry);
+    return output2;
+  }
+  switch (tag) {
+    case RPC_VALUE_TAGS.typedArray:
+      return base64ToBytes(String(candidate["data"] ?? ""));
+    case RPC_VALUE_TAGS.arrayBuffer: {
+      const bytes = base64ToBytes(String(candidate["data"] ?? ""));
+      return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+    }
+    case RPC_VALUE_TAGS.date:
+      return new Date(String(candidate["data"] ?? ""));
+    case RPC_VALUE_TAGS.map: {
+      const entries = Array.isArray(candidate["data"]) ? candidate["data"] : [];
+      const map2 = /* @__PURE__ */ new Map();
+      for (const entry of entries) {
+        if (!Array.isArray(entry) || entry.length < 2) continue;
+        map2.set(decodeRpcValue(entry[0]), decodeRpcValue(entry[1]));
+      }
+      return map2;
+    }
+    case RPC_VALUE_TAGS.set: {
+      const values = Array.isArray(candidate["data"]) ? candidate["data"] : [];
+      return new Set(values.map((entry) => decodeRpcValue(entry)));
+    }
+    case RPC_VALUE_TAGS.undefined:
+      return void 0;
+    case RPC_VALUE_TAGS.number: {
+      const raw = String(candidate["data"] ?? "");
+      if (raw === "NaN") return Number.NaN;
+      if (raw === "Infinity") return Number.POSITIVE_INFINITY;
+      if (raw === "-Infinity") return Number.NEGATIVE_INFINITY;
+      return Number(raw);
+    }
+    case RPC_VALUE_TAGS.bigint:
+      return BigInt(String(candidate["data"] ?? "0"));
+    case RPC_VALUE_TAGS.object: {
+      const escaped = candidate["data"];
+      if (typeof escaped !== "object" || escaped === null) return {};
+      const output2 = {};
+      for (const [key, entry] of Object.entries(escaped)) {
+        output2[key] = decodeRpcValue(entry);
+      }
+      return output2;
+    }
+    default:
+      return Object.fromEntries(
+        Object.entries(candidate).filter(([key]) => key !== RPC_VALUE_TAG_KEY).map(([key, entry]) => [key, decodeRpcValue(entry)])
+      );
+  }
+}
+var RPC_VALUE_TAG_KEY, RPC_VALUE_TAGS, RPC_VALUE_MAX_BYTES;
+var init_rpc_codec = __esm({
+  "packages/runtime/src/functions/runtime/rpc-codec.ts"() {
+    "use strict";
+    RPC_VALUE_TAG_KEY = "__adepRpcType";
+    RPC_VALUE_TAGS = {
+      typedArray: "Uint8Array",
+      arrayBuffer: "ArrayBuffer",
+      date: "Date",
+      map: "Map",
+      set: "Set",
+      undefined: "undefined",
+      number: "Number",
+      bigint: "BigInt",
+      /** 转义：用户对象自身带 `RPC_VALUE_TAG_KEY` 键时的包装形态。 */
+      object: "Object"
+    };
+    RPC_VALUE_MAX_BYTES = 8 * 1024 * 1024;
+  }
+});
+
 // packages/runtime/src/functions/runtime/rpc-wire.ts
 function wireRpcResponses(port, pending) {
   port.on?.((message) => {
@@ -5797,13 +6223,14 @@ function wireRpcResponses(port, pending) {
     const entry = pending.get(reply.id);
     if (entry === void 0) return;
     pending.delete(reply.id);
-    if (reply.ok === true) entry.resolve(reply.result);
+    if (reply.ok === true) entry.resolve(decodeRpcValue(reply.result));
     else entry.reject(new Error(reply.error ?? "RPC \u80FD\u529B\u8C03\u7528\u5931\u8D25"));
   });
 }
 var init_rpc_wire = __esm({
   "packages/runtime/src/functions/runtime/rpc-wire.ts"() {
     "use strict";
+    init_rpc_codec();
   }
 });
 
@@ -5814,9 +6241,9 @@ function isChainCapability(value) {
   return typeof spec === "object" && spec !== null && Array.isArray(spec.stepMethods) && Array.isArray(spec.terminalMethods);
 }
 function createChainClient(capability, port, pending, nextId, spec) {
-  const call = (method, args) => new Promise((resolve20, reject) => {
+  const call = (method, args) => new Promise((resolve21, reject) => {
     const id = nextId();
-    pending.set(id, { resolve: resolve20, reject });
+    pending.set(id, { resolve: resolve21, reject });
     port.postMessage({ type: "rpc", id, capability, method, args });
   });
   const makeChainable = (rootArgs, steps, txId) => new Proxy(
@@ -6731,18 +7158,12 @@ async function startDevServer(options) {
     } catch {
     }
   };
-  await new Promise((resolveListen, rejectListen) => {
-    const onListenError = (error62) => {
-      void disposeAfterListenError().finally(() => rejectListen(error62));
-    };
-    server.once("error", onListenError);
-    server.listen(port, "127.0.0.1", () => {
-      server.off("error", onListenError);
-      resolveListen();
-    });
+  const actualPort = await listenOnFetchSafePort(server, {
+    port,
+    host: "127.0.0.1",
+    warn: log,
+    onListenError: disposeAfterListenError
   });
-  const address = server.address();
-  const actualPort = typeof address === "object" && address !== null ? address.port : port;
   const baseUrl = `http://127.0.0.1:${actualPort}`;
   const coldStartMs = Date.now() - coldStartAt;
   const curlPath = config2.functionsPrefix.length === 0 ? "/hello" : `/${config2.functionsPrefix}/hello`;
@@ -6782,6 +7203,7 @@ var init_dev = __esm({
     init_worker_executor();
     init_runtime();
     init_db_mode();
+    init_fetch_safe_port();
     init_env();
     init_fetch_config();
     init_invoke();
@@ -7229,6 +7651,7 @@ var init_zip = __esm({
         this.buf = buf;
         this.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
       }
+      buf;
       view;
       u16(offset) {
         return this.view.getUint16(offset, true);
@@ -7946,18 +8369,7 @@ async function startServeServer(options) {
       }
     });
   });
-  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 actualPort = await listenOnFetchSafePort(server, { port, host, warn: log });
   const banner = renderBanner({
     host,
     port: actualPort,
@@ -8015,6 +8427,7 @@ var init_server = __esm({
     init_invoke();
     init_dev();
     init_banner();
+    init_fetch_safe_port();
     init_staleness();
     init_template_params2();
     init_adep_env_inject();
@@ -8059,6 +8472,163 @@ var init_hash = __esm({
   }
 });
 
+// packages/cli/src/publish-checks.ts
+import { posix as posix3 } from "node:path";
+function formatFindings(findings) {
+  const lines = findings.map(
+    (finding) => `${finding.file}:${finding.line} [${finding.rule}] ${finding.severity === "error" ? "\u5371\u9669" : "\u8B66\u544A"}\uFF1A${finding.message}`
+  );
+  return [`\u53D1\u5E03\u524D\u9759\u6001\u6821\u9A8C\u53D1\u73B0 ${findings.length} \u4E2A\u95EE\u9898\uFF1A`, ...lines, "\u4FEE\u590D\u540E\u91CD\u8BD5\uFF1Bwarn \u7EA7\u53EF\u7528 --force \u653E\u884C\uFF0Cerror \u7EA7\u4E0D\u53EF\u653E\u884C\u3002"].join(
+    "\n"
+  );
+}
+function locate(content, index) {
+  const before = content.slice(0, index);
+  const line = before.split("\n").length;
+  const start = before.lastIndexOf("\n") + 1;
+  const end = content.indexOf("\n", index);
+  return { line, text: content.slice(start, end === -1 ? content.length : end) };
+}
+function checkFilePath(functionName, file2) {
+  const normalized = file2.split("\\").join("/");
+  const segments = normalized.split("/");
+  const escapes = normalized.startsWith("/") || segments.some((s) => ESCAPE_KEY_SEGMENTS.has(s));
+  if (!escapes) return [];
+  return [
+    {
+      rule: "PATH_ESCAPE",
+      severity: "error",
+      functionName,
+      file: file2,
+      line: 1,
+      message: `bundle \u952E\u4E0D\u80FD\u662F\u7EDD\u5BF9\u8DEF\u5F84\u6216\u5305\u542B ".."\uFF08\u6536\u5230 "${file2}"\uFF09`
+    }
+  ];
+}
+function checkImportSpecifiers(functionName, file2, content) {
+  const findings = [];
+  for (const matched of content.matchAll(IMPORT_SPECIFIER)) {
+    const specifier = matched[1] ?? "";
+    if (!specifier.startsWith(".")) continue;
+    const resolved = posix3.normalize(posix3.join(posix3.dirname(file2.split("\\").join("/")), specifier));
+    if (!resolved.startsWith("..") && !posix3.isAbsolute(resolved)) continue;
+    const { line } = locate(content, matched.index ?? 0);
+    findings.push({
+      rule: "PATH_ESCAPE",
+      severity: "error",
+      functionName,
+      file: file2,
+      line,
+      message: `import "${specifier}" \u89E3\u6790\u5230 "${resolved}"\uFF0C\u9003\u51FA\u51FD\u6570 bundle \u6839`
+    });
+  }
+  return findings;
+}
+function checkSqlConcat(functionName, file2, content) {
+  const findings = [];
+  for (const matched of content.matchAll(SQL_CALL)) {
+    const arg = matched.groups?.["arg"] ?? "";
+    if (!SQL_KEYWORD.test(arg) || !CONCAT_OR_TEMPLATE.test(arg)) continue;
+    const { line } = locate(content, matched.index ?? 0);
+    findings.push({
+      rule: "SQL_CONCAT",
+      severity: "error",
+      functionName,
+      file: file2,
+      line,
+      message: "SQL \u8BED\u53E5\u542B\u5B57\u7B26\u4E32\u62FC\u63A5 / \u6A21\u677F\u63D2\u503C\uFF1B\u6539\u7528\u53C2\u6570\u5316\u5360\u4F4D\u7B26\uFF08? / $1\uFF09"
+    });
+  }
+  return findings;
+}
+function checkSecrets(functionName, file2, content) {
+  const findings = [];
+  const lines = content.split("\n");
+  lines.forEach((text, index) => {
+    for (const rule of SECRET_RULES) {
+      if (!rule.pattern.test(text)) continue;
+      findings.push({
+        rule: "SECRET_LITERAL",
+        severity: rule.severity,
+        functionName,
+        file: file2,
+        line: index + 1,
+        message: rule.message
+      });
+    }
+  });
+  return findings;
+}
+function collectPrecheckFindings(functions) {
+  const findings = [];
+  for (const [functionName, files] of Object.entries(functions).toSorted(
+    ([a], [b]) => a.localeCompare(b)
+  )) {
+    const sortedFiles = Object.entries(files).toSorted(([a], [b]) => a.localeCompare(b));
+    for (const [file2, content] of sortedFiles) {
+      findings.push(...checkFilePath(functionName, file2));
+      findings.push(...checkImportSpecifiers(functionName, file2, content));
+      findings.push(...checkSqlConcat(functionName, file2, content));
+      findings.push(...checkSecrets(functionName, file2, content));
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return findings.filter((finding) => {
+    const key = `${finding.rule}|${finding.functionName}|${finding.file}|${finding.line}|${finding.message}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  }).toSorted(
+    (a, b) => a.file.localeCompare(b.file) || a.line - b.line || a.rule.localeCompare(b.rule)
+  );
+}
+function assertPrechecks(functions, options = {}) {
+  const findings = collectPrecheckFindings(functions);
+  const errors = findings.filter((finding) => finding.severity === "error");
+  const warnings = findings.filter((finding) => finding.severity === "warn");
+  if (errors.length > 0) throw new PrecheckError(findings);
+  if (warnings.length > 0 && options.force !== true) throw new PrecheckError(warnings);
+  return warnings;
+}
+var PrecheckError, ESCAPE_KEY_SEGMENTS, IMPORT_SPECIFIER, SQL_CALL, SQL_KEYWORD, CONCAT_OR_TEMPLATE, SECRET_RULES;
+var init_publish_checks = __esm({
+  "packages/cli/src/publish-checks.ts"() {
+    "use strict";
+    init_auth();
+    PrecheckError = class extends CliError {
+      findings;
+      constructor(findings) {
+        super("PRECHECK_FAILED", formatFindings(findings));
+        this.name = "PrecheckError";
+        this.findings = findings;
+      }
+    };
+    ESCAPE_KEY_SEGMENTS = /* @__PURE__ */ new Set([".."]);
+    IMPORT_SPECIFIER = /(?:from\s*|import\s*|require\s*\(\s*)['"]([^'"]+)['"]/g;
+    SQL_CALL = /\.(?:query|execute|run|all|get|prepare)\s*\(\s*(?<arg>[^\n]*)/g;
+    SQL_KEYWORD = /\b(?:SELECT|INSERT|UPDATE|DELETE|REPLACE|WITH|WHERE|FROM)\b/i;
+    CONCAT_OR_TEMPLATE = /(?:\$\{|`\s*\+|\+\s*['"`]|['"`]\s*\+)/;
+    SECRET_RULES = [
+      {
+        pattern: /-----BEGIN (?:RSA |EC |OPENSSH |DSA )?PRIVATE KEY-----/,
+        message: "\u6E90\u7801\u542B PEM \u79C1\u94A5\u660E\u6587",
+        severity: "error"
+      },
+      { pattern: /AKIA[0-9A-Z]{16}/, message: "\u6E90\u7801\u542B AWS Access Key \u660E\u6587", severity: "error" },
+      {
+        pattern: /(?:sk|pk)_(?:live|test)_[0-9A-Za-z]{16,}/,
+        message: "\u6E90\u7801\u542B\u652F\u4ED8\u6E20\u9053\u5BC6\u94A5\u660E\u6587",
+        severity: "error"
+      },
+      {
+        pattern: /(?:password|passwd|secret|api[_-]?key|access[_-]?token)\s*[:=]\s*['"][^'"]{8,}['"]/i,
+        message: "\u7591\u4F3C\u5BC6\u94A5 / \u53E3\u4EE4\u786C\u7F16\u7801\uFF1B\u6539\u4ECE ctx.env / \u5E73\u53F0\u73AF\u5883\u53D8\u91CF\u8BFB\u53D6",
+        severity: "warn"
+      }
+    ];
+  }
+});
+
 // packages/cli/src/deploy.ts
 var deploy_exports = {};
 __export(deploy_exports, {
@@ -8164,6 +8734,10 @@ async function deploy(paths, options) {
   }
   const shared = await collectShared(functionsDir);
   const filesFor = (name) => local[name] ?? {};
+  const precheckWarnings = assertPrechecks(local, { force: options.force === true });
+  for (const finding of precheckWarnings) {
+    log(`[adep] \u6821\u9A8C\u8B66\u544A ${finding.file}:${finding.line} [${finding.rule}] ${finding.message}`);
+  }
   const sharedRows = Object.entries(shared).map(([path, content]) => ({ path, content }));
   const hashFiles = (name) => {
     const filesAsRuntimeSees = mergeSharedSource(filesFor(name), sharedRows);
@@ -8264,6 +8838,7 @@ var init_deploy = __esm({
     init_hash();
     init_dev();
     init_net();
+    init_publish_checks();
     init_shared_source();
     init_shared_source();
     AmbiguousFunctionError = class extends CliError {
@@ -8275,6 +8850,7 @@ var init_deploy = __esm({
         this.names = names;
         this.name = "AmbiguousFunctionError";
       }
+      names;
     };
     IGNORED_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git"]);
   }
@@ -8743,11 +9319,11 @@ var fs_exports = {};
 __export(fs_exports, {
   createExportFileSystem: () => createExportFileSystem
 });
-import { mkdir as mkdir16, readFile as readFile27, rm as rm5, stat as stat17, writeFile as writeFile16 } from "node:fs/promises";
+import { mkdir as mkdir16, readFile as readFile28, rm as rm5, stat as stat17, writeFile as writeFile16 } from "node:fs/promises";
 import { dirname as dirname14, join as join36 } from "node:path";
 function createExportFileSystem() {
   return {
-    readFile: (path) => readFile27(path),
+    readFile: (path) => readFile28(path),
     writeFile: (path, content) => writeFile16(path, content),
     // 同时用于清理解压临时目录（${zip}.tmp 是个目录）——递归强制删除，缺失不报错。
     deleteFile: async (path) => {
@@ -8765,7 +9341,7 @@ function createExportFileSystem() {
       await mkdir16(path, { recursive: true });
     },
     unzip: async (zipPath, targetDir) => {
-      const entries = zipRead(await readFile27(zipPath));
+      const entries = zipRead(await readFile28(zipPath));
       for (const [name, data] of entries) {
         const dest = join36(targetDir, name);
         await mkdir16(dirname14(dest), { recursive: true });
@@ -8799,6 +9375,10 @@ var init_command = __esm({
         this.pollInterval = pollInterval;
         this.maxPollAttempts = maxPollAttempts;
       }
+      apiClient;
+      fs;
+      pollInterval;
+      maxPollAttempts;
       /**
        * 执行导出命令。
        *
@@ -9006,14 +9586,14 @@ ${detail}`);
        * @param ms 毫秒数
        */
       sleep(ms) {
-        return new Promise((resolve20) => setTimeout(resolve20, ms));
+        return new Promise((resolve21) => setTimeout(resolve21, ms));
       }
     };
   }
 });
 
 // packages/cli/src/sandbox-scan.ts
-import { readdir as readdir13, readFile as readFile28 } from "node:fs/promises";
+import { readdir as readdir13, readFile as readFile30 } from "node:fs/promises";
 import { join as join37, relative as relative9, sep as sep5 } from "node:path";
 function extractSpecifiers(line) {
   const out = [];
@@ -9079,7 +9659,7 @@ async function scanFunctionSources(rootDir, functionsDir) {
       if (entry.name.endsWith(".d.ts")) continue;
       let content;
       try {
-        content = await readFile28(abs, "utf8");
+        content = await readFile30(abs, "utf8");
       } catch {
         continue;
       }
@@ -9353,7 +9933,7 @@ __export(mcp_exports, {
   mcpPublish: () => mcpPublish,
   mcpUnpublish: () => mcpUnpublish
 });
-import { resolve as resolve18 } from "node:path";
+import { resolve as resolve19 } from "node:path";
 async function mcpPublish(paths, options) {
   const fn = requireFunctionName(options.fn);
   const client = await createClient(paths);
@@ -9434,7 +10014,7 @@ function requireFunctionName(fn) {
   return fn.trim();
 }
 async function resolveProject(client, options) {
-  const slug = await resolveSlug(resolve18(options.cwd), options.slug);
+  const slug = await resolveSlug(resolve19(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) {
@@ -9619,9 +10199,11 @@ var init_git = __esm({
 var functions_exports = {};
 __export(functions_exports, {
   functionsList: () => functionsList,
-  functionsLogs: () => functionsLogs
+  functionsLogs: () => functionsLogs,
+  logsByTrace: () => logsByTrace,
+  resolveProject: () => resolveProject2
 });
-import { resolve as resolve19 } from "node:path";
+import { resolve as resolve20 } from "node:path";
 async function functionsList(paths, options) {
   const client = await createClient(paths);
   const project2 = await resolveProject2(client, options);
@@ -9662,8 +10244,24 @@ async function functionsLogs(paths, options) {
   );
   return { functionId: target.id, name: target.name, logs: result.logs };
 }
+async function logsByTrace(paths, options) {
+  const trace = options.trace.trim();
+  if (trace.length === 0) {
+    throw new CliError("INVALID_ARGUMENT", "\u7F3A\u5C11 traceId\uFF1Aadep logs --trace <traceId>");
+  }
+  const client = await createClient(paths);
+  const project2 = await resolveProject2(client, options);
+  const params = new URLSearchParams({ trace });
+  if (options.tail !== void 0) params.set("tail", String(options.tail));
+  const result = await client.request(
+    `/api/v1/projects/${project2.id}/logs?${params.toString()}`,
+    {},
+    "FUNCTION_LOGS_FAILED"
+  );
+  return { projectId: project2.id, slug: project2.slug, traceId: result.traceId, logs: result.logs };
+}
 async function resolveProject2(client, options) {
-  const slug = await resolveSlug(resolve19(options.cwd), options.slug);
+  const slug = await resolveSlug(resolve20(options.cwd), options.slug);
   const projects = await projectsListFrom(client);
   const match = projects.find((project2) => project2.slug === slug);
   if (match === void 0) {
@@ -9686,6 +10284,65 @@ var init_functions = __esm({
   }
 });
 
+// packages/cli/src/rollback.ts
+var rollback_exports = {};
+__export(rollback_exports, {
+  parseVersionFlag: () => parseVersionFlag,
+  rollbackFunctionTo: () => rollbackFunctionTo
+});
+function parseVersionFlag(raw) {
+  const text = (raw ?? "").trim();
+  const matched = /^v?(\d+)$/.exec(text);
+  const version2 = matched === null ? Number.NaN : Number(matched[1]);
+  if (!Number.isInteger(version2) || version2 <= 0) {
+    throw new CliError("INVALID_ARGUMENT", `--to \u987B\u4E3A\u7248\u672C\u53F7\uFF08\u5982 v2 \u6216 2\uFF09\uFF0C\u6536\u5230 "${raw ?? ""}"`);
+  }
+  return version2;
+}
+async function rollbackFunctionTo(paths, options) {
+  if (!Number.isInteger(options.to) || options.to <= 0) {
+    throw new CliError("INVALID_ARGUMENT", `--to \u987B\u4E3A\u6B63\u6574\u6570\uFF0C\u6536\u5230 ${options.to}`);
+  }
+  const client = await createClient(paths);
+  const project2 = await resolveProject2(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 versions = await client.request(`/api/v1/functions/${target.id}/versions`, {}, "FUNCTION_VERSIONS_FAILED");
+  if (!versions.versions.some((version2) => version2.version === options.to)) {
+    const available = versions.versions.map((version2) => `v${version2.version}`).join(", ");
+    throw new CliError(
+      "VERSION_NOT_FOUND",
+      `\u7248\u672C v${options.to} \u4E0D\u5728\u4FDD\u7559\u7A97\u53E3\u5185\uFF08\u5F53\u524D v${versions.current ?? "\u2014"}\uFF1B\u53EF\u7528\uFF1A${available === "" ? "\u65E0" : available}\uFF09`
+    );
+  }
+  const result = await client.request(
+    `/api/v1/functions/${target.id}/rollback`,
+    { method: "POST", body: { version: options.to } },
+    "ROLLBACK_FAILED"
+  );
+  return {
+    functionId: target.id,
+    name: target.name,
+    from: versions.current,
+    to: result.version
+  };
+}
+var init_rollback = __esm({
+  "packages/cli/src/rollback.ts"() {
+    "use strict";
+    init_auth();
+    init_client();
+    init_functions();
+  }
+});
+
 // packages/cli/src/cli.ts
 init_config();
 import { Command } from "commander";
@@ -13019,6 +13676,7 @@ var TemplateRenderError = class extends Error {
     this.code = code;
     this.name = "TemplateRenderError";
   }
+  code;
 };
 var PLACEHOLDER_PATTERN = /\{\{\s*([A-Za-z0-9_-]+)\s*\}\}/g;
 function declaredVariables(manifest) {
@@ -13141,6 +13799,7 @@ var InitError = class extends Error {
     this.code = code;
     this.name = "InitError";
   }
+  code;
 };
 async function initProject(cwd, name, template, filesOverride) {
   if (!/^[a-z][a-z0-9-]{0,62}$/.test(name)) {
@@ -18920,7 +19579,7 @@ var recursive = /* @__PURE__ */ new WeakMap();
 var NONE = 0;
 var ASSUMED = 1;
 var PROVEN = 2;
-function isRecursive(inst, stack, resolve20) {
+function isRecursive(inst, stack, resolve21) {
   const cached2 = recursive.get(inst);
   if (cached2 !== void 0)
     return cached2 ? PROVEN : NONE;
@@ -18930,7 +19589,7 @@ function isRecursive(inst, stack, resolve20) {
   let result = NONE;
   const check2 = (child) => {
     if (result !== PROVEN && child?._zod) {
-      const answer = isRecursive(child, stack, resolve20);
+      const answer = isRecursive(child, stack, resolve21);
       if (answer > result)
         result = answer;
     }
@@ -18941,7 +19600,7 @@ function isRecursive(inst, stack, resolve20) {
       const desc = Object.getOwnPropertyDescriptor(sh, key);
       if (spread && !desc.enumerable)
         continue;
-      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve20) : NONE;
+      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve21) : NONE;
       if (child > answer)
         answer = child;
     }
@@ -19005,7 +19664,7 @@ function isRecursive(inst, stack, resolve20) {
       break;
     // `$ZodLazy` caches its inner on the def, so a resolved edge is followed exactly
     case "lazy": {
-      const inner = def._cachedInner ?? (resolve20 ? inst._zod.innerType : void 0);
+      const inner = def._cachedInner ?? (resolve21 ? inst._zod.innerType : void 0);
       merge2(inner ? isRecursive(inner, stack, false) : ASSUMED);
       break;
     }
@@ -26796,8 +27455,8 @@ function registry() {
 var globalRegistry = globalThis.__zod_globalRegistry;
 
 // node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/compile.js
-var INVALID = Symbol.for("zod.compile.invalid");
-var FALLBACK_FLAG = Symbol.for("zod.compile.fallback");
+var INVALID = /* @__PURE__ */ Symbol.for("zod.compile.invalid");
+var FALLBACK_FLAG = /* @__PURE__ */ Symbol.for("zod.compile.fallback");
 var ZodCompileAsyncError = class extends Error {
   constructor(message = "z.compile does not support async refinements, transforms, or checks") {
     super(message);
@@ -30585,7 +31244,7 @@ var nonoptionalProcessor = (schema, ctx, _json, params) => {
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
-var UNREPRESENTABLE_DEFAULT = Symbol();
+var UNREPRESENTABLE_DEFAULT = /* @__PURE__ */ Symbol();
 function serializeDefaultValue(value, schema, ctx, json2, params) {
   let unrepresentable = false;
   const serialized = JSON.stringify(value, (_, val) => {
@@ -33349,7 +34008,7 @@ function fromJSONSchema(schema, params) {
 }
 
 // node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/visit.js
-var RESOLVING = Symbol("z.visit/resolving");
+var RESOLVING = /* @__PURE__ */ Symbol("z.visit/resolving");
 function visit(schema, fnOrHandlers) {
   const fn = typeof fnOrHandlers === "function" ? fnOrHandlers : (node2, rewritten) => {
     const h = fnOrHandlers[node2._zod.def.type];
@@ -35574,6 +36233,9 @@ var SyncTransportError = class extends Error {
     this.failedSeq = failedSeq;
     this.name = "SyncTransportError";
   }
+  code;
+  status;
+  failedSeq;
 };
 function isBindable(value) {
   return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null;
@@ -37071,7 +37733,7 @@ function registerDevServers(program2, ctx) {
 init_auth();
 init_client();
 init_deploy();
-import { stat as stat16 } from "node:fs/promises";
+import { readFile as readFile26, stat as stat16 } from "node:fs/promises";
 import { join as join34, resolve as resolve16 } from "node:path";
 async function resolveProjectId2(client, cwd, slug) {
   const resolvedSlug = await resolveSlug(resolve16(cwd), slug);
@@ -37154,6 +37816,58 @@ async function publishFunctions(paths, options) {
   const deployedCount = result.functions.filter((fn) => fn.action !== "none").length;
   return { ...result, elapsedSeconds, deployedCount };
 }
+async function checkSchemaDrift(paths, options) {
+  const schemaFile = join34(options.cwd, "database", "schema.sql");
+  const schemaStat = await stat16(schemaFile).catch(() => null);
+  if (schemaStat === null || !schemaStat.isFile()) {
+    options.log("[adep] \u672A\u627E\u5230 database/schema.sql\uFF0C\u8DF3\u8FC7 schema \u6F02\u79FB\u68C0\u67E5");
+    return null;
+  }
+  const sql = await readFile26(schemaFile, "utf8");
+  const { dbSchemaDiff: dbSchemaDiff2 } = await Promise.resolve().then(() => (init_db2(), db_exports));
+  let drift;
+  try {
+    drift = await dbSchemaDiff2(paths, {
+      cwd: options.cwd,
+      sql,
+      ...options.slug === void 0 ? {} : { slug: options.slug },
+      log: options.log
+    });
+  } catch (error62) {
+    if (error62 instanceof CliError && (error62.code === "DB_NOT_PROVISIONED" || error62.code === "DB_NOT_FOUND")) {
+      options.log("[adep] \u6570\u636E\u5E93\u5C1A\u672A\u542F\u52A8\uFF0C\u8DF3\u8FC7 schema \u6F02\u79FB\u68C0\u67E5\uFF08\u5148 adep db start \u540E\u53D1\u5E03\u53EF\u542F\u7528\uFF09");
+      return null;
+    }
+    throw error62;
+  }
+  const blocking = drift.missingTables.length > 0 || drift.missingColumns.length > 0 || drift.typeMismatches.length > 0;
+  if (drift.destructiveStatements.length > 0) {
+    options.log(
+      `[adep] \u26A0 schema.sql \u542B\u7834\u574F\u6027\u8BED\u53E5\uFF08\u4E0D\u4F1A\u88AB\u81EA\u52A8\u6267\u884C\uFF09\uFF1A${drift.destructiveStatements.join(" \xB7 ")}`
+    );
+  }
+  if (!blocking) {
+    options.log("[adep] \u2713 schema \u65E0\u6F02\u79FB");
+    return drift;
+  }
+  if (options.allowDrift === true) {
+    options.log("[adep] \u26A0 schema \u6F02\u79FB\u88AB --allow-drift \u653E\u884C\uFF1A\u7EBF\u4E0A\u51FD\u6570\u53EF\u80FD no such column");
+    return drift;
+  }
+  const lines = ["\u68C0\u6D4B\u5230 schema \u6F02\u79FB\uFF0C\u53D1\u5E03\u5DF2\u963B\u65AD\uFF08\u4E91\u51FD\u6570\u4F1A\u76F4\u63A5 no such column\uFF09\uFF1A"];
+  for (const item of drift.missingTables) lines.push(`  +table  ${item.table}`);
+  for (const item of drift.missingColumns) {
+    lines.push(`  +column ${item.table}.${item.column.name}`);
+  }
+  for (const item of drift.typeMismatches) {
+    lines.push(`  !type   ${item.table}.${item.column}\uFF08\u671F\u671B ${item.expected}\uFF0C\u7EBF\u4E0A ${item.actual}\uFF09`);
+  }
+  lines.push("\u4E0B\u4E00\u6B65\uFF1Aadep db migrate database/schema.sql");
+  lines.push("  \u67E5\u770B\u8BA1\u5212\uFF1Aadep db migrate database/schema.sql --plan");
+  lines.push("  \u5168\u5E93\u6F02\u79FB\u62A5\u544A\uFF1Aadep db doctor");
+  lines.push("\u786E\u8BA4\u53EF\u5BB9\u5FCD\u6F02\u79FB\u65F6\u7528 adep publish --allow-drift \u653E\u884C\uFF08\u4E0D\u63A8\u8350\uFF1A\u4E0A\u7EBF\u5373 500\uFF09");
+  throw new CliError("SCHEMA_DRIFT_DETECTED", lines.join("\n"));
+}
 async function runPublish(paths, io, cwd, flags) {
   const scope = flags.only === void 0 ? "fullstack" : flags.only;
   if (flags.only !== void 0 && flags.only !== "functions" && flags.only !== "frontend") {
@@ -37164,6 +37878,12 @@ async function runPublish(paths, io, cwd, flags) {
   const environment = flags.environment;
   const result = { scope };
   if (wantFunctions) {
+    await checkSchemaDrift(paths, {
+      cwd,
+      ...flags.project === void 0 ? {} : { slug: flags.project },
+      log: io.json ? () => void 0 : (line) => io.line(line),
+      ...flags.allowDrift === void 0 ? {} : { allowDrift: flags.allowDrift }
+    });
     result.functions = await publishFunctions(paths, {
       cwd,
       ...flags.project === void 0 ? {} : { slug: flags.project },
@@ -37257,6 +37977,9 @@ function registerPublish(program2, ctx) {
   ).option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09").option(
     "--force",
     "\u653E\u884C warn \u7EA7\u5BC6\u94A5\u5F15\u7528\u547D\u4E2D\uFF08FN-013\uFF1B\u6E90\u7801\u5F15\u7528\u4E86\u5DF2\u914D\u7F6E\u7684 secret \u73AF\u5883\u53D8\u91CF\u540D\u65F6\u53D1\u5E03\u88AB\u963B\u65AD\uFF0C\u786E\u8BA4\u975E\u6CC4\u6F0F\u540E\u7528\u672C\u65D7\u6807\u653E\u884C\uFF0C\u670D\u52A1\u7AEF\u843D\u5BA1\u8BA1\uFF09"
+  ).option(
+    "--allow-drift",
+    "\u653E\u884C schema \u6F02\u79FB\uFF08\u7F3A\u8868/\u7F3A\u5217/\u7C7B\u578B\u4E0D\u4E00\u81F4\u65F6\u53D1\u5E03\u9ED8\u8BA4\u88AB\u963B\u65AD\uFF0C\u786E\u8BA4\u53EF\u5BB9\u5FCD\u540E\u4F7F\u7528\uFF1B\u4E0D\u63A8\u8350\uFF0C\u7EBF\u4E0A\u51FD\u6570\u4F1A no such column\uFF09"
   ).action(async (flags) => {
     const command = ctx.io("publish");
     await command.run(async () => {
@@ -37281,7 +38004,7 @@ init_auth();
 // packages/cli/src/deploy-worker.ts
 init_auth();
 init_client();
-import { readdir as readdir12, readFile as readFile26 } from "node:fs/promises";
+import { readdir as readdir12, readFile as readFile27 } from "node:fs/promises";
 import { join as join35, relative as relative8, resolve as resolve17, sep as sep4 } from "node:path";
 async function collectWranglerFiles(dir) {
   const root = resolve17(dir);
@@ -37303,7 +38026,7 @@ async function collectWranglerFiles(dir) {
       if (entry.isDirectory()) {
         await walk(full);
       } else if (entry.isFile()) {
-        const buf = await readFile26(full).catch(() => null);
+        const buf = await readFile27(full).catch(() => null);
         if (buf === null) continue;
         if (buf.includes(0)) continue;
         out[relative8(root, full).split(sep4).join("/")] = buf.toString("utf8");
@@ -37502,6 +38225,35 @@ function registerExport(program2, ctx) {
 }
 
 // packages/cli/src/commands/db.ts
+import { readFile as readFile29 } from "node:fs/promises";
+import { resolve as resolve18 } from "node:path";
+init_db2();
+function renderDrift(diff) {
+  const lines = [];
+  for (const table of diff.missingTables) lines.push(`+table  ${table.table}`);
+  for (const column of diff.missingColumns) {
+    lines.push(
+      `+column ${column.table}.${column.column.name} ${column.column.type}` + (column.blocked === null ? `  \u2192 ${column.sql}` : `  [\u62D2\u7EDD\u81EA\u52A8\u6267\u884C] ${column.blocked}`)
+    );
+  }
+  for (const mismatch of diff.typeMismatches) {
+    lines.push(
+      `!type   ${mismatch.table}.${mismatch.column}  \u7EBF\u4E0A ${mismatch.actual || "(\u65E0\u7C7B\u578B)"} \u2192 schema ${mismatch.expected}`
+    );
+  }
+  for (const table of diff.extraTables) lines.push(`-table  ${table}\uFF08\u7EBF\u4E0A\u6709\u3001schema \u672A\u58F0\u660E\uFF1B\u4E0D\u4F1A\u81EA\u52A8\u5220\u9664\uFF09`);
+  for (const column of diff.extraColumns) {
+    lines.push(`-column ${column.table}.${column.column}\uFF08\u7EBF\u4E0A\u6709\u3001schema \u672A\u58F0\u660E\uFF1B\u4E0D\u4F1A\u81EA\u52A8\u5220\u9664\uFF09`);
+  }
+  for (const statement of diff.destructiveStatements) {
+    lines.push(`!ddl    ${statement.replace(/\s+/g, " ").slice(0, 120)}`);
+  }
+  if (lines.length === 0) return ["\u2713 schema \u4E0E\u7EBF\u4E0A\u4E00\u81F4\uFF0C\u65E0\u6F02\u79FB"];
+  if (!diff.applicable) {
+    lines.push("", "\u5B58\u5728\u7834\u574F\u6027 / \u4E0D\u53EF\u81EA\u52A8\u6267\u884C\u7684\u53D8\u66F4\uFF1A\u5DF2\u62D2\u7EDD\u81EA\u52A8\u5E94\u7528\uFF0C\u8BF7\u5907\u4EFD\u540E\u624B\u5DE5\u5904\u7406\u3002");
+  }
+  return lines;
+}
 function registerDb(program2, ctx) {
   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");
   db.command("start").description("\u542F\u52A8\u9879\u76EE\u6570\u636E\u5E93\uFF08\u5DF2\u5B58\u5728\u5219\u91CD\u65B0\u6FC0\u6D3B\uFF0C\u4E0D\u91CD\u5EFA\u6570\u636E\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) => {
@@ -37544,33 +38296,66 @@ function registerDb(program2, ctx) {
     });
   });
   db.command("exec").description(
-    "\u6267\u884C\u5355\u6761 SQL\uFF08\u5199 / \u7834\u574F\u6027\u8BED\u53E5\u9700 --confirm-table \u4E8C\u6B21\u786E\u8BA4\uFF09\u3002\u53D7\u5168\u5C40 --env \u5F71\u54CD\uFF1Adev \u6253\u5F00\u53D1\u5E93\u3001prod \u6253\u751F\u4EA7\u5E93"
-  ).option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09").requiredOption("--sql <sql>", "\u5F85\u6267\u884C SQL").option("--confirm-table <table>", "\u7834\u574F\u6027\u64CD\u4F5C\u7684\u76EE\u6807\u8868\u540D\uFF08\u4E8C\u6B21\u786E\u8BA4\uFF09").action(async (flags) => {
+    "\u6267\u884C\u5355\u6761 SQL \u6216\u6279\u91CF SQL \u6587\u4EF6\uFF08\u5355\u4E8B\u52A1\uFF1B\u5199 / \u7834\u574F\u6027\u8BED\u53E5\u9700 --confirm-table \u4E8C\u6B21\u786E\u8BA4\uFF09\u3002\u53D7\u5168\u5C40 --env \u5F71\u54CD\uFF1Adev \u6253\u5F00\u53D1\u5E93\u3001prod \u6253\u751F\u4EA7\u5E93"
+  ).option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09").option("--sql <sql>", "\u5F85\u6267\u884C SQL\uFF08\u5355\u6761\uFF09").option("--file <path>", "\u6279\u91CF SQL \u6587\u4EF6\uFF08\u5355\u4E8B\u52A1\uFF0C\u4EFB\u4E00\u6761\u5931\u8D25\u6574\u4F53\u56DE\u6EDA\uFF09").option("--confirm-table <table>", "\u7834\u574F\u6027\u64CD\u4F5C\u7684\u76EE\u6807\u8868\u540D\uFF08\u4E8C\u6B21\u786E\u8BA4\uFF09").action(async (flags) => {
     const command = ctx.io("db exec");
     await command.run(async () => {
+      if (flags.sql !== void 0 && flags.file !== void 0) {
+        command.fail("INVALID_ARGS", "--sql \u4E0E --file \u53EA\u80FD\u4E8C\u9009\u4E00");
+        return;
+      }
+      if (flags.sql === void 0 && flags.file === void 0) {
+        command.fail("INVALID_ARGS", "\u9700\u8981 --sql <sql> \u6216 --file <path>");
+        return;
+      }
       const { environment, source } = await ctx.env();
-      const { dbExec: dbExec2 } = await Promise.resolve().then(() => (init_db2(), db_exports));
-      const result = await dbExec2(ctx.paths, {
-        cwd: ctx.cwd,
-        sql: flags.sql,
-        environment,
-        ...flags.project === void 0 ? {} : { slug: flags.project },
-        ...flags.confirmTable === void 0 ? {} : { confirmTable: flags.confirmTable }
-      });
-      command.ok(result, (data) => {
-        const r = data;
-        const lines = [];
-        if (r.columns.length > 0) {
-          lines.push(formatTable(r.columns, r.rows));
-          if (r.truncated) lines.push(`\uFF08\u7ED3\u679C\u5DF2\u622A\u65AD\u5230 ${r.rows.length} \u884C\uFF09`);
-        } else if (r.changes > 0) {
-          lines.push(`${r.changes} \u884C\u53D7\u5F71\u54CD`);
-        } else {
-          lines.push("\u8BED\u53E5\u6267\u884C\u6210\u529F\uFF08\u65E0\u8FD4\u56DE\u884C\uFF09");
+      if (flags.file !== void 0) {
+        const { dbExecBatch: dbExecBatch2 } = await Promise.resolve().then(() => (init_db2(), db_exports));
+        const sql = await readFile29(resolve18(flags.file), "utf8");
+        const statements = splitSqlStatements(sql);
+        if (statements.length === 0) {
+          command.fail("EMPTY_FILE", `SQL \u6587\u4EF6\u6CA1\u6709\u53EF\u6267\u884C\u8BED\u53E5\uFF1A${flags.file}`);
+          return;
         }
-        lines.push(`\u8017\u65F6 ${r.elapsedMs}ms`);
-        return lines;
-      });
+        const result = await dbExecBatch2(ctx.paths, {
+          cwd: ctx.cwd,
+          statements,
+          environment,
+          ...flags.project === void 0 ? {} : { slug: flags.project },
+          ...flags.confirmTable === void 0 ? {} : { confirmTables: statements.map(() => flags.confirmTable) }
+        });
+        command.ok(result, (data) => {
+          const results = data.results;
+          const total = results.reduce((sum, entry) => sum + entry.changes, 0);
+          return [
+            `\u2713 ${results.length} \u6761\u8BED\u53E5\u5DF2\u5728\u4E00\u4E2A\u4E8B\u52A1\u5185\u63D0\u4EA4`,
+            `${total} \u884C\u53D7\u5F71\u54CD`
+          ];
+        });
+      } else {
+        const { dbExec: dbExec2 } = await Promise.resolve().then(() => (init_db2(), db_exports));
+        const result = await dbExec2(ctx.paths, {
+          cwd: ctx.cwd,
+          sql: flags.sql,
+          environment,
+          ...flags.project === void 0 ? {} : { slug: flags.project },
+          ...flags.confirmTable === void 0 ? {} : { confirmTable: flags.confirmTable }
+        });
+        command.ok(result, (data) => {
+          const r = data;
+          const lines = [];
+          if (r.columns.length > 0) {
+            lines.push(formatTable(r.columns, r.rows));
+            if (r.truncated) lines.push(`\uFF08\u7ED3\u679C\u5DF2\u622A\u65AD\u5230 ${r.rows.length} \u884C\uFF09`);
+          } else if (r.changes > 0) {
+            lines.push(`${r.changes} \u884C\u53D7\u5F71\u54CD`);
+          } else {
+            lines.push("\u8BED\u53E5\u6267\u884C\u6210\u529F\uFF08\u65E0\u8FD4\u56DE\u884C\uFF09");
+          }
+          lines.push(`\u8017\u65F6 ${r.elapsedMs}ms`);
+          return lines;
+        });
+      }
       command.line(
         `\u73AF\u5883\uFF1A${environment}\uFF08${describeEnvironmentSource(source)}\uFF09\u2014\u2014 \u6253\u7684\u662F${environment === "dev" ? "\u5F00\u53D1\u5E93" : "\u751F\u4EA7\u5E93"}`
       );
@@ -37615,8 +38400,8 @@ function registerDb(program2, ctx) {
     });
   });
   db.command("migrate").description(
-    "\u6267\u884C SQL \u8FC1\u79FB\u6587\u4EF6\uFF08\u53EF\u591A\u4E2A\uFF0C\u6309\u58F0\u660E\u987A\u5E8F\u6267\u884C\u2014\u2014a.sql \u5EFA\u8868\u3001b.sql \u63D2\u6570\u636E\u7684\u4F9D\u8D56\u987A\u5E8F\u5C31\u662F\u58F0\u660E\u987A\u5E8F\uFF1B\u5931\u8D25\u5373\u505C\u5E76\u6307\u5411\u5931\u8D25\u6587\u4EF6\uFF09"
-  ).argument("<files...>", "\u8FC1\u79FB SQL \u6587\u4EF6\u8DEF\u5F84\uFF08\u76F8\u5BF9\u5F53\u524D\u76EE\u5F55\u6216\u7EDD\u5BF9\u8DEF\u5F84\uFF0C\u6309\u58F0\u660E\u987A\u5E8F\u6267\u884C\uFF09").option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09").action(async (files, flags) => {
+    "\u6267\u884C SQL \u8FC1\u79FB\u6587\u4EF6\uFF08\u589E\u91CF\u8BED\u4E49\uFF09\uFF1A\u7F3A\u8868\u5EFA\u8868\u3001\u65E2\u6709\u8868\u7F3A\u5217\u81EA\u52A8 ADD COLUMN\uFF1B\u5220\u5217/\u6539\u7C7B\u578B/\u91CD\u547D\u540D\u62D2\u7EDD\u81EA\u52A8\u6267\u884C\u3002\u53EF\u591A\u4E2A\u6587\u4EF6\uFF0C\u6309\u58F0\u660E\u987A\u5E8F\u6267\u884C\uFF0C\u5931\u8D25\u5373\u505C"
+  ).argument("<files...>", "\u8FC1\u79FB SQL \u6587\u4EF6\u8DEF\u5F84\uFF08\u76F8\u5BF9\u5F53\u524D\u76EE\u5F55\u6216\u7EDD\u5BF9\u8DEF\u5F84\uFF0C\u6309\u58F0\u660E\u987A\u5E8F\u6267\u884C\uFF09").option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09").option("--plan", "\u53EA\u8F93\u51FA\u6F02\u79FB\u8BA1\u5212\uFF08+table / +column / !type\uFF09\uFF0C\u4E0D\u6267\u884C\u4EFB\u4F55\u8BED\u53E5").action(async (files, flags) => {
     const command = ctx.io("db migrate");
     await command.run(async () => {
       const { environment, source } = await ctx.env();
@@ -37625,21 +38410,64 @@ function registerDb(program2, ctx) {
         cwd: ctx.cwd,
         files,
         environment,
-        ...flags.project === void 0 ? {} : { slug: flags.project }
+        ...flags.project === void 0 ? {} : { slug: flags.project },
+        ...flags.plan === true ? { plan: true } : {}
       });
+      command.line(
+        `\u73AF\u5883\uFF1A${environment}\uFF08${describeEnvironmentSource(source)}\uFF09\u2014\u2014 \u8FC1\u79FB\u5C06\u4F5C\u7528\u5230${environment === "dev" ? "\u5F00\u53D1\u5E93" : "\u751F\u4EA7\u5E93"}`
+      );
       if (result.failed !== void 0) {
         const f = result.failed;
-        command.fail(f.code, `\u6587\u4EF6 ${f.file} \u4E2D\u7684\u8BED\u53E5\u6267\u884C\u5931\u8D25\uFF1A${f.message}`);
+        command.fail(f.code, `\u6587\u4EF6 ${f.file} \u8FC1\u79FB\u5931\u8D25\uFF1A${f.message}`);
         return;
       }
-      command.line(
-        `\u73AF\u5883\uFF1A${environment}\uFF08${describeEnvironmentSource(source)}\uFF09\u2014\u2014 \u8FC1\u79FB\u5C06\u4F5C\u7528\u5230${environment === "dev" ? "\u5F00\u53D1\u5E93" : "\u751F\u4EA7\u5E93"}`
-      );
       command.ok(result, (data) => {
         const r = data;
-        const kinds = r.applied.map((s) => s.split(/\s+/)[0] ?? s).join(", ");
-        return `\u2713 ${r.applied.length} \u6761\u8BED\u53E5\u5DF2\u6267\u884C\uFF08${kinds}\uFF09`;
+        const lines = renderDrift(
+          r.drift ?? {
+            missingTables: [],
+            missingColumns: [],
+            typeMismatches: [],
+            extraTables: [],
+            extraColumns: [],
+            destructiveStatements: [],
+            applicable: true
+          }
+        );
+        if (flags.plan === true) return lines;
+        lines.push(
+          `\u2713 \u8FC1\u79FB\u5B8C\u6210\uFF1A\u65B0\u5EFA\u8868 ${r.createdTables}\uFF0C\u65B0\u589E\u5217 ${r.addedColumns}\uFF0C\u5DF2\u5B58\u5728\u8DF3\u8FC7 ${r.skippedTables}\uFF08\u5171\u6267\u884C ${r.applied.length} \u6761\u8BED\u53E5\uFF09`
+        );
+        return lines;
+      });
+    });
+  });
+  db.command("doctor").description(
+    "\u5168\u5E93 schema \u6F02\u79FB\u62A5\u544A\uFF1A\u5BF9\u6BD4 schema.sql \u4E0E\u7EBF\u4E0A\u76EE\u5F55\uFF08\u7F3A\u8868 / \u7F3A\u5217 / \u7C7B\u578B\u4E0D\u4E00\u81F4\uFF09\u3002\u53D7\u5168\u5C40 --env \u5F71\u54CD\uFF1B\u5B58\u5728\u7834\u574F\u6027\u53D8\u66F4\u65F6\u9000\u51FA\u7801\u975E 0"
+  ).argument("[schema]", "schema.sql \u8DEF\u5F84", "database/schema.sql").option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09").action(async (schema, flags) => {
+    const command = ctx.io("db doctor");
+    await command.run(async () => {
+      const { environment, source } = await ctx.env();
+      const { dbSchemaDiff: dbSchemaDiff2 } = await Promise.resolve().then(() => (init_db2(), db_exports));
+      const sql = await readFile29(resolve18(schema), "utf8");
+      const diff = await dbSchemaDiff2(ctx.paths, {
+        cwd: ctx.cwd,
+        sql,
+        environment,
+        ...flags.project === void 0 ? {} : { slug: flags.project }
       });
+      command.line(
+        `\u73AF\u5883\uFF1A${environment}\uFF08${describeEnvironmentSource(source)}\uFF09\u2014\u2014 \u68C0\u67E5\u7684\u662F${environment === "dev" ? "\u5F00\u53D1\u5E93" : "\u751F\u4EA7\u5E93"}`
+      );
+      if (!diff.applicable) {
+        command.fail(
+          "SCHEMA_DRIFT",
+          `\u68C0\u6D4B\u5230\u65E0\u6CD5\u81EA\u52A8\u6267\u884C\u7684\u6F02\u79FB\uFF08${schema}\uFF09\uFF1A
+${renderDrift(diff).join("\n")}`
+        );
+        return;
+      }
+      command.ok(diff, () => renderDrift(diff));
     });
   });
   const snapshot = db.command("snapshot").description("\u6570\u636E\u5E93\u5FEB\u7167\uFF08\u4ED8\u8D39\u6863\u4F4D\uFF09\uFF1A\u5217\u51FA\uFF08\u7F3A\u7701\uFF09/ \u521B\u5EFA / \u8FD8\u539F");
@@ -38176,6 +39004,59 @@ function registerHosting(program2, ctx) {
   });
 }
 
+// packages/cli/src/commands/logs.ts
+init_auth();
+function registerLogs(program2, ctx) {
+  program2.command("logs").description("\u6309 traceId \u67E5\u8BE2\u4E00\u6B21\u8C03\u7528\u94FE\u7684\u65E5\u5FD7\uFF08traceId \u89C1\u9519\u8BEF\u4FE1\u5C01\u6216\u54CD\u5E94\u5934\uFF09").option("--trace <traceId>", "W3C traceId\uFF0832 \u4F4D hex\uFF09").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 (flags) => {
+    const command = ctx.io("logs");
+    await command.run(async () => {
+      const trace = flags.trace?.trim() ?? "";
+      if (trace.length === 0) {
+        throw new CliError("INVALID_ARGUMENT", "\u7F3A\u5C11 --trace\uFF1Aadep logs --trace <traceId>");
+      }
+      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 { logsByTrace: logsByTrace2 } = await Promise.resolve().then(() => (init_functions(), functions_exports));
+      const result = await logsByTrace2(ctx.paths, {
+        cwd: ctx.cwd,
+        trace,
+        ...tail === void 0 ? {} : { tail },
+        ...flags.project === void 0 ? {} : { slug: flags.project }
+      });
+      command.ok(result, (data) => {
+        const r = data;
+        if (r.logs.length === 0) {
+          return `\uFF08trace ${r.traceId} \u6682\u65E0\u65E5\u5FD7\uFF1A\u786E\u8BA4 traceId \u6B63\u786E\uFF0C\u4E14\u8BE5\u8C03\u7528\u53D1\u751F\u5728\u65E5\u5FD7\u7F13\u51B2\u4FDD\u7559\u7A97\u53E3\u5185\uFF09`;
+        }
+        return r.logs.map((log) => `${log.at}  [${log.level}]  ${log.message}`);
+      });
+    });
+  });
+}
+
+// packages/cli/src/commands/rollback.ts
+function registerRollback(program2, ctx) {
+  program2.command("rollback <fn>").description("\u628A\u5DF2\u53D1\u5E03\u51FD\u6570\u5207\u56DE\u5386\u53F2\u7248\u672C\uFF08\u7248\u672C\u6765\u81EA adep publish \u751F\u6210\u7684\u81EA\u589E\u53F7\uFF09").option("--to <version>", "\u76EE\u6807\u7248\u672C\u53F7\uFF0C\u5982 v2 \u6216 2").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) => {
+    const command = ctx.io("rollback");
+    await command.run(async () => {
+      const { parseVersionFlag: parseVersionFlag2, rollbackFunctionTo: rollbackFunctionTo2 } = await Promise.resolve().then(() => (init_rollback(), rollback_exports));
+      const to = parseVersionFlag2(flags.to);
+      const result = await rollbackFunctionTo2(ctx.paths, {
+        cwd: ctx.cwd,
+        name,
+        to,
+        ...flags.project === void 0 ? {} : { slug: flags.project }
+      });
+      command.ok(result, (data) => {
+        const r = data;
+        return `\u5DF2\u56DE\u6EDA ${r.name}\uFF1Av${r.from ?? "\u2014"} \u2192 v${r.to}`;
+      });
+    });
+  });
+}
+
 // packages/cli/src/cli.ts
 var requireJson = createRequire2(import.meta.url);
 var APP_VERSION = requireJson("../package.json").version;
@@ -38211,6 +39092,8 @@ function buildProgram(options = {}) {
   registerAuth(program2, ctx);
   registerMcp(program2, ctx);
   registerGit(program2, ctx);
+  registerLogs(program2, ctx);
+  registerRollback(program2, ctx);
   registerDeploy(program2, ctx);
   registerProjects(program2, ctx);
   registerFunctions(program2, ctx);