@dmsdc-ai/aigentry-telepty 0.5.8 → 0.6.0

package/cross-machine.js

@@ -8,6 +8,7 @@ const { getSharedContextPromptPath } = require('./shared-context');
 const { parseHostSpec } = require('./host-spec');
 
 const PEERS_PATH = path.join(os.homedir(), '.telepty', 'peers.json');
+const BROKER_CONFIG_PATH = path.join(os.homedir(), '.telepty', 'broker.json');
 const CONTROL_DIR = path.join(os.homedir(), '.telepty', 'ssh');
 
 function getPeerTransport(entry) {
@@ -34,6 +35,30 @@ function savePeers(data) {
   } catch {}
 }
 
+function normalizeBrokerUrl(url) {
+  const value = String(url || '').trim();
+  if (!value) return '';
+  try {
+    const parsed = new URL(value);
+    return parsed.toString().replace(/\/+$/, '');
+  } catch {
+    return '';
+  }
+}
+
+function loadBrokerConfig() {
+  try {
+    if (!fs.existsSync(BROKER_CONFIG_PATH)) return null;
+    return JSON.parse(fs.readFileSync(BROKER_CONFIG_PATH, 'utf8'));
+  } catch { return null; }
+}
+
+function saveBrokerConfig(config) {
+  fs.mkdirSync(path.dirname(BROKER_CONFIG_PATH), { recursive: true });
+  fs.writeFileSync(BROKER_CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
+  try { fs.chmodSync(BROKER_CONFIG_PATH, 0o600); } catch {}
+}
+
 // In-memory active peers
 const activePeers = new Map(); // name -> { target, controlSocket, connectedAt, machineId }
 
@@ -469,6 +494,97 @@ async function discoverHttpRemoteSessions(options = {}) {
   return results.flat();
 }
 
+// ── Broker peer support (opt-in relay discovery) ────────────────────────────
+// connect-broker stores the node's broker credentials in broker.json (0600) and
+// records a non-secret transport='broker' peer in peers.json. Discovery remains
+// default-OFF: no broker peer entry means list discovery never calls the broker.
+
+async function connectBroker(url, options = {}) {
+  const brokerUrl = normalizeBrokerUrl(url);
+  if (!brokerUrl) {
+    return { success: false, error: 'connect-broker requires a valid broker URL.' };
+  }
+
+  const node = String(options.node || '').trim();
+  if (!node) {
+    return { success: false, error: 'connect-broker requires --node <name>.' };
+  }
+
+  const jwt = String(options.jwt || '').trim();
+  if (!jwt) {
+    return { success: false, error: 'connect-broker requires a node JWT.' };
+  }
+
+  const connectedAt = new Date().toISOString();
+  const config = {
+    url: brokerUrl,
+    node,
+    jwt,
+    pin: options.pin || null,
+    accept_from: null
+  };
+  saveBrokerConfig(config);
+
+  const peers = loadPeers();
+  peers.peers[node] = {
+    transport: 'broker',
+    node,
+    url: brokerUrl,
+    machineId: node,
+    lastConnected: connectedAt
+  };
+  savePeers(peers);
+
+  return { success: true, name: node, node, url: brokerUrl };
+}
+
+function listBrokerPeers() {
+  const peers = loadPeers().peers || {};
+  return Object.entries(peers)
+    .filter(([, entry]) => getPeerTransport(entry) === 'broker')
+    .map(([name, entry]) => ({
+      name,
+      node: entry.node || entry.machineId || name,
+      url: entry.url,
+      machineId: entry.machineId || entry.node || name,
+      lastConnected: entry.lastConnected
+    }));
+}
+
+async function listBrokerRemoteSessions(options = {}) {
+  const config = options.config || loadBrokerConfig();
+  const brokerUrl = normalizeBrokerUrl(options.url || (config && config.url));
+  const jwt = String(options.jwt || (config && config.jwt) || '').trim();
+  if (!brokerUrl || !jwt) return [];
+
+  try {
+    const res = await fetch(`${brokerUrl}/broker/sessions`, {
+      signal: AbortSignal.timeout(options.timeoutMs || 3000),
+      headers: { Authorization: `Bearer ${jwt}` }
+    });
+    if (!res.ok) return [];
+    const body = await res.json();
+    const sessions = Array.isArray(body) ? body : body && body.sessions;
+    if (!Array.isArray(sessions)) return [];
+    return sessions.map((session) => {
+      const base = (session && typeof session === 'object') ? session : { id: session };
+      const node = base.peerName || base.host || base.node || base.machineId || base.machine_id;
+      return {
+        ...base,
+        host: node,
+        peerName: node
+      };
+    });
+  } catch {
+    return [];
+  }
+}
+
+async function discoverBrokerRemoteSessions(options = {}) {
+  if (listBrokerPeers().length === 0) return [];
+  return listBrokerRemoteSessions(options);
+}
+
 module.exports = {
   connect,
   disconnect,
@@ -490,9 +606,16 @@ module.exports = {
   listHttpPeers,
   listHttpRemoteSessions,
   discoverHttpRemoteSessions,
+  // Broker peer transport (opt-in relay discovery)
+  connectBroker,
+  listBrokerPeers,
+  listBrokerRemoteSessions,
+  discoverBrokerRemoteSessions,
+  loadBrokerConfig,
   // File-backed SSH peer enumeration (cross-process — #411)
   listSshPeers,
   getSshPeerHandle,
   getPeerTransport,
-  PEERS_PATH
+  PEERS_PATH,
+  BROKER_CONFIG_PATH
 };

package/daemon-control.js

@@ -102,6 +102,14 @@ function isLikelyTeleptyDaemon(commandLine) {
     return false;
   }
 
+  // telepty#44: the running daemon sets process.title = 'telepty-daemon' (daemon.js:188).
+  // On macOS/Linux that REPLACES the command field `ps -axo command=` returns, so the
+  // daemon's own title (hyphen) — not its launch command line — is what the process scan
+  // and port-owner confirmation see. Recognize it so the stop path is no longer blind to it.
+  if (text.includes('telepty-daemon')) {
+    return true;
+  }
+
   if (text.includes('telepty daemon')) {
     return true;
   }
@@ -336,6 +344,7 @@ module.exports = {
   cleanupDaemonProcesses,
   clearDaemonState,
   findPortOwnerPid,
+  isLikelyTeleptyDaemon,
   isProcessRunning,
   listDaemonProcesses,
   pidMatchesTeleptyCmdline,