@agentconnect/host 0.2.0

package/dist/providers/index.d.ts

@@ -0,0 +1,5 @@
+import type { Provider, ProviderId, ModelInfo } from '../types.js';
+export declare const providers: Record<ProviderId, Provider>;
+export declare function listModels(): Promise<ModelInfo[]>;
+export declare function listRecentModels(providerId?: ProviderId): Promise<ModelInfo[]>;
+export declare function resolveProviderForModel(model: string | undefined): ProviderId;

package/dist/providers/index.js

@@ -0,0 +1,111 @@
+import { ensureClaudeInstalled, getClaudeFastStatus, getClaudeStatus, listClaudeModels, listClaudeRecentModels, loginClaude, runClaudePrompt, updateClaude, } from './claude.js';
+import { ensureCodexInstalled, getCodexFastStatus, getCodexStatus, listCodexModels, loginCodex, runCodexPrompt, updateCodex, } from './codex.js';
+import { ensureCursorInstalled, getCursorFastStatus, getCursorStatus, listCursorModels, loginCursor, runCursorPrompt, updateCursor, } from './cursor.js';
+import { ensureLocalInstalled, getLocalStatus, listLocalModels, loginLocal, runLocalPrompt, updateLocal, } from './local.js';
+export const providers = {
+    claude: {
+        id: 'claude',
+        name: 'Claude',
+        ensureInstalled: ensureClaudeInstalled,
+        fastStatus: getClaudeFastStatus,
+        status: getClaudeStatus,
+        update: updateClaude,
+        login: loginClaude,
+        logout: async () => { },
+        runPrompt: runClaudePrompt,
+    },
+    codex: {
+        id: 'codex',
+        name: 'Codex',
+        ensureInstalled: ensureCodexInstalled,
+        fastStatus: getCodexFastStatus,
+        status: getCodexStatus,
+        update: updateCodex,
+        login: loginCodex,
+        logout: async () => { },
+        runPrompt: runCodexPrompt,
+    },
+    cursor: {
+        id: 'cursor',
+        name: 'Cursor',
+        ensureInstalled: ensureCursorInstalled,
+        fastStatus: getCursorFastStatus,
+        status: getCursorStatus,
+        update: updateCursor,
+        login: loginCursor,
+        logout: async () => { },
+        runPrompt: runCursorPrompt,
+    },
+    local: {
+        id: 'local',
+        name: 'Local',
+        ensureInstalled: ensureLocalInstalled,
+        status: getLocalStatus,
+        update: updateLocal,
+        login: loginLocal,
+        logout: async () => { },
+        runPrompt: runLocalPrompt,
+    },
+};
+export async function listModels() {
+    const claudeModels = await listClaudeModels();
+    const codexModels = await listCodexModels();
+    const cursorModels = await listCursorModels();
+    const base = [
+        ...claudeModels,
+        ...cursorModels,
+        { id: 'local', provider: 'local', displayName: 'Local Model' },
+    ];
+    const envModels = process.env.AGENTCONNECT_LOCAL_MODELS;
+    if (envModels) {
+        try {
+            const parsed = JSON.parse(envModels);
+            if (Array.isArray(parsed)) {
+                for (const entry of parsed) {
+                    if (typeof entry === 'string' && entry) {
+                        base.push({ id: entry, provider: 'local', displayName: entry });
+                    }
+                }
+            }
+        }
+        catch {
+            // ignore invalid json
+        }
+    }
+    const discovered = await listLocalModels();
+    const all = [...base, ...codexModels, ...discovered.filter((entry) => entry.id !== 'local')];
+    const seen = new Set();
+    return all.filter((entry) => {
+        const key = `${entry.provider}:${entry.id}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+export async function listRecentModels(providerId) {
+    if (providerId && providerId !== 'claude')
+        return [];
+    const recent = await listClaudeRecentModels();
+    return recent.filter((entry) => entry.provider === 'claude');
+}
+export function resolveProviderForModel(model) {
+    const lower = String(model || '').toLowerCase();
+    if (lower.includes('cursor'))
+        return 'cursor';
+    if (lower.includes('codex'))
+        return 'codex';
+    if (lower.startsWith('gpt') ||
+        lower.startsWith('o1') ||
+        lower.startsWith('o3') ||
+        lower.startsWith('o4')) {
+        return 'codex';
+    }
+    if (lower.includes('local'))
+        return 'local';
+    if (lower.includes('opus') || lower.includes('sonnet') || lower.includes('haiku'))
+        return 'claude';
+    if (lower.includes('claude'))
+        return 'claude';
+    return 'claude';
+}

package/dist/providers/local.d.ts

@@ -0,0 +1,9 @@
+import type { ProviderStatus, ProviderLoginOptions, ModelInfo, RunPromptOptions, RunPromptResult, InstallResult } from '../types.js';
+export declare function ensureLocalInstalled(): Promise<InstallResult>;
+export declare function getLocalStatus(): Promise<ProviderStatus>;
+export declare function updateLocal(): Promise<ProviderStatus>;
+export declare function loginLocal(options?: ProviderLoginOptions): Promise<{
+    loggedIn: boolean;
+}>;
+export declare function listLocalModels(): Promise<ModelInfo[]>;
+export declare function runLocalPrompt({ prompt, model, onEvent, }: RunPromptOptions): Promise<RunPromptResult>;

package/dist/providers/local.js

@@ -0,0 +1,114 @@
+function getLocalBaseUrl() {
+    const base = process.env.AGENTCONNECT_LOCAL_BASE_URL || 'http://localhost:11434/v1';
+    return base.replace(/\/+$/, '');
+}
+function getLocalApiKey() {
+    return process.env.AGENTCONNECT_LOCAL_API_KEY || '';
+}
+function resolveLocalModel(model, fallback) {
+    if (!model)
+        return fallback;
+    const raw = String(model);
+    if (raw === 'local')
+        return fallback;
+    if (raw.startsWith('local:'))
+        return raw.slice('local:'.length);
+    if (raw.startsWith('local/'))
+        return raw.slice('local/'.length);
+    return raw;
+}
+async function fetchJson(url, options = {}) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 4000);
+    try {
+        const res = await fetch(url, { ...options, signal: controller.signal });
+        if (!res.ok) {
+            return { ok: false, status: res.status, data: null };
+        }
+        const data = (await res.json());
+        return { ok: true, status: res.status, data };
+    }
+    catch {
+        return { ok: false, status: 0, data: null };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export async function ensureLocalInstalled() {
+    const base = getLocalBaseUrl();
+    const res = await fetchJson(`${base}/models`);
+    return { installed: res.ok };
+}
+export async function getLocalStatus() {
+    const base = getLocalBaseUrl();
+    const res = await fetchJson(`${base}/models`);
+    if (!res.ok)
+        return { installed: false, loggedIn: false };
+    return { installed: true, loggedIn: true };
+}
+export async function updateLocal() {
+    return getLocalStatus();
+}
+export async function loginLocal(options = {}) {
+    if (typeof options.baseUrl === 'string') {
+        process.env.AGENTCONNECT_LOCAL_BASE_URL = options.baseUrl;
+    }
+    if (typeof options.apiKey === 'string') {
+        process.env.AGENTCONNECT_LOCAL_API_KEY = options.apiKey;
+    }
+    if (typeof options.model === 'string') {
+        process.env.AGENTCONNECT_LOCAL_MODEL = options.model;
+    }
+    if (Array.isArray(options.models)) {
+        process.env.AGENTCONNECT_LOCAL_MODELS = JSON.stringify(options.models.filter(Boolean));
+    }
+    const status = await getLocalStatus();
+    return { loggedIn: status.installed };
+}
+export async function listLocalModels() {
+    const base = getLocalBaseUrl();
+    const res = await fetchJson(`${base}/models`);
+    if (!res.ok || !res.data || !Array.isArray(res.data.data))
+        return [];
+    return res.data.data
+        .map((entry) => ({ id: entry.id, provider: 'local', displayName: entry.id }))
+        .filter((entry) => entry.id);
+}
+export async function runLocalPrompt({ prompt, model, onEvent, }) {
+    const base = getLocalBaseUrl();
+    const fallback = process.env.AGENTCONNECT_LOCAL_MODEL || '';
+    const resolvedModel = resolveLocalModel(model, fallback);
+    if (!resolvedModel) {
+        onEvent({ type: 'error', message: 'Local provider model is not configured.' });
+        return { sessionId: null };
+    }
+    const payload = {
+        model: resolvedModel,
+        messages: [{ role: 'user', content: prompt }],
+        stream: false,
+    };
+    const headers = { 'Content-Type': 'application/json' };
+    const apiKey = getLocalApiKey();
+    if (apiKey)
+        headers.Authorization = `Bearer ${apiKey}`;
+    const res = await fetchJson(`${base}/chat/completions`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(payload),
+    });
+    if (!res.ok) {
+        onEvent({ type: 'error', message: 'Local provider request failed.' });
+        return { sessionId: null };
+    }
+    const message = res.data?.choices?.[0]?.message?.content;
+    const text = typeof message === 'string' ? message : '';
+    if (text) {
+        onEvent({ type: 'delta', text });
+        onEvent({ type: 'final', text });
+    }
+    else {
+        onEvent({ type: 'error', message: 'Local provider returned no content.' });
+    }
+    return { sessionId: null };
+}

package/dist/providers/utils.d.ts

@@ -0,0 +1,33 @@
+import { type SpawnOptions } from 'child_process';
+import type { CommandResult } from '../types.js';
+export declare function debugLog(scope: string, message: string, details?: Record<string, unknown>): void;
+export interface SplitCommandResult {
+    command: string;
+    args: string[];
+}
+export declare function splitCommand(value: string | string[] | undefined): SplitCommandResult;
+export declare function resolveWindowsCommand(command: string): string;
+export declare function resolveCommandPath(command: string): string | null;
+export declare function resolveCommandRealPath(command: string): string | null;
+export declare function commandExists(command: string): boolean;
+export interface RunCommandOptions extends SpawnOptions {
+    input?: string;
+    timeoutMs?: number;
+}
+export declare function runCommand(command: string, args: string[], options?: RunCommandOptions): Promise<CommandResult>;
+export declare function createLineParser(onLine: (line: string) => void): (chunk: Buffer | string) => void;
+export interface CheckVersionResult {
+    ok: boolean;
+    version: string;
+}
+export declare function checkCommandVersion(command: string, argsList: string[][]): Promise<CheckVersionResult>;
+export type PackageManager = 'bun' | 'pnpm' | 'npm' | 'brew' | 'unknown';
+export interface InstallCommandResult extends SplitCommandResult {
+    packageManager: PackageManager;
+}
+export declare function detectPackageManager(): Promise<PackageManager>;
+export declare function getInstallCommand(packageManager: PackageManager, packageName: string): SplitCommandResult;
+export declare function buildInstallCommandAuto(packageName: string): Promise<InstallCommandResult>;
+export declare function buildInstallCommand(envVar: string, fallback: string): SplitCommandResult;
+export declare function buildLoginCommand(envVar: string, fallback: string): SplitCommandResult;
+export declare function buildStatusCommand(envVar: string, fallback: string): SplitCommandResult;

package/dist/providers/utils.js

@@ -0,0 +1,284 @@
+import { spawn } from 'child_process';
+import { existsSync, realpathSync } from 'fs';
+import os from 'os';
+import path from 'path';
+const DEBUG_ENABLED = Boolean(process.env.AGENTCONNECT_DEBUG?.trim());
+export function debugLog(scope, message, details) {
+    if (!DEBUG_ENABLED)
+        return;
+    let suffix = '';
+    if (details) {
+        try {
+            suffix = ` ${JSON.stringify(details)}`;
+        }
+        catch {
+            suffix = '';
+        }
+    }
+    console.log(`[AgentConnect][${scope}] ${message}${suffix}`);
+}
+export function splitCommand(value) {
+    if (!value)
+        return { command: '', args: [] };
+    if (Array.isArray(value))
+        return { command: value[0] ?? '', args: value.slice(1) };
+    const input = String(value).trim();
+    const parts = [];
+    let current = '';
+    let quote = null;
+    for (let i = 0; i < input.length; i += 1) {
+        const char = input[i];
+        if (quote) {
+            if (char === quote) {
+                quote = null;
+            }
+            else {
+                current += char;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            continue;
+        }
+        if (char === ' ') {
+            if (current) {
+                parts.push(current);
+                current = '';
+            }
+            continue;
+        }
+        current += char;
+    }
+    if (current)
+        parts.push(current);
+    return { command: parts[0] ?? '', args: parts.slice(1) };
+}
+export function resolveWindowsCommand(command) {
+    if (process.platform !== 'win32')
+        return command;
+    if (!command)
+        return command;
+    if (command.endsWith('.cmd') || command.endsWith('.exe') || command.includes('\\')) {
+        return command;
+    }
+    return `${command}.cmd`;
+}
+function getCommonBinPaths() {
+    const home = os.homedir();
+    const bunInstall = process.env.BUN_INSTALL || path.join(home, '.bun');
+    const pnpmHome = process.env.PNPM_HOME || path.join(home, 'Library', 'pnpm');
+    const npmPrefix = process.env.NPM_CONFIG_PREFIX;
+    const npmBin = npmPrefix ? path.join(npmPrefix, 'bin') : '';
+    const claudeLocal = process.env.CLAUDE_CONFIG_DIR
+        ? path.join(process.env.CLAUDE_CONFIG_DIR, 'local')
+        : path.join(home, '.claude', 'local');
+    return [
+        path.join(bunInstall, 'bin'),
+        pnpmHome,
+        path.join(home, '.local', 'bin'),
+        claudeLocal,
+        path.join(home, '.claude', 'bin'),
+        npmBin,
+        '/opt/homebrew/bin',
+        '/usr/local/bin',
+        '/usr/bin',
+        '/bin',
+    ].filter(Boolean);
+}
+function getCommandCandidates(command) {
+    if (process.platform !== 'win32')
+        return [command];
+    if (command.endsWith('.cmd') || command.endsWith('.exe') || command.endsWith('.bat')) {
+        return [command];
+    }
+    return [command, `${command}.cmd`, `${command}.exe`, `${command}.bat`];
+}
+export function resolveCommandPath(command) {
+    if (!command)
+        return null;
+    if (command.includes('/') || command.includes('\\')) {
+        return existsSync(command) ? command : null;
+    }
+    const candidates = getCommandCandidates(command);
+    const searchPaths = new Set();
+    const pathEntries = process.env.PATH ? process.env.PATH.split(path.delimiter) : [];
+    for (const entry of pathEntries) {
+        if (entry)
+            searchPaths.add(entry);
+    }
+    for (const entry of getCommonBinPaths()) {
+        if (entry)
+            searchPaths.add(entry);
+    }
+    for (const dir of searchPaths) {
+        for (const candidate of candidates) {
+            const fullPath = path.join(dir, candidate);
+            if (existsSync(fullPath))
+                return fullPath;
+        }
+    }
+    return null;
+}
+export function resolveCommandRealPath(command) {
+    const resolved = resolveCommandPath(command);
+    if (!resolved)
+        return null;
+    try {
+        return realpathSync(resolved);
+    }
+    catch {
+        return resolved;
+    }
+}
+export function commandExists(command) {
+    return Boolean(resolveCommandPath(command));
+}
+export function runCommand(command, args, options = {}) {
+    return new Promise((resolve) => {
+        const { input, timeoutMs, ...spawnOptions } = options;
+        if (!command) {
+            resolve({ code: -1, stdout: '', stderr: 'Command is empty' });
+            return;
+        }
+        const resolved = resolveCommandPath(command);
+        if (!resolved) {
+            resolve({ code: 127, stdout: '', stderr: `Executable not found in PATH: "${command}"` });
+            return;
+        }
+        const startedAt = Date.now();
+        debugLog('Command', 'run', {
+            command: resolved,
+            args,
+            startedAt: new Date(startedAt).toISOString(),
+        });
+        const child = spawn(resolved, args, {
+            ...spawnOptions,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        let timeout;
+        if (typeof timeoutMs === 'number' && timeoutMs > 0) {
+            timeout = setTimeout(() => {
+                child.kill();
+                resolve({ code: -1, stdout, stderr: `${stderr}Command timed out` });
+            }, timeoutMs);
+        }
+        if (input) {
+            child.stdin?.write(input);
+        }
+        child.stdin?.end();
+        child.stdout?.on('data', (chunk) => {
+            stdout += chunk.toString('utf8');
+        });
+        child.stderr?.on('data', (chunk) => {
+            stderr += chunk.toString('utf8');
+        });
+        child.on('error', (err) => {
+            if (timeout)
+                clearTimeout(timeout);
+            debugLog('Command', 'result', {
+                command: resolved,
+                code: -1,
+                durationMs: Date.now() - startedAt,
+                error: err.message,
+            });
+            resolve({ code: -1, stdout, stderr: `${stderr}${err.message}` });
+        });
+        child.on('close', (code) => {
+            if (timeout)
+                clearTimeout(timeout);
+            debugLog('Command', 'result', {
+                command: resolved,
+                code: code ?? 0,
+                durationMs: Date.now() - startedAt,
+            });
+            resolve({ code: code ?? 0, stdout, stderr });
+        });
+    });
+}
+export function createLineParser(onLine) {
+    let buffer = '';
+    return (chunk) => {
+        const text = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+        buffer += text;
+        let idx;
+        while ((idx = buffer.indexOf('\n')) !== -1) {
+            const line = buffer.slice(0, idx).trim();
+            buffer = buffer.slice(idx + 1);
+            if (line)
+                onLine(line);
+        }
+    };
+}
+export async function checkCommandVersion(command, argsList) {
+    for (const args of argsList) {
+        const result = await runCommand(command, args);
+        if (result.code === 0) {
+            const version = result.stdout.trim().split('\n')[0] ?? '';
+            return { ok: true, version };
+        }
+    }
+    return { ok: false, version: '' };
+}
+const packageManagerCache = { detected: null };
+async function isCommandAvailable(command) {
+    const result = await runCommand(command, ['--version']);
+    return result.code === 0;
+}
+export async function detectPackageManager() {
+    if (packageManagerCache.detected) {
+        return packageManagerCache.detected;
+    }
+    // Priority: bun > pnpm > npm > brew
+    if (await isCommandAvailable('bun')) {
+        packageManagerCache.detected = 'bun';
+        return 'bun';
+    }
+    if (await isCommandAvailable('pnpm')) {
+        packageManagerCache.detected = 'pnpm';
+        return 'pnpm';
+    }
+    if (await isCommandAvailable('npm')) {
+        packageManagerCache.detected = 'npm';
+        return 'npm';
+    }
+    if (process.platform === 'darwin' && (await isCommandAvailable('brew'))) {
+        packageManagerCache.detected = 'brew';
+        return 'brew';
+    }
+    packageManagerCache.detected = 'unknown';
+    return 'unknown';
+}
+export function getInstallCommand(packageManager, packageName) {
+    switch (packageManager) {
+        case 'bun':
+            return { command: 'bun', args: ['add', '-g', packageName] };
+        case 'pnpm':
+            return { command: 'pnpm', args: ['add', '-g', packageName] };
+        case 'npm':
+            return { command: 'npm', args: ['install', '-g', packageName] };
+        case 'brew':
+            return { command: 'brew', args: ['install', packageName] };
+        default:
+            return { command: '', args: [] };
+    }
+}
+export async function buildInstallCommandAuto(packageName) {
+    const pm = await detectPackageManager();
+    const cmd = getInstallCommand(pm, packageName);
+    return { ...cmd, packageManager: pm };
+}
+export function buildInstallCommand(envVar, fallback) {
+    const value = process.env[envVar] || fallback;
+    return splitCommand(value);
+}
+export function buildLoginCommand(envVar, fallback) {
+    const value = process.env[envVar] || fallback;
+    return splitCommand(value);
+}
+export function buildStatusCommand(envVar, fallback) {
+    const value = process.env[envVar] || fallback;
+    return splitCommand(value);
+}