@bman654/clodex 2.8.0 → 2.8.1

package/README.md

@@ -205,6 +205,10 @@ Enabling this feature executes that JavaScript with your full user permissions;
 
 The module must default-export an array. Each site has a unique lowercase `id` and an `apply` function that returns the complete source and emits the generated `marker` exactly once when it applies:
 
+The `source` your `apply` receives is every JavaScript module in the binary joined together, with a ``/*clodex:module-boundary`;{}"]*/`` line between them. This is true of every Claude Code version — a pre-2.1.242 binary carries the bundle plus five small helper modules; a 2.1.242-or-later one carries the bundle split across roughly 1,370. Match and replace as you always have; just do not add or remove one of those lines, or the whole patch is refused. (The punctuation in the marker is there so that a wildcard bounded by a character class cannot run across a module boundary.)
+
+If your transform works by **position** rather than by matching an anchor, mind where it lands: text prepended to `source` goes into the first module and text appended to it goes into the last, and neither is necessarily the module that runs at startup. Anchor your edit to text you match, the way the examples below do.
+
 ```js
 export default [
   {

package/dist/cli.js

@@ -382,7 +382,7 @@ import { join } from "path";
 // package.json
 var package_default = {
   name: "@bman654/clodex",
-  version: "2.8.0",
+  version: "2.8.1",
   publishConfig: {
     access: "public"
   },
@@ -3419,7 +3419,7 @@ function savedStopsAfter(current, assignments) {
 }
 
 // src/patch-transforms.ts
-var PATCH_TRANSFORMS_VERSION = 8;
+var PATCH_TRANSFORMS_VERSION = 9;
 var NATIVE_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
 var BASE_EFFORT_LEVELS = ["low", "medium", "high"];
 function projectNativeEffort(effort) {
@@ -3622,7 +3622,7 @@ function applyClodexPatches(source, config) {
     }).join("; ");
     applyOnce(
       "PATCH 4: Agent tool model description",
-      /(describe\(`Optional model override for this agent[^`]*?)(`\))/,
+      /(describe\(`Optional model override for this agent(?:[^`\\]|\\.)*?)(`)/,
       (_m, body, close) => body.includes("Additional custom models") ? body + close : body + " Additional custom models: " + listing + "." + close,
       { required: false, noopIsSkip: true }
     );
@@ -4169,7 +4169,7 @@ function captureBuiltInPatchProofs(source, config, results) {
   );
   addPattern(
     "PATCH 4: Agent tool model description",
-    /describe\(`Optional model override for this agent[^`]*?`\)/
+    /describe\(`Optional model override for this agent(?:[^`\\]|\\.)*?`/
   );
   const aliases = configuredAliases(config);
   if (protectsResult(results, "PATCH 6: alias resolver switch")) {
@@ -6800,6 +6800,9 @@ var BUN_OFFSETS_BYTES = 32;
 var TAIL_SCAN_BYTES = 16 * 1024 * 1024;
 var MODULE_STRUCT_BYTES_CURRENT = 52;
 var MODULE_STRUCT_BYTES_LEGACY = 36;
+var CONTENTS_FIELD_AT = 8;
+var LOADER_FROM_END = 3;
+var BUN_JAVASCRIPT_LOADER = 1;
 var MAX_MODULE_NAME_BYTES = 4096;
 var MIN_SHIMMABLE_NAME_BYTES = 7;
 function tweakccRecognizesModuleName(name) {
@@ -6854,6 +6857,8 @@ function parseBunModuleNamesAtUnchecked(fd, offsetsAt) {
   if (!modules) return null;
   const names = [];
   const nameOffsets = [];
+  const contents = [];
+  const loaders = [];
   for (let index = 0; index < moduleCount; index++) {
     const nameOffset = modules.readUInt32LE(index * structBytes);
     const nameLength = modules.readUInt32LE(index * structBytes + 4);
@@ -6865,8 +6870,23 @@ function parseBunModuleNamesAtUnchecked(fd, offsetsAt) {
     if (!/^[\x20-\x7e]+$/.test(name)) return null;
     names.push(name);
     nameOffsets.push(blobAt + nameOffset);
+    contents.push({
+      offset: modules.readUInt32LE(index * structBytes + CONTENTS_FIELD_AT),
+      length: modules.readUInt32LE(index * structBytes + CONTENTS_FIELD_AT + 4)
+    });
+    loaders.push(modules.readUInt8(index * structBytes + structBytes - LOADER_FROM_END));
   }
-  return { names, entryPointId, offsets: nameOffsets };
+  return {
+    names,
+    entryPointId,
+    offsets: nameOffsets,
+    contents,
+    loaders,
+    blobAt,
+    modulesAt: blobAt + modulesOffset,
+    structBytes,
+    byteCount: Number(byteCount)
+  };
 }
 function findStandIn(fd, fileSize, marker) {
   const needle = Buffer.from(marker);
@@ -6912,6 +6932,70 @@ function isMachO(fd) {
   const value = magic.readUInt32BE(0);
   return value === 4277009102 || value === 4277009103 || value === 3472551422 || value === 3489328638 || value === 3405691582 || value === 3405691583;
 }
+function readBunModuleTable(path) {
+  const fd = openSync2(path, "r");
+  try {
+    const parsed = readBunModuleNames(fd, statSync4(path).size);
+    if (!parsed) return null;
+    const { names, loaders, contents, entryPointId, blobAt, modulesAt, structBytes, byteCount } = parsed;
+    return { names, loaders, contents, entryPointId, blobAt, modulesAt, structBytes, byteCount };
+  } finally {
+    closeSync2(fd);
+  }
+}
+function readBunJavaScriptModules(path) {
+  const fd = openSync2(path, "r");
+  try {
+    const parsed = readBunModuleNames(fd, statSync4(path).size);
+    if (!parsed) return null;
+    const modules = [];
+    for (let index = 0; index < parsed.names.length; index++) {
+      if (parsed.loaders[index] !== BUN_JAVASCRIPT_LOADER) continue;
+      const range = parsed.contents[index];
+      if (range.offset < 0 || range.length < 0 || range.offset + range.length > parsed.byteCount) {
+        return null;
+      }
+      const bytes = range.length === 0 ? Buffer.alloc(0) : readAt(fd, range.length, parsed.blobAt + range.offset);
+      if (!bytes) return null;
+      modules.push({
+        index,
+        name: parsed.names[index],
+        source: bytes.toString("utf8"),
+        byteLength: bytes.length
+      });
+    }
+    return modules;
+  } finally {
+    closeSync2(fd);
+  }
+}
+function repointBunModuleContents(path, edits) {
+  if (edits.length === 0) return;
+  const fd = openSync2(path, "r+");
+  try {
+    const parsed = readBunModuleNames(fd, statSync4(path).size);
+    if (!parsed) throw new Error(`cannot read the Bun module table of ${path}`);
+    for (const { index, range } of edits) {
+      if (index < 0 || index >= parsed.names.length) {
+        throw new Error(`module ${index} is outside the ${parsed.names.length}-module table of ${path}`);
+      }
+      if (range.offset < 0 || range.length < 0 || range.offset + range.length > parsed.byteCount) {
+        throw new Error(
+          `module ${index} would point at ${range.offset}+${range.length}, outside the ${parsed.byteCount}-byte blob of ${path}`
+        );
+      }
+      const at = parsed.modulesAt + index * parsed.structBytes + CONTENTS_FIELD_AT;
+      const pair = Buffer.alloc(8);
+      pair.writeUInt32LE(range.offset, 0);
+      pair.writeUInt32LE(range.length, 4);
+      if (writeSync2(fd, pair, 0, pair.length, at) !== pair.length) {
+        throw new Error(`short write repointing module ${index} of ${path}`);
+      }
+    }
+  } finally {
+    closeSync2(fd);
+  }
+}
 function shimEntryModuleName(path) {
   const fd = openSync2(path, "r+");
   try {
@@ -6944,7 +7028,17 @@ function restoreEntryModuleName(path, shim, { resign }) {
     }
     writeNameBytes(fd, shim.original, offset);
     restoreEveryStandIn(fd, statSync4(path).size, shim);
-    machO = resign && isMachO(fd);
+    machO = resign;
+  } finally {
+    closeSync2(fd);
+  }
+  if (machO) resignMachOBinary(path);
+}
+function resignMachOBinary(path) {
+  const fd = openSync2(path, "r");
+  let machO;
+  try {
+    machO = isMachO(fd);
   } finally {
     closeSync2(fd);
   }
@@ -6953,6 +7047,99 @@ function restoreEntryModuleName(path, shim, { resign }) {
   }
 }
 
+// src/bun-bundle.ts
+function writableModuleIndex(path) {
+  const table = readBunModuleTable(path);
+  if (!table) return null;
+  const index = table.names.findIndex(tweakccRecognizesModuleName);
+  return index < 0 ? null : index;
+}
+var BUNDLE_MODULE_SEPARATOR = '\n/*clodex:module-boundary`;{}"]*/\n';
+function readClaudeBundle(path) {
+  const modules = readBunJavaScriptModules(path);
+  if (!modules || modules.length === 0) return null;
+  if (modules.some((module) => module.source.includes(BUNDLE_MODULE_SEPARATOR))) return null;
+  if (modules.some((module) => !roundTripsAsUtf8(module.source, module.byteLength))) return null;
+  return { modules, source: modules.map((module) => module.source).join(BUNDLE_MODULE_SEPARATOR) };
+}
+function roundTripsAsUtf8(source, byteLength) {
+  return Buffer.byteLength(source, "utf8") === byteLength && !source.includes("\uFFFD");
+}
+function splitBundleSource(bundle, patched) {
+  const parts = patched.split(BUNDLE_MODULE_SEPARATOR);
+  if (parts.length !== bundle.modules.length) {
+    throw new Error(
+      `the patched bundle has ${parts.length} module boundaries, expected ${bundle.modules.length}`
+    );
+  }
+  return parts;
+}
+function planBundleWrite(bundle, patchedSources, writableIndex) {
+  if (patchedSources.length !== bundle.modules.length) {
+    throw new Error(
+      `expected ${bundle.modules.length} patched module sources, got ${patchedSources.length}`
+    );
+  }
+  const writable = bundle.modules.findIndex((module) => module.index === writableIndex);
+  if (writable < 0) {
+    throw new Error(`module ${writableIndex} is not one of this binary's JavaScript modules`);
+  }
+  const changed = bundle.modules.map((module, at) => at).filter((at) => at !== writable && patchedSources[at] !== bundle.modules[at].source);
+  if (changed.length === 0) return { content: patchedSources[writable], repoints: [] };
+  const order = [writable, ...changed];
+  const repoints = [];
+  let content = "";
+  let start = 0;
+  for (const at of order) {
+    const source = patchedSources[at];
+    const length = Buffer.byteLength(source, "utf8");
+    repoints.push({ index: bundle.modules[at].index, start, length, expected: source });
+    content += source + "\0";
+    start += length + 1;
+  }
+  return { content, repoints };
+}
+function applyBundleWritePlan(path, plan) {
+  const table = readBunModuleTable(path);
+  if (!table) {
+    if (plan.repoints.length === 0) return;
+    throw new Error(`cannot read the Bun module table of ${path} after repacking`);
+  }
+  const recognized = table.names.filter(tweakccRecognizesModuleName);
+  if (recognized.length !== 1) {
+    throw new Error(
+      `${path} has ${recognized.length} modules tweakcc would write to; the patch was planned around exactly one`
+    );
+  }
+  if (plan.repoints.length === 0) return;
+  const writable = table.names.findIndex(tweakccRecognizesModuleName);
+  if (writable !== plan.repoints[0].index) {
+    throw new Error(
+      `${path} exposes module ${writable} to tweakcc, but the patch was planned around module ${plan.repoints[0].index}`
+    );
+  }
+  const written = table.contents[writable];
+  const expectedBytes = Buffer.byteLength(plan.content, "utf8");
+  if (written.length !== expectedBytes) {
+    throw new Error(
+      `${path} holds ${written.length} bytes where the ${expectedBytes} bytes clodex wrote should be; refusing to repoint its modules`
+    );
+  }
+  const edits = plan.repoints.map((repoint) => ({
+    index: repoint.index,
+    range: { offset: written.offset + repoint.start, length: repoint.length }
+  }));
+  repointBunModuleContents(path, edits);
+  const after = readBunJavaScriptModules(path);
+  if (!after) throw new Error(`cannot re-read the modules of ${path} after repointing them`);
+  const byIndex = new Map(after.map((module) => [module.index, module.source]));
+  for (const repoint of plan.repoints) {
+    if (byIndex.get(repoint.index) !== repoint.expected) {
+      throw new Error(`module ${repoint.index} of ${path} did not read back as the patched source`);
+    }
+  }
+}
+
 // src/patch-backup.ts
 import { createHash as createHash5 } from "crypto";
 import { existsSync as existsSync4, readFileSync as readFileSync7, readdirSync, statSync as statSync5 } from "fs";
@@ -12304,9 +12491,15 @@ async function applyPatch(binaryPath, version, desired, configHash, opts) {
       copyFileSync(from, candidatePath);
       const shim = shimEntryModuleName(candidatePath);
       const installation = await tryDetectInstallation({ path: candidatePath });
-      const source = await readContent(installation);
+      const bundle = readClaudeBundle(candidatePath);
+      if (!bundle && installation.kind === "native") {
+        p2.log.warn(
+          `Could not read ${candidatePath} as a Bun module table, so only the module tweakcc names is being patched. On Claude Code 2.1.242 and later that module is a stub holding none of the code clodex patches, and the patch below will fail at its first required site \u2014 the cause is this read, not a changed anchor.`
+        );
+      }
+      const source = bundle ? bundle.source : await readContent(installation);
       if (shim) restoreEntryModuleName(candidatePath, shim, { resign: false });
-      return { installation, source };
+      return { installation, source, bundle };
     };
     const facts = collectPristineFacts({
       version,
@@ -12399,8 +12592,25 @@ async function applyPatch(binaryPath, version, desired, configHash, opts) {
     }
     results = [...results, ...local.results];
     const writeShim = shimEntryModuleName(candidatePath);
-    await writeContent(loaded.installation, local.content);
+    let repointed = false;
+    if (loaded.bundle) {
+      const writable = writableModuleIndex(candidatePath);
+      if (writable === null) {
+        throw new Error("no module of the patch candidate carries a name tweakcc can write to");
+      }
+      const plan2 = planBundleWrite(
+        loaded.bundle,
+        splitBundleSource(loaded.bundle, local.content),
+        writable
+      );
+      await writeContent(loaded.installation, plan2.content);
+      applyBundleWritePlan(candidatePath, plan2);
+      repointed = plan2.repoints.length > 0;
+    } else {
+      await writeContent(loaded.installation, local.content);
+    }
     if (writeShim) restoreEntryModuleName(candidatePath, writeShim, { resign: true });
+    else if (repointed) resignMachOBinary(candidatePath);
     patchedSize = statSync6(candidatePath).size;
     patchedSha256 = sha256File(candidatePath);
     renameSync2(candidatePath, binaryPath);