memoryblock 0.0.1 → 0.1.0-beta

package/src/cli/commands/server.ts

@@ -0,0 +1,327 @@
+import {
+    isInitialized, getHome,
+} from '../../utils/config.js';
+import { log } from '../logger.js';
+import { join } from 'node:path';
+import { promises as fsp } from 'node:fs';
+import { DEFAULT_PORT } from '../constants.js';
+
+const API_PKG = '@memoryblock/api';
+
+/**
+ * Server lifecycle management.
+ * Manages the web/API server as a foreground or daemon process.
+ */
+
+export async function serverStartCommand(options?: {
+    port?: string;
+    newToken?: boolean;
+    daemon?: boolean;
+}): Promise<void> {
+    if (!(await isInitialized())) {
+        log.error('Not initialized. Run `mblk init` first.');
+        process.exit(1);
+    }
+
+    const port = parseInt(options?.port || DEFAULT_PORT, 10);
+
+    // Check if server is already running (skip if stored PID is our own — we ARE the daemon child)
+    const existingPid = await readServerPid();
+    if (existingPid && existingPid !== process.pid && isProcessAlive(existingPid)) {
+        const existingPort = await readServerPort();
+        log.warn(`Server already running (PID ${existingPid}${existingPort ? `, port ${existingPort}` : ''}).`);
+        log.dim('  Use `mblk server stop` to stop it first.');
+        return;
+    }
+
+    // Daemon mode — spawn detached and exit
+    if (options?.daemon) {
+        const { spawn } = await import('node:child_process');
+        const fs = await import('node:fs');
+        const scriptPath = process.argv[1];
+
+        // Redirect daemon output to a log file for debugging crashes
+        const logPath = join(getHome(), 'server.log');
+        const logFd = fs.openSync(logPath, 'a');
+
+        const child = spawn(process.execPath, [
+            scriptPath, 'server', 'start', '--port', port.toString(),
+            ...(options?.newToken ? ['--new-token'] : []),
+        ], {
+            detached: true,
+            stdio: ['ignore', logFd, logFd],
+            env: process.env,
+            cwd: process.cwd(),
+        });
+
+        child.unref();
+        fs.closeSync(logFd);
+
+        if (child.pid) {
+            await writeServerPid(child.pid);
+            await writeServerPort(port);
+            log.brand('server\n');
+            log.success(`  Server started as daemon (PID ${child.pid}).`);
+            log.dim(`  http://localhost:${port}`);
+            log.dim('  `mblk server stop` to shut down.\n');
+        } else {
+            log.error('Failed to spawn daemon process.');
+            process.exit(1);
+        }
+        return;
+    }
+
+    // Foreground mode
+    let api: any;
+    try {
+        api = await import(API_PKG);
+    } catch (err) {
+        log.error(`Failed to load API package: ${(err as Error).message}`);
+        process.exit(1);
+    }
+
+    const workspacePath = process.cwd();
+    const authToken = await api.generateAuthToken(workspacePath, options?.newToken);
+
+    // Write PID + port for status/stop
+    await writeServerPid(process.pid);
+    await writeServerPort(port);
+
+    log.brand('server\n');
+    log.dim(`  http://localhost:${port}`);
+    log.dim(`  token: ${authToken}`);
+    console.log('');
+
+    // Auto-install OS service hook quietly
+    import('./service.js').then(s => s.silentServiceInstall()).catch(() => {});
+
+    // Resolve web UI static files
+    let webRoot: string | undefined;
+    try {
+        const { createRequire } = await import('node:module');
+        const require = createRequire(import.meta.url);
+        const webPkg = require.resolve('@memoryblock/web/package.json');
+        const { dirname, join: pJoin } = await import('node:path');
+        webRoot = pJoin(dirname(webPkg), 'public');
+    } catch {
+        log.warn('Web UI package not found. API-only mode.');
+    }
+
+    const server = new api.ApiServer({
+        port,
+        authToken,
+        workspacePath,
+        webRoot,
+    });
+
+    const shutdown = async () => {
+        log.system('server', 'shutting down...');
+        await server.stop();
+        await cleanupServerFiles();
+        process.exit(0);
+    };
+
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+
+    try {
+        await server.start();
+        log.dim('  server running. ctrl+c to stop.\n');
+    } catch (err) {
+        log.error(`Server failed: ${(err as Error).message}`);
+        await cleanupServerFiles();
+        process.exit(1);
+    }
+
+    // Keep alive
+    await new Promise(() => {});
+}
+
+export async function serverStopCommand(): Promise<void> {
+    const pid = await readServerPid();
+    const port = await readServerPort();
+
+    if (!pid) {
+        // No PID file — try killing by port as a fallback
+        if (port) {
+            const killed = await killByPort(port);
+            if (killed) {
+                log.success(`  Server on port ${port} stopped (via port lookup).`);
+            } else {
+                log.dim('  No server PID found. Server may not be running.');
+            }
+        } else {
+            // Last resort: try the default port
+            const defaultPort = parseInt(DEFAULT_PORT, 10);
+            const killed = await killByPort(defaultPort);
+            if (killed) {
+                log.success(`  Server on port ${DEFAULT_PORT} stopped (via port lookup).`);
+            } else {
+                log.dim('  No server PID found. Server may not be running.');
+            }
+        }
+        await cleanupServerFiles();
+        return;
+    }
+
+    if (!isProcessAlive(pid)) {
+        log.dim('  Server process not found (stale PID). Cleaning up.');
+        await cleanupServerFiles();
+        return;
+    }
+
+    try {
+        process.kill(pid, 'SIGTERM');
+        log.success(`  Server stopped (PID ${pid}).`);
+    } catch (err: any) {
+        if (err.code === 'ESRCH') {
+            log.dim('  Server process already gone. Cleaning up.');
+        } else {
+            log.error(`Failed to stop server: ${err.message}`);
+        }
+    }
+
+    await cleanupServerFiles();
+}
+
+export async function serverStatusCommand(): Promise<void> {
+    const pid = await readServerPid();
+    const port = await readServerPort();
+
+    log.brand('server status\n');
+
+    if (!pid) {
+        log.dim('  Status: not running');
+        return;
+    }
+
+    if (isProcessAlive(pid)) {
+        log.success(`  Status: running`);
+        log.dim(`  PID:    ${pid}`);
+        if (port) log.dim(`  URL:    http://localhost:${port}`);
+    } else {
+        log.dim('  Status: not running (stale PID file)');
+        await cleanupServerFiles();
+    }
+    console.log('');
+}
+
+export async function serverTokenCommand(options?: { newToken?: boolean }): Promise<void> {
+    log.brand(options?.newToken ? 'server token (new)\n' : 'server token\n');
+
+    let api: any;
+    try {
+        api = await import(API_PKG);
+    } catch (err) {
+        log.error(`Failed to load API package: ${(err as Error).message}`);
+        process.exit(1);
+    }
+
+    const workspacePath = process.cwd();
+    const token = await api.generateAuthToken(workspacePath, options?.newToken);
+
+    if (options?.newToken) {
+        log.success(`  New token generated successfully.`);
+    }
+    log.dim(`  token: ${token}\n`);
+}
+
+
+// ===== PID / Port Helpers =====
+
+function pidPath(): string { return join(getHome(), 'server.pid'); }
+function portPath(): string { return join(getHome(), 'server.port'); }
+
+async function writeServerPid(pid: number): Promise<void> {
+    await fsp.mkdir(getHome(), { recursive: true });
+    await fsp.writeFile(pidPath(), pid.toString());
+}
+
+async function writeServerPort(port: number): Promise<void> {
+    await fsp.writeFile(portPath(), port.toString());
+}
+
+async function readServerPid(): Promise<number | null> {
+    try {
+        const s = await fsp.readFile(pidPath(), 'utf-8');
+        const n = parseInt(s.trim(), 10);
+        return isNaN(n) ? null : n;
+    } catch { return null; }
+}
+
+async function readServerPort(): Promise<number | null> {
+    try {
+        const s = await fsp.readFile(portPath(), 'utf-8');
+        const n = parseInt(s.trim(), 10);
+        return isNaN(n) ? null : n;
+    } catch { return null; }
+}
+
+function isProcessAlive(pid: number): boolean {
+    try {
+        process.kill(pid, 0); // Signal 0 checks existence
+        return true;
+    } catch { return false; }
+}
+
+async function cleanupServerFiles(): Promise<void> {
+    await fsp.unlink(pidPath()).catch(() => {});
+    await fsp.unlink(portPath()).catch(() => {});
+}
+
+/** Kill process by port using lsof — fallback when PID file is missing. */
+async function killByPort(port: number): Promise<boolean> {
+    try {
+        const { execSync } = await import('node:child_process');
+        const pids = execSync(`lsof -ti:${port}`, { stdio: 'pipe' })
+            .toString().trim().split('\n').filter(Boolean);
+        for (const p of pids) {
+            try { process.kill(parseInt(p, 10), 'SIGTERM'); } catch { /* already gone */ }
+        }
+        return pids.length > 0;
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * mblk shutdown — stop all blocks AND the server in one shot.
+ */
+export async function shutdownCommand(): Promise<void> {
+    log.brand('shutdown\n');
+
+    // 1. Stop all blocks
+    log.dim('  Stopping all blocks...');
+    try {
+        const { stopCommand } = await import('./stop.js');
+        await stopCommand(undefined, { preserveEnabled: true });
+    } catch { /* ignore */ }
+
+    // 2. Stop the server
+    log.dim('  Stopping server...');
+    await serverStopCommand();
+
+    log.success('\n  Everything shut down.');
+}
+
+/**
+ * mblk restart — shutdown then start server as daemon.
+ */
+export async function restartCommand(options?: { port?: string }): Promise<void> {
+    log.brand('restart\n');
+
+    // Shutdown first
+    await shutdownCommand();
+
+    // Small delay to let PID files clean up
+    await new Promise(resolve => setTimeout(resolve, 500));
+
+    // Start server as daemon
+    log.dim('\n  Starting server...');
+    await serverStartCommand({ port: options?.port, daemon: true });
+
+    // Start all enabled blocks
+    log.dim('\n  Starting enabled blocks...');
+    const { startAllEnabledBlocks } = await import('./start.js');
+    await startAllEnabledBlocks();
+}

package/src/cli/commands/service.ts

@@ -0,0 +1,300 @@
+import { log } from '../logger.js';
+import { getHome } from '../../utils/config.js';
+import { promises as fsp } from 'node:fs';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+import { platform } from 'node:os';
+
+const SERVICE_ID = 'io.memoryblock.daemon';
+const SERVICE_LABEL = 'memoryblock';
+
+/**
+ * Get the path to the launchd plist or systemd unit file.
+ */
+function getServicePath(): string {
+    const os = platform();
+    if (os === 'darwin') {
+        return join(process.env.HOME || '~', 'Library', 'LaunchAgents', `${SERVICE_ID}.plist`);
+    } else if (os === 'linux') {
+        return join(process.env.HOME || '~', '.config', 'systemd', 'user', `${SERVICE_LABEL}.service`);
+    } else if (os === 'win32') {
+        const appData = process.env.APPDATA || join(process.env.USERPROFILE || '~', 'AppData', 'Roaming');
+        return join(appData, 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup', `${SERVICE_LABEL}.vbs`);
+    }
+    throw new Error(`Unsupported platform: ${os}. Service management is available on macOS, Linux, and Windows.`);
+}
+
+/**
+ * Resolve the mblk binary path — works in both dev (bun) and installed (node) modes.
+ */
+function getMblkBinaryPath(): string {
+    // In dev mode: process.argv[1] is the TS source
+    // After npm install: the bin wrapper is symlinked
+    const scriptPath = process.argv[1];
+
+    // If running from bun with .ts source, use bun to execute
+    if (scriptPath.endsWith('.ts')) {
+        const bunPath = join(process.env.HOME || '~', '.bun', 'bin', 'bun');
+        return `${bunPath} ${scriptPath}`;
+    }
+
+    // Otherwise use node (installed via npm)
+    return `${process.execPath} ${scriptPath}`;
+}
+
+/**
+ * Generate launchd plist content for macOS.
+ */
+function generateLaunchdPlist(mblkCmd: string): string {
+    const parts = mblkCmd.split(' ');
+    const programArgs = parts.map(p => `        <string>${p}</string>`).join('\n');
+
+    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>${SERVICE_ID}</string>
+    <key>ProgramArguments</key>
+    <array>
+${programArgs}
+        <string>restart</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <false/>
+    <key>WorkingDirectory</key>
+    <string>${process.cwd()}</string>
+    <key>StandardOutPath</key>
+    <string>${join(getHome(), 'service.log')}</string>
+    <key>StandardErrorPath</key>
+    <string>${join(getHome(), 'service.log')}</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>${process.env.PATH}</string>
+        <key>HOME</key>
+        <string>${process.env.HOME}</string>
+    </dict>
+</dict>
+</plist>`;
+}
+
+/**
+ * Generate systemd user unit content for Linux.
+ */
+function generateSystemdUnit(mblkCmd: string): string {
+    return `[Unit]
+Description=memoryblock - AI assistant daemon
+After=network.target
+
+[Service]
+Type=oneshot
+RemainAfterExit=yes
+ExecStart=${mblkCmd} restart
+ExecStop=${mblkCmd} shutdown
+WorkingDirectory=${process.cwd()}
+Environment="PATH=${process.env.PATH}"
+Environment="HOME=${process.env.HOME}"
+
+[Install]
+WantedBy=default.target`;
+}
+
+/**
+ * Generate a Windows VBScript to run mblk restart hidden.
+ */
+function generateWindowsVbs(mblkCmd: string): string {
+    // VBScript to execute command without showing a console window
+    return `Set WshShell = CreateObject("WScript.Shell")\nWshShell.Run "${mblkCmd} restart", 0, False`;
+}
+
+/**
+ * Install memoryblock as a system service (runs on login/boot).
+ */
+export async function serviceInstallCommand(): Promise<void> {
+    const os = platform();
+    const servicePath = getServicePath();
+    const mblkCmd = getMblkBinaryPath();
+
+    log.brand('service install\n');
+
+    // Write service file
+    await fsp.mkdir(join(servicePath, '..'), { recursive: true });
+
+    if (os === 'darwin') {
+        const plist = generateLaunchdPlist(mblkCmd);
+        await fsp.writeFile(servicePath, plist, 'utf-8');
+
+        // Unload first if already loaded (ignore errors)
+        try { execSync(`launchctl bootout gui/${process.getuid?.()} ${servicePath}`, { stdio: 'pipe' }); } catch { /* ignore */ }
+
+        // Load the plist
+        try {
+            execSync(`launchctl bootstrap gui/${process.getuid?.()} ${servicePath}`, { stdio: 'pipe' });
+            log.success('  Service installed and loaded.');
+        } catch {
+            // Fallback for older macOS
+            try {
+                execSync(`launchctl load ${servicePath}`, { stdio: 'pipe' });
+                log.success('  Service installed and loaded.');
+            } catch (err) {
+                log.warn(`  Plist written but failed to load: ${(err as Error).message}`);
+                log.dim(`  Try manually: launchctl load ${servicePath}`);
+            }
+        }
+    } else if (os === 'linux') {
+        const unit = generateSystemdUnit(mblkCmd);
+        await fsp.writeFile(servicePath, unit, 'utf-8');
+
+        try {
+            execSync('systemctl --user daemon-reload', { stdio: 'pipe' });
+            execSync(`systemctl --user enable ${SERVICE_LABEL}`, { stdio: 'pipe' });
+            log.success('  Service installed and enabled.');
+            log.dim('  It will start automatically on next login.');
+            log.dim(`  Start now: systemctl --user start ${SERVICE_LABEL}`);
+        } catch (err) {
+            log.warn(`  Unit file written but systemctl failed: ${(err as Error).message}`);
+        }
+    } else if (os === 'win32') {
+        const vbs = generateWindowsVbs(mblkCmd);
+        await fsp.writeFile(servicePath, vbs, 'utf-8');
+        log.success('  Service installed to Windows Startup folder.');
+        log.dim('  It will start automatically on next login.');
+    }
+
+    log.dim(`  File: ${servicePath}`);
+    log.dim('  memoryblock will auto-start on boot/login.\n');
+}
+
+/**
+ * Silently install the service in the background (used by start/server commands).
+ * Catches all errors so it never interrupts the user.
+ */
+export async function silentServiceInstall(): Promise<void> {
+    try {
+        const os = platform();
+        const servicePath = getServicePath();
+        const mblkCmd = getMblkBinaryPath();
+
+        await fsp.mkdir(join(servicePath, '..'), { recursive: true });
+
+        // Generate content based on OS
+        let content = '';
+        if (os === 'darwin') {
+            content = generateLaunchdPlist(mblkCmd);
+        } else if (os === 'linux') {
+            content = generateSystemdUnit(mblkCmd);
+        } else if (os === 'win32') {
+            content = generateWindowsVbs(mblkCmd);
+        } else {
+            return;
+        }
+
+        // Idempotency check: if the file exists and is identical, do nothing.
+        // This prevents infinite reload loops where the service restarts itself.
+        try {
+            const existing = await fsp.readFile(servicePath, 'utf-8');
+            if (existing === content) {
+                return; // Already installed and up-to-date
+            }
+        } catch {
+            // File doesn't exist, proceed with install
+        }
+
+        await fsp.writeFile(servicePath, content, 'utf-8');
+
+        if (os === 'darwin') {
+            try { execSync(`launchctl bootout gui/${process.getuid?.()} ${servicePath}`, { stdio: 'ignore' }); } catch { /* ignore */ }
+            try {
+                execSync(`launchctl bootstrap gui/${process.getuid?.()} ${servicePath}`, { stdio: 'ignore' });
+            } catch {
+                try { execSync(`launchctl load ${servicePath}`, { stdio: 'ignore' }); } catch { /* ignore */ }
+            }
+        } else if (os === 'linux') {
+            try {
+                execSync('systemctl --user daemon-reload', { stdio: 'ignore' });
+                execSync(`systemctl --user enable ${SERVICE_LABEL}`, { stdio: 'ignore' });
+            } catch { /* ignore */ }
+        }
+    } catch {
+        // Entirely silent
+    }
+}
+
+/**
+ * Uninstall the system service.
+ */
+export async function serviceUninstallCommand(): Promise<void> {
+    const os = platform();
+    const servicePath = getServicePath();
+
+    log.brand('service uninstall\n');
+
+    if (os === 'darwin') {
+        try { execSync(`launchctl bootout gui/${process.getuid?.()} ${servicePath}`, { stdio: 'pipe' }); } catch { /* ignore */ }
+        try { execSync(`launchctl unload ${servicePath}`, { stdio: 'pipe' }); } catch { /* ignore */ }
+    } else if (os === 'linux') {
+        try {
+            execSync(`systemctl --user stop ${SERVICE_LABEL}`, { stdio: 'pipe' });
+            execSync(`systemctl --user disable ${SERVICE_LABEL}`, { stdio: 'pipe' });
+        } catch { /* ignore */ }
+    } else if (os === 'win32') {
+        // Nothing to stop gracefully on Windows for a startup script 
+        // Admin could taskkill, but mblk shutdown handles cleanup
+    }
+
+    try {
+        await fsp.unlink(servicePath);
+        log.success('  Service removed.');
+    } catch {
+        log.dim('  No service file found. Nothing to remove.');
+    }
+    console.log('');
+}
+
+/**
+ * Show service status.
+ */
+export async function serviceStatusCommand(): Promise<void> {
+    const os = platform();
+    const servicePath = getServicePath();
+
+    log.brand('service status\n');
+
+    // Check if service file exists
+    try {
+        await fsp.access(servicePath);
+    } catch {
+        log.dim('  Status: not installed');
+        log.dim(`  Run \`mblk service install\` to enable auto-start.\n`);
+        return;
+    }
+
+    log.success('  Status: installed');
+    log.dim(`  File: ${servicePath}`);
+
+    if (os === 'darwin') {
+        try {
+            const output = execSync(`launchctl list | grep ${SERVICE_ID}`, { stdio: 'pipe' }).toString().trim();
+            if (output) {
+                log.dim('  launchd: loaded');
+            } else {
+                log.dim('  launchd: not loaded');
+            }
+        } catch {
+            log.dim('  launchd: not loaded');
+        }
+    } else if (os === 'linux') {
+        try {
+            const output = execSync(`systemctl --user is-active ${SERVICE_LABEL}`, { stdio: 'pipe' }).toString().trim();
+            log.dim(`  systemd: ${output}`);
+        } catch {
+            log.dim('  systemd: inactive');
+        }
+    } else if (os === 'win32') {
+        log.dim('  Windows Startup: active (file exists)');
+    }
+    console.log('');
+}