@jlongo78/agent-spaces 0.7.2 → 0.7.3

package/bin/spaces-service.js

@@ -440,11 +440,15 @@ function linuxSystemctl(level, ...args) {
   if (level === 'system') {
     execFileSync('sudo', ['systemctl', ...args], { stdio: 'inherit' });
   } else {
-    // User-level systemctl needs XDG_RUNTIME_DIR to connect to the user bus
-    const env = { ...process.env };
-    if (!env.XDG_RUNTIME_DIR) {
-      env.XDG_RUNTIME_DIR = `/run/user/${process.getuid()}`;
-    }
+    // User-level systemctl needs XDG_RUNTIME_DIR to connect to the user bus.
+    // Always set it from the real UID — inherited env may have a stale value
+    // (e.g. from a prior session with a different UID mapping).
+    const uid = process.getuid();
+    const env = {
+      ...process.env,
+      XDG_RUNTIME_DIR: `/run/user/${uid}`,
+      DBUS_SESSION_BUS_ADDRESS: `unix:path=/run/user/${uid}/bus`,
+    };
     execFileSync('systemctl', ['--user', ...args], { stdio: 'inherit', env });
   }
 }
@@ -482,8 +486,12 @@ async function linuxInstall() {
 
   if (level === 'user') {
     try {
-      const env = { ...process.env };
-      if (!env.XDG_RUNTIME_DIR) env.XDG_RUNTIME_DIR = `/run/user/${process.getuid()}`;
+      const uid = process.getuid();
+      const env = {
+        ...process.env,
+        XDG_RUNTIME_DIR: `/run/user/${uid}`,
+        DBUS_SESSION_BUS_ADDRESS: `unix:path=/run/user/${uid}/bus`,
+      };
       execFileSync('loginctl', ['enable-linger', os.userInfo().username], { stdio: 'inherit', env });
       logOk('Enabled login lingering for user service');
     } catch {
@@ -570,8 +578,12 @@ async function linuxStatus() {
 async function linuxLogs() {
   const level = loadLevel() || 'user';
   if (level === 'user') {
-    const env = { ...process.env };
-    if (!env.XDG_RUNTIME_DIR) env.XDG_RUNTIME_DIR = `/run/user/${process.getuid()}`;
+    const uid = process.getuid();
+    const env = {
+      ...process.env,
+      XDG_RUNTIME_DIR: `/run/user/${uid}`,
+      DBUS_SESSION_BUS_ADDRESS: `unix:path=/run/user/${uid}/bus`,
+    };
     spawnSync('journalctl', ['--user', '-u', SERVICE_NAME, '-f', '--no-pager'], { stdio: 'inherit', env });
   } else {
     spawnSync('sudo', ['journalctl', '-u', SERVICE_NAME, '-f', '--no-pager'], { stdio: 'inherit' });

package/bin/spaces.js

@@ -139,22 +139,42 @@ if (cliFlags.setup) {
   startServer();
 }
 
-// ─── Self-signed TLS certificate ────────────────────────────
-// Generates a self-signed cert on first run (valid 365 days) so mobile
-// browsers that force HTTPS-first can still connect.  The cert/key are
-// persisted under ~/.spaces/ so they survive restarts.
-function ensureSelfSignedCert() {
+// ─── TLS certificate ────────────────────────────────────────
+// Uses a real cert if configured in server.json (tlsCert, tlsKey, optional
+// tlsCa for the full chain), otherwise generates a self-signed cert so
+// mobile browsers that force HTTPS-first can still connect.
+function ensureTlsCert() {
+  // Check for configured real cert in server.json
+  try {
+    const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+    if (config.tlsCert && config.tlsKey) {
+      if (fs.existsSync(config.tlsCert) && fs.existsSync(config.tlsKey)) {
+        // Read cert + key, and optionally the CA bundle for full chain
+        const certPem = fs.readFileSync(config.tlsCert, 'utf-8').trim();
+        const caPem = (config.tlsCa && fs.existsSync(config.tlsCa))
+          ? fs.readFileSync(config.tlsCa, 'utf-8').trim()
+          : null;
+        const creds = {
+          cert: caPem ? certPem + '\n' + caPem : certPem,
+          key: fs.readFileSync(config.tlsKey, 'utf-8'),
+        };
+        console.log('  Using TLS certificate: ' + config.tlsCert);
+        return creds;
+      }
+      console.log('  Warning: tlsCert/tlsKey configured but files not found, falling back to self-signed');
+    }
+  } catch {}
+
+  // Fall back to self-signed
   const certPath = path.join(SPACES_DIR, 'tls-cert.pem');
   const keyPath  = path.join(SPACES_DIR, 'tls-key.pem');
 
-  // Re-use existing cert if present
   if (fs.existsSync(certPath) && fs.existsSync(keyPath)) {
     try {
       return { cert: fs.readFileSync(certPath), key: fs.readFileSync(keyPath) };
     } catch {}
   }
 
-  // Generate via openssl CLI (available on all platforms)
   try {
     fs.mkdirSync(SPACES_DIR, { recursive: true });
     execFileSync('openssl', [
@@ -331,6 +351,70 @@ function startServer() {
 
   console.log('');
 
+  // ─── Background update check (non-blocking) ───────────────
+  // Compare installed version against npm registry. Writes result to
+  // ~/.spaces/update-check.json so the UI can show a banner.
+  const updateCheckPath = path.join(SPACES_DIR, 'update-check.json');
+  (async () => {
+    try {
+      const pkg = require(path.join(projectDir, 'package.json'));
+      const currentVersion = pkg.version;
+      const npmName = pkg.name || '@jlongo78/agent-spaces';
+
+      // Skip if checked within the last hour
+      try {
+        if (fs.existsSync(updateCheckPath)) {
+          const cached = JSON.parse(fs.readFileSync(updateCheckPath, 'utf-8'));
+          if (Date.now() - (cached.checkedAt || 0) < 3600_000) {
+            if (cached.available) {
+              console.log(`  Update available: ${currentVersion} → ${cached.latest} (run: npm i -g ${npmName})`);
+            }
+            return;
+          }
+        }
+      } catch { /* check fresh */ }
+
+      const res = await fetch(`https://registry.npmjs.org/${encodeURIComponent(npmName)}/latest`, {
+        signal: AbortSignal.timeout(5000),
+      });
+      if (!res.ok) return;
+      const data = await res.json();
+      const latest = data.version;
+
+      const result = {
+        current: currentVersion,
+        latest,
+        available: latest !== currentVersion && latest > currentVersion,
+        checkedAt: Date.now(),
+        name: npmName,
+      };
+
+      fs.writeFileSync(updateCheckPath, JSON.stringify(result, null, 2));
+
+      if (result.available) {
+        console.log(`  Update available: ${currentVersion} → ${latest} (run: npm i -g ${npmName})`);
+      }
+    } catch { /* network error — skip silently */ }
+  })();
+
+  // Also check addon updates (git-based packages)
+  const gitSafe = ['-c', 'safe.directory=*'];
+  const addonPaths = { teams: teamsPath, pro: proPath, cortex: cortexPath };
+  (async () => {
+    for (const [key, addonDir] of Object.entries(addonPaths)) {
+      if (!addonDir || !fs.existsSync(path.join(addonDir, '.git'))) continue;
+      const realDir = fs.realpathSync(addonDir);
+      try {
+        execFileSync('git', [...gitSafe, 'fetch', '--quiet'], { cwd: realDir, stdio: 'ignore', timeout: 5000 });
+        const local = execFileSync('git', [...gitSafe, 'rev-parse', 'HEAD'], { cwd: realDir, encoding: 'utf-8' }).trim();
+        const remote = execFileSync('git', [...gitSafe, 'rev-parse', '@{u}'], { cwd: realDir, encoding: 'utf-8' }).trim();
+        if (local !== remote) {
+          console.log(`  Update available for @spaces/${key} (run: spaces upgrade ${key})`);
+        }
+      } catch { /* not on a branch with upstream, skip */ }
+    }
+  })();
+
   // Check for ~/.claude/ directory
   const claudeDir = path.join(os.homedir(), '.claude');
   if (!fs.existsSync(claudeDir)) {
@@ -465,7 +549,7 @@ function startServer() {
   // anything else = plain HTTP.  This lets mobile browsers that force
   // HTTPS-first connect to the same port without a separate listener.
   const httpServer = http.createServer(proxyHandler);
-  const tlsCreds = ensureSelfSignedCert();
+  const tlsCreds = ensureTlsCert();
   const httpsServer = tlsCreds ? https.createServer(tlsCreds, proxyHandler) : null;
 
   const { createTerminalServer } = require('./terminal-server');
@@ -479,17 +563,17 @@ function startServer() {
   if (httpsServer) patchAddress(httpsServer);
 
   const dualServer = net.createServer((socket) => {
+    // If client connects but sends nothing for 5s, destroy.
+    // Once routed, clear the timeout so long-lived connections (WebSocket) aren't killed.
+    socket.setTimeout(5000, () => socket.destroy());
     socket.once('data', (buf) => {
-      // Pause the socket until the right server handles it, then
-      // unshift the peeked data so nothing is lost.
+      socket.setTimeout(0);
       socket.pause();
       const target = (buf[0] === 0x16 && httpsServer) ? httpsServer : httpServer;
       target.emit('connection', socket);
       socket.unshift(buf);
       socket.resume();
     });
-    // If client connects but sends nothing for 5s, destroy
-    socket.setTimeout(5000, () => socket.destroy());
   });
 
   dualServer.listen(PORT, () => {

package/bin/terminal-server.js

@@ -936,6 +936,7 @@ function handleConnection(wss, ws, req) {
   // Check for existing session to reattach
   const existing = sessions.get(paneId);
   if (existing && existing.pty && !existing.exited) {
+    console.log(`[WS] Reattach pane=${paneId.slice(0,8)} buffer=${existing.buffer.length} chunks`);
     existing.ws = ws;
 
     // Replay buffered output so user sees context
@@ -965,10 +966,15 @@ function handleConnection(wss, ws, req) {
       }
     });
 
-    ws.on('close', () => {
+    ws.on('close', (code, reason) => {
+      console.log(`[WS] Close pane=${paneId.slice(0,8)} code=${code} reason=${reason || 'none'}`);
       if (existing.ws === ws) existing.ws = null;
     });
 
+    ws.on('error', (err) => {
+      console.log(`[WS] Error pane=${paneId.slice(0,8)} err=${err.message}`);
+    });
+
     return;
   }
 
@@ -1258,10 +1264,15 @@ function handleConnection(wss, ws, req) {
     }
   });
 
-  ws.on('close', () => {
+  ws.on('close', (code, reason) => {
+    console.log(`[WS] Close pane=${paneId.slice(0,8)} code=${code} reason=${reason || 'none'}`);
     if (session.ws === ws) session.ws = null;
   });
 
+  ws.on('error', (err) => {
+    console.log(`[WS] Error pane=${paneId.slice(0,8)} err=${err.message}`);
+  });
+
   ws.send(JSON.stringify({ type: 'ready', paneId }));
 
   // Confirm actual collaboration state so browser syncs with backend

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jlongo78/agent-spaces",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "description": "Agent workspace manager for Claude, Codex, Gemini, and more",
   "bin": {
     "spaces": "./bin/spaces.js"