claude-tg 1.0.0

package/src/hooks/notification.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+// Notification hook for Claude Code.
+// Detects parent TTY, reads hook input from stdin, fires POST to daemon, exits.
+
+const http = require('http');
+const { execSync } = require('child_process');
+
+const DAEMON_PORT = 7483;
+const DAEMON_HOST = '127.0.0.1';
+
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => { data += chunk; });
+    process.stdin.on('end', () => {
+      try { resolve(JSON.parse(data)); }
+      catch (e) { reject(e); }
+    });
+    process.stdin.on('error', reject);
+  });
+}
+
+/**
+ * Walk up the process tree to find the TTY of the Claude process.
+ * Hook process itself has tty=??, but the Claude parent has a real TTY.
+ */
+function findTty() {
+  try {
+    let pid = process.ppid;
+    for (let i = 0; i < 10; i++) {
+      const tty = execSync(`ps -o tty= -p ${pid} 2>/dev/null`).toString().trim();
+      if (tty && tty !== '??' && tty !== '') {
+        return `/dev/${tty}`;
+      }
+      const ppid = execSync(`ps -o ppid= -p ${pid} 2>/dev/null`).toString().trim();
+      if (!ppid || ppid === '0' || ppid === '1') break;
+      pid = parseInt(ppid);
+    }
+  } catch {}
+  return null;
+}
+
+function postToDaemon(body) {
+  return new Promise((resolve, reject) => {
+    const payload = JSON.stringify(body);
+    const req = http.request(
+      {
+        hostname: DAEMON_HOST,
+        port: DAEMON_PORT,
+        path: '/api/notify',
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(payload),
+        },
+        timeout: 5000,
+      },
+      (res) => {
+        res.on('data', () => {});
+        res.on('end', resolve);
+      }
+    );
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('timeout')); });
+    req.write(payload);
+    req.end();
+  });
+}
+
+async function main() {
+  try {
+    const input = await readStdin();
+    const hookInput = input.hookInput || input;
+    const ttyPath = findTty();
+
+    await postToDaemon({
+      session_id: hookInput.session_id,
+      cwd: hookInput.cwd,
+      notification_type: hookInput.notification_type || hookInput.type,
+      message: hookInput.message,
+      transcript_path: hookInput.transcript_path,
+      tty_path: ttyPath,
+    });
+  } catch {
+    // Daemon unreachable — silently ignore
+  }
+  process.exit(0);
+}
+
+main();

package/src/hooks/permission-request.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+
+// PermissionRequest hook for Claude Code.
+// Reads hook input from stdin, forwards to daemon, blocks until Telegram response.
+// On error/timeout: exits 0 with no output → falls back to local dialog.
+
+const http = require('http');
+const { execSync } = require('child_process');
+
+const DAEMON_PORT = 7483;
+const DAEMON_HOST = '127.0.0.1';
+
+function findTty() {
+  try {
+    let pid = process.ppid;
+    for (let i = 0; i < 10; i++) {
+      const tty = execSync(`ps -o tty= -p ${pid} 2>/dev/null`).toString().trim();
+      if (tty && tty !== '??' && tty !== '') {
+        return `/dev/${tty}`;
+      }
+      const ppid = execSync(`ps -o ppid= -p ${pid} 2>/dev/null`).toString().trim();
+      if (!ppid || ppid === '0' || ppid === '1') break;
+      pid = parseInt(ppid);
+    }
+  } catch {}
+  return null;
+}
+
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => { data += chunk; });
+    process.stdin.on('end', () => {
+      try { resolve(JSON.parse(data)); }
+      catch (e) { reject(e); }
+    });
+    process.stdin.on('error', reject);
+  });
+}
+
+function postToDaemon(path, body) {
+  return new Promise((resolve, reject) => {
+    const payload = JSON.stringify(body);
+    const req = http.request(
+      {
+        hostname: DAEMON_HOST,
+        port: DAEMON_PORT,
+        path,
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(payload),
+        },
+        timeout: 1800000, // 30 minutes — daemon holds until Telegram answer
+      },
+      (res) => {
+        let data = '';
+        res.on('data', (chunk) => { data += chunk; });
+        res.on('end', () => {
+          try { resolve(JSON.parse(data)); }
+          catch { resolve(null); }
+        });
+      }
+    );
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('timeout')); });
+    req.write(payload);
+    req.end();
+  });
+}
+
+async function main() {
+  try {
+    const input = await readStdin();
+
+    const hookInput = input.hookInput || input;
+    const ttyPath = findTty();
+    const result = await postToDaemon('/api/permission', {
+      session_id: hookInput.session_id,
+      cwd: hookInput.cwd,
+      tool_name: hookInput.tool_name,
+      tool_input: hookInput.tool_input,
+      permission_suggestions: hookInput.permission_suggestions,
+      transcript_path: hookInput.transcript_path,
+      tty_path: ttyPath,
+    });
+
+    if (!result || !result.decision) {
+      // No decision — fall back to local dialog
+      process.exit(0);
+    }
+
+    const output = {
+      hookSpecificOutput: {
+        hookEventName: 'PermissionRequest',
+        decision: result.decision,
+      },
+      statusMessage: 'Waiting for Telegram approval...',
+    };
+
+    process.stdout.write(JSON.stringify(output));
+  } catch {
+    // Daemon unreachable or error — fall back to local dialog
+    process.exit(0);
+  }
+}
+
+main();

package/src/setup.js

@@ -0,0 +1,221 @@
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const https = require('https');
+const { loadConfig, saveConfig } = require('./config');
+
+const CLAUDE_SETTINGS_PATH = path.join(process.env.HOME, '.claude', 'settings.json');
+const HOOKS_DIR = path.resolve(__dirname, 'hooks');
+
+function ask(rl, question) {
+  return new Promise((resolve) => rl.question(question, resolve));
+}
+
+function telegramApiCall(token, method) {
+  return new Promise((resolve, reject) => {
+    https.get(`https://api.telegram.org/bot${token}/${method}`, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        try { resolve(JSON.parse(data)); }
+        catch (e) { reject(e); }
+      });
+    }).on('error', reject);
+  });
+}
+
+function getHooksConfig(port) {
+  return {
+    PermissionRequest: [
+      {
+        hooks: [
+          {
+            type: 'command',
+            command: `node ${path.join(HOOKS_DIR, 'permission-request.js')}`,
+            timeout: 1800,
+            statusMessage: 'Waiting for Telegram approval...',
+          },
+        ],
+      },
+    ],
+    Notification: [
+      {
+        matcher: 'idle_prompt|elicitation_dialog',
+        hooks: [
+          {
+            type: 'command',
+            command: `node ${path.join(HOOKS_DIR, 'notification.js')}`,
+            async: true,
+          },
+        ],
+      },
+    ],
+  };
+}
+
+function installHooks(port) {
+  let settings = {};
+  if (fs.existsSync(CLAUDE_SETTINGS_PATH)) {
+    try {
+      settings = JSON.parse(fs.readFileSync(CLAUDE_SETTINGS_PATH, 'utf8'));
+    } catch {
+      settings = {};
+    }
+  }
+
+  if (!settings.hooks) settings.hooks = {};
+
+  const newHooks = getHooksConfig(port);
+
+  // Replace our hooks (identified by our hook command paths), preserve others
+  for (const [event, hookConfigs] of Object.entries(newHooks)) {
+    const existing = settings.hooks[event] || [];
+    // Remove any previous telegram-bridge hooks
+    const filtered = existing.filter((entry) => {
+      const hooks = entry.hooks || [];
+      return !hooks.some((h) => h.command && h.command.includes('claude-telegram-bridge'));
+    });
+    settings.hooks[event] = [...filtered, ...hookConfigs];
+  }
+
+  // Ensure directory exists
+  const dir = path.dirname(CLAUDE_SETTINGS_PATH);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+  fs.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2) + '\n');
+}
+
+function uninstallHooks() {
+  if (!fs.existsSync(CLAUDE_SETTINGS_PATH)) return;
+
+  let settings;
+  try {
+    settings = JSON.parse(fs.readFileSync(CLAUDE_SETTINGS_PATH, 'utf8'));
+  } catch {
+    return;
+  }
+
+  if (!settings.hooks) return;
+
+  for (const event of Object.keys(settings.hooks)) {
+    settings.hooks[event] = (settings.hooks[event] || []).filter((entry) => {
+      const hooks = entry.hooks || [];
+      return !hooks.some((h) => h.command && h.command.includes('claude-telegram-bridge'));
+    });
+    if (settings.hooks[event].length === 0) {
+      delete settings.hooks[event];
+    }
+  }
+
+  if (Object.keys(settings.hooks).length === 0) {
+    delete settings.hooks;
+  }
+
+  fs.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2) + '\n');
+}
+
+async function run() {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const config = loadConfig();
+
+  console.log('\nClaude Telegram Bridge Setup\n');
+
+  // Bot token
+  const token = await ask(rl, `Telegram Bot Token${config.botToken ? ' [keep existing]' : ''}: `);
+  if (token.trim()) {
+    config.botToken = token.trim();
+  }
+  if (!config.botToken) {
+    console.error('Bot token is required. Create one via @BotFather on Telegram.');
+    rl.close();
+    process.exit(1);
+  }
+
+  // Validate token
+  console.log('Validating bot token...');
+  try {
+    const me = await telegramApiCall(config.botToken, 'getMe');
+    if (!me.ok) throw new Error(me.description);
+    console.log(`Bot: @${me.result.username}`);
+  } catch (err) {
+    console.error(`Invalid bot token: ${err.message}`);
+    rl.close();
+    process.exit(1);
+  }
+
+  // Chat ID
+  if (!config.chatId) {
+    console.log('\nSend /start to your bot in Telegram, then press Enter here...');
+    await ask(rl, 'Press Enter after sending /start to the bot: ');
+
+    const updates = await telegramApiCall(config.botToken, 'getUpdates?offset=-1');
+    if (updates.ok && updates.result.length > 0) {
+      const lastUpdate = updates.result[updates.result.length - 1];
+      const chat = lastUpdate.message?.chat;
+      if (chat) {
+        config.chatId = chat.id.toString();
+        console.log(`Chat ID captured: ${config.chatId}`);
+      }
+    }
+
+    if (!config.chatId) {
+      const manual = await ask(rl, 'Could not auto-detect. Enter Chat ID manually: ');
+      config.chatId = manual.trim();
+    }
+  } else {
+    console.log(`Using existing Chat ID: ${config.chatId}`);
+    const change = await ask(rl, 'Change Chat ID? [y/N]: ');
+    if (change.toLowerCase() === 'y') {
+      console.log('Send /start to your bot in Telegram, then press Enter here...');
+      await ask(rl, 'Press Enter after sending /start to the bot: ');
+      const updates = await telegramApiCall(config.botToken, 'getUpdates?offset=-1');
+      if (updates.ok && updates.result.length > 0) {
+        const lastUpdate = updates.result[updates.result.length - 1];
+        const chat = lastUpdate.message?.chat;
+        if (chat) {
+          config.chatId = chat.id.toString();
+          console.log(`Chat ID updated: ${config.chatId}`);
+        }
+      }
+    }
+  }
+
+  if (!config.chatId) {
+    console.error('Chat ID is required.');
+    rl.close();
+    process.exit(1);
+  }
+
+  // Port
+  const portStr = await ask(rl, `Daemon port [${config.port}]: `);
+  if (portStr.trim()) {
+    config.port = parseInt(portStr.trim(), 10);
+  }
+
+  // Save config
+  saveConfig(config);
+  console.log('\nConfig saved.');
+
+  // Install hooks
+  installHooks(config.port);
+  console.log('Hooks installed into ~/.claude/settings.json');
+
+  // Send test message
+  console.log('Sending test message...');
+  try {
+    const { Telegraf } = require('telegraf');
+    const testBot = new Telegraf(config.botToken);
+    await testBot.telegram.sendMessage(config.chatId, '✅ Claude Telegram Bridge configured successfully!\n\nRun `claude-tg daemon start` to begin.');
+    console.log('Test message sent to Telegram.');
+  } catch (err) {
+    console.error(`Could not send test message: ${err.message}`);
+  }
+
+  console.log('\nSetup complete! Next steps:');
+  console.log('  claude-tg daemon start   — Start the daemon');
+  console.log('  claude                   — Use Claude as normal\n');
+
+  rl.close();
+}
+
+module.exports = { run, installHooks, uninstallHooks };