@shykaruu/jarvis-brain 0.4.0

package/src/cli/uninstall.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, test } from 'bun:test';
+import { join } from 'node:path';
+import { createCleanupPlan, buildCleanupScript } from './uninstall.ts';
+
+describe('uninstall helpers', () => {
+  test('includes managed repo installs under ~/.jarvis', () => {
+    const plan = createCleanupPlan(join(process.env.HOME ?? '/tmp', '.jarvis', 'daemon'));
+    expect(plan.removablePaths).toContain(join(process.env.HOME ?? '/tmp', '.jarvis'));
+    expect(plan.removablePaths).toContain(join(process.env.HOME ?? '/tmp', '.jarvis', 'daemon'));
+  });
+
+  test('includes bun global installs', () => {
+    const plan = createCleanupPlan(join(process.env.HOME ?? '/tmp', '.bun', 'install', 'global', 'node_modules', '@usejarvis', 'brain'));
+    expect(plan.removablePaths.some((path) => path.includes(join('.bun', 'install', 'global')))).toBe(true);
+  });
+
+  test('does not remove arbitrary source checkouts', () => {
+    const plan = createCleanupPlan('/work/projects/jarvis');
+    expect(plan.removablePaths).toContain(join(process.env.HOME ?? '/tmp', '.jarvis'));
+    expect(plan.removablePaths).not.toContain('/work/projects/jarvis');
+  });
+
+  test('cleanup script includes package uninstall and wrapper cleanup', () => {
+    const script = buildCleanupScript({
+      dataDir: '/tmp/.jarvis',
+      packageRoot: '/tmp/.jarvis/daemon',
+      removablePaths: ['/tmp/.jarvis/daemon', '/tmp/.jarvis'],
+      cliWrapperPaths: ['/tmp/bin/jarvis'],
+      bunPath: '/usr/bin/bun',
+      autostartInstalled: false,
+    });
+
+    expect(script).toContain("@usejarvis/brain");
+    expect(script).toContain('/tmp/bin/jarvis');
+    expect(script).toContain('/usr/bin/bun');
+  });
+});

package/src/cli/uninstall.ts

@@ -0,0 +1,202 @@
+import { spawn } from 'node:child_process';
+import { existsSync, mkdtempSync, writeFileSync } from 'node:fs';
+import { homedir, tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { closeRL, ask, askYesNo, c } from './helpers.ts';
+import { isLocked, releaseLock } from '../daemon/pid.ts';
+import { getAutostartName, isAutostartInstalled, uninstallAutostart } from './autostart.ts';
+
+const PACKAGE_ROOT = join(import.meta.dir, '..', '..');
+const JARVIS_HOME = join(homedir(), '.jarvis');
+const GLOBAL_BUN_ROOT = join(homedir(), '.bun', 'install', 'global');
+const CLI_WRAPPER_CANDIDATES = [
+  join(homedir(), '.bun', 'bin', 'jarvis'),
+  join(homedir(), '.bun', 'bin', 'jarvis.cmd'),
+  join(homedir(), '.bun', 'bin', 'jarvis.ps1'),
+];
+
+type CleanupPlan = {
+  dataDir: string;
+  packageRoot: string;
+  removablePaths: string[];
+  cliWrapperPaths: string[];
+  bunPath: string;
+  autostartInstalled: boolean;
+};
+
+function normalizePath(path: string): string {
+  const resolved = resolve(path);
+  return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+}
+
+function isWithinPath(candidate: string, parent: string): boolean {
+  const normalizedCandidate = normalizePath(candidate);
+  const normalizedParent = normalizePath(parent);
+  return normalizedCandidate === normalizedParent || normalizedCandidate.startsWith(`${normalizedParent}${process.platform === 'win32' ? '\\' : '/'}`);
+}
+
+function uniqueSortedPaths(paths: string[]): string[] {
+  const unique = Array.from(new Set(paths.map((path) => resolve(path))));
+  return unique.sort((left, right) => right.length - left.length);
+}
+
+export function createCleanupPlan(packageRoot = PACKAGE_ROOT): CleanupPlan {
+  const resolvedPackageRoot = resolve(packageRoot);
+  const removablePaths = [JARVIS_HOME];
+
+  if (isWithinPath(resolvedPackageRoot, GLOBAL_BUN_ROOT) || isWithinPath(resolvedPackageRoot, JARVIS_HOME)) {
+    removablePaths.push(resolvedPackageRoot);
+  }
+
+  return {
+    dataDir: JARVIS_HOME,
+    packageRoot: resolvedPackageRoot,
+    removablePaths: uniqueSortedPaths(removablePaths),
+    cliWrapperPaths: CLI_WRAPPER_CANDIDATES.filter((path) => existsSync(path)),
+    bunPath: Bun.which('bun') ?? 'bun',
+    autostartInstalled: isAutostartInstalled(),
+  };
+}
+
+export function buildCleanupScript(plan: CleanupPlan): string {
+  const payload = JSON.stringify({
+    removablePaths: plan.removablePaths,
+    cliWrapperPaths: plan.cliWrapperPaths,
+    bunPath: plan.bunPath,
+  });
+
+  return `import { rmSync, unlinkSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { setTimeout as sleep } from 'node:timers/promises';
+
+const payload = ${payload};
+
+function removePath(path) {
+  try {
+    rmSync(path, { recursive: true, force: true });
+  } catch {}
+}
+
+function unlinkPath(path) {
+  try {
+    unlinkSync(path);
+  } catch {
+    removePath(path);
+  }
+}
+
+await sleep(1500);
+
+for (const wrapperPath of payload.cliWrapperPaths) {
+  unlinkPath(wrapperPath);
+}
+
+try {
+  spawnSync(payload.bunPath, ['uninstall', '-g', '@usejarvis/brain'], {
+    stdio: 'ignore',
+    env: { ...process.env },
+  });
+} catch {}
+
+for (const target of payload.removablePaths) {
+  removePath(target);
+}
+`;
+}
+
+async function stopDaemonIfRunning(): Promise<void> {
+  const pid = isLocked();
+  if (!pid) return;
+
+  console.log(c.dim(`Stopping daemon (PID ${pid})...`));
+  try {
+    process.kill(pid, 'SIGTERM');
+
+    let alive = true;
+    for (let i = 0; i < 10; i += 1) {
+      await new Promise((resolve) => setTimeout(resolve, 500));
+      try {
+        process.kill(pid, 0);
+      } catch {
+        alive = false;
+        break;
+      }
+    }
+
+    if (alive) {
+      try {
+        process.kill(pid, 'SIGKILL');
+      } catch {}
+    }
+  } catch {}
+
+  releaseLock();
+}
+
+async function scheduleCleanup(plan: CleanupPlan): Promise<void> {
+  const tempDir = mkdtempSync(join(tmpdir(), 'jarvis-uninstall-'));
+  const scriptPath = join(tempDir, 'cleanup.mjs');
+  writeFileSync(scriptPath, buildCleanupScript(plan), 'utf-8');
+
+  const child = spawn(plan.bunPath, [scriptPath], {
+    detached: true,
+    stdio: 'ignore',
+    env: { ...process.env },
+  });
+  child.unref();
+}
+
+export async function runUninstallWizard(packageRoot = PACKAGE_ROOT): Promise<void> {
+  const plan = createCleanupPlan(packageRoot);
+
+  console.log(c.red('\nJARVIS Uninstall Wizard\n'));
+  console.log('This will remove JARVIS from this machine.');
+  console.log(c.dim('\nPlanned removal:'));
+  console.log(c.dim(`  • Data directory: ${plan.dataDir}`));
+
+  if (plan.autostartInstalled) {
+    console.log(c.dim(`  • Autostart: ${getAutostartName()}`));
+  }
+
+  if (plan.cliWrapperPaths.length > 0) {
+    for (const wrapperPath of plan.cliWrapperPaths) {
+      console.log(c.dim(`  • CLI wrapper: ${wrapperPath}`));
+    }
+  }
+
+  for (const target of plan.removablePaths) {
+    if (target !== plan.dataDir) {
+      console.log(c.dim(`  • Managed install: ${target}`));
+    }
+  }
+
+  console.log(c.dim('\nSidecars are separate installs and will not be removed.\n'));
+
+  const proceed = await askYesNo('Continue with complete uninstall?', false);
+  if (!proceed) {
+    console.log(c.yellow('\nUninstall cancelled.'));
+    closeRL();
+    return;
+  }
+
+  const confirmation = await ask('Type UNINSTALL to confirm');
+  if (confirmation !== 'UNINSTALL') {
+    console.log(c.yellow('\nConfirmation did not match. Uninstall cancelled.'));
+    closeRL();
+    return;
+  }
+
+  closeRL();
+
+  await stopDaemonIfRunning();
+
+  if (plan.autostartInstalled) {
+    console.log(c.dim(`Removing ${getAutostartName()}...`));
+    await uninstallAutostart();
+  }
+
+  await scheduleCleanup(plan);
+
+  console.log(c.green('\nJARVIS uninstall scheduled.'));
+  console.log(c.dim('Background cleanup will finish in a moment and remove the CLI wrapper.'));
+}

package/src/comms/README.md

@@ -0,0 +1,329 @@
+# J.A.R.V.I.S. Communication Layer
+
+The communication layer provides multi-channel messaging, WebSocket-based real-time communication, LLM response streaming, and voice I/O capabilities.
+
+## Architecture
+
+```
+comms/
+├── websocket.ts       # Local WebSocket server using Bun.serve()
+├── streaming.ts       # LLM stream relay to WebSocket clients
+├── voice.ts          # STT/TTS provider interfaces and stubs
+├── channels/         # Multi-platform messaging adapters
+│   ├── telegram.ts   # ✅ Telegram Bot API (fully functional)
+│   ├── whatsapp.ts   # 🚧 WhatsApp Business API (stub)
+│   ├── discord.ts    # 🚧 Discord Bot (stub)
+│   └── signal.ts     # 🚧 Signal CLI (stub)
+└── index.ts          # ChannelManager and exports
+```
+
+## Core Components
+
+### 1. WebSocket Server
+
+Real-time bidirectional communication with web clients.
+
+```typescript
+import { WebSocketServer } from './comms';
+
+const wsServer = new WebSocketServer(3142);
+
+wsServer.setHandler({
+  async onMessage(msg) {
+    console.log('Received:', msg.type, msg.payload);
+    return { type: 'status', payload: 'Acknowledged', timestamp: Date.now() };
+  },
+  onConnect() {
+    console.log('Client connected');
+  },
+  onDisconnect() {
+    console.log('Client disconnected');
+  },
+});
+
+wsServer.start();
+```
+
+**Endpoints:**
+- `ws://localhost:3142/ws` - WebSocket connection
+- `http://localhost:3142/health` - Health check
+- `http://localhost:3142/` - Server info
+
+**Message Types:**
+```typescript
+type WSMessage = {
+  type: 'chat' | 'command' | 'status' | 'stream' | 'error';
+  payload: unknown;
+  id?: string;
+  timestamp: number;
+};
+```
+
+### 2. Stream Relay
+
+Relays LLM streaming responses to connected WebSocket clients in real-time.
+
+```typescript
+import { StreamRelay, WebSocketServer } from './comms';
+
+const wsServer = new WebSocketServer();
+wsServer.start();
+
+const relay = new StreamRelay(wsServer);
+
+// Relay LLM stream to all connected clients
+const stream = llmProvider.generateStream(prompt);
+const fullResponse = await relay.relayStream(stream, 'request-123');
+```
+
+Clients receive incremental updates:
+```json
+{
+  "type": "stream",
+  "payload": {
+    "text": "chunk of text",
+    "requestId": "request-123",
+    "accumulated": "full text so far"
+  },
+  "timestamp": 1708645200000
+}
+```
+
+### 3. Channel Manager
+
+Unified interface for managing multiple messaging platforms.
+
+```typescript
+import { ChannelManager, TelegramAdapter } from './comms';
+
+const manager = new ChannelManager();
+
+// Register Telegram
+const telegram = new TelegramAdapter(process.env.TELEGRAM_BOT_TOKEN!);
+manager.register(telegram);
+
+// Set unified message handler
+manager.setHandler(async (message) => {
+  console.log(`[${message.channel}] ${message.from}: ${message.text}`);
+  return `Received: ${message.text}`;
+});
+
+// Connect all channels
+await manager.connectAll();
+
+// Check status
+console.log(manager.getStatus()); // { telegram: true }
+```
+
+### 4. Telegram Adapter (Functional)
+
+Full implementation using Telegram Bot API with long polling.
+
+```typescript
+import { TelegramAdapter } from './comms/channels/telegram';
+
+const telegram = new TelegramAdapter(process.env.TELEGRAM_BOT_TOKEN!);
+
+telegram.onMessage(async (message) => {
+  console.log(`Message from ${message.from}: ${message.text}`);
+  return `Echo: ${message.text}`;
+});
+
+await telegram.connect();
+
+// Send message
+await telegram.sendMessage('CHAT_ID', 'Hello from J.A.R.V.I.S.!');
+```
+
+**Setup:**
+1. Create bot via [@BotFather](https://t.me/botfather)
+2. Get bot token
+3. Set `TELEGRAM_BOT_TOKEN` environment variable
+
+### 5. Voice I/O (Stubs)
+
+Speech-to-Text and Text-to-Speech provider interfaces.
+
+```typescript
+import { WhisperSTT, LocalTTS } from './comms';
+
+// STT - requires whisper.cpp setup
+const stt = new WhisperSTT('http://localhost:8080');
+// const text = await stt.transcribe(audioBuffer);
+
+// TTS - requires ElevenLabs API or local TTS
+const tts = new LocalTTS({ provider: 'elevenlabs', apiKey: '...' });
+// const audio = await tts.synthesize('Hello world');
+```
+
+## Message Flow
+
+### Incoming Message Flow
+```
+Telegram/Discord/etc
+    ↓
+ChannelAdapter.onMessage()
+    ↓
+ChannelHandler (unified)
+    ↓
+Business logic (in daemon)
+    ↓
+WebSocketServer.broadcast()
+    ↓
+All connected web clients
+```
+
+### LLM Streaming Flow
+```
+LLM Provider stream
+    ↓
+StreamRelay.relayStream()
+    ↓
+WebSocketServer.broadcast()
+    ↓
+Real-time updates to clients
+```
+
+## Running Examples
+
+### Start WebSocket Server Only
+```bash
+bun run src/comms/example.ts
+```
+
+### With Telegram Integration
+```bash
+export TELEGRAM_BOT_TOKEN="your_bot_token"
+bun run src/comms/example.ts
+```
+
+### Run Tests
+```bash
+bun test src/comms/websocket.test.ts
+bun test src/comms/channels.test.ts
+```
+
+## Environment Variables
+
+```bash
+# Required for Telegram
+TELEGRAM_BOT_TOKEN=1234567890:ABCdefGHIjklMNOpqrsTUVwxyz
+
+# Future integrations
+WHATSAPP_PHONE_ID=...
+WHATSAPP_ACCESS_TOKEN=...
+DISCORD_BOT_TOKEN=...
+SIGNAL_PHONE=+1234567890
+ELEVENLABS_API_KEY=...
+```
+
+## Channel Adapter Interface
+
+All channel adapters implement this interface:
+
+```typescript
+interface ChannelAdapter {
+  name: string;
+  connect(): Promise<void>;
+  disconnect(): Promise<void>;
+  sendMessage(to: string, text: string): Promise<void>;
+  onMessage(handler: ChannelHandler): void;
+  isConnected(): boolean;
+}
+
+type ChannelMessage = {
+  id: string;
+  channel: string;
+  from: string;
+  text: string;
+  timestamp: number;
+  metadata: Record<string, unknown>;
+};
+
+type ChannelHandler = (message: ChannelMessage) => Promise<string>;
+```
+
+## Future Channel Implementations
+
+### WhatsApp
+- Requires WhatsApp Business API setup
+- Webhook-based architecture
+- See: https://developers.facebook.com/docs/whatsapp/cloud-api
+
+### Discord
+- Use Discord Gateway WebSocket or discord.js
+- Support slash commands
+- See: https://discord.com/developers/docs
+
+### Signal
+- Requires signal-cli in daemon mode
+- Local installation needed
+- See: https://github.com/AsamK/signal-cli
+
+## Integration with J.A.R.V.I.S. Daemon
+
+```typescript
+// In daemon/index.ts
+import { WebSocketServer, ChannelManager, TelegramAdapter, StreamRelay } from './comms';
+import { LLMRouter } from './llm';
+
+const wsServer = new WebSocketServer();
+const channels = new ChannelManager();
+const streamRelay = new StreamRelay(wsServer);
+const llmRouter = new LLMRouter();
+
+// Unified message handler
+channels.setHandler(async (message) => {
+  // Route to appropriate LLM provider
+  const stream = await llmRouter.route(message.text, { stream: true });
+
+  // Relay stream to WebSocket clients
+  const response = await streamRelay.relayStream(stream, message.id);
+
+  // Return response to original channel
+  return response;
+});
+
+// Start everything
+wsServer.start();
+if (process.env.TELEGRAM_BOT_TOKEN) {
+  channels.register(new TelegramAdapter(process.env.TELEGRAM_BOT_TOKEN));
+}
+await channels.connectAll();
+```
+
+## Performance Considerations
+
+- **WebSocket**: Bun's native WebSocket support is extremely fast
+- **Telegram Polling**: Uses long polling (30s timeout) to minimize requests
+- **Stream Relay**: Zero-copy broadcast to multiple clients
+- **Memory**: Each WebSocket connection uses ~1KB of memory
+
+## Security Notes
+
+- **WebSocket**: Currently no authentication - add JWT or session tokens for production
+- **Channel Tokens**: Store in environment variables, never commit
+- **Rate Limiting**: Implement on message handlers to prevent abuse
+- **Input Validation**: Always sanitize user input before processing
+
+## Troubleshooting
+
+### WebSocket Connection Failed
+- Check port 3142 is not in use: `lsof -i :3142`
+- Verify firewall allows connections
+- Check CORS if connecting from browser
+
+### Telegram Not Receiving Messages
+- Verify bot token is correct
+- Check bot is not blocked
+- Ensure polling is active: check logs for "Starting polling"
+- Test with `/health` endpoint
+
+### Stream Not Broadcasting
+- Verify WebSocket clients are connected: check `/health`
+- Ensure LLM stream implements AsyncIterable<LLMStreamEvent>
+- Check client WebSocket listeners are set up
+
+## API Reference
+
+See inline TypeScript documentation in each module for detailed API reference.

package/src/comms/auth-error.html

@@ -0,0 +1,48 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <!--
+    Auth error page — if ?token= is inside the hash (e.g. /#/settings?token=xxx),
+    move it into the query string so the server can set the cookie via Set-Cookie + 302.
+  -->
+  <script>
+    (function () {
+      var h = location.hash;
+      var qi = h.indexOf('?');
+      if (qi !== -1) {
+        var hp = new URLSearchParams(h.slice(qi));
+        var t = hp.get('token');
+        if (t) {
+          hp.delete('token');
+          var cleanHash = h.slice(0, qi);
+          var remaining = hp.toString();
+          if (remaining) cleanHash += '?' + remaining;
+          location.replace(location.pathname + '?token=' + encodeURIComponent(t) + cleanHash);
+        }
+      }
+    })();
+  </script>
+  <title>Unauthorized</title>
+  <style>
+    body {
+      font-family: system-ui;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      height: 100vh;
+      margin: 0;
+      background: #111;
+      color: #ccc;
+    }
+    .box { text-align: center }
+    h1 { font-size: 4rem; margin: 0; color: #666 }
+    p { margin-top: 1rem }
+  </style>
+</head>
+<body>
+  <div class="box">
+    <h1>401</h1>
+    <p>Access requires a valid token.</p>
+  </div>
+</body>
+</html>