discoclaw 0.1.0

package/dist/cli/daemon-installer.js

@@ -0,0 +1,225 @@
+/**
+ * Daemon installer for discoclaw.
+ * Invoked by `discoclaw install-daemon`.
+ * On Linux: writes a systemd user unit and enables it via systemctl.
+ * On macOS: writes a launchd plist and loads it via launchctl.
+ */
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import * as readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+// ── Package resolution ─────────────────────────────────────────────────────
+/**
+ * Resolves the package root directory.
+ * At runtime this file lives at dist/cli/daemon-installer.js,
+ * so package root is two directories up.
+ */
+export function resolvePackageRoot() {
+    const selfDir = path.dirname(fileURLToPath(import.meta.url));
+    return path.resolve(selfDir, '..', '..');
+}
+// ── Rendering helpers ──────────────────────────────────────────────────────
+/**
+ * Parses a .env file into key-value pairs.
+ * Skips blank lines and comment lines.
+ */
+export function parseEnvFile(content) {
+    const result = {};
+    for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const eqIdx = trimmed.indexOf('=');
+        if (eqIdx < 0)
+            continue;
+        const key = trimmed.slice(0, eqIdx).trim();
+        const val = trimmed.slice(eqIdx + 1);
+        if (key)
+            result[key] = val;
+    }
+    return result;
+}
+/**
+ * Renders a systemd user unit file for discoclaw.
+ * Uses EnvironmentFile for .env loading (native systemd feature).
+ */
+export function renderSystemdUnit(packageRoot, cwd) {
+    const entryPoint = path.join(packageRoot, 'dist', 'index.js');
+    return [
+        '[Unit]',
+        'Description=DiscoClaw — personal AI orchestrator',
+        'After=network.target',
+        '',
+        '[Service]',
+        'Type=simple',
+        `ExecStart=/usr/bin/node ${entryPoint}`,
+        `WorkingDirectory=${cwd}`,
+        `EnvironmentFile=${path.join(cwd, '.env')}`,
+        'Restart=on-failure',
+        'RestartSec=5',
+        '',
+        '[Install]',
+        'WantedBy=default.target',
+        '',
+    ].join('\n');
+}
+/**
+ * Renders a launchd plist for discoclaw.
+ * Since launchd has no EnvironmentFile equivalent, env vars are baked in
+ * from the parsed .env at install time.
+ */
+export function renderLaunchdPlist(packageRoot, cwd, envVars) {
+    const entryPoint = path.join(packageRoot, 'dist', 'index.js');
+    const envEntries = Object.entries(envVars)
+        .map(([k, v]) => `\t\t<key>${k}</key>\n\t\t<string>${v}</string>`)
+        .join('\n');
+    const lines = [
+        '<?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>',
+        '\t<key>Label</key>',
+        '\t<string>com.discoclaw.agent</string>',
+        '\t<key>ProgramArguments</key>',
+        '\t<array>',
+        '\t\t<string>/usr/bin/node</string>',
+        `\t\t<string>${entryPoint}</string>`,
+        '\t</array>',
+        '\t<key>WorkingDirectory</key>',
+        `\t<string>${cwd}</string>`,
+        '\t<key>EnvironmentVariables</key>',
+        '\t<dict>',
+    ];
+    if (envEntries)
+        lines.push(envEntries);
+    lines.push('\t</dict>');
+    lines.push('\t<key>RunAtLoad</key>');
+    lines.push('\t<true/>');
+    lines.push('\t<key>KeepAlive</key>');
+    lines.push('\t<true/>');
+    lines.push('</dict>');
+    lines.push('</plist>');
+    lines.push('');
+    return lines.join('\n');
+}
+// ── Platform installers ────────────────────────────────────────────────────
+async function installSystemd(packageRoot, cwd, ask) {
+    const serviceDir = path.join(os.homedir(), '.config', 'systemd', 'user');
+    const servicePath = path.join(serviceDir, 'discoclaw.service');
+    if (fs.existsSync(servicePath)) {
+        const answer = await ask(`Service file already exists at ${servicePath}. Overwrite? [y/N] `);
+        if (answer.trim().toLowerCase() !== 'y') {
+            console.log('Aborted.\n');
+            return;
+        }
+    }
+    const unit = renderSystemdUnit(packageRoot, cwd);
+    fs.mkdirSync(serviceDir, { recursive: true });
+    fs.writeFileSync(servicePath, unit, 'utf8');
+    console.log(`Wrote ${servicePath}\n`);
+    console.log('Running systemctl --user daemon-reload...');
+    try {
+        execFileSync('systemctl', ['--user', 'daemon-reload']);
+    }
+    catch (err) {
+        console.error(`systemctl daemon-reload failed: ${err.message}\n`);
+        process.exit(1);
+    }
+    console.log('Enabling and starting discoclaw service...');
+    try {
+        execFileSync('systemctl', ['--user', 'enable', '--now', 'discoclaw']);
+    }
+    catch (err) {
+        console.error(`systemctl enable/start failed: ${err.message}\n`);
+        process.exit(1);
+    }
+    console.log('DiscoClaw daemon installed and started.\n');
+    console.log('Useful commands:');
+    console.log('  journalctl --user -u discoclaw.service -f   # tail logs');
+    console.log('  systemctl --user status discoclaw           # check status');
+    console.log('  systemctl --user stop discoclaw             # stop the service');
+    console.log('');
+}
+async function installLaunchd(packageRoot, cwd, envPath, ask) {
+    const agentsDir = path.join(os.homedir(), 'Library', 'LaunchAgents');
+    const plistPath = path.join(agentsDir, 'com.discoclaw.agent.plist');
+    if (fs.existsSync(plistPath)) {
+        const answer = await ask(`Plist already exists at ${plistPath}. Overwrite? [y/N] `);
+        if (answer.trim().toLowerCase() !== 'y') {
+            console.log('Aborted.\n');
+            return;
+        }
+    }
+    const envContent = fs.readFileSync(envPath, 'utf8');
+    const envVars = parseEnvFile(envContent);
+    const plist = renderLaunchdPlist(packageRoot, cwd, envVars);
+    fs.mkdirSync(agentsDir, { recursive: true });
+    fs.writeFileSync(plistPath, plist, 'utf8');
+    console.log(`Wrote ${plistPath}\n`);
+    console.log('Note: On macOS, .env changes require re-running `discoclaw install-daemon`.\n' +
+        '      Environment variables are baked into the plist at install time.\n');
+    const uid = process.getuid();
+    const target = `gui/${uid}/com.discoclaw.agent`;
+    // Idempotent: bootout first (ignore failure if agent is not currently loaded)
+    try {
+        execFileSync('launchctl', ['bootout', target]);
+    }
+    catch {
+        // Not currently loaded — that's fine
+    }
+    console.log('Running launchctl bootstrap...');
+    try {
+        execFileSync('launchctl', ['bootstrap', `gui/${uid}`, plistPath]);
+    }
+    catch (err) {
+        console.error(`launchctl bootstrap failed: ${err.message}\n`);
+        process.exit(1);
+    }
+    console.log('DiscoClaw daemon installed and started.\n');
+    console.log('Useful commands:');
+    console.log("  log stream --predicate 'process == \"node\"'  # tail logs");
+    console.log('  launchctl list com.discoclaw.agent           # check status');
+    console.log(`  launchctl bootout ${target}  # stop and unload`);
+    console.log('');
+}
+// ── Main entrypoint ────────────────────────────────────────────────────────
+export async function runDaemonInstaller() {
+    if (!input.isTTY) {
+        console.error('discoclaw install-daemon requires an interactive terminal.\n');
+        process.exit(1);
+    }
+    const platform = process.platform;
+    if (platform !== 'linux' && platform !== 'darwin') {
+        console.error(`Unsupported platform: ${platform}. Only Linux (systemd) and macOS (launchd) are supported.\n`);
+        process.exit(1);
+    }
+    const cwd = process.cwd();
+    const envPath = path.join(cwd, '.env');
+    if (!fs.existsSync(envPath)) {
+        console.error(`No .env found in ${cwd}.\nRun \`discoclaw init\` first to set up your configuration.\n`);
+        process.exit(1);
+    }
+    const packageRoot = resolvePackageRoot();
+    const entryPoint = path.join(packageRoot, 'dist', 'index.js');
+    if (!fs.existsSync(entryPoint)) {
+        console.error(`Cannot find the bot runtime at ${entryPoint}.\n` +
+            'Make sure the package is properly installed (try running `npm install -g discoclaw` again).\n');
+        process.exit(1);
+    }
+    const rl = readline.createInterface({ input, output });
+    const ask = (prompt) => rl.question(prompt);
+    try {
+        if (platform === 'linux') {
+            await installSystemd(packageRoot, cwd, ask);
+        }
+        else {
+            await installLaunchd(packageRoot, cwd, envPath, ask);
+        }
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/cli/daemon-installer.test.js

@@ -0,0 +1,289 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+vi.mock('node:fs', () => ({
+    default: {
+        existsSync: vi.fn(),
+        mkdirSync: vi.fn(),
+        writeFileSync: vi.fn(),
+        readFileSync: vi.fn(),
+    },
+}));
+vi.mock('node:child_process', () => ({
+    execFileSync: vi.fn(),
+}));
+vi.mock('node:readline/promises', () => ({
+    createInterface: vi.fn(),
+}));
+import fs from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { createInterface } from 'node:readline/promises';
+import { parseEnvFile, renderSystemdUnit, renderLaunchdPlist, runDaemonInstaller, } from './daemon-installer.js';
+// ── Test helpers ───────────────────────────────────────────────────────────
+function makeReadline(answers = []) {
+    return {
+        question: vi.fn(async () => answers.shift() ?? ''),
+        close: vi.fn(),
+        on: vi.fn(),
+    };
+}
+const PACKAGE_ROOT = '/opt/discoclaw';
+const CWD = '/home/user/bot';
+const SAMPLE_ENV = 'DISCORD_TOKEN=abc123\nDISCORD_ALLOW_USER_IDS=111\n# comment\n\nFOO=bar=baz\n';
+// ── parseEnvFile ───────────────────────────────────────────────────────────
+describe('parseEnvFile', () => {
+    it('parses key=value pairs', () => {
+        const result = parseEnvFile('FOO=bar\nBAZ=qux\n');
+        expect(result).toEqual({ FOO: 'bar', BAZ: 'qux' });
+    });
+    it('skips blank lines and comment lines', () => {
+        const result = parseEnvFile('# comment\n\nFOO=bar\n');
+        expect(result).toEqual({ FOO: 'bar' });
+    });
+    it('preserves values that contain = characters', () => {
+        const result = parseEnvFile('FOO=bar=baz\n');
+        expect(result).toEqual({ FOO: 'bar=baz' });
+    });
+    it('returns empty object for empty input', () => {
+        expect(parseEnvFile('')).toEqual({});
+        expect(parseEnvFile('# just comments\n')).toEqual({});
+    });
+});
+// ── renderSystemdUnit ──────────────────────────────────────────────────────
+describe('renderSystemdUnit', () => {
+    it('produces correct ExecStart with /usr/bin/node and dist/index.js', () => {
+        const unit = renderSystemdUnit(PACKAGE_ROOT, CWD);
+        expect(unit).toContain(`ExecStart=/usr/bin/node ${PACKAGE_ROOT}/dist/index.js`);
+    });
+    it('sets WorkingDirectory to the provided cwd', () => {
+        const unit = renderSystemdUnit(PACKAGE_ROOT, CWD);
+        expect(unit).toContain(`WorkingDirectory=${CWD}`);
+    });
+    it('sets EnvironmentFile to <cwd>/.env', () => {
+        const unit = renderSystemdUnit(PACKAGE_ROOT, CWD);
+        expect(unit).toContain(`EnvironmentFile=${CWD}/.env`);
+    });
+    it('includes standard unit and install sections', () => {
+        const unit = renderSystemdUnit(PACKAGE_ROOT, CWD);
+        expect(unit).toContain('[Unit]');
+        expect(unit).toContain('[Service]');
+        expect(unit).toContain('[Install]');
+        expect(unit).toContain('Restart=on-failure');
+        expect(unit).toContain('WantedBy=default.target');
+    });
+});
+// ── renderLaunchdPlist ─────────────────────────────────────────────────────
+describe('renderLaunchdPlist', () => {
+    const envVars = { DISCORD_TOKEN: 'tok', FOO: 'bar' };
+    it('produces valid XML plist with correct label', () => {
+        const plist = renderLaunchdPlist(PACKAGE_ROOT, CWD, envVars);
+        expect(plist).toContain('<?xml version="1.0"');
+        expect(plist).toContain('<string>com.discoclaw.agent</string>');
+    });
+    it('sets ProgramArguments to /usr/bin/node and dist/index.js', () => {
+        const plist = renderLaunchdPlist(PACKAGE_ROOT, CWD, envVars);
+        expect(plist).toContain('<string>/usr/bin/node</string>');
+        expect(plist).toContain(`<string>${PACKAGE_ROOT}/dist/index.js</string>`);
+    });
+    it('sets WorkingDirectory to the provided cwd', () => {
+        const plist = renderLaunchdPlist(PACKAGE_ROOT, CWD, envVars);
+        expect(plist).toContain(`<string>${CWD}</string>`);
+    });
+    it('emits EnvironmentVariables entries for each parsed .env key', () => {
+        const plist = renderLaunchdPlist(PACKAGE_ROOT, CWD, envVars);
+        expect(plist).toContain('<key>DISCORD_TOKEN</key>');
+        expect(plist).toContain('<string>tok</string>');
+        expect(plist).toContain('<key>FOO</key>');
+        expect(plist).toContain('<string>bar</string>');
+    });
+    it('includes RunAtLoad and KeepAlive', () => {
+        const plist = renderLaunchdPlist(PACKAGE_ROOT, CWD, envVars);
+        expect(plist).toContain('<key>RunAtLoad</key>');
+        expect(plist).toContain('<key>KeepAlive</key>');
+        expect(plist).toContain('<true/>');
+    });
+});
+// ── runDaemonInstaller ─────────────────────────────────────────────────────
+const originalIsTTY = process.stdin.isTTY;
+const originalPlatform = process.platform;
+describe('runDaemonInstaller', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        process.stdin.isTTY = true;
+        // Default: .env and dist/index.js exist; service file does not
+        vi.mocked(fs.existsSync).mockImplementation((p) => {
+            const s = String(p);
+            if (s.endsWith('.env'))
+                return true;
+            if (s.endsWith('dist/index.js'))
+                return true;
+            return false;
+        });
+        vi.mocked(fs.readFileSync).mockReturnValue(SAMPLE_ENV);
+        vi.mocked(fs.mkdirSync).mockReturnValue(undefined);
+        vi.mocked(fs.writeFileSync).mockReturnValue(undefined);
+        vi.mocked(execFileSync).mockReturnValue(Buffer.alloc(0));
+        vi.mocked(createInterface).mockReturnValue(makeReadline());
+        // Default to linux for most tests
+        Object.defineProperty(process, 'platform', { value: 'linux', configurable: true });
+    });
+    afterEach(() => {
+        process.stdin.isTTY = originalIsTTY;
+        Object.defineProperty(process, 'platform', {
+            value: originalPlatform,
+            configurable: true,
+        });
+        vi.restoreAllMocks();
+    });
+    // ── Guard checks ──────────────────────────────────────────────────────────
+    it('errors when stdin is not a TTY', async () => {
+        process.stdin.isTTY = false;
+        const errSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        const exitSpy = vi.spyOn(process, 'exit').mockImplementation(((code) => {
+            throw new Error(`exit:${code ?? 0}`);
+        }));
+        await expect(runDaemonInstaller()).rejects.toThrow('exit:1');
+        expect(errSpy).toHaveBeenCalledWith(expect.stringContaining('requires an interactive terminal'));
+        expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+    it('errors when .env is missing in cwd', async () => {
+        vi.mocked(fs.existsSync).mockReturnValue(false);
+        const errSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        const exitSpy = vi.spyOn(process, 'exit').mockImplementation(((code) => {
+            throw new Error(`exit:${code ?? 0}`);
+        }));
+        await expect(runDaemonInstaller()).rejects.toThrow('exit:1');
+        expect(errSpy).toHaveBeenCalledWith(expect.stringContaining('discoclaw init'));
+        expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+    it('errors when dist/index.js does not exist at package root', async () => {
+        vi.mocked(fs.existsSync).mockImplementation((p) => {
+            const s = String(p);
+            if (s.endsWith('.env'))
+                return true;
+            return false; // dist/index.js missing
+        });
+        const errSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        const exitSpy = vi.spyOn(process, 'exit').mockImplementation(((code) => {
+            throw new Error(`exit:${code ?? 0}`);
+        }));
+        await expect(runDaemonInstaller()).rejects.toThrow('exit:1');
+        expect(errSpy).toHaveBeenCalledWith(expect.stringContaining('dist/index.js'));
+        expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+    it('errors on unsupported platforms', async () => {
+        Object.defineProperty(process, 'platform', { value: 'win32', configurable: true });
+        const errSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        const exitSpy = vi.spyOn(process, 'exit').mockImplementation(((code) => {
+            throw new Error(`exit:${code ?? 0}`);
+        }));
+        await expect(runDaemonInstaller()).rejects.toThrow('exit:1');
+        expect(errSpy).toHaveBeenCalledWith(expect.stringContaining('Unsupported platform'));
+        expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+    // ── Platform routing ──────────────────────────────────────────────────────
+    it('linux: calls systemctl daemon-reload then enable --now', async () => {
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        Object.defineProperty(process, 'platform', { value: 'linux', configurable: true });
+        await runDaemonInstaller();
+        const calls = vi.mocked(execFileSync).mock.calls;
+        expect(calls).toContainEqual(['systemctl', ['--user', 'daemon-reload']]);
+        expect(calls).toContainEqual(['systemctl', ['--user', 'enable', '--now', 'discoclaw']]);
+        expect(calls.some(([cmd]) => cmd === 'launchctl')).toBe(false);
+    });
+    it('darwin: calls launchctl bootout then bootstrap', async () => {
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        Object.defineProperty(process, 'platform', { value: 'darwin', configurable: true });
+        await runDaemonInstaller();
+        const calls = vi.mocked(execFileSync).mock.calls;
+        const launchctlCalls = calls.filter(([cmd]) => cmd === 'launchctl');
+        expect(launchctlCalls.length).toBeGreaterThanOrEqual(2);
+        const [bootoutArgs] = launchctlCalls[0].slice(1);
+        const [bootstrapArgs] = launchctlCalls[1].slice(1);
+        expect(bootoutArgs[0]).toBe('bootout');
+        expect(bootstrapArgs[0]).toBe('bootstrap');
+        expect(calls.some(([cmd]) => cmd === 'systemctl')).toBe(false);
+    });
+    // ── Failure handling ──────────────────────────────────────────────────────
+    it('systemctl enable failure produces a clear error message', async () => {
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        Object.defineProperty(process, 'platform', { value: 'linux', configurable: true });
+        vi.mocked(execFileSync).mockImplementation((cmd, args) => {
+            const argsArr = args;
+            if (cmd === 'systemctl' && argsArr.includes('enable')) {
+                throw new Error('Failed to enable unit');
+            }
+            return Buffer.alloc(0);
+        });
+        const errSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        const exitSpy = vi.spyOn(process, 'exit').mockImplementation(((code) => {
+            throw new Error(`exit:${code ?? 0}`);
+        }));
+        await expect(runDaemonInstaller()).rejects.toThrow('exit:1');
+        expect(errSpy).toHaveBeenCalledWith(expect.stringContaining('systemctl enable/start failed'));
+        expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+    it('launchctl bootout failure is ignored; bootstrap failure produces a clear error', async () => {
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        Object.defineProperty(process, 'platform', { value: 'darwin', configurable: true });
+        let bootoutCalled = false;
+        vi.mocked(execFileSync).mockImplementation((cmd, args) => {
+            const argsArr = args;
+            if (cmd === 'launchctl' && argsArr[0] === 'bootout') {
+                bootoutCalled = true;
+                // bootout "succeeds" (no throw) — idempotent unload
+                return Buffer.alloc(0);
+            }
+            if (cmd === 'launchctl' && argsArr[0] === 'bootstrap') {
+                throw new Error('bootstrap: service already exists');
+            }
+            return Buffer.alloc(0);
+        });
+        const errSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        const exitSpy = vi.spyOn(process, 'exit').mockImplementation(((code) => {
+            throw new Error(`exit:${code ?? 0}`);
+        }));
+        await expect(runDaemonInstaller()).rejects.toThrow('exit:1');
+        expect(bootoutCalled).toBe(true);
+        expect(errSpy).toHaveBeenCalledWith(expect.stringContaining('launchctl bootstrap failed'));
+        expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+    // ── Overwrite prompts ─────────────────────────────────────────────────────
+    it('linux: prompts before overwriting an existing service file', async () => {
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        Object.defineProperty(process, 'platform', { value: 'linux', configurable: true });
+        // Service file exists
+        vi.mocked(fs.existsSync).mockImplementation((p) => {
+            const s = String(p);
+            if (s.endsWith('.env'))
+                return true;
+            if (s.endsWith('dist/index.js'))
+                return true;
+            if (s.endsWith('discoclaw.service'))
+                return true;
+            return false;
+        });
+        const rl = makeReadline(['y']); // answer 'y' to overwrite prompt
+        vi.mocked(createInterface).mockReturnValue(rl);
+        await runDaemonInstaller();
+        expect(rl.question).toHaveBeenCalledWith(expect.stringContaining('Overwrite?'));
+        expect(fs.writeFileSync).toHaveBeenCalled();
+    });
+    it('linux: aborts if user declines to overwrite existing service file', async () => {
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        Object.defineProperty(process, 'platform', { value: 'linux', configurable: true });
+        vi.mocked(fs.existsSync).mockImplementation((p) => {
+            const s = String(p);
+            if (s.endsWith('.env'))
+                return true;
+            if (s.endsWith('dist/index.js'))
+                return true;
+            if (s.endsWith('discoclaw.service'))
+                return true;
+            return false;
+        });
+        const rl = makeReadline(['n']); // decline overwrite
+        vi.mocked(createInterface).mockReturnValue(rl);
+        await runDaemonInstaller();
+        expect(fs.writeFileSync).not.toHaveBeenCalled();
+        expect(execFileSync).not.toHaveBeenCalled();
+    });
+});

package/dist/cli/index.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+/**
+ * discoclaw CLI entrypoint.
+ * Usage: discoclaw <command> [options]
+ */
+import { createRequire } from 'node:module';
+import { runInitWizard } from './init-wizard.js';
+import { runDaemonInstaller } from './daemon-installer.js';
+const require = createRequire(import.meta.url);
+const { version } = require('../../package.json');
+const [, , command] = process.argv;
+switch (command) {
+    case 'init':
+        await runInitWizard();
+        break;
+    case 'install-daemon':
+        await runDaemonInstaller();
+        break;
+    case '--version':
+    case '-v':
+        console.log(version);
+        break;
+    case '--help':
+    case '-h':
+    case undefined:
+        printHelp(version);
+        break;
+    default:
+        console.error(`Unknown command: ${command}\n`);
+        printHelp(version);
+        process.exit(1);
+}
+function printHelp(ver) {
+    console.log(`discoclaw v${ver} — Personal AI orchestrator\n` +
+        `\nUsage: discoclaw <command>\n` +
+        `\nCommands:\n` +
+        `  init              Interactive setup wizard — creates .env and workspace/\n` +
+        `  install-daemon    Register discoclaw as a persistent background service\n` +
+        `\nOptions:\n` +
+        `  -v, --version   Print version\n` +
+        `  -h, --help      Print this help\n`);
+}