claude-tg 1.0.6 → 1.0.8

package/bin/claude-tg.js

@@ -276,15 +276,21 @@ program
         const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
         const hooks = settings.hooks || {};
 
+        // Extract script path from hook command (handles optional env prefix)
+        function extractScriptPath(cmd) {
+          const match = cmd.match(/node\s+(.+)$/);
+          return match ? match[1].trim() : null;
+        }
+
         const permHooks = hooks.PermissionRequest || [];
         const permCmd = permHooks[0]?.hooks?.[0]?.command || 'NOT FOUND';
         console.log(`  PermissionRequest: ${permCmd}`);
         if (permCmd !== 'NOT FOUND') {
-          const scriptPath = permCmd.replace(/^node\s+/, '');
-          if (fs.existsSync(scriptPath)) {
+          const scriptPath = extractScriptPath(permCmd);
+          if (scriptPath && fs.existsSync(scriptPath)) {
             console.log('    File exists: YES');
           } else {
-            console.log(`    File exists: NO — ${scriptPath}`);
+            console.log(`    File exists: NO — ${scriptPath || permCmd}`);
             ok = false;
           }
         }
@@ -293,11 +299,11 @@ program
         const notifCmd = notifHooks[0]?.hooks?.[0]?.command || 'NOT FOUND';
         console.log(`  Notification: ${notifCmd}`);
         if (notifCmd !== 'NOT FOUND') {
-          const scriptPath = notifCmd.replace(/^node\s+/, '');
-          if (fs.existsSync(scriptPath)) {
+          const scriptPath = extractScriptPath(notifCmd);
+          if (scriptPath && fs.existsSync(scriptPath)) {
             console.log('    File exists: YES');
           } else {
-            console.log(`    File exists: NO — ${scriptPath}`);
+            console.log(`    File exists: NO — ${scriptPath || notifCmd}`);
             ok = false;
           }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-tg",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "Control Claude Code from Telegram — approve permissions, answer questions, reply to idle sessions, send files, all from your phone",
   "bin": {
     "claude-tg": "./bin/claude-tg.js"

package/src/daemon.js

@@ -1,6 +1,6 @@
 const http = require('http');
 const crypto = require('crypto');
-const { execSync, exec } = require('child_process');
+const { exec } = require('child_process');
 const util = require('util');
 const execAsync = util.promisify(exec);
 const { Telegraf, Markup } = require('telegraf');
@@ -32,9 +32,12 @@ let config;
 
 // --- Utilities ---
 
+// Non-blocking log using a write stream
+const logStream = fs.createWriteStream(LOG_PATH, { flags: 'a' });
+logStream.on('error', () => {}); // prevent stream errors from crashing
+
 function log(msg) {
-  const line = `[${new Date().toISOString()}] ${msg}\n`;
-  fs.appendFileSync(LOG_PATH, line);
+  logStream.write(`[${new Date().toISOString()}] ${msg}\n`);
 }
 
 function projectLabel(cwd) {
@@ -76,14 +79,14 @@ function trackSession(data) {
 
 /**
  * Check if a TTY has any active processes (terminal is still open + something running).
- * More reliable than fs.statSync which succeeds even after terminal closes.
+ * Non-blocking async version to avoid blocking the event loop.
  */
-function isTtyAlive(ttyPath) {
+async function isTtyAlive(ttyPath) {
   if (!ttyPath) return false;
   try {
     const ttyName = ttyPath.replace('/dev/', '');
-    const result = execSync(`ps -t ${ttyName} -o pid= 2>/dev/null`, { timeout: 2000, stdio: 'pipe' }).toString().trim();
-    return result.length > 0;
+    const { stdout } = await execAsync(`ps -t ${ttyName} -o pid= 2>/dev/null`, { timeout: 2000 });
+    return stdout.trim().length > 0;
   } catch {
     return false;
   }
@@ -93,7 +96,12 @@ function isTtyAlive(ttyPath) {
  * Escape a string for use inside AppleScript double-quoted strings.
  */
 function escapeAppleScript(str) {
-  return str.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+  return str
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"')
+    .replace(/\n/g, '\\n')
+    .replace(/\r/g, '\\r')
+    .replace(/\t/g, '\\t');
 }
 
 /**
@@ -450,9 +458,13 @@ async function sendElicitationQuestion(elicId) {
   }
 
   const keyboard = Markup.inlineKeyboard(rows);
-  const sent = await bot.telegram.sendMessage(config.chatId, msg, keyboard);
-  elic.telegramMessageIds.push(sent.message_id);
-  elic.currentMessageId = sent.message_id;
+  try {
+    const sent = await bot.telegram.sendMessage(config.chatId, msg, keyboard);
+    elic.telegramMessageIds.push(sent.message_id);
+    elic.currentMessageId = sent.message_id;
+  } catch (err) {
+    log(`Elicitation question send failed: ${err.message}`);
+  }
 }
 
 /**
@@ -493,8 +505,12 @@ async function sendElicitationSummary(elicId) {
   }
   const keyboard = Markup.inlineKeyboard(summaryButtons);
 
-  const sent = await bot.telegram.sendMessage(config.chatId, msg, keyboard);
-  elic.telegramMessageIds.push(sent.message_id);
+  try {
+    const sent = await bot.telegram.sendMessage(config.chatId, msg, keyboard);
+    elic.telegramMessageIds.push(sent.message_id);
+  } catch (err) {
+    log(`Elicitation summary send failed: ${err.message}`);
+  }
 }
 
 /**
@@ -591,14 +607,18 @@ async function handleElicitationCallback(ctx, cbData) {
     try { await ctx.editMessageReplyMarkup(undefined); } catch {}
     try { await ctx.editMessageText(ctx.callbackQuery.message.text + '\n\n✏️ Selected: Custom'); } catch {}
 
-    const prompt = await bot.telegram.sendMessage(
-      config.chatId,
-      `✏️ Type your custom answer for: "${q.question}"\n\nReply to this message with your answer.`
-    );
-
-    elic.customWaitingMessageId = prompt.message_id;
-    elic.customWaitingQIdx = qIdx;
-    elic.telegramMessageIds.push(prompt.message_id);
+    try {
+      const prompt = await bot.telegram.sendMessage(
+        config.chatId,
+        `✏️ Type your custom answer for: "${q.question}"\n\nReply to this message with your answer.`
+      );
+
+      elic.customWaitingMessageId = prompt.message_id;
+      elic.customWaitingQIdx = qIdx;
+      elic.telegramMessageIds.push(prompt.message_id);
+    } catch (err) {
+      log(`Elicitation custom prompt send failed: ${err.message}`);
+    }
     log(`Elicitation ${elicId}: waiting for custom answer to q${qIdx}`);
     return;
   }
@@ -831,10 +851,15 @@ function startBot() {
 
   bot.command('status', async (ctx) => {
     const pendingCount = pendingQuestions.size;
-    const activeSessions = [...sessions.entries()].filter(([, s]) => {
-      if (s.ttyPath) return isTtyAlive(s.ttyPath);
-      return Date.now() - s.lastActive < 60 * 60 * 1000;
-    });
+    const allSessions = [...sessions.entries()];
+    const activeSessions = [];
+    for (const [sid, s] of allSessions) {
+      if (s.ttyPath) {
+        if (await isTtyAlive(s.ttyPath)) activeSessions.push([sid, s]);
+      } else if (Date.now() - s.lastActive < 60 * 60 * 1000) {
+        activeSessions.push([sid, s]);
+      }
+    }
 
     let msg = '';
     if (activeSessions.length === 0 && pendingCount === 0) {
@@ -909,6 +934,9 @@ function startBot() {
     } else if (action === 'always') {
       label = '✅ Always Allowed';
       pending.resolve({ decision: 'always' });
+    } else {
+      label = '❌ Denied';
+      pending.resolve({ decision: 'deny' });
     }
 
     try { await ctx.answerCbQuery(label); } catch {}
@@ -983,14 +1011,16 @@ function startBot() {
     // If no reply-to, try auto-routing
     if (!targetSessionId) {
       // Find sessions that have notifications and are still alive (TTY exists)
-      const recentNotifications = [...messageToSession.entries()]
-        .filter(([, m]) => {
-          if (m.type !== 'notification') return false;
-          const s = sessions.get(m.sessionId);
-          if (s?.ttyPath) return isTtyAlive(s.ttyPath);
-          return Date.now() - m.createdAt < 60 * 60 * 1000;
-        })
-        .map(([, m]) => m.sessionId);
+      const allNotifs = [...messageToSession.entries()].filter(([, m]) => m.type === 'notification');
+      const recentNotifications = [];
+      for (const [, m] of allNotifs) {
+        const s = sessions.get(m.sessionId);
+        if (s?.ttyPath) {
+          if (await isTtyAlive(s.ttyPath)) recentNotifications.push(m.sessionId);
+        } else if (Date.now() - m.createdAt < 60 * 60 * 1000) {
+          recentNotifications.push(m.sessionId);
+        }
+      }
 
       const uniqueSessions = [...new Set(recentNotifications)];
 
@@ -1028,11 +1058,47 @@ function startBot() {
   });
 
   bot.catch((err) => {
-    log(`Bot error: ${err.message}`);
+    log(`Bot error: ${err?.message || err}`);
   });
 
+  // Launch polling in background — don't block the HTTP server
+  // Note: Telegraf's launch() promise never settles in v4.16 — that's OK,
+  // polling starts immediately in the background.
   bot.launch({ dropPendingUpdates: true });
-  log('Telegram bot started');
+  log('Telegram bot polling started');
+
+  // Send startup notification after brief delay (let polling initialize)
+  setTimeout(async () => {
+    try {
+      await bot.telegram.sendMessage(config.chatId, '🟢 claude-tg daemon started');
+      log('Startup notification sent to Telegram');
+    } catch (e) {
+      log(`Startup notification failed: ${e?.message || e}`);
+    }
+  }, 2000);
+}
+
+/**
+ * Periodic health check — verify Telegram connectivity.
+ * If bot polling dies silently, restart it.
+ */
+let healthCheckRestarting = false;
+function startHealthCheck() {
+  setInterval(async () => {
+    if (healthCheckRestarting) return;
+    try {
+      await bot.telegram.getMe();
+    } catch (err) {
+      log(`Telegram health check failed: ${err?.message || err}. Restarting bot...`);
+      healthCheckRestarting = true;
+      try { bot.stop('health_restart'); } catch {}
+      // Wait for old polling to fully stop before starting new instance
+      setTimeout(() => {
+        startBot();
+        healthCheckRestarting = false;
+      }, 3000);
+    }
+  }, 3 * 60 * 1000); // every 3 minutes
 }
 
 // --- HTTP handlers ---
@@ -1056,7 +1122,13 @@ async function sendPermissionRequest(data) {
     Markup.button.callback('Always Allow', `${rid}:always`),
   ]);
 
-  const sent = await bot.telegram.sendMessage(config.chatId, msg, keyboard);
+  let sent;
+  try {
+    sent = await bot.telegram.sendMessage(config.chatId, msg, keyboard);
+  } catch (err) {
+    log(`Permission send failed: ${err.message}`);
+    return { decision: 'allow' }; // Fallback: allow if Telegram unreachable
+  }
 
   // Track this message for reply routing
   messageToSession.set(sent.message_id, {
@@ -1245,14 +1317,14 @@ function startServer() {
 // --- Cleanup stale state periodically ---
 
 function startCleanup() {
-  setInterval(() => {
+  setInterval(async () => {
     const now = Date.now();
     const staleThreshold = 60 * 60 * 1000; // 1 hour
 
     // Clean message mappings — keep if session's TTY is still alive
     for (const [msgId, m] of messageToSession) {
       const s = sessions.get(m.sessionId);
-      if (s?.ttyPath && isTtyAlive(s.ttyPath)) continue;
+      if (s?.ttyPath && await isTtyAlive(s.ttyPath)) continue;
       if (now - m.createdAt > staleThreshold) {
         messageToSession.delete(msgId);
       }
@@ -1261,7 +1333,7 @@ function startCleanup() {
     // Clean stale sessions — only if terminal is gone
     for (const [sid, s] of sessions) {
       if (s.ttyPath) {
-        if (!isTtyAlive(s.ttyPath)) {
+        if (!(await isTtyAlive(s.ttyPath))) {
           sessions.delete(sid);
           log(`Cleaned session ${sid} (TTY gone: ${s.ttyPath})`);
         }
@@ -1291,9 +1363,10 @@ function main() {
   }
 
   log('Daemon starting...');
-  startBot();
-  startServer();
+  startServer();  // HTTP server first — hooks must be able to connect immediately
+  startBot();     // Telegram polling in background
   startCleanup();
+  startHealthCheck();
 
   process.on('unhandledRejection', (err) => {
     log(`Unhandled rejection: ${err?.message || err}`);