@hasna/hooks 0.0.4 → 0.0.6

package/dist/index.js

@@ -1,6 +1,4 @@
 // @bun
-var __require = import.meta.require;
-
 // src/lib/registry.ts
 var CATEGORIES = [
   "Git Safety",
@@ -172,13 +170,18 @@ function getHook(name) {
   return HOOKS.find((h) => h.name === name);
 }
 // src/lib/installer.ts
-import { existsSync, cpSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { join, dirname } from "path";
 import { homedir } from "os";
 import { fileURLToPath } from "url";
 var __dirname2 = dirname(fileURLToPath(import.meta.url));
 var HOOKS_DIR = existsSync(join(__dirname2, "..", "..", "hooks", "hook-gitguard")) ? join(__dirname2, "..", "..", "hooks") : join(__dirname2, "..", "hooks");
-var SETTINGS_PATH = join(homedir(), ".claude", "settings.json");
+function getSettingsPath(scope = "global") {
+  if (scope === "project") {
+    return join(process.cwd(), ".claude", "settings.json");
+  }
+  return join(homedir(), ".claude", "settings.json");
+}
 function getHookPath(name) {
   const hookName = name.startsWith("hook-") ? name : `hook-${name}`;
   return join(HOOKS_DIR, hookName);
@@ -186,56 +189,38 @@ function getHookPath(name) {
 function hookExists(name) {
   return existsSync(getHookPath(name));
 }
-function readSettings() {
+function readSettings(scope = "global") {
+  const path = getSettingsPath(scope);
   try {
-    if (existsSync(SETTINGS_PATH)) {
-      return JSON.parse(readFileSync(SETTINGS_PATH, "utf-8"));
+    if (existsSync(path)) {
+      return JSON.parse(readFileSync(path, "utf-8"));
     }
   } catch {}
   return {};
 }
-function writeSettings(settings) {
-  const dir = dirname(SETTINGS_PATH);
+function writeSettings(settings, scope = "global") {
+  const path = getSettingsPath(scope);
+  const dir = dirname(path);
   if (!existsSync(dir)) {
     mkdirSync(dir, { recursive: true });
   }
-  writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2) + `
+  writeFileSync(path, JSON.stringify(settings, null, 2) + `
 `);
 }
 function installHook(name, options = {}) {
-  const { targetDir = process.cwd(), overwrite = false } = options;
+  const { scope = "global", overwrite = false } = options;
   const hookName = name.startsWith("hook-") ? name : `hook-${name}`;
   const shortName = hookName.replace("hook-", "");
-  const sourcePath = getHookPath(name);
-  const destDir = join(targetDir, ".hooks");
-  const destPath = join(destDir, hookName);
-  if (!existsSync(sourcePath)) {
-    return {
-      hook: shortName,
-      success: false,
-      error: `Hook '${shortName}' not found`
-    };
+  if (!hookExists(shortName)) {
+    return { hook: shortName, success: false, error: `Hook '${shortName}' not found` };
   }
-  if (existsSync(destPath) && !overwrite) {
-    return {
-      hook: shortName,
-      success: false,
-      error: `Already installed. Use --overwrite to replace.`,
-      path: destPath
-    };
+  const registered = getRegisteredHooks(scope);
+  if (registered.includes(shortName) && !overwrite) {
+    return { hook: shortName, success: false, error: "Already installed. Use --overwrite to replace.", scope };
   }
   try {
-    if (!existsSync(destDir)) {
-      mkdirSync(destDir, { recursive: true });
-    }
-    cpSync(sourcePath, destPath, { recursive: true });
-    registerHookInSettings(shortName);
-    updateHooksIndex(destDir);
-    return {
-      hook: shortName,
-      success: true,
-      path: destPath
-    };
+    registerHook(shortName, scope);
+    return { hook: shortName, success: true, scope };
   } catch (error) {
     return {
       hook: shortName,
@@ -244,20 +229,18 @@ function installHook(name, options = {}) {
     };
   }
 }
-function registerHookInSettings(name) {
+function registerHook(name, scope = "global") {
   const meta = getHook(name);
   if (!meta)
     return;
-  const settings = readSettings();
+  const settings = readSettings(scope);
   if (!settings.hooks)
     settings.hooks = {};
   const eventKey = meta.event;
   if (!settings.hooks[eventKey])
     settings.hooks[eventKey] = [];
-  const hookCommand = `hook-${name}`;
-  const existing = settings.hooks[eventKey].find((entry2) => entry2.hooks?.some((h) => h.command?.includes(hookCommand)));
-  if (existing)
-    return;
+  const hookCommand = `hooks run ${name}`;
+  settings.hooks[eventKey] = settings.hooks[eventKey].filter((entry2) => !entry2.hooks?.some((h) => h.command === hookCommand));
   const entry = {
     hooks: [{ type: "command", command: hookCommand }]
   };
@@ -265,69 +248,42 @@ function registerHookInSettings(name) {
     entry.matcher = meta.matcher;
   }
   settings.hooks[eventKey].push(entry);
-  writeSettings(settings);
+  writeSettings(settings, scope);
 }
-function unregisterHookFromSettings(name) {
+function unregisterHook(name, scope = "global") {
   const meta = getHook(name);
   if (!meta)
     return;
-  const settings = readSettings();
+  const settings = readSettings(scope);
   if (!settings.hooks)
     return;
   const eventKey = meta.event;
   if (!settings.hooks[eventKey])
     return;
-  const hookCommand = `hook-${name}`;
-  settings.hooks[eventKey] = settings.hooks[eventKey].filter((entry) => !entry.hooks?.some((h) => h.command?.includes(hookCommand)));
+  const hookCommand = `hooks run ${name}`;
+  settings.hooks[eventKey] = settings.hooks[eventKey].filter((entry) => !entry.hooks?.some((h) => h.command === hookCommand));
   if (settings.hooks[eventKey].length === 0) {
     delete settings.hooks[eventKey];
   }
   if (Object.keys(settings.hooks).length === 0) {
     delete settings.hooks;
   }
-  writeSettings(settings);
+  writeSettings(settings, scope);
 }
 function installHooks(names, options = {}) {
   return names.map((name) => installHook(name, options));
 }
-function updateHooksIndex(hooksDir) {
-  const indexPath = join(hooksDir, "index.ts");
-  const { readdirSync } = __require("fs");
-  const hooks = readdirSync(hooksDir).filter((f) => f.startsWith("hook-") && !f.includes("."));
-  const exports = hooks.map((h) => {
-    const name = h.replace("hook-", "");
-    return `export * as ${name} from './${h}/src/index.js';`;
-  }).join(`
-`);
-  const content = `/**
- * Auto-generated index of installed hooks
- * Do not edit manually - run 'hooks install' to update
- */
-
-${exports}
-`;
-  writeFileSync(indexPath, content);
-}
-function getInstalledHooks(targetDir = process.cwd()) {
-  const hooksDir = join(targetDir, ".hooks");
-  if (!existsSync(hooksDir)) {
-    return [];
-  }
-  const { readdirSync, statSync } = __require("fs");
-  return readdirSync(hooksDir).filter((f) => {
-    const fullPath = join(hooksDir, f);
-    return f.startsWith("hook-") && statSync(fullPath).isDirectory();
-  }).map((f) => f.replace("hook-", ""));
-}
-function getRegisteredHooks() {
-  const settings = readSettings();
+function getRegisteredHooks(scope = "global") {
+  const settings = readSettings(scope);
   if (!settings.hooks)
     return [];
   const registered = [];
   for (const eventKey of Object.keys(settings.hooks)) {
     for (const entry of settings.hooks[eventKey]) {
       for (const hook of entry.hooks || []) {
-        const match = hook.command?.match(/hook-(\w+)/);
+        const newMatch = hook.command?.match(/^hooks run (\w+)$/);
+        const oldMatch = hook.command?.match(/^hook-(\w+)$/);
+        const match = newMatch || oldMatch;
         if (match) {
           registered.push(match[1]);
         }
@@ -336,18 +292,17 @@ function getRegisteredHooks() {
   }
   return [...new Set(registered)];
 }
-function removeHook(name, targetDir = process.cwd()) {
-  const { rmSync } = __require("fs");
+function getInstalledHooks(scope = "global") {
+  return getRegisteredHooks(scope);
+}
+function removeHook(name, scope = "global") {
   const hookName = name.startsWith("hook-") ? name : `hook-${name}`;
   const shortName = hookName.replace("hook-", "");
-  const hooksDir = join(targetDir, ".hooks");
-  const hookPath = join(hooksDir, hookName);
-  if (!existsSync(hookPath)) {
+  const registered = getRegisteredHooks(scope);
+  if (!registered.includes(shortName)) {
     return false;
   }
-  rmSync(hookPath, { recursive: true });
-  unregisterHookFromSettings(shortName);
-  updateHooksIndex(hooksDir);
+  unregisterHook(shortName, scope);
   return true;
 }
 export {
@@ -356,6 +311,7 @@ export {
   installHooks,
   installHook,
   hookExists,
+  getSettingsPath,
   getRegisteredHooks,
   getInstalledHooks,
   getHooksByCategory,

package/hooks/hook-agentmessages/src/check-messages.ts

@@ -0,0 +1,151 @@
+#!/usr/bin/env bun
+/**
+ * Stop hook for service-message
+ *
+ * Runs when Claude finishes a response. Checks for unread messages
+ * and notifies Claude if there are any pending messages.
+ *
+ * This is efficient because it only runs after Claude completes a turn,
+ * not continuously polling.
+ */
+
+import { homedir } from 'os';
+import { join } from 'path';
+import { readdir } from 'fs/promises';
+
+interface HookInput {
+  session_id: string;
+  cwd: string;
+  hook_event_name: string;
+  stop_hook_active?: boolean;
+}
+
+interface Message {
+  id: string;
+  timestamp: number;
+  from: string;
+  to: string;
+  project: string;
+  subject: string;
+  body: string;
+  read?: boolean;
+}
+
+const SERVICE_DIR = join(homedir(), '.service', 'service-message');
+
+/**
+ * Sanitize ID to prevent path traversal attacks
+ */
+function sanitizeId(id: string): string | null {
+  if (!id || typeof id !== 'string') return null;
+  // Only allow alphanumeric, dash, underscore
+  if (!/^[a-zA-Z0-9_-]+$/.test(id)) return null;
+  // Reject path traversal attempts
+  if (id.includes('..') || id.includes('/') || id.includes('\\')) return null;
+  return id;
+}
+
+async function readJson<T>(path: string): Promise<T | null> {
+  try {
+    const file = Bun.file(path);
+    if (await file.exists()) {
+      return await file.json();
+    }
+  } catch {}
+  return null;
+}
+
+async function getUnreadMessages(agentId: string, projectId?: string): Promise<Message[]> {
+  const messages: Message[] = [];
+  const messagesDir = join(SERVICE_DIR, 'messages');
+
+  try {
+    const rawProjects = projectId ? [projectId] : await readdir(messagesDir);
+    // Sanitize all project names to prevent path traversal
+    const projects = rawProjects.map(p => sanitizeId(p)).filter((p): p is string => p !== null);
+
+    for (const proj of projects) {
+      // Check inbox
+      const inboxDir = join(messagesDir, proj, 'inbox', agentId);
+      try {
+        const files = await readdir(inboxDir);
+        for (const file of files) {
+          if (!file.endsWith('.json')) continue;
+          // Sanitize filename to prevent path traversal
+          const safeFile = sanitizeId(file.replace('.json', ''));
+          if (!safeFile) continue;
+          const msg = await readJson<Message>(join(inboxDir, `${safeFile}.json`));
+          if (msg && !msg.read) {
+            messages.push(msg);
+          }
+        }
+      } catch {}
+
+      // Check broadcast
+      const broadcastDir = join(messagesDir, proj, 'broadcast');
+      try {
+        const files = await readdir(broadcastDir);
+        for (const file of files) {
+          if (!file.endsWith('.json')) continue;
+          // Sanitize filename to prevent path traversal
+          const safeFile = sanitizeId(file.replace('.json', ''));
+          if (!safeFile) continue;
+          const msg = await readJson<Message>(join(broadcastDir, `${safeFile}.json`));
+          if (msg && !msg.read && msg.from !== agentId) {
+            messages.push(msg);
+          }
+        }
+      } catch {}
+    }
+  } catch {}
+
+  return messages.sort((a, b) => b.timestamp - a.timestamp);
+}
+
+async function main() {
+  // Get agent ID from environment (set by session-start hook)
+  const rawAgentId = process.env.SMSG_AGENT_ID;
+  const rawProjectId = process.env.SMSG_PROJECT_ID;
+
+  // Sanitize IDs to prevent path traversal
+  const agentId = rawAgentId ? sanitizeId(rawAgentId) : null;
+  const projectId = rawProjectId ? sanitizeId(rawProjectId) : undefined;
+
+  if (!agentId) {
+    // Agent not configured or invalid, skip silently
+    console.log(JSON.stringify({ continue: true }));
+    return;
+  }
+
+  // Check for unread messages
+  const unreadMessages = await getUnreadMessages(agentId, projectId);
+
+  if (unreadMessages.length === 0) {
+    // No messages, continue normally
+    console.log(JSON.stringify({ continue: true }));
+    return;
+  }
+
+  // Format message summary in a friendly way
+  const msgList = unreadMessages.slice(0, 3).map(msg => {
+    const time = new Date(msg.timestamp).toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' });
+    const preview = msg.body.slice(0, 60).replace(/\n/g, ' ');
+    return `📨 **${msg.subject}** from \`${msg.from}\` (${time})\n   ${preview}${msg.body.length > 60 ? '...' : ''}`;
+  }).join('\n\n');
+
+  const moreNote = unreadMessages.length > 3
+    ? `\n\n_...and ${unreadMessages.length - 3} more message(s)_`
+    : '';
+
+  // Inject message in a friendly, readable format
+  console.log(JSON.stringify({
+    continue: true,
+    stopReason: `📬 **You have ${unreadMessages.length} unread message(s):**\n\n${msgList}${moreNote}\n\n💡 Use \`service-message inbox\` to see all messages or \`service-message read <id>\` to read one.`
+  }));
+}
+
+main().catch(() => {
+  // Don't block on errors
+  console.log(JSON.stringify({ continue: true }));
+  process.exit(0);
+});

package/hooks/hook-agentmessages/src/install.ts

@@ -0,0 +1,126 @@
+#!/usr/bin/env bun
+/**
+ * Install hook-agentmessages into Claude Code settings
+ *
+ * Adds hooks to ~/.claude/settings.json:
+ * - SessionStart: Auto-register agent, project, session
+ * - Stop: Check for unread messages
+ */
+
+import { homedir } from 'os';
+import { join } from 'path';
+
+const CLAUDE_SETTINGS_DIR = join(homedir(), '.claude');
+const CLAUDE_SETTINGS_FILE = join(CLAUDE_SETTINGS_DIR, 'settings.json');
+const HOOK_DIR = import.meta.dir.replace('/src', '');
+
+interface HookConfig {
+  type: 'command';
+  command: string;
+  timeout?: number;
+}
+
+interface HookMatcher {
+  matcher?: string;
+  hooks: HookConfig[];
+}
+
+interface Settings {
+  hooks?: {
+    SessionStart?: HookMatcher[];
+    Stop?: HookMatcher[];
+    [key: string]: HookMatcher[] | undefined;
+  };
+  [key: string]: unknown;
+}
+
+async function readSettings(): Promise<Settings> {
+  try {
+    const file = Bun.file(CLAUDE_SETTINGS_FILE);
+    if (await file.exists()) {
+      return await file.json();
+    }
+  } catch {}
+  return {};
+}
+
+async function writeSettings(settings: Settings): Promise<void> {
+  // Ensure .claude directory exists
+  await Bun.write(join(CLAUDE_SETTINGS_DIR, '.gitkeep'), '');
+  await Bun.write(CLAUDE_SETTINGS_FILE, JSON.stringify(settings, null, 2));
+}
+
+function findHookIndex(hooks: HookMatcher[], command: string): number {
+  return hooks.findIndex(h =>
+    h.hooks.some(hook => hook.command.includes('hook-agentmessages'))
+  );
+}
+
+async function main() {
+  console.log('Installing hook-agentmessages into Claude Code...\n');
+
+  const settings = await readSettings();
+
+  // Initialize hooks object if not exists
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+
+  // SessionStart hook
+  const sessionStartHook: HookMatcher = {
+    hooks: [
+      {
+        type: 'command',
+        command: `bun ${join(HOOK_DIR, 'src/session-start.ts')}`,
+        timeout: 10,
+      },
+    ],
+  };
+
+  if (!settings.hooks.SessionStart) {
+    settings.hooks.SessionStart = [];
+  }
+
+  // Remove existing hook-agentmessages hooks
+  const existingSessionStartIdx = findHookIndex(settings.hooks.SessionStart, 'hook-agentmessages');
+  if (existingSessionStartIdx >= 0) {
+    settings.hooks.SessionStart.splice(existingSessionStartIdx, 1);
+  }
+  settings.hooks.SessionStart.push(sessionStartHook);
+
+  // Stop hook (check messages after each response)
+  const stopHook: HookMatcher = {
+    hooks: [
+      {
+        type: 'command',
+        command: `bun ${join(HOOK_DIR, 'src/check-messages.ts')}`,
+        timeout: 5,
+      },
+    ],
+  };
+
+  if (!settings.hooks.Stop) {
+    settings.hooks.Stop = [];
+  }
+
+  const existingStopIdx = findHookIndex(settings.hooks.Stop, 'hook-agentmessages');
+  if (existingStopIdx >= 0) {
+    settings.hooks.Stop.splice(existingStopIdx, 1);
+  }
+  settings.hooks.Stop.push(stopHook);
+
+  // Write updated settings
+  await writeSettings(settings);
+
+  console.log('Hooks installed successfully!\n');
+  console.log('Installed hooks:');
+  console.log('  - SessionStart: Auto-registers agent, project, and session');
+  console.log('  - Stop: Checks for unread messages after each response\n');
+  console.log(`Settings file: ${CLAUDE_SETTINGS_FILE}`);
+  console.log('\nRestart Claude Code for hooks to take effect.');
+}
+
+main().catch((err) => {
+  console.error('Installation failed:', err.message);
+  process.exit(1);
+});