makecoder 5.0.22 → 5.0.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "makecoder",
-  "version": "5.0.22",
+  "version": "5.0.23",
   "description": "MakeCoder Coder: AI Agent Runtime OS that runs and orchestrates Claude Code, Codex, Gemini and more across CLI, API, Web and chat",
   "main": "./dist/coder.js",
   "bin": {
@@ -37,6 +37,8 @@
   "dependencies": {
     "@larksuiteoapi/node-sdk": "^1.59.0",
     "@wecom/aibot-node-sdk": "1.0.7",
+    "bidi-js": "^1.1.0",
+    "bun": "1.3.14",
     "commander": "^15.0.0",
     "node-fetch": "^3.3.2",
     "node-pty": "^1.1.0",
@@ -46,33 +48,26 @@
     "yazl": "^3.3.1",
     "zod": "^3.25.76"
   },
-  "optionalDependencies": {
-    "@anthropic-ai/claude-code-darwin-arm64": "2.1.283",
-    "@anthropic-ai/claude-code-darwin-x64": "2.1.283",
-    "@anthropic-ai/claude-code-linux-arm64": "2.1.283",
-    "@anthropic-ai/claude-code-linux-x64": "2.1.283",
-    "@anthropic-ai/claude-code-win32-x64": "2.1.283",
-    "makecoder-bin-darwin-arm64": "5.0.22",
-    "makecoder-bin-linux-arm64": "5.0.22",
-    "makecoder-bin-linux-x64": "5.0.22",
-    "makecoder-bin-win-x64": "5.0.22",
-    "makecoder-c-bin-darwin-arm64": "5.0.22",
-    "makecoder-c-bin-darwin-x64": "5.0.22",
-    "makecoder-c-bin-linux-arm64": "5.0.22",
-    "makecoder-c-bin-linux-x64": "5.0.22",
-    "makecoder-c-bin-win-x64": "5.0.22"
-  },
   "engines": {
     "node": ">=20.0.0"
   },
   "devDependencies": {
-    "bun": ">=1.3.12",
     "chokidar": "^4.0.3"
   },
   "files": [
     "dist",
     "scripts/postinstall.js",
-    "scripts/assemble-claude-native.mjs",
-    "scripts/claude-native-runtime.mjs"
-  ]
+    "scripts/claude-cell-segmenter-shim.js"
+  ],
+  "optionalDependencies": {
+    "makecoder-bin-darwin-arm64": "5.0.23",
+    "makecoder-bin-linux-arm64": "5.0.23",
+    "makecoder-bin-linux-x64": "5.0.23",
+    "makecoder-bin-win-x64": "5.0.23",
+    "makecoder-c-bin-darwin-arm64": "5.0.23",
+    "makecoder-c-bin-darwin-x64": "5.0.23",
+    "makecoder-c-bin-linux-arm64": "5.0.23",
+    "makecoder-c-bin-linux-x64": "5.0.23",
+    "makecoder-c-bin-win-x64": "5.0.23"
+  }
 }

package/scripts/claude-cell-segmenter-shim.js

@@ -0,0 +1,172 @@
+// Public Bun adapter for Claude Code 2.1.284.
+const SEG = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+const BIDI = require('bidi-js')();
+class CellSegmenter {
+  constructor(opts) {
+    this.opts=opts;
+    this.graphemes=[' ',''];
+    for(let i=33;i<=126;i++) this.graphemes.push(String.fromCharCode(i));
+    this.graphemes.push('\t','\ufffd');
+    this.charIds=new Map(this.graphemes.map((v,i)=>[v,i]));
+    this.sgrKeys=[''];this.sgrCloseKeys=[''];this.uris=[''];
+    this.styleIds=new Map([['',0]]);this.uriIds=new Map([['',0]]);
+    this.styles=[];
+  }
+  internChar(ch){let id=this.charIds.get(ch);if(id===undefined){id=this.graphemes.length;this.graphemes.push(ch);this.charIds.set(ch,id)}return id}
+  internStyle(codes){const key=codes.map(x=>x.open).join('\0');let id=this.styleIds.get(key);if(id===undefined){id=this.sgrKeys.length;this.sgrKeys.push(key);this.sgrCloseKeys.push(codes.map(x=>x.close).join('\0'));this.styleIds.set(key,id)}return id}
+  applySgr(codes,params){
+    const close={1:22,2:22,3:23,4:24,5:25,7:27,8:28,9:29,21:24};
+    const group={1:'intensity',2:'intensity',3:'italic',4:'underline',21:'underline',5:'blink',7:'inverse',8:'conceal',9:'strike'};
+    const resets={22:['intensity'],23:['italic'],24:['underline'],25:['blink'],27:['inverse'],28:['conceal'],29:['strike'],39:['foreground'],49:['background']};
+    const result=[...codes];
+    const clear=name=>{const i=result.findIndex(x=>x.group===name);if(i>=0)result.splice(i,1)};
+    const add=(name,open,end)=>{const i=result.findIndex(x=>x.group===name);if(i>=0&&result[i].open===open)return;if(i>=0)result.splice(i,1);result.push({group:name,open,close:end})};
+    const nums=params===''?[0]:params.split(';').map(x=>x===''?0:Number(x));
+    for(let i=0;i<nums.length;i++){
+      const n=nums[i];
+      if(n===0){result.length=0;continue}
+      if(resets[n]){for(const name of resets[n])clear(name);continue}
+      if(n===38||n===48){
+        const mode=nums[i+1],length=mode===5?1:mode===2?3:0;
+        if(length&&i+1+length<nums.length){
+          const values=nums.slice(i,i+2+length);i+=1+length;
+          if(values.every(Number.isInteger)&&values.slice(2).every(x=>x>=0&&x<=255))add(n===38?'foreground':'background',`\x1b[${values.join(';')}m`,n===38?'\x1b[39m':'\x1b[49m');
+        }
+        continue;
+      }
+      if(close[n]){add(group[n],`\x1b[${n}m`,`\x1b[${close[n]}m`);continue}
+      if(n>=30&&n<=37||n>=90&&n<=97)add('foreground',`\x1b[${n}m`,'\x1b[39m');
+      else if(n>=40&&n<=47||n>=100&&n<=107)add('background',`\x1b[${n}m`,'\x1b[49m');
+    }
+    return result;
+  }
+  internUri(uri){let id=this.uriIds.get(uri);if(id===undefined){id=this.uris.length;this.uris.push(uri);this.uriIds.set(uri,id)}return id}
+  segment(text,cells,runs,reorder){
+    let visible='', codes=[],uri='',state=[];
+    for(let i=0;i<text.length;){
+      if(text[i]==='\x1b'){
+        const rest=text.slice(i);let m=/^\x1b\[[0-9;]*m/.exec(rest);
+        if(m){codes=this.applySgr(codes,m[0].slice(2,-1));i+=m[0].length;continue}
+        m=/^\x1b\]8;[^;]*;([^\x07\x1b]*)(?:\x07|\x1b\\)/.exec(rest);
+        if(m){uri=m[1];this.internUri(uri);i+=m[0].length;continue}
+        m=/^\x1b(?:\[[0-?]*[ -/]*[@-~]|\][^\x07]*(?:\x07|\x1b\\))/.exec(rest);
+        if(m){i+=m[0].length;continue}
+        i++;continue;
+      }
+      const codePoint=text.codePointAt(i),raw=String.fromCodePoint(codePoint);
+      const replaced=(this.opts.substitute||[]).some(([lo,hi])=>codePoint>=lo&&codePoint<=hi)?'\ufffd':raw;
+      state.push({codes,uri});
+      if(replaced.length===2)state.push({codes,uri});
+      visible+=replaced;i+=raw.length;
+    }
+    let tokens=[];let run=-1,lastStyle=-1,lastUri=-1;
+    for(const part of SEG.segment(visible)){
+      const ch=part.segment;
+      if(ch==='\n'||ch==='\r'||ch==='\r\n')continue;
+      // A joiner chain after a zero-width space is folded into that cluster;
+      // style changes on the joiners are not interned as separate entries.
+      if(/^\u200d+$/u.test(ch)){
+        let prior=part.index-1;
+        while(prior>=0&&visible[prior]==='\u200d')prior--;
+        if(prior>=0&&visible[prior]==='\u200b')continue;
+      }
+      const width=ch==='\t'?256:Math.min(2,Math.max(0,Bun.stringWidth(ch,{ambiguousIsNarrow:true})));
+      const {codes:style,uri:link}=state[part.index]||{codes:[],uri:''};
+      const sid=this.internStyle(style),uid=this.internUri(link);
+      if(width===0)continue;
+      if(sid!==lastStyle||uid!==lastUri){run++;lastStyle=sid;lastUri=uid}
+      runs[2*run]=sid;runs[2*run+1]=uid;
+      tokens.push({ch:this.internChar(ch),width,sid,uid,run,start:part.index,end:part.index+ch.length});
+    }
+    if(reorder&&tokens.length&&/[\u0590-\u08ff\ufb1d-\ufdff\ufe70-\ufeff]/u.test(visible)){
+      // The native object resolves one visual run across line breaks. bidi-js
+      // treats LF/CR as paragraph separators, so retain their positions as
+      // neutral spaces while calculating the order of the visible cells.
+      const bidiText=visible.replace(/[\n\r]/g,' ');
+      const strong=bidiText.match(/[\p{L}]/u)?.[0];
+      const direction=strong&&/[\u0590-\u08ff\ufb1d-\ufdff\ufe70-\ufeff]/u.test(strong)?'rtl':'ltr';
+      const levels=BIDI.getEmbeddingLevels(bidiText,direction);
+      const rtl=/[\u0590-\u08ff\ufb1d-\ufdff\ufe70-\ufeff]/u;
+      const nearestStrong=(at,step)=>{
+        for(let i=at;i>=0&&i<bidiText.length;i+=step){
+          if(/\p{L}/u.test(bidiText[i]))return rtl.test(bidiText[i])?'rtl':'ltr';
+        }
+        return null;
+      };
+      for(let i=0;i<bidiText.length;i++){
+        const cp=bidiText.codePointAt(i);
+        if(cp<=0xffff)continue;
+        const emoji=String.fromCodePoint(cp);
+        const left=nearestStrong(i-1,-1),right=nearestStrong(i+2,1);
+        const rtlContext=left&&left===right?left==='rtl':direction==='rtl';
+        if(rtlContext){
+          levels.levels[i]=1;levels.levels[i+1]=1;
+          if(direction==='rtl'&&/\p{Extended_Pictographic}/u.test(emoji)){
+            let before=i-1,after=i+2;
+            while(before>=0&&bidiText[before]==='\u200d')levels.levels[before--]=1;
+            while(after<bidiText.length&&bidiText[after]==='\u200d')levels.levels[after++]=1;
+            for(let j=before;j>=0&&bidiText[j]===' ';j--)levels.levels[j]=1;
+            for(let j=after;j<bidiText.length&&bidiText[j]===' ';j++)levels.levels[j]=1;
+          }
+        }
+        i++;
+      }
+      // Reordering is by rendered grapheme. A joiner attached to the prior
+      // grapheme inherits its level instead of forming a separate bidi cell.
+      for(let i=1;i<bidiText.length;i++){
+        if(bidiText[i]==='\u200d')levels.levels[i]=levels.levels[i-1];
+      }
+      // bidi-js resets trailing formatting characters during reordering.
+      // ZWJ belongs to the preceding grapheme here, so preserve its level.
+      const indices=BIDI.getReorderedIndices(bidiText.replace(/\u200d/g,'\ufffc'),levels);
+      const chars=new Int32Array(visible.length).fill(-1);
+      for(let i=0;i<tokens.length;i++)for(let k=tokens[i].start;k<tokens[i].end;k++)chars[k]=i;
+      const seen=new Set(),ordered=[];
+      for(const pos of indices){const i=chars[pos];if(i>=0&&!seen.has(i)){ordered.push(tokens[i]);seen.add(i)}}
+      tokens=ordered;
+    }
+    if(tokens.length*2>cells.length||tokens.length*2>runs.length)return -tokens.length;
+    for(let k=0;k<tokens.length;k++){let {ch,width,run}=tokens[k];cells[2*k]=ch;cells[2*k+1]=width|(run<<10)}
+    return tokens.length;
+  }
+
+  setCell(dst,screenWidth,x,y,ch,word){
+    const maxRows=Math.floor(dst.length/(2*screenWidth));
+    if(x<0||y<0||x>=screenWidth||y>=maxRows)return 65535*1048576+x+1;
+    const ix=2*(y*screenWidth+x),prev=dst[ix+1]&this.opts.screen.widthMask,next=word&this.opts.screen.widthMask;
+    let start=x,end=x+1;
+    if(prev===1&&next!==1&&x+1<screenWidth){const tail=ix+2;if((dst[tail+1]&3)===2){dst[tail]=this.opts.screen.emptyCharIndex;dst[tail+1]=this.opts.screen.emptyWord;end=x+2}}
+    if(prev===2&&next!==2&&x>0){const head=ix-2;if((dst[head+1]&3)===1){dst[head]=this.opts.screen.emptyCharIndex;dst[head+1]=this.opts.screen.emptyWord;start=x-1}}
+    dst[ix]=ch;dst[ix+1]=word;
+    if(next===1&&x+1<screenWidth){
+      if((dst[ix+3]&3)===1&&x+2<screenWidth&&(dst[ix+5]&3)===2){dst[ix+4]=this.opts.screen.emptyCharIndex;dst[ix+5]=this.opts.screen.emptyWord;end=x+3}
+      dst[ix+2]=this.opts.screen.spacerCharIndex;dst[ix+3]=this.opts.screen.spacerTail;end=Math.max(end,x+2)
+    }
+    return end*68719476736+start*1048576+(x+1);
+  }
+  paint(dst,screenWidth,x,y,cells,count,_unused,charIndices,runWords){
+    let start=screenWidth,end=-1,col=x;
+    for(let k=0;k<count;k++){
+      let charId=cells[2*k],packed=cells[2*k+1],width=packed&255;
+      if(packed&256){
+        if(col>=screenWidth)continue;
+        const next=Math.min(screenWidth,(Math.floor(col/this.opts.screen.tabWidth)+1)*this.opts.screen.tabWidth);
+        if(col<screenWidth){start=Math.min(start,col);end=Math.max(end,next);for(let at=col;at<next;at++){const ix=2*(y*screenWidth+at);if(ix>=0&&ix+1<dst.length){dst[ix]=this.opts.screen.emptyCharIndex;dst[ix+1]=this.opts.screen.emptyWord}}}
+        col=next;continue;
+      }
+      if(width<1)continue;
+      if(col>=screenWidth){col+=width===2?1:width;continue}
+      let actual=width===2&&col===screenWidth-1?3:width;
+      const idx=2*(y*screenWidth+col),run=packed>>>10;
+      if(idx<0||idx+1>=dst.length)break;
+      dst[idx]=actual===3?this.opts.screen.emptyCharIndex:charIndices[charId];
+      dst[idx+1]=actual===3?3:(runWords[run]||0)|(actual===2?1:0);
+      start=Math.min(start,col);end=Math.max(end,col+1);
+      if(actual===2&&col+1<screenWidth){dst[idx+2]=this.opts.screen.spacerCharIndex;dst[idx+3]=this.opts.screen.spacerTail;end=Math.max(end,col+2)}
+      col+=actual===3?1:width;
+    }
+    if(end<0)return 65535*1048576+col;
+    return end*68719476736+start*1048576+col;
+  }
+}
+if (typeof Bun.ant?.CellSegmenter !== "function") Bun.ant={...Bun.ant,CellSegmenter};

package/scripts/postinstall.js

@@ -3,6 +3,7 @@
 const fs = require('fs');
 const path = require('path');
 const { execFileSync } = require('child_process');
+const { createHash } = require('crypto');
 
 const PLATFORM_PACKAGES = {
     'darwin-arm64': '@oven/bun-darwin-aarch64',
@@ -12,27 +13,41 @@ const PLATFORM_PACKAGES = {
     'win32-x64': '@oven/bun-windows-x64',
 };
 
-function isBunAvailable() {
+function isBunAvailable(requiredVersion = null) {
     const isWindows = process.platform === 'win32';
     const binName = isWindows ? 'bun.exe' : 'bun';
+    const usable = candidate => {
+        try {
+            const version = execFileSync(candidate, ['--version'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+            return !requiredVersion || version === requiredVersion;
+        } catch { return false; }
+    };
 
     // 1. PATH
-    try {
-        execFileSync(binName, ['--version'], { stdio: 'ignore' });
-        return true;
-    } catch {}
+    if (!requiredVersion && usable(binName)) return true;
 
     // 2. npm's bun package names the launcher bun.exe even on Unix.
     for (const spec of ['bun/bin/bun.exe', 'bun/bin/bun']) {
         try {
             const resolved = require.resolve(spec, { paths: [path.join(__dirname, '..')] });
-            if (fs.existsSync(resolved)) return true;
+            if (fs.existsSync(resolved) && usable(resolved)) return true;
+        } catch {}
+    }
+
+    // bun's wrapper can be a non-executable placeholder if its install script
+    // was skipped; the platform package may still contain a usable binary.
+    const platformPkg = PLATFORM_PACKAGES[`${process.platform}-${process.arch}`];
+    if (platformPkg) {
+        try {
+            const dir = path.dirname(require.resolve(`${platformPkg}/package.json`, { paths: [path.join(__dirname, '..')] }));
+            const candidate = path.join(dir, 'bin', binName);
+            if (usable(candidate)) return true;
         } catch {}
     }
 
     // 3. ~/.bun/bin/bun (curl bun.sh/install fallback location)
     const home = process.env.HOME || process.env.USERPROFILE || '';
-    if (home && fs.existsSync(path.join(home, '.bun', 'bin', binName))) {
+    if (!requiredVersion && home && fs.existsSync(path.join(home, '.bun', 'bin', binName))) {
         return true;
     }
 
@@ -43,25 +58,6 @@ function npmCmd() {
     return process.platform === 'win32' ? 'npm.cmd' : 'npm';
 }
 
-// Native Claude packages execute the bundled Anthropic runtime. Public Bun is
-// needed only for building cc.js or launching older public-runtime artifacts.
-function hasNativeClaudeRuntime(packageRoot = path.join(__dirname, '..'), platform = process.platform, arch = process.arch) {
-    const platformKey = `${platform}-${arch}`;
-    const dir = path.join(packageRoot, 'dist', platformKey);
-    const manifestPath = path.join(dir, 'cc-runtime.json');
-    try {
-        const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-        const executable = platform === 'win32' ? 'cc-native.exe' : 'cc-native';
-        return manifest.schemaVersion === 1 && manifest.mode === 'anthropic-native' &&
-            manifest.platform === platformKey && manifest.executable === executable &&
-            fs.existsSync(path.join(dir, 'cc.js')) &&
-            fs.existsSync(path.join(dir, executable)) &&
-            fs.existsSync(path.join(dir, `${executable}.mjs`));
-    } catch {
-        return false;
-    }
-}
-
 function installClaudeSidecars(packageRoot = path.join(__dirname, '..'), platform = process.platform, arch = process.arch) {
     const markerPath = path.join(packageRoot, 'dist', 'claude-sidecar-release.json');
     if (!fs.existsSync(markerPath)) return false; // Source checkout / old-style local build.
@@ -70,6 +66,7 @@ function installClaudeSidecars(packageRoot = path.join(__dirname, '..'), platfor
     if (marker.schemaVersion !== 1 || !marker.platforms?.includes(platformKey)) {
         throw new Error(`Claude sidecar release does not support ${platformKey}`);
     }
+    if (marker.mode !== 'public-shim') throw new Error(`Unsupported Claude sidecar mode: ${marker.mode}`);
     let sidecars = path.join(packageRoot, 'dist', platformKey);
     if (marker.packageVersion) {
         const sidecarName = `makecoder-c-bin-${platformKey === 'win32-x64' ? 'win-x64' : platformKey}`;
@@ -85,22 +82,28 @@ function installClaudeSidecars(packageRoot = path.join(__dirname, '..'), platfor
         }
         sidecars = path.join(sidecarPackage, 'dist', platformKey);
     }
-    const packageName = `@anthropic-ai/claude-code-${platformKey}`;
-    let officialPackage;
-    try {
-        officialPackage = path.dirname(require.resolve(`${packageName}/package.json`, { paths: [packageRoot] }));
-    } catch {
-        throw new Error(`Official Claude runtime ${packageName}@${marker.version} is missing. Reinstall with optional dependencies enabled.`);
+    const manifest = JSON.parse(fs.readFileSync(path.join(sidecars, 'cc-runtime.json'), 'utf8'));
+    if (manifest.schemaVersion !== 1 || manifest.mode !== 'public-shim' ||
+        manifest.platform !== platformKey || manifest.version !== marker.version ||
+        manifest.shimFile !== 'cc-cell-segmenter-shim.js') {
+        throw new Error(`Invalid Claude public Bun sidecar for ${platformKey}`);
+    }
+    for (const [file, digest] of [['cc.js', manifest.bundleSha256],
+        [manifest.shimFile, manifest.shimSha256]]) {
+        if (!/^[a-f0-9]{64}$/.test(digest) ||
+            createHash('sha256').update(fs.readFileSync(path.join(sidecars, file))).digest('hex') !== digest) {
+            throw new Error(`Claude public Bun sidecar hash mismatch: ${file}`);
+        }
     }
-    const officialManifest = JSON.parse(fs.readFileSync(path.join(officialPackage, 'package.json'), 'utf8'));
-    if (officialManifest.name !== packageName || officialManifest.version !== marker.version) {
-        throw new Error(`Official Claude runtime version mismatch: expected ${packageName}@${marker.version}`);
+    if (['cc-native', 'cc-native.exe', 'cc-native.mjs', 'cc-native.exe.mjs'].some(file =>
+        fs.existsSync(path.join(sidecars, file)))) {
+        throw new Error('Claude public Bun sidecar contains an obsolete native runtime');
     }
     const output = path.join(packageRoot, 'dist', platformKey);
-    execFileSync(process.execPath, [path.join(packageRoot, 'scripts', 'assemble-claude-native.mjs'),
-        officialPackage, sidecars, output], { cwd: packageRoot, stdio: 'inherit', timeout: 120000 });
-    if (!hasNativeClaudeRuntime(packageRoot, platform, arch)) {
-        throw new Error(`Claude runtime assembly did not produce a usable ${platformKey} artifact`);
+    fs.mkdirSync(output, { recursive: true });
+    fs.cpSync(sidecars, output, { recursive: true, force: true });
+    for (const file of ['cc-native', 'cc-native.exe', 'cc-native.mjs', 'cc-native.exe.mjs']) {
+        fs.rmSync(path.join(output, file), { force: true });
     }
     return true;
 }
@@ -274,8 +277,10 @@ function installBun() {
         return;
     }
 
-    console.log(`bun not found, installing ${platformPkg} via npm...`);
     const installDir = path.join(__dirname, '..');
+    const pinnedBun = JSON.parse(fs.readFileSync(path.join(installDir, 'package.json'), 'utf8')).dependencies?.bun;
+    const bunSpec = pinnedBun && /^\d+\.\d+\.\d+$/.test(pinnedBun) ? `bun@${pinnedBun}` : 'bun@latest';
+    console.log(`bun not found, installing ${bunSpec} and ${platformPkg} via npm...`);
 
     // Install into makecoder's own node_modules so _resolveBunPath()'s
     // require.resolve('bun/bin/bun.exe') and the @oven fallback can find it.
@@ -284,7 +289,7 @@ function installBun() {
     try {
         execFileSync(
             npmCmd(),
-            ['install', '--no-save', '--no-audit', '--no-fund', `bun@latest`, platformPkg],
+            ['install', '--no-save', '--no-audit', '--no-fund', bunSpec, platformPkg],
             { cwd: installDir, stdio: 'inherit' },
         );
         console.log('bun installed successfully.');
@@ -297,10 +302,13 @@ function installBun() {
 
 function main() {
     try {
-        const assembled = installClaudeSidecars();
-        if (!assembled && !hasNativeClaudeRuntime() && !isBunAvailable()) {
+        installClaudeSidecars();
+        if (!isBunAvailable('1.3.14')) {
             installBun();
         }
+        if (!isBunAvailable('1.3.14')) {
+            throw new Error('bun@1.3.14 is required for this Claude sidecar release');
+        }
     } catch (error) {
         console.error('Error during postinstall setup:', error.message);
         process.exit(1);
@@ -333,4 +341,4 @@ if (require.main === module) {
     main();
 }
 
-module.exports = { main, checkCodexCodeModeHost, ensureNodePtyHelperExecutable, hasNativeClaudeRuntime, installClaudeSidecars };
+module.exports = { main, checkCodexCodeModeHost, ensureNodePtyHelperExecutable, installClaudeSidecars };

package/scripts/assemble-claude-native.mjs

@@ -1,142 +0,0 @@
-#!/usr/bin/env node
-/** Assemble a MakeCoder UI runtime from the official platform binary and patch sidecars. */
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { execFileSync } from "node:child_process";
-import { bootstrapSource, inspectModuleGraph, loaderSource, replaceEntry, sha256 } from "./claude-native-runtime.mjs";
-
-const excluded = new Set(["cc-runtime.json", "cc-native", "cc-native.exe",
-  "cc-native.mjs", "cc-native.exe.mjs"]);
-const windowsLockErrors = new Set(["EPERM", "EACCES", "EBUSY"]);
-const retrySignal = new Int32Array(new SharedArrayBuffer(4));
-
-export function renameWithWindowsRetry(source, target, {
-  platform = process.platform,
-  rename = fs.renameSync,
-  pause = ms => Atomics.wait(retrySignal, 0, 0, ms),
-} = {}) {
-  for (let attempt = 0; ; attempt++) {
-    try {
-      return rename(source, target);
-    } catch (error) {
-      if (platform !== "win32" || !windowsLockErrors.has(error.code) || attempt >= 20) throw error;
-      // A just-exited executable can still have an open handle on Windows.
-      pause(500);
-    }
-  }
-}
-
-export function assembleNative(officialDir, sidecarDir, outputDir) {
-  const official = fs.realpathSync(officialDir);
-  const sidecars = fs.realpathSync(sidecarDir);
-  const output = path.resolve(outputDir);
-  if (output === official || output.startsWith(official + path.sep) ||
-      (output !== sidecars && output.startsWith(sidecars + path.sep))) {
-    throw new Error("Output cannot be inside the official package or patch sidecars");
-  }
-  const pkg = JSON.parse(fs.readFileSync(path.join(official, "package.json"), "utf8"));
-  const platform = pkg.name?.replace(/^@anthropic-ai\/claude-code-/, "");
-  if (!/^@anthropic-ai\/claude-code-(darwin-(arm64|x64)|linux-(arm64|x64)|win32-x64)$/.test(pkg.name) ||
-      !/^\d+\.\d+\.\d+$/.test(pkg.version)) {
-    throw new Error("Expected a versioned official Claude platform package");
-  }
-  const patch = JSON.parse(fs.readFileSync(path.join(sidecars, "cc-runtime.json"), "utf8"));
-  if (patch.schemaVersion !== 1 || patch.mode !== "anthropic-native" ||
-      patch.platform !== platform || patch.version !== pkg.version || patch.package !== pkg.name) {
-    throw new Error("Patch sidecars and official package must have the same platform and version");
-  }
-  const sourceBinary = path.join(official, platform === "win32-x64" ? "claude.exe" : "claude");
-  const upstream = fs.readFileSync(sourceBinary);
-  if (sha256(upstream) !== patch.upstreamSha256 || inspectModuleGraph(upstream).platform !== platform) {
-    throw new Error("Official binary does not match the binary used to build the patch sidecars");
-  }
-  if (sha256(fs.readFileSync(path.join(sidecars, "cc.js"))) !== patch.bundleSha256) {
-    throw new Error("Patch sidecar bundle hash mismatch");
-  }
-  if (platform.startsWith("darwin")) {
-    if (process.platform !== "darwin") throw new Error("macOS assembly requires macOS codesign");
-    execFileSync("codesign", ["--verify", "--strict", sourceBinary], { stdio: "inherit" });
-  }
-  if (fs.existsSync(output)) {
-    const previous = JSON.parse(fs.readFileSync(path.join(output, "cc-runtime.json"), "utf8"));
-    if (previous.schemaVersion !== 1 || previous.mode !== "anthropic-native") {
-      throw new Error(`Output is not a generated native artifact: ${output}`);
-    }
-  }
-  fs.mkdirSync(path.dirname(output), { recursive: true });
-  const staging = fs.mkdtempSync(path.join(path.dirname(output), ".claude-assembled-"));
-  const backup = staging + "-previous";
-  let assemblyError;
-  try {
-    for (const name of fs.readdirSync(sidecars)) {
-      if (!excluded.has(name)) fs.cpSync(path.join(sidecars, name), path.join(staging, name), { recursive: true });
-    }
-    const executable = platform === "win32-x64" ? "cc-native.exe" : "cc-native";
-    const nativePath = path.join(staging, executable);
-    fs.writeFileSync(nativePath + ".mjs", loaderSource(patch.bundleSha256));
-    fs.writeFileSync(nativePath,
-      replaceEntry(upstream, bootstrapSource(patch.bundleSha256, pkg.version), platform), { mode: 0o755 });
-    if (platform.startsWith("darwin")) {
-      execFileSync("codesign", ["--force", "--sign", process.env.CODER_CODESIGN_IDENTITY || "-", nativePath], { stdio: "inherit" });
-      execFileSync("codesign", ["--verify", "--strict", nativePath], { stdio: "inherit" });
-    }
-    const manifest = {
-      schemaVersion: 1, mode: "anthropic-native", platform, version: pkg.version,
-      package: pkg.name, source: patch.source, upstreamSha256: patch.upstreamSha256,
-      bundleSha256: patch.bundleSha256, executable,
-      runtimeSha256: sha256(fs.readFileSync(nativePath)),
-      loaderSha256: sha256(fs.readFileSync(nativePath + ".mjs")),
-      signing: platform.startsWith("darwin") ? (process.env.CODER_CODESIGN_IDENTITY ? "identity" : "ad-hoc") :
-        platform === "win32-x64" ? "unsigned" : "not-applicable",
-    };
-    if (platform === `${process.platform}-${process.arch}`) {
-      const probe = JSON.parse(execFileSync(nativePath, ["--coder-runtime-info"], { encoding: "utf8", timeout: 30000 }));
-      if (probe.cellSegmenter !== "function" || probe.bundleSha256 !== patch.bundleSha256 ||
-          `${probe.platform}-${probe.arch}` !== platform || probe.version !== pkg.version) {
-        throw new Error("Assembled native runtime capability probe failed");
-      }
-      manifest.bunVersion = probe.bun;
-      const version = execFileSync(nativePath, ["--version"], { encoding: "utf8", timeout: 30000 });
-      if (!version.includes(`${pkg.version} (Claude Code)`)) {
-        throw new Error("Assembled native runtime failed to load the MakeCoder CLI");
-      }
-    }
-    fs.writeFileSync(path.join(staging, "cc-runtime.json"), JSON.stringify(manifest, null, 2) + "\n");
-    // mkdtemp creates a 0700 directory. Docker image builds assemble as root,
-    // but the CLI runs as an unprivileged user after the image is published.
-    if (process.platform !== "win32") fs.chmodSync(staging, 0o755);
-    if (fs.existsSync(output)) renameWithWindowsRetry(output, backup);
-    try { renameWithWindowsRetry(staging, output); }
-    catch (error) {
-      if (fs.existsSync(backup)) {
-        try { renameWithWindowsRetry(backup, output); }
-        catch (restoreError) {
-          throw new AggregateError([error, restoreError], "Failed to install Claude runtime and restore the previous artifact");
-        }
-      }
-      throw error;
-    }
-    fs.rmSync(backup, { recursive: true, force: true, maxRetries: 10, retryDelay: 500 });
-    console.log(`Assembled ${pkg.name}@${pkg.version} -> ${output}`);
-  } catch (error) {
-    assemblyError = error;
-    throw error;
-  } finally {
-    try {
-      // Windows can briefly lock an executable after execFileSync returns.
-      fs.rmSync(staging, { recursive: true, force: true, maxRetries: 10, retryDelay: 500 });
-    } catch (cleanupError) {
-      if (!assemblyError) throw cleanupError;
-      console.warn(`Could not clean staging directory ${staging}: ${cleanupError.message}`);
-    }
-  }
-}
-
-if (process.argv[1] && fileURLToPath(import.meta.url) === path.resolve(process.argv[1])) {
-  const [official, sidecars, output, ...rest] = process.argv.slice(2);
-  if (!official || !sidecars || !output || rest.length) {
-    throw new Error("Usage: assemble-claude-native.mjs <official-platform-package> <patch-sidecars> <output>");
-  }
-  assembleNative(official, sidecars, output);
-}