@qwen-code/qwen-code 0.22.2-preview.1 → 0.22.2

package/chunks/{chunk-TMGAS5TO.js → chunk-SJ3ZUWFK.js}

@@ -3,17 +3,17 @@
 import {
   getGitVersion,
   getNpmVersion
-} from "./chunk-ATLGYSYH.js";
+} from "./chunk-RJC5EIKY.js";
 import {
   buildEnvStatusFromEnv,
   snapshotProcessEnv
-} from "./chunk-UCQOSV6A.js";
+} from "./chunk-IOPCFOTF.js";
 import {
   mapDomainErrorToErrorKind
-} from "./chunk-XUX6O2ZT.js";
+} from "./chunk-JHS74YAB.js";
 import {
   canUseRipgrep
-} from "./chunk-77TOMRBG.js";
+} from "./chunk-43GGFFLY.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -24,6 +24,23 @@ import {
 // packages/cli/src/serve/daemon-status-provider.ts
 init_esbuild_shims();
 import { promises as fs } from "node:fs";
+
+// packages/acp-bridge/src/index.ts
+init_esbuild_shims();
+
+// packages/acp-bridge/src/inMemoryChannel.ts
+init_esbuild_shims();
+
+// packages/acp-bridge/src/channel.ts
+init_esbuild_shims();
+
+// packages/acp-bridge/src/prompt-ledger.ts
+init_esbuild_shims();
+
+// packages/acp-bridge/src/bridgeFileSystem.ts
+init_esbuild_shims();
+
+// packages/cli/src/serve/daemon-status-provider.ts
 var REQUIRED_NODE_MAJOR = 22;
 function createDaemonStatusProvider(options = {}) {
   const readEnv = /* @__PURE__ */ __name(() => options.env ?? snapshotProcessEnv(), "readEnv");
@@ -201,3 +218,8 @@ export {
  * Copyright 2025 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-DEYPMJPD.js → chunk-SMPR7SPO.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-2NNTE2ED.js";
+} from "./chunk-UHQFIS7N.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-7CWEZQ6T.js → chunk-STUJ7IMZ.js}

@@ -1,8 +1,5 @@
 // Force strict mode and setup for ESM
 "use strict";
-import {
-  CHANNEL_DELIVERY_ERROR_CODES
-} from "./chunk-UDG5EZJI.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -58,72 +55,6 @@ function isChannelWebhookTaskResultMessage(value) {
 }
 __name(isChannelWebhookTaskResultMessage, "isChannelWebhookTaskResultMessage");
 
-// packages/cli/src/runtime/channel-delivery-ipc.ts
-init_esbuild_shims();
-import { randomUUID as randomUUID2 } from "node:crypto";
-var ChannelDeliveryError = class extends Error {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "ChannelDeliveryError";
-  }
-  static {
-    __name(this, "ChannelDeliveryError");
-  }
-};
-function isChannelDeliveryErrorCode(value) {
-  return typeof value === "string" && CHANNEL_DELIVERY_ERROR_CODES.has(value);
-}
-__name(isChannelDeliveryErrorCode, "isChannelDeliveryErrorCode");
-function isChannelDeliveryError(value) {
-  return value instanceof ChannelDeliveryError || typeof value === "object" && value !== null && isChannelDeliveryErrorCode(value.code) && typeof value.message === "string";
-}
-__name(isChannelDeliveryError, "isChannelDeliveryError");
-var CHANNEL_DELIVERY_IPC_TIMEOUT_MS = 3e4;
-var MAX_CHANNEL_DELIVERIES_IN_FLIGHT = 16;
-var MAX_CHANNEL_DELIVERY_TEXT_LENGTH = 1e5;
-function createChannelDeliveryMessage(request) {
-  return {
-    type: "channel_delivery",
-    id: randomUUID2(),
-    expiresAt: Date.now() + CHANNEL_DELIVERY_IPC_TIMEOUT_MS,
-    request
-  };
-}
-__name(createChannelDeliveryMessage, "createChannelDeliveryMessage");
-function isNonEmptyString(value) {
-  return typeof value === "string" && value.trim().length > 0;
-}
-__name(isNonEmptyString, "isNonEmptyString");
-function isChannelDeliveryTarget(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const target = value;
-  return (target["type"] === "user" || target["type"] === "chat") && isNonEmptyString(target["id"]) && Object.keys(target).every((key) => key === "type" || key === "id");
-}
-__name(isChannelDeliveryTarget, "isChannelDeliveryTarget");
-function isChannelDeliveryRequest(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const request = value;
-  return isNonEmptyString(request["deliveryId"]) && isNonEmptyString(request["channelName"]) && isChannelDeliveryTarget(request["target"]) && isNonEmptyString(request["text"]) && request["text"].length <= MAX_CHANNEL_DELIVERY_TEXT_LENGTH;
-}
-__name(isChannelDeliveryRequest, "isChannelDeliveryRequest");
-function isChannelDeliveryMessage(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const message = value;
-  return message["type"] === "channel_delivery" && isNonEmptyString(message["id"]) && typeof message["expiresAt"] === "number" && Number.isFinite(message["expiresAt"]) && isChannelDeliveryRequest(message["request"]);
-}
-__name(isChannelDeliveryMessage, "isChannelDeliveryMessage");
-function isChannelDeliveryResultMessage(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const message = value;
-  if (message["type"] !== "channel_delivery_result" || !isNonEmptyString(message["id"]) || typeof message["ok"] !== "boolean") {
-    return false;
-  }
-  if (message["ok"]) return true;
-  return isChannelDeliveryErrorCode(message["code"]) && typeof message["error"] === "string";
-}
-__name(isChannelDeliveryResultMessage, "isChannelDeliveryResultMessage");
-
 // packages/cli/src/serve/channel-worker-startup-ipc.ts
 init_esbuild_shims();
 var MAX_CHANNEL_STARTUP_FAILURES = 64;
@@ -205,14 +136,6 @@ export {
   createChannelWebhookTaskMessage,
   isChannelWebhookTaskMessage,
   isChannelWebhookTaskResultMessage,
-  ChannelDeliveryError,
-  isChannelDeliveryError,
-  CHANNEL_DELIVERY_IPC_TIMEOUT_MS,
-  MAX_CHANNEL_DELIVERIES_IN_FLIGHT,
-  MAX_CHANNEL_DELIVERY_TEXT_LENGTH,
-  createChannelDeliveryMessage,
-  isChannelDeliveryMessage,
-  isChannelDeliveryResultMessage,
   MAX_CHANNEL_STARTUP_FAILURES,
   MAX_CHANNEL_STARTUP_FAILURE_CHANNEL_LENGTH,
   MAX_CHANNEL_STARTUP_FAILURE_CODE_LENGTH,

package/chunks/{chunk-BPMVPWBT.js → chunk-T32W2JHI.js}

@@ -16,7 +16,7 @@ import {
   MODIFIER_SHIFT_BIT,
   MODIFIER_SUPER_BIT,
   clipboardHasImage
-} from "./chunk-2FN2HNTI.js";
+} from "./chunk-FDY5RMGH.js";
 import {
   require_jsx_runtime
 } from "./chunk-SV5PQVQE.js";
@@ -24,19 +24,19 @@ import {
   use_stdin_default,
   use_stdout_default
 } from "./chunk-5Q372OFJ.js";
-import {
-  noteInteraction
-} from "./chunk-KW7NOTN6.js";
 import {
   require_react
 } from "./chunk-5QWWOFGG.js";
+import {
+  noteInteraction
+} from "./chunk-KW7NOTN6.js";
 import {
   KittySequenceOverflowEvent,
   logKittySequenceOverflow
-} from "./chunk-OF2DPXUS.js";
+} from "./chunk-L2M46FP5.js";
 import {
   createDebugLogger
-} from "./chunk-2NNTE2ED.js";
+} from "./chunk-UHQFIS7N.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/chunk-T3WXYEZ4.js

@@ -0,0 +1,304 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/utils/conversation-directory-identity.ts
+init_esbuild_shims();
+import { createHash } from "node:crypto";
+import { lstat, mkdir, realpath } from "node:fs/promises";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+function hasVerifiableInode(ino) {
+  return Number(ino) !== 0;
+}
+__name(hasVerifiableInode, "hasVerifiableInode");
+var ConversationDirectoryIdentityError = class extends Error {
+  constructor(scope, reason, cause) {
+    super(
+      `Conversation ${scope} identity validation failed: ${reason}`,
+      cause !== void 0 ? { cause } : void 0
+    );
+    this.scope = scope;
+    this.reason = reason;
+  }
+  static {
+    __name(this, "ConversationDirectoryIdentityError");
+  }
+  name = "ConversationDirectoryIdentityError";
+};
+function throwIdentityIoError(scope, cause) {
+  throw new ConversationDirectoryIdentityError(scope, "io_error", cause);
+}
+__name(throwIdentityIoError, "throwIdentityIoError");
+var isSameConversationPath = /* @__PURE__ */ __name((left, right) => process.platform === "win32" ? left.toLowerCase() === right.toLowerCase() : left === right, "isSameConversationPath");
+function getConversationDirectoryName(storageSessionId) {
+  if (storageSessionId.length === 0 || storageSessionId.length > 256) {
+    throw new ConversationDirectoryIdentityError("child", "invalid_session_id");
+  }
+  return `conversation-${createHash("sha256").update(storageSessionId).digest("hex")}`;
+}
+__name(getConversationDirectoryName, "getConversationDirectoryName");
+function validateDirectoryStats(stats, scope) {
+  if (stats.isSymbolicLink() || !stats.isDirectory()) {
+    throw new ConversationDirectoryIdentityError(scope, "not_directory");
+  }
+  if (process.platform !== "win32" && typeof process.getuid === "function" && stats.uid !== process.getuid()) {
+    throw new ConversationDirectoryIdentityError(scope, "wrong_owner");
+  }
+  if (process.platform !== "win32" && (stats.mode & 63) !== 0) {
+    throw new ConversationDirectoryIdentityError(scope, "wrong_mode");
+  }
+}
+__name(validateDirectoryStats, "validateDirectoryStats");
+function hasRootIdentity(stats, root) {
+  if (!root.inodeVerifiable) return stats.dev === root.device;
+  return hasVerifiableInode(stats.ino) && stats.dev === root.device && stats.ino === root.inode;
+}
+__name(hasRootIdentity, "hasRootIdentity");
+function isSameDirectoryIdentity(before, after) {
+  if (!hasVerifiableInode(before.ino) || !hasVerifiableInode(after.ino)) {
+    return before.dev === after.dev;
+  }
+  return before.dev === after.dev && before.ino === after.ino;
+}
+__name(isSameDirectoryIdentity, "isSameDirectoryIdentity");
+function hasExpectedDirectoryIdentity(identity, expected) {
+  const inodesProvable = hasVerifiableInode(identity.inode) && hasVerifiableInode(expected.inode);
+  return identity.storageSessionId === expected.storageSessionId && identity.name === expected.name && isSameConversationPath(identity.canonicalPath, expected.canonicalPath) && identity.device === expected.device && (!inodesProvable || identity.inode === expected.inode) && isSameConversationPath(
+    identity.root.configuredRoot,
+    expected.root.configuredRoot
+  ) && isSameConversationPath(
+    identity.root.canonicalRoot,
+    expected.root.canonicalRoot
+  ) && identity.root.device === expected.root.device && (!identity.root.inodeVerifiable || !expected.root.inodeVerifiable || identity.root.inode === expected.root.inode);
+}
+__name(hasExpectedDirectoryIdentity, "hasExpectedDirectoryIdentity");
+async function createConversationRootIdentity(configuredRoot) {
+  try {
+    await mkdir(configuredRoot, { recursive: true, mode: 448 });
+  } catch (error) {
+    let existing;
+    try {
+      existing = await lstat(configuredRoot);
+    } catch {
+      throwIdentityIoError("root", error);
+    }
+    validateDirectoryStats(existing, "root");
+    throwIdentityIoError("root", error);
+  }
+  let before;
+  try {
+    before = await lstat(configuredRoot);
+  } catch (error) {
+    throwIdentityIoError("root", error);
+  }
+  validateDirectoryStats(before, "root");
+  let canonicalRoot;
+  let after;
+  try {
+    canonicalRoot = await realpath(configuredRoot);
+    after = await lstat(canonicalRoot);
+  } catch (error) {
+    throwIdentityIoError("root", error);
+  }
+  validateDirectoryStats(after, "root");
+  if (!isSameDirectoryIdentity(before, after)) {
+    throw new ConversationDirectoryIdentityError("root", "identity_changed");
+  }
+  return {
+    configuredRoot,
+    canonicalRoot,
+    device: after.dev,
+    inode: after.ino,
+    inodeVerifiable: hasVerifiableInode(after.ino)
+  };
+}
+__name(createConversationRootIdentity, "createConversationRootIdentity");
+async function revalidateConversationRootIdentity(root) {
+  let configuredStats;
+  try {
+    configuredStats = await lstat(root.configuredRoot);
+  } catch (error) {
+    throwIdentityIoError("root", error);
+  }
+  validateDirectoryStats(configuredStats, "root");
+  if (!hasRootIdentity(configuredStats, root)) {
+    throw new ConversationDirectoryIdentityError("root", "identity_changed");
+  }
+  let canonical;
+  try {
+    canonical = await realpath(root.configuredRoot);
+  } catch (error) {
+    throwIdentityIoError("root", error);
+  }
+  if (!isSameConversationPath(canonical, root.canonicalRoot)) {
+    throw new ConversationDirectoryIdentityError(
+      "root",
+      "canonical_path_changed"
+    );
+  }
+  let canonicalStats;
+  try {
+    canonicalStats = await lstat(root.canonicalRoot);
+  } catch (error) {
+    throwIdentityIoError("root", error);
+  }
+  validateDirectoryStats(canonicalStats, "root");
+  if (!hasRootIdentity(canonicalStats, root)) {
+    throw new ConversationDirectoryIdentityError("root", "identity_changed");
+  }
+  return root;
+}
+__name(revalidateConversationRootIdentity, "revalidateConversationRootIdentity");
+async function assertExactConversationRootIdentity(root, candidate) {
+  await revalidateConversationRootIdentity(root);
+  const resolvedCandidate = resolve(candidate);
+  if (!isSameConversationPath(resolvedCandidate, root.configuredRoot) && !isSameConversationPath(resolvedCandidate, root.canonicalRoot)) {
+    throw new ConversationDirectoryIdentityError("root", "unexpected_identity");
+  }
+  let stats;
+  let canonical;
+  try {
+    stats = await lstat(resolvedCandidate);
+    validateDirectoryStats(stats, "root");
+    canonical = await realpath(resolvedCandidate);
+  } catch (error) {
+    if (error instanceof ConversationDirectoryIdentityError) throw error;
+    throwIdentityIoError("root", error);
+  }
+  if (!isSameConversationPath(canonical, root.canonicalRoot) || !hasRootIdentity(stats, root)) {
+    throw new ConversationDirectoryIdentityError("root", "unexpected_identity");
+  }
+  return root;
+}
+__name(assertExactConversationRootIdentity, "assertExactConversationRootIdentity");
+async function inspectConversationDirectoryIdentity(root, storageSessionId, expected) {
+  await revalidateConversationRootIdentity(root);
+  const name = getConversationDirectoryName(storageSessionId);
+  const candidate = join(root.canonicalRoot, name);
+  let before;
+  try {
+    before = await lstat(candidate);
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throwIdentityIoError("child", error);
+  }
+  validateDirectoryStats(before, "child");
+  let canonical;
+  let after;
+  try {
+    canonical = await realpath(candidate);
+    after = await lstat(canonical);
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throwIdentityIoError("child", error);
+  }
+  validateDirectoryStats(after, "child");
+  const child = relative(root.canonicalRoot, canonical);
+  if (child !== name || child.includes(sep) || child.startsWith("..") || isAbsolute(child)) {
+    throw new ConversationDirectoryIdentityError("child", "not_direct_child");
+  }
+  if (!isSameDirectoryIdentity(before, after)) {
+    throw new ConversationDirectoryIdentityError("child", "identity_changed");
+  }
+  await revalidateConversationRootIdentity(root);
+  const identity = {
+    root,
+    storageSessionId,
+    name,
+    canonicalPath: canonical,
+    device: after.dev,
+    inode: after.ino
+  };
+  if (expected && !hasExpectedDirectoryIdentity(identity, expected)) {
+    throw new ConversationDirectoryIdentityError(
+      "child",
+      "unexpected_identity"
+    );
+  }
+  return identity;
+}
+__name(inspectConversationDirectoryIdentity, "inspectConversationDirectoryIdentity");
+async function materializeConversationDirectoryIdentity(root, storageSessionId) {
+  await revalidateConversationRootIdentity(root);
+  const name = getConversationDirectoryName(storageSessionId);
+  const candidate = join(root.canonicalRoot, name);
+  let created = false;
+  try {
+    await mkdir(candidate, { mode: 448 });
+    created = true;
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throwIdentityIoError("child", error);
+    }
+  }
+  const identity = await inspectConversationDirectoryIdentity(
+    root,
+    storageSessionId
+  );
+  if (!identity) {
+    throw new ConversationDirectoryIdentityError("child", "identity_changed");
+  }
+  return { identity, created };
+}
+__name(materializeConversationDirectoryIdentity, "materializeConversationDirectoryIdentity");
+
+// packages/core/dist/src/services/tool-write-origin.js
+init_esbuild_shims();
+var TOOL_WRITE_ORIGIN_META_KEY = "qwen-code/tool-write-origin";
+var TOOL_WRITE_ORIGINS = [
+  "write_file",
+  "edit",
+  "notebook_edit",
+  "shell_sed_edit"
+];
+var TOOL_WRITE_ORIGIN_SET = new Set(TOOL_WRITE_ORIGINS);
+function buildToolWriteOriginMeta(meta, source) {
+  const sanitized = { ...meta };
+  delete sanitized[TOOL_WRITE_ORIGIN_META_KEY];
+  if (source !== void 0) {
+    sanitized[TOOL_WRITE_ORIGIN_META_KEY] = { version: 1, source };
+  }
+  return Object.keys(sanitized).length > 0 ? sanitized : void 0;
+}
+__name(buildToolWriteOriginMeta, "buildToolWriteOriginMeta");
+function parseToolWriteOriginMeta(meta) {
+  const marker = meta?.[TOOL_WRITE_ORIGIN_META_KEY];
+  if (typeof marker !== "object" || marker === null || Array.isArray(marker)) {
+    return void 0;
+  }
+  const keys = Object.keys(marker);
+  if (keys.length !== 2 || !Object.hasOwn(marker, "version") || !Object.hasOwn(marker, "source")) {
+    return void 0;
+  }
+  const record = marker;
+  return record["version"] === 1 && typeof record["source"] === "string" && TOOL_WRITE_ORIGIN_SET.has(record["source"]) ? record["source"] : void 0;
+}
+__name(parseToolWriteOriginMeta, "parseToolWriteOriginMeta");
+
+export {
+  buildToolWriteOriginMeta,
+  parseToolWriteOriginMeta,
+  ConversationDirectoryIdentityError,
+  isSameConversationPath,
+  getConversationDirectoryName,
+  createConversationRootIdentity,
+  revalidateConversationRootIdentity,
+  assertExactConversationRootIdentity,
+  inspectConversationDirectoryIdentity,
+  materializeConversationDirectoryIdentity
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */