overarch-linux-arm64 0.8.0

package/dist/src/companion/petdex_bridge.js

@@ -0,0 +1,356 @@
+import * as http from 'node:http';
+import * as path from 'node:path';
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import { spawn } from 'node:child_process';
+import { petdexAdapter } from './petdex_adapter.js';
+export const STATE_TO_PETDEX_TRIGGER = {
+    idle: 'idle',
+    thinking: 'focus',
+    reading: 'reading',
+    searching: 'searching',
+    editing: 'typing',
+    executing: 'running',
+    testing: 'testing',
+    waiting: 'waiting',
+    awaiting_approval: 'waiting',
+    success: 'celebrate',
+    warning: 'alert',
+    error: 'alert',
+    paused: 'sleep',
+    stopped: 'sleep',
+    offline: 'sleep',
+};
+export class PetdexBridge {
+    server = null;
+    sseClients = new Set();
+    currentState = 'idle';
+    currentMessage = '';
+    activePet = 'savage-codex-hacker';
+    port = 45731;
+    externalHookPort = 7777;
+    isRunning = false;
+    companionProcess = null;
+    constructor(options) {
+        if (options?.port)
+            this.port = options.port;
+        if (options?.externalHookPort)
+            this.externalHookPort = options.externalHookPort;
+    }
+    /**
+     * Starts local SSE / HTTP bridge server (unref'd so it does not block Node process exit)
+     */
+    start() {
+        if (this.isRunning && this.server) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+            try {
+                this.server = http.createServer((req, res) => {
+                    this.handleRequest(req, res);
+                });
+                this.server.on('error', (_err) => {
+                    this.isRunning = false;
+                    resolve();
+                });
+                this.server.listen(this.port, '127.0.0.1', () => {
+                    this.isRunning = true;
+                    this.server?.unref();
+                    resolve();
+                });
+            }
+            catch {
+                resolve();
+            }
+        });
+    }
+    handleRequest(req, res) {
+        const url = new URL(req.url || '/', `http://${req.headers.host || '127.0.0.1'}`);
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+        if (req.method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        // SSE endpoint: /events
+        if (url.pathname === '/events' && req.method === 'GET') {
+            res.writeHead(200, {
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache, no-transform',
+                Connection: 'keep-alive',
+            });
+            res.write(`: connected to Overarch Petdex Companion Bridge\n\n`);
+            this.sseClients.add(res);
+            const rowMapping = petdexAdapter.mapStateToAnimationRow(this.currentState);
+            const initialPayload = {
+                event: 'state_change',
+                data: {
+                    state: this.currentState,
+                    petdexTrigger: STATE_TO_PETDEX_TRIGGER[this.currentState] || 'idle',
+                    animationRow: rowMapping.row,
+                    message: this.currentMessage,
+                    pet: this.activePet,
+                    timestamp: new Date().toISOString(),
+                },
+            };
+            res.write(`data: ${JSON.stringify(initialPayload)}\n\n`);
+            req.on('close', () => {
+                this.sseClients.delete(res);
+            });
+            return;
+        }
+        // JSON status endpoint: /state or /companion/status
+        if ((url.pathname === '/state' || url.pathname === '/companion/status') && req.method === 'GET') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                active: true,
+                state: this.currentState,
+                petdexTrigger: STATE_TO_PETDEX_TRIGGER[this.currentState] || 'idle',
+                animationRow: petdexAdapter.mapStateToAnimationRow(this.currentState).row,
+                message: this.currentMessage,
+                pet: this.activePet,
+                activePet: this.activePet,
+                clientsConnected: this.sseClients.size,
+                port: this.port,
+            }));
+            return;
+        }
+        // Discovered pets endpoint: /pets or /companion/pets
+        if ((url.pathname === '/pets' || url.pathname === '/companion/pets') && req.method === 'GET') {
+            petdexAdapter.listPets().then((pets) => {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ activePet: this.activePet, pets }));
+            });
+            return;
+        }
+        // Select active companion pet: POST /select or /companion/select
+        if ((url.pathname === '/select' || url.pathname === '/companion/select') && req.method === 'POST') {
+            let body = '';
+            req.on('data', (chunk) => (body += chunk));
+            req.on('end', () => {
+                try {
+                    const parsed = JSON.parse(body || '{}');
+                    if (parsed.pet) {
+                        this.activePet = String(parsed.pet);
+                        const rowMapping = petdexAdapter.mapStateToAnimationRow(this.currentState);
+                        this.broadcast('pet_selected', {
+                            state: this.currentState,
+                            petdexTrigger: STATE_TO_PETDEX_TRIGGER[this.currentState] || 'idle',
+                            animationRow: rowMapping.row,
+                            pet: this.activePet,
+                            timestamp: new Date().toISOString(),
+                        });
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ success: true, activePet: this.activePet }));
+                        return;
+                    }
+                }
+                catch { }
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Missing or invalid pet name in payload' }));
+            });
+            return;
+        }
+        // Install Petdex pet endpoint: POST /companion/install
+        if (url.pathname === '/companion/install' && req.method === 'POST') {
+            let body = '';
+            req.on('data', (chunk) => (body += chunk));
+            req.on('end', async () => {
+                try {
+                    const parsed = JSON.parse(body || '{}');
+                    if (parsed.slug) {
+                        const installRes = await petdexAdapter.installPet(parsed.slug);
+                        res.writeHead(installRes.success ? 200 : 500, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify(installRes));
+                        return;
+                    }
+                }
+                catch { }
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Missing slug' }));
+            });
+            return;
+        }
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Not found' }));
+    }
+    /**
+     * Broadcast state change to SSE subscribers and notify external hook port if present
+     */
+    broadcastState(state, message) {
+        this.currentState = state;
+        if (message !== undefined) {
+            this.currentMessage = message;
+        }
+        const trigger = STATE_TO_PETDEX_TRIGGER[state] || 'idle';
+        const rowMapping = petdexAdapter.mapStateToAnimationRow(state);
+        const payload = {
+            event: 'state_change',
+            data: {
+                state,
+                petdexTrigger: trigger,
+                animationRow: rowMapping.row,
+                message: this.currentMessage,
+                pet: this.activePet,
+                timestamp: new Date().toISOString(),
+            },
+        };
+        const dataStr = `data: ${JSON.stringify(payload)}\n\n`;
+        for (const client of this.sseClients) {
+            try {
+                client.write(dataStr);
+            }
+            catch {
+                this.sseClients.delete(client);
+            }
+        }
+        this.notifyExternalPetdexHook(payload);
+    }
+    broadcast(event, data) {
+        const payload = { event, data };
+        const dataStr = `data: ${JSON.stringify(payload)}\n\n`;
+        for (const client of this.sseClients) {
+            try {
+                client.write(dataStr);
+            }
+            catch {
+                this.sseClients.delete(client);
+            }
+        }
+        this.notifyExternalPetdexHook(payload);
+    }
+    /**
+     * Non-blocking, error-tolerant notification to standard Petdex hook port 7777
+     */
+    notifyExternalPetdexHook(payload) {
+        const postData = JSON.stringify(payload);
+        const req = http.request({
+            hostname: '127.0.0.1',
+            port: this.externalHookPort,
+            path: '/events',
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(postData),
+            },
+            timeout: 60,
+        }, (res) => {
+            res.resume();
+        });
+        req.on('error', () => {
+            // Gracefully silent when external hook server is not running
+        });
+        req.on('timeout', () => {
+            req.destroy();
+        });
+        req.write(postData);
+        req.end();
+    }
+    /**
+     * Discovers Petdex-compatible pets
+     */
+    async discoverPets() {
+        return petdexAdapter.listPets();
+    }
+    /**
+     * Launches native Overarch desktop companion (or external Petdex app if present)
+     */
+    async launchCompanion(cwd = process.cwd()) {
+        // Check candidate paths for OverarchCompanion.exe
+        const companionCandidates = [
+            path.join(cwd, 'dist-desktop', 'OverarchCompanion.exe'),
+            path.join(path.dirname(process.execPath), 'OverarchCompanion.exe'),
+            path.join(os.homedir(), '.overarch', 'bin', 'OverarchCompanion.exe'),
+        ];
+        let binaryPath = null;
+        for (const candidate of companionCandidates) {
+            try {
+                await fs.access(candidate);
+                binaryPath = candidate;
+                break;
+            }
+            catch { }
+        }
+        if (binaryPath) {
+            try {
+                const proc = spawn(binaryPath, [`--bridge=http://127.0.0.1:${this.port}`, `--pet=${this.activePet}`], {
+                    detached: true,
+                    stdio: 'ignore',
+                });
+                proc.unref();
+                this.companionProcess = proc;
+                return {
+                    success: true,
+                    message: `Launched Overarch Desktop Companion (${this.activePet}) connected to bridge port ${this.port}.`,
+                };
+            }
+            catch (err) {
+                return { success: false, message: `Failed to launch ${binaryPath}: ${err.message}` };
+            }
+        }
+        // Fallback: try petdex CLI or desktop
+        return new Promise((resolve) => {
+            const proc = spawn(`petdex start --bridge http://127.0.0.1:${this.port}`, {
+                detached: true,
+                stdio: 'ignore',
+                shell: true,
+            });
+            proc.on('error', () => {
+                resolve({
+                    success: false,
+                    message: 'OverarchCompanion.exe not found in dist-desktop/ and external petdex not in PATH.',
+                });
+            });
+            proc.unref();
+            setTimeout(() => {
+                resolve({
+                    success: true,
+                    message: `Dispatched launch to companion bridge (listening on http://127.0.0.1:${this.port}/events).`,
+                });
+            }, 120);
+        });
+    }
+    getActivePet() {
+        return this.activePet;
+    }
+    setActivePet(pet) {
+        this.activePet = pet;
+        const rowMapping = petdexAdapter.mapStateToAnimationRow(this.currentState);
+        this.broadcast('pet_selected', {
+            state: this.currentState,
+            petdexTrigger: STATE_TO_PETDEX_TRIGGER[this.currentState] || 'idle',
+            animationRow: rowMapping.row,
+            pet: this.activePet,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    getStatus() {
+        return {
+            running: this.isRunning,
+            port: this.port,
+            connectedClients: this.sseClients.size,
+            activePet: this.activePet,
+            state: this.currentState,
+        };
+    }
+    stop() {
+        for (const client of this.sseClients) {
+            try {
+                client.end();
+            }
+            catch { }
+        }
+        this.sseClients.clear();
+        if (this.server) {
+            try {
+                this.server.close();
+            }
+            catch { }
+            this.server = null;
+        }
+        this.isRunning = false;
+    }
+}
+export const petdexBridge = new PetdexBridge();

package/dist/src/companion/types.d.ts

@@ -0,0 +1,57 @@
+export type AgentState = 'idle' | 'thinking' | 'reading' | 'searching' | 'editing' | 'executing' | 'testing' | 'waiting' | 'awaiting_approval' | 'success' | 'warning' | 'error' | 'paused' | 'stopped' | 'offline';
+export type MissionState = AgentState;
+export interface PetdexManifest {
+    id: string;
+    displayName: string;
+    description?: string;
+    spritesheetPath?: string;
+    spriteVersionNumber?: 1 | 2;
+    author?: string;
+    version?: string;
+}
+export interface CompanionPetInfo {
+    id: string;
+    displayName: string;
+    description: string;
+    source: 'petdex-installed' | 'petdex-gallery' | 'local';
+    spritesheetPath?: string;
+    spritesheetFormat: 'webp' | 'png';
+    spriteVersionNumber: 1 | 2;
+    columns: number;
+    rows: number;
+    frameWidth?: number;
+    frameHeight?: number;
+}
+export interface PetdexAnimationRowMapping {
+    idle: number;
+    runningRight: number;
+    runningLeft: number;
+    waving: number;
+    jumping: number;
+    failed: number;
+    waiting: number;
+    running: number;
+    review: number;
+}
+export declare const PETDEX_DEFAULT_ROW_MAPPING: PetdexAnimationRowMapping;
+export interface CompanionConfig {
+    enabled: boolean;
+    activePet: string;
+    position?: {
+        x: number;
+        y: number;
+    };
+    alwaysOnTop: boolean;
+    opacity: number;
+    scale: number;
+}
+export interface PetProvider {
+    id: string;
+    name: string;
+    listPets(): Promise<CompanionPetInfo[]>;
+    getPet(id: string): Promise<CompanionPetInfo | null>;
+    installPet?(slug: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+}

package/dist/src/companion/types.js

@@ -0,0 +1,11 @@
+export const PETDEX_DEFAULT_ROW_MAPPING = {
+    idle: 0,
+    runningRight: 1,
+    runningLeft: 2,
+    waving: 3,
+    jumping: 4,
+    failed: 5,
+    waiting: 6,
+    running: 7,
+    review: 8,
+};

package/dist/src/config/index.d.ts

@@ -0,0 +1,24 @@
+import { OverarchConfig, ResolvedConfig } from './types.js';
+export declare const DEFAULT_CONFIG: OverarchConfig;
+export declare function getConfigDir(): string;
+/**
+ * Load environment variables from .env file without external dependencies
+ */
+export declare function loadDotenv(cwd?: string): Promise<Record<string, string>>;
+/**
+ * Safely writes or updates an API key in the project's .env file.
+ * Automatically verifies and adds .env to .gitignore to prevent secret leaks.
+ */
+export declare function writeDotenvKey(cwd: string, keyName: string, keyValue: string): Promise<void>;
+/**
+ * Ensures an entry is present in the workspace .gitignore
+ */
+export declare function ensureGitignoreEntry(cwd: string, entry: string): Promise<void>;
+/**
+ * Auto-generates or verifies the .overarch project subsystem structure
+ */
+export declare function autoEnsureOverarch(cwd?: string): Promise<string>;
+export declare function loadConfig(): Promise<ResolvedConfig>;
+export declare function saveConfig(config: OverarchConfig, targetPath: string): Promise<void>;
+export declare function saveGlobalConfig(updates: Partial<OverarchConfig>): Promise<void>;
+export declare function getApiKey(provider: string, cwd?: string): string | undefined;

package/dist/src/config/index.js

@@ -0,0 +1,237 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { PermissionTier } from './types.js';
+export const DEFAULT_CONFIG = {
+    providers: {},
+    defaultModel: '',
+    mode: 'online',
+    agentMode: 'approval',
+    ponytail: 'full',
+    ccss: 'auto',
+    permissions: {
+        autoApprove: [PermissionTier.ReadOnly, PermissionTier.SafeMutation],
+        requireApproval: [PermissionTier.StateMutating, PermissionTier.Destructive],
+        deny: []
+    },
+    context: {
+        maxTokens: 100000,
+        maxFileSize: 1024 * 1024
+    },
+    project: {
+        include: [],
+        exclude: [],
+        instructions: ''
+    },
+    ui: {
+        accentColor: 'cyan',
+        avatar: '◆',
+        verbosity: 'normal',
+    },
+    onboarding: {
+        completed: false,
+        version: '0.3.0',
+    },
+};
+export function getConfigDir() {
+    return path.join(os.homedir(), '.overarch');
+}
+/**
+ * Load environment variables from .env file without external dependencies
+ */
+export async function loadDotenv(cwd = process.cwd()) {
+    const envVars = {};
+    const pathsToCheck = [
+        path.join(cwd, '.env'),
+        path.join(getConfigDir(), '.env')
+    ];
+    for (const p of pathsToCheck) {
+        try {
+            const content = await fs.readFile(p, 'utf8');
+            const lines = content.replace(/\r\n/g, '\n').split('\n');
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith('#'))
+                    continue;
+                const eqIdx = trimmed.indexOf('=');
+                if (eqIdx > 0) {
+                    const key = trimmed.slice(0, eqIdx).trim();
+                    let val = trimmed.slice(eqIdx + 1).trim();
+                    if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+                        val = val.slice(1, -1);
+                    }
+                    envVars[key] = val;
+                    if (!process.env[key]) {
+                        process.env[key] = val;
+                    }
+                }
+            }
+        }
+        catch { }
+    }
+    return envVars;
+}
+/**
+ * Safely writes or updates an API key in the project's .env file.
+ * Automatically verifies and adds .env to .gitignore to prevent secret leaks.
+ */
+export async function writeDotenvKey(cwd, keyName, keyValue) {
+    const envPath = path.join(cwd, '.env');
+    let lines = [];
+    try {
+        const existing = await fs.readFile(envPath, 'utf8');
+        lines = existing.replace(/\r\n/g, '\n').split('\n');
+    }
+    catch { }
+    let found = false;
+    const updatedLines = lines.map(line => {
+        const trimmed = line.trim();
+        if (trimmed.startsWith(`${keyName}=`)) {
+            found = true;
+            return `${keyName}="${keyValue}"`;
+        }
+        return line;
+    });
+    if (!found) {
+        if (updatedLines.length > 0 && updatedLines[updatedLines.length - 1] !== '') {
+            updatedLines.push('');
+        }
+        updatedLines.push(`${keyName}="${keyValue}"`);
+    }
+    await fs.writeFile(envPath, updatedLines.join('\n') + '\n', 'utf8');
+    process.env[keyName] = keyValue;
+    // Ensure .env is in .gitignore
+    await ensureGitignoreEntry(cwd, '.env');
+}
+/**
+ * Ensures an entry is present in the workspace .gitignore
+ */
+export async function ensureGitignoreEntry(cwd, entry) {
+    const gitignorePath = path.join(cwd, '.gitignore');
+    try {
+        let content = '';
+        try {
+            content = await fs.readFile(gitignorePath, 'utf8');
+        }
+        catch { }
+        const lines = content.replace(/\r\n/g, '\n').split('\n').map(l => l.trim());
+        if (!lines.includes(entry.trim())) {
+            const addition = (content && !content.endsWith('\n') ? '\n' : '') + `${entry}\n`;
+            await fs.appendFile(gitignorePath, addition, 'utf8');
+        }
+    }
+    catch { }
+}
+/**
+ * Auto-generates or verifies the .overarch project subsystem structure
+ */
+export async function autoEnsureOverarch(cwd = process.cwd()) {
+    const overarchDir = path.join(cwd, '.overarch');
+    await fs.mkdir(overarchDir, { recursive: true });
+    await fs.mkdir(path.join(overarchDir, 'sessions'), { recursive: true });
+    await fs.mkdir(path.join(overarchDir, 'cache'), { recursive: true });
+    const filesToEnsure = {
+        'config.json': JSON.stringify({ project: DEFAULT_CONFIG.project }, null, 2),
+        'instructions.md': '# Overarch Project Instructions\n\nAdd repository-specific guidelines, architecture rules, and patterns here.\n',
+        'memory.md': '# Project Memory\n\nPersistent decisions, patterns, and notes discovered during sessions.\n',
+        '.gitignore': 'sessions/\ncache/\n*.log\n*.env\nstate.json\n'
+    };
+    for (const [filename, defaultContent] of Object.entries(filesToEnsure)) {
+        const filePath = path.join(overarchDir, filename);
+        try {
+            await fs.access(filePath);
+        }
+        catch {
+            await fs.writeFile(filePath, defaultContent, 'utf8');
+        }
+    }
+    return overarchDir;
+}
+export async function loadConfig() {
+    await loadDotenv(process.cwd());
+    let globalConfig = {};
+    let projectConfig = {};
+    const globalConfigPath = path.join(getConfigDir(), 'config.json');
+    try {
+        const globalConfigData = await fs.readFile(globalConfigPath, 'utf8');
+        globalConfig = JSON.parse(globalConfigData);
+    }
+    catch (e) {
+        // Ignore error
+    }
+    const projectConfigPath = path.join(process.cwd(), '.overarch', 'config.json');
+    try {
+        const projectConfigData = await fs.readFile(projectConfigPath, 'utf8');
+        projectConfig = JSON.parse(projectConfigData);
+    }
+    catch (e) {
+        // Ignore error
+    }
+    const mergedConfig = {
+        ...DEFAULT_CONFIG,
+        ...globalConfig,
+        ...projectConfig,
+        providers: { ...DEFAULT_CONFIG.providers, ...globalConfig.providers, ...projectConfig.providers },
+        permissions: { ...DEFAULT_CONFIG.permissions, ...globalConfig.permissions, ...projectConfig.permissions },
+        context: { ...DEFAULT_CONFIG.context, ...globalConfig.context, ...projectConfig.context },
+        project: { ...DEFAULT_CONFIG.project, ...globalConfig.project, ...projectConfig.project },
+        ui: { ...DEFAULT_CONFIG.ui, ...globalConfig.ui, ...projectConfig.ui },
+        onboarding: { ...DEFAULT_CONFIG.onboarding, ...globalConfig.onboarding, ...projectConfig.onboarding },
+    };
+    return {
+        ...mergedConfig,
+        configPath: Object.keys(projectConfig).length > 0 ? projectConfigPath : (Object.keys(globalConfig).length > 0 ? globalConfigPath : ''),
+        isProjectConfig: Object.keys(projectConfig).length > 0
+    };
+}
+export async function saveConfig(config, targetPath) {
+    const dir = path.dirname(targetPath);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(targetPath, JSON.stringify(config, null, 2), 'utf8');
+}
+export async function saveGlobalConfig(updates) {
+    const globalConfigPath = path.join(getConfigDir(), 'config.json');
+    let currentConfig = {};
+    try {
+        const data = await fs.readFile(globalConfigPath, 'utf8');
+        currentConfig = JSON.parse(data);
+    }
+    catch (e) {
+        // ignore
+    }
+    const newConfig = {
+        ...currentConfig,
+        ...updates,
+        providers: { ...currentConfig.providers, ...updates.providers },
+        permissions: { ...currentConfig.permissions, ...updates.permissions },
+        context: { ...currentConfig.context, ...updates.context },
+        project: { ...currentConfig.project, ...updates.project },
+        ui: { ...currentConfig.ui, ...updates.ui },
+        onboarding: { ...currentConfig.onboarding, ...updates.onboarding },
+    };
+    // Strip raw API keys before persisting to disk
+    const configToSave = JSON.parse(JSON.stringify(newConfig));
+    if (configToSave.providers) {
+        for (const p of Object.values(configToSave.providers)) {
+            if (p && 'apiKey' in p) {
+                delete p.apiKey;
+            }
+        }
+    }
+    await fs.mkdir(getConfigDir(), { recursive: true });
+    await fs.writeFile(globalConfigPath, JSON.stringify(configToSave, null, 2), 'utf8');
+}
+export function getApiKey(provider, cwd = process.cwd()) {
+    const envMap = {
+        openai: 'OPENAI_API_KEY',
+        anthropic: 'ANTHROPIC_API_KEY',
+        gemini: 'GEMINI_API_KEY',
+        google: 'GEMINI_API_KEY',
+        openrouter: 'OPENROUTER_API_KEY'
+    };
+    const envVar = envMap[provider.toLowerCase()];
+    if (envVar && process.env[envVar]) {
+        return process.env[envVar];
+    }
+    return undefined;
+}