@agentconnect/cli 0.1.0

package/dist/manifest.d.ts

@@ -0,0 +1,10 @@
+import { type ErrorObject } from 'ajv';
+import type { AppManifest } from './types.js';
+export declare function readManifestFromDir(appPath: string): Promise<AppManifest>;
+export declare function readManifestFromZip(zipPath: string): Promise<AppManifest>;
+export declare function loadManifestSchema(): Promise<object>;
+export interface ManifestValidationResult {
+    valid: boolean;
+    errors: ErrorObject[];
+}
+export declare function validateManifest(manifest: unknown): Promise<ManifestValidationResult>;

package/dist/manifest.js

@@ -0,0 +1,34 @@
+import path from 'path';
+import Ajv from 'ajv';
+import { readJson, fileExists } from './fs-utils.js';
+import { findSchemaDir } from './paths.js';
+import { readZipEntry } from './zip.js';
+export async function readManifestFromDir(appPath) {
+    const manifestPath = path.join(appPath, 'agentconnect.app.json');
+    if (!(await fileExists(manifestPath))) {
+        throw new Error('agentconnect.app.json not found in app directory.');
+    }
+    return readJson(manifestPath);
+}
+export async function readManifestFromZip(zipPath) {
+    const content = await readZipEntry(zipPath, 'agentconnect.app.json');
+    if (!content) {
+        throw new Error('agentconnect.app.json not found in zip.');
+    }
+    return JSON.parse(content);
+}
+export async function loadManifestSchema() {
+    const schemaDir = await findSchemaDir();
+    if (!schemaDir) {
+        throw new Error('Unable to locate schemas directory.');
+    }
+    const schemaPath = path.join(schemaDir, 'app-manifest.json');
+    return readJson(schemaPath);
+}
+export async function validateManifest(manifest) {
+    const schema = await loadManifestSchema();
+    const ajv = new Ajv({ allErrors: true, strict: false });
+    const validate = ajv.compile(schema);
+    const valid = validate(manifest);
+    return { valid: Boolean(valid), errors: validate.errors || [] };
+}

package/dist/observed.d.ts

@@ -0,0 +1,7 @@
+import type { ObservedTracker } from './types.js';
+export interface ObservedTrackerOptions {
+    basePath: string;
+    appId: string;
+    requested?: string[];
+}
+export declare function createObservedTracker({ basePath, appId, requested, }: ObservedTrackerOptions): ObservedTracker;

package/dist/observed.js

@@ -0,0 +1,69 @@
+import fs from 'fs';
+import path from 'path';
+export function createObservedTracker({ basePath, appId, requested = [], }) {
+    const requestedList = Array.isArray(requested) ? requested.filter(Boolean) : [];
+    const dirPath = path.join(basePath, '.agentconnect');
+    const filePath = path.join(dirPath, 'observed-capabilities.json');
+    const observed = new Set();
+    let writeTimer = null;
+    function load() {
+        if (!fs.existsSync(filePath))
+            return;
+        try {
+            const raw = fs.readFileSync(filePath, 'utf8');
+            const parsed = JSON.parse(raw);
+            if (Array.isArray(parsed?.observed)) {
+                for (const entry of parsed.observed) {
+                    if (typeof entry === 'string' && entry)
+                        observed.add(entry);
+                }
+            }
+        }
+        catch {
+            // ignore parse errors
+        }
+    }
+    function snapshot() {
+        return {
+            appId,
+            requested: requestedList,
+            observed: Array.from(observed).sort(),
+            updatedAt: new Date().toISOString(),
+        };
+    }
+    function flush() {
+        if (writeTimer) {
+            clearTimeout(writeTimer);
+            writeTimer = null;
+        }
+        const payload = JSON.stringify(snapshot(), null, 2);
+        fs.mkdirSync(dirPath, { recursive: true });
+        fs.writeFileSync(filePath, payload);
+    }
+    function scheduleFlush() {
+        if (writeTimer)
+            return;
+        writeTimer = setTimeout(() => {
+            flush();
+        }, 400);
+    }
+    function record(capability) {
+        const value = typeof capability === 'string' ? capability.trim() : '';
+        if (!value)
+            return;
+        if (observed.has(value))
+            return;
+        observed.add(value);
+        scheduleFlush();
+    }
+    function list() {
+        return Array.from(observed).sort();
+    }
+    load();
+    return {
+        record,
+        list,
+        snapshot,
+        flush,
+    };
+}

package/dist/paths.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveAppPath(input?: string): string;
+export declare function findSchemaDir(): Promise<string | null>;

package/dist/paths.js

@@ -0,0 +1,36 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { promises as fs } from 'fs';
+async function exists(target) {
+    try {
+        await fs.stat(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function resolveAppPath(input) {
+    const candidate = input ? path.resolve(input) : process.cwd();
+    return candidate;
+}
+export async function findSchemaDir() {
+    const envDir = process.env.AGENTCONNECT_SCHEMA_DIR;
+    if (envDir && (await exists(envDir)))
+        return envDir;
+    const start = path.dirname(fileURLToPath(import.meta.url));
+    const roots = [start, process.cwd()];
+    for (const root of roots) {
+        let current = root;
+        for (let i = 0; i < 8; i += 1) {
+            const candidate = path.join(current, 'schemas');
+            if (await exists(candidate))
+                return candidate;
+            const parent = path.dirname(current);
+            if (parent === current)
+                break;
+            current = parent;
+        }
+    }
+    return null;
+}

package/dist/providers/claude.d.ts

@@ -0,0 +1,10 @@
+import type { ProviderStatus, RunPromptOptions, RunPromptResult, InstallResult, ProviderLoginOptions, ModelInfo } from '../types.js';
+export declare function getClaudeCommand(): string;
+export declare function listClaudeModels(): Promise<ModelInfo[]>;
+export declare function listClaudeRecentModels(): Promise<ModelInfo[]>;
+export declare function ensureClaudeInstalled(): Promise<InstallResult>;
+export declare function getClaudeStatus(): Promise<ProviderStatus>;
+export declare function loginClaude(options?: ProviderLoginOptions): Promise<{
+    loggedIn: boolean;
+}>;
+export declare function runClaudePrompt({ prompt, resumeSessionId, model, cwd, onEvent, signal, }: RunPromptOptions): Promise<RunPromptResult>;