@mnemonik/scanner 1.0.0 → 2.0.1

package/src/index.ts

@@ -1,74 +1,103 @@
 #!/usr/bin/env node
 
-import { readFile, unlink, mkdir } from 'fs/promises';
+import { readFile, writeFile, unlink, mkdir, stat, chmod } from 'fs/promises';
 import { join } from 'path';
 import { homedir } from 'os';
 import { ScannerDaemon } from './daemon.js';
 
 const DEFAULT_SERVER = 'https://api.mnemonik.dev';
 const MNEMONIK_DIR = join(homedir(), '.mnemonik');
-const DAEMONS_DIR = join(MNEMONIK_DIR, 'daemons');
-const LOGS_DIR = join(MNEMONIK_DIR, 'logs');
+const PID_FILE = join(MNEMONIK_DIR, 'daemon.pid');
+const LOG_FILE = join(MNEMONIK_DIR, 'scanner.log');
+const CONFIG_FILE = join(MNEMONIK_DIR, 'scanner.json');
 const MAX_LOG_SIZE = 5 * 1024 * 1024; // 5MB
 
-function parseCliArgs(): { server?: string; key?: string } {
+interface ScannerConfig {
+  roots: string[];
+  apiKey?: string;
+  server?: string;
+  refreshIntervalMs?: number;
+}
+
+interface CliArgs {
+  command: 'start' | 'stop' | 'status' | 'log' | 'help';
+  key?: string;
+  server?: string;
+  roots?: string[];
+}
+
+function parseCliArgs(): CliArgs {
   const args = process.argv.slice(2);
-  let server: string | undefined;
+  const command = (args[0] ?? 'help') as CliArgs['command'];
+
+  if (!['start', 'stop', 'status', 'log', 'help'].includes(command)) {
+    return { command: 'help' };
+  }
+
   let key: string | undefined;
+  let server: string | undefined;
+  let roots: string[] | undefined;
 
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === '--server' && args[i + 1]) server = args[++i]!;
-    else if (args[i] === '--key' && args[i + 1]) key = args[++i]!;
+  for (let i = 1; i < args.length; i++) {
+    if (args[i] === '--key' && args[i + 1]) key = args[++i]!;
+    else if (args[i] === '--server' && args[i + 1]) server = args[++i]!;
+    else if (args[i] === '--roots' && args[i + 1]) {
+      roots = args[++i]!.split(',').map((r) => r.trim());
+    }
   }
 
-  return { server, key };
+  return { command, key, server, roots };
 }
 
-async function readProjectId(): Promise<string> {
-  const configPath = join(process.cwd(), '.mnemonik.json');
+async function readConfig(): Promise<ScannerConfig | null> {
   try {
-    const raw = await readFile(configPath, 'utf-8');
-    const parsed = JSON.parse(raw) as Record<string, unknown>;
-    if (typeof parsed.projectId === 'string' && parsed.projectId.length > 0) {
-      return parsed.projectId;
-    }
-    console.error('[mnemonik] .mnemonik.json missing "projectId" field.');
-    process.exit(1);
+    const raw = await readFile(CONFIG_FILE, 'utf-8');
+    return JSON.parse(raw) as ScannerConfig;
   } catch {
-    console.error(
-      '[mnemonik] No .mnemonik.json found in current directory.\n' +
-        '  Run session_bootstrap from your IDE to create one.'
-    );
-    process.exit(1);
+    return null;
   }
 }
 
-function lockFile(projectId: string): string {
-  return join(DAEMONS_DIR, `${projectId}.pid`);
+async function writeConfig(config: ScannerConfig): Promise<void> {
+  await mkdir(MNEMONIK_DIR, { recursive: true });
+  await writeFile(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
 }
 
-function logFile(projectId: string): string {
-  return join(LOGS_DIR, `${projectId}.log`);
+async function checkConfigPermissions(): Promise<void> {
+  try {
+    const s = await stat(CONFIG_FILE);
+    // Check if group or other have read/write permissions
+    const mode = s.mode & 0o077;
+    if (mode !== 0) {
+      console.warn(
+        `[mnemonik] WARNING: ${CONFIG_FILE} has overly permissive permissions (${(s.mode & 0o777).toString(8)}).`
+      );
+      console.warn(`[mnemonik] Fixing to 0600 (owner read/write only).`);
+      await chmod(CONFIG_FILE, 0o600);
+    }
+  } catch {
+    // Config file doesn't exist yet
+  }
 }
 
-async function rotateLogIfNeeded(path: string): Promise<void> {
+async function rotateLogIfNeeded(): Promise<void> {
   try {
-    const { stat: fsStat, rename } = await import('fs/promises');
-    const s = await fsStat(path);
+    const { rename } = await import('fs/promises');
+    const s = await stat(LOG_FILE);
     if (s.size > MAX_LOG_SIZE) {
-      await rename(path, path + '.old');
+      await rename(LOG_FILE, LOG_FILE + '.old');
     }
   } catch {
     // Log file doesn't exist yet
   }
 }
 
-async function acquireLock(lockPath: string, retried = false): Promise<boolean> {
+async function acquireLock(retried = false): Promise<boolean> {
   try {
     const { open: fsOpen } = await import('fs/promises');
     const { constants } = await import('fs');
     const fd = await fsOpen(
-      lockPath,
+      PID_FILE,
       constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY,
       0o644
     );
@@ -78,7 +107,7 @@ async function acquireLock(lockPath: string, retried = false): Promise<boolean>
   } catch (err: unknown) {
     if ((err as NodeJS.ErrnoException).code !== 'EEXIST') return false;
 
-    const existing = await readFile(lockPath, 'utf-8').catch(() => null);
+    const existing = await readFile(PID_FILE, 'utf-8').catch(() => null);
     if (existing) {
       const pid = parseInt(existing.trim(), 10);
       try {
@@ -89,71 +118,257 @@ async function acquireLock(lockPath: string, retried = false): Promise<boolean>
       }
     }
     if (retried) return false;
-    await unlink(lockPath).catch(() => {});
-    return acquireLock(lockPath, true);
+    await unlink(PID_FILE).catch(() => {});
+    return acquireLock(true);
   }
 }
 
-async function releaseLock(lockPath: string): Promise<void> {
-  await unlink(lockPath).catch(() => {});
+async function releaseLock(): Promise<void> {
+  await unlink(PID_FILE).catch(() => {});
 }
 
-async function main(): Promise<void> {
-  const cli = parseCliArgs();
-  const projectId = await readProjectId();
-  const server = cli.server || DEFAULT_SERVER;
-  const apiKey = cli.key;
+async function readPid(): Promise<number | null> {
+  try {
+    const raw = await readFile(PID_FILE, 'utf-8');
+    const pid = parseInt(raw.trim(), 10);
+    if (isNaN(pid)) return null;
+    // Check if process is actually alive
+    try {
+      process.kill(pid, 0);
+      return pid;
+    } catch {
+      return null; // Stale PID
+    }
+  } catch {
+    return null;
+  }
+}
+
+function printHelp(): void {
+  console.log(`
+mnemonik-scanner - Automatic codebase indexing daemon
 
+Usage:
+  mnemonik-scanner start [options]    Start the scanner daemon
+  mnemonik-scanner stop               Stop the running daemon
+  mnemonik-scanner status             Show daemon status
+  mnemonik-scanner log                Tail the scanner log file
+  mnemonik-scanner help               Show this help
+
+Options (for start):
+  --key <api-key>       API key (or set MNEMONIK_API_KEY env var)
+  --server <url>        Server URL (default: https://api.mnemonik.dev)
+  --roots <dirs>        Comma-separated directories to scan for projects
+
+Examples:
+  mnemonik-scanner start --key mnk_... --roots ~/Projects,~/work
+  mnemonik-scanner status
+  mnemonik-scanner stop
+
+Configuration is saved to ~/.mnemonik/scanner.json after first run.
+Subsequent starts use saved config (CLI args override).
+
+Environment variables:
+  MNEMONIK_API_KEY      API key (takes precedence over config file)
+`);
+}
+
+async function handleStart(cli: CliArgs): Promise<void> {
+  const config = await readConfig();
+
+  // Resolve API key: env var > CLI > config
+  const apiKey = process.env.MNEMONIK_API_KEY || cli.key || config?.apiKey;
   if (!apiKey) {
     console.error(
       '[mnemonik] Missing API key.\n' +
-        '  Usage: mnemonik-scanner --key <api-key>\n' +
-        '  The API key is provided by _scannerSetup in session_bootstrap.'
+        '  Use --key <api-key>, set MNEMONIK_API_KEY env var,\n' +
+        '  or run once with --key to save to config.'
+    );
+    process.exit(1);
+  }
+
+  const roots = cli.roots || config?.roots;
+  if (!roots || roots.length === 0) {
+    console.error(
+      '[mnemonik] No roots specified.\n' +
+        '  Use --roots ~/Projects,~/work to specify directories to scan.'
     );
     process.exit(1);
   }
 
+  const server = cli.server || config?.server || DEFAULT_SERVER;
+
   // Ensure directories exist
-  await mkdir(DAEMONS_DIR, { recursive: true });
-  await mkdir(LOGS_DIR, { recursive: true });
+  await mkdir(MNEMONIK_DIR, { recursive: true });
 
-  const lock = lockFile(projectId);
-  const log = logFile(projectId);
+  // Save config for future runs (never save env var key to file)
+  const configToSave: ScannerConfig = {
+    roots,
+    server,
+    refreshIntervalMs: config?.refreshIntervalMs,
+  };
+  // Only save API key to config if it came from CLI (not env var)
+  if (cli.key) {
+    configToSave.apiKey = cli.key;
+  } else if (config?.apiKey && !process.env.MNEMONIK_API_KEY) {
+    configToSave.apiKey = config.apiKey;
+  }
+  await writeConfig(configToSave);
+  await checkConfigPermissions();
 
-  await rotateLogIfNeeded(log);
+  await rotateLogIfNeeded();
 
-  const locked = await acquireLock(lock);
+  const locked = await acquireLock();
   if (!locked) {
-    console.log(`[mnemonik] Scanner already running for project ${projectId}. Exiting.`);
+    const pid = await readPid();
+    console.log(
+      `[mnemonik] Scanner daemon already running (PID ${pid}). Use 'mnemonik-scanner stop' first.`
+    );
     process.exit(0);
   }
 
-  const projectRoot = process.cwd();
   const daemon = new ScannerDaemon({
-    projectId,
-    projectRoot,
     serverUrl: server,
     apiKey,
+    roots,
+    refreshIntervalMs: config?.refreshIntervalMs,
   });
 
   const shutdown = async () => {
     console.log('\n[mnemonik] Shutting down...');
     await daemon.stop();
-    await releaseLock(lock);
+    await releaseLock();
     process.exit(0);
   };
 
   process.on('SIGINT', shutdown);
   process.on('SIGTERM', shutdown);
+  process.on('SIGHUP', shutdown); // Graceful restart — external tooling sends SIGHUP then relaunches
 
   try {
     await daemon.start();
-    console.log('[mnemonik] Watching for changes.');
   } catch (err) {
     console.error(`[mnemonik] ${(err as Error).message}`);
-    await releaseLock(lock);
+    await releaseLock();
     process.exit(1);
   }
 }
 
+async function handleStop(): Promise<void> {
+  const pid = await readPid();
+  if (!pid) {
+    console.log('[mnemonik] Scanner daemon is not running.');
+    // Clean up stale PID file if it exists
+    await unlink(PID_FILE).catch(() => {});
+    return;
+  }
+
+  try {
+    process.kill(pid, 'SIGTERM');
+    console.log(`[mnemonik] Sent SIGTERM to daemon (PID ${pid}).`);
+
+    // Wait for process to exit (up to 5 seconds)
+    for (let i = 0; i < 50; i++) {
+      await new Promise((r) => setTimeout(r, 100));
+      try {
+        process.kill(pid, 0);
+      } catch {
+        console.log('[mnemonik] Daemon stopped.');
+        return;
+      }
+    }
+    console.warn('[mnemonik] Daemon did not exit within 5 seconds.');
+  } catch {
+    console.log('[mnemonik] Daemon process not found. Cleaning up PID file.');
+    await unlink(PID_FILE).catch(() => {});
+  }
+}
+
+async function handleStatus(): Promise<void> {
+  const pid = await readPid();
+  const config = await readConfig();
+
+  if (!pid) {
+    console.log('Status: not running');
+    if (config?.roots) {
+      console.log(`Configured roots: ${config.roots.join(', ')}`);
+    }
+    console.log(`\nStart with: mnemonik-scanner start`);
+    return;
+  }
+
+  console.log(`Status: running (PID ${pid})`);
+  if (config?.roots) {
+    console.log(`Roots: ${config.roots.join(', ')}`);
+  }
+  if (config?.server) {
+    console.log(`Server: ${config.server}`);
+  }
+
+  // Check for old per-project daemons
+  try {
+    const { readdir: readdirAsync } = await import('fs/promises');
+    const oldDaemonsDir = join(MNEMONIK_DIR, 'daemons');
+    const oldPidFiles = await readdirAsync(oldDaemonsDir).catch(() => []);
+    const staleOldDaemons: string[] = [];
+    for (const f of oldPidFiles) {
+      if (!f.endsWith('.pid')) continue;
+      const content = await readFile(join(oldDaemonsDir, f), 'utf-8').catch(() => null);
+      if (content) {
+        const oldPid = parseInt(content.trim(), 10);
+        try {
+          process.kill(oldPid, 0);
+          staleOldDaemons.push(`${f} (PID ${oldPid})`);
+        } catch {
+          // Dead process, just a stale file
+        }
+      }
+    }
+    if (staleOldDaemons.length > 0) {
+      console.log(`\nLegacy per-project daemons still running:`);
+      for (const d of staleOldDaemons) {
+        console.log(`  ${d}`);
+      }
+      console.log('  Consider stopping these — the global daemon handles all projects.');
+    }
+  } catch {
+    // Old daemons dir doesn't exist
+  }
+}
+
+async function handleLog(): Promise<void> {
+  try {
+    const content = await readFile(LOG_FILE, 'utf-8');
+    // Show last 50 lines
+    const lines = content.split('\n');
+    const tail = lines.slice(-50).join('\n');
+    console.log(tail);
+  } catch {
+    console.log('[mnemonik] No log file found at', LOG_FILE);
+  }
+}
+
+async function main(): Promise<void> {
+  const cli = parseCliArgs();
+
+  switch (cli.command) {
+    case 'start':
+      await handleStart(cli);
+      break;
+    case 'stop':
+      await handleStop();
+      break;
+    case 'status':
+      await handleStatus();
+      break;
+    case 'log':
+      await handleLog();
+      break;
+    case 'help':
+    default:
+      printHelp();
+      break;
+  }
+}
+
 main();

package/src/watcher.ts

@@ -1,6 +1,6 @@
 import { watch, type FSWatcher } from 'fs';
 import { join, relative } from 'path';
-import { readdir, stat } from 'fs/promises';
+import { readdir } from 'fs/promises';
 
 const SKIP_DIRS = new Set([
   'node_modules',
@@ -23,19 +23,23 @@ const SKIP_DIRS = new Set([
 ]);
 
 export type ChangeHandler = (changedFiles: string[]) => void;
+export type ErrorHandler = (err: Error) => void;
 
 export class FileWatcher {
   private watchers: FSWatcher[] = [];
   private pendingFiles = new Set<string>();
   private flushTimer: ReturnType<typeof setTimeout> | null = null;
   private debounceMs: number;
+  private onError: ErrorHandler | undefined;
 
   constructor(
     private rootPath: string,
     private onChange: ChangeHandler,
-    debounceMs = 500
+    debounceMs = 500,
+    onError?: ErrorHandler
   ) {
     this.debounceMs = debounceMs;
+    this.onError = onError;
   }
 
   async start(): Promise<void> {
@@ -79,6 +83,13 @@ export class FileWatcher {
         this.scheduleFlush();
       });
 
+      watcher.on('error', (err) => {
+        console.warn(`[scanner] Watcher error for ${dir}:`, err.message);
+        if (dir === this.rootPath && this.onError) {
+          this.onError(err);
+        }
+      });
+
       this.watchers.push(watcher);
 
       const entries = await readdir(dir, { withFileTypes: true });