@nkmc/gateway 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,436 @@
+import { R as RegistryStore, S as ServiceRecord, V as VersionSummary, b as ServiceSummary, d as SearchResult, e as RegistryStats, f as EndpointPricing, P as PeerGateway, g as EndpointRecord, C as CredentialVault, h as StoredCredential, E as Env, i as PeerStore, L as LendingRule, T as TunnelStore, j as TunnelRecord, a as TunnelProvider } from './proxy-qpda1ANS.js';
+export { k as EndpointAnnotations, l as EndpointSummary, m as ServiceStatus, n as SourceConfig } from './proxy-qpda1ANS.js';
+import { D as D1Database } from './types-C6JC9oTm.js';
+export { a as D1PreparedStatement, b as D1Result, c as D1RunResult } from './types-C6JC9oTm.js';
+import { HttpBackendConfig, Mount, AgentContext, HttpAuth, FsBackend } from '@nkmc/agent-fs';
+import { JWK } from 'jose';
+import * as hono_types from 'hono/types';
+import { Hono } from 'hono';
+import Database from 'better-sqlite3';
+export { T as TunnelRouteOptions, t as tunnelRoutes } from './tunnels-DFHNgmN7.js';
+
+declare class MemoryRegistryStore implements RegistryStore {
+    private records;
+    private key;
+    get(domain: string): Promise<ServiceRecord | null>;
+    getVersion(domain: string, version: string): Promise<ServiceRecord | null>;
+    listVersions(domain: string): Promise<VersionSummary[]>;
+    put(domain: string, record: ServiceRecord): Promise<void>;
+    delete(domain: string): Promise<void>;
+    list(): Promise<ServiceSummary[]>;
+    search(query: string): Promise<SearchResult[]>;
+}
+
+declare class D1RegistryStore implements RegistryStore {
+    private db;
+    constructor(db: D1Database);
+    initSchema(): Promise<void>;
+    get(domain: string): Promise<ServiceRecord | null>;
+    getVersion(domain: string, version: string): Promise<ServiceRecord | null>;
+    listVersions(domain: string): Promise<VersionSummary[]>;
+    /** Max endpoints JSON size before stripping verbose fields (parameters, requestBody, responses). */
+    static readonly ENDPOINTS_SIZE_LIMIT = 800000;
+    put(domain: string, record: ServiceRecord): Promise<void>;
+    delete(domain: string): Promise<void>;
+    list(): Promise<ServiceSummary[]>;
+    search(query: string): Promise<SearchResult[]>;
+    stats(): Promise<RegistryStats>;
+}
+
+interface ParseOptions {
+    isFirstParty?: boolean;
+}
+declare function parseSkillMd(domain: string, raw: string, options?: ParseOptions): ServiceRecord;
+declare function parsePricingAnnotation(text: string): EndpointPricing | undefined;
+
+declare function skillToHttpConfig(record: ServiceRecord): HttpBackendConfig;
+
+interface PeerQueryResult {
+    available: boolean;
+    pricing?: {
+        mode: string;
+        amount?: number;
+    };
+}
+interface PeerExecResult {
+    ok: boolean;
+    data?: unknown;
+    error?: string;
+    paymentRequired?: {
+        price: number;
+        currency: string;
+        payTo: string;
+        network: string;
+    };
+}
+/**
+ * Client for communicating with peer gateways in the federation.
+ * Each method sends authenticated HTTP requests to the peer's URL.
+ */
+declare class PeerClient {
+    private selfId;
+    constructor(selfId: string);
+    /**
+     * Query a peer to check if it has credentials for a domain
+     * and its lending rules allow access.
+     */
+    query(peer: PeerGateway, domain: string): Promise<PeerQueryResult>;
+    /**
+     * Execute a command on a peer gateway on behalf of an agent.
+     * Handles 402 Payment Required responses with X-402-* headers.
+     */
+    exec(peer: PeerGateway, request: {
+        command: string;
+        agentId: string;
+    }): Promise<PeerExecResult>;
+    /**
+     * Announce our available domains to a peer gateway.
+     */
+    announce(peer: PeerGateway, domains: string[]): Promise<void>;
+}
+
+interface RegistryResolverHooks {
+    onMiss: (path: string, addMount: (mount: Mount) => void, agent?: AgentContext) => Promise<boolean>;
+    listDomains: () => Promise<string[]>;
+    searchDomains: (query: string) => Promise<SearchResult[]>;
+    searchEndpoints: (domain: string, query: string) => Promise<Pick<EndpointRecord, "method" | "path" | "description">[]>;
+}
+interface RegistryResolverOptions {
+    store: RegistryStore;
+    vault?: {
+        get(domain: string, developerId?: string): Promise<{
+            auth: HttpAuth;
+        } | null>;
+    };
+    gatewayPrivateKey?: JWK;
+    wrapVirtualFiles?: boolean;
+    peerStore?: {
+        listPeers(): Promise<PeerGateway[]>;
+    };
+    peerClient?: PeerClient;
+}
+declare function createRegistryResolver(storeOrOptions: RegistryStore | RegistryResolverOptions): RegistryResolverHooks;
+declare function extractDomainPath(path: string): {
+    domain: string | null;
+    version: string | null;
+};
+
+interface MeterRecord {
+    id: string;
+    timestamp: number;
+    domain: string;
+    version: string;
+    endpoint: string;
+    agentId: string;
+    developerId?: string;
+    cost: number;
+    currency: string;
+}
+interface MeterQuery {
+    domain?: string;
+    agentId?: string;
+    developerId?: string;
+    from?: number;
+    to?: number;
+}
+interface MeterStore {
+    record(entry: MeterRecord): Promise<void>;
+    query(filter: MeterQuery): Promise<MeterRecord[]>;
+    sum(filter: MeterQuery): Promise<{
+        total: number;
+        currency: string;
+    }>;
+}
+
+declare class MemoryMeterStore implements MeterStore {
+    private records;
+    record(entry: MeterRecord): Promise<void>;
+    query(filter: MeterQuery): Promise<MeterRecord[]>;
+    sum(filter: MeterQuery): Promise<{
+        total: number;
+        currency: string;
+    }>;
+    private matches;
+}
+
+declare class D1MeterStore implements MeterStore {
+    private db;
+    constructor(db: D1Database);
+    initSchema(): Promise<void>;
+    record(entry: MeterRecord): Promise<void>;
+    query(filter: MeterQuery): Promise<MeterRecord[]>;
+    sum(filter: MeterQuery): Promise<{
+        total: number;
+        currency: string;
+    }>;
+    private buildQuery;
+}
+
+declare function lookupPricing(record: ServiceRecord, method: string, path: string): EndpointPricing | null;
+declare function checkAccess(record: ServiceRecord): {
+    allowed: boolean;
+    reason?: string;
+};
+declare function meter(store: MeterStore, opts: {
+    domain: string;
+    version: string;
+    endpoint: string;
+    agentId: string;
+    developerId?: string;
+    pricing: EndpointPricing;
+}): Promise<MeterRecord>;
+
+interface VirtualFileOptions {
+    inner: FsBackend;
+    domain: string;
+    store: RegistryStore;
+}
+declare class VirtualFileBackend implements FsBackend {
+    private inner;
+    private domain;
+    private store;
+    constructor(options: VirtualFileOptions);
+    list(path: string): Promise<string[]>;
+    read(path: string): Promise<unknown>;
+    write(path: string, data: unknown): Promise<{
+        id: string;
+    }>;
+    remove(path: string): Promise<void>;
+    search(path: string, pattern: string): Promise<unknown[]>;
+}
+
+declare class MemoryCredentialVault implements CredentialVault {
+    private credentials;
+    private poolKey;
+    private byokKey;
+    get(domain: string, developerId?: string): Promise<StoredCredential | null>;
+    putPool(domain: string, auth: HttpAuth): Promise<void>;
+    putByok(domain: string, developerId: string, auth: HttpAuth): Promise<void>;
+    delete(domain: string, developerId?: string): Promise<void>;
+    listDomains(): Promise<string[]>;
+}
+
+declare class D1CredentialVault implements CredentialVault {
+    private db;
+    private encryptionKey;
+    constructor(db: D1Database, encryptionKey: CryptoKey);
+    initSchema(): Promise<void>;
+    get(domain: string, developerId?: string): Promise<StoredCredential | null>;
+    putPool(domain: string, auth: HttpAuth): Promise<void>;
+    putByok(domain: string, developerId: string, auth: HttpAuth): Promise<void>;
+    delete(domain: string, developerId?: string): Promise<void>;
+    listDomains(): Promise<string[]>;
+    private rowToCredential;
+}
+
+interface CredentialRouteOptions {
+    vault: CredentialVault;
+}
+declare function credentialRoutes(options: CredentialRouteOptions): Hono<Env, hono_types.BlankSchema, "/">;
+
+declare function queryDnsTxt(domain: string): Promise<string[]>;
+
+interface Context7Options {
+    apiKey?: string;
+    baseUrl?: string;
+    fetchFn?: typeof globalThis.fetch;
+}
+interface LibrarySearchResult {
+    id: string;
+    name: string;
+    description?: string;
+    totalSnippets?: number;
+    trustScore?: number;
+}
+declare class Context7Client {
+    private apiKey?;
+    private baseUrl;
+    private fetchFn;
+    constructor(options?: Context7Options);
+    /** Search for a library by name. Returns matching library entries. */
+    searchLibraries(libraryName: string, query?: string): Promise<LibrarySearchResult[]>;
+    /** Query documentation for a specific library. Returns documentation text. */
+    queryDocs(libraryId: string, query: string): Promise<string>;
+    private headers;
+}
+
+interface Context7BackendOptions extends Context7Options {
+}
+/**
+ * FsBackend that maps filesystem operations to Context7 documentation queries.
+ *
+ * Filesystem mapping:
+ *   grep "react" /         → searchLibraries("react")  — search for libraries
+ *   cat /{owner}/{repo}    → queryDocs("/{owner}/{repo}", repo) — library overview
+ *   grep "hooks" /{o}/{r}  → queryDocs("/{o}/{r}", "hooks")   — query specific docs
+ *   ls /                   → usage instructions
+ */
+declare class Context7Backend implements FsBackend {
+    private client;
+    constructor(options?: Context7BackendOptions);
+    list(path: string): Promise<string[]>;
+    read(path: string): Promise<unknown>;
+    write(_path: string, _data: unknown): Promise<{
+        id: string;
+    }>;
+    remove(_path: string): Promise<void>;
+    search(path: string, pattern: string): Promise<unknown[]>;
+}
+
+interface RpcManifestDef {
+    url: string;
+    convention?: "crud" | "evm" | "raw";
+    methods: Array<{
+        rpcMethod: string;
+        description: string;
+        resource?: string;
+        fsOp?: "list" | "read" | "write" | "create" | "remove" | "search";
+    }>;
+}
+/** A single service to onboard */
+interface ManifestEntry {
+    domain: string;
+    /** OpenAPI spec URL — triggers compilation */
+    specUrl?: string;
+    /** skill.md URL — fetched and registered directly */
+    skillMdUrl?: string;
+    /** Inline skill.md content */
+    skillMd?: string;
+    /** JSON-RPC definition — triggers RPC compilation */
+    rpcDef?: RpcManifestDef;
+    /** Pool credential — values can be "${ENV_VAR}" references */
+    auth?: ManifestAuth;
+    /** Tags for categorization */
+    tags?: string[];
+    /** Skip this entry (default false) */
+    disabled?: boolean;
+}
+interface ManifestAuth {
+    type: "bearer" | "api-key" | "basic" | "oauth2";
+    token?: string;
+    prefix?: string;
+    header?: string;
+    key?: string;
+    username?: string;
+    password?: string;
+    tokenUrl?: string;
+    clientId?: string;
+    clientSecret?: string;
+    scope?: string;
+}
+/** Result of onboarding one service */
+interface OnboardResult {
+    domain: string;
+    status: "ok" | "failed" | "skipped";
+    error?: string;
+    source: "openapi" | "skillmd" | "wellknown" | "jsonrpc" | "none";
+    endpoints: number;
+    resources: number;
+    hasCredentials: boolean;
+    smokeTest?: {
+        ls: boolean;
+        cat: boolean;
+        catEndpoint?: string;
+    };
+    durationMs: number;
+}
+/** Summary of a batch onboard run */
+interface OnboardReport {
+    total: number;
+    ok: number;
+    failed: number;
+    skipped: number;
+    results: OnboardResult[];
+    durationMs: number;
+}
+
+interface PipelineOptions {
+    store: RegistryStore;
+    vault?: CredentialVault;
+    /** Run smoke tests after registration (default true) */
+    smokeTest?: boolean;
+    /** Concurrency limit for parallel onboarding (default 5) */
+    concurrency?: number;
+    /** Custom fetch function */
+    fetchFn?: typeof globalThis.fetch;
+    /** Progress callback */
+    onProgress?: (result: OnboardResult, index: number, total: number) => void;
+}
+declare class OnboardPipeline {
+    private store;
+    private vault?;
+    private smokeTest;
+    private concurrency;
+    private fetchFn;
+    private onProgress?;
+    constructor(options: PipelineOptions);
+    /** Onboard a single service */
+    onboardOne(entry: ManifestEntry): Promise<OnboardResult>;
+    /** Onboard many services with controlled concurrency */
+    onboardMany(entries: ManifestEntry[]): Promise<OnboardReport>;
+    private runSmokeTest;
+}
+
+interface ApisGuruOptions {
+    /** Max number of APIs to return */
+    limit?: number;
+    /** Filter by keyword in API title/description */
+    filter?: string;
+    /** Custom fetch function */
+    fetchFn?: typeof globalThis.fetch;
+}
+/**
+ * Discover APIs from the apis.guru public directory.
+ * Returns ManifestEntry[] ready for the onboard pipeline.
+ */
+declare function discoverFromApisGuru(options?: ApisGuruOptions): Promise<ManifestEntry[]>;
+
+/**
+ * Wraps a better-sqlite3 Database instance to implement the D1Database interface.
+ * This allows all existing D1-based stores (RegistryStore, CredentialVault, MeterStore)
+ * to work with a local SQLite database for standalone deployments.
+ */
+declare function createSqliteD1(db: Database.Database): D1Database;
+
+declare class D1PeerStore implements PeerStore {
+    private db;
+    constructor(db: D1Database);
+    initSchema(): Promise<void>;
+    getPeer(id: string): Promise<PeerGateway | null>;
+    putPeer(peer: PeerGateway): Promise<void>;
+    deletePeer(id: string): Promise<void>;
+    listPeers(): Promise<PeerGateway[]>;
+    updateLastSeen(id: string, timestamp: number): Promise<void>;
+    getRule(domain: string): Promise<LendingRule | null>;
+    putRule(rule: LendingRule): Promise<void>;
+    deleteRule(domain: string): Promise<void>;
+    listRules(): Promise<LendingRule[]>;
+}
+
+declare class MemoryTunnelStore implements TunnelStore {
+    private records;
+    get(id: string): Promise<TunnelRecord | null>;
+    getByAgent(agentId: string): Promise<TunnelRecord | null>;
+    put(record: TunnelRecord): Promise<void>;
+    delete(id: string): Promise<void>;
+    list(): Promise<TunnelRecord[]>;
+}
+
+declare class CloudflareTunnelProvider implements TunnelProvider {
+    private accountId;
+    private apiToken;
+    private tunnelDomain;
+    private zoneId;
+    constructor(accountId: string, apiToken: string, tunnelDomain: string, // e.g. "tunnel.example.com"
+    zoneId: string);
+    create(name: string, hostname: string): Promise<{
+        tunnelId: string;
+        tunnelToken: string;
+    }>;
+    delete(tunnelId: string): Promise<void>;
+    private cfFetch;
+}
+
+declare const VERSION = "0.1.0";
+
+export { type ApisGuruOptions, CloudflareTunnelProvider, Context7Backend, type Context7BackendOptions, Context7Client, type Context7Options, CredentialVault, D1CredentialVault, D1Database, D1MeterStore, D1PeerStore, D1RegistryStore, EndpointPricing, EndpointRecord, LendingRule, type LibrarySearchResult, type ManifestAuth, type ManifestEntry, MemoryCredentialVault, MemoryMeterStore, MemoryRegistryStore, MemoryTunnelStore, type MeterQuery, type MeterRecord, type MeterStore, OnboardPipeline, type OnboardReport, type OnboardResult, type ParseOptions, PeerGateway, PeerStore, type PipelineOptions, type RegistryResolverHooks, type RegistryResolverOptions, RegistryStore, SearchResult, ServiceRecord, ServiceSummary, StoredCredential, TunnelProvider, TunnelRecord, TunnelStore, VERSION, VersionSummary, VirtualFileBackend, checkAccess, createRegistryResolver, createSqliteD1, credentialRoutes, discoverFromApisGuru, extractDomainPath, lookupPricing, meter, parsePricingAnnotation, parseSkillMd, queryDnsTxt, skillToHttpConfig };