claude-simple 0.2.27 → 0.2.30

package/README.md

@@ -109,6 +109,22 @@ Edge-only env (when connecting to a hub):
 
 `claude-edge migrate-user-agent` 可将旧的 macOS system Edge 迁移到用户会话。对只使用无用户凭据的后台 agent，system service 仍可选；默认建议使用用户 LaunchAgent。
 
+### Windows Edge
+
+Windows 没有 launchd/systemd。在业务机安装 Node 后：
+
+```bat
+set GATEWAY_URL=wss://your-hub/machine-connect
+set MACHINE_TOKEN=long-shared-secret
+set MACHINE_ID=win-box
+claude-edge start
+claude-edge status
+```
+
+进程、日志和 env 落在 `%USERPROFILE%\.claude-simple-edge\`。Shell 标签使用 PowerShell/cmd（不走 unix pty）。Session / Files 路径按 Windows 盘符与大小写不敏感比较。
+
+计划任务必须跑在**当前登录用户**（`LogonType=Interactive` / 用户登录时），不要用 SYSTEM / Session 0，否则 Grok/Codex 会读不到用户的 `auth.json` / Credential Manager，网页上会反复要求登录。
+
 ## Features
 
 ### Chat
@@ -260,6 +276,6 @@ The Memory tab lists files for the selected session's agent and loads their cont
 | `npm start` / `npm run serve` | Production standalone |
 | `npm run build` | Bundle frontend into `dist/` |
 | `npm run client` | Edge worker (requires hub) |
-| `claude-edge status\|start\|stop\|restart\|logs` | Supervised edge (launchd / systemd). Also `claude-simple-edge`, `edge-daemon` |
+| `claude-edge status\|start\|stop\|restart\|logs` | Supervised edge (launchd / systemd / Windows user process). Also `claude-simple-edge`, `edge-daemon` |
 | `npm run gateway` | Legacy Node hub |
 | `npm run gateway:build` | Build Go hub via `gateway/Makefile` |

package/bin/edge-ctl.js

@@ -4,7 +4,7 @@
  *   claude-edge status|start|stop|restart|logs
  *   claude-edge daemon <same>
  *
- * Detects launchd (macOS com.claude-simple.edge) or systemd (claude-simple-edge).
+ * Detects launchd (macOS), systemd (Linux), or a user-session process on Windows.
  */
 import { spawn, spawnSync } from 'child_process';
 import fs from 'fs';
@@ -22,6 +22,17 @@ const AGENT_PLIST = path.join(os.homedir(), 'Library', 'LaunchAgents', `${AGENT_
 const SYSTEMD_UNIT = 'claude-simple-edge.service';
 const MAC_OUT = path.join(os.homedir(), '.claude-simple-edge', 'edge.out.log');
 const MAC_ERR = path.join(os.homedir(), '.claude-simple-edge', 'edge.err.log');
+const WIN_DIR = path.join(os.homedir(), '.claude-simple-edge');
+const WIN_PID = path.join(WIN_DIR, 'edge.pid');
+const WIN_OUT = path.join(WIN_DIR, 'edge.out.log');
+const WIN_ERR = path.join(WIN_DIR, 'edge.err.log');
+const WIN_ENV = path.join(WIN_DIR, 'edge.env.json');
+const WIN_TASK = 'ClaudeSimpleEdge';
+const WIN_ENV_KEYS = [
+  'GATEWAY_URL', 'MACHINE_TOKEN', 'MACHINE_ID', 'LOCAL_PORT', 'AGENTS',
+  'CLAUDE_CONFIG_DIRS', 'CODEX_HOME', 'GROK_HOME', 'GEMINI_HOME', 'CURSOR_HOME',
+  'AUTO_UPDATE',
+];
 
 function usage(code = 0) {
   const text = `Usage: claude-edge <command>
@@ -35,6 +46,9 @@ function usage(code = 0) {
   logs err   Stderr only (launchd)
   migrate-user-agent  Move macOS Edge into the login session (required for Keychain-backed AGY auth)
 
+Windows uses a user-session process (pid + logs under %USERPROFILE%\\.claude-simple-edge).
+start persists GATEWAY_URL / MACHINE_TOKEN from the current environment.
+
 Also installed as: claude-simple-edge, edge-daemon
 `;
   if (code) process.stderr.write(text);
@@ -70,6 +84,7 @@ function detectBackend() {
   }
   if (process.platform === 'darwin') return 'launchd-user';
   if (process.platform === 'linux') return 'systemd';
+  if (process.platform === 'win32') return 'win32';
   return null;
 }
 
@@ -177,6 +192,13 @@ function parseLaunchdPrint(text) {
 
 function listenPort() {
   const port = process.env.LOCAL_PORT || '13000';
+  if (process.platform === 'win32') {
+    const r = run('netstat', ['-ano']);
+    if (r.status === 0 && r.stdout && new RegExp(`:${port}\\s+.*LISTENING`, 'i').test(r.stdout)) {
+      return `127.0.0.1:${port}`;
+    }
+    return 'down';
+  }
   const r = run('lsof', ['-nP', `-iTCP:${port}`, '-sTCP:LISTEN']);
   if (r.status === 0 && r.stdout.trim()) return `127.0.0.1:${port}`;
   const ss = run('ss', ['-lnt']);
@@ -186,11 +208,128 @@ function listenPort() {
 
 function tailFile(file, n) {
   if (!fs.existsSync(file)) return '';
-  const r = run('tail', ['-n', String(n), file]);
-  return (r.stdout || '').trimEnd();
+  try {
+    const text = fs.readFileSync(file, 'utf8');
+    const lines = text.split(/\r?\n/);
+    return lines.slice(Math.max(0, lines.length - n)).join('\n').trimEnd();
+  } catch {
+    return '';
+  }
+}
+
+function pidAlive(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function readWinPid() {
+  try {
+    const n = parseInt(fs.readFileSync(WIN_PID, 'utf8').trim(), 10);
+    return Number.isFinite(n) ? n : 0;
+  } catch {
+    return 0;
+  }
+}
+
+function loadWinEnv() {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(WIN_ENV, 'utf8'));
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function persistWinEnv() {
+  fs.mkdirSync(WIN_DIR, { recursive: true });
+  const prev = loadWinEnv();
+  const next = { ...prev };
+  for (const key of WIN_ENV_KEYS) {
+    if (process.env[key]) next[key] = process.env[key];
+  }
+  fs.writeFileSync(WIN_ENV, JSON.stringify(next, null, 2));
+  return next;
+}
+
+function clientScript() {
+  return path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'client.js');
+}
+
+function tryWinStartupTask(nodePath, client) {
+  const tr = `"${nodePath}" "${client}"`;
+  run('schtasks', ['/Create', '/TN', WIN_TASK, '/SC', 'ONLOGON', '/RL', 'LIMITED', '/F', '/TR', tr]);
+}
+
+function cmdWinStatus() {
+  const pid = readWinPid();
+  const alive = pidAlive(pid);
+  const env = loadWinEnv();
+  console.log('service:   windows-user');
+  console.log(`machine:   ${env.MACHINE_ID || process.env.MACHINE_ID || '-'}`);
+  console.log(`state:     ${alive ? 'running' : 'stopped'}`);
+  console.log(`pid:       ${alive ? pid : '-'}`);
+  console.log(`listen:    ${listenPort()}`);
+  console.log(`dir:       ${WIN_DIR}`);
+  console.log(`stdout:    ${WIN_OUT}`);
+  console.log(`stderr:    ${WIN_ERR}`);
+  const last = tailFile(WIN_OUT, 8);
+  if (last) console.log(`\n--- last logs ---\n${last}`);
+}
+
+function cmdWinStart() {
+  const existing = readWinPid();
+  if (pidAlive(existing)) {
+    console.log(`already running (pid ${existing})`);
+    return;
+  }
+  const envFile = persistWinEnv();
+  if (!envFile.GATEWAY_URL || !envFile.MACHINE_TOKEN) {
+    fail('set GATEWAY_URL and MACHINE_TOKEN in this shell (they are saved under .claude-simple-edge\\edge.env.json)');
+  }
+  fs.mkdirSync(WIN_DIR, { recursive: true });
+  const out = fs.openSync(WIN_OUT, 'a');
+  const err = fs.openSync(WIN_ERR, 'a');
+  const child = spawn(process.execPath, [clientScript()], {
+    cwd: WIN_DIR,
+    env: { ...process.env, ...envFile },
+    detached: true,
+    stdio: ['ignore', out, err],
+    windowsHide: true,
+  });
+  fs.writeFileSync(WIN_PID, String(child.pid));
+  child.unref();
+  tryWinStartupTask(process.execPath, clientScript());
+  console.log(`started pid ${child.pid}`);
+}
+
+function cmdWinStop() {
+  const pid = readWinPid();
+  if (pidAlive(pid)) {
+    const killed = run('taskkill', ['/PID', String(pid), '/T', '/F']);
+    if (killed.status !== 0) {
+      try { process.kill(pid, 'SIGTERM'); } catch {}
+    }
+  }
+  try { fs.unlinkSync(WIN_PID); } catch {}
+  run('schtasks', ['/End', '/TN', WIN_TASK]);
+  console.log('stopped');
+}
+
+function cmdWinLogs(mode) {
+  if (mode === '-f' || mode === '--follow') {
+    fail('log follow is not supported on Windows; use `claude-edge logs` and re-run');
+  }
+  const file = (mode === 'err' || mode === 'error' || mode === 'stderr') ? WIN_ERR : WIN_OUT;
+  process.stdout.write(tailFile(file, 80) + '\n');
 }
 
 function cmdStatus(backend) {
+  if (backend === 'win32') return cmdWinStatus();
   if (backend === 'launchd') ensureRoot();
   if (backend === 'launchd' || backend === 'launchd-user') {
     const target = macTarget(backend);
@@ -241,6 +380,7 @@ function cmdStatus(backend) {
 }
 
 function cmdStart(backend) {
+  if (backend === 'win32') return cmdWinStart();
   if (backend === 'launchd') ensureRoot();
   if (backend === 'launchd' || backend === 'launchd-user') {
     const target = macTarget(backend);
@@ -261,6 +401,7 @@ function cmdStart(backend) {
 }
 
 function cmdStop(backend) {
+  if (backend === 'win32') return cmdWinStop();
   if (backend === 'launchd') ensureRoot();
   if (backend === 'launchd' || backend === 'launchd-user') {
     const target = macTarget(backend);
@@ -275,6 +416,11 @@ function cmdStop(backend) {
 }
 
 function cmdRestart(backend) {
+  if (backend === 'win32') {
+    cmdWinStop();
+    cmdWinStart();
+    return;
+  }
   if (backend === 'launchd') ensureRoot();
   if (backend === 'launchd' || backend === 'launchd-user') {
     const target = macTarget(backend);
@@ -295,6 +441,7 @@ function cmdRestart(backend) {
 }
 
 function cmdLogs(backend, mode) {
+  if (backend === 'win32') return cmdWinLogs(mode);
   if (backend === 'systemd') ensureRoot();
   if (backend === 'launchd' || backend === 'launchd-user') {
     if (mode === '-f' || mode === '--follow') {
@@ -328,7 +475,7 @@ const rest = raw.slice(1);
 if (['-h', '--help', 'help'].includes(cmd)) usage(0);
 
 const backend = detectBackend();
-if (!backend) fail('no launchd/systemd edge service found');
+if (!backend) fail('no launchd/systemd/windows edge service found');
 
 switch (cmd) {
   case 'migrate-user-agent':

package/client.js

@@ -2,8 +2,10 @@
 import { createApp, init, hasBusyAgent } from './src/app.js';
 import { startAutoUpdate } from './src/auto-update.js';
 import { WebSocket } from 'ws';
+import { createPortWebSocketRelay } from './src/runtime/port-websocket.js';
 import os from 'os';
 import crypto from 'crypto';
+import zlib from 'zlib';
 import { promises as fs, watch as watchFs } from 'fs';
 import path from 'path';
 
@@ -13,6 +15,7 @@ const MACHINE_TOKEN = process.env.MACHINE_TOKEN;  // shared secret with gateway
 const LOCAL_PORT    = parseInt(process.env.LOCAL_PORT || '13000');
 const SYNC_DIR      = process.env.EDGE_SYNC_DIR || path.join(os.homedir(), '.claude-simple-edge');
 const SYNC_FILE     = path.join(SYNC_DIR, 'hub-stream-outbox.json');
+const portWebSockets = createPortWebSocketRelay(sendControl, { allowRemote: process.env.PORT_PROXY_ALLOW_REMOTE === '1' });
 
 if (!GATEWAY_URL)    { console.error('GATEWAY_URL is required'); process.exit(1); }
 if (!MACHINE_TOKEN)  { console.error('MACHINE_TOKEN is required'); process.exit(1); }
@@ -361,6 +364,7 @@ function connect() {
           method: msg.method,
           headers: reqHeaders,
           body: reqBody,
+          redirect: 'manual',
         });
         const headers = sanitizeProxyHeaders(Object.fromEntries(res.headers.entries()));
         const contentType = res.headers.get('content-type') || '';
@@ -408,8 +412,26 @@ function connect() {
         }
 
         const body = await res.text();
-        // Body is always decoded text here — length must match UTF-8 bytes.
-        headers['content-length'] = String(Buffer.byteLength(body));
+        const raw = Buffer.from(body, 'utf8');
+        // Large JSON (session history) is gzip+base64 on the control channel so
+        // Hub→phone does not wait on an uncompressed multi-MB WS frame.
+        if (raw.length >= 4096) {
+          try {
+            const zipped = zlib.gzipSync(raw, { level: 4 });
+            if (zipped.length < raw.length * 0.95) {
+              sendControl({
+                type: 'http-res',
+                reqId: msg.reqId,
+                status: res.status,
+                headers,
+                body: zipped.toString('base64'),
+                encoding: 'gzip',
+              });
+              return;
+            }
+          } catch { /* fall through to plain text */ }
+        }
+        headers['content-length'] = String(raw.length);
         sendControl({
           type: 'http-res',
           reqId: msg.reqId,
@@ -423,6 +445,8 @@ function connect() {
       return;
     }
 
+    if (portWebSockets.handle(msg)) return;
+
     // ── WS tunnel open ────────────────────────────────────────────────────────
     if (msg.type === 'ws-open') {
       const { tunnelId, path, query } = msg;
@@ -480,11 +504,12 @@ function connect() {
   });
 
   controlWs.on('close', () => {
+    portWebSockets.closeAll();
     syncSent = new Set();
     console.log(`[client] Disconnected. Reconnecting in ${reconnectDelay}ms ...`);
     // Close all open tunnels
-    for (const localWs of tunnels.values()) {
-      try { localWs.close(); } catch {}
+    for (const tunnel of tunnels.values()) {
+      try { tunnel.ws.terminate(); } catch {}
     }
     tunnels.clear();
     setTimeout(connect, reconnectDelay);