@privateconnect/sdk 0.3.0

package/README.md

@@ -0,0 +1,174 @@
+# Private Connect SDK
+
+TypeScript SDK for Private Connect - programmatic access to services and agent orchestration.
+
+## Installation
+
+```bash
+npm install @privateconnect/sdk
+# or
+pnpm add @privateconnect/sdk
+```
+
+## Quick Start
+
+```typescript
+import { PrivateConnect, connect } from '@privateconnect/sdk';
+
+// Quick connect to a service
+const db = await connect('postgres-prod');
+console.log(db.connectionString); // postgres://localhost:5432/...
+
+// Or use the full client
+const pc = new PrivateConnect({ 
+  apiKey: process.env.PRIVATECONNECT_API_KEY 
+});
+
+// List available services
+const services = await pc.services.list();
+
+// Connect to a specific service
+const redis = await pc.connect('redis-cache');
+console.log(redis.connectionString); // redis://localhost:6379
+```
+
+## Agent Orchestration
+
+The SDK enables multi-agent orchestration - coordinating work across agents running on different machines.
+
+### List Agents
+
+```typescript
+// Get all agents in your workspace
+const agents = await pc.agents.list();
+
+// Get only online agents
+const online = await pc.agents.list({ onlineOnly: true });
+
+// Find agents with specific capabilities
+const gpuAgents = await pc.agents.findByCapability('gpu');
+```
+
+### Register Capabilities
+
+Tell other agents what you can do:
+
+```typescript
+await pc.agents.registerCapabilities([
+  { name: 'database', metadata: { type: 'postgres', version: '15' } },
+  { name: 'gpu', metadata: { model: 'A100', memory: '80GB' } },
+]);
+```
+
+### Agent Messaging
+
+Coordinate with other agents:
+
+```typescript
+// Send a message to a specific agent
+await pc.agents.sendMessage(targetAgentId, {
+  action: 'run-migration',
+  database: 'users',
+});
+
+// Broadcast to all agents
+await pc.agents.broadcast({
+  type: 'deployment-starting',
+  service: 'api',
+});
+
+// Get your messages
+const messages = await pc.agents.getMessages({ unreadOnly: true });
+for (const msg of messages) {
+  console.log(`From ${msg.from.name}: ${JSON.stringify(msg.payload)}`);
+}
+```
+
+### Orchestration Sessions
+
+Create ephemeral sessions for coordinated workflows:
+
+```typescript
+// Create a session
+const session = await pc.sessions.create('deploy-v2.1', {
+  ttlMinutes: 30,
+  metadata: { version: '2.1.0' },
+});
+
+// ... coordinate agents ...
+
+// End the session
+await pc.sessions.end(session.id);
+```
+
+## Connection Strings
+
+Get properly formatted connection strings for common services:
+
+```typescript
+const db = await pc.connect('postgres-prod');
+// db.connectionString = 'postgres://localhost:5432/postgres'
+// db.envVar = 'DATABASE_URL'
+
+const cache = await pc.connect('redis-cache');
+// cache.connectionString = 'redis://localhost:6379'
+// cache.envVar = 'REDIS_URL'
+
+const api = await pc.connect('internal-api');
+// api.connectionString = 'http://localhost:8080'
+// api.envVar = 'API_URL'
+```
+
+## Environment Variables
+
+The SDK can read configuration from environment variables:
+
+```bash
+export PRIVATECONNECT_API_KEY=your-api-key
+```
+
+```typescript
+// API key automatically read from env
+const connection = await connect('my-service');
+```
+
+## API Reference
+
+### `PrivateConnect`
+
+Main client class.
+
+```typescript
+const pc = new PrivateConnect({
+  apiKey: string,        // Required: Your API key
+  hubUrl?: string,       // Optional: Hub URL (default: https://api.privateconnect.co)
+  agentId?: string,      // Optional: Agent ID (auto-detected)
+});
+```
+
+### `pc.services`
+
+- `list()` - List all services
+- `get(name)` - Get a service by name
+- `getConnection(name)` - Get connection details for a service
+
+### `pc.agents`
+
+- `list(options?)` - List all agents
+- `findByCapability(capability)` - Find agents by capability
+- `registerCapabilities(capabilities)` - Register this agent's capabilities
+- `sendMessage(toAgentId, payload, options?)` - Send a message
+- `broadcast(payload, options?)` - Broadcast to all agents
+- `getMessages(options?)` - Get received messages
+- `markRead(messageIds)` - Mark messages as read
+
+### `pc.sessions`
+
+- `create(name, options?)` - Create an orchestration session
+- `end(sessionId)` - End a session
+- `getActive()` - Get active sessions
+
+## License
+
+[FSL-1.1-MIT](LICENSE)
+

package/dist/index.d.ts

@@ -0,0 +1,203 @@
+/**
+ * Private Connect SDK
+ *
+ * Programmatic access to Private Connect services and agent orchestration.
+ *
+ * @example
+ * ```typescript
+ * import { PrivateConnect } from '@privateconnect/sdk';
+ *
+ * const pc = new PrivateConnect({ apiKey: 'your-api-key' });
+ *
+ * // Connect to a service
+ * const db = await pc.connect('postgres-prod');
+ * console.log(db.connectionString); // postgres://localhost:5432/...
+ *
+ * // List all agents
+ * const agents = await pc.agents.list();
+ *
+ * // Send message to another agent
+ * await pc.agents.sendMessage(targetAgentId, { action: 'deploy' });
+ * ```
+ */
+export interface PrivateConnectConfig {
+    /** API key for authentication */
+    apiKey: string;
+    /** Hub URL (default: https://api.privateconnect.co) */
+    hubUrl?: string;
+    /** Agent ID (auto-detected from config if not provided) */
+    agentId?: string;
+}
+export interface Service {
+    id: string;
+    name: string;
+    targetHost: string;
+    targetPort: number;
+    tunnelPort?: number;
+    protocol: string;
+    status: string;
+    agentLabel?: string;
+}
+export interface Agent {
+    id: string;
+    name?: string;
+    label: string;
+    isOnline: boolean;
+    lastSeenAt: string;
+    capabilities: string[];
+    services: string[];
+}
+export interface Connection {
+    service: string;
+    host: string;
+    port: number;
+    connectionString: string;
+    envVar: string;
+}
+export interface Message {
+    id: string;
+    from: {
+        id: string;
+        name?: string;
+        label?: string;
+    };
+    channel: string;
+    type: string;
+    payload: Record<string, unknown>;
+    createdAt: string;
+    isRead: boolean;
+}
+export interface Session {
+    id: string;
+    name: string;
+    createdBy: string;
+    createdAt: string;
+    expiresAt: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Agents API for discovery and orchestration
+ */
+export declare class AgentsAPI {
+    private client;
+    constructor(client: PrivateConnect);
+    /**
+     * List all agents in the workspace
+     */
+    list(options?: {
+        onlineOnly?: boolean;
+    }): Promise<Agent[]>;
+    /**
+     * Find agents by capability
+     */
+    findByCapability(capability: string): Promise<Agent[]>;
+    /**
+     * Register capabilities for this agent
+     */
+    registerCapabilities(capabilities: Array<{
+        name: string;
+        metadata?: Record<string, unknown>;
+    }>): Promise<void>;
+    /**
+     * Send a message to another agent
+     */
+    sendMessage(toAgentId: string, payload: Record<string, unknown>, options?: {
+        channel?: string;
+        type?: 'request' | 'response' | 'event';
+    }): Promise<{
+        messageId: string;
+    }>;
+    /**
+     * Broadcast a message to all online agents
+     */
+    broadcast(payload: Record<string, unknown>, options?: {
+        channel?: string;
+    }): Promise<{
+        sent: number;
+    }>;
+    /**
+     * Get messages for this agent
+     */
+    getMessages(options?: {
+        channel?: string;
+        unreadOnly?: boolean;
+        limit?: number;
+    }): Promise<Message[]>;
+    /**
+     * Mark messages as read
+     */
+    markRead(messageIds: string[]): Promise<void>;
+}
+/**
+ * Services API for connecting to and managing services
+ */
+export declare class ServicesAPI {
+    private client;
+    constructor(client: PrivateConnect);
+    /**
+     * List all services
+     */
+    list(): Promise<Service[]>;
+    /**
+     * Get a specific service by name
+     */
+    get(name: string): Promise<Service | null>;
+    /**
+     * Get connection details for a service
+     */
+    getConnection(serviceName: string): Promise<Connection>;
+}
+/**
+ * Sessions API for ephemeral orchestration sessions
+ */
+export declare class SessionsAPI {
+    private client;
+    private activeSessions;
+    constructor(client: PrivateConnect);
+    /**
+     * Create an orchestration session
+     */
+    create(name: string, options?: {
+        ttlMinutes?: number;
+        metadata?: Record<string, unknown>;
+    }): Promise<Session>;
+    /**
+     * End an orchestration session
+     */
+    end(sessionId: string): Promise<void>;
+    /**
+     * Get active sessions
+     */
+    getActive(): Session[];
+}
+/**
+ * Main Private Connect SDK client
+ */
+export declare class PrivateConnect {
+    private config;
+    /** Agents API for discovery and orchestration */
+    agents: AgentsAPI;
+    /** Services API for connecting to services */
+    services: ServicesAPI;
+    /** Sessions API for ephemeral orchestration */
+    sessions: SessionsAPI;
+    constructor(config: PrivateConnectConfig);
+    /**
+     * Get the agent ID
+     */
+    get agentId(): string | undefined;
+    /**
+     * Connect to a service and get connection details
+     */
+    connect(serviceName: string): Promise<Connection>;
+    /**
+     * Internal fetch helper
+     */
+    fetch(path: string, options?: RequestInit): Promise<Response>;
+    /**
+     * Try to detect agent ID from local config
+     */
+    private detectAgentId;
+}
+export default PrivateConnect;
+export declare function connect(serviceName: string, config?: PrivateConnectConfig): Promise<Connection>;

package/dist/index.js

@@ -0,0 +1,309 @@
+"use strict";
+/**
+ * Private Connect SDK
+ *
+ * Programmatic access to Private Connect services and agent orchestration.
+ *
+ * @example
+ * ```typescript
+ * import { PrivateConnect } from '@privateconnect/sdk';
+ *
+ * const pc = new PrivateConnect({ apiKey: 'your-api-key' });
+ *
+ * // Connect to a service
+ * const db = await pc.connect('postgres-prod');
+ * console.log(db.connectionString); // postgres://localhost:5432/...
+ *
+ * // List all agents
+ * const agents = await pc.agents.list();
+ *
+ * // Send message to another agent
+ * await pc.agents.sendMessage(targetAgentId, { action: 'deploy' });
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrivateConnect = exports.SessionsAPI = exports.ServicesAPI = exports.AgentsAPI = void 0;
+exports.connect = connect;
+/**
+ * Agents API for discovery and orchestration
+ */
+class AgentsAPI {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * List all agents in the workspace
+     */
+    async list(options) {
+        const response = await this.client.fetch('/v1/agents/orchestration');
+        const data = await response.json();
+        let agents = data.agents || [];
+        if (options?.onlineOnly) {
+            agents = agents.filter((a) => a.isOnline);
+        }
+        return agents.map((a) => ({
+            id: a.id,
+            name: a.name,
+            label: a.label,
+            isOnline: a.isOnline,
+            lastSeenAt: a.lastSeenAt,
+            capabilities: a.capabilities?.map((c) => c.name) || [],
+            services: a.services?.map((s) => s.name) || [],
+        }));
+    }
+    /**
+     * Find agents by capability
+     */
+    async findByCapability(capability) {
+        const response = await this.client.fetch(`/v1/agents/by-capability/${encodeURIComponent(capability)}`);
+        const data = await response.json();
+        return data.agents || [];
+    }
+    /**
+     * Register capabilities for this agent
+     */
+    async registerCapabilities(capabilities) {
+        await this.client.fetch(`/v1/agents/${this.client.agentId}/capabilities`, {
+            method: 'POST',
+            body: JSON.stringify({ capabilities }),
+        });
+    }
+    /**
+     * Send a message to another agent
+     */
+    async sendMessage(toAgentId, payload, options) {
+        const response = await this.client.fetch(`/v1/agents/${this.client.agentId}/messages/send`, {
+            method: 'POST',
+            body: JSON.stringify({ toAgentId, payload, ...options }),
+        });
+        return response.json();
+    }
+    /**
+     * Broadcast a message to all online agents
+     */
+    async broadcast(payload, options) {
+        const response = await this.client.fetch(`/v1/agents/${this.client.agentId}/messages/broadcast`, {
+            method: 'POST',
+            body: JSON.stringify({ payload, ...options }),
+        });
+        return response.json();
+    }
+    /**
+     * Get messages for this agent
+     */
+    async getMessages(options) {
+        const params = new URLSearchParams();
+        if (options?.channel)
+            params.set('channel', options.channel);
+        if (options?.unreadOnly !== undefined)
+            params.set('unreadOnly', String(options.unreadOnly));
+        if (options?.limit)
+            params.set('limit', String(options.limit));
+        const response = await this.client.fetch(`/v1/agents/${this.client.agentId}/messages?${params}`);
+        const data = await response.json();
+        return data.messages || [];
+    }
+    /**
+     * Mark messages as read
+     */
+    async markRead(messageIds) {
+        await this.client.fetch(`/v1/agents/${this.client.agentId}/messages/read`, {
+            method: 'POST',
+            body: JSON.stringify({ messageIds }),
+        });
+    }
+}
+exports.AgentsAPI = AgentsAPI;
+/**
+ * Services API for connecting to and managing services
+ */
+class ServicesAPI {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * List all services
+     */
+    async list() {
+        const response = await this.client.fetch('/v1/services');
+        return response.json();
+    }
+    /**
+     * Get a specific service by name
+     */
+    async get(name) {
+        const services = await this.list();
+        return services.find(s => s.name.toLowerCase() === name.toLowerCase()) || null;
+    }
+    /**
+     * Get connection details for a service
+     */
+    async getConnection(serviceName) {
+        const service = await this.get(serviceName);
+        if (!service) {
+            throw new Error(`Service "${serviceName}" not found`);
+        }
+        const port = service.tunnelPort || service.targetPort;
+        const host = 'localhost';
+        let connectionString = '';
+        let envVar = 'SERVICE_URL';
+        if (service.targetPort === 5432 || service.protocol === 'postgres') {
+            connectionString = `postgres://${host}:${port}/postgres`;
+            envVar = 'DATABASE_URL';
+        }
+        else if (service.targetPort === 3306 || service.protocol === 'mysql') {
+            connectionString = `mysql://${host}:${port}`;
+            envVar = 'DATABASE_URL';
+        }
+        else if (service.targetPort === 6379 || service.protocol === 'redis') {
+            connectionString = `redis://${host}:${port}`;
+            envVar = 'REDIS_URL';
+        }
+        else if (service.targetPort === 27017 || service.protocol === 'mongodb') {
+            connectionString = `mongodb://${host}:${port}`;
+            envVar = 'MONGODB_URI';
+        }
+        else if (service.protocol === 'http' || service.protocol === 'https') {
+            connectionString = `http://${host}:${port}`;
+            envVar = 'API_URL';
+        }
+        else {
+            connectionString = `tcp://${host}:${port}`;
+            envVar = `${serviceName.toUpperCase().replace(/-/g, '_')}_URL`;
+        }
+        return {
+            service: serviceName,
+            host,
+            port,
+            connectionString,
+            envVar,
+        };
+    }
+}
+exports.ServicesAPI = ServicesAPI;
+/**
+ * Sessions API for ephemeral orchestration sessions
+ */
+class SessionsAPI {
+    constructor(client) {
+        this.client = client;
+        this.activeSessions = new Map();
+    }
+    /**
+     * Create an orchestration session
+     */
+    async create(name, options) {
+        const ttlMinutes = options?.ttlMinutes || 60;
+        const sessionId = `${this.client.agentId}-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+        const expiresAt = new Date(Date.now() + ttlMinutes * 60 * 1000);
+        const session = {
+            id: sessionId,
+            name,
+            createdBy: this.client.agentId,
+            createdAt: new Date().toISOString(),
+            expiresAt: expiresAt.toISOString(),
+            metadata: options?.metadata,
+        };
+        this.activeSessions.set(sessionId, session);
+        // Broadcast session creation
+        await this.client.agents.broadcast({ type: 'session:created', session }, { channel: 'orchestration' });
+        return session;
+    }
+    /**
+     * End an orchestration session
+     */
+    async end(sessionId) {
+        this.activeSessions.delete(sessionId);
+        // Broadcast session end
+        await this.client.agents.broadcast({
+            type: 'session:ended',
+            sessionId,
+            endedBy: this.client.agentId,
+            endedAt: new Date().toISOString(),
+        }, { channel: 'orchestration' });
+    }
+    /**
+     * Get active sessions
+     */
+    getActive() {
+        const now = new Date();
+        const active = [];
+        for (const [id, session] of this.activeSessions) {
+            if (new Date(session.expiresAt) > now) {
+                active.push(session);
+            }
+            else {
+                this.activeSessions.delete(id);
+            }
+        }
+        return active;
+    }
+}
+exports.SessionsAPI = SessionsAPI;
+/**
+ * Main Private Connect SDK client
+ */
+class PrivateConnect {
+    constructor(config) {
+        this.config = {
+            apiKey: config.apiKey,
+            hubUrl: config.hubUrl || 'https://api.privateconnect.co',
+            agentId: config.agentId || this.detectAgentId(),
+        };
+        this.agents = new AgentsAPI(this);
+        this.services = new ServicesAPI(this);
+        this.sessions = new SessionsAPI(this);
+    }
+    /**
+     * Get the agent ID
+     */
+    get agentId() {
+        return this.config.agentId;
+    }
+    /**
+     * Connect to a service and get connection details
+     */
+    async connect(serviceName) {
+        return this.services.getConnection(serviceName);
+    }
+    /**
+     * Internal fetch helper
+     */
+    async fetch(path, options) {
+        const url = `${this.config.hubUrl}${path}`;
+        const response = await fetch(url, {
+            ...options,
+            headers: {
+                'x-api-key': this.config.apiKey,
+                'Content-Type': 'application/json',
+                ...options?.headers,
+            },
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ message: 'Unknown error' }));
+            throw new Error(error.message || `Request failed: ${response.status}`);
+        }
+        return response;
+    }
+    /**
+     * Try to detect agent ID from local config
+     */
+    detectAgentId() {
+        // In a real implementation, this would read from ~/.connect/config.json
+        // For now, generate a default ID
+        return `sdk-${Date.now()}`;
+    }
+}
+exports.PrivateConnect = PrivateConnect;
+// Default export
+exports.default = PrivateConnect;
+// Convenience function
+async function connect(serviceName, config) {
+    const apiKey = config?.apiKey || process.env.PRIVATECONNECT_API_KEY;
+    if (!apiKey) {
+        throw new Error('API key required. Set PRIVATECONNECT_API_KEY or pass config.apiKey');
+    }
+    const client = new PrivateConnect({ ...config, apiKey });
+    return client.connect(serviceName);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Private Connect SDK\n * \n * Programmatic access to Private Connect services and agent orchestration.\n * \n * @example\n * ```typescript\n * import { PrivateConnect } from '@privateconnect/sdk';\n * \n * const pc = new PrivateConnect({ apiKey: 'your-api-key' });\n * \n * // Connect to a service\n * const db = await pc.connect('postgres-prod');\n * console.log(db.connectionString); // postgres://localhost:5432/...\n * \n * // List all agents\n * const agents = await pc.agents.list();\n * \n * // Send message to another agent\n * await pc.agents.sendMessage(targetAgentId, { action: 'deploy' });\n * ```\n */\n\nexport interface PrivateConnectConfig {\n  /** API key for authentication */\n  apiKey: string;\n  /** Hub URL (default: https://api.privateconnect.co) */\n  hubUrl?: string;\n  /** Agent ID (auto-detected from config if not provided) */\n  agentId?: string;\n}\n\nexport interface Service {\n  id: string;\n  name: string;\n  targetHost: string;\n  targetPort: number;\n  tunnelPort?: number;\n  protocol: string;\n  status: string;\n  agentLabel?: string;\n}\n\nexport interface Agent {\n  id: string;\n  name?: string;\n  label: string;\n  isOnline: boolean;\n  lastSeenAt: string;\n  capabilities: string[];\n  services: string[];\n}\n\nexport interface Connection {\n  service: string;\n  host: string;\n  port: number;\n  connectionString: string;\n  envVar: string;\n}\n\nexport interface Message {\n  id: string;\n  from: { id: string; name?: string; label?: string };\n  channel: string;\n  type: string;\n  payload: Record<string, unknown>;\n  createdAt: string;\n  isRead: boolean;\n}\n\nexport interface Session {\n  id: string;\n  name: string;\n  createdBy: string;\n  createdAt: string;\n  expiresAt: string;\n  metadata?: Record<string, unknown>;\n}\n\n/**\n * Agents API for discovery and orchestration\n */\nexport class AgentsAPI {\n  constructor(private client: PrivateConnect) {}\n\n  /**\n   * List all agents in the workspace\n   */\n  async list(options?: { onlineOnly?: boolean }): Promise<Agent[]> {\n    const response = await this.client.fetch('/v1/agents/orchestration');\n    const data = await response.json();\n    let agents = data.agents || [];\n    \n    if (options?.onlineOnly) {\n      agents = agents.filter((a: any) => a.isOnline);\n    }\n    \n    return agents.map((a: any) => ({\n      id: a.id,\n      name: a.name,\n      label: a.label,\n      isOnline: a.isOnline,\n      lastSeenAt: a.lastSeenAt,\n      capabilities: a.capabilities?.map((c: any) => c.name) || [],\n      services: a.services?.map((s: any) => s.name) || [],\n    }));\n  }\n\n  /**\n   * Find agents by capability\n   */\n  async findByCapability(capability: string): Promise<Agent[]> {\n    const response = await this.client.fetch(`/v1/agents/by-capability/${encodeURIComponent(capability)}`);\n    const data = await response.json();\n    return data.agents || [];\n  }\n\n  /**\n   * Register capabilities for this agent\n   */\n  async registerCapabilities(capabilities: Array<{ name: string; metadata?: Record<string, unknown> }>): Promise<void> {\n    await this.client.fetch(`/v1/agents/${this.client.agentId}/capabilities`, {\n      method: 'POST',\n      body: JSON.stringify({ capabilities }),\n    });\n  }\n\n  /**\n   * Send a message to another agent\n   */\n  async sendMessage(\n    toAgentId: string,\n    payload: Record<string, unknown>,\n    options?: { channel?: string; type?: 'request' | 'response' | 'event' }\n  ): Promise<{ messageId: string }> {\n    const response = await this.client.fetch(`/v1/agents/${this.client.agentId}/messages/send`, {\n      method: 'POST',\n      body: JSON.stringify({ toAgentId, payload, ...options }),\n    });\n    return response.json();\n  }\n\n  /**\n   * Broadcast a message to all online agents\n   */\n  async broadcast(\n    payload: Record<string, unknown>,\n    options?: { channel?: string }\n  ): Promise<{ sent: number }> {\n    const response = await this.client.fetch(`/v1/agents/${this.client.agentId}/messages/broadcast`, {\n      method: 'POST',\n      body: JSON.stringify({ payload, ...options }),\n    });\n    return response.json();\n  }\n\n  /**\n   * Get messages for this agent\n   */\n  async getMessages(options?: { channel?: string; unreadOnly?: boolean; limit?: number }): Promise<Message[]> {\n    const params = new URLSearchParams();\n    if (options?.channel) params.set('channel', options.channel);\n    if (options?.unreadOnly !== undefined) params.set('unreadOnly', String(options.unreadOnly));\n    if (options?.limit) params.set('limit', String(options.limit));\n    \n    const response = await this.client.fetch(`/v1/agents/${this.client.agentId}/messages?${params}`);\n    const data = await response.json();\n    return data.messages || [];\n  }\n\n  /**\n   * Mark messages as read\n   */\n  async markRead(messageIds: string[]): Promise<void> {\n    await this.client.fetch(`/v1/agents/${this.client.agentId}/messages/read`, {\n      method: 'POST',\n      body: JSON.stringify({ messageIds }),\n    });\n  }\n}\n\n/**\n * Services API for connecting to and managing services\n */\nexport class ServicesAPI {\n  constructor(private client: PrivateConnect) {}\n\n  /**\n   * List all services\n   */\n  async list(): Promise<Service[]> {\n    const response = await this.client.fetch('/v1/services');\n    return response.json();\n  }\n\n  /**\n   * Get a specific service by name\n   */\n  async get(name: string): Promise<Service | null> {\n    const services = await this.list();\n    return services.find(s => s.name.toLowerCase() === name.toLowerCase()) || null;\n  }\n\n  /**\n   * Get connection details for a service\n   */\n  async getConnection(serviceName: string): Promise<Connection> {\n    const service = await this.get(serviceName);\n    if (!service) {\n      throw new Error(`Service \"${serviceName}\" not found`);\n    }\n\n    const port = service.tunnelPort || service.targetPort;\n    const host = 'localhost';\n    \n    let connectionString = '';\n    let envVar = 'SERVICE_URL';\n    \n    if (service.targetPort === 5432 || service.protocol === 'postgres') {\n      connectionString = `postgres://${host}:${port}/postgres`;\n      envVar = 'DATABASE_URL';\n    } else if (service.targetPort === 3306 || service.protocol === 'mysql') {\n      connectionString = `mysql://${host}:${port}`;\n      envVar = 'DATABASE_URL';\n    } else if (service.targetPort === 6379 || service.protocol === 'redis') {\n      connectionString = `redis://${host}:${port}`;\n      envVar = 'REDIS_URL';\n    } else if (service.targetPort === 27017 || service.protocol === 'mongodb') {\n      connectionString = `mongodb://${host}:${port}`;\n      envVar = 'MONGODB_URI';\n    } else if (service.protocol === 'http' || service.protocol === 'https') {\n      connectionString = `http://${host}:${port}`;\n      envVar = 'API_URL';\n    } else {\n      connectionString = `tcp://${host}:${port}`;\n      envVar = `${serviceName.toUpperCase().replace(/-/g, '_')}_URL`;\n    }\n\n    return {\n      service: serviceName,\n      host,\n      port,\n      connectionString,\n      envVar,\n    };\n  }\n}\n\n/**\n * Sessions API for ephemeral orchestration sessions\n */\nexport class SessionsAPI {\n  private activeSessions = new Map<string, Session>();\n\n  constructor(private client: PrivateConnect) {}\n\n  /**\n   * Create an orchestration session\n   */\n  async create(name: string, options?: { ttlMinutes?: number; metadata?: Record<string, unknown> }): Promise<Session> {\n    const ttlMinutes = options?.ttlMinutes || 60;\n    const sessionId = `${this.client.agentId}-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;\n    const expiresAt = new Date(Date.now() + ttlMinutes * 60 * 1000);\n\n    const session: Session = {\n      id: sessionId,\n      name,\n      createdBy: this.client.agentId!,\n      createdAt: new Date().toISOString(),\n      expiresAt: expiresAt.toISOString(),\n      metadata: options?.metadata,\n    };\n\n    this.activeSessions.set(sessionId, session);\n\n    // Broadcast session creation\n    await this.client.agents.broadcast(\n      { type: 'session:created', session },\n      { channel: 'orchestration' }\n    );\n\n    return session;\n  }\n\n  /**\n   * End an orchestration session\n   */\n  async end(sessionId: string): Promise<void> {\n    this.activeSessions.delete(sessionId);\n\n    // Broadcast session end\n    await this.client.agents.broadcast(\n      {\n        type: 'session:ended',\n        sessionId,\n        endedBy: this.client.agentId,\n        endedAt: new Date().toISOString(),\n      },\n      { channel: 'orchestration' }\n    );\n  }\n\n  /**\n   * Get active sessions\n   */\n  getActive(): Session[] {\n    const now = new Date();\n    const active: Session[] = [];\n    \n    for (const [id, session] of this.activeSessions) {\n      if (new Date(session.expiresAt) > now) {\n        active.push(session);\n      } else {\n        this.activeSessions.delete(id);\n      }\n    }\n    \n    return active;\n  }\n}\n\n/**\n * Main Private Connect SDK client\n */\nexport class PrivateConnect {\n  private config: Required<PrivateConnectConfig>;\n  \n  /** Agents API for discovery and orchestration */\n  public agents: AgentsAPI;\n  \n  /** Services API for connecting to services */\n  public services: ServicesAPI;\n  \n  /** Sessions API for ephemeral orchestration */\n  public sessions: SessionsAPI;\n\n  constructor(config: PrivateConnectConfig) {\n    this.config = {\n      apiKey: config.apiKey,\n      hubUrl: config.hubUrl || 'https://api.privateconnect.co',\n      agentId: config.agentId || this.detectAgentId(),\n    };\n\n    this.agents = new AgentsAPI(this);\n    this.services = new ServicesAPI(this);\n    this.sessions = new SessionsAPI(this);\n  }\n\n  /**\n   * Get the agent ID\n   */\n  get agentId(): string | undefined {\n    return this.config.agentId;\n  }\n\n  /**\n   * Connect to a service and get connection details\n   */\n  async connect(serviceName: string): Promise<Connection> {\n    return this.services.getConnection(serviceName);\n  }\n\n  /**\n   * Internal fetch helper\n   */\n  async fetch(path: string, options?: RequestInit): Promise<Response> {\n    const url = `${this.config.hubUrl}${path}`;\n    const response = await fetch(url, {\n      ...options,\n      headers: {\n        'x-api-key': this.config.apiKey,\n        'Content-Type': 'application/json',\n        ...options?.headers,\n      },\n    });\n\n    if (!response.ok) {\n      const error = await response.json().catch(() => ({ message: 'Unknown error' }));\n      throw new Error(error.message || `Request failed: ${response.status}`);\n    }\n\n    return response;\n  }\n\n  /**\n   * Try to detect agent ID from local config\n   */\n  private detectAgentId(): string {\n    // In a real implementation, this would read from ~/.connect/config.json\n    // For now, generate a default ID\n    return `sdk-${Date.now()}`;\n  }\n}\n\n// Default export\nexport default PrivateConnect;\n\n// Convenience function\nexport async function connect(serviceName: string, config?: PrivateConnectConfig): Promise<Connection> {\n  const apiKey = config?.apiKey || process.env.PRIVATECONNECT_API_KEY;\n  if (!apiKey) {\n    throw new Error('API key required. Set PRIVATECONNECT_API_KEY or pass config.apiKey');\n  }\n  \n  const client = new PrivateConnect({ ...config, apiKey });\n  return client.connect(serviceName);\n}\n\n"]}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@privateconnect/sdk",
+  "version": "0.3.0",
+  "description": "TypeScript SDK for Private Connect - programmatic access to services and agent orchestration",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w",
+    "clean": "rm -rf dist"
+  },
+  "keywords": [
+    "private-connect",
+    "tunnel",
+    "networking",
+    "orchestration",
+    "agent"
+  ],
+  "license": "FSL-1.1-MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/treadiehq/private-connect.git",
+    "directory": "packages/sdk"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  }
+}
+