@adep/cli 0.3.1 → 0.4.1

package/dist/vite.js

@@ -3559,13 +3559,67 @@ import vm from "node:vm";
 import * as nodeModule from "node:module";
 
 // packages/runtime/src/functions/runtime/exports.ts
+function keepLineCount(matched, lead) {
+  const consumed = matched.split("\n").length - 1;
+  const kept = lead === "\n" ? 1 : 0;
+  return "\n".repeat(Math.max(0, consumed - kept));
+}
+function parseSpecifier(part) {
+  const asMatch = /^([A-Za-z_$][\w$]*)\s+as\s+([A-Za-z_$][\w$]*)$/.exec(part);
+  if (asMatch !== null) {
+    const [, local, exported] = asMatch;
+    if (local !== void 0 && exported !== void 0) return [local, exported];
+  }
+  return /^[A-Za-z_$][\w$]*$/.test(part) ? [part, part] : null;
+}
+function namedImportsToDestructure(clause) {
+  const parts = [];
+  for (const raw of clause.split(",")) {
+    const part = raw.trim();
+    if (part === "") continue;
+    const spec = parseSpecifier(part);
+    if (spec === null) {
+      throw new Error(`\u4E0D\u652F\u6301\u7684\u5177\u540D\u5BFC\u5165\u5F62\u6001\uFF1A"${part}"\uFF08\u6C99\u7BB1\u5B50\u96C6\u4EC5\u63A5\u53D7 a \u6216 a as b\uFF09`);
+    }
+    parts.push(spec[0] === spec[1] ? spec[0] : `${spec[0]}: ${spec[1]}`);
+  }
+  return parts;
+}
+function parseExportClause(clause) {
+  const entries = [];
+  for (const raw of clause.split(",")) {
+    const part = raw.trim();
+    if (part === "") continue;
+    const spec = parseSpecifier(part);
+    if (spec === null) {
+      throw new Error(`\u4E0D\u652F\u6301\u7684\u518D\u5BFC\u51FA\u5B50\u53E5\uFF1A"${part}"\uFF08\u6C99\u7BB1\u5B50\u96C6\u4EC5\u63A5\u53D7 a \u6216 a as b\uFF09`);
+    }
+    entries.push({ local: spec[0], exported: spec[1] });
+  }
+  return entries;
+}
 function transformModule(code) {
   let out = code;
   const named = [];
+  const starReexports = [];
+  let tempSeq = 0;
+  const nextTemp = () => `__adep_reexport_${tempSeq++}`;
   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})`
+    (matched, clause, source) => {
+      const parts = namedImportsToDestructure(clause);
+      const pad = keepLineCount(matched, "");
+      return parts.length === 0 ? `require(${source})${pad}` : `const { ${parts.join(", ")} } = require(${source})${pad}`;
+    }
+  );
+  out = out.replace(
+    /import\s+([A-Za-z_$][\w$]*)\s*,\s*\{([^}]*)\}\s*from\s*(['"][^'"]*['"])[ \t]*;?/g,
+    (matched, name, clause, source) => {
+      const parts = namedImportsToDestructure(clause);
+      const pad = keepLineCount(matched, "");
+      return parts.length === 0 ? `const ${name} = require(${source})${pad}` : `const ${name} = require(${source}), { ${parts.join(", ")} } = ${name}${pad}`;
+    }
   );
   out = out.replace(
     /import\s*\*\s*as\s*([A-Za-z_$][\w$]*)\s*from\s*(['"][^'"]*['"])[ \t]*;?/g,
@@ -3575,31 +3629,76 @@ function transformModule(code) {
     /import\s+([A-Za-z_$][\w$]*)\s+from\s*(['"][^'"]*['"])[ \t]*;?/g,
     (_match, name, source) => `const ${name} = require(${source})`
   );
+  out = out.replace(
+    /(^|\n)([ \t]*)import\s*(['"][^'"]*['"])[ \t]*;?/g,
+    (_match, lead, indent, source) => `${lead}${indent}require(${source})`
+  );
+  out = out.replace(
+    /(^|\n)([ \t]*)export\s*\{([^}]*)\}[ \t]*(?:\n[ \t]*(?=from\b))?(?:from\s*(['"][^'"]*['"]))?[ \t]*;?/g,
+    (matched, lead, indent, clause, source) => {
+      const pad = keepLineCount(matched, lead);
+      const entries = parseExportClause(clause);
+      if (entries.length === 0) return `${lead}${indent}${pad}`;
+      if (source === void 0) {
+        named.push(...entries);
+        return `${lead}${indent}${pad}`;
+      }
+      const temp = nextTemp();
+      for (const entry of entries) {
+        named.push({ local: `${temp}.${entry.local}`, exported: entry.exported });
+      }
+      return `${lead}${indent}const ${temp} = require(${source})${pad}`;
+    }
+  );
+  out = out.replace(
+    /(^|\n)([ \t]*)export\s*\*[ \t]*(?:as[ \t]+([A-Za-z_$][\w$]*)[ \t]*)?\s*from\s*(['"][^'"]*['"])[ \t]*;?/g,
+    (matched, lead, indent, ns, source) => {
+      const pad = keepLineCount(matched, lead);
+      const temp = nextTemp();
+      if (ns === void 0) starReexports.push(temp);
+      else named.push({ local: temp, exported: ns });
+      return `${lead}${indent}const ${temp} = require(${source})${pad}`;
+    }
+  );
   out = out.replace(
     /export\s+(const|let|var)\s+([A-Za-z_$][\w$]*)/g,
     (_match, kw, name) => {
-      named.push(name);
+      named.push({ local: name, exported: 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);
+      named.push({ local: name, exported: name });
       return `${asyncKw ?? ""}function ${name}`;
     }
   );
   out = out.replace(/export\s+class\s+([A-Za-z_$][\w$]*)/g, (_match, name) => {
-    named.push(name);
+    named.push({ local: name, exported: name });
     return `class ${name}`;
   });
-  if (named.length > 0) {
+  for (const temp of starReexports) {
+    out += `
+;Object.keys(${temp}).forEach((k) => { if (k !== 'default') exports[k] = ${temp}[k] })`;
+  }
+  const byExported = /* @__PURE__ */ new Map();
+  for (const entry of named) byExported.set(entry.exported, entry.local);
+  if (byExported.size > 0) {
+    const picks = [...byExported].map(
+      ([exported, local]) => local === exported ? exported : `${exported}: ${local}`
+    );
     out += `
-;Object.assign(exports, { ${named.join(", ")} })`;
+;Object.assign(exports, { ${picks.join(", ")} })`;
   }
   return out;
 }
 
+// packages/runtime/src/shared/regexp.ts
+function escapeRegExp(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
 // packages/runtime/src/functions/runtime/sandbox.ts
 var bunTranspiler;
 function transpile(code) {
@@ -3618,6 +3717,29 @@ function transformExports(code) {
   return transformModule(code);
 }
 var SANDBOX_BUILTIN_REJECTED = "FN_SANDBOX_BUILTIN_BLOCKED";
+var REALM_VALUE_KEY = "__adepRealmValue";
+function realmValue(value) {
+  return { [REALM_VALUE_KEY]: value };
+}
+function isRealmValue(value) {
+  return typeof value === "object" && value !== null && REALM_VALUE_KEY in value;
+}
+function createSandboxContext(sandboxGlobals) {
+  const direct = {};
+  const realmEntries = {};
+  for (const [key, value] of Object.entries(sandboxGlobals)) {
+    if (isRealmValue(value)) realmEntries[key] = value[REALM_VALUE_KEY];
+    else direct[key] = value;
+  }
+  const context = vm.createContext(direct, { codeGeneration: { strings: false, wasm: false } });
+  if (Object.keys(realmEntries).length > 0) {
+    const literal = JSON.stringify(JSON.stringify(realmEntries));
+    vm.runInContext(`Object.assign(globalThis, JSON.parse(${literal}))`, context, {
+      filename: "<sandbox-realm-globals>"
+    });
+  }
+  return context;
+}
 function resolveModulePath(fromDir, request, files) {
   if (!request.startsWith("./") && !request.startsWith("../")) return null;
   const base = joinPosix(fromDir, request);
@@ -3641,6 +3763,21 @@ function joinPosix(dir, request) {
 function normalizePosix(p) {
   return joinPosix("", p);
 }
+function errorLineIn(stack, path) {
+  const own = new RegExp(`${escapeRegExp(path)}:(\\d+)`).exec(stack);
+  if (own !== null) return own[1];
+  return /(?:^|\n):(\d+)(?:\n|$)/.exec(stack)?.[1];
+}
+function syntaxErrorWithLocation(error, path) {
+  const rawMessage = error instanceof Error ? error.message : String(error);
+  const stack = error.stack;
+  const line = typeof stack === "string" ? errorLineIn(stack, path) : 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;
+  return wrapped;
+}
 function loadModule(path, files, sandboxGlobals, cache, resolveBare, bareCache) {
   const cached = cache.get(path);
   if (cached !== void 0) return cached;
@@ -3674,21 +3811,20 @@ function loadModule(path, files, sandboxGlobals, cache, resolveBare, bareCache)
   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} 
+    throw syntaxErrorWithLocation(error, path);
+  }
+  const context = createSandboxContext(sandboxGlobals);
+  let wrapper;
+  try {
+    wrapper = vm.runInContext(
+      `(function (module, exports, require) { ${transformed} 
 })`,
-    vm.createContext({ ...sandboxGlobals }),
-    { filename: path }
-  );
+      context,
+      { filename: path }
+    );
+  } catch (error) {
+    throw syntaxErrorWithLocation(error, path);
+  }
   wrapper(module, exports, require2);
   if (module.default !== void 0 && exports["default"] === void 0) {
     exports["default"] = module.default;
@@ -3863,6 +3999,8 @@ var SandboxFetchError = class extends Error {
   }
 };
 var DEFAULT_MAX_RESPONSE_BYTES = 100 * 1024 * 1024;
+var DEFAULT_MAX_REDIRECTS = 5;
+var REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
 var defaultFetch = (url, init) => (
   // 真实 Response 与内部 ResponseLike 结构性一致；getReader 的多态签名差异属纯类型问题，运行语义等价。
   globalThis.fetch(url, init)
@@ -3901,18 +4039,24 @@ function headersToRecord(headers) {
   }
   return out;
 }
-function contentLength(res) {
-  const headers = res.headers;
+function headerValue(headers, name) {
   if (headers === void 0 || headers === null) return null;
+  let raw;
   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;
+    raw = headers.get?.(name);
+  } else {
+    const record = headers;
+    raw = record[name.toLocaleLowerCase()] ?? record[name];
+  }
+  if (raw === void 0 || raw === null || raw.trim() === "") return null;
+  return raw;
+}
+function contentLength(res) {
+  const raw = headerValue(
+    res.headers,
+    "content-length"
+  );
+  if (raw === null) return null;
   const n = Number(raw);
   return Number.isFinite(n) && n >= 0 ? n : null;
 }
@@ -3992,44 +4136,72 @@ function createSandboxFetch(options) {
   const fetchImpl = options.fetchImpl ?? defaultFetch;
   const { allowlist, timeoutMs } = options;
   const maxBytes = options.maxResponseBytes ?? DEFAULT_MAX_RESPONSE_BYTES;
-  return async (url, init) => {
+  const maxRedirects = Math.max(0, options.maxRedirects ?? DEFAULT_MAX_REDIRECTS);
+  const guard = (raw) => {
     let parsed;
     try {
-      parsed = new URL(url);
+      parsed = new URL(raw);
     } catch {
-      throw new SandboxFetchError("FN_FETCH_INVALID_URL", `cloud.fetch \u6536\u5230\u975E\u6CD5 URL"${url}"`);
+      throw new SandboxFetchError("FN_FETCH_INVALID_URL", `cloud.fetch \u6536\u5230\u975E\u6CD5 URL"${raw}"`);
     }
-    if (parsed.protocol !== "https:" && parsed.protocol !== "http:") throw FORBIDDEN(url);
-    if (!isHostAllowed(parsed.hostname, allowlist)) throw FORBIDDEN(url);
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:") throw FORBIDDEN(raw);
+    if (!isHostAllowed(parsed.hostname, allowlist)) throw FORBIDDEN(raw);
+    return parsed;
+  };
+  const fetchOnce = async (url, init) => {
     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);
+    const request = {
+      ...init,
+      signal,
+      redirect: "manual"
+    };
     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 await fetchImpl(url, request);
+    } 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");
       }
-      return normalizeResponse(res, maxBytes);
+      throw new SandboxFetchError(
+        "FN_FETCH_FAILED",
+        `cloud.fetch \u8BF7\u6C42\u5931\u8D25\uFF1A${errorMessageOf(error)}`
+      );
     } finally {
       clearTimeout(timer);
     }
   };
+  return async (url, init) => {
+    let target = guard(url);
+    let currentInit = init === void 0 ? void 0 : { ...init };
+    let lastRes = null;
+    for (let hop = 0; hop <= maxRedirects; hop++) {
+      const res = await fetchOnce(target.href, currentInit);
+      const location = REDIRECT_STATUSES.has(res.status) ? headerValue(res.headers, "location") : null;
+      if (location === null || hop === maxRedirects) {
+        lastRes = res;
+        break;
+      }
+      let next;
+      try {
+        next = new URL(location, target.href);
+      } catch {
+        lastRes = res;
+        break;
+      }
+      if (res.status !== 307 && res.status !== 308 && currentInit !== void 0) {
+        currentInit.method = "GET";
+        delete currentInit.body;
+      }
+      target = guard(next.href);
+    }
+    return normalizeResponse(lastRes, maxBytes);
+  };
 }
 
 // packages/runtime/src/functions/runtime/flat-rpc-proxy.ts
@@ -4158,11 +4330,6 @@ function createChainClient(capability, port, pending, nextId, spec) {
   return makeRoot(void 0);
 }
 
-// packages/runtime/src/shared/regexp.ts
-function escapeRegExp(text) {
-  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
 // packages/runtime/src/functions/runtime/worker-entry.ts
 function errorMessageOf2(error) {
   if (error instanceof Error) return error.message;
@@ -4172,12 +4339,35 @@ function errorMessageOf2(error) {
   }
   return String(error);
 }
+async function normalizeResultBody(value) {
+  if (!(value instanceof Response)) return value;
+  const contentType = value.headers.get("content-type") ?? "";
+  const text = await value.text();
+  let payload = text;
+  if (contentType.includes("application/json")) {
+    try {
+      payload = text === "" ? null : JSON.parse(text);
+    } catch {
+      payload = text;
+    }
+  }
+  const headers = {};
+  value.headers.forEach((headerValue2, key) => {
+    headers[key] = headerValue2;
+  });
+  return { __adepHttp: { status: value.status, body: payload, headers } };
+}
 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) {
+  const patterns = Object.keys(files).map(
+    (key) => [
+      key,
+      new RegExp(`(?<![\\w$/.])${escapeRegExp(key)}:(\\d+)(?::(\\d+))?(?::(\\d+))?`)
+    ]
+  );
+  for (const line of stack.split("\n")) {
+    for (const [key, pattern] of patterns) {
+      const match = pattern.exec(line);
+      if (match === null) continue;
       return match[2] === void 0 ? `${key}:${match[1]}` : `${key}:${match[1]}:${match[2]}`;
     }
   }
@@ -4188,7 +4378,8 @@ function errorMessageWithLocation(error, files) {
   const stack = error.stack;
   if (typeof stack !== "string") return message;
   const frame = firstUserFrame(stack, files);
-  return frame === void 0 ? message : `${message}\uFF08${frame}\uFF09`;
+  if (frame === void 0 || message.includes(`\uFF08${frame}\uFF09`)) return message;
+  return `${message}\uFF08${frame}\uFF09`;
 }
 function createBareResolver(deps) {
   const platformRequire = createRequire(import.meta.url);
@@ -4269,7 +4460,7 @@ function runWorker(input, port) {
     structuredClone
   };
   if (input.env !== void 0) {
-    sandboxGlobals["process"] = { env: input.env };
+    sandboxGlobals["process"] = realmValue({ env: input.env });
   }
   if (input.fetch !== void 0) {
     const sandboxFetch = createSandboxFetch({
@@ -4301,8 +4492,20 @@ function runWorker(input, port) {
     const result = Promise.resolve(handler(ctx));
     void result.then(
       (value) => {
-        port.postMessage({ type: "result", body: value === void 0 ? null : value });
-        return void 0;
+        return normalizeResultBody(value).then(
+          (body) => {
+            port.postMessage({ type: "result", body: body === void 0 ? null : body });
+            return void 0;
+          },
+          (error) => {
+            port.postMessage({
+              type: "error",
+              message: `\u51FD\u6570\u8FD4\u56DE\u7684 Response \u89E3\u5305\u5931\u8D25\uFF1A${errorMessageOf2(error)}`,
+              code: "FN_RESPONSE_UNWRAP_FAILED"
+            });
+            return void 0;
+          }
+        );
       },
       (error) => {
         port.postMessage({