@agentconnect/cli 0.1.0

package/dist/providers/local.js

@@ -0,0 +1,111 @@
+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 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,32 @@
+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 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,256 @@
+import { spawn } from 'child_process';
+import { existsSync } 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 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 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);
+            resolve({ code: -1, stdout, stderr: `${stderr}${err.message}` });
+        });
+        child.on('close', (code) => {
+            if (timeout)
+                clearTimeout(timeout);
+            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);
+}

package/dist/registry-validate.d.ts

@@ -0,0 +1,6 @@
+import type { RegistryValidationResult } from './types.js';
+export interface ValidateRegistryOptions {
+    registryPath: string;
+    requireSignature?: boolean;
+}
+export declare function validateRegistry({ registryPath, requireSignature, }: ValidateRegistryOptions): Promise<RegistryValidationResult>;

package/dist/registry-validate.js

@@ -0,0 +1,209 @@
+import path from 'path';
+import { createPublicKey, verify as verifySignature } from 'crypto';
+import { readJson, fileExists } from './fs-utils.js';
+import { hashFile } from './zip.js';
+import { validateManifest } from './manifest.js';
+function compareSemver(a, b) {
+    const parse = (v) => v
+        .split('-')[0]
+        .split('.')
+        .map((n) => Number(n));
+    const pa = parse(a);
+    const pb = parse(b);
+    for (let i = 0; i < 3; i += 1) {
+        const diff = (pa[i] || 0) - (pb[i] || 0);
+        if (diff !== 0)
+            return diff;
+    }
+    return 0;
+}
+function resolveEntry(registryPath, entryPath) {
+    if (!entryPath || typeof entryPath !== 'string')
+        return null;
+    return path.resolve(registryPath, entryPath);
+}
+function normalizeSignatureAlg(signatureAlg) {
+    const value = String(signatureAlg || '').toLowerCase();
+    if (value === 'ed25519')
+        return null;
+    if (value === 'rsa-sha256')
+        return 'sha256';
+    if (value === 'ecdsa-sha256')
+        return 'sha256';
+    return 'sha256';
+}
+async function verifySignatureFile({ signaturePath, hash, }) {
+    const signature = await readJson(signaturePath);
+    if (!signature || typeof signature !== 'object') {
+        return { ok: false, message: 'Signature payload is not valid JSON.' };
+    }
+    if (signature.hash !== hash) {
+        return { ok: false, message: 'Signature hash does not match app hash.' };
+    }
+    const publicKey = signature.publicKey;
+    if (!publicKey || typeof publicKey !== 'string') {
+        return { ok: false, message: 'Signature is missing public key.' };
+    }
+    const signatureValue = signature.signature;
+    if (!signatureValue || typeof signatureValue !== 'string') {
+        return { ok: false, message: 'Signature is missing signature bytes.' };
+    }
+    const algorithm = normalizeSignatureAlg(signature.signatureAlg);
+    const key = createPublicKey(publicKey);
+    const payload = Buffer.from(hash, 'hex');
+    const sigBuffer = Buffer.from(signatureValue, 'base64');
+    const ok = verifySignature(algorithm, payload, key, sigBuffer);
+    return { ok, message: ok ? '' : 'Signature verification failed.' };
+}
+export async function validateRegistry({ registryPath, requireSignature = false, }) {
+    const errors = [];
+    const warnings = [];
+    const indexPath = path.join(registryPath, 'index.json');
+    if (!(await fileExists(indexPath))) {
+        return {
+            valid: false,
+            errors: [{ path: 'index.json', message: 'index.json not found.' }],
+            warnings,
+        };
+    }
+    const index = await readJson(indexPath).catch(() => null);
+    if (!index || typeof index !== 'object') {
+        return {
+            valid: false,
+            errors: [{ path: 'index.json', message: 'index.json is not valid JSON.' }],
+            warnings,
+        };
+    }
+    const apps = index.apps;
+    if (!apps || typeof apps !== 'object') {
+        return {
+            valid: false,
+            errors: [{ path: 'index.json', message: 'index.json missing apps map.' }],
+            warnings,
+        };
+    }
+    for (const [appId, appEntry] of Object.entries(apps)) {
+        if (!appEntry || typeof appEntry !== 'object') {
+            errors.push({
+                path: `apps.${appId}`,
+                message: `App entry for ${appId} is invalid.`,
+            });
+            continue;
+        }
+        const versions = appEntry.versions;
+        if (!versions || typeof versions !== 'object') {
+            errors.push({
+                path: `apps.${appId}`,
+                message: `App entry for ${appId} missing versions.`,
+            });
+            continue;
+        }
+        const versionKeys = Object.keys(versions);
+        if (!versionKeys.length) {
+            errors.push({
+                path: `apps.${appId}`,
+                message: `App entry for ${appId} has no versions.`,
+            });
+            continue;
+        }
+        const latest = appEntry.latest;
+        if (latest && !versions[latest]) {
+            errors.push({
+                path: `apps.${appId}`,
+                message: `App ${appId} latest (${latest}) not found in versions.`,
+            });
+        }
+        const sorted = [...versionKeys].sort(compareSemver);
+        const expectedLatest = sorted[sorted.length - 1];
+        if (latest && expectedLatest && compareSemver(latest, expectedLatest) !== 0) {
+            warnings.push({
+                path: `apps.${appId}`,
+                message: `App ${appId} latest (${latest}) is not the newest (${expectedLatest}).`,
+            });
+        }
+        for (const [version, entry] of Object.entries(versions)) {
+            if (!entry || typeof entry !== 'object') {
+                errors.push({
+                    path: `apps.${appId}.versions.${version}`,
+                    message: `App ${appId}@${version} entry is invalid.`,
+                });
+                continue;
+            }
+            const zipPath = resolveEntry(registryPath, entry.path);
+            const manifestPath = resolveEntry(registryPath, entry.manifest);
+            const signaturePath = entry.signature ? resolveEntry(registryPath, entry.signature) : null;
+            if (!zipPath || !(await fileExists(zipPath))) {
+                errors.push({
+                    path: `apps.${appId}.versions.${version}`,
+                    message: `App ${appId}@${version} app.zip missing.`,
+                });
+                continue;
+            }
+            if (!manifestPath || !(await fileExists(manifestPath))) {
+                errors.push({
+                    path: `apps.${appId}.versions.${version}`,
+                    message: `App ${appId}@${version} manifest missing.`,
+                });
+                continue;
+            }
+            const hash = await hashFile(zipPath);
+            if (entry.hash && entry.hash !== hash) {
+                errors.push({
+                    path: `apps.${appId}.versions.${version}`,
+                    message: `App ${appId}@${version} hash mismatch.`,
+                });
+            }
+            const manifest = await readJson(manifestPath).catch(() => null);
+            if (!manifest) {
+                errors.push({
+                    path: `apps.${appId}.versions.${version}`,
+                    message: `App ${appId}@${version} manifest invalid JSON.`,
+                });
+                continue;
+            }
+            const manifestValidation = await validateManifest(manifest);
+            if (!manifestValidation.valid) {
+                errors.push({
+                    path: `apps.${appId}.versions.${version}`,
+                    message: `App ${appId}@${version} manifest failed schema validation.`,
+                });
+            }
+            if (manifest.id !== appId || manifest.version !== version) {
+                errors.push({
+                    path: `apps.${appId}.versions.${version}`,
+                    message: `App ${appId}@${version} manifest id/version mismatch.`,
+                });
+            }
+            if (signaturePath) {
+                if (!(await fileExists(signaturePath))) {
+                    errors.push({
+                        path: `apps.${appId}.versions.${version}`,
+                        message: `App ${appId}@${version} signature file missing.`,
+                    });
+                }
+                else {
+                    const verification = await verifySignatureFile({ signaturePath, hash });
+                    if (!verification.ok) {
+                        errors.push({
+                            path: `apps.${appId}.versions.${version}`,
+                            message: `App ${appId}@${version} signature invalid: ${verification.message}`,
+                        });
+                    }
+                }
+            }
+            else if (requireSignature) {
+                errors.push({
+                    path: `apps.${appId}.versions.${version}`,
+                    message: `App ${appId}@${version} is missing a signature.`,
+                });
+            }
+            else {
+                warnings.push({
+                    path: `apps.${appId}.versions.${version}`,
+                    message: `App ${appId}@${version} has no signature.`,
+                });
+            }
+        }
+    }
+    return { valid: errors.length === 0, errors, warnings };
+}

package/dist/registry.d.ts

@@ -0,0 +1,17 @@
+import type { AppManifest } from './types.js';
+export interface PublishPackageOptions {
+    zipPath: string;
+    signaturePath?: string;
+    registryPath: string;
+    manifest?: AppManifest;
+}
+export interface PublishPackageResult {
+    appId: string;
+    version: string;
+    hash: string;
+    targetZip: string;
+    manifestPath: string;
+    signaturePath: string | null;
+    indexPath: string;
+}
+export declare function publishPackage({ zipPath, signaturePath, registryPath, manifest, }: PublishPackageOptions): Promise<PublishPackageResult>;