indieclaw-agent 2.0.0 → 2.2.0

package/index.js

@@ -90,6 +90,7 @@ if (TLS_ENABLED) {
 
 const terminals = new Map(); // id -> pty process
 const activeChats = new Map(); // id -> http.ClientRequest
+const activeSearches = new Map(); // ws -> child_process (one search per connection)
 
 // --- Deep Link & QR Code ---
 function getMachineIP() {
@@ -143,12 +144,14 @@ try {
 }
 
 // --- OpenClaw Detection ---
-function detectOpenClaw() {
+const OPENCLAW_PORTS = [18789, 8080, 11434, 1234, 8000];
+
+function tryOpenClawPort(port) {
   return new Promise((resolve) => {
     const req = http.request(
       {
         hostname: '127.0.0.1',
-        port: 18789,
+        port,
         path: '/v1/models',
         method: 'GET',
         timeout: 2000,
@@ -160,30 +163,44 @@ function detectOpenClaw() {
           try {
             const json = JSON.parse(body);
             const models = (json.data || []).map((m) => m.id);
-            resolve({ available: true, models });
+            if (models.length > 0) {
+              resolve({ available: true, models, port });
+            } else {
+              resolve({ available: false, models: [], port });
+            }
           } catch {
-            resolve({ available: false, models: [] });
+            resolve({ available: false, models: [], port });
           }
         });
       }
     );
     req.on('timeout', () => {
       req.destroy();
-      resolve({ available: false, models: [] });
+      resolve({ available: false, models: [], port });
     });
     req.on('error', () => {
-      resolve({ available: false, models: [] });
+      resolve({ available: false, models: [], port });
     });
     req.end();
   });
 }
 
+async function detectOpenClaw() {
+  // Try all common ports in parallel
+  const results = await Promise.all(OPENCLAW_PORTS.map(tryOpenClawPort));
+  const found = results.find((r) => r.available);
+  if (found) {
+    return { available: true, models: found.models, port: found.port };
+  }
+  return { available: false, models: [], port: null };
+}
+
 // Run detection on startup
 detectOpenClaw().then((oc) => {
   if (oc.available) {
-    console.log(`  [OpenClaw] Detected! Models: ${oc.models.join(', ')}`);
+    console.log(`  [OpenClaw] Detected on port ${oc.port}! Models: ${oc.models.join(', ')}`);
   } else {
-    console.log('  [OpenClaw] Not detected on port 18789');
+    console.log(`  [OpenClaw] Not detected on ports ${OPENCLAW_PORTS.join(', ')}`);
   }
 });
 
@@ -243,7 +260,9 @@ wss.on('connection', (ws) => {
     }
 
     // Route message
-    handleMessage(ws, msg);
+    handleMessage(ws, msg).catch((err) => {
+      console.error('[handleMessage] Unhandled error:', err.message || err);
+    });
   });
 
   ws.on('close', () => {
@@ -261,6 +280,12 @@ wss.on('connection', (ws) => {
         activeChats.delete(id);
       }
     }
+    // Kill any active search process for this connection
+    const search = activeSearches.get(ws);
+    if (search) {
+      search.kill();
+      activeSearches.delete(ws);
+    }
   });
 });
 
@@ -338,9 +363,9 @@ async function handleMessage(ws, msg) {
       case 'cron.history':
         return handleCronHistory(ws, msg);
       case 'agent.list':
-        return handleAgentList(ws, msg);
+        return await handleAgentList(ws, msg);
       case 'agent.logs':
-        return handleAgentLogs(ws, msg);
+        return await handleAgentLogs(ws, msg);
       default:
         return replyError(ws, id, `Unknown message type: ${type}`);
     }
@@ -1062,7 +1087,7 @@ function handleLogsSystem(ws, { id, lines = 200 }) {
   const platform = os.platform();
 
   if (platform === 'linux') {
-    exec(`journalctl -n ${lines} --no-pager -o json`, { timeout: 10000, maxBuffer: 1024 * 1024 * 5 }, (err, stdout) => {
+    exec(`journalctl -n ${lines} --no-pager --since "1 hour ago" -o json`, { timeout: 10000, maxBuffer: 1024 * 1024 * 5 }, (err, stdout) => {
       if (err) return replyError(ws, id, err.message);
       try {
         const entries = stdout.trim().split('\n').filter(Boolean).map((line) => {
@@ -1121,32 +1146,44 @@ function handleLogsSystem(ws, { id, lines = 200 }) {
 function handleLogsSearch(ws, { id, query, lines = 100 }) {
   const platform = os.platform();
   // Sanitize query to prevent command injection
-  const safeQuery = query.replace(/["`$\\]/g, '');
+  const safeQuery = query.replace(/["`$\\!;']/g, '');
+
+  if (!safeQuery || safeQuery.length < 2) {
+    return reply(ws, id, []);
+  }
 
+  // Kill any previous search for this connection to prevent pile-up
+  const prev = activeSearches.get(ws);
+  if (prev) {
+    prev.kill();
+    activeSearches.delete(ws);
+  }
+
+  let cmd;
   if (platform === 'linux') {
-    exec(`journalctl -n ${lines} --no-pager -g "${safeQuery}"`, { timeout: 10000, maxBuffer: 1024 * 1024 * 5 }, (err, stdout) => {
-      if (err) return replyError(ws, id, err.message);
-      const entries = stdout.trim().split('\n').filter(Boolean).map((line) => ({
-        timestamp: null,
-        level: 'info',
-        message: line,
-        source: '',
-      }));
-      reply(ws, id, entries);
-    });
+    // --since "24h ago" limits search scope instead of grepping entire journal
+    cmd = `journalctl -n ${lines} --no-pager --since "24 hours ago" -g "${safeQuery}"`;
   } else {
-    // macOS
-    exec(`grep -i "${safeQuery}" /var/log/system.log | tail -${lines}`, { timeout: 10000 }, (err, stdout) => {
-      if (err) return replyError(ws, id, err.message || 'No matches found');
-      const entries = stdout.trim().split('\n').filter(Boolean).map((line) => ({
-        timestamp: null,
-        level: 'info',
-        message: line,
-        source: '',
-      }));
-      reply(ws, id, entries);
-    });
+    cmd = `grep -i "${safeQuery}" /var/log/system.log | tail -${lines}`;
   }
+
+  const child = exec(cmd, { timeout: 10000, maxBuffer: 1024 * 1024 * 2 }, (err, stdout) => {
+    activeSearches.delete(ws);
+    if (err) {
+      // journalctl returns exit code 1 when no matches found — not an error
+      if (err.killed) return; // process was killed by a newer search
+      return reply(ws, id, []);
+    }
+    const entries = stdout.trim().split('\n').filter(Boolean).map((line) => ({
+      timestamp: null,
+      level: 'info',
+      message: line,
+      source: '',
+    }));
+    reply(ws, id, entries);
+  });
+
+  activeSearches.set(ws, child);
 }
 
 // --- Cron History ---
@@ -1190,42 +1227,22 @@ function handleCronHistory(ws, { id }) {
 }
 
 // --- Agent List (OpenClaw Models) ---
-function handleAgentList(ws, { id }) {
-  const req = http.request(
-    {
-      hostname: '127.0.0.1',
-      port: 18789,
-      path: '/v1/models',
-      method: 'GET',
-      timeout: 2000,
-    },
-    (res) => {
-      let body = '';
-      res.on('data', (chunk) => (body += chunk));
-      res.on('end', () => {
-        try {
-          const json = JSON.parse(body);
-          const models = (json.data || []).map((m) => ({
-            id: m.id,
-            name: m.id,
-            status: 'running',
-            port: 18789,
-          }));
-          reply(ws, id, models);
-        } catch {
-          reply(ws, id, []);
-        }
-      });
+async function handleAgentList(ws, { id }) {
+  try {
+    const oc = await detectOpenClaw();
+    if (oc.available) {
+      const models = oc.models.map((modelId) => ({
+        id: modelId,
+        name: modelId,
+        status: 'running',
+        port: oc.port,
+      }));
+      return reply(ws, id, models);
     }
-  );
-  req.on('timeout', () => {
-    req.destroy();
     reply(ws, id, []);
-  });
-  req.on('error', () => {
-    reply(ws, id, []);
-  });
-  req.end();
+  } catch (err) {
+    replyError(ws, id, 'OpenClaw detection failed: ' + (err.message || String(err)));
+  }
 }
 
 // --- Agent Logs ---

package/install.sh

@@ -23,7 +23,7 @@ else
 fi
 
 # Step 1: Check/Install Node.js
-echo -e "${YELLOW}[1/4]${NC} Checking Node.js..."
+echo -e "${YELLOW}[1/5]${NC} Checking Node.js..."
 if command -v node &> /dev/null; then
   NODE_VERSION=$(node -v)
   echo -e "  ${GREEN}✓${NC} Node.js ${NODE_VERSION} found"
@@ -46,12 +46,13 @@ else
 fi
 
 # Step 2: Install indieclaw-agent
-echo -e "${YELLOW}[2/4]${NC} Installing indieclaw-agent..."
-$SUDO npm install -g indieclaw-agent 2>/dev/null || npm install -g indieclaw-agent
-echo -e "  ${GREEN}✓${NC} indieclaw-agent installed"
+echo -e "${YELLOW}[2/5]${NC} Installing indieclaw-agent..."
+$SUDO npm install -g indieclaw-agent@latest 2>/dev/null || npm install -g indieclaw-agent@latest
+AGENT_VERSION=$(node -e "try{console.log(require(require('child_process').execSync('which indieclaw-agent',{encoding:'utf8'}).trim().replace(/indieclaw-agent$/,'')+'../lib/node_modules/indieclaw-agent/package.json').version)}catch{console.log('2.0.0')}" 2>/dev/null || echo "2.0.0")
+echo -e "  ${GREEN}✓${NC} indieclaw-agent v${AGENT_VERSION} installed"
 
 # Step 3: Create systemd service
-echo -e "${YELLOW}[3/4]${NC} Setting up background service..."
+echo -e "${YELLOW}[3/5]${NC} Setting up background service..."
 AGENT_PATH=$(which indieclaw-agent)
 CURRENT_USER=$(whoami)
 
@@ -74,32 +75,78 @@ EOF
 
 $SUDO systemctl daemon-reload
 $SUDO systemctl enable indieclaw-agent
-$SUDO systemctl start indieclaw-agent
+$SUDO systemctl restart indieclaw-agent
 echo -e "  ${GREEN}✓${NC} Service created and started"
 
-# Step 4: Wait for token to be generated
+# Step 4: Wait for token and detect IP
+echo -e "${YELLOW}[4/5]${NC} Detecting configuration..."
 sleep 2
 
-# Show token
-echo ""
-echo -e "${CYAN}═══════════════════════════════════════${NC}"
-echo ""
+PORT=3100
+HOSTNAME=$(hostname)
 
+# Get token
 if [ -f "$HOME/.indieclaw-token" ]; then
   TOKEN=$(cat "$HOME/.indieclaw-token")
-  echo -e "  ${GREEN}${BOLD}Setup complete!${NC}"
-  echo ""
-  echo -e "  Your auth token:"
-  echo ""
-  echo -e "  ${BOLD}${CYAN}${TOKEN}${NC}"
-  echo ""
-  echo -e "  Copy this token into the IndieClaw app."
-  echo -e "  Port: ${BOLD}3100${NC}"
 else
-  echo -e "  ${GREEN}${BOLD}Setup complete!${NC}"
+  echo -e "  ${YELLOW}⚠${NC} Token file not found yet. Check: cat ~/.indieclaw-token"
+  TOKEN=""
+fi
+
+# Detect IP (same logic as agent: try tailscale first, fallback to network)
+MACHINE_IP=""
+if command -v tailscale &> /dev/null; then
+  MACHINE_IP=$(tailscale ip -4 2>/dev/null || true)
+fi
+if [ -z "$MACHINE_IP" ]; then
+  MACHINE_IP=$(hostname -I 2>/dev/null | awk '{print $1}' || ip route get 1 2>/dev/null | awk '{print $7; exit}' || echo "")
+fi
+if [ -z "$MACHINE_IP" ]; then
+  MACHINE_IP="YOUR_SERVER_IP"
+fi
+
+echo -e "  ${GREEN}✓${NC} IP: ${MACHINE_IP}"
+
+# Step 5: Check OpenClaw
+echo -e "${YELLOW}[5/5]${NC} Checking OpenClaw..."
+OPENCLAW_STATUS="not detected"
+if curl -s --max-time 2 http://127.0.0.1:18789/v1/models > /dev/null 2>&1; then
+  OPENCLAW_STATUS="detected on port 18789"
+  echo -e "  ${GREEN}✓${NC} OpenClaw detected on port 18789"
+else
+  echo -e "  ${YELLOW}—${NC} OpenClaw not detected on port 18789 (optional, for AI features)"
+fi
+
+# Build deep link
+DEEP_LINK="indieclaw://connect?host=${MACHINE_IP}&port=${PORT}&token=${TOKEN}&name=${HOSTNAME}&tls=0"
+
+# Show results
+echo ""
+echo -e "${CYAN}╔═══════════════════════════════════════╗${NC}"
+echo -e "${CYAN}║       ${BOLD}IndieClaw Agent v${AGENT_VERSION}${NC}${CYAN}          ║${NC}"
+echo -e "${CYAN}╠═══════════════════════════════════════╣${NC}"
+echo -e "${CYAN}║${NC}  Port:     ${BOLD}${PORT}${NC}"
+echo -e "${CYAN}║${NC}  IP:       ${BOLD}${MACHINE_IP}${NC}"
+echo -e "${CYAN}║${NC}  OpenClaw: ${BOLD}${OPENCLAW_STATUS}${NC}"
+echo -e "${CYAN}╚═══════════════════════════════════════╝${NC}"
+echo ""
+
+if [ -n "$TOKEN" ]; then
+  echo -e "  ${BOLD}Auth Token:${NC}"
+  echo -e "  ${CYAN}${TOKEN}${NC}"
   echo ""
-  echo -e "  Run this to see your token:"
-  echo -e "  ${BOLD}cat ~/.indieclaw-token${NC}"
+  echo -e "  ${BOLD}Deep Link (paste in IndieClaw app → Add Machine → Paste Link):${NC}"
+  echo -e "  ${CYAN}${DEEP_LINK}${NC}"
+  echo ""
+
+  # Generate QR code using the installed qrcode-terminal package
+  AGENT_MODULES=$(npm root -g 2>/dev/null)/indieclaw-agent/node_modules
+  if [ -d "$AGENT_MODULES/qrcode-terminal" ]; then
+    echo -e "  ${BOLD}Scan with IndieClaw app:${NC}"
+    echo ""
+    node -e "require('${AGENT_MODULES}/qrcode-terminal').generate('${DEEP_LINK}', {small: true}, function(qr) { qr.split('\n').forEach(function(l) { console.log('  ' + l) }) })" 2>/dev/null || true
+    echo ""
+  fi
 fi
 
 echo ""

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "indieclaw-agent",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "description": "Manage your server from your phone. Agent for the IndieClaw mobile app.",
   "main": "index.js",
   "bin": {