@cnwenf/occ 2.1.327 → 2.1.328

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-globalThis.MACRO={"VERSION":"2.1.327","BINARY_NAME":"occ","BUILD_TIME":"2026-09-09T22:35:02.507Z","FEEDBACK_CHANNEL":"","ISSUES_EXPLAINER":"","NATIVE_PACKAGE_URL":"","PACKAGE_URL":"@cnwenf/occ","VERSION_CHANGELOG":""};
+globalThis.MACRO={"VERSION":"2.1.328","BINARY_NAME":"occ","BUILD_TIME":"2026-09-10T19:48:17.557Z","FEEDBACK_CHANNEL":"","ISSUES_EXPLAINER":"","NATIVE_PACKAGE_URL":"","PACKAGE_URL":"@cnwenf/occ","VERSION_CHANGELOG":""};
 // @bun
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
@@ -60319,6 +60319,102 @@ var init_settings = __esm(() => {
   EMPTY_RESULT = Object.freeze({ settings: {}, errors: [] });
 });
 
+// src/utils/settings/sanitizeAllowlists.ts
+function issueDetail(error49) {
+  const issue2 = error49.issues[0];
+  if (issue2 === undefined)
+    return "failed validation";
+  return issue2.path.length > 0 ? `${issue2.path.join(".")}: ${issue2.message}` : issue2.message;
+}
+function validateAllowlistEntry(key, entry) {
+  if (key === "allowedChannelPlugins") {
+    if (typeof entry === "string") {
+      const at = entry.indexOf("@");
+      const plugin = entry.slice(0, at);
+      const marketplace = entry.slice(at + 1);
+      if (at > 0 && marketplace.length > 0) {
+        return {
+          ok: true,
+          value: { marketplace, plugin },
+          notice: `"allowedChannelPlugins" entry "${entry}" was accepted; prefer the documented object form {"plugin": "${plugin}", "marketplace": "${marketplace}"}.`
+        };
+      }
+    }
+    const parsed2 = CHANNEL_PLUGIN_ENTRY.safeParse(entry);
+    return parsed2.success ? { ok: true, value: parsed2.data } : { ok: false, detail: issueDetail(parsed2.error) };
+  }
+  const parsed = STRING_ENTRY.safeParse(entry);
+  return parsed.success ? { ok: true, value: parsed.data } : { ok: false, detail: issueDetail(parsed.error) };
+}
+function sanitizeSecurityAllowlists(data, filePath) {
+  if (!data || typeof data !== "object")
+    return [];
+  const obj = data;
+  const warnings = [];
+  for (const { key, emptyReason } of ALLOWLIST_SPECS) {
+    if (!(key in obj))
+      continue;
+    const raw = obj[key];
+    if (!Array.isArray(raw)) {
+      obj[key] = [];
+      warnings.push({
+        file: filePath,
+        path: key,
+        message: `"${key}" was present but invalid; enforcing an empty allowlist (${emptyReason}) until it is fixed.`,
+        invalidValue: raw
+      });
+      continue;
+    }
+    const valid = [];
+    for (const [index2, entry] of raw.entries()) {
+      const result = validateAllowlistEntry(key, entry);
+      if (result.ok) {
+        valid.push(result.value);
+        if (result.notice !== undefined) {
+          warnings.push({
+            file: filePath,
+            path: `${key}[${index2}]`,
+            message: result.notice
+          });
+        }
+      } else {
+        warnings.push({
+          file: filePath,
+          path: `${key}[${index2}]`,
+          message: `Invalid entry was ignored: ${result.detail}`,
+          invalidValue: entry
+        });
+      }
+    }
+    if (raw.length > 0 && valid.length === 0) {
+      warnings.push({
+        file: filePath,
+        path: key,
+        message: `Every entry of "${key}" was invalid; enforcing an empty allowlist (${emptyReason}) until it is fixed.`
+      });
+    }
+    obj[key] = valid;
+  }
+  return warnings;
+}
+var STRING_ENTRY, CHANNEL_PLUGIN_ENTRY, ALLOWLIST_SPECS;
+var init_sanitizeAllowlists = __esm(() => {
+  init_v4();
+  STRING_ENTRY = exports_external.string();
+  CHANNEL_PLUGIN_ENTRY = exports_external.object({
+    marketplace: exports_external.string(),
+    plugin: exports_external.string()
+  });
+  ALLOWLIST_SPECS = [
+    { key: "allowedHttpHookUrls", emptyReason: "no HTTP hooks may run" },
+    {
+      key: "httpHookAllowedEnvVars",
+      emptyReason: "no environment variables may be interpolated into HTTP hook headers"
+    },
+    { key: "allowedChannelPlugins", emptyReason: "no channel plugins admitted" }
+  ];
+});
+
 // src/utils/settings/settings.ts
 var exports_settings = {};
 __export(exports_settings, {
@@ -60455,12 +60551,19 @@ function parseSettingsFileUncached(path9) {
     }
     const data = safeParseJSON(content, false);
     const ruleWarnings = filterInvalidPermissionRules(data, path9);
+    const allowlistWarnings = sanitizeSecurityAllowlists(data, path9);
     const result = SettingsSchema().safeParse(data);
     if (!result.success) {
       const errors3 = formatZodError(result.error, path9);
-      return { settings: null, errors: [...ruleWarnings, ...errors3] };
+      return {
+        settings: null,
+        errors: [...ruleWarnings, ...allowlistWarnings, ...errors3]
+      };
     }
-    return { settings: result.data, errors: ruleWarnings };
+    return {
+      settings: result.data,
+      errors: [...ruleWarnings, ...allowlistWarnings]
+    };
   } catch (error49) {
     handleFileSystemError(error49, path9);
     return { settings: null, errors: [] };
@@ -61086,6 +61189,7 @@ var init_settings2 = __esm(() => {
   init_managedPath();
   init_settings();
   init_settingsCache();
+  init_sanitizeAllowlists();
   init_types2();
   init_validation2();
   MAX_SETTINGS_FILE_BYTES = 2 * 1024 * 1024;
@@ -266184,6 +266288,9 @@ async function* withRetry(getClient2, operation, options) {
   let persistentAttempt = 0;
   let apiKeyHelperAuthRetries = 0;
   const API_KEY_HELPER_AUTH_RETRY_CAP = 2;
+  let awsAuthRetries = 0;
+  let gcpAuthRetries = 0;
+  const CLOUD_AUTH_RETRY_CAP = 2;
   let mediaStrips = 0;
   const MAX_MEDIA_STRIPS = 20;
   for (let attempt = 1;attempt <= maxRetries + 1; attempt++) {
@@ -266312,6 +266419,25 @@ async function* withRetry(getClient2, operation, options) {
         }
         apiKeyHelperAuthRetries++;
       }
+      const cloudCredentialKind = classifyCloudCredentialError(error52);
+      if (cloudCredentialKind === "AWS" || getAPIProvider() !== "firstParty" && isBedrockAuthError(error52)) {
+        if (awsAuthRetries >= CLOUD_AUTH_RETRY_CAP) {
+          logEvent2("api_request", {
+            reason: "api_request_aws_auth_exhausted"
+          });
+          throw new CannotRetryError(error52, retryContext);
+        }
+        awsAuthRetries++;
+      }
+      if (cloudCredentialKind === "Google Cloud" || getAPIProvider() !== "firstParty" && isVertexAuthError(error52)) {
+        if (gcpAuthRetries >= CLOUD_AUTH_RETRY_CAP) {
+          logEvent2("api_request", {
+            reason: "api_request_gcp_auth_exhausted"
+          });
+          throw new CannotRetryError(error52, retryContext);
+        }
+        gcpAuthRetries++;
+      }
       const handledCloudAuthError = handleAwsCredentialError(error52) || handleGcpCredentialError(error52);
       if (!handledCloudAuthError && (!(error52 instanceof APIError) || !shouldRetry(error52))) {
         throw new CannotRetryError(error52, retryContext);
@@ -266474,6 +266600,34 @@ function getFallbackTriggerReason(error52) {
 function isOAuthTokenRevokedError(error52) {
   return error52 instanceof APIError && error52.status === 403 && (error52.message?.includes("OAuth token has been revoked") ?? false);
 }
+function findInErrorCauseChain(error52, predicate, maxDepth = 5) {
+  let current = error52;
+  for (let depth = 0;depth < maxDepth; depth++) {
+    if (!(current instanceof Error))
+      return;
+    if (predicate(current))
+      return current;
+    current = current.cause;
+  }
+  return;
+}
+function errorChainMessageIncludes(error52, needles) {
+  return findInErrorCauseChain(error52, (e4) => needles.some((needle) => e4.message.includes(needle))) !== undefined;
+}
+function isGoogleCloudEnv() {
+  return !!(process.env.CLAUDE_CODE_USE_VERTEX || process.env.CLAUDE_CODE_USE_ANTHROPIC_GOOGLE_CLOUD);
+}
+function classifyCloudCredentialError(error52) {
+  if (error52 instanceof APIError && error52.status !== undefined)
+    return null;
+  if (findInErrorCauseChain(error52, (e4) => e4.name === "CredentialsProviderError") !== undefined) {
+    return "AWS";
+  }
+  if (isGoogleCloudEnv() && errorChainMessageIncludes(error52, GOOGLE_CREDENTIAL_CLASSIFIER_MESSAGES)) {
+    return "Google Cloud";
+  }
+  return null;
+}
 function isBedrockAuthError(error52) {
   if (isEnvTruthy(process.env.CLAUDE_CODE_USE_BEDROCK)) {
     if (isAwsCredentialsProviderError(error52) || error52 instanceof APIError && error52.status === 403) {
@@ -266490,10 +266644,11 @@ function handleAwsCredentialError(error52) {
   return false;
 }
 function isGoogleAuthLibraryCredentialError(error52) {
-  if (!(error52 instanceof Error))
-    return false;
-  const msg = error52.message;
-  return msg.includes("Could not load the default credentials") || msg.includes("Could not refresh access token") || msg.includes("invalid_grant");
+  return errorChainMessageIncludes(error52, [
+    ...GOOGLE_CREDENTIAL_CLASSIFIER_MESSAGES,
+    GOOGLE_OAUTH_FAILURE_MESSAGE,
+    GOOGLE_TOKEN_REFRESH_FAILURE_MESSAGE
+  ]);
 }
 function isVertexAuthError(error52) {
   if (isEnvTruthy(process.env.CLAUDE_CODE_USE_VERTEX)) {
@@ -266593,7 +266748,7 @@ function getRateLimitResetDelayMs(error52) {
     return null;
   return Math.min(delayMs, PERSISTENT_RESET_CAP_MS);
 }
-var abortError = () => new APIUserAbortError, DEFAULT_MAX_RETRIES2 = 10, FLOOR_OUTPUT_TOKENS = 3000, MAX_529_RETRIES = 3, BASE_DELAY_MS = 500, MAX_RETRIES_CLAMP = 15, WATCHDOG_DEFAULT_MAX_RETRIES = 300, maxRetriesClampWarned = false, FOREGROUND_529_RETRY_SOURCES, PERSISTENT_MAX_BACKOFF_MS, PERSISTENT_RESET_CAP_MS, HEARTBEAT_INTERVAL_MS = 30000, CannotRetryError, FallbackTriggeredError, DEFAULT_FAST_MODE_FALLBACK_HOLD_MS, SHORT_RETRY_THRESHOLD_MS, MIN_COOLDOWN_MS;
+var abortError = () => new APIUserAbortError, DEFAULT_MAX_RETRIES2 = 10, FLOOR_OUTPUT_TOKENS = 3000, MAX_529_RETRIES = 3, BASE_DELAY_MS = 500, MAX_RETRIES_CLAMP = 15, WATCHDOG_DEFAULT_MAX_RETRIES = 300, maxRetriesClampWarned = false, FOREGROUND_529_RETRY_SOURCES, PERSISTENT_MAX_BACKOFF_MS, PERSISTENT_RESET_CAP_MS, HEARTBEAT_INTERVAL_MS = 30000, CannotRetryError, FallbackTriggeredError, GOOGLE_CREDENTIAL_CLASSIFIER_MESSAGES, GOOGLE_OAUTH_FAILURE_MESSAGE = "Failed to acquire Google OAuth credentials.", GOOGLE_TOKEN_REFRESH_FAILURE_MESSAGE = "Could not refresh access token", DEFAULT_FAST_MODE_FALLBACK_HOLD_MS, SHORT_RETRY_THRESHOLD_MS, MIN_COOLDOWN_MS;
 var init_withRetry = __esm(() => {
   init_featureFlags();
   init_sdk();
@@ -266659,6 +266814,12 @@ var init_withRetry = __esm(() => {
       this.name = "FallbackTriggeredError";
     }
   };
+  GOOGLE_CREDENTIAL_CLASSIFIER_MESSAGES = [
+    "Could not load the default credentials",
+    "invalid_grant",
+    "invalid_client",
+    "unauthorized_client"
+  ];
   DEFAULT_FAST_MODE_FALLBACK_HOLD_MS = 30 * 60 * 1000;
   SHORT_RETRY_THRESHOLD_MS = 20 * 1000;
   MIN_COOLDOWN_MS = 10 * 60 * 1000;
@@ -377715,7 +377876,8 @@ function getSimpleSandboxSection() {
   ];
   const items = [
     ...sandboxOverrideItems,
-    "For temporary files, always use the `$TMPDIR` environment variable. TMPDIR is automatically set to the correct sandbox-writable directory in sandbox mode. Do NOT use `/tmp` directly - use `$TMPDIR` instead."
+    "For temporary files, always use the `$TMPDIR` environment variable. TMPDIR is automatically set to the correct sandbox-writable directory in sandbox mode. Do NOT use `/tmp` directly - use `$TMPDIR` instead.",
+    "If a clipboard utility such as `pbcopy`, `xclip`, or `wl-copy` fails inside the sandbox and the user wants the text on their clipboard, put the text in a fenced code block in your response and tell them to run `/copy` (it copies from outside the sandbox; when the picker appears they can select just that block), rather than writing a file for them to copy manually."
   ];
   return [
     "",
@@ -383975,6 +384137,8 @@ var init_BashTool = __esm(() => {
     timeout: semanticNumber(exports_external.number().optional()).describe(`Optional timeout in milliseconds (max ${getMaxTimeoutMs()})`),
     description: exports_external.string().optional().describe(`Clear, concise description of what this command does in active voice. Never use words like "complex" or "risk" in the description - just describe what it does.
 
+Say what the command does in plain words: do not echo the command's text, its flags, or file paths - the user reads this description, often without seeing the command.
+
 For simple commands (git, npm, standard CLI tools), keep it brief (5-10 words):
 - ls \u2192 "List files in current directory"
 - git status \u2192 "Show working tree status"
@@ -475491,7 +475655,7 @@ function deserializeMessagesWithInterruptDetection(serializedMessages) {
       turnInterruptionState = internalState;
     }
     const lastRelevantIdx = filteredMessages.findLastIndex((m5) => m5.type !== "system" && m5.type !== "progress");
-    if (lastRelevantIdx !== -1 && filteredMessages[lastRelevantIdx].type === "user") {
+    if (lastRelevantIdx !== -1 && filteredMessages[lastRelevantIdx].type === "user" && !isCompleteLocalCommandTail(filteredMessages, lastRelevantIdx)) {
       filteredMessages.splice(lastRelevantIdx + 1, 0, createAssistantMessage({
         content: NO_RESPONSE_REQUESTED
       }));
@@ -475515,6 +475679,9 @@ function detectTurnInterruption(messages) {
     return { kind: "none" };
   }
   if (lastMessage.type === "user") {
+    if (isCompleteLocalCommandTail(messages, lastMessageIdx)) {
+      return { kind: "none" };
+    }
     if (lastMessage.isMeta || lastMessage.isCompactSummary) {
       return { kind: "none" };
     }
@@ -475554,6 +475721,43 @@ function isTerminalToolResult(result, messages, resultIdx) {
   }
   return false;
 }
+function classifyLocalCommandKind(message) {
+  const content = message.message?.content;
+  const text2 = Array.isArray(content) ? content.findLast((block) => block?.type === "text")?.text : typeof content === "string" ? content : undefined;
+  if (typeof text2 !== "string")
+    return;
+  return LOCAL_COMMAND_TAG_KINDS.find(([prefix]) => text2.startsWith(prefix))?.[1];
+}
+function localCommandBreadcrumbKind(message) {
+  if (message.type !== "user")
+    return;
+  if (message.promptSource !== undefined)
+    return;
+  const kind = classifyLocalCommandKind(message);
+  if (kind === "caveat" && message.isMeta !== true)
+    return;
+  return kind;
+}
+function isCompleteLocalCommandTail(messages, idx) {
+  if (localCommandBreadcrumbKind(messages[idx]) === undefined)
+    return false;
+  let seenRecord = false;
+  let allMetaUsers = true;
+  for (let i6 = idx;i6 >= 0; i6--) {
+    const msg = messages[i6];
+    if (msg.type === "system" || msg.type === "progress" || msg.type === "attachment") {
+      continue;
+    }
+    const kind = localCommandBreadcrumbKind(msg);
+    if (kind === "caveat")
+      return true;
+    if (kind === undefined || seenRecord)
+      break;
+    seenRecord = kind === "record";
+    allMetaUsers = allMetaUsers && msg.type === "user" && msg.isMeta === true;
+  }
+  return allMetaUsers;
+}
 function restoreSkillStateFromMessages(messages) {
   for (const message of messages) {
     if (message.type !== "attachment") {
@@ -475671,11 +475875,12 @@ async function loadConversationForResume(source, sourceJsonlFile) {
     throw error52;
   }
 }
-var BRIEF_TOOL_NAME4, LEGACY_BRIEF_TOOL_NAME2, SEND_USER_FILE_TOOL_NAME3;
+var BRIEF_TOOL_NAME4, LEGACY_BRIEF_TOOL_NAME2, SEND_USER_FILE_TOOL_NAME3, LOCAL_COMMAND_TAG_KINDS;
 var init_conversationRecovery = __esm(() => {
   init_featureFlags();
   init_cwd2();
   init_state();
+  init_xml();
   init_ids();
   init_permissions();
   init_attachments2();
@@ -475688,6 +475893,12 @@ var init_conversationRecovery = __esm(() => {
   BRIEF_TOOL_NAME4 = feature("KAIROS") || feature("KAIROS_BRIEF") ? (init_prompt(), __toCommonJS(exports_prompt)).BRIEF_TOOL_NAME : null;
   LEGACY_BRIEF_TOOL_NAME2 = feature("KAIROS") || feature("KAIROS_BRIEF") ? (init_prompt(), __toCommonJS(exports_prompt)).LEGACY_BRIEF_TOOL_NAME : null;
   SEND_USER_FILE_TOOL_NAME3 = feature("KAIROS") ? (init_prompt8(), __toCommonJS(exports_prompt2)).SEND_USER_FILE_TOOL_NAME : null;
+  LOCAL_COMMAND_TAG_KINDS = [
+    [`<${COMMAND_NAME_TAG}>`, "record"],
+    [`<${LOCAL_COMMAND_STDOUT_TAG}>`, "output"],
+    [`<${LOCAL_COMMAND_STDERR_TAG}>`, "output"],
+    [`<${LOCAL_COMMAND_CAVEAT_TAG}>`, "caveat"]
+  ];
 });
 
 // src/services/api/filesApi.ts
@@ -612335,6 +612546,9 @@ function getCurrentTimestamp() {
   return new Date().toISOString();
 }
 function validatePathWithinBase(basePath, relativePath) {
+  if (process.platform !== "win32" && relativePath.includes("\\")) {
+    throw new Error(`Path traversal detected: "${relativePath}" would escape the base directory`);
+  }
   const resolvedPath = resolve51(basePath, relativePath);
   const normalizedBase = resolve51(basePath) + sep38;
   if (!resolvedPath.startsWith(normalizedBase) && resolvedPath !== resolve51(basePath)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cnwenf/occ",
-  "version": "2.1.327",
+  "version": "2.1.328",
   "license": "MIT",
   "type": "module",
   "bin": {