bridge-agent 0.1.0-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Jerico
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,67 @@
+# bridge-agent
+
+Bridge local agent — connects your AI tools to Jerico
+
+## Installation
+
+```bash
+npm install -g bridge-agent
+```
+
+## Usage
+
+### 1. Authenticate
+
+Get a token from your Jerico server (Settings → Daemon Tokens), then:
+
+```bash
+bridge-agent auth --server https://your-server.com --token YOUR_TOKEN
+```
+
+Or with interactive browser flow:
+
+```bash
+bridge-agent auth --server https://your-server.com
+```
+
+### 2. Start the Daemon
+
+```bash
+bridge-agent start
+```
+
+The daemon will:
+- Connect to your Jerico server via WebSocket
+- Detect installed AI agents (Claude, Qwen, Kimi, etc.)
+- Allow spawning terminals from the web interface
+
+### 3. Check Status
+
+```bash
+bridge-agent status
+```
+
+## Supported Agents
+
+- **Claude Code** (`claude`) - Requires `claude` CLI
+- **Qwen CLI** (`qwen`) - Requires `qwen` CLI  
+- **Kimi Code** (`kimi`) - Requires `kimi` CLI
+- **Codex CLI** (`codex`) - Requires `codex` CLI
+- **Gemini** (`gemini`) - Requires `gemini` CLI
+- **Ollama** (`ollama`) - Requires `ollama`
+- **Aider** (`aider`) - Requires `aider`
+- **Shell** (`sh`) - System shell (always available)
+
+## Configuration
+
+Config is stored in:
+- macOS/Linux: `~/.bridge/config.json` or `~/.jerico/settings.json`
+
+## Requirements
+
+- Node.js >= 20
+- For each AI agent: the respective CLI tool installed and authenticated
+
+## License
+
+MIT

package/dist/commands/auth.d.ts

@@ -0,0 +1 @@
+export declare function runAuth(serverUrl: string, noBrowser?: boolean, providedToken?: string): Promise<void>;

package/dist/commands/auth.js

@@ -0,0 +1,87 @@
+import https from 'https';
+import http from 'http';
+import { saveConfig } from '../config.js';
+function sanitizeToken(raw) {
+    return (raw ?? '').trim();
+}
+export async function runAuth(serverUrl, noBrowser = false, providedToken) {
+    console.log('[bridge] Starting auth flow...');
+    console.log(`[bridge] Server: ${serverUrl}`);
+    console.log('[bridge] Open this URL to generate a daemon token:');
+    console.log(`  ${serverUrl}/connect`);
+    const inlineToken = sanitizeToken(providedToken);
+    if (inlineToken) {
+        console.log('[bridge] Using token from --token');
+    }
+    if (noBrowser) {
+        if (inlineToken) {
+            console.log('[bridge] --no-browser ignored because --token is provided.');
+        }
+        else {
+            console.log('[bridge] --no-browser: exiting after printing URL.');
+            process.exit(0);
+        }
+    }
+    let token = inlineToken;
+    if (!token) {
+        console.log();
+        console.log('[bridge] After authenticating, paste your token here:');
+        token = await promptToken();
+    }
+    if (!token) {
+        console.error('[bridge] No token provided. Exiting.');
+        process.exit(1);
+    }
+    // Validate token with server
+    const isValid = await validateToken(serverUrl, token);
+    if (!isValid) {
+        console.error('[bridge] Token validation failed. Please try again.');
+        process.exit(1);
+    }
+    const wsBase = serverUrl.replace(/^https?:\/\//, (match) => match.startsWith('https') ? 'wss://' : 'ws://');
+    const wsUrl = wsBase.replace(/\/?$/, '/ws/daemon');
+    saveConfig({
+        server: wsUrl,
+        token,
+        name: process.env['HOSTNAME'] ?? 'My Machine',
+    });
+    console.log('[bridge] Auth successful! Config saved to ~/.bridge/config.json');
+    console.log('[bridge] Run: bridge-agent start');
+}
+async function promptToken() {
+    return new Promise(resolve => {
+        process.stdout.write('Token: ');
+        let input = '';
+        process.stdin.setEncoding('utf-8');
+        process.stdin.on('data', (chunk) => {
+            input += chunk;
+            if (input.includes('\n')) {
+                process.stdin.pause();
+                resolve(input.trim());
+            }
+        });
+        process.stdin.resume();
+    });
+}
+async function validateToken(serverUrl, token) {
+    return new Promise(resolve => {
+        const url = new URL('/api/tokens/validate', serverUrl);
+        const isHttps = url.protocol === 'https:';
+        const lib = isHttps ? https : http;
+        const options = {
+            hostname: url.hostname,
+            port: url.port || (isHttps ? 443 : 80),
+            path: url.pathname,
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${token}`,
+            },
+        };
+        const req = lib.request(options, (res) => {
+            resolve(res.statusCode === 200);
+        });
+        req.on('error', () => resolve(false));
+        req.end();
+    });
+}

package/dist/commands/start.d.ts

@@ -0,0 +1 @@
+export declare function runStart(): void;

package/dist/commands/start.js

@@ -0,0 +1,21 @@
+import { createServer } from 'node:http';
+import { PtyManager } from '../pty/manager.js';
+import { startDaemonConnection, isDaemonWsConnected } from '../ws/client.js';
+export function runStart() {
+    console.log('[bridge] Starting bridge-agent daemon...');
+    const manager = new PtyManager();
+    startDaemonConnection(manager);
+    const healthPort = parseInt(process.env['HEALTH_PORT'] ?? '3101', 10);
+    const health = createServer((_, res) => {
+        const connected = isDaemonWsConnected();
+        const body = JSON.stringify({ status: 'ok', connected, uptime: process.uptime() });
+        res.writeHead(connected ? 200 : 503, { 'Content-Type': 'application/json' });
+        res.end(body);
+    });
+    health.listen(healthPort, '127.0.0.1', () => {
+        console.log(`[bridge] health check listening on 127.0.0.1:${healthPort}`);
+    });
+    health.on('error', (err) => {
+        console.error('[bridge] health.server.error', { error: err.message });
+    });
+}

package/dist/config.d.ts

@@ -0,0 +1,21 @@
+export interface BridgeConfig {
+    server: string;
+    token: string;
+    name: string;
+}
+/** Project-level settings from .jerico/settings.json in cwd */
+export interface ProjectSettings {
+    /** Override the agent binary to prefer in this project */
+    preferredAgent?: string;
+    /** Shell hooks — see lifecycle hooks (ISSUE 7) */
+    hooks?: Record<string, string>;
+    /** Additional env vars injected into spawned agents in this project */
+    env?: Record<string, string>;
+}
+export declare function loadConfig(): BridgeConfig;
+export declare function saveConfig(config: BridgeConfig): void;
+/**
+ * Load project-level settings from .jerico/settings.json in the given directory (or cwd).
+ * Returns empty object if the file does not exist or fails to parse.
+ */
+export declare function loadProjectSettings(cwd?: string): ProjectSettings;

package/dist/config.js

@@ -0,0 +1,76 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+/** New global path; legacy ~/.bridge/config.json is still supported as fallback */
+const JERICO_CONFIG_PATH = path.join(os.homedir(), '.jerico', 'settings.json');
+const CONFIG_PATH = path.join(os.homedir(), '.bridge', 'config.json');
+export function loadConfig() {
+    // Prefer new ~/.jerico/settings.json; fall back to legacy ~/.bridge/config.json
+    const configPath = fs.existsSync(JERICO_CONFIG_PATH) ? JERICO_CONFIG_PATH : CONFIG_PATH;
+    if (!fs.existsSync(configPath)) {
+        console.error('[bridge] Config not found. Run: bridge-agent auth');
+        process.exit(1);
+    }
+    const raw = fs.readFileSync(configPath, 'utf-8');
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        console.error('[bridge] Invalid config file at', CONFIG_PATH);
+        process.exit(1);
+    }
+    if (!parsed || typeof parsed !== 'object') {
+        console.error('[bridge] Config must be a JSON object. Run: bridge-agent auth');
+        process.exit(1);
+    }
+    const obj = parsed;
+    const server = typeof obj['server'] === 'string' ? obj['server'] : '';
+    const token = typeof obj['token'] === 'string' ? obj['token'] : '';
+    const name = typeof obj['name'] === 'string' ? obj['name'] : 'bridge-agent';
+    if (!server || !token) {
+        console.error('[bridge] Config missing server or token. Run: bridge-agent auth');
+        process.exit(1);
+    }
+    return { server, token, name };
+}
+export function saveConfig(config) {
+    // Always write to new ~/.jerico path
+    const dir = path.dirname(JERICO_CONFIG_PATH);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(JERICO_CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+/**
+ * Load project-level settings from .jerico/settings.json in the given directory (or cwd).
+ * Returns empty object if the file does not exist or fails to parse.
+ */
+export function loadProjectSettings(cwd) {
+    const settingsPath = path.join(cwd ?? process.cwd(), '.jerico', 'settings.json');
+    if (!fs.existsSync(settingsPath))
+        return {};
+    try {
+        const raw = fs.readFileSync(settingsPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            return {};
+        const obj = parsed;
+        const result = {};
+        if (typeof obj['preferredAgent'] === 'string')
+            result.preferredAgent = obj['preferredAgent'];
+        if (obj['hooks'] && typeof obj['hooks'] === 'object' && !Array.isArray(obj['hooks'])) {
+            result.hooks = Object.fromEntries(Object.entries(obj['hooks'])
+                .filter(([, v]) => typeof v === 'string'));
+        }
+        if (obj['env'] && typeof obj['env'] === 'object' && !Array.isArray(obj['env'])) {
+            result.env = Object.fromEntries(Object.entries(obj['env'])
+                .filter(([, v]) => typeof v === 'string'));
+        }
+        return result;
+    }
+    catch {
+        console.warn('[bridge] Failed to parse .jerico/settings.json, ignoring');
+        return {};
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};