@agentconnect/cli 0.1.0

package/dist/registry.js

@@ -0,0 +1,66 @@
+import path from 'path';
+import { promises as fs } from 'fs';
+import { readJson, writeJson, fileExists } from './fs-utils.js';
+import { hashFile } from './zip.js';
+import { readManifestFromZip } 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;
+}
+export async function publishPackage({ zipPath, signaturePath, registryPath, manifest, }) {
+    const resolvedManifest = manifest || (await readManifestFromZip(zipPath));
+    const appId = resolvedManifest.id;
+    const version = resolvedManifest.version;
+    if (!appId || !version) {
+        throw new Error('Manifest must include id and version.');
+    }
+    const entryDir = path.join(registryPath, 'apps', appId, version);
+    await fs.mkdir(entryDir, { recursive: true });
+    const targetZip = path.join(entryDir, 'app.zip');
+    await fs.copyFile(zipPath, targetZip);
+    const manifestPath = path.join(entryDir, 'manifest.json');
+    await writeJson(manifestPath, resolvedManifest);
+    let signatureOut = null;
+    if (signaturePath) {
+        signatureOut = path.join(entryDir, 'signature.json');
+        await fs.copyFile(signaturePath, signatureOut);
+    }
+    const hash = await hashFile(zipPath);
+    const indexPath = path.join(registryPath, 'index.json');
+    const index = (await fileExists(indexPath))
+        ? await readJson(indexPath)
+        : { apps: {} };
+    if (!index.apps)
+        index.apps = {};
+    if (!index.apps[appId]) {
+        index.apps[appId] = { latest: version, versions: {} };
+    }
+    index.apps[appId].versions[version] = {
+        path: path.relative(registryPath, targetZip).replace(/\\/g, '/'),
+        manifest: resolvedManifest,
+        signature: signatureOut
+            ? {
+                algorithm: 'unknown',
+                publicKey: '',
+                signature: '',
+            }
+            : undefined,
+        hash,
+    };
+    const currentLatest = index.apps[appId].latest;
+    if (!currentLatest || compareSemver(version, currentLatest) > 0) {
+        index.apps[appId].latest = version;
+    }
+    await writeJson(indexPath, index);
+    return { appId, version, hash, targetZip, manifestPath, signaturePath: signatureOut, indexPath };
+}

package/dist/types.d.ts

@@ -0,0 +1,225 @@
+import type { ChildProcess } from 'child_process';
+export type RpcId = string | number;
+export interface RpcRequest {
+    jsonrpc: '2.0';
+    id: RpcId;
+    method: string;
+    params?: Record<string, unknown>;
+}
+export interface RpcSuccess {
+    jsonrpc: '2.0';
+    id: RpcId;
+    result: Record<string, unknown>;
+}
+export type RpcErrorCode = 'AC_ERR_UNAUTHORIZED' | 'AC_ERR_NOT_INSTALLED' | 'AC_ERR_INVALID_ARGS' | 'AC_ERR_UNSUPPORTED' | 'AC_ERR_INTERNAL' | 'AC_ERR_FS_READ' | 'AC_ERR_FS_WRITE' | 'AC_ERR_FS_LIST' | 'AC_ERR_FS_STAT' | 'AC_ERR_PROCESS' | 'AC_ERR_NET' | 'AC_ERR_BACKEND';
+export interface RpcError {
+    jsonrpc: '2.0';
+    id: RpcId;
+    error: {
+        code: RpcErrorCode;
+        message: string;
+        data?: Record<string, unknown>;
+    };
+}
+export type RpcResponse = RpcSuccess | RpcError;
+export type ProviderId = 'claude' | 'codex' | 'local';
+export interface AppManifestEntry {
+    type: 'web';
+    path: string;
+    devUrl?: string;
+}
+export interface AppManifestBackendHealthcheck {
+    type: 'http';
+    path: string;
+}
+export interface AppManifestBackend {
+    runtime: 'node';
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    healthcheck?: AppManifestBackendHealthcheck;
+}
+export interface AppManifestAuthor {
+    name?: string;
+    email?: string;
+    url?: string;
+}
+export interface AppManifest {
+    id: string;
+    name: string;
+    version: string;
+    description?: string;
+    entry: AppManifestEntry;
+    backend?: AppManifestBackend;
+    capabilities?: string[];
+    providers?: ProviderId[];
+    models?: {
+        default?: string;
+    };
+    icon?: string;
+    repo?: string;
+    homepage?: string;
+    license?: string;
+    author?: AppManifestAuthor;
+    keywords?: string[];
+}
+export interface RegistryAppVersion {
+    path: string;
+    manifest: AppManifest;
+    signature?: {
+        algorithm: string;
+        publicKey: string;
+        signature: string;
+    };
+    hash?: string;
+}
+export interface RegistryApp {
+    versions: Record<string, RegistryAppVersion>;
+    latest: string;
+}
+export interface RegistryIndex {
+    apps: Record<string, RegistryApp>;
+}
+export interface ProviderStatus {
+    installed: boolean;
+    loggedIn: boolean;
+    version?: string;
+}
+export interface ProviderInfo extends ProviderStatus {
+    id: ProviderId;
+    name: string;
+}
+export interface ReasoningEffort {
+    id: string;
+    label: string;
+}
+export interface ModelInfo {
+    id: string;
+    provider: ProviderId;
+    displayName?: string;
+    contextWindow?: number;
+    maxOutputTokens?: number;
+    reasoningEfforts?: ReasoningEffort[];
+    defaultReasoningEffort?: string;
+}
+export interface ProviderLoginOptions {
+    baseUrl?: string;
+    apiKey?: string;
+    model?: string;
+    models?: string[];
+    loginMethod?: 'claudeai' | 'console';
+    loginExperience?: 'embedded' | 'terminal';
+}
+export interface SessionEvent {
+    type: 'delta' | 'final' | 'usage' | 'status' | 'error' | 'raw_line' | 'provider_event';
+    text?: string;
+    message?: string;
+    line?: string;
+    provider?: ProviderId;
+    event?: Record<string, unknown>;
+    providerSessionId?: string | null;
+    inputTokens?: number;
+    outputTokens?: number;
+}
+export interface RunPromptOptions {
+    prompt: string;
+    resumeSessionId?: string | null;
+    model?: string;
+    reasoningEffort?: string | null;
+    repoRoot?: string;
+    cwd?: string;
+    signal?: AbortSignal;
+    onEvent: (event: SessionEvent) => void;
+}
+export interface RunPromptResult {
+    sessionId: string | null;
+}
+export type PackageManagerType = 'bun' | 'pnpm' | 'npm' | 'brew' | 'script' | 'unknown';
+export interface InstallResult {
+    installed: boolean;
+    version?: string;
+    packageManager?: PackageManagerType;
+}
+export interface Provider {
+    id: ProviderId;
+    name: string;
+    ensureInstalled(): Promise<InstallResult>;
+    status(): Promise<ProviderStatus>;
+    login(options?: ProviderLoginOptions): Promise<{
+        loggedIn: boolean;
+    }>;
+    logout(): Promise<void>;
+    listModels?(): Promise<ModelInfo[]>;
+    runPrompt(options: RunPromptOptions): Promise<RunPromptResult>;
+}
+export interface SessionState {
+    id: string;
+    providerId: ProviderId;
+    model: string;
+    providerSessionId: string | null;
+    reasoningEffort: string | null;
+    cwd?: string;
+    repoRoot?: string;
+}
+export interface BackendState {
+    status: 'starting' | 'running' | 'stopped' | 'error' | 'disabled';
+    pid?: number;
+    url?: string;
+}
+export interface ProcessHandle {
+    pid: number;
+    process: ChildProcess;
+}
+export interface ValidationError {
+    path: string;
+    message: string;
+}
+export interface ValidationWarning {
+    path: string;
+    message: string;
+}
+export interface RegistryValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+    warnings: ValidationWarning[];
+}
+export interface ObservedCapabilities {
+    requested: string[];
+    observed: string[];
+}
+export interface ObservedTracker {
+    record(capability: string): void;
+    list(): string[];
+    snapshot(): ObservedCapabilities;
+    flush(): void;
+}
+export interface CommandResult {
+    stdout: string;
+    stderr: string;
+    code: number | null;
+}
+export interface LineParser {
+    push(chunk: Buffer | string): void;
+    end(): void;
+}
+export interface CollectFilesOptions {
+    ignoreNames?: string[];
+    ignorePaths?: string[];
+}
+export interface FileEntry {
+    name: string;
+    path: string;
+    type: 'file' | 'dir' | 'link' | 'other';
+    size: number;
+}
+export interface FileStat {
+    type: 'file' | 'dir' | 'link' | 'other';
+    size: number;
+    mtime: string;
+}
+export interface SignatureData {
+    algorithm: string;
+    publicKey: string;
+    signature: string;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/zip.d.ts

@@ -0,0 +1,9 @@
+export declare function hashFile(filePath: string): Promise<string>;
+export interface ZipDirectoryOptions {
+    inputDir: string;
+    outputPath: string;
+    ignoreNames?: string[];
+    ignorePaths?: string[];
+}
+export declare function zipDirectory({ inputDir, outputPath, ignoreNames, ignorePaths, }: ZipDirectoryOptions): Promise<void>;
+export declare function readZipEntry(zipPath: string, entryName: string): Promise<string | null>;

package/dist/zip.js

@@ -0,0 +1,71 @@
+import fs from 'fs';
+import path from 'path';
+import { createHash } from 'crypto';
+import yazl from 'yazl';
+import yauzl from 'yauzl';
+import { collectFiles } from './fs-utils.js';
+export async function hashFile(filePath) {
+    return new Promise((resolve, reject) => {
+        const hash = createHash('sha256');
+        const stream = fs.createReadStream(filePath);
+        stream.on('data', (chunk) => hash.update(chunk));
+        stream.on('error', reject);
+        stream.on('end', () => resolve(hash.digest('hex')));
+    });
+}
+export async function zipDirectory({ inputDir, outputPath, ignoreNames = [], ignorePaths = [], }) {
+    await fs.promises.mkdir(path.dirname(outputPath), { recursive: true });
+    const zipfile = new yazl.ZipFile();
+    const files = await collectFiles(inputDir, { ignoreNames, ignorePaths });
+    for (const file of files) {
+        zipfile.addFile(file.fullPath, file.rel);
+    }
+    return new Promise((resolve, reject) => {
+        const outStream = fs.createWriteStream(outputPath);
+        zipfile.outputStream.pipe(outStream);
+        outStream.on('close', () => resolve());
+        outStream.on('error', reject);
+        zipfile.end();
+    });
+}
+export async function readZipEntry(zipPath, entryName) {
+    return new Promise((resolve, reject) => {
+        yauzl.open(zipPath, { lazyEntries: true }, (err, zipfile) => {
+            if (err || !zipfile) {
+                reject(err || new Error('Unable to open zip'));
+                return;
+            }
+            let found = false;
+            zipfile.readEntry();
+            zipfile.on('entry', (entry) => {
+                if (entry.fileName === entryName || entry.fileName.endsWith(`/${entryName}`)) {
+                    found = true;
+                    zipfile.openReadStream(entry, (streamErr, stream) => {
+                        if (streamErr || !stream) {
+                            zipfile.close();
+                            reject(streamErr || new Error('Unable to read zip entry'));
+                            return;
+                        }
+                        const chunks = [];
+                        stream.on('data', (chunk) => chunks.push(chunk));
+                        stream.on('end', () => {
+                            const content = Buffer.concat(chunks).toString('utf8');
+                            zipfile.close();
+                            resolve(content);
+                        });
+                        stream.on('error', reject);
+                    });
+                }
+                else {
+                    zipfile.readEntry();
+                }
+            });
+            zipfile.on('end', () => {
+                if (!found) {
+                    zipfile.close();
+                    resolve(null);
+                }
+            });
+        });
+    });
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@agentconnect/cli",
+  "version": "0.1.0",
+  "license": "MIT",
+  "type": "module",
+  "homepage": "https://github.com/rayzhudev/agent-connect",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rayzhudev/agent-connect.git",
+    "directory": "packages/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/rayzhudev/agent-connect/issues"
+  },
+  "bin": {
+    "agentconnect": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc && esbuild src/index.ts --bundle --platform=node --format=esm --target=node20 --outfile=dist/index.js --banner:js='#!/usr/bin/env node' --packages=external",
+    "dev": "tsc --watch"
+  },
+  "dependencies": {
+    "ajv": "^8.17.1",
+    "node-pty": "^1.1.0",
+    "ws": "^8.17.0",
+    "yauzl": "^2.10.0",
+    "yazl": "^2.5.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "@types/ws": "^8",
+    "@types/yauzl": "^2",
+    "@types/yazl": "^2",
+    "typescript": "^5.6.2",
+    "esbuild": "^0.23.0"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}