@moshi-labs/snitch 1.0.0

package/README.md

@@ -0,0 +1,53 @@
+# @moshi-labs/snitch
+
+CLI daemon that reports Claude Code activity to a team server.
+
+## Install
+
+```bash
+npm install -g @moshi-labs/snitch
+```
+
+## Setup
+
+```bash
+snitch init
+```
+
+You'll be prompted for:
+- **Server URL** - Your team's snitch server
+- **API Key** - Team API key for authentication
+- **Your name** - How you appear on the dashboard
+
+## Usage
+
+```bash
+snitch start    # Start the background daemon
+snitch stop     # Stop the daemon
+snitch status   # Check if daemon is running
+snitch logs     # View recent logs
+snitch logs -f  # Follow logs in real-time
+```
+
+## How It Works
+
+1. Daemon watches `~/.claude/projects/` for Claude Code session activity
+2. Extracts tool calls and messages from moshi-labs repos
+3. POSTs activity to your team server
+4. Server categorizes work and displays on dashboard
+
+## Config
+
+Stored in `~/.snitch/config.json`:
+
+```json
+{
+  "serverUrl": "http://your-server:3333",
+  "apiKey": "your-team-key",
+  "userName": "Your Name"
+}
+```
+
+## License
+
+MIT

package/bin/snitch.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { readFileSync } from 'fs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
+
+const program = new Command();
+
+program
+  .name('snitch')
+  .description('Team awareness CLI for Claude Code sessions')
+  .version(pkg.version);
+
+program
+  .command('init')
+  .description('Configure snitch (server URL, API key, user name)')
+  .action(async () => {
+    const { initCommand } = await import('../cli/commands/init.js');
+    await initCommand();
+  });
+
+program
+  .command('start')
+  .description('Start the background daemon')
+  .option('-f, --foreground', 'Run in foreground (for debugging)')
+  .action(async (options) => {
+    const { startCommand } = await import('../cli/commands/start.js');
+    startCommand(options);
+  });
+
+program
+  .command('stop')
+  .description('Stop the background daemon')
+  .action(async () => {
+    const { stopCommand } = await import('../cli/commands/stop.js');
+    stopCommand();
+  });
+
+program
+  .command('status')
+  .description('Show daemon status')
+  .action(async () => {
+    const { statusCommand } = await import('../cli/commands/status.js');
+    statusCommand();
+  });
+
+program
+  .command('logs')
+  .description('View daemon logs')
+  .option('-n, --lines <number>', 'Number of lines to show', '50')
+  .option('-f, --follow', 'Follow log output')
+  .action(async (options) => {
+    const { logsCommand } = await import('../cli/commands/logs.js');
+    logsCommand({ ...options, lines: parseInt(options.lines, 10) });
+  });
+
+program.parse();

package/cli/client.js

@@ -0,0 +1,100 @@
+import { load } from './config.js';
+
+/**
+ * HTTP client for posting activity to the snitch server
+ */
+export class SnitchClient {
+  constructor() {
+    this.queue = [];
+    this.isProcessing = false;
+    this.maxRetries = 3;
+    this.retryDelayMs = 5000;
+  }
+
+  /**
+   * Post activity to the server
+   */
+  async postActivity(activity) {
+    const config = load();
+
+    if (!config.serverUrl || !config.apiKey) {
+      console.error('[client] Not configured. Run: snitch init');
+      return false;
+    }
+
+    const url = `${config.serverUrl}/api/activity`;
+
+    try {
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-API-Secret': config.apiKey,
+        },
+        body: JSON.stringify(activity),
+      });
+
+      if (!response.ok) {
+        const error = await response.text();
+        console.error(`[client] Server error: ${response.status} - ${error}`);
+        return false;
+      }
+
+      return true;
+    } catch (err) {
+      console.error(`[client] Network error: ${err.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Queue activity for posting with retry logic
+   */
+  enqueue(activity) {
+    this.queue.push({ activity, retries: 0 });
+    this.processQueue();
+  }
+
+  /**
+   * Process queued activities
+   */
+  async processQueue() {
+    if (this.isProcessing || this.queue.length === 0) {
+      return;
+    }
+
+    this.isProcessing = true;
+
+    while (this.queue.length > 0) {
+      const item = this.queue[0];
+
+      const success = await this.postActivity(item.activity);
+
+      if (success) {
+        this.queue.shift(); // Remove from queue
+        console.log(`[client] Posted activity for session ${item.activity.sessionId.slice(0, 8)}`);
+      } else {
+        item.retries++;
+        if (item.retries >= this.maxRetries) {
+          console.error(`[client] Giving up on activity after ${this.maxRetries} retries`);
+          this.queue.shift();
+        } else {
+          console.log(`[client] Will retry in ${this.retryDelayMs / 1000}s (attempt ${item.retries}/${this.maxRetries})`);
+          // Move to end of queue and wait before retrying
+          this.queue.shift();
+          this.queue.push(item);
+          await new Promise(resolve => setTimeout(resolve, this.retryDelayMs));
+        }
+      }
+    }
+
+    this.isProcessing = false;
+  }
+
+  /**
+   * Get queue size
+   */
+  getQueueSize() {
+    return this.queue.length;
+  }
+}

package/cli/collector.js

@@ -0,0 +1,185 @@
+import chokidar from 'chokidar';
+import { readFileSync, statSync, existsSync } from 'fs';
+import { join, basename, dirname } from 'path';
+import { execSync } from 'child_process';
+import { homedir } from 'os';
+
+const CLAUDE_PROJECTS_DIR = join(homedir(), '.claude', 'projects');
+
+/**
+ * Watches session JSONL files and emits activity events
+ */
+export class ActivityCollector {
+  constructor(onActivity, userName) {
+    this.onActivity = onActivity;
+    this.userName = userName;
+    this.watcher = null;
+    this.filePositions = new Map(); // Track read position per file
+    this.activeThresholdMs = 5 * 60 * 1000; // 5 minutes = active
+    // Only track these repos
+    this.allowedRepos = ['moshi-api', 'moshi-frontend', 'moshi-e2e', 'terraform', 'browser-use', 'claude-team-viewer', 'snitch'];
+  }
+
+  start() {
+    // Watch all .jsonl files in projects directory
+    const pattern = join(CLAUDE_PROJECTS_DIR, '*', '*.jsonl');
+
+    this.watcher = chokidar.watch(pattern, {
+      ignoreInitial: true,  // Don't process existing files on startup
+      awaitWriteFinish: { stabilityThreshold: 200 },
+    });
+
+    this.watcher.on('add', (path) => this.handleFile(path, true));
+    this.watcher.on('change', (path) => this.handleFile(path, false));
+
+    console.log(`[collector] Watching for activity in ${CLAUDE_PROJECTS_DIR}`);
+  }
+
+  handleFile(filePath, isNew) {
+    // Skip sessions-index.json
+    if (basename(filePath) === 'sessions-index.json') return;
+
+    const sessionId = basename(filePath, '.jsonl');
+    const projectDir = basename(dirname(filePath));
+
+    try {
+      const stat = statSync(filePath);
+      const lastModified = stat.mtime;
+      const isActive = (Date.now() - lastModified.getTime()) < this.activeThresholdMs;
+
+      // Read new content since last position
+      const content = readFileSync(filePath, 'utf-8');
+      const lastPos = this.filePositions.get(filePath) || 0;
+      const newContent = content.slice(lastPos);
+      this.filePositions.set(filePath, content.length);
+
+      if (!newContent.trim()) return;
+
+      // Only process if file was modified in last hour
+      const oneHourAgo = Date.now() - (60 * 60 * 1000);
+      if (lastModified.getTime() < oneHourAgo) {
+        return;
+      }
+
+      // Parse new lines
+      const lines = newContent.trim().split('\n');
+      const events = [];
+
+      for (const line of lines) {
+        try {
+          const event = JSON.parse(line);
+          events.push(event);
+        } catch {
+          // Skip malformed lines
+        }
+      }
+
+      if (events.length === 0) return;
+
+      // Extract activity from events
+      const activity = this.extractActivity(sessionId, projectDir, events, lastModified, isActive);
+
+      if (activity) {
+        // Only emit if working on an allowed repo
+        if (activity.repo && this.allowedRepos.includes(activity.repo)) {
+          this.onActivity(activity);
+        } else if (projectDir.includes('moshi')) {
+          // Also allow if the project dir contains 'moshi'
+          this.onActivity(activity);
+        }
+      }
+    } catch (err) {
+      // File might be mid-write
+    }
+  }
+
+  extractActivity(sessionId, projectDir, events, lastModified, isActive) {
+    const activity = {
+      sessionId,
+      user: this.userName,
+      timestamp: lastModified.toISOString(),
+      isActive,
+      events: [],
+      repo: null,
+      branch: null,
+    };
+
+    for (const event of events) {
+      // Extract user messages
+      if (event.type === 'user' && event.message?.content) {
+        const content = typeof event.message.content === 'string'
+          ? event.message.content
+          : event.message.content.map(c => c.text || '').join('');
+        activity.events.push({
+          type: 'user_message',
+          content: content.slice(0, 500), // Truncate
+          timestamp: event.timestamp,
+        });
+      }
+
+      // Extract assistant tool calls
+      if (event.type === 'assistant' && event.message?.content) {
+        for (const block of event.message.content) {
+          if (block.type === 'tool_use') {
+            const toolEvent = {
+              type: 'tool_call',
+              tool: block.name,
+              timestamp: event.timestamp,
+            };
+
+            // Extract repo/branch hints from tool calls
+            if (block.name === 'Bash' && block.input?.command) {
+              const cmd = block.input.command;
+              // Detect git branch switches
+              const branchMatch = cmd.match(/git (?:checkout|switch)(?: -b)? ([^\s&|;]+)/);
+              if (branchMatch) {
+                activity.branch = branchMatch[1];
+              }
+              // Detect cd into repos
+              const cdMatch = cmd.match(/cd\s+['"]*([^'"&|;\s]+)/);
+              if (cdMatch) {
+                const path = cdMatch[1];
+                const repoMatch = path.match(/moshi-(api|frontend|e2e)|terraform|browser-use|claude-team-viewer|snitch/);
+                if (repoMatch) {
+                  activity.repo = repoMatch[0];
+                }
+              }
+              toolEvent.hint = cmd.slice(0, 200);
+            }
+
+            // Extract repo hints from file operations
+            if (['Read', 'Edit', 'Write'].includes(block.name) && block.input?.file_path) {
+              const path = block.input.file_path;
+              const repoMatch = path.match(/moshi-(api|frontend|e2e)|terraform|browser-use|claude-team-viewer|snitch/);
+              if (repoMatch) {
+                activity.repo = repoMatch[0];
+              }
+              toolEvent.hint = path;
+            }
+
+            activity.events.push(toolEvent);
+          }
+        }
+      }
+
+      // Extract session metadata
+      if (event.gitBranch) {
+        activity.branch = event.gitBranch;
+      }
+      if (event.cwd) {
+        const repoMatch = event.cwd.match(/moshi-(api|frontend|e2e)|terraform|browser-use|claude-team-viewer|snitch/);
+        if (repoMatch) {
+          activity.repo = repoMatch[0];
+        }
+      }
+    }
+
+    return activity.events.length > 0 ? activity : null;
+  }
+
+  stop() {
+    if (this.watcher) {
+      this.watcher.close();
+    }
+  }
+}

package/cli/commands/init.js

@@ -0,0 +1,62 @@
+import { load, save, paths } from '../config.js';
+import * as readline from 'readline';
+
+/**
+ * Interactive configuration setup
+ */
+export async function initCommand() {
+  const config = load();
+
+  console.log('Snitch Configuration');
+  console.log('====================\n');
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  const question = (prompt) => new Promise((resolve) => {
+    rl.question(prompt, resolve);
+  });
+
+  try {
+    // Server URL
+    const serverUrlPrompt = config.serverUrl
+      ? `Server URL [${config.serverUrl}]: `
+      : 'Server URL: ';
+    const serverUrl = await question(serverUrlPrompt);
+    if (serverUrl.trim()) {
+      config.serverUrl = serverUrl.trim();
+    } else if (!config.serverUrl) {
+      console.log('Error: Server URL is required');
+      rl.close();
+      return;
+    }
+
+    // API Key
+    const apiKeyPrompt = config.apiKey
+      ? `API Key [***]: `
+      : 'API Key: ';
+    const apiKey = await question(apiKeyPrompt);
+    if (apiKey.trim()) {
+      config.apiKey = apiKey.trim();
+    }
+
+    // User Name
+    const defaultName = config.userName || process.env.USER || '';
+    const userName = await question(`Your name [${defaultName}]: `);
+    config.userName = userName.trim() || defaultName;
+
+    save(config);
+
+    console.log('\nConfiguration saved to:', paths.config);
+    console.log('\nCurrent config:');
+    console.log(`  Server URL: ${config.serverUrl}`);
+    console.log(`  API Key:    ${config.apiKey ? '***' : '(not set)'}`);
+    console.log(`  User Name:  ${config.userName}`);
+    console.log('\nRun "snitch start" to begin tracking activity.');
+
+  } finally {
+    rl.close();
+  }
+}

package/cli/commands/logs.js

@@ -0,0 +1,49 @@
+import { existsSync, readFileSync, watchFile, statSync } from 'fs';
+import { paths } from '../config.js';
+
+/**
+ * Tail daemon logs
+ */
+export function logsCommand(options) {
+  const logFile = paths.log;
+
+  if (!existsSync(logFile)) {
+    console.log('No log file found. Start the daemon first: snitch start');
+    return;
+  }
+
+  const lines = options.lines || 50;
+
+  // Read last N lines
+  const content = readFileSync(logFile, 'utf-8');
+  const allLines = content.split('\n').filter(Boolean);
+  const lastLines = allLines.slice(-lines);
+
+  console.log(`=== Last ${Math.min(lines, lastLines.length)} log entries ===\n`);
+  console.log(lastLines.join('\n'));
+
+  if (options.follow) {
+    console.log('\n=== Following log file (Ctrl+C to stop) ===\n');
+
+    let lastSize = statSync(logFile).size;
+
+    watchFile(logFile, { interval: 500 }, () => {
+      try {
+        const newSize = statSync(logFile).size;
+        if (newSize > lastSize) {
+          const content = readFileSync(logFile, 'utf-8');
+          const newContent = content.slice(lastSize);
+          process.stdout.write(newContent);
+          lastSize = newSize;
+        }
+      } catch {
+        // File might be in flux
+      }
+    });
+
+    // Keep process alive
+    process.on('SIGINT', () => {
+      process.exit(0);
+    });
+  }
+}

package/cli/commands/start.js

@@ -0,0 +1,36 @@
+import { startDaemon, isRunning } from '../daemon.js';
+import { load } from '../config.js';
+
+/**
+ * Start the background daemon
+ */
+export function startCommand(options) {
+  const config = load();
+
+  if (!config.serverUrl || !config.apiKey || !config.userName) {
+    console.error('Error: Not configured. Run: snitch init');
+    process.exit(1);
+  }
+
+  if (options.foreground) {
+    // Run in foreground (for debugging)
+    console.log('Running in foreground mode (Ctrl+C to stop)...\n');
+    import('../daemon.js').then(({ runDaemonForeground }) => {
+      runDaemonForeground();
+    });
+    return;
+  }
+
+  const result = startDaemon();
+
+  if (result.success) {
+    console.log(`Snitch daemon started (PID: ${result.pid})`);
+    console.log(`User: ${config.userName}`);
+    console.log(`Server: ${config.serverUrl}`);
+    console.log('\nRun "snitch status" to check status');
+    console.log('Run "snitch logs" to view logs');
+  } else {
+    console.error(`Error: ${result.error}`);
+    process.exit(1);
+  }
+}

package/cli/commands/status.js

@@ -0,0 +1,38 @@
+import { getStatus } from '../daemon.js';
+import { paths } from '../config.js';
+
+/**
+ * Show daemon status
+ */
+export function statusCommand() {
+  const status = getStatus();
+
+  console.log('Snitch Status');
+  console.log('=============\n');
+
+  if (status.running) {
+    console.log(`Status:     Running (PID: ${status.pid})`);
+  } else {
+    console.log('Status:     Stopped');
+  }
+
+  console.log(`Configured: ${status.configured ? 'Yes' : 'No'}`);
+
+  if (status.config.userName) {
+    console.log(`User:       ${status.config.userName}`);
+  }
+
+  if (status.config.serverUrl) {
+    console.log(`Server:     ${status.config.serverUrl}`);
+  }
+
+  console.log(`\nConfig:     ${paths.config}`);
+  console.log(`Logs:       ${paths.log}`);
+  console.log(`PID file:   ${paths.pid}`);
+
+  if (!status.running && status.configured) {
+    console.log('\nRun "snitch start" to begin tracking activity.');
+  } else if (!status.configured) {
+    console.log('\nRun "snitch init" to configure.');
+  }
+}

package/cli/commands/stop.js

@@ -0,0 +1,15 @@
+import { stopDaemon, isRunning } from '../daemon.js';
+
+/**
+ * Stop the background daemon
+ */
+export function stopCommand() {
+  const result = stopDaemon();
+
+  if (result.success) {
+    console.log('Snitch daemon stopped');
+  } else {
+    console.error(`Error: ${result.error}`);
+    process.exit(1);
+  }
+}

package/cli/config.js

@@ -0,0 +1,82 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const SNITCH_DIR = join(homedir(), '.snitch');
+const CONFIG_FILE = join(SNITCH_DIR, 'config.json');
+const LOG_FILE = join(SNITCH_DIR, 'daemon.log');
+const PID_FILE = join(SNITCH_DIR, 'daemon.pid');
+
+/**
+ * Default config schema
+ */
+const DEFAULT_CONFIG = {
+  serverUrl: '',
+  apiKey: '',
+  userName: '',
+};
+
+/**
+ * Ensure ~/.snitch directory exists
+ */
+export function ensureDir() {
+  if (!existsSync(SNITCH_DIR)) {
+    mkdirSync(SNITCH_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Load config from ~/.snitch/config.json
+ */
+export function load() {
+  ensureDir();
+  if (existsSync(CONFIG_FILE)) {
+    try {
+      const data = JSON.parse(readFileSync(CONFIG_FILE, 'utf-8'));
+      return { ...DEFAULT_CONFIG, ...data };
+    } catch {
+      return { ...DEFAULT_CONFIG };
+    }
+  }
+  return { ...DEFAULT_CONFIG };
+}
+
+/**
+ * Save config to ~/.snitch/config.json
+ */
+export function save(config) {
+  ensureDir();
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+/**
+ * Get a specific config value
+ */
+export function get(key) {
+  const config = load();
+  return config[key];
+}
+
+/**
+ * Set a specific config value
+ */
+export function set(key, value) {
+  const config = load();
+  config[key] = value;
+  save(config);
+}
+
+/**
+ * Check if config is complete (has all required fields)
+ */
+export function isConfigured() {
+  const config = load();
+  return config.serverUrl && config.apiKey && config.userName;
+}
+
+export const paths = {
+  dir: SNITCH_DIR,
+  config: CONFIG_FILE,
+  log: LOG_FILE,
+  pid: PID_FILE,
+};

package/cli/daemon-process.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+/**
+ * This is the actual daemon process that runs in the background.
+ * It's spawned by daemon.js startDaemon().
+ */
+
+import { appendFileSync } from 'fs';
+import { paths, load, ensureDir } from './config.js';
+import { ActivityCollector } from './collector.js';
+import { SnitchClient } from './client.js';
+
+ensureDir();
+
+// Redirect console to log file
+const originalLog = console.log;
+const originalError = console.error;
+
+function log(level, ...args) {
+  const timestamp = new Date().toISOString();
+  const message = `[${timestamp}] [${level}] ${args.join(' ')}\n`;
+  try {
+    appendFileSync(paths.log, message);
+  } catch {
+    // Ignore log write errors
+  }
+}
+
+console.log = (...args) => log('INFO', ...args);
+console.error = (...args) => log('ERROR', ...args);
+
+// Main daemon logic
+const config = load();
+
+if (!config.serverUrl || !config.apiKey || !config.userName) {
+  console.error('Not configured. Exiting.');
+  process.exit(1);
+}
+
+console.log(`Starting snitch daemon for ${config.userName}`);
+console.log(`Server: ${config.serverUrl}`);
+
+const client = new SnitchClient();
+
+const collector = new ActivityCollector((activity) => {
+  console.log(`Activity: session=${activity.sessionId.slice(0, 8)}, repo=${activity.repo || '?'}, events=${activity.events.length}`);
+  client.enqueue(activity);
+}, config.userName);
+
+collector.start();
+
+console.log('Watching for Claude Code activity...');
+
+// Graceful shutdown
+process.on('SIGTERM', () => {
+  console.log('Received SIGTERM, shutting down...');
+  collector.stop();
+  process.exit(0);
+});
+
+process.on('SIGINT', () => {
+  console.log('Received SIGINT, shutting down...');
+  collector.stop();
+  process.exit(0);
+});
+
+// Keep process alive
+setInterval(() => {
+  // Heartbeat - keeps the process running
+}, 60000);

package/cli/daemon.js

@@ -0,0 +1,139 @@
+import { spawn } from 'child_process';
+import { existsSync, readFileSync, writeFileSync, unlinkSync, appendFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { paths, load, ensureDir } from './config.js';
+import { ActivityCollector } from './collector.js';
+import { SnitchClient } from './client.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Check if daemon is running
+ */
+export function isRunning() {
+  if (!existsSync(paths.pid)) {
+    return false;
+  }
+
+  try {
+    const pid = parseInt(readFileSync(paths.pid, 'utf-8').trim(), 10);
+    // Check if process exists
+    process.kill(pid, 0);
+    return pid;
+  } catch {
+    // Process doesn't exist, clean up stale PID file
+    try {
+      unlinkSync(paths.pid);
+    } catch {}
+    return false;
+  }
+}
+
+/**
+ * Start daemon in background
+ */
+export function startDaemon() {
+  ensureDir();
+
+  if (isRunning()) {
+    return { success: false, error: 'Daemon is already running' };
+  }
+
+  const config = load();
+  if (!config.serverUrl || !config.apiKey || !config.userName) {
+    return { success: false, error: 'Not configured. Run: snitch init' };
+  }
+
+  // Spawn detached process
+  const daemonScript = join(__dirname, 'daemon-process.js');
+  const out = appendFileSync(paths.log, ''); // Ensure log file exists
+
+  const child = spawn(process.execPath, [daemonScript], {
+    detached: true,
+    stdio: ['ignore', 'ignore', 'ignore'],
+    env: { ...process.env, SNITCH_DAEMON: '1' },
+  });
+
+  child.unref();
+
+  // Write PID file
+  writeFileSync(paths.pid, child.pid.toString());
+
+  return { success: true, pid: child.pid };
+}
+
+/**
+ * Stop daemon
+ */
+export function stopDaemon() {
+  const pid = isRunning();
+
+  if (!pid) {
+    return { success: false, error: 'Daemon is not running' };
+  }
+
+  try {
+    process.kill(pid, 'SIGTERM');
+    // Clean up PID file
+    try {
+      unlinkSync(paths.pid);
+    } catch {}
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+/**
+ * Run daemon in foreground (used by daemon-process.js)
+ */
+export function runDaemonForeground() {
+  const config = load();
+
+  console.log(`[daemon] Starting snitch daemon for ${config.userName}`);
+  console.log(`[daemon] Server: ${config.serverUrl}`);
+
+  const client = new SnitchClient();
+
+  const collector = new ActivityCollector((activity) => {
+    console.log(`[daemon] Activity: session=${activity.sessionId.slice(0, 8)}, repo=${activity.repo || '?'}, events=${activity.events.length}`);
+    client.enqueue(activity);
+  }, config.userName);
+
+  collector.start();
+
+  console.log('[daemon] Watching for Claude Code activity...');
+
+  // Graceful shutdown
+  process.on('SIGTERM', () => {
+    console.log('[daemon] Shutting down...');
+    collector.stop();
+    process.exit(0);
+  });
+
+  process.on('SIGINT', () => {
+    console.log('[daemon] Shutting down...');
+    collector.stop();
+    process.exit(0);
+  });
+}
+
+/**
+ * Get daemon status info
+ */
+export function getStatus() {
+  const pid = isRunning();
+  const config = load();
+
+  return {
+    running: !!pid,
+    pid: pid || null,
+    configured: !!(config.serverUrl && config.apiKey && config.userName),
+    config: {
+      serverUrl: config.serverUrl,
+      userName: config.userName,
+      apiKey: config.apiKey ? '***' : null,
+    },
+  };
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@moshi-labs/snitch",
+  "version": "1.0.0",
+  "description": "CLI daemon that reports Claude Code activity to a team server",
+  "type": "module",
+  "bin": {
+    "snitch": "./bin/snitch.js"
+  },
+  "files": [
+    "bin/",
+    "cli/",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node bin/snitch.js --help"
+  },
+  "dependencies": {
+    "chokidar": "^3.5.3",
+    "commander": "^12.1.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/moshi-labs/snitch.git"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "team",
+    "awareness"
+  ],
+  "author": "Moshi Labs",
+  "license": "MIT"
+}