marmot-logger 1.0.0

package/src/cli/logs.js

@@ -0,0 +1,93 @@
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const config = require('../core/config');
+const logger = require('../core/logger');
+
+module.exports = async function logs(options) {
+  const projectConfig = config.loadConfig();
+
+  if (!projectConfig) {
+    console.log(chalk.red('Marmot not initialized. Run: marmot init'));
+    process.exit(1);
+  }
+
+  let logFile;
+
+  if (options.today) {
+    logFile = config.getLogFile(projectConfig);
+  } else {
+    // Find the most recent log file
+    const logDir = config.getLogDir(projectConfig);
+    if (!fs.existsSync(logDir)) {
+      console.log(chalk.yellow('No logs found.'));
+      return;
+    }
+
+    const files = fs.readdirSync(logDir)
+      .filter(f => f.startsWith('file_events_') && f.endsWith('.log'))
+      .sort()
+      .reverse();
+
+    if (files.length === 0) {
+      console.log(chalk.yellow('No logs found.'));
+      return;
+    }
+
+    logFile = path.join(logDir, files[0]);
+  }
+
+  if (!fs.existsSync(logFile)) {
+    console.log(chalk.yellow('No logs found.'));
+    return;
+  }
+
+  const last = parseInt(options.last) || 10;
+  const entries = logger.readLogs(logFile, { last });
+
+  console.log(`Showing last ${entries.length} entries from: ${chalk.cyan(logFile)}`);
+  console.log('');
+
+  for (const entry of entries) {
+    const time = entry.timestamp ? entry.timestamp.split('T')[1].replace('Z', '') : '??:??:??';
+    const event = entry.event || 'unknown';
+    const eventPath = entry.path || '';
+
+    let signedStatus = '';
+    if (entry.signed === true) {
+      signedStatus = chalk.green(' ✓');
+    } else if (entry.signed === false) {
+      signedStatus = chalk.red(' ✗');
+    }
+
+    // Color code by event type
+    let eventColor = chalk.white;
+    if (event.startsWith('claude_hook_')) {
+      eventColor = chalk.magenta;
+    } else if (event.startsWith('git_')) {
+      eventColor = chalk.blue;
+    } else if (event === 'terminal') {
+      eventColor = chalk.yellow;
+    } else if (event === 'created') {
+      eventColor = chalk.green;
+    } else if (event === 'deleted') {
+      eventColor = chalk.red;
+    } else if (event === 'modified') {
+      eventColor = chalk.cyan;
+    } else if (event === 'make_command') {
+      eventColor = chalk.gray;
+    }
+
+    let details = eventPath;
+    if (entry.command) {
+      details = entry.command;
+    }
+    if (entry.additions !== undefined && entry.deletions !== undefined) {
+      details += ` (+${entry.additions}/-${entry.deletions})`;
+    }
+
+    console.log(`${chalk.gray(time)} ${eventColor(event.padEnd(25))} ${details}${signedStatus}`);
+  }
+
+  console.log('');
+};

package/src/cli/monitor.js

@@ -0,0 +1,32 @@
+const chalk = require('chalk');
+const config = require('../core/config');
+const fileMonitor = require('../plugins/file-monitor');
+
+module.exports = async function monitor() {
+  const projectConfig = config.loadConfig();
+
+  if (!projectConfig) {
+    console.log(chalk.red('Marmot not initialized. Run: marmot init'));
+    process.exit(1);
+  }
+
+  if (!config.isPluginEnabled(projectConfig, 'file-monitor')) {
+    console.log(chalk.yellow('File monitor plugin is not enabled.'));
+    console.log('Run:', chalk.cyan('marmot enable file-monitor'));
+    process.exit(1);
+  }
+
+  try {
+    const changes = await fileMonitor.run(projectConfig);
+
+    if (changes === 0) {
+      // No changes, silent exit for cron usage
+      process.exit(0);
+    }
+
+    console.log(chalk.green(`✓ Detected ${changes} change(s)`));
+  } catch (err) {
+    console.error(chalk.red(`Monitor error: ${err.message}`));
+    process.exit(1);
+  }
+};

package/src/cli/status.js

@@ -0,0 +1,72 @@
+const chalk = require('chalk');
+const fs = require('fs');
+const config = require('../core/config');
+const signer = require('../core/signer');
+
+module.exports = async function status() {
+  const projectDir = process.cwd();
+  const projectConfig = config.loadConfig(projectDir);
+
+  if (!projectConfig) {
+    console.log(chalk.red('Marmot not initialized.'));
+    console.log('Run:', chalk.cyan('marmot init'));
+    return;
+  }
+
+  console.log(chalk.bold('Marmot Status'));
+  console.log('─'.repeat(40));
+
+  // Configuration
+  console.log('');
+  console.log(chalk.bold('Configuration:'));
+  console.log(`  Marmot dir:    ${chalk.cyan(config.getMarmotDir(projectDir))}`);
+  console.log(`  Config file:   ${chalk.cyan(config.getConfigPath(projectDir))}`);
+  console.log(`  Snapshot dir:  ${chalk.cyan(config.getSnapshotDir(projectConfig, projectDir))}`);
+  console.log(`  Log directory: ${chalk.cyan(config.getLogDir(projectConfig, projectDir))}`);
+  console.log(`  Signing URL:   ${chalk.cyan(config.getSigningUrl(projectDir))}`);
+
+  // API Key status
+  const apiKey = config.getApiKey(projectDir);
+  if (apiKey) {
+    console.log(`  API Key:       ${chalk.green('✓ Set')} (from .env or environment)`);
+  } else {
+    console.log(`  API Key:       ${chalk.red('✗ Not set')} (run: marmot login)`);
+  }
+
+  // Signing service health
+  console.log('');
+  console.log(chalk.bold('Signing Service:'));
+  try {
+    await signer.healthCheck();
+    console.log(`  Status:        ${chalk.green('✓ Healthy')}`);
+  } catch (err) {
+    console.log(`  Status:        ${chalk.red('✗ Unreachable')} - ${err.message}`);
+  }
+
+  // Plugins
+  console.log('');
+  console.log(chalk.bold('Plugins:'));
+  const plugins = ['file-monitor', 'terminal', 'git-hooks', 'makefile', 'claude-hooks'];
+
+  for (const plugin of plugins) {
+    const enabled = config.isPluginEnabled(projectConfig, plugin);
+    const statusIcon = enabled ? chalk.green('✓ enabled') : chalk.gray('○ disabled');
+    console.log(`  ${plugin.padEnd(15)} ${statusIcon}`);
+  }
+
+  // Recent logs
+  console.log('');
+  console.log(chalk.bold('Recent Activity:'));
+  const logFile = config.getLogFile(projectConfig, projectDir);
+  if (fs.existsSync(logFile)) {
+    const stats = fs.statSync(logFile);
+    const lines = fs.readFileSync(logFile, 'utf8').trim().split('\n').length;
+    console.log(`  Today's log:   ${chalk.cyan(logFile)}`);
+    console.log(`  Entries:       ${lines}`);
+    console.log(`  Size:          ${(stats.size / 1024).toFixed(1)} KB`);
+  } else {
+    console.log(`  ${chalk.gray('No logs yet today')}`);
+  }
+
+  console.log('');
+};

package/src/cli/verify.js

@@ -0,0 +1,81 @@
+const chalk = require('chalk');
+const fs = require('fs');
+const config = require('../core/config');
+const logger = require('../core/logger');
+
+module.exports = async function verify(options) {
+  const projectConfig = config.loadConfig();
+
+  if (!projectConfig) {
+    console.log(chalk.red('Marmot not initialized. Run: marmot init'));
+    process.exit(1);
+  }
+
+  const logFile = options.file || config.getLogFile(projectConfig);
+
+  if (!fs.existsSync(logFile)) {
+    console.log(chalk.red(`Log file not found: ${logFile}`));
+    process.exit(1);
+  }
+
+  console.log(`Verifying: ${chalk.cyan(logFile)}`);
+  console.log('');
+
+  try {
+    const results = await logger.verifyLogs(logFile);
+
+    let valid = 0;
+    let invalid = 0;
+    let unsigned = 0;
+
+    for (const result of results) {
+      if (result.verified === true) {
+        valid++;
+      } else if (result.verified === false) {
+        invalid++;
+      } else {
+        unsigned++;
+      }
+    }
+
+    console.log(chalk.bold('Results:'));
+    console.log(`  ${chalk.green('✓ Valid:')}    ${valid}`);
+    console.log(`  ${chalk.red('✗ Invalid:')}  ${invalid}`);
+    console.log(`  ${chalk.gray('○ Unsigned:')} ${unsigned}`);
+    console.log(`  Total:       ${results.length}`);
+
+    if (invalid > 0) {
+      console.log('');
+      console.log(chalk.yellow('Invalid entries:'));
+      for (const result of results) {
+        if (result.verified === false) {
+          console.log(`  - ${result.entry.timestamp} ${result.entry.event}: ${result.reason}`);
+        }
+      }
+    }
+
+    // Update log file with verification results
+    if (invalid > 0) {
+      console.log('');
+      console.log('Updating log file with verification status...');
+
+      const entries = logger.readLogs(logFile);
+      const updatedEntries = entries.map((entry, i) => {
+        const result = results[i];
+        if (result.verified === true) {
+          return { ...entry, signed: true };
+        } else if (result.verified === false) {
+          return { ...entry, signed: false };
+        }
+        return entry;
+      });
+
+      fs.writeFileSync(logFile, updatedEntries.map(e => JSON.stringify(e)).join('\n') + '\n');
+      console.log(chalk.green('✓ Log file updated.'));
+    }
+
+  } catch (err) {
+    console.log(chalk.red(`Verification failed: ${err.message}`));
+    process.exit(1);
+  }
+};

package/src/core/config.js

@@ -0,0 +1,190 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const CONFIG_FILE = '.marmotrc.json';
+const MARMOT_TMP_BASE = '/tmp/marmot';
+
+const DEFAULT_CONFIG = {
+  logDir: './marmot-logs',
+  bearerToken: 'broken-bearer',
+  plugins: {
+    'file-monitor': {
+      enabled: false
+    },
+    'terminal': {
+      enabled: false
+    },
+    'git-hooks': {
+      enabled: false,
+      events: ['commit', 'push', 'checkout', 'merge']
+    },
+    'makefile': {
+      enabled: false
+    },
+    'claude-hooks': {
+      enabled: false,
+      events: ['PreToolUse', 'PostToolUse', 'Stop', 'SubagentStop', 'UserPromptSubmit', 'SessionStart', 'SessionEnd']
+    }
+  }
+};
+
+function getProjectHash(projectDir) {
+  return crypto.createHash('md5').update(path.resolve(projectDir)).digest('hex');
+}
+
+function getMarmotDir(projectDir = process.cwd()) {
+  const hash = getProjectHash(projectDir);
+  return path.join(MARMOT_TMP_BASE, hash);
+}
+
+function getConfigPath(projectDir = process.cwd()) {
+  return path.join(getMarmotDir(projectDir), CONFIG_FILE);
+}
+
+function loadConfig(projectDir = process.cwd()) {
+  const configPath = getConfigPath(projectDir);
+
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+
+  try {
+    const content = fs.readFileSync(configPath, 'utf8');
+    return JSON.parse(content);
+  } catch (err) {
+    throw new Error(`Failed to parse ${CONFIG_FILE}: ${err.message}`);
+  }
+}
+
+function saveConfig(config, projectDir = process.cwd()) {
+  const configPath = getConfigPath(projectDir);
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+}
+
+function createDefaultConfig(projectDir = process.cwd()) {
+  const config = { ...DEFAULT_CONFIG };
+  saveConfig(config, projectDir);
+  return config;
+}
+
+function loadEnvFile(projectDir = process.cwd()) {
+  const envPath = path.join(projectDir, '.env');
+  const env = {};
+
+  if (fs.existsSync(envPath)) {
+    try {
+      const content = fs.readFileSync(envPath, 'utf8');
+      for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        // Skip comments and empty lines
+        if (!trimmed || trimmed.startsWith('#')) continue;
+        const match = trimmed.match(/^([^=]+)=(.*)$/);
+        if (match) {
+          const key = match[1].trim();
+          let value = match[2].trim();
+          // Remove quotes if present
+          if ((value.startsWith('"') && value.endsWith('"')) ||
+              (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+          }
+          env[key] = value;
+        }
+      }
+    } catch (e) {
+      // Ignore .env read errors
+    }
+  }
+
+  return env;
+}
+
+function getSigningUrl(projectDir = process.cwd()) {
+  // Priority: env var > .env file > default
+  if (process.env.MARMOT_URL) {
+    return process.env.MARMOT_URL;
+  }
+  const envFile = loadEnvFile(projectDir);
+  return envFile.MARMOT_URL || 'https://logging.drazou.net';
+}
+
+function getApiKey(projectDir = process.cwd()) {
+  // Priority: env var > .env file
+  if (process.env.MARMOT_API_KEY) {
+    return process.env.MARMOT_API_KEY;
+  }
+  const envFile = loadEnvFile(projectDir);
+  return envFile.MARMOT_API_KEY;
+}
+
+function getLogDir(config, projectDir = process.cwd()) {
+  return path.resolve(projectDir, config.logDir || './logs');
+}
+
+function getSnapshotDir(config, projectDir = process.cwd()) {
+  return path.join(getMarmotDir(projectDir), 'snapshot');
+}
+
+function getLogFile(config, projectDir = process.cwd()) {
+  const logDir = getLogDir(config, projectDir);
+  const date = new Date().toISOString().split('T')[0];
+  return path.join(logDir, `file_events_${date}.log`);
+}
+
+function isPluginEnabled(config, pluginName) {
+  return config.plugins?.[pluginName]?.enabled || false;
+}
+
+function enablePlugin(config, pluginName) {
+  if (!config.plugins) {
+    config.plugins = {};
+  }
+  if (!config.plugins[pluginName]) {
+    config.plugins[pluginName] = { ...DEFAULT_CONFIG.plugins[pluginName] };
+  }
+  config.plugins[pluginName].enabled = true;
+  return config;
+}
+
+function disablePlugin(config, pluginName) {
+  if (config.plugins?.[pluginName]) {
+    config.plugins[pluginName].enabled = false;
+  }
+  return config;
+}
+
+function getBearerToken(projectDir = process.cwd()) {
+  const projectConfig = loadConfig(projectDir);
+  return projectConfig?.bearerToken || 'broken-bearer';
+}
+
+function setBearerToken(token, projectDir = process.cwd()) {
+  const projectConfig = loadConfig(projectDir);
+  if (projectConfig) {
+    projectConfig.bearerToken = token;
+    saveConfig(projectConfig, projectDir);
+  }
+}
+
+module.exports = {
+  CONFIG_FILE,
+  DEFAULT_CONFIG,
+  MARMOT_TMP_BASE,
+  getProjectHash,
+  getMarmotDir,
+  loadConfig,
+  saveConfig,
+  createDefaultConfig,
+  getConfigPath,
+  getSigningUrl,
+  getApiKey,
+  loadEnvFile,
+  getLogDir,
+  getSnapshotDir,
+  getLogFile,
+  isPluginEnabled,
+  enablePlugin,
+  disablePlugin,
+  getBearerToken,
+  setBearerToken
+};

package/src/core/gitignore.js

@@ -0,0 +1,109 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Parse .gitignore file and return patterns
+ * Skips comments, empty lines, and negation patterns (!)
+ */
+function parseGitignore(projectDir) {
+  const gitignorePath = path.join(projectDir, '.gitignore');
+
+  if (!fs.existsSync(gitignorePath)) {
+    return [];
+  }
+
+  try {
+    const content = fs.readFileSync(gitignorePath, 'utf8');
+    return content
+      .split('\n')
+      .map(line => line.trim())
+      .filter(line => line && !line.startsWith('#') && !line.startsWith('!'));
+  } catch (err) {
+    return [];
+  }
+}
+
+/**
+ * Get default exclusions (always exclude regardless of .gitignore)
+ */
+function getDefaultExclusions() {
+  return [
+    '.git',
+    'logs/'
+  ];
+}
+
+/**
+ * Build rsync exclude arguments from .gitignore + defaults
+ */
+function buildRsyncExcludes(projectDir) {
+  const defaults = getDefaultExclusions();
+  const gitignorePatterns = parseGitignore(projectDir);
+
+  // Combine: defaults first, then gitignore patterns
+  const allPatterns = [...defaults, ...gitignorePatterns];
+
+  return allPatterns.map(pattern => `--exclude=${pattern}`);
+}
+
+/**
+ * Check if a file path should be excluded based on gitignore patterns
+ * Used for filtering git diff output
+ */
+function shouldExclude(filePath, projectDir) {
+  const defaults = getDefaultExclusions();
+  const gitignorePatterns = parseGitignore(projectDir);
+  const allPatterns = [...defaults, ...gitignorePatterns];
+
+  // Normalize path separators
+  const normalizedPath = filePath.replace(/\\/g, '/');
+
+  for (const pattern of allPatterns) {
+    if (matchPattern(normalizedPath, pattern)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Simple pattern matching for gitignore-style patterns
+ * Supports: wildcards (*), directory markers (/), character classes ([])
+ */
+function matchPattern(filePath, pattern) {
+  // Handle trailing slash (directory pattern)
+  const isDir = pattern.endsWith('/');
+  let cleanPattern = isDir ? pattern.slice(0, -1) : pattern;
+
+  // Check if pattern has path separators (anchored pattern)
+  const isAnchored = cleanPattern.includes('/');
+
+  // Convert gitignore pattern to regex
+  let regex = cleanPattern
+    .replace(/[.+^${}()|[\]\\]/g, '\\$&')  // Escape regex special chars except * and ?
+    .replace(/\*\*/g, '<<<GLOBSTAR>>>')     // Preserve **
+    .replace(/\*/g, '[^/]*')                // * matches anything except /
+    .replace(/<<<GLOBSTAR>>>/g, '.*')       // ** matches anything including /
+    .replace(/\?/g, '[^/]');                // ? matches single char except /
+
+  // Patterns without / match anywhere in path
+  if (!isAnchored) {
+    regex = `(^|/)${regex}($|/)`;
+  } else {
+    regex = `^${regex}`;
+  }
+
+  try {
+    return new RegExp(regex).test(filePath);
+  } catch (e) {
+    return false;
+  }
+}
+
+module.exports = {
+  parseGitignore,
+  getDefaultExclusions,
+  buildRsyncExcludes,
+  shouldExclude,
+  matchPattern
+};

package/src/core/logger.js

@@ -0,0 +1,120 @@
+const fs = require('fs');
+const path = require('path');
+const config = require('./config');
+const signer = require('./signer');
+
+async function log(entry, projectConfig, projectDir = process.cwd()) {
+  const logFile = config.getLogFile(projectConfig, projectDir);
+  const logDir = path.dirname(logFile);
+
+  // Ensure log directory exists
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true });
+  }
+
+  let signedEntry;
+
+  try {
+    // Try to sign the entry with cached token
+    signedEntry = await signer.sign(entry, projectDir);
+  } catch (err) {
+    // If unauthorized, refresh token and retry once
+    if (err.statusCode === 401) {
+      try {
+        await signer.refreshToken(projectDir);
+        signedEntry = await signer.sign(entry, projectDir);
+      } catch (retryErr) {
+        // Second attempt failed, fall back to unsigned
+        const timestamp = new Date().toISOString().replace(/\.\d{3}Z$/, 'Z');
+        signedEntry = {
+          timestamp,
+          ...entry,
+          signed: false
+        };
+      }
+    } else {
+      // Other error, fall back to unsigned
+      const timestamp = new Date().toISOString().replace(/\.\d{3}Z$/, 'Z');
+      signedEntry = {
+        timestamp,
+        ...entry,
+        signed: false
+      };
+    }
+  }
+
+  // Append to log file
+  fs.appendFileSync(logFile, JSON.stringify(signedEntry) + '\n');
+
+  return signedEntry;
+}
+
+async function logEvent(eventType, eventPath, size = 0, extra = {}, projectDir = process.cwd()) {
+  const projectConfig = config.loadConfig(projectDir);
+  if (!projectConfig) {
+    throw new Error('Marmot not initialized. Run: marmot init');
+  }
+
+  const entry = {
+    event: eventType,
+    path: eventPath,
+    size,
+    ...extra
+  };
+
+  return log(entry, projectConfig, projectDir);
+}
+
+function readLogs(logFile, options = {}) {
+  if (!fs.existsSync(logFile)) {
+    return [];
+  }
+
+  const content = fs.readFileSync(logFile, 'utf8');
+  const lines = content.trim().split('\n').filter(line => line.trim());
+
+  let entries = lines.map(line => {
+    try {
+      return JSON.parse(line);
+    } catch (e) {
+      return null;
+    }
+  }).filter(e => e !== null);
+
+  if (options.last) {
+    entries = entries.slice(-options.last);
+  }
+
+  return entries;
+}
+
+async function verifyLogs(logFile, projectDir = process.cwd()) {
+  const entries = readLogs(logFile);
+  const results = [];
+
+  for (const entry of entries) {
+    if (!entry.uuid) {
+      // Entry without UUID cannot be verified
+      results.push({ entry, verified: null, reason: 'no uuid' });
+      continue;
+    }
+
+    try {
+      // Create entry with signed:true for verification
+      const verifyEntry = { ...entry, signed: true };
+      const result = await signer.verify(verifyEntry, projectDir);
+      results.push({ entry, verified: result.valid, reason: result.reason });
+    } catch (err) {
+      results.push({ entry, verified: false, reason: err.message });
+    }
+  }
+
+  return results;
+}
+
+module.exports = {
+  log,
+  logEvent,
+  readLogs,
+  verifyLogs
+};