claude-simple 0.2.28 → 0.2.31

package/src/platform.js

@@ -0,0 +1,133 @@
+/**
+ * OS helpers so Edge can run on Windows as well as macOS/Linux.
+ * Unix remains the default; Windows gets cmd/PowerShell, .cmd spawn, and
+ * case-insensitive path checks.
+ */
+import path from 'path';
+import os from 'os';
+import fs from 'fs';
+
+export function isWin(platform = process.platform) {
+  return platform === 'win32';
+}
+
+export function expandHome(p, home = os.homedir()) {
+  if (!p) return p;
+  if (p === '~') return home;
+  if (p.startsWith('~/') || p.startsWith('~\\')) return path.join(home, p.slice(2));
+  return p;
+}
+
+function normalizeForCompare(p, platform) {
+  let s = String(p);
+  if (isWin(platform)) s = s.replace(/[/\\]+/g, '\\').replace(/\\+$/, '');
+  else s = path.normalize(s);
+  return isWin(platform) ? s.toLowerCase() : s;
+}
+
+export function pathsEqual(a, b, platform = process.platform) {
+  if (a == null || b == null) return a === b;
+  return normalizeForCompare(a, platform) === normalizeForCompare(b, platform);
+}
+
+/** True if `resolved` is `base` or a descendant (not a sibling prefix). */
+export function containedPath(base, resolved, platform = process.platform) {
+  const b = path.resolve(base);
+  const r = path.resolve(resolved);
+  const rel = path.relative(b, r);
+  if (!rel) return true;
+  if (path.isAbsolute(rel)) return false;
+  const first = rel.split(/[/\\]/)[0];
+  if (first === '..') return false;
+  if (isWin(platform) && rel.toLowerCase().startsWith('..')) return false;
+  return true;
+}
+
+export function defaultInteractiveShell({ platform = process.platform, env = process.env } = {}) {
+  if (isWin(platform)) {
+    const comspec = env.ComSpec || env.COMSPEC;
+    const shellEnv = env.SHELL || '';
+    // Git Bash sets SHELL=...\bash.exe; Edge still wants a native Windows shell.
+    if (shellEnv && /\.(exe|cmd|bat)$/i.test(shellEnv) && !/(^|[\\/])(bash|zsh|sh|dash|fish)(\.exe)?$/i.test(shellEnv)) {
+      return { bin: shellEnv, args: [] };
+    }
+    const sysroot = env.SystemRoot || env.SYSTEMROOT || 'C:\\Windows';
+    const ps = path.join(sysroot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+    if (fs.existsSync(ps)) {
+      return { bin: ps, args: ['-NoLogo', '-NoExit'] };
+    }
+    return { bin: comspec || path.join(sysroot, 'System32', 'cmd.exe'), args: [] };
+  }
+  return { bin: env.SHELL || 'zsh', args: ['-i'] };
+}
+
+export function shellExecSpec(command, { platform = process.platform, env = process.env } = {}) {
+  if (isWin(platform)) {
+    const sysroot = env.SystemRoot || env.SYSTEMROOT || 'C:\\Windows';
+    const cmd = env.ComSpec || env.COMSPEC || path.join(sysroot, 'System32', 'cmd.exe');
+    return { bin: cmd, args: ['/d', '/s', '/c', command] };
+  }
+  const bin = env.SHELL || 'bash';
+  return { bin, args: ['-c', command] };
+}
+
+export function spawnCommandOpts({ platform = process.platform, extra = {} } = {}) {
+  if (isWin(platform)) {
+    return { shell: true, windowsHide: true, ...extra };
+  }
+  return { shell: false, ...extra };
+}
+
+export function processKillSignal(platform = process.platform) {
+  return isWin(platform) ? 'SIGTERM' : 'SIGHUP';
+}
+
+export function userLocalBinDirs(home = os.homedir(), platform = process.platform) {
+  const dirs = [
+    path.join(home, '.local', 'bin'),
+    path.join(home, 'bin'),
+    path.join(home, '.grok', 'bin'),
+  ];
+  if (isWin(platform)) {
+    dirs.push(
+      path.join(home, 'AppData', 'Roaming', 'npm'),
+      path.join(home, 'AppData', 'Local', 'npm'),
+    );
+  }
+  return dirs;
+}
+
+/**
+ * Resolve a bare command to an absolute .exe/.cmd on Windows so agents can be
+ * spawned with stdio pipes and shell:false. Unix returns the name unchanged.
+ */
+export function resolveWinExecutable(command, {
+  platform = process.platform,
+  env = process.env,
+  extraDirs = [],
+  exists = fs.existsSync,
+} = {}) {
+  if (!command) return command;
+  if (!isWin(platform)) return command;
+  if (command.includes('/') || command.includes('\\') || /\.[a-z0-9]+$/i.test(command)) {
+    return expandHome(command, env.USERPROFILE || env.HOME);
+  }
+  const exts = String(env.PATHEXT || '.EXE;.CMD;.BAT;.COM')
+    .split(';')
+    .map(e => e.trim())
+    .filter(Boolean);
+  const pathDirs = String(env.PATH || '').split(';').map(d => d.trim()).filter(Boolean);
+  const dirs = [...extraDirs, ...pathDirs];
+  for (const dir of dirs) {
+    for (const ext of ['', ...exts]) {
+      const candidate = path.join(dir, command + ext);
+      if (exists(candidate)) return candidate;
+    }
+  }
+  return command;
+}
+
+export function spawnAgentOpts({ platform = process.platform } = {}) {
+  if (isWin(platform)) return { shell: false, windowsHide: true };
+  return { shell: false };
+}

package/src/project-api-path.js

@@ -0,0 +1,14 @@
+/**
+ * Files/git APIs take the real directory in ?root=. The :id path segment is
+ * unused. Clients that put a Windows cwd (C:\\Users\\... or C:/Users/...) into
+ * :id make extra slashes; Hub/Express then 404. Collapse those to `_`.
+ */
+export function canonicalizeProjectApiPath(pathname) {
+  const m = String(pathname || '').match(
+    /^(\/api\/projects\/)(.+)\/(files|file|git\/(?:status|diff|log))$/,
+  );
+  if (!m) return pathname;
+  const id = m[2];
+  if (!/[\\/:]/.test(id)) return pathname;
+  return `${m[1]}_/${m[3]}`;
+}

package/src/runtime/chat-broadcast.js

@@ -0,0 +1,12 @@
+// The run owner (including a Hub task tunnel) must receive every frame even
+// when it has not subscribed to the newly assigned native session ID.
+export function broadcastChatFrame(clients, sessionId, data, ownerWs, send) {
+  const recipients = new Set();
+  if (ownerWs) recipients.add(ownerWs);
+  if (sessionId) {
+    for (const client of clients) {
+      if (client.sessionId === sessionId) recipients.add(client.ws);
+    }
+  }
+  for (const ws of recipients) send(ws, data);
+}

package/src/runtime/port-websocket.js

@@ -0,0 +1,80 @@
+import { WebSocket } from 'ws';
+import { isLoopbackHost } from '../collab.js';
+
+const MAX_FRAME = 16 * 1024 * 1024;
+const validClose = code => code === 1000 || code === 1001 || code === 1002 || code === 1003 ||
+  (code >= 1007 && code <= 1014) || (code >= 3000 && code <= 4999);
+
+// Separate from agent tunnels: arbitrary application frames must remain opaque.
+export function createPortWebSocketRelay(send, { allowRemote = false } = {}) {
+  const sockets = new Map();
+  function handle(msg) {
+    if (!msg.type?.startsWith('port-ws-')) return false;
+    const id = msg.tunnelId;
+    if (msg.type === 'port-ws-open') {
+      if (sockets.has(id)) return true;
+      try {
+        const params = new URLSearchParams(msg.query);
+        const host = params.get('host') || '127.0.0.1';
+        const port = Number(params.get('port'));
+        if ((!allowRemote && !isLoopbackHost(host)) || !Number.isInteger(port) || port < 1 || port > 65535) throw new Error('invalid target');
+        const url = new URL(`ws://${host.includes(':') ? `[${host}]` : host}:${port}`);
+        url.pathname = params.get('path') || '/';
+        url.search = params.get('q') || '';
+        const headers = {};
+        for (const name of ['Cookie', 'Origin', 'User-Agent']) {
+          if (typeof msg.headers?.[name] === 'string') headers[name] = msg.headers[name];
+        }
+        const ws = new WebSocket(url, msg.protocols || [], { headers, handshakeTimeout: 15000, maxPayload: MAX_FRAME, followRedirects: false });
+        const entry = { ws, timer: null };
+        sockets.set(id, entry);
+        ws.on('open', () => {
+          ws.pause();
+          entry.timer = setTimeout(() => ws.terminate(), 15000);
+          send({ type: 'port-ws-ready', tunnelId: id, protocol: ws.protocol });
+        });
+        ws.on('message', (data, binary) => {
+          send({ type: 'port-ws-msg', tunnelId: id, frameType: binary ? 2 : 1, data: data.toString('base64') });
+        });
+        ws.on('close', code => {
+          clearTimeout(entry.timer);
+          if (sockets.get(id) === entry) sockets.delete(id);
+          send({ type: 'port-ws-close', tunnelId: id, closeCode: validClose(code) ? code : 1011 });
+        });
+        ws.on('error', () => {
+          send({ type: 'port-ws-error', tunnelId: id });
+          ws.terminate();
+        });
+      } catch {
+        send({ type: 'port-ws-error', tunnelId: id });
+      }
+      return true;
+    }
+    const entry = sockets.get(id);
+    if (!entry) return true;
+    if (msg.type === 'port-ws-start') {
+      clearTimeout(entry.timer);
+      entry.ws.resume();
+    } else if (msg.type === 'port-ws-msg' && entry.ws.readyState === WebSocket.OPEN) {
+      if (![1, 2].includes(msg.frameType) || typeof msg.data !== 'string' || msg.data.length > MAX_FRAME * 4 / 3 + 4) {
+        entry.ws.terminate();
+      } else if (entry.ws.bufferedAmount > MAX_FRAME) {
+        entry.ws.close(1013, 'backpressure');
+      } else {
+        entry.ws.send(Buffer.from(msg.data, 'base64'), { binary: msg.frameType === 2 });
+      }
+    } else if (msg.type === 'port-ws-close') {
+      clearTimeout(entry.timer);
+      if (entry.ws.readyState === WebSocket.OPEN) entry.ws.close(validClose(msg.closeCode) ? msg.closeCode : 1000);
+      else entry.ws.terminate();
+    }
+    return true;
+  }
+  return {
+    handle,
+    closeAll() {
+      for (const { ws, timer } of sockets.values()) { clearTimeout(timer); ws.terminate(); }
+      sockets.clear();
+    },
+  };
+}