@stackmemoryai/stackmemory 0.5.15 → 0.5.17

package/templates/claude-hooks/auto-background-hook.js

@@ -110,19 +110,19 @@ process.stdin.on('end', () => {
     // Only process Bash tool
     if (tool_name !== 'Bash') {
       // Allow other tools through unchanged
-      console.log(JSON.stringify({ decision: 'allow' }));
+      console.log(JSON.stringify({ permissionDecision: 'allow' }));
       return;
     }
 
     const command = tool_input?.command;
     if (!command) {
-      console.log(JSON.stringify({ decision: 'allow' }));
+      console.log(JSON.stringify({ permissionDecision: 'allow' }));
       return;
     }
 
     // Already backgrounded
     if (tool_input.run_in_background === true) {
-      console.log(JSON.stringify({ decision: 'allow' }));
+      console.log(JSON.stringify({ permissionDecision: 'allow' }));
       return;
     }
 
@@ -135,22 +135,23 @@ process.stdin.on('end', () => {
         );
       }
 
-      // Modify the tool input to add run_in_background
+      // Modify the tool input to add run_in_background using correct schema
       console.log(
         JSON.stringify({
-          decision: 'modify',
-          tool_input: {
+          hookEventName: 'PreToolUse',
+          permissionDecision: 'allow',
+          updatedInput: {
             ...tool_input,
             run_in_background: true,
           },
         })
       );
     } else {
-      console.log(JSON.stringify({ decision: 'allow' }));
+      console.log(JSON.stringify({ permissionDecision: 'allow' }));
     }
   } catch (err) {
     // On error, allow the command through unchanged
     console.error('[auto-bg] Error:', err.message);
-    console.log(JSON.stringify({ decision: 'allow' }));
+    console.log(JSON.stringify({ permissionDecision: 'allow' }));
   }
 });

package/templates/claude-hooks/notify-review-hook.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 /**
- * Claude Code hook for SMS notifications on review-ready events
+ * Claude Code hook for WhatsApp/SMS notifications
  *
  * Triggers notifications when:
+ * - AskUserQuestion tool is used (allows remote response)
  * - PR is created
  * - Task is marked complete
  * - User explicitly requests notification
@@ -15,7 +16,35 @@ const path = require('path');
 const os = require('os');
 const https = require('https');
 
+// Load .env files (check multiple locations)
+const envPaths = [
+  path.join(process.cwd(), '.env'),
+  path.join(os.homedir(), 'Dev/stackmemory/.env'),
+  path.join(os.homedir(), '.stackmemory/.env'),
+  path.join(os.homedir(), '.env'),
+];
+for (const envPath of envPaths) {
+  if (fs.existsSync(envPath)) {
+    try {
+      const content = fs.readFileSync(envPath, 'utf8');
+      for (const line of content.split('\n')) {
+        const match = line.match(/^([^#=]+)=(.*)$/);
+        if (match && !process.env[match[1].trim()]) {
+          process.env[match[1].trim()] = match[2]
+            .trim()
+            .replace(/^["']|["']$/g, '');
+        }
+      }
+    } catch {}
+  }
+}
+
 const CONFIG_PATH = path.join(os.homedir(), '.stackmemory', 'sms-notify.json');
+const DEBUG_LOG = path.join(
+  os.homedir(),
+  '.stackmemory',
+  'claude-session-debug.log'
+);
 
 function loadConfig() {
   try {
@@ -23,13 +52,103 @@ function loadConfig() {
       return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
     }
   } catch {}
-  return { enabled: false };
+  return { enabled: false, pendingPrompts: [] };
+}
+
+function saveConfig(config) {
+  try {
+    const dir = path.join(os.homedir(), '.stackmemory');
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+  } catch (err) {
+    console.error('[notify-hook] Failed to save config:', err.message);
+  }
+}
+
+function logDebug(event, data) {
+  try {
+    const entry = `[${new Date().toISOString()}] ${event}: ${typeof data === 'string' ? data : JSON.stringify(data)}\n`;
+    fs.appendFileSync(DEBUG_LOG, entry);
+  } catch {}
+}
+
+function savePendingPrompt(prompt) {
+  try {
+    const config = loadConfig();
+    if (!config.pendingPrompts) {
+      config.pendingPrompts = [];
+    }
+    config.pendingPrompts.push(prompt);
+    // Keep only last 10 prompts
+    if (config.pendingPrompts.length > 10) {
+      config.pendingPrompts = config.pendingPrompts.slice(-10);
+    }
+    saveConfig(config);
+    logDebug('PENDING_PROMPT', {
+      id: prompt.id,
+      options: prompt.options.length,
+    });
+  } catch (err) {
+    console.error('[notify-hook] Failed to save pending prompt:', err.message);
+  }
 }
 
 function shouldNotify(toolName, toolInput, output) {
   const config = loadConfig();
   if (!config.enabled) return null;
 
+  // AskUserQuestion - send question via WhatsApp for remote response
+  if (toolName === 'AskUserQuestion') {
+    const questions = toolInput?.questions || [];
+    if (questions.length === 0) return null;
+
+    // Take first question (most common case)
+    const q = questions[0];
+    const promptId = Math.random().toString(36).substring(2, 10);
+
+    // Build message text
+    let messageText = q.question;
+    const options = [];
+
+    if (q.options && q.options.length > 0) {
+      messageText += '\n';
+      q.options.forEach((opt, i) => {
+        const key = String(i + 1);
+        messageText += `${key}. ${opt.label}`;
+        if (opt.description) {
+          messageText += ` - ${opt.description}`;
+        }
+        messageText += '\n';
+        options.push({ key, label: opt.label });
+      });
+      // Add "Other" option
+      const otherKey = String(q.options.length + 1);
+      messageText += `${otherKey}. Other (type your answer)`;
+      options.push({ key: otherKey, label: 'Other' });
+    }
+
+    // Store pending prompt in format webhook expects
+    const pendingPrompt = {
+      id: promptId,
+      timestamp: new Date().toISOString(),
+      message: q.question,
+      options: options,
+      type: options.length > 0 ? 'options' : 'freeform',
+      expiresAt: new Date(Date.now() + 60 * 60 * 1000).toISOString(), // 1 hour
+    };
+    savePendingPrompt(pendingPrompt);
+
+    return {
+      type: 'custom',
+      title: 'Claude needs your input',
+      message: messageText,
+      promptId: promptId,
+      isQuestion: true,
+    };
+  }
+
   // Check for PR creation
   if (toolName === 'Bash') {
     const cmd = toolInput?.command || '';
@@ -73,30 +192,71 @@ function shouldNotify(toolName, toolInput, output) {
   return null;
 }
 
-function sendNotification(notification) {
-  const config = loadConfig();
+function getChannelNumbers(config) {
+  const channel = config.channel || 'whatsapp';
 
-  if (
-    !config.accountSid ||
-    !config.authToken ||
-    !config.fromNumber ||
-    !config.toNumber
-  ) {
-    // Try env vars
-    const sid = process.env.TWILIO_ACCOUNT_SID;
-    const token = process.env.TWILIO_AUTH_TOKEN;
-    const from = process.env.TWILIO_FROM_NUMBER;
-    const to = process.env.TWILIO_TO_NUMBER;
-
-    if (!sid || !token || !from || !to) {
-      console.error('[notify-hook] Missing Twilio credentials');
-      return;
+  if (channel === 'whatsapp') {
+    const from = config.whatsappFromNumber || config.fromNumber;
+    const to = config.whatsappToNumber || config.toNumber;
+    if (from && to) {
+      return {
+        from: from.startsWith('whatsapp:') ? from : `whatsapp:${from}`,
+        to: to.startsWith('whatsapp:') ? to : `whatsapp:${to}`,
+        channel: 'whatsapp',
+      };
     }
+  }
 
-    config.accountSid = sid;
-    config.authToken = token;
-    config.fromNumber = from;
-    config.toNumber = to;
+  // Fallback to SMS
+  const from = config.smsFromNumber || config.fromNumber;
+  const to = config.smsToNumber || config.toNumber;
+  if (from && to) {
+    return { from, to, channel: 'sms' };
+  }
+
+  return null;
+}
+
+function sendNotification(notification) {
+  let config = loadConfig();
+
+  // Apply env vars
+  config.accountSid = config.accountSid || process.env.TWILIO_ACCOUNT_SID;
+  config.authToken = config.authToken || process.env.TWILIO_AUTH_TOKEN;
+  config.channel = config.channel || process.env.TWILIO_CHANNEL || 'whatsapp';
+
+  // WhatsApp numbers
+  config.whatsappFromNumber =
+    config.whatsappFromNumber || process.env.TWILIO_WHATSAPP_FROM;
+  config.whatsappToNumber =
+    config.whatsappToNumber || process.env.TWILIO_WHATSAPP_TO;
+
+  // SMS numbers (fallback)
+  config.smsFromNumber =
+    config.smsFromNumber ||
+    process.env.TWILIO_SMS_FROM ||
+    process.env.TWILIO_FROM_NUMBER;
+  config.smsToNumber =
+    config.smsToNumber ||
+    process.env.TWILIO_SMS_TO ||
+    process.env.TWILIO_TO_NUMBER;
+
+  // Legacy support
+  config.fromNumber = config.fromNumber || process.env.TWILIO_FROM_NUMBER;
+  config.toNumber = config.toNumber || process.env.TWILIO_TO_NUMBER;
+
+  if (!config.accountSid || !config.authToken) {
+    console.error('[notify-hook] Missing Twilio credentials');
+    return;
+  }
+
+  const numbers = getChannelNumbers(config);
+  if (!numbers) {
+    console.error(
+      '[notify-hook] Missing phone numbers for channel:',
+      config.channel
+    );
+    return;
   }
 
   let message = `${notification.title}\n\n${notification.message}`;
@@ -109,9 +269,22 @@ function sendNotification(notification) {
     message += '\nReply with number to select';
   }
 
+  // For questions, add reply instruction
+  if (notification.isQuestion) {
+    message += '\n\nReply with your choice number or type your answer.';
+    if (notification.promptId) {
+      message += `\n[ID: ${notification.promptId}]`;
+    }
+  }
+
+  // Add session link if available
+  if (notification.sessionId) {
+    message += `\n\nSession: https://claude.ai/share/${notification.sessionId}`;
+  }
+
   const postData = new URLSearchParams({
-    From: config.fromNumber,
-    To: config.toNumber,
+    From: numbers.from,
+    To: numbers.to,
     Body: message,
   }).toString();
 
@@ -132,11 +305,23 @@ function sendNotification(notification) {
   };
 
   const req = https.request(options, (res) => {
-    if (res.statusCode === 201) {
-      console.error(`[notify-hook] Sent: ${notification.title}`);
-    } else {
-      console.error(`[notify-hook] Failed: ${res.statusCode}`);
-    }
+    let body = '';
+    res.on('data', (chunk) => (body += chunk));
+    res.on('end', () => {
+      if (res.statusCode === 201) {
+        console.error(
+          `[notify-hook] Sent via ${numbers.channel}: ${notification.title}`
+        );
+        logDebug('MESSAGE_SENT', {
+          channel: numbers.channel,
+          title: notification.title,
+          promptId: notification.promptId,
+        });
+      } else {
+        console.error(`[notify-hook] Failed (${res.statusCode}): ${body}`);
+        logDebug('MESSAGE_FAILED', { status: res.statusCode, error: body });
+      }
+    });
   });
 
   req.on('error', (e) => {
@@ -156,15 +341,19 @@ process.stdin.on('end', () => {
     const hookData = JSON.parse(input);
     const { tool_name, tool_input, tool_output } = hookData;
 
+    logDebug('PostToolUse', { tool: tool_name, session: hookData.session_id });
+
     const notification = shouldNotify(tool_name, tool_input, tool_output);
 
     if (notification) {
+      notification.sessionId = hookData.session_id;
       sendNotification(notification);
     }
 
     // Always allow (post-tool hooks don't block)
     console.log(JSON.stringify({ status: 'ok' }));
   } catch (err) {
+    logDebug('ERROR', err.message);
     console.error('[notify-hook] Error:', err.message);
     console.log(JSON.stringify({ status: 'ok' }));
   }

package/templates/claude-hooks/sms-response-handler.js

@@ -139,13 +139,9 @@ process.stdin.on('end', () => {
 
         clearLatestResponse();
 
-        console.log(
-          JSON.stringify({
-            decision: 'allow',
-            context: context,
-            user_message: `[SMS Response] User replied: "${latestResponse.response}"`,
-          })
-        );
+        // Log context to stderr for visibility, allow the tool
+        console.error(`[sms-hook] Context: ${JSON.stringify(context)}`);
+        console.log(JSON.stringify({ permissionDecision: 'allow' }));
         return;
       }
 
@@ -162,24 +158,17 @@ process.stdin.on('end', () => {
           )
           .join('\n');
 
-        console.log(
-          JSON.stringify({
-            decision: 'allow',
-            context: {
-              type: 'sms_actions_executed',
-              results,
-            },
-            user_message: `[SMS Actions] Executed queued actions:\n${summary}`,
-          })
-        );
+        // Log results to stderr for visibility, allow the tool
+        console.error(`[sms-hook] Actions summary:\n${summary}`);
+        console.log(JSON.stringify({ permissionDecision: 'allow' }));
         return;
       }
     }
 
     // Default: allow everything
-    console.log(JSON.stringify({ decision: 'allow' }));
+    console.log(JSON.stringify({ permissionDecision: 'allow' }));
   } catch (err) {
     console.error('[sms-hook] Error:', err.message);
-    console.log(JSON.stringify({ decision: 'allow' }));
+    console.log(JSON.stringify({ permissionDecision: 'allow' }));
   }
 });