@adep/cli 0.0.2 → 0.0.4

package/README.md

@@ -391,15 +391,14 @@ export ADEP_HOME=~/.adep
 
 ### `adep.config.ts`
 
-`adep init` 生成的项目标识文件，CLI 的 `dev` / `deploy` 按此识别项目：
+`adep init` 生成的项目标识文件，CLI 的 `dev` / `deploy` 按此识别项目（CLI 直接 import 后读 `default` 的字段，无需任何辅助包）：
 
 ```ts
-import { defineConfig } from 'adep/config'
-
-export default defineConfig({
+// adep 项目配置：CLI（dev / deploy）按 default export 读取（name / functionsDir）。
+export default {
   name: 'my-app', // 项目名（deploy 的默认 slug）
   template: 'function', // 模板：empty | function
-})
+}
 ```
 
 ---

package/dist/index.js

@@ -5568,13 +5568,11 @@ var InitError = class extends Error {
     this.name = "InitError";
   }
 };
-var ADEP_CONFIG = (name, template) => `import { defineConfig } from 'adep/config'
-
-// adep \u9879\u76EE\u914D\u7F6E\uFF1ACLI\uFF08dev / deploy\uFF09\u4E0E\u5E73\u53F0\u6309\u6B64\u8BC6\u522B\u9879\u76EE\u3002
-export default defineConfig({
+var ADEP_CONFIG = (name, template) => `// adep \u9879\u76EE\u914D\u7F6E\uFF1ACLI\uFF08dev / deploy\uFF09\u6309 default export \u8BFB\u53D6\uFF08name / functionsDir\uFF09\u3002
+export default {
   name: '${name}',
   template: '${template}',
-})
+}
 `;
 var README = (name, template) => `# ${name}
 
@@ -5583,13 +5581,13 @@ AgentDeploy \u9879\u76EE\uFF08\u6A21\u677F\uFF1A${template}\uFF09\u3002
 - \`adep dev\`\uFF1A\u672C\u5730\u8C03\u8BD5\uFF08CLI-002 \u4EA4\u4ED8\uFF09
 - \`adep deploy\`\uFF1A\u53D1\u5E03\uFF08CLI-003 \u4EA4\u4ED8\uFF09
 `;
-var HELLO_FUNCTION = `import { defineFunction } from 'adep/function'
-
-// \u793A\u4F8B\u51FD\u6570\uFF1Aadep deploy \u540E\u7ECF https://<project-slug>.<platform-domain>/hello \u89E6\u53D1\u3002
-export default defineFunction(async (ctx) => {
+var HELLO_FUNCTION = `// \u793A\u4F8B\u51FD\u6570\uFF1Aadep deploy \u540E\u7ECF https://<project-slug>.<platform-domain>/hello \u89E6\u53D1\u3002
+// \u7528\u6237\u51FD\u6570\u5373 functions/ \u4E0B\u7684\u72EC\u7ACB\u6587\u4EF6\uFF0C\u9ED8\u8BA4\u5BFC\u51FA (ctx) => Response \u5F62\u72B6\u7684\u5904\u7406\u5668
+//\uFF08ctx \u5951\u7EA6\u89C1\u5E73\u53F0\u7684 FunctionContext\uFF1Amethod / path / query / headers / body / cloud.*\uFF09\u3002
+export default async (ctx) => {
   const name = (ctx.query['name'] as string | undefined) ?? 'world'
   return { message: \`hello \${name}\` }
-})
+}
 `;
 var FUNCTION_INDEX = `// \u51FD\u6570\u6A21\u5757\u5165\u53E3\uFF1A\u9879\u76EE\u91CC\u7684\u6BCF\u4E2A\u51FD\u6570\u662F functions/ \u4E0B\u7684\u72EC\u7ACB\u6587\u4EF6\uFF0C
 // \u9ED8\u8BA4\u5BFC\u51FA (ctx) => Response \u5F62\u72B6\u7684\u5904\u7406\u5668\uFF08\u5951\u7EA6\u89C1 @adep/types \u7684 FunctionContext\uFF09\u3002

package/dist/worker-entry.js

@@ -0,0 +1,692 @@
+// packages/runtime/src/functions/runtime/worker-entry.ts
+import { parentPort, workerData } from "node:worker_threads";
+import { createRequire } from "node:module";
+import { join } from "node:path";
+
+// packages/runtime/src/functions/runtime/cloud-container.ts
+var KNOWN_CAPABILITY_HINTS = {
+  db: {
+    code: "DB_NOT_PROVISIONED",
+    message: "\u9879\u76EE\u6570\u636E\u5E93\u5C1A\u672A\u5F00\u542F\uFF1A\u8BF7\u5230\u9879\u76EE\u8BBE\u7F6E\u542F\u52A8\u6570\u636E\u5E93\uFF08DB_NOT_PROVISIONED\uFF09"
+  },
+  storage: {
+    code: "STORAGE_NOT_AVAILABLE",
+    message: "\u6587\u4EF6\u5B58\u50A8\u5C1A\u672A\u5F00\u542F\uFF1A\u8BF7\u5230\u9879\u76EE\u8BBE\u7F6E\u5F00\u542F\u6587\u4EF6\u5B58\u50A8\uFF08STORAGE_NOT_AVAILABLE\uFF09"
+  },
+  fetch: {
+    code: "FN_FETCH_DISABLED",
+    message: "\u6C99\u7BB1\u7F51\u7EDC\u672A\u5F00\u542F\uFF1A\u8BF7\u914D\u7F6E FUNCTIONS_FETCH_ALLOWLIST \u767D\u540D\u5355\u540E\u91CD\u542F\uFF08FN_FETCH_DISABLED\uFF09"
+  },
+  realtime: {
+    code: "REALTIME_NOT_AVAILABLE",
+    message: "\u5B9E\u65F6\u901A\u9053\u672A\u88C5\u914D\uFF1Arealtime \u57DF\u672A\u88C5\u8F7D\uFF08\u68C0\u67E5\u90E8\u7F72\u5F62\u6001\u4E0E Redis \u914D\u7F6E\uFF09\uFF08REALTIME_NOT_AVAILABLE\uFF09"
+  }
+};
+var CapabilityNotRegisteredError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "CapabilityNotRegisteredError";
+  }
+};
+function createCloud(registrations) {
+  const store = registrations;
+  return new Proxy(
+    {},
+    {
+      get(_target, prop) {
+        if (typeof prop !== "string") return void 0;
+        if (!store.has(prop)) {
+          const hint = KNOWN_CAPABILITY_HINTS[prop];
+          throw new CapabilityNotRegisteredError(
+            hint?.code ?? "CAPABILITY_NOT_REGISTERED",
+            hint?.message ?? `\u80FD\u529B "${prop}" \u672A\u6CE8\u518C\uFF1A\u8BF7\u5728\u51FD\u6570\u6240\u5728\u9879\u76EE\u5B89\u88C5\u5BF9\u5E94\u80FD\u529B`
+          );
+        }
+        return store.get(prop);
+      },
+      has: () => true
+      // 支持 'db' in ctx.cloud 形态
+    }
+  );
+}
+function createCloudContainer() {
+  const registry = /* @__PURE__ */ new Map();
+  const names = /* @__PURE__ */ new Set();
+  let cloud = null;
+  const rebuild = () => {
+    cloud = createCloud(registry);
+  };
+  rebuild();
+  return {
+    register(name, impl) {
+      registry.set(name, impl);
+      names.add(name);
+      rebuild();
+    },
+    unregister(name) {
+      registry.delete(name);
+      names.delete(name);
+      rebuild();
+    },
+    get names() {
+      return [...names];
+    },
+    get cloud() {
+      return cloud;
+    }
+  };
+}
+
+// packages/runtime/src/functions/runtime/sandbox.ts
+import vm from "node:vm";
+import * as nodeModule from "node:module";
+
+// packages/runtime/src/functions/runtime/exports.ts
+function transformModule(code) {
+  let out = code;
+  const named = [];
+  out = out.replace(/(^|\n)(\s*)export\s+default\s+/g, "$1$2module.default = ");
+  out = out.replace(
+    /import\s*\{([^}]*)\}\s*from\s*(['"][^'"]*['"])[ \t]*;?/g,
+    (_match, names, source) => `const {${names}} = require(${source})`
+  );
+  out = out.replace(
+    /import\s*\*\s*as\s*([A-Za-z_$][\w$]*)\s*from\s*(['"][^'"]*['"])[ \t]*;?/g,
+    (_match, name, source) => `const ${name} = require(${source})`
+  );
+  out = out.replace(
+    /import\s+([A-Za-z_$][\w$]*)\s+from\s*(['"][^'"]*['"])[ \t]*;?/g,
+    (_match, name, source) => `const ${name} = require(${source})`
+  );
+  out = out.replace(
+    /export\s+(const|let|var)\s+([A-Za-z_$][\w$]*)/g,
+    (_match, kw, name) => {
+      named.push(name);
+      return `${kw} ${name}`;
+    }
+  );
+  out = out.replace(
+    /export\s+(async\s+)?function\s*\*?\s*([A-Za-z_$][\w$]*)/g,
+    (_match, asyncKw, name) => {
+      named.push(name);
+      return `${asyncKw ?? ""}function ${name}`;
+    }
+  );
+  out = out.replace(/export\s+class\s+([A-Za-z_$][\w$]*)/g, (_match, name) => {
+    named.push(name);
+    return `class ${name}`;
+  });
+  if (named.length > 0) {
+    out += `
+;Object.assign(exports, { ${named.join(", ")} })`;
+  }
+  return out;
+}
+
+// packages/runtime/src/functions/runtime/sandbox.ts
+var bunTranspiler;
+function transpile(code) {
+  const bun = globalThis["Bun"];
+  if (bun?.Transpiler !== void 0) {
+    bunTranspiler ??= new bun.Transpiler({ loader: "ts" });
+    return bunTranspiler.transformSync(code);
+  }
+  const stripTypeScriptTypes2 = nodeModule.stripTypeScriptTypes;
+  if (typeof stripTypeScriptTypes2 === "function") {
+    return stripTypeScriptTypes2(code, { mode: "strip" });
+  }
+  return code;
+}
+function transformExports(code) {
+  return transformModule(code);
+}
+var SANDBOX_BUILTIN_REJECTED = "FN_SANDBOX_BUILTIN_BLOCKED";
+function resolveModulePath(fromDir, request, files) {
+  if (!request.startsWith("./") && !request.startsWith("../")) return null;
+  const base = joinPosix(fromDir, request);
+  const candidates = [base, `${base}.ts`, `${base}.js`, `${base}/index.ts`, `${base}/index.js`];
+  for (const candidate of candidates) {
+    const normalized = normalizePosix(candidate);
+    if (files[normalized] !== void 0) return normalized;
+  }
+  return null;
+}
+function joinPosix(dir, request) {
+  const parts = [...dir.split("/"), ...request.split("/")];
+  const stack = [];
+  for (const part of parts) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") stack.pop();
+    else stack.push(part);
+  }
+  return stack.join("/");
+}
+function normalizePosix(p) {
+  return joinPosix("", p);
+}
+function loadModule(path, files, sandboxGlobals, cache, resolveBare, bareCache) {
+  const cached = cache.get(path);
+  if (cached !== void 0) return cached;
+  const source = files[path];
+  if (source === void 0) {
+    throw new Error(`\u6A21\u5757\u4E0D\u5B58\u5728\uFF1A${path}`);
+  }
+  const exports = {};
+  cache.set(path, exports);
+  const dir = path.includes("/") ? path.slice(0, path.lastIndexOf("/")) : "";
+  const module = { exports, default: void 0 };
+  const require2 = (request) => {
+    const resolved = resolveModulePath(dir, request, files);
+    if (resolved !== null) {
+      return loadModule(resolved, files, sandboxGlobals, cache, resolveBare, bareCache);
+    }
+    if (resolveBare !== void 0 && !request.startsWith("./") && !request.startsWith("../")) {
+      const cachedModule = bareCache?.get(request);
+      if (cachedModule !== void 0) return cachedModule;
+      const loaded = resolveBare(request);
+      bareCache?.set(request, loaded);
+      return loaded;
+    }
+    const error = new Error(
+      `\u6C99\u7BB1\u62D2\u7EDD\u8BE5\u5F15\u7528\uFF1A"${request}"\u3002\u51FD\u6570\u5185\u53EA\u80FD require \u9879\u76EE\u5185\u7684\u76F8\u5BF9\u8DEF\u5F84\u6587\u4EF6\uFF08FN_SANDBOX_BUILTIN_BLOCKED\uFF09`
+    );
+    error.code = SANDBOX_BUILTIN_REJECTED;
+    throw error;
+  };
+  let transformed;
+  try {
+    transformed = transformExports(transpile(source));
+  } catch (error) {
+    const rawMessage = error instanceof Error ? error.message : String(error);
+    const stack = error.stack;
+    const line = typeof stack === "string" ? /(?:^|\n):(\d+)(?:\n|$)/.exec(stack)?.[1] : void 0;
+    const location = line === void 0 ? path : `${path}:${line}`;
+    const wrapped = new Error(`\u6E90\u7801\u8BED\u6CD5\u9519\u8BEF\uFF08${location}\uFF09\uFF1A${rawMessage}`, { cause: error });
+    const code = error.code;
+    if (typeof code === "string") wrapped.code = code;
+    throw wrapped;
+  }
+  const wrapper = vm.runInNewContext(
+    `(function (module, exports, require) { ${transformed} 
+})`,
+    vm.createContext({ ...sandboxGlobals }),
+    { filename: path }
+  );
+  wrapper(module, exports, require2);
+  if (module.default !== void 0 && exports["default"] === void 0) {
+    exports["default"] = module.default;
+  }
+  return exports;
+}
+function loadFunctionModule(files, entry, sandboxGlobals, resolveBare) {
+  const cache = /* @__PURE__ */ new Map();
+  const bareCache = /* @__PURE__ */ new Map();
+  const entryExports = loadModule(entry, files, sandboxGlobals, cache, resolveBare, bareCache);
+  const handler = entryExports["default"];
+  if (typeof handler !== "function") {
+    throw new Error(`\u5165\u53E3\u6587\u4EF6 ${entry} \u7F3A\u5C11 default \u5BFC\u51FA\u7684\u51FD\u6570`);
+  }
+  return { handler };
+}
+
+// packages/runtime/src/functions/runtime/sandbox-fetch.ts
+var SandboxFetchError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "SandboxFetchError";
+    this.code = code;
+  }
+};
+var DEFAULT_MAX_RESPONSE_BYTES = 100 * 1024 * 1024;
+var defaultFetch = (url, init) => (
+  // 真实 Response 与内部 ResponseLike 结构性一致；getReader 的多态签名差异属纯类型问题，运行语义等价。
+  globalThis.fetch(url, init)
+);
+function isHostAllowed(host, rules) {
+  const h = host.toLocaleLowerCase();
+  return rules.some((raw) => {
+    const rule = raw.trim().toLocaleLowerCase();
+    if (rule.startsWith("*.")) {
+      const base = rule.slice(2);
+      return h === base || h.endsWith(`.${base}`);
+    }
+    return h === rule;
+  });
+}
+var FORBIDDEN = (url) => new SandboxFetchError(
+  "FN_FETCH_FORBIDDEN",
+  `cloud.fetch \u62D2\u7EDD\u8BBF\u95EE "${url}"\uFF1A\u8BE5\u4E3B\u673A\u4E0D\u5728\u6C99\u7BB1\u7F51\u7EDC\u767D\u540D\u5355\u5185\uFF08FN_FETCH_FORBIDDEN\uFF09`
+);
+var TOO_LARGE = new SandboxFetchError(
+  "FN_FETCH_TOO_LARGE",
+  "cloud.fetch \u54CD\u5E94\u4F53\u8D85\u8FC7\u4E0A\u9650\uFF08FN_FETCH_TOO_LARGE\uFF09"
+);
+function headersToRecord(headers) {
+  const out = {};
+  if (headers === void 0 || headers === null) return out;
+  if (typeof headers.forEach === "function") {
+    ;
+    headers.forEach((value, key) => {
+      out[String(key).toLocaleLowerCase()] = String(value);
+    });
+    return out;
+  }
+  for (const [key, value] of Object.entries(headers)) {
+    out[key.toLocaleLowerCase()] = String(value);
+  }
+  return out;
+}
+function contentLength(res) {
+  const headers = res.headers;
+  if (headers === void 0 || headers === null) return null;
+  if (typeof headers.get === "function") {
+    const raw2 = headers.get?.("content-length");
+    if (raw2 === void 0 || raw2 === null || raw2.trim() === "") return null;
+    const n2 = Number(raw2);
+    return Number.isFinite(n2) && n2 >= 0 ? n2 : null;
+  }
+  const record = headers;
+  const raw = record["content-length"] ?? record["Content-Length"];
+  if (raw === void 0 || raw === null) return null;
+  const n = Number(raw);
+  return Number.isFinite(n) && n >= 0 ? n : null;
+}
+function concatChunks(chunks, total) {
+  const merged = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    merged.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return merged;
+}
+async function readBodyBytes(res, maxBytes) {
+  if (maxBytes > 0) {
+    const cl = contentLength(res);
+    if (cl !== null && cl > maxBytes) throw TOO_LARGE;
+  }
+  const body = res.body;
+  if (body !== void 0 && body !== null) {
+    const reader = body.getReader();
+    const chunks = [];
+    let total = 0;
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (value !== void 0) {
+        total += value.byteLength;
+        if (maxBytes > 0 && total > maxBytes) throw TOO_LARGE;
+        chunks.push(value);
+      }
+    }
+    return concatChunks(chunks, total);
+  }
+  if (typeof res.arrayBuffer === "function") {
+    const buffer = await res.arrayBuffer();
+    const bytes2 = new Uint8Array(buffer);
+    if (maxBytes > 0 && bytes2.byteLength > maxBytes) throw TOO_LARGE;
+    return bytes2;
+  }
+  const text = await res.text();
+  const bytes = encoder.encode(text);
+  if (maxBytes > 0 && bytes.byteLength > maxBytes) throw TOO_LARGE;
+  return bytes;
+}
+var encoder = new TextEncoder();
+function errorMessageOf(error) {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+function normalizeResponse(res, maxBytes) {
+  let cached = null;
+  let cachedPromise = null;
+  const readCached = () => {
+    if (cached !== null) return Promise.resolve(cached);
+    cachedPromise ??= readBodyBytes(res, maxBytes).then((bytes) => {
+      cached = bytes;
+      return bytes;
+    });
+    return cachedPromise;
+  };
+  const read = () => readCached();
+  return {
+    ok: res.ok,
+    status: res.status,
+    statusText: res.statusText,
+    headers: headersToRecord(res.headers),
+    text: async () => decoder.decode(await read()),
+    arrayBuffer: async () => bufferViewToArrayBuffer(await read()),
+    json: async () => JSON.parse(decoder.decode(await read()))
+  };
+}
+var decoder = new TextDecoder();
+function bufferViewToArrayBuffer(bytes) {
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+function createSandboxFetch(options) {
+  const fetchImpl = options.fetchImpl ?? defaultFetch;
+  const { allowlist, timeoutMs } = options;
+  const maxBytes = options.maxResponseBytes ?? DEFAULT_MAX_RESPONSE_BYTES;
+  return async (url, init) => {
+    let parsed;
+    try {
+      parsed = new URL(url);
+    } catch {
+      throw new SandboxFetchError("FN_FETCH_INVALID_URL", `cloud.fetch \u6536\u5230\u975E\u6CD5 URL"${url}"`);
+    }
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:") throw FORBIDDEN(url);
+    if (!isHostAllowed(parsed.hostname, allowlist)) throw FORBIDDEN(url);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const signals = [controller.signal];
+    if (init?.signal !== void 0) signals.push(init.signal);
+    const signal = signals.length === 1 ? signals[0] : AbortSignal.any(signals);
+    try {
+      let res;
+      try {
+        res = await fetchImpl(url, { ...init, signal });
+      } catch (error) {
+        if (controller.signal.aborted) {
+          throw new SandboxFetchError(
+            "FN_FETCH_TIMEOUT",
+            `cloud.fetch \u8BF7\u6C42\u8D85\u65F6\uFF08\u8D85\u8FC7 ${timeoutMs}ms\uFF09`
+          );
+        }
+        if (init?.signal?.aborted === true) {
+          throw new SandboxFetchError("FN_FETCH_ABORTED", "cloud.fetch \u8BF7\u6C42\u88AB\u8C03\u7528\u65B9\u4E2D\u6B62");
+        }
+        throw new SandboxFetchError(
+          "FN_FETCH_FAILED",
+          `cloud.fetch \u8BF7\u6C42\u5931\u8D25\uFF1A${errorMessageOf(error)}`
+        );
+      }
+      return normalizeResponse(res, maxBytes);
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+}
+
+// packages/runtime/src/shared/capability-keys.ts
+var RPC_CAPABILITY_KEY = "__adepRpc";
+var CHAIN_CAPABILITY_KEY = "__adepChain";
+var DB_RPC = {
+  /** 直通方法（如 query）：`(method=query, args=[sql, params])`。 */
+  query: "query",
+  /** 读取 owned 表变更流（DB-006）：`(method=changes, args=[table, query])`。 */
+  changes: "changes",
+  /** 开启事务：`begin → txId`。 */
+  begin: "begin",
+  /** 提交事务：`commit, args=[txId]`。 */
+  commit: "commit",
+  /** 回滚事务：`rollback, args=[txId]`。 */
+  rollback: "rollback",
+  /** 执行一条链：`chain, args=[ChainRequest]`。 */
+  chain: "chain"
+};
+
+// packages/runtime/src/functions/runtime/chain.ts
+function isChainCapability(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const spec = value[CHAIN_CAPABILITY_KEY];
+  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((resolve, reject) => {
+    const id = nextId();
+    pending.set(id, { resolve, reject });
+    port.postMessage({ type: "rpc", id, capability, method, args });
+  });
+  const makeChainable = (rootArgs, steps, txId) => new Proxy(
+    {},
+    {
+      get(_target, prop) {
+        if (typeof prop !== "string") return void 0;
+        if (spec.stepMethods.includes(prop)) {
+          return (...args) => makeChainable(rootArgs, [...steps, { method: prop, args }], txId);
+        }
+        if (spec.terminalMethods.includes(prop)) {
+          return (...args) => call(DB_RPC.chain, [
+            {
+              rootArgs,
+              steps,
+              terminal: prop,
+              terminalArgs: args,
+              ...txId === void 0 ? {} : { txId }
+            }
+          ]);
+        }
+        return void 0;
+      }
+    }
+  );
+  const makeRoot = (txId) => new Proxy(
+    {},
+    {
+      get(_target, prop) {
+        if (typeof prop !== "string") return void 0;
+        if (prop === spec.rootMethod) {
+          return (...rootArgs) => makeChainable(rootArgs, [], txId);
+        }
+        if (spec.directMethods.includes(prop)) {
+          return (...args) => call(prop, args);
+        }
+        if (prop === spec.transactionMethod) {
+          return (fn) => orchestrateTransaction(fn, txId);
+        }
+        return void 0;
+      }
+    }
+  );
+  const orchestrateTransaction = async (fn, _outerTxId) => {
+    const txId = await call(DB_RPC.begin, []);
+    const tx = makeRoot(txId);
+    const settle = async (commit) => {
+      await call(commit ? DB_RPC.commit : DB_RPC.rollback, [txId]).catch(() => void 0);
+    };
+    try {
+      const result = await fn(tx);
+      await settle(true);
+      return result;
+    } catch (error) {
+      await settle(false);
+      throw error;
+    }
+  };
+  return makeRoot(void 0);
+}
+
+// packages/runtime/src/functions/deps/manifest.ts
+function splitBareSpecifier(request) {
+  if (request.startsWith("@")) {
+    const segments = request.split("/");
+    return segments.slice(0, 2).join("/");
+  }
+  return request.split("/")[0];
+}
+
+// packages/runtime/src/functions/runtime/worker-entry.ts
+function isRpcCapability(value) {
+  return typeof value === "object" && value !== null && value[RPC_CAPABILITY_KEY] === true;
+}
+function createRpcClient(capability, port, pending, nextId) {
+  return new Proxy(
+    {},
+    {
+      get(_target, method) {
+        if (typeof method !== "string") return void 0;
+        return (...args) => {
+          const id = nextId();
+          return new Promise((resolve, reject) => {
+            pending.set(id, { resolve, reject });
+            port.postMessage({ type: "rpc", id, capability, method, args });
+          });
+        };
+      }
+    }
+  );
+}
+function errorMessageOf2(error) {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "object" && error !== null && "message" in error) {
+    const message = error.message;
+    if (typeof message === "string") return message;
+  }
+  return String(error);
+}
+function escapeRegExp(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function firstUserFrame(stack, files) {
+  for (const key of Object.keys(files)) {
+    const match = new RegExp(
+      `(?<![\\w$/.])${escapeRegExp(key)}:(\\d+)(?::(\\d+))?(?::(\\d+))?`
+    ).exec(stack);
+    if (match !== null) {
+      return match[2] === void 0 ? `${key}:${match[1]}` : `${key}:${match[1]}:${match[2]}`;
+    }
+  }
+  return void 0;
+}
+function errorMessageWithLocation(error, files) {
+  const message = errorMessageOf2(error);
+  const stack = error.stack;
+  if (typeof stack !== "string") return message;
+  const frame = firstUserFrame(stack, files);
+  return frame === void 0 ? message : `${message}\uFF08${frame}\uFF09`;
+}
+function createBareResolver(deps) {
+  const platformRequire = createRequire(import.meta.url);
+  const depsRequire = deps.dir === null ? null : createRequire(join(deps.dir, "__deps__.js"));
+  return (request) => {
+    const root = splitBareSpecifier(request);
+    if (deps.builtin.includes(root)) return platformRequire(request);
+    if (deps.custom.includes(root)) {
+      if (depsRequire === null) {
+        throw new Error(`\u4F9D\u8D56 "${root}" \u672A\u88C5\u8F7D\uFF1A\u9879\u76EE\u4F9D\u8D56\u76EE\u5F55\u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u53D1\u5E03\u51FD\u6570\u89E6\u53D1\u4F9D\u8D56\u88C5\u8F7D`);
+      }
+      try {
+        return depsRequire(request);
+      } catch (error2) {
+        const message = errorMessageOf2(error2);
+        throw new Error(
+          `\u4F9D\u8D56 "${request}" \u88C5\u8F7D\u5931\u8D25\uFF08\u76EE\u5F55 ${deps.dir}\uFF09\uFF1A\u8BF7\u91CD\u65B0\u53D1\u5E03\u51FD\u6570\u4EE5\u89E6\u53D1\u4F9D\u8D56\u5B89\u88C5\u3002\u539F\u56E0\uFF1A${message}`,
+          { cause: error2 }
+        );
+      }
+    }
+    const error = new Error(
+      `\u6C99\u7BB1\u62D2\u7EDD\u8BE5\u5F15\u7528\uFF1A"${request}"\u3002\u4EC5\u5141\u8BB8\u76F8\u5BF9\u8DEF\u5F84\u6587\u4EF6\u4E0E\u5DF2\u58F0\u660E\u7684\u4F9D\u8D56\uFF08\u5185\u7F6E\u767D\u540D\u5355\u6216 package.json\uFF09\uFF0C\u88F8\u6A21\u5757 "${root}" \u672A\u58F0\u660E\uFF08FN_SANDBOX_BUILTIN_BLOCKED\uFF09`
+    );
+    error.code = SANDBOX_BUILTIN_REJECTED;
+    throw error;
+  };
+}
+function runWorker(input, port) {
+  const emit = (level, args) => {
+    port.postMessage({ type: "log", level, message: args.map(String).join(" ") });
+  };
+  const forwardedConsole = {
+    log: (...args) => emit("log", args),
+    error: (...args) => emit("error", args),
+    warn: (...args) => emit("warn", args)
+  };
+  const container = createCloudContainer();
+  const pending = /* @__PURE__ */ new Map();
+  let rpcId = 0;
+  port.on?.((message) => {
+    const reply = message;
+    if (reply?.type !== "rpc-response" || typeof reply.id !== "number") return;
+    const entry = pending.get(reply.id);
+    if (entry === void 0) return;
+    pending.delete(reply.id);
+    if (reply.ok === true) entry.resolve(reply.result);
+    else entry.reject(new Error(reply.error ?? "RPC \u80FD\u529B\u8C03\u7528\u5931\u8D25"));
+  });
+  for (const capability of input.capabilities ?? []) {
+    container.register(
+      capability.name,
+      isChainCapability(capability.value) ? createChainClient(
+        capability.name,
+        port,
+        pending,
+        () => ++rpcId,
+        capability.value[CHAIN_CAPABILITY_KEY]
+      ) : isRpcCapability(capability.value) ? createRpcClient(capability.name, port, pending, () => ++rpcId) : capability.value
+    );
+  }
+  const sandboxGlobals = {
+    console: forwardedConsole
+  };
+  if (input.env !== void 0) {
+    sandboxGlobals["process"] = { env: input.env };
+  }
+  if (input.fetch !== void 0) {
+    const sandboxFetch = createSandboxFetch({
+      allowlist: input.fetch.allowlist,
+      timeoutMs: input.fetch.timeoutMs,
+      ...input.fetch.maxResponseBytes === void 0 ? {} : { maxResponseBytes: input.fetch.maxResponseBytes }
+    });
+    sandboxGlobals["fetch"] = sandboxFetch;
+    container.register("fetch", sandboxFetch);
+  }
+  const ctx = {
+    method: input.request.method,
+    path: input.request.path,
+    query: input.request.query,
+    headers: input.request.headers,
+    ...input.request.body === void 0 ? {} : { body: input.request.body },
+    files: input.request.files ?? [],
+    cloud: container.cloud,
+    user: input.request.user ?? null
+  };
+  try {
+    const { handler } = loadFunctionModule(
+      input.files,
+      input.entry,
+      sandboxGlobals,
+      input.deps === void 0 ? void 0 : createBareResolver(input.deps)
+    );
+    const result = Promise.resolve(handler(ctx));
+    void result.then(
+      (value) => {
+        port.postMessage({ type: "result", body: value === void 0 ? null : value });
+        return void 0;
+      },
+      (error) => {
+        port.postMessage({
+          type: "error",
+          message: errorMessageWithLocation(error, input.files),
+          code: error.code,
+          // FN-011：函数抛错可携带 status（4xx/5xx），透传给执行器落 ExecutorError.status。
+          status: error.status
+        });
+        return void 0;
+      }
+    );
+  } catch (error) {
+    port.postMessage({
+      type: "error",
+      message: errorMessageWithLocation(error, input.files),
+      code: error.code,
+      status: error.status
+    });
+  }
+}
+var workerPort = parentPort;
+if (workerPort !== null && workerData !== void 0) {
+  const port = {
+    // eslint-disable-next-line unicorn/require-post-message-target-origin -- node worker_threads 无 targetOrigin 语义
+    postMessage: (message) => workerPort.postMessage(message),
+    on: (listener) => {
+      workerPort.on("message", (value) => listener(value));
+    }
+  };
+  runWorker(workerData, port);
+}
+export {
+  runWorker
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adep/cli",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "type": "module",
   "description": "`adep` 命令行工具包位：登录 / 初始化 / 本地调试 / 部署 / 数据库维护 / 云存储 / 静态托管 / 微前端组件（widget），实现见任务单 CLI-001 ~ CLI-003 与 FE-002",
   "bin": {
@@ -14,8 +14,8 @@
     "esbuild": "0.25.12"
   },
   "devDependencies": {
-    "@adep/runtime": "0.1.1",
-    "@adep/types": "0.1.1"
+    "@adep/runtime": "0.1.2",
+    "@adep/types": "0.1.3"
   },
   "scripts": {
     "test": "vitest run",