@rozek/nanoclaw 1.2.17

package/setup/register.test.ts

@@ -0,0 +1,257 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+
+import Database from 'better-sqlite3';
+
+/**
+ * Tests for the register step.
+ *
+ * Verifies: parameterized SQL (no injection), file templating,
+ * apostrophe in names, .env updates.
+ */
+
+function createTestDb(): Database.Database {
+  const db = new Database(':memory:');
+  db.exec(`CREATE TABLE IF NOT EXISTS registered_groups (
+    jid TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    folder TEXT NOT NULL UNIQUE,
+    trigger_pattern TEXT NOT NULL,
+    added_at TEXT NOT NULL,
+    container_config TEXT,
+    requires_trigger INTEGER DEFAULT 1,
+    is_main INTEGER DEFAULT 0
+  )`);
+  return db;
+}
+
+describe('parameterized SQL registration', () => {
+  let db: Database.Database;
+
+  beforeEach(() => {
+    db = createTestDb();
+  });
+
+  it('registers a group with parameterized query', () => {
+    db.prepare(
+      `INSERT OR REPLACE INTO registered_groups
+       (jid, name, folder, trigger_pattern, added_at, container_config, requires_trigger)
+       VALUES (?, ?, ?, ?, ?, NULL, ?)`,
+    ).run(
+      '123@g.us',
+      'Test Group',
+      'test-group',
+      '@Andy',
+      '2024-01-01T00:00:00.000Z',
+      1,
+    );
+
+    const row = db
+      .prepare('SELECT * FROM registered_groups WHERE jid = ?')
+      .get('123@g.us') as {
+      jid: string;
+      name: string;
+      folder: string;
+      trigger_pattern: string;
+      requires_trigger: number;
+    };
+
+    expect(row.jid).toBe('123@g.us');
+    expect(row.name).toBe('Test Group');
+    expect(row.folder).toBe('test-group');
+    expect(row.trigger_pattern).toBe('@Andy');
+    expect(row.requires_trigger).toBe(1);
+  });
+
+  it('handles apostrophes in group names safely', () => {
+    const name = "O'Brien's Group";
+
+    db.prepare(
+      `INSERT OR REPLACE INTO registered_groups
+       (jid, name, folder, trigger_pattern, added_at, container_config, requires_trigger)
+       VALUES (?, ?, ?, ?, ?, NULL, ?)`,
+    ).run(
+      '456@g.us',
+      name,
+      'obriens-group',
+      '@Andy',
+      '2024-01-01T00:00:00.000Z',
+      0,
+    );
+
+    const row = db
+      .prepare('SELECT name FROM registered_groups WHERE jid = ?')
+      .get('456@g.us') as {
+      name: string;
+    };
+
+    expect(row.name).toBe(name);
+  });
+
+  it('prevents SQL injection in JID field', () => {
+    const maliciousJid = "'; DROP TABLE registered_groups; --";
+
+    db.prepare(
+      `INSERT OR REPLACE INTO registered_groups
+       (jid, name, folder, trigger_pattern, added_at, container_config, requires_trigger)
+       VALUES (?, ?, ?, ?, ?, NULL, ?)`,
+    ).run(maliciousJid, 'Evil', 'evil', '@Andy', '2024-01-01T00:00:00.000Z', 1);
+
+    // Table should still exist and have the row
+    const count = db
+      .prepare('SELECT COUNT(*) as count FROM registered_groups')
+      .get() as {
+      count: number;
+    };
+    expect(count.count).toBe(1);
+
+    const row = db.prepare('SELECT jid FROM registered_groups').get() as {
+      jid: string;
+    };
+    expect(row.jid).toBe(maliciousJid);
+  });
+
+  it('handles requiresTrigger=false', () => {
+    db.prepare(
+      `INSERT OR REPLACE INTO registered_groups
+       (jid, name, folder, trigger_pattern, added_at, container_config, requires_trigger)
+       VALUES (?, ?, ?, ?, ?, NULL, ?)`,
+    ).run(
+      '789@s.whatsapp.net',
+      'Personal',
+      'main',
+      '@Andy',
+      '2024-01-01T00:00:00.000Z',
+      0,
+    );
+
+    const row = db
+      .prepare('SELECT requires_trigger FROM registered_groups WHERE jid = ?')
+      .get('789@s.whatsapp.net') as { requires_trigger: number };
+
+    expect(row.requires_trigger).toBe(0);
+  });
+
+  it('stores is_main flag', () => {
+    db.prepare(
+      `INSERT OR REPLACE INTO registered_groups
+       (jid, name, folder, trigger_pattern, added_at, container_config, requires_trigger, is_main)
+       VALUES (?, ?, ?, ?, ?, NULL, ?, ?)`,
+    ).run(
+      '789@s.whatsapp.net',
+      'Personal',
+      'whatsapp_main',
+      '@Andy',
+      '2024-01-01T00:00:00.000Z',
+      0,
+      1,
+    );
+
+    const row = db
+      .prepare('SELECT is_main FROM registered_groups WHERE jid = ?')
+      .get('789@s.whatsapp.net') as { is_main: number };
+
+    expect(row.is_main).toBe(1);
+  });
+
+  it('defaults is_main to 0', () => {
+    db.prepare(
+      `INSERT OR REPLACE INTO registered_groups
+       (jid, name, folder, trigger_pattern, added_at, container_config, requires_trigger)
+       VALUES (?, ?, ?, ?, ?, NULL, ?)`,
+    ).run(
+      '123@g.us',
+      'Some Group',
+      'whatsapp_some-group',
+      '@Andy',
+      '2024-01-01T00:00:00.000Z',
+      1,
+    );
+
+    const row = db
+      .prepare('SELECT is_main FROM registered_groups WHERE jid = ?')
+      .get('123@g.us') as { is_main: number };
+
+    expect(row.is_main).toBe(0);
+  });
+
+  it('upserts on conflict', () => {
+    const stmt = db.prepare(
+      `INSERT OR REPLACE INTO registered_groups
+       (jid, name, folder, trigger_pattern, added_at, container_config, requires_trigger)
+       VALUES (?, ?, ?, ?, ?, NULL, ?)`,
+    );
+
+    stmt.run(
+      '123@g.us',
+      'Original',
+      'main',
+      '@Andy',
+      '2024-01-01T00:00:00.000Z',
+      1,
+    );
+    stmt.run(
+      '123@g.us',
+      'Updated',
+      'main',
+      '@Bot',
+      '2024-02-01T00:00:00.000Z',
+      0,
+    );
+
+    const rows = db.prepare('SELECT * FROM registered_groups').all();
+    expect(rows).toHaveLength(1);
+
+    const row = rows[0] as {
+      name: string;
+      trigger_pattern: string;
+      requires_trigger: number;
+    };
+    expect(row.name).toBe('Updated');
+    expect(row.trigger_pattern).toBe('@Bot');
+    expect(row.requires_trigger).toBe(0);
+  });
+});
+
+describe('file templating', () => {
+  it('replaces assistant name in CLAUDE.md content', () => {
+    let content = '# Andy\n\nYou are Andy, a personal assistant.';
+
+    content = content.replace(/^# Andy$/m, '# Nova');
+    content = content.replace(/You are Andy/g, 'You are Nova');
+
+    expect(content).toBe('# Nova\n\nYou are Nova, a personal assistant.');
+  });
+
+  it('handles names with special regex characters', () => {
+    let content = '# Andy\n\nYou are Andy.';
+
+    const newName = 'C.L.A.U.D.E';
+    content = content.replace(/^# Andy$/m, `# ${newName}`);
+    content = content.replace(/You are Andy/g, `You are ${newName}`);
+
+    expect(content).toContain('# C.L.A.U.D.E');
+    expect(content).toContain('You are C.L.A.U.D.E.');
+  });
+
+  it('updates .env ASSISTANT_NAME line', () => {
+    let envContent = 'SOME_KEY=value\nASSISTANT_NAME="Andy"\nOTHER=test';
+
+    envContent = envContent.replace(
+      /^ASSISTANT_NAME=.*$/m,
+      'ASSISTANT_NAME="Nova"',
+    );
+
+    expect(envContent).toContain('ASSISTANT_NAME="Nova"');
+    expect(envContent).toContain('SOME_KEY=value');
+  });
+
+  it('appends ASSISTANT_NAME to .env if not present', () => {
+    let envContent = 'SOME_KEY=value\n';
+
+    if (!envContent.includes('ASSISTANT_NAME=')) {
+      envContent += '\nASSISTANT_NAME="Nova"';
+    }
+
+    expect(envContent).toContain('ASSISTANT_NAME="Nova"');
+  });
+});

package/setup/register.ts

@@ -0,0 +1,177 @@
+/**
+ * Step: register — Write channel registration config, create group folders.
+ *
+ * Accepts --channel to specify the messaging platform (whatsapp, telegram, slack, discord).
+ * Uses parameterized SQL queries to prevent injection.
+ */
+import fs from 'fs';
+import path from 'path';
+
+import { STORE_DIR } from '../src/config.ts';
+import { initDatabase, setRegisteredGroup } from '../src/db.ts';
+import { isValidGroupFolder } from '../src/group-folder.ts';
+import { logger } from '../src/logger.ts';
+import { emitStatus } from './status.ts';
+
+interface RegisterArgs {
+  jid: string;
+  name: string;
+  trigger: string;
+  folder: string;
+  channel: string;
+  requiresTrigger: boolean;
+  isMain: boolean;
+  assistantName: string;
+}
+
+function parseArgs(args: string[]): RegisterArgs {
+  const result: RegisterArgs = {
+    jid: '',
+    name: '',
+    trigger: '',
+    folder: '',
+    channel: 'whatsapp', // backward-compat: pre-refactor installs omit --channel
+    requiresTrigger: true,
+    isMain: false,
+    assistantName: 'Andy',
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    switch (args[i]) {
+      case '--jid':
+        result.jid = args[++i] || '';
+        break;
+      case '--name':
+        result.name = args[++i] || '';
+        break;
+      case '--trigger':
+        result.trigger = args[++i] || '';
+        break;
+      case '--folder':
+        result.folder = args[++i] || '';
+        break;
+      case '--channel':
+        result.channel = (args[++i] || '').toLowerCase();
+        break;
+      case '--no-trigger-required':
+        result.requiresTrigger = false;
+        break;
+      case '--is-main':
+        result.isMain = true;
+        break;
+      case '--assistant-name':
+        result.assistantName = args[++i] || 'Andy';
+        break;
+    }
+  }
+
+  return result;
+}
+
+export async function run(args: string[]): Promise<void> {
+  const projectRoot = process.cwd();
+  const parsed = parseArgs(args);
+
+  if (!parsed.jid || !parsed.name || !parsed.trigger || !parsed.folder) {
+    emitStatus('REGISTER_CHANNEL', {
+      STATUS: 'failed',
+      ERROR: 'missing_required_args',
+      LOG: 'logs/setup.log',
+    });
+    process.exit(4);
+  }
+
+  if (!isValidGroupFolder(parsed.folder)) {
+    emitStatus('REGISTER_CHANNEL', {
+      STATUS: 'failed',
+      ERROR: 'invalid_folder',
+      LOG: 'logs/setup.log',
+    });
+    process.exit(4);
+  }
+
+  logger.info(parsed, 'Registering channel');
+
+  // Ensure data and store directories exist (store/ may not exist on
+  // fresh installs that skip WhatsApp auth, which normally creates it)
+  fs.mkdirSync(path.join(projectRoot, 'data'), { recursive: true });
+  fs.mkdirSync(STORE_DIR, { recursive: true });
+
+  // Initialize database (creates schema + runs migrations)
+  initDatabase();
+
+  setRegisteredGroup(parsed.jid, {
+    name: parsed.name,
+    folder: parsed.folder,
+    trigger: parsed.trigger,
+    added_at: new Date().toISOString(),
+    requiresTrigger: parsed.requiresTrigger,
+    isMain: parsed.isMain,
+  });
+
+  logger.info('Wrote registration to SQLite');
+
+  // Create group folders
+  fs.mkdirSync(path.join(projectRoot, 'groups', parsed.folder, 'logs'), {
+    recursive: true,
+  });
+
+  // Update assistant name in CLAUDE.md files if different from default
+  let nameUpdated = false;
+  if (parsed.assistantName !== 'Andy') {
+    logger.info(
+      { from: 'Andy', to: parsed.assistantName },
+      'Updating assistant name',
+    );
+
+    const mdFiles = [
+      path.join(projectRoot, 'groups', 'global', 'CLAUDE.md'),
+      path.join(projectRoot, 'groups', parsed.folder, 'CLAUDE.md'),
+    ];
+
+    for (const mdFile of mdFiles) {
+      if (fs.existsSync(mdFile)) {
+        let content = fs.readFileSync(mdFile, 'utf-8');
+        content = content.replace(/^# Andy$/m, `# ${parsed.assistantName}`);
+        content = content.replace(
+          /You are Andy/g,
+          `You are ${parsed.assistantName}`,
+        );
+        fs.writeFileSync(mdFile, content);
+        logger.info({ file: mdFile }, 'Updated CLAUDE.md');
+      }
+    }
+
+    // Update .env
+    const envFile = path.join(projectRoot, '.env');
+    if (fs.existsSync(envFile)) {
+      let envContent = fs.readFileSync(envFile, 'utf-8');
+      if (envContent.includes('ASSISTANT_NAME=')) {
+        envContent = envContent.replace(
+          /^ASSISTANT_NAME=.*$/m,
+          `ASSISTANT_NAME="${parsed.assistantName}"`,
+        );
+      } else {
+        envContent += `\nASSISTANT_NAME="${parsed.assistantName}"`;
+      }
+      fs.writeFileSync(envFile, envContent);
+    } else {
+      fs.writeFileSync(envFile, `ASSISTANT_NAME="${parsed.assistantName}"\n`);
+    }
+    logger.info('Set ASSISTANT_NAME in .env');
+    nameUpdated = true;
+  }
+
+  emitStatus('REGISTER_CHANNEL', {
+    JID: parsed.jid,
+    NAME: parsed.name,
+    FOLDER: parsed.folder,
+    CHANNEL: parsed.channel,
+    TRIGGER: parsed.trigger,
+    REQUIRES_TRIGGER: parsed.requiresTrigger,
+    ASSISTANT_NAME: parsed.assistantName,
+    NAME_UPDATED: nameUpdated,
+    STATUS: 'success',
+    LOG: 'logs/setup.log',
+  });
+}

package/setup/service.test.ts

@@ -0,0 +1,187 @@
+import { describe, it, expect } from 'vitest';
+import path from 'path';
+
+/**
+ * Tests for service configuration generation.
+ *
+ * These tests verify the generated content of plist/systemd/nohup configs
+ * without actually loading services.
+ */
+
+// Helper: generate a plist string the same way service.ts does
+function generatePlist(
+  nodePath: string,
+  projectRoot: string,
+  homeDir: string,
+): string {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.nanoclaw</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${nodePath}</string>
+        <string>${projectRoot}/dist/index.js</string>
+    </array>
+    <key>WorkingDirectory</key>
+    <string>${projectRoot}</string>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>/usr/local/bin:/usr/bin:/bin:${homeDir}/.local/bin</string>
+        <key>HOME</key>
+        <string>${homeDir}</string>
+    </dict>
+    <key>StandardOutPath</key>
+    <string>${projectRoot}/logs/nanoclaw.log</string>
+    <key>StandardErrorPath</key>
+    <string>${projectRoot}/logs/nanoclaw.error.log</string>
+</dict>
+</plist>`;
+}
+
+function generateSystemdUnit(
+  nodePath: string,
+  projectRoot: string,
+  homeDir: string,
+  isSystem: boolean,
+): string {
+  return `[Unit]
+Description=NanoClaw Personal Assistant
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${nodePath} ${projectRoot}/dist/index.js
+WorkingDirectory=${projectRoot}
+Restart=always
+RestartSec=5
+KillMode=process
+Environment=HOME=${homeDir}
+Environment=PATH=/usr/local/bin:/usr/bin:/bin:${homeDir}/.local/bin
+StandardOutput=append:${projectRoot}/logs/nanoclaw.log
+StandardError=append:${projectRoot}/logs/nanoclaw.error.log
+
+[Install]
+WantedBy=${isSystem ? 'multi-user.target' : 'default.target'}`;
+}
+
+describe('plist generation', () => {
+  it('contains the correct label', () => {
+    const plist = generatePlist(
+      '/usr/local/bin/node',
+      '/home/user/nanoclaw',
+      '/home/user',
+    );
+    expect(plist).toContain('<string>com.nanoclaw</string>');
+  });
+
+  it('uses the correct node path', () => {
+    const plist = generatePlist(
+      '/opt/node/bin/node',
+      '/home/user/nanoclaw',
+      '/home/user',
+    );
+    expect(plist).toContain('<string>/opt/node/bin/node</string>');
+  });
+
+  it('points to dist/index.js', () => {
+    const plist = generatePlist(
+      '/usr/local/bin/node',
+      '/home/user/nanoclaw',
+      '/home/user',
+    );
+    expect(plist).toContain('/home/user/nanoclaw/dist/index.js');
+  });
+
+  it('sets log paths', () => {
+    const plist = generatePlist(
+      '/usr/local/bin/node',
+      '/home/user/nanoclaw',
+      '/home/user',
+    );
+    expect(plist).toContain('nanoclaw.log');
+    expect(plist).toContain('nanoclaw.error.log');
+  });
+});
+
+describe('systemd unit generation', () => {
+  it('user unit uses default.target', () => {
+    const unit = generateSystemdUnit(
+      '/usr/bin/node',
+      '/home/user/nanoclaw',
+      '/home/user',
+      false,
+    );
+    expect(unit).toContain('WantedBy=default.target');
+  });
+
+  it('system unit uses multi-user.target', () => {
+    const unit = generateSystemdUnit(
+      '/usr/bin/node',
+      '/home/user/nanoclaw',
+      '/home/user',
+      true,
+    );
+    expect(unit).toContain('WantedBy=multi-user.target');
+  });
+
+  it('contains restart policy', () => {
+    const unit = generateSystemdUnit(
+      '/usr/bin/node',
+      '/home/user/nanoclaw',
+      '/home/user',
+      false,
+    );
+    expect(unit).toContain('Restart=always');
+    expect(unit).toContain('RestartSec=5');
+  });
+
+  it('uses KillMode=process to preserve detached children', () => {
+    const unit = generateSystemdUnit(
+      '/usr/bin/node',
+      '/home/user/nanoclaw',
+      '/home/user',
+      false,
+    );
+    expect(unit).toContain('KillMode=process');
+  });
+
+  it('sets correct ExecStart', () => {
+    const unit = generateSystemdUnit(
+      '/usr/bin/node',
+      '/srv/nanoclaw',
+      '/home/user',
+      false,
+    );
+    expect(unit).toContain(
+      'ExecStart=/usr/bin/node /srv/nanoclaw/dist/index.js',
+    );
+  });
+});
+
+describe('WSL nohup fallback', () => {
+  it('generates a valid wrapper script', () => {
+    const projectRoot = '/home/user/nanoclaw';
+    const nodePath = '/usr/bin/node';
+    const pidFile = path.join(projectRoot, 'nanoclaw.pid');
+
+    // Simulate what service.ts generates
+    const wrapper = `#!/bin/bash
+set -euo pipefail
+cd ${JSON.stringify(projectRoot)}
+nohup ${JSON.stringify(nodePath)} ${JSON.stringify(projectRoot)}/dist/index.js >> ${JSON.stringify(projectRoot)}/logs/nanoclaw.log 2>> ${JSON.stringify(projectRoot)}/logs/nanoclaw.error.log &
+echo $! > ${JSON.stringify(pidFile)}`;
+
+    expect(wrapper).toContain('#!/bin/bash');
+    expect(wrapper).toContain('nohup');
+    expect(wrapper).toContain(nodePath);
+    expect(wrapper).toContain('nanoclaw.pid');
+  });
+});