@rozek/nanoclaw 1.2.17

package/setup/groups.ts

@@ -0,0 +1,229 @@
+/**
+ * Step: groups — Fetch group metadata from messaging platforms, write to DB.
+ * WhatsApp requires an upfront sync (Baileys groupFetchAllParticipating).
+ * Other channels discover group names at runtime — this step auto-skips for them.
+ * Replaces 05-sync-groups.sh + 05b-list-groups.sh
+ */
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+
+import Database from 'better-sqlite3';
+
+import { STORE_DIR } from '../src/config.js';
+import { logger } from '../src/logger.js';
+import { emitStatus } from './status.js';
+
+function parseArgs(args: string[]): { list: boolean; limit: number } {
+  let list = false;
+  let limit = 30;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--list') list = true;
+    if (args[i] === '--limit' && args[i + 1]) {
+      limit = parseInt(args[i + 1], 10);
+      i++;
+    }
+  }
+  return { list, limit };
+}
+
+export async function run(args: string[]): Promise<void> {
+  const projectRoot = process.cwd();
+  const { list, limit } = parseArgs(args);
+
+  if (list) {
+    await listGroups(limit);
+    return;
+  }
+
+  await syncGroups(projectRoot);
+}
+
+async function listGroups(limit: number): Promise<void> {
+  const dbPath = path.join(STORE_DIR, 'messages.db');
+
+  if (!fs.existsSync(dbPath)) {
+    console.error('ERROR: database not found');
+    process.exit(1);
+  }
+
+  const db = new Database(dbPath, { readonly: true });
+  const rows = db
+    .prepare(
+      `SELECT jid, name FROM chats
+     WHERE jid LIKE '%@g.us' AND jid <> '__group_sync__' AND name <> jid
+     ORDER BY last_message_time DESC
+     LIMIT ?`,
+    )
+    .all(limit) as Array<{ jid: string; name: string }>;
+  db.close();
+
+  for (const row of rows) {
+    console.log(`${row.jid}|${row.name}`);
+  }
+}
+
+async function syncGroups(projectRoot: string): Promise<void> {
+  // Only WhatsApp needs an upfront group sync; other channels resolve names at runtime.
+  // Detect WhatsApp by checking for auth credentials on disk.
+  const authDir = path.join(projectRoot, 'store', 'auth');
+  const hasWhatsAppAuth =
+    fs.existsSync(authDir) && fs.readdirSync(authDir).length > 0;
+
+  if (!hasWhatsAppAuth) {
+    logger.info('WhatsApp auth not found — skipping group sync');
+    emitStatus('SYNC_GROUPS', {
+      BUILD: 'skipped',
+      SYNC: 'skipped',
+      GROUPS_IN_DB: 0,
+      REASON: 'whatsapp_not_configured',
+      STATUS: 'success',
+      LOG: 'logs/setup.log',
+    });
+    return;
+  }
+
+  // Build TypeScript first
+  logger.info('Building TypeScript');
+  let buildOk = false;
+  try {
+    execSync('npm run build', {
+      cwd: projectRoot,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    buildOk = true;
+    logger.info('Build succeeded');
+  } catch {
+    logger.error('Build failed');
+    emitStatus('SYNC_GROUPS', {
+      BUILD: 'failed',
+      SYNC: 'skipped',
+      GROUPS_IN_DB: 0,
+      STATUS: 'failed',
+      ERROR: 'build_failed',
+      LOG: 'logs/setup.log',
+    });
+    process.exit(1);
+  }
+
+  // Run sync script via a temp file to avoid shell escaping issues with node -e
+  logger.info('Fetching group metadata');
+  let syncOk = false;
+  try {
+    const syncScript = `
+import makeWASocket, { useMultiFileAuthState, makeCacheableSignalKeyStore, Browsers } from '@whiskeysockets/baileys';
+import pino from 'pino';
+import path from 'path';
+import fs from 'fs';
+import Database from 'better-sqlite3';
+
+const logger = pino({ level: 'silent' });
+const authDir = path.join('store', 'auth');
+const dbPath = path.join('store', 'messages.db');
+
+if (!fs.existsSync(authDir)) {
+  console.error('NO_AUTH');
+  process.exit(1);
+}
+
+const db = new Database(dbPath);
+db.pragma('journal_mode = WAL');
+db.exec('CREATE TABLE IF NOT EXISTS chats (jid TEXT PRIMARY KEY, name TEXT, last_message_time TEXT)');
+
+const upsert = db.prepare(
+  'INSERT INTO chats (jid, name, last_message_time) VALUES (?, ?, ?) ON CONFLICT(jid) DO UPDATE SET name = excluded.name'
+);
+
+const { state, saveCreds } = await useMultiFileAuthState(authDir);
+
+const sock = makeWASocket({
+  auth: { creds: state.creds, keys: makeCacheableSignalKeyStore(state.keys, logger) },
+  printQRInTerminal: false,
+  logger,
+  browser: Browsers.macOS('Chrome'),
+});
+
+const timeout = setTimeout(() => {
+  console.error('TIMEOUT');
+  process.exit(1);
+}, 30000);
+
+sock.ev.on('creds.update', saveCreds);
+
+sock.ev.on('connection.update', async (update) => {
+  if (update.connection === 'open') {
+    try {
+      const groups = await sock.groupFetchAllParticipating();
+      const now = new Date().toISOString();
+      let count = 0;
+      for (const [jid, metadata] of Object.entries(groups)) {
+        if (metadata.subject) {
+          upsert.run(jid, metadata.subject, now);
+          count++;
+        }
+      }
+      console.log('SYNCED:' + count);
+    } catch (err) {
+      console.error('FETCH_ERROR:' + err.message);
+    } finally {
+      clearTimeout(timeout);
+      sock.end(undefined);
+      db.close();
+      process.exit(0);
+    }
+  } else if (update.connection === 'close') {
+    clearTimeout(timeout);
+    console.error('CONNECTION_CLOSED');
+    process.exit(1);
+  }
+});
+`;
+
+    const tmpScript = path.join(projectRoot, '.tmp-group-sync.mjs');
+    fs.writeFileSync(tmpScript, syncScript, 'utf-8');
+    try {
+      const output = execSync(`node ${tmpScript}`, {
+        cwd: projectRoot,
+        encoding: 'utf-8',
+        timeout: 45000,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+      syncOk = output.includes('SYNCED:');
+      logger.info({ output: output.trim() }, 'Sync output');
+    } finally {
+      try { fs.unlinkSync(tmpScript); } catch { /* ignore cleanup errors */ }
+    }
+  } catch (err) {
+    logger.error({ err }, 'Sync failed');
+  }
+
+  // Count groups in DB using better-sqlite3 (no sqlite3 CLI)
+  let groupsInDb = 0;
+  const dbPath = path.join(STORE_DIR, 'messages.db');
+  if (fs.existsSync(dbPath)) {
+    try {
+      const db = new Database(dbPath, { readonly: true });
+      const row = db
+        .prepare(
+          "SELECT COUNT(*) as count FROM chats WHERE jid LIKE '%@g.us' AND jid <> '__group_sync__'",
+        )
+        .get() as { count: number };
+      groupsInDb = row.count;
+      db.close();
+    } catch {
+      // DB may not exist yet
+    }
+  }
+
+  const status = syncOk ? 'success' : 'failed';
+
+  emitStatus('SYNC_GROUPS', {
+    BUILD: buildOk ? 'success' : 'failed',
+    SYNC: syncOk ? 'success' : 'failed',
+    GROUPS_IN_DB: groupsInDb,
+    STATUS: status,
+    LOG: 'logs/setup.log',
+  });
+
+  if (status === 'failed') process.exit(1);
+}

package/setup/index.ts

@@ -0,0 +1,58 @@
+/**
+ * Setup CLI entry point.
+ * Usage: npx tsx setup/index.ts --step <name> [args...]
+ */
+import { logger } from '../src/logger.js';
+import { emitStatus } from './status.js';
+
+const STEPS: Record<
+  string,
+  () => Promise<{ run: (args: string[]) => Promise<void> }>
+> = {
+  environment: () => import('./environment.js'),
+  container: () => import('./container.js'),
+  groups: () => import('./groups.js'),
+  register: () => import('./register.js'),
+  mounts: () => import('./mounts.js'),
+  service: () => import('./service.js'),
+  verify: () => import('./verify.js'),
+};
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+  const stepIdx = args.indexOf('--step');
+
+  if (stepIdx === -1 || !args[stepIdx + 1]) {
+    console.error(
+      `Usage: npx tsx setup/index.ts --step <${Object.keys(STEPS).join('|')}> [args...]`,
+    );
+    process.exit(1);
+  }
+
+  const stepName = args[stepIdx + 1];
+  const stepArgs = args.filter(
+    (a, i) => i !== stepIdx && i !== stepIdx + 1 && a !== '--',
+  );
+
+  const loader = STEPS[stepName];
+  if (!loader) {
+    console.error(`Unknown step: ${stepName}`);
+    console.error(`Available steps: ${Object.keys(STEPS).join(', ')}`);
+    process.exit(1);
+  }
+
+  try {
+    const mod = await loader();
+    await mod.run(stepArgs);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    logger.error({ err, step: stepName }, 'Setup step failed');
+    emitStatus(stepName.toUpperCase(), {
+      STATUS: 'failed',
+      ERROR: message,
+    });
+    process.exit(1);
+  }
+}
+
+main();

package/setup/mounts.ts

@@ -0,0 +1,115 @@
+/**
+ * Step: mounts — Write mount allowlist config file.
+ * Replaces 07-configure-mounts.sh
+ */
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+import { logger } from '../src/logger.js';
+import { isRoot } from './platform.js';
+import { emitStatus } from './status.js';
+
+function parseArgs(args: string[]): { empty: boolean; json: string } {
+  let empty = false;
+  let json = '';
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--empty') empty = true;
+    if (args[i] === '--json' && args[i + 1]) {
+      json = args[i + 1];
+      i++;
+    }
+  }
+  return { empty, json };
+}
+
+export async function run(args: string[]): Promise<void> {
+  const { empty, json } = parseArgs(args);
+  const homeDir = os.homedir();
+  const configDir = path.join(homeDir, '.config', 'nanoclaw');
+  const configFile = path.join(configDir, 'mount-allowlist.json');
+
+  if (isRoot()) {
+    logger.warn(
+      'Running as root — mount allowlist will be written to root home directory',
+    );
+  }
+
+  fs.mkdirSync(configDir, { recursive: true });
+
+  let allowedRoots = 0;
+  let nonMainReadOnly = 'true';
+
+  if (empty) {
+    logger.info('Writing empty mount allowlist');
+    const emptyConfig = {
+      allowedRoots: [],
+      blockedPatterns: [],
+      nonMainReadOnly: true,
+    };
+    fs.writeFileSync(configFile, JSON.stringify(emptyConfig, null, 2) + '\n');
+  } else if (json) {
+    // Validate JSON with JSON.parse (not piped through shell)
+    let parsed: { allowedRoots?: unknown[]; nonMainReadOnly?: boolean };
+    try {
+      parsed = JSON.parse(json);
+    } catch {
+      logger.error('Invalid JSON input');
+      emitStatus('CONFIGURE_MOUNTS', {
+        PATH: configFile,
+        ALLOWED_ROOTS: 0,
+        NON_MAIN_READ_ONLY: 'unknown',
+        STATUS: 'failed',
+        ERROR: 'invalid_json',
+        LOG: 'logs/setup.log',
+      });
+      process.exit(4);
+      return; // unreachable but satisfies TS
+    }
+
+    fs.writeFileSync(configFile, JSON.stringify(parsed, null, 2) + '\n');
+    allowedRoots = Array.isArray(parsed.allowedRoots)
+      ? parsed.allowedRoots.length
+      : 0;
+    nonMainReadOnly = parsed.nonMainReadOnly === false ? 'false' : 'true';
+  } else {
+    // Read from stdin
+    logger.info('Reading mount allowlist from stdin');
+    const input = fs.readFileSync(0, 'utf-8');
+    let parsed: { allowedRoots?: unknown[]; nonMainReadOnly?: boolean };
+    try {
+      parsed = JSON.parse(input);
+    } catch {
+      logger.error('Invalid JSON from stdin');
+      emitStatus('CONFIGURE_MOUNTS', {
+        PATH: configFile,
+        ALLOWED_ROOTS: 0,
+        NON_MAIN_READ_ONLY: 'unknown',
+        STATUS: 'failed',
+        ERROR: 'invalid_json',
+        LOG: 'logs/setup.log',
+      });
+      process.exit(4);
+      return;
+    }
+
+    fs.writeFileSync(configFile, JSON.stringify(parsed, null, 2) + '\n');
+    allowedRoots = Array.isArray(parsed.allowedRoots)
+      ? parsed.allowedRoots.length
+      : 0;
+    nonMainReadOnly = parsed.nonMainReadOnly === false ? 'false' : 'true';
+  }
+
+  logger.info(
+    { configFile, allowedRoots, nonMainReadOnly },
+    'Allowlist configured',
+  );
+
+  emitStatus('CONFIGURE_MOUNTS', {
+    PATH: configFile,
+    ALLOWED_ROOTS: allowedRoots,
+    NON_MAIN_READ_ONLY: nonMainReadOnly,
+    STATUS: 'success',
+    LOG: 'logs/setup.log',
+  });
+}

package/setup/platform.test.ts

@@ -0,0 +1,120 @@
+import { describe, it, expect } from 'vitest';
+
+import {
+  getPlatform,
+  isWSL,
+  isRoot,
+  isHeadless,
+  hasSystemd,
+  getServiceManager,
+  commandExists,
+  getNodeVersion,
+  getNodeMajorVersion,
+} from './platform.js';
+
+// --- getPlatform ---
+
+describe('getPlatform', () => {
+  it('returns a valid platform string', () => {
+    const result = getPlatform();
+    expect(['macos', 'linux', 'unknown']).toContain(result);
+  });
+});
+
+// --- isWSL ---
+
+describe('isWSL', () => {
+  it('returns a boolean', () => {
+    expect(typeof isWSL()).toBe('boolean');
+  });
+
+  it('checks /proc/version for WSL markers', () => {
+    // On non-WSL Linux, should return false
+    // On WSL, should return true
+    // Just verify it doesn't throw
+    const result = isWSL();
+    expect(typeof result).toBe('boolean');
+  });
+});
+
+// --- isRoot ---
+
+describe('isRoot', () => {
+  it('returns a boolean', () => {
+    expect(typeof isRoot()).toBe('boolean');
+  });
+});
+
+// --- isHeadless ---
+
+describe('isHeadless', () => {
+  it('returns a boolean', () => {
+    expect(typeof isHeadless()).toBe('boolean');
+  });
+});
+
+// --- hasSystemd ---
+
+describe('hasSystemd', () => {
+  it('returns a boolean', () => {
+    expect(typeof hasSystemd()).toBe('boolean');
+  });
+
+  it('checks /proc/1/comm', () => {
+    // On systemd systems, should return true
+    // Just verify it doesn't throw
+    const result = hasSystemd();
+    expect(typeof result).toBe('boolean');
+  });
+});
+
+// --- getServiceManager ---
+
+describe('getServiceManager', () => {
+  it('returns a valid service manager', () => {
+    const result = getServiceManager();
+    expect(['launchd', 'systemd', 'none']).toContain(result);
+  });
+
+  it('matches the detected platform', () => {
+    const platform = getPlatform();
+    const result = getServiceManager();
+    if (platform === 'macos') {
+      expect(result).toBe('launchd');
+    } else {
+      expect(['systemd', 'none']).toContain(result);
+    }
+  });
+});
+
+// --- commandExists ---
+
+describe('commandExists', () => {
+  it('returns true for node', () => {
+    expect(commandExists('node')).toBe(true);
+  });
+
+  it('returns false for nonexistent command', () => {
+    expect(commandExists('this_command_does_not_exist_xyz_123')).toBe(false);
+  });
+});
+
+// --- getNodeVersion ---
+
+describe('getNodeVersion', () => {
+  it('returns a version string', () => {
+    const version = getNodeVersion();
+    expect(version).not.toBeNull();
+    expect(version).toMatch(/^\d+\.\d+\.\d+/);
+  });
+});
+
+// --- getNodeMajorVersion ---
+
+describe('getNodeMajorVersion', () => {
+  it('returns at least 20', () => {
+    const major = getNodeMajorVersion();
+    expect(major).not.toBeNull();
+    expect(major!).toBeGreaterThanOrEqual(20);
+  });
+});

package/setup/platform.ts

@@ -0,0 +1,132 @@
+/**
+ * Cross-platform detection utilities for NanoClaw setup.
+ */
+import { execSync } from 'child_process';
+import fs from 'fs';
+import os from 'os';
+
+export type Platform = 'macos' | 'linux' | 'unknown';
+export type ServiceManager = 'launchd' | 'systemd' | 'none';
+
+export function getPlatform(): Platform {
+  const platform = os.platform();
+  if (platform === 'darwin') return 'macos';
+  if (platform === 'linux') return 'linux';
+  return 'unknown';
+}
+
+export function isWSL(): boolean {
+  if (os.platform() !== 'linux') return false;
+  try {
+    const release = fs.readFileSync('/proc/version', 'utf-8').toLowerCase();
+    return release.includes('microsoft') || release.includes('wsl');
+  } catch {
+    return false;
+  }
+}
+
+export function isRoot(): boolean {
+  return process.getuid?.() === 0;
+}
+
+export function isHeadless(): boolean {
+  // No display server available
+  if (getPlatform() === 'linux') {
+    return !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY;
+  }
+  // macOS is never headless in practice (even SSH sessions can open URLs)
+  return false;
+}
+
+export function hasSystemd(): boolean {
+  if (getPlatform() !== 'linux') return false;
+  try {
+    // Check if systemd is PID 1
+    const init = fs.readFileSync('/proc/1/comm', 'utf-8').trim();
+    return init === 'systemd';
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Open a URL in the default browser, cross-platform.
+ * Returns true if the command was attempted, false if no method available.
+ */
+export function openBrowser(url: string): boolean {
+  try {
+    const platform = getPlatform();
+    if (platform === 'macos') {
+      execSync(`open ${JSON.stringify(url)}`, { stdio: 'ignore' });
+      return true;
+    }
+    if (platform === 'linux') {
+      // Try xdg-open first, then wslview for WSL
+      if (commandExists('xdg-open')) {
+        execSync(`xdg-open ${JSON.stringify(url)}`, { stdio: 'ignore' });
+        return true;
+      }
+      if (isWSL() && commandExists('wslview')) {
+        execSync(`wslview ${JSON.stringify(url)}`, { stdio: 'ignore' });
+        return true;
+      }
+      // WSL without wslview: try cmd.exe
+      if (isWSL()) {
+        try {
+          execSync(`cmd.exe /c start "" ${JSON.stringify(url)}`, {
+            stdio: 'ignore',
+          });
+          return true;
+        } catch {
+          // cmd.exe not available
+        }
+      }
+    }
+  } catch {
+    // Command failed
+  }
+  return false;
+}
+
+export function getServiceManager(): ServiceManager {
+  const platform = getPlatform();
+  if (platform === 'macos') return 'launchd';
+  if (platform === 'linux') {
+    if (hasSystemd()) return 'systemd';
+    return 'none';
+  }
+  return 'none';
+}
+
+export function getNodePath(): string {
+  try {
+    return execSync('command -v node', { encoding: 'utf-8' }).trim();
+  } catch {
+    return process.execPath;
+  }
+}
+
+export function commandExists(name: string): boolean {
+  try {
+    execSync(`command -v ${name}`, { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function getNodeVersion(): string | null {
+  try {
+    const version = execSync('node --version', { encoding: 'utf-8' }).trim();
+    return version.replace(/^v/, '');
+  } catch {
+    return null;
+  }
+}
+
+export function getNodeMajorVersion(): number | null {
+  const version = getNodeVersion();
+  if (!version) return null;
+  const major = parseInt(version.split('.')[0], 10);
+  return isNaN(major) ? null : major;
+}