@qwen-code/qwen-code 0.23.5-preview.0 → 0.24.0

package/chunks/{chunk-PPJSG2PU.js → chunk-EVZT24AF.js}

@@ -1,14 +1,17 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  resolveNetworkTarget
+} from "./chunk-6C3D7BKK.js";
 import {
   isPrivateHost
-} from "./chunk-3WILPKTJ.js";
+} from "./chunk-KKPIFWTZ.js";
 import {
   loadUndici
-} from "./chunk-7O5PYQ3M.js";
+} from "./chunk-SBP43AO6.js";
 import {
   getErrorMessage
-} from "./chunk-ZAFYHRVY.js";
+} from "./chunk-S34QJ6IR.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -18,144 +21,6 @@ import {
 
 // packages/core/src/services/image-generation-service.ts
 init_esbuild_shims();
-
-// packages/core/src/extension/network-policy.ts
-init_esbuild_shims();
-import { promises as dns } from "node:dns";
-import { BlockList, isIP } from "node:net";
-var blockedAddresses = new BlockList();
-var publicIpv6Addresses = new BlockList();
-publicIpv6Addresses.addSubnet("2000::", 3, "ipv6");
-for (const [address, prefix] of [
-  ["0.0.0.0", 8],
-  ["10.0.0.0", 8],
-  ["100.64.0.0", 10],
-  ["127.0.0.0", 8],
-  ["169.254.0.0", 16],
-  ["172.16.0.0", 12],
-  ["192.0.0.0", 24],
-  ["192.0.2.0", 24],
-  ["192.88.99.0", 24],
-  ["192.168.0.0", 16],
-  ["198.18.0.0", 15],
-  ["198.51.100.0", 24],
-  ["203.0.113.0", 24],
-  ["224.0.0.0", 4],
-  ["240.0.0.0", 4]
-]) {
-  blockedAddresses.addSubnet(address, prefix, "ipv4");
-}
-for (const [address, prefix] of [
-  ["2001::", 23],
-  ["2001:db8::", 32],
-  ["2002::", 16],
-  ["3fff::", 20]
-]) {
-  blockedAddresses.addSubnet(address, prefix, "ipv6");
-}
-async function waitForAbortable(promise, signal) {
-  if (!signal) return await promise;
-  signal.throwIfAborted();
-  return await new Promise((resolve, reject) => {
-    let settled = false;
-    const finish = /* @__PURE__ */ __name((callback) => {
-      if (settled) return;
-      settled = true;
-      signal.removeEventListener("abort", onAbort);
-      callback();
-    }, "finish");
-    const onAbort = /* @__PURE__ */ __name(() => finish(() => reject(signal.reason)), "onAbort");
-    signal.addEventListener("abort", onAbort, { once: true });
-    if (signal.aborted) {
-      onAbort();
-      return;
-    }
-    promise.then(
-      (value) => finish(() => resolve(value)),
-      (error) => finish(() => reject(error))
-    );
-  });
-}
-__name(waitForAbortable, "waitForAbortable");
-function stripIpv6Brackets(hostname) {
-  return hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
-}
-__name(stripIpv6Brackets, "stripIpv6Brackets");
-function parseMappedIpv4(address) {
-  const suffix = address.toLowerCase().slice("::ffff:".length);
-  if (isIP(suffix) === 4) return suffix;
-  const parts = suffix.split(":");
-  if (parts.length !== 2 || parts.some((part) => !/^[\da-f]{1,4}$/.test(part))) {
-    return void 0;
-  }
-  const upper = Number.parseInt(parts[0], 16);
-  const lower = Number.parseInt(parts[1], 16);
-  return `${upper >> 8}.${upper & 255}.${lower >> 8}.${lower & 255}`;
-}
-__name(parseMappedIpv4, "parseMappedIpv4");
-function isBlockedAddress(address, family) {
-  if (family === 6 && address.toLowerCase().startsWith("::ffff:")) {
-    const mapped = parseMappedIpv4(address);
-    return mapped === void 0 || isBlockedAddress(mapped, 4);
-  }
-  if (family === 6 && !publicIpv6Addresses.check(address, "ipv6")) return true;
-  return blockedAddresses.check(address, family === 6 ? "ipv6" : "ipv4");
-}
-__name(isBlockedAddress, "isBlockedAddress");
-async function resolveNetworkTarget(value, policy, signal) {
-  signal?.throwIfAborted();
-  const url = value instanceof URL ? value : new URL(value);
-  if (policy !== "public") return { url };
-  if (url.protocol !== "https:") {
-    throw new Error("Public extension network requests must use HTTPS.");
-  }
-  if (url.username || url.password) {
-    throw new Error(
-      "Public extension network requests must not use credentials."
-    );
-  }
-  const hostname = stripIpv6Brackets(url.hostname);
-  const literalFamily = isIP(hostname);
-  const addresses = literalFamily ? [{ address: hostname, family: literalFamily }] : await waitForAbortable(
-    dns.lookup(hostname, { all: true, verbatim: true }),
-    signal
-  );
-  if (addresses.length === 0) {
-    throw new Error(`Extension network host did not resolve: ${hostname}`);
-  }
-  if (addresses.some(({ address, family }) => isBlockedAddress(address, family))) {
-    throw new Error(
-      `Extension network host resolved to a blocked address: ${hostname}`
-    );
-  }
-  const selected = addresses[0];
-  const lookup = /* @__PURE__ */ __name((requestedHostname, options, callback) => {
-    if (stripIpv6Brackets(requestedHostname) !== hostname) {
-      const error = new Error(
-        "Pinned extension lookup hostname mismatch"
-      );
-      error.code = "ENOTFOUND";
-      callback(error, "", 0);
-      return;
-    }
-    if (options.all) {
-      callback(null, [selected]);
-    } else {
-      callback(null, selected.address, selected.family);
-    }
-  }, "lookup");
-  const port = url.port || "443";
-  const curlHostname = literalFamily === 6 ? `[${hostname}]` : hostname;
-  const curlAddress = selected.family === 6 ? `[${selected.address}]` : selected.address;
-  return {
-    url,
-    lookup,
-    curlResolve: `${curlHostname}:${port}:${curlAddress}`
-  };
-}
-__name(resolveNetworkTarget, "resolveNetworkTarget");
-
-// packages/core/src/services/image-generation-service.ts
 var GENERATION_TIMEOUT_MS = 24e4;
 var DOWNLOAD_TIMEOUT_MS = 12e4;
 var MAX_API_RESPONSE_BYTES = 1024 * 1024;
@@ -609,7 +474,6 @@ function isRecord(value) {
 __name(isRecord, "isRecord");
 
 export {
-  resolveNetworkTarget,
   normalizeImageGenerationBaseUrl,
   generateImage
 };

package/chunks/{chunk-E2VSBAFA.js → chunk-FL2EJUOY.js}

@@ -5,26 +5,26 @@ import {
 } from "./chunk-57OAHC2Y.js";
 import {
   loadSettings
-} from "./chunk-RRI764F7.js";
+} from "./chunk-VPFKSRAB.js";
 import {
   getCurrentLanguage,
   t
-} from "./chunk-GSAOVDTH.js";
+} from "./chunk-POMFSBEC.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-NQ272MQG.js";
+} from "./chunk-5XK2YELE.js";
 import {
   ExtensionManager,
   getExtensionDescription,
   getExtensionDisplayName,
   require_prompts
-} from "./chunk-KAYC5FBN.js";
+} from "./chunk-SNPYTKXI.js";
 import {
   stripAnsi
 } from "./chunk-TWPJO254.js";
 import {
   redactUrlCredentials
-} from "./chunk-6USYH3EU.js";
+} from "./chunk-B3XJFEEH.js";
 import {
   writeStdoutLine
 } from "./chunk-7FA2II6K.js";

package/chunks/{chunk-2C5TR6HN.js → chunk-FSNLTHNG.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-LYD3T3H7.js";
 import {
   MissingCliEntryError
-} from "./chunk-M23GFJ5B.js";
+} from "./chunk-EHMLJKF5.js";
 import {
   AcpChildCapacityExceededError
 } from "./chunk-YXHY6BKS.js";

package/chunks/chunk-FTKXJMQV.js

@@ -0,0 +1,255 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  hashFileSha256
+} from "./chunk-S5BHLTHK.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/omni/storage.ts
+init_esbuild_shims();
+import { createHash, randomBytes } from "node:crypto";
+import { createReadStream, createWriteStream } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { pipeline } from "node:stream/promises";
+var INVOCATION_ID_RE = /^[0-9a-f]{16}$/;
+var OBJECT_EXTENSION_RE = /^\.[A-Za-z0-9]{1,8}$/;
+function assertInvocationId(invocationId) {
+  if (!INVOCATION_ID_RE.test(invocationId)) {
+    throw new Error(`Invalid omni policy invocation id: ${invocationId}`);
+  }
+}
+__name(assertInvocationId, "assertInvocationId");
+async function assertRealDirIfExists(p) {
+  let st;
+  try {
+    st = await fs.lstat(p);
+  } catch {
+    return;
+  }
+  if (st.isSymbolicLink() || !st.isDirectory()) {
+    throw new Error(
+      `Omni object store path is not a real directory (symlink or special file refused): ${p}`
+    );
+  }
+}
+__name(assertRealDirIfExists, "assertRealDirIfExists");
+async function prepareOmniDownloadsDir(downloadsDir) {
+  await fs.mkdir(downloadsDir, { recursive: true, mode: 448 });
+  const st = await fs.lstat(downloadsDir);
+  if (st.isSymbolicLink() || !st.isDirectory()) {
+    throw new Error(
+      `Omni downloads path is not a real directory (symlink or special file refused): ${downloadsDir}`
+    );
+  }
+  return downloadsDir;
+}
+__name(prepareOmniDownloadsDir, "prepareOmniDownloadsDir");
+var OmniObjectStore = class {
+  static {
+    __name(this, "OmniObjectStore");
+  }
+  omniRoot;
+  layoutReady;
+  /** @param qwenDir Absolute path of the project `.qwen` directory. */
+  constructor(qwenDir) {
+    this.omniRoot = path.join(qwenDir, "omni");
+  }
+  getOmniRootDir() {
+    return this.omniRoot;
+  }
+  getObjectsDir() {
+    return path.join(this.omniRoot, "objects", "sha256");
+  }
+  /** Root of the policy-invocation work area (stale entries deleted by
+   * startup recovery — anything past the grace window belongs to an
+   * uncommitted, crashed run). */
+  getStagingDir() {
+    return path.join(this.omniRoot, "staging");
+  }
+  /** Root of the failed-invocation debris area, kept for debugging under
+   * a retention/size budget and never re-entering recognition/delivery. */
+  getQuarantineDir() {
+    return path.join(this.omniRoot, "quarantine");
+  }
+  /**
+   * Compute the final object path for a content hash + extension.
+   *
+   * Both components are validated here, not just at putFile: callers may
+   * feed values read back from on-disk cache files (policy-cache.json),
+   * and a crafted hash or extension ("/../../…") would otherwise turn
+   * this join into a path-traversal primitive pointing outside the store.
+   */
+  objectPathFor(sha256, extension) {
+    if (!/^[0-9a-f]{64}$/.test(sha256)) {
+      throw new Error(`invalid object hash: ${JSON.stringify(sha256)}`);
+    }
+    if (!OBJECT_EXTENSION_RE.test(extension)) {
+      throw new Error(`invalid object extension: ${JSON.stringify(extension)}`);
+    }
+    return path.join(
+      this.getObjectsDir(),
+      sha256.slice(0, 2),
+      `${sha256}${extension}`
+    );
+  }
+  /**
+   * Ensure the directory layout and the self-ignoring .gitignore exist.
+   * Idempotent and shared across concurrent callers. Refuses symlinked
+   * store directories.
+   */
+  ensureLayout() {
+    this.layoutReady ??= (async () => {
+      await assertRealDirIfExists(this.omniRoot);
+      await assertRealDirIfExists(path.join(this.omniRoot, "objects"));
+      await assertRealDirIfExists(this.getObjectsDir());
+      await assertRealDirIfExists(this.getStagingDir());
+      await assertRealDirIfExists(this.getQuarantineDir());
+      await fs.mkdir(this.getObjectsDir(), { recursive: true, mode: 448 });
+      await fs.mkdir(this.getStagingDir(), { recursive: true, mode: 448 });
+      await fs.mkdir(this.getQuarantineDir(), {
+        recursive: true,
+        mode: 448
+      });
+      const gitignorePath = path.join(this.omniRoot, ".gitignore");
+      try {
+        await fs.writeFile(gitignorePath, "*\n", { flag: "wx" });
+      } catch (err) {
+        if (err.code !== "EEXIST") {
+          throw err;
+        }
+      }
+    })().catch((err) => {
+      this.layoutReady = void 0;
+      throw err;
+    });
+    return this.layoutReady;
+  }
+  /**
+   * Create the exclusive work directory for one policy invocation and
+   * return its absolute path. The directory is the ONLY location the
+   * policy tool is allowed to write to (storage design §4.3). Creation is
+   * non-recursive and exclusive: a pre-existing entry (id collision or a
+   * planted path) fails instead of being silently reused.
+   */
+  async createStagingDir(invocationId) {
+    assertInvocationId(invocationId);
+    await this.ensureLayout();
+    const dir = path.join(this.getStagingDir(), invocationId);
+    await fs.mkdir(dir, { mode: 448 });
+    return dir;
+  }
+  /**
+   * Delete one invocation's staging directory (after a successful commit,
+   * or as the failure path while quarantine is not involved).
+   */
+  async removeStagingDir(invocationId) {
+    assertInvocationId(invocationId);
+    await fs.rm(path.join(this.getStagingDir(), invocationId), {
+      recursive: true,
+      force: true
+    });
+  }
+  /**
+   * Move a failed invocation's staging directory into
+   * `quarantine/<invocationId>/`, preserving the artifact files and adding
+   * a `reason.json` (storage design §4.4). The reason file is written into
+   * the staging directory BEFORE the rename so the quarantine entry appears
+   * complete in one atomic step; a crash in between leaves it in staging,
+   * which startup recovery deletes once past the grace window.
+   */
+  async quarantineInvocation(invocationId, reason) {
+    assertInvocationId(invocationId);
+    await this.ensureLayout();
+    const stagingDir = path.join(this.getStagingDir(), invocationId);
+    const st = await fs.lstat(stagingDir);
+    if (st.isSymbolicLink() || !st.isDirectory()) {
+      throw new Error(
+        `Staging path is not a real directory (symlink or special file refused): ${stagingDir}`
+      );
+    }
+    await fs.writeFile(
+      path.join(stagingDir, "reason.json"),
+      JSON.stringify(
+        { ...reason, failedAt: (/* @__PURE__ */ new Date()).toISOString() },
+        null,
+        2
+      ),
+      { mode: 384 }
+    );
+    const quarantineDir = path.join(this.getQuarantineDir(), invocationId);
+    await fs.rename(stagingDir, quarantineDir);
+    return quarantineDir;
+  }
+  /**
+   * Promote a local file into the object store under its content hash.
+   * The bytes are re-hashed while copying and verified against `sha256`,
+   * so a source file that changed since the caller hashed it (TOCTOU)
+   * fails closed instead of poisoning the immutable store.
+   */
+  async putFile(sourcePath, sha256, extension, signal) {
+    if (!/^[0-9a-f]{64}$/.test(sha256)) {
+      throw new Error(`Invalid sha256 object key: ${sha256}`);
+    }
+    await this.ensureLayout();
+    const objectPath = this.objectPathFor(sha256, extension);
+    const objectDir = path.dirname(objectPath);
+    await assertRealDirIfExists(objectDir);
+    const existing = await fs.lstat(objectPath).catch(() => void 0);
+    if (existing) {
+      if (existing.isFile() && !existing.isSymbolicLink()) {
+        const existingHash = await hashFileSha256(objectPath, signal);
+        if (existingHash === sha256) {
+          const now = /* @__PURE__ */ new Date();
+          await fs.utimes(objectPath, now, now).catch(() => {
+          });
+          return { objectPath, deduped: true };
+        }
+      }
+      await fs.rm(objectPath, { force: true, recursive: true });
+    }
+    await fs.mkdir(objectDir, { recursive: true, mode: 448 });
+    const tmpPath = path.join(
+      objectDir,
+      `.tmp-${randomBytes(8).toString("hex")}`
+    );
+    try {
+      const hash = createHash("sha256");
+      const source = createReadStream(sourcePath, signal ? { signal } : {});
+      source.on("data", (chunk) => hash.update(chunk));
+      await pipeline(source, createWriteStream(tmpPath, { mode: 384 }));
+      const actual = hash.digest("hex");
+      if (actual !== sha256) {
+        throw new Error(
+          `Source content changed while storing (expected sha256 ${sha256.slice(0, 12)}\u2026, got ${actual.slice(0, 12)}\u2026). Retry the read.`
+        );
+      }
+      await fs.rename(tmpPath, objectPath);
+    } catch (err) {
+      await fs.rm(tmpPath, { force: true });
+      if (signal?.aborted) throw err;
+      const winner = await fs.lstat(objectPath).catch(() => void 0);
+      if (winner?.isFile() && !winner.isSymbolicLink() && await hashFileSha256(objectPath, signal).catch(() => void 0) === sha256) {
+        return { objectPath, deduped: true };
+      }
+      throw err;
+    }
+    return { objectPath, deduped: false };
+  }
+};
+
+export {
+  OBJECT_EXTENSION_RE,
+  prepareOmniDownloadsDir,
+  OmniObjectStore
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-TRZ22SG5.js → chunk-FXPP7VLM.js}

@@ -2,16 +2,18 @@
 "use strict";
 import {
   isWithinRoot
-} from "./chunk-5NUKK2DT.js";
+} from "./chunk-25FMWESU.js";
 import {
   BaseDeclarativeTool,
-  BaseToolInvocation,
+  BaseToolInvocation
+} from "./chunk-VPGRGNNH.js";
+import {
   ToolDisplayNames,
   ToolNames
-} from "./chunk-RSWBT7AZ.js";
+} from "./chunk-ERIBG3BX.js";
 import {
   isNodeError
-} from "./chunk-ZAFYHRVY.js";
+} from "./chunk-S34QJ6IR.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";