agentgui 1.0.273 → 1.0.274

package/build-portable.js

@@ -0,0 +1,150 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { execSync, execFileSync } from 'child_process';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const src = __dirname;
+const out = path.join(src, '..', 'wagentgui');
+const nm = path.join(src, 'node_modules');
+const BUN_WIN_CACHE = path.join(process.env.HOME, '.bun', 'install', 'cache', 'bun-windows-x64-v1.3.9');
+
+function log(msg) { console.log('[BUILD] ' + msg); }
+
+function rmrf(dir) {
+  if (!fs.existsSync(dir)) return;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const fp = path.join(dir, entry.name);
+    if (entry.isDirectory()) fs.rmSync(fp, { recursive: true, force: true });
+    else fs.unlinkSync(fp);
+  }
+}
+
+function copyDir(from, to) {
+  if (!fs.existsSync(from)) return;
+  fs.mkdirSync(to, { recursive: true });
+  for (const entry of fs.readdirSync(from, { withFileTypes: true })) {
+    const s = path.join(from, entry.name);
+    const d = path.join(to, entry.name);
+    if (entry.isDirectory()) copyDir(s, d);
+    else fs.copyFileSync(s, d);
+  }
+}
+
+function copyFile(from, to) {
+  fs.mkdirSync(path.dirname(to), { recursive: true });
+  fs.copyFileSync(from, to);
+}
+
+function sizeOf(dir) {
+  if (!fs.existsSync(dir)) return 0;
+  let sz = 0;
+  for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+    const fp = path.join(dir, e.name);
+    sz += e.isDirectory() ? sizeOf(fp) : fs.statSync(fp).size;
+  }
+  return sz;
+}
+
+function ensureWinBun() {
+  if (fs.existsSync(BUN_WIN_CACHE)) {
+    const stat = fs.statSync(BUN_WIN_CACHE);
+    if (stat.size > 50 * 1024 * 1024) {
+      // Verify it's a PE file
+      const buf = Buffer.alloc(2);
+      const fd = fs.openSync(BUN_WIN_CACHE, 'r');
+      fs.readSync(fd, buf, 0, 2, 0);
+      fs.closeSync(fd);
+      if (buf[0] === 0x4D && buf[1] === 0x5A) return BUN_WIN_CACHE;
+    }
+  }
+  log('Downloading Windows Bun binary...');
+  execSync(
+    `~/.bun/bin/bun build --compile --target=bun-windows-x64 --outfile=/tmp/_bun_trigger.exe /dev/null 2>/dev/null || true`,
+    { stdio: 'inherit' }
+  );
+  if (fs.existsSync(BUN_WIN_CACHE)) return BUN_WIN_CACHE;
+  throw new Error(`Windows Bun binary not found at ${BUN_WIN_CACHE}. Run: bun build --compile --target=bun-windows-x64 --outfile=/tmp/x.exe /dev/null`);
+}
+
+log('Output: ' + out);
+rmrf(out);
+fs.mkdirSync(out, { recursive: true });
+
+log('Building JS bundle...');
+execSync(
+  `~/.bun/bin/bun build --minify --target=bun --outfile=${path.join(out, 'bundle.js')} ${path.join(src, 'portable-entry.js')}`,
+  { stdio: 'inherit', cwd: src }
+);
+const bundleSize = fs.statSync(path.join(out, 'bundle.js')).size;
+log(`Bundle: ${Math.round(bundleSize / 1024)}KB`);
+
+log('Locating Windows Bun binary...');
+const bunWinPath = ensureWinBun();
+log(`Windows Bun: ${bunWinPath} (${Math.round(fs.statSync(bunWinPath).size / 1024 / 1024)}MB)`);
+
+log('Injecting bundle into Windows Bun exe (.bun PE section)...');
+const injector = path.join(src, 'scripts', 'inject-pe-section.py');
+execFileSync('python3', [
+  injector,
+  bunWinPath,
+  path.join(out, 'bundle.js'),
+  path.join(out, 'agentgui.exe')
+], { stdio: 'inherit' });
+fs.unlinkSync(path.join(out, 'bundle.js'));
+
+const exeSize = fs.statSync(path.join(out, 'agentgui.exe')).size;
+// Verify PE magic
+const buf = Buffer.alloc(2);
+const fd = fs.openSync(path.join(out, 'agentgui.exe'), 'r');
+fs.readSync(fd, buf, 0, 2, 0);
+fs.closeSync(fd);
+if (buf[0] !== 0x4D || buf[1] !== 0x5A) throw new Error('Output exe is not a valid PE file (bad MZ magic)');
+log(`Exe compiled: ${Math.round(exeSize / 1024 / 1024)}MB (valid PE)`);
+
+log('Copying static files...');
+copyDir(path.join(src, 'static'), path.join(out, 'static'));
+
+const destNm = path.join(out, 'node_modules');
+
+log('Copying @huggingface/transformers (dist + win32 natives)...');
+const hfSrc = path.join(nm, '@huggingface', 'transformers');
+const hfDest = path.join(destNm, '@huggingface', 'transformers');
+copyFile(path.join(hfSrc, 'package.json'), path.join(hfDest, 'package.json'));
+copyDir(path.join(hfSrc, 'dist'), path.join(hfDest, 'dist'));
+const hfNmSrc = path.join(hfSrc, 'node_modules');
+const hfNmDest = path.join(hfDest, 'node_modules');
+const hfOnnxSrc = path.join(hfNmSrc, 'onnxruntime-node');
+const hfOnnxDest = path.join(hfNmDest, 'onnxruntime-node');
+copyFile(path.join(hfOnnxSrc, 'package.json'), path.join(hfOnnxDest, 'package.json'));
+copyDir(path.join(hfOnnxSrc, 'dist'), path.join(hfOnnxDest, 'dist'));
+copyDir(path.join(hfOnnxSrc, 'lib'), path.join(hfOnnxDest, 'lib'));
+copyDir(path.join(hfOnnxSrc, 'bin', 'napi-v3', 'win32', 'x64'), path.join(hfOnnxDest, 'bin', 'napi-v3', 'win32', 'x64'));
+copyDir(path.join(hfNmSrc, 'onnxruntime-common'), path.join(hfNmDest, 'onnxruntime-common'));
+
+log('Copying webtalk...');
+copyDir(path.join(nm, 'webtalk'), path.join(destNm, 'webtalk'));
+
+log('Copying @anthropic-ai/claude-code ripgrep (win32)...');
+const claudeSrc = path.join(nm, '@anthropic-ai', 'claude-code');
+const claudeDest = path.join(destNm, '@anthropic-ai', 'claude-code');
+copyFile(path.join(claudeSrc, 'package.json'), path.join(claudeDest, 'package.json'));
+copyDir(path.join(claudeSrc, 'vendor', 'ripgrep', 'x64-win32'), path.join(claudeDest, 'vendor', 'ripgrep', 'x64-win32'));
+
+log('Creating data directory...');
+fs.mkdirSync(path.join(out, 'data'), { recursive: true });
+
+fs.writeFileSync(path.join(out, 'README.txt'), [
+  '# AgentGUI Portable',
+  '',
+  'No installation required. Double-click agentgui.exe to start.',
+  '',
+  'Web interface: http://localhost:3000/gm/',
+  '',
+  'Data is stored in the data/ folder next to the executable.',
+  '',
+  'Requirements: None - fully self-contained.',
+].join('\n'));
+
+const totalMB = Math.round(sizeOf(out) / 1024 / 1024);
+log(`Build complete! Total: ${totalMB}MB  Output: ${out}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.273",
+  "version": "1.0.274",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",

package/portable-entry.js

@@ -0,0 +1,43 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs';
+import { spawn } from 'child_process';
+
+function getExeDir() {
+  if (process.execPath && process.execPath !== process.argv[0]) {
+    return path.dirname(process.execPath);
+  }
+  if (process.argv[1]) {
+    const argv1 = path.resolve(process.argv[1]);
+    if (fs.existsSync(argv1) || fs.existsSync(argv1 + '.exe')) {
+      return path.dirname(argv1);
+    }
+  }
+  return process.cwd();
+}
+
+const exeDir = getExeDir();
+const dataDir = path.join(exeDir, 'data');
+
+if (!fs.existsSync(dataDir)) fs.mkdirSync(dataDir, { recursive: true });
+
+process.env.PORTABLE_DATA_DIR = dataDir;
+process.env.PORTABLE_EXE_DIR = exeDir;
+process.env.BASE_URL = process.env.BASE_URL || '/gm';
+process.env.PORT = process.env.PORT || '3000';
+process.env.STARTUP_CWD = process.env.STARTUP_CWD || exeDir;
+
+const port = process.env.PORT;
+const baseUrl = process.env.BASE_URL;
+const url = `http://localhost:${port}${baseUrl}/`;
+
+console.log(`[AgentGUI Portable] Exe directory: ${exeDir}`);
+console.log(`[AgentGUI Portable] Data directory: ${dataDir}`);
+console.log(`[AgentGUI Portable] Server starting on ${url}`);
+
+setTimeout(() => {
+  const cmd = process.platform === 'win32' ? 'start' : process.platform === 'darwin' ? 'open' : 'xdg-open';
+  spawn(cmd, [url], { shell: true, detached: true, stdio: 'ignore' }).unref();
+}, 1500);
+
+await import('./server.js');

package/scripts/inject-pe-section.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+"""
+Injects a .bun section into a Windows PE executable (bun standalone format).
+Usage: inject-pe-section.py <bun-exe> <bundle-bytes> <output-exe>
+"""
+
+import sys
+import struct
+import os
+
+def align_up(value, alignment):
+    return (value + alignment - 1) & ~(alignment - 1)
+
+def read_u16(data, offset): return struct.unpack_from('<H', data, offset)[0]
+def read_u32(data, offset): return struct.unpack_from('<I', data, offset)[0]
+def read_u64(data, offset): return struct.unpack_from('<Q', data, offset)[0]
+def write_u16(data, offset, val): struct.pack_into('<H', data, offset, val)
+def write_u32(data, offset, val): struct.pack_into('<I', data, offset, val)
+def write_u64(data, offset, val): struct.pack_into('<Q', data, offset, val)
+
+def add_bun_section(pe_bytes, bundle_bytes):
+    data = bytearray(pe_bytes)
+
+    # PE header offset at 0x3C
+    e_lfanew = read_u32(data, 0x3C)
+    pe_sig = data[e_lfanew:e_lfanew+4]
+    assert pe_sig == b'PE\0\0', f"Not a PE file: {pe_sig!r}"
+
+    coff_offset = e_lfanew + 4
+    machine = read_u16(data, coff_offset)
+    num_sections = read_u16(data, coff_offset + 2)
+    size_of_optional = read_u16(data, coff_offset + 16)
+
+    opt_offset = coff_offset + 20
+    magic = read_u16(data, opt_offset)
+    assert magic == 0x20B, f"Expected PE32+ (0x20B), got 0x{magic:X}"
+
+    # Optional header fields (PE32+)
+    file_alignment    = read_u32(data, opt_offset + 36)
+    section_alignment = read_u32(data, opt_offset + 32)
+    size_of_image     = read_u32(data, opt_offset + 56)
+    size_of_headers   = read_u32(data, opt_offset + 60)
+    checksum_offset   = opt_offset + 64
+    # Data directories start at opt_offset + 112 for PE32+
+    # Security directory is entry 4
+    security_dd_offset = opt_offset + 112 + 4 * 8  # entry 4, each entry 8 bytes
+
+    # Section headers follow the optional header
+    section_headers_offset = opt_offset + size_of_optional
+    SECTION_HEADER_SIZE = 40
+
+    # Parse existing sections
+    sections = []
+    for i in range(num_sections):
+        off = section_headers_offset + i * SECTION_HEADER_SIZE
+        name         = data[off:off+8]
+        virtual_size = read_u32(data, off + 8)
+        virtual_addr = read_u32(data, off + 12)
+        raw_size     = read_u32(data, off + 16)
+        raw_ptr      = read_u32(data, off + 20)
+        chars        = read_u32(data, off + 36)
+        sections.append({
+            'name': name, 'virtual_size': virtual_size, 'virtual_addr': virtual_addr,
+            'raw_size': raw_size, 'raw_ptr': raw_ptr, 'chars': chars, 'off': off
+        })
+
+        if name == b'.bun\0\0\0\0':
+            raise ValueError("PE already has a .bun section")
+
+    assert num_sections < 96, "Too many sections"
+
+    # Check header space
+    new_sh_off = section_headers_offset + num_sections * SECTION_HEADER_SIZE
+    new_sh_end = new_sh_off + SECTION_HEADER_SIZE
+    first_raw = min((s['raw_ptr'] for s in sections if s['raw_size'] > 0), default=len(data))
+    new_size_of_headers = align_up(new_sh_end, file_alignment)
+    assert new_size_of_headers <= first_raw, f"Insufficient header space: need {new_size_of_headers}, first_raw={first_raw}"
+
+    # Find last file end and last va end
+    last_file_end = max((s['raw_ptr'] + s['raw_size'] for s in sections), default=0)
+    last_va_end = max(
+        (s['virtual_addr'] + align_up(max(s['virtual_size'], s['raw_size']), section_alignment)
+         for s in sections),
+        default=0
+    )
+
+    payload_len = len(bundle_bytes) + 8  # 8-byte u64 LE length prefix
+    raw_size_new = align_up(payload_len, file_alignment)
+    new_va  = align_up(last_va_end, section_alignment)
+    new_raw = align_up(last_file_end, file_alignment)
+
+    # Extend data buffer
+    new_file_size = new_raw + raw_size_new
+    if len(data) < new_file_size:
+        data.extend(b'\0' * (new_file_size - len(data)))
+    else:
+        # Zero the new section area
+        data[new_raw:new_file_size] = b'\0' * raw_size_new
+
+    # Write new section header
+    IMAGE_SCN_CNT_INITIALIZED_DATA = 0x00000040
+    IMAGE_SCN_MEM_READ              = 0x40000000
+    sh = bytearray(SECTION_HEADER_SIZE)
+    sh[0:8] = b'.bun\0\0\0\0'
+    struct.pack_into('<I', sh, 8,  payload_len)   # VirtualSize
+    struct.pack_into('<I', sh, 12, new_va)          # VirtualAddress
+    struct.pack_into('<I', sh, 16, raw_size_new)    # SizeOfRawData
+    struct.pack_into('<I', sh, 20, new_raw)          # PointerToRawData
+    struct.pack_into('<I', sh, 36, IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ)
+    data[new_sh_off:new_sh_off + SECTION_HEADER_SIZE] = sh
+
+    # Write payload: u64 LE length + bundle bytes
+    write_u64(data, new_raw, len(bundle_bytes))
+    data[new_raw + 8: new_raw + 8 + len(bundle_bytes)] = bundle_bytes
+
+    # Update COFF: number_of_sections
+    write_u16(data, coff_offset + 2, num_sections + 1)
+
+    # Update optional header
+    if size_of_headers < new_size_of_headers:
+        write_u32(data, opt_offset + 60, new_size_of_headers)
+
+    # size_of_image: aligned end of new section
+    new_size_of_image = align_up(new_va + payload_len, section_alignment)
+    write_u32(data, opt_offset + 56, new_size_of_image)
+
+    # Clear security directory (signature invalidated)
+    data[security_dd_offset:security_dd_offset + 8] = b'\0' * 8
+
+    # Recompute PE checksum
+    data = recompute_checksum(data, checksum_offset)
+
+    return bytes(data)
+
+
+def recompute_checksum(data, checksum_offset):
+    # Zero out the checksum field first
+    write_u32(data, checksum_offset, 0)
+
+    checksum = 0
+    # Process data as u16 pairs
+    for i in range(0, len(data) - 1, 2):
+        val = struct.unpack_from('<H', data, i)[0]
+        checksum += val
+        if checksum > 0xFFFFFFFF:
+            checksum = (checksum & 0xFFFFFFFF) + (checksum >> 32)
+
+    if len(data) % 2:
+        checksum += data[-1]
+
+    # Fold to 32 bits
+    checksum = (checksum & 0xFFFF) + (checksum >> 16)
+    checksum += checksum >> 16
+    checksum &= 0xFFFF
+    checksum += len(data)
+
+    write_u32(data, checksum_offset, checksum)
+    return data
+
+
+if __name__ == '__main__':
+    if len(sys.argv) != 4:
+        print(f"Usage: {sys.argv[0]} <bun-exe> <bundle-js> <output-exe>")
+        sys.exit(1)
+
+    bun_path, bundle_path, out_path = sys.argv[1], sys.argv[2], sys.argv[3]
+
+    with open(bun_path, 'rb') as f:
+        pe_bytes = f.read()
+
+    with open(bundle_path, 'rb') as f:
+        bundle_bytes = f.read()
+
+    print(f"Bun exe: {len(pe_bytes)//1024//1024}MB, Bundle: {len(bundle_bytes)//1024}KB")
+
+    result = add_bun_section(pe_bytes, bundle_bytes)
+
+    with open(out_path, 'wb') as f:
+        f.write(result)
+
+    try:
+        os.chmod(out_path, 0o755)
+    except (PermissionError, OSError):
+        pass
+    print(f"Output: {len(result)//1024//1024}MB -> {out_path}")