@agentconnect/sdk 0.1.2 → 0.1.5

package/README.md

@@ -70,9 +70,9 @@ session.on('raw_line', (event) => {
   console.log('CLI:', event.line);
 });
 
-session.on('provider_event', (event) => {
+session.on('detail', (event) => {
   if (event.provider === 'codex') {
-    console.log('Codex event:', event.event);
+    console.log('Codex detail:', event.providerDetail);
   }
 });
 ```

package/dist/host.d.ts

@@ -0,0 +1,10 @@
+export type EnsureHostOptions = {
+    host?: string;
+    port?: number;
+    appPath?: string;
+    cliPackage?: string;
+    runtime?: string;
+    timeoutMs?: number;
+    debug?: boolean;
+};
+export declare function ensureAgentConnectHost(options?: EnsureHostOptions): Promise<void>;

package/dist/host.js

@@ -0,0 +1,184 @@
+import fs from 'fs';
+import net from 'net';
+import path from 'path';
+import { spawn } from 'child_process';
+const HOST_KEY = '__agentconnectHostState__';
+function getState() {
+    const globalAny = globalThis;
+    if (!globalAny[HOST_KEY]) {
+        globalAny[HOST_KEY] = { status: 'idle' };
+    }
+    return globalAny[HOST_KEY];
+}
+function findExecutable(name) {
+    const envPath = process.env.PATH || '';
+    const extensions = process.platform === 'win32' ? ['.exe', '.cmd', '.bat', ''] : [''];
+    for (const entry of envPath.split(path.delimiter)) {
+        if (!entry)
+            continue;
+        for (const ext of extensions) {
+            const candidate = path.join(entry, `${name}${ext}`);
+            try {
+                fs.accessSync(candidate, fs.constants.X_OK);
+                return candidate;
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    return null;
+}
+function findPackageRoot(startDir, pkgName) {
+    let current = startDir;
+    while (true) {
+        const candidate = path.join(current, 'node_modules', pkgName, 'package.json');
+        if (fs.existsSync(candidate))
+            return path.dirname(candidate);
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return null;
+}
+function resolveCliEntry(appPath, cliPackage) {
+    const pkgRoot = findPackageRoot(appPath, cliPackage);
+    if (!pkgRoot) {
+        throw new Error(`AgentConnect CLI not found. Install ${cliPackage} and retry.`);
+    }
+    const pkgJsonPath = path.join(pkgRoot, 'package.json');
+    const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
+    let entry = pkg.main || 'dist/index.js';
+    if (typeof pkg.bin === 'string') {
+        entry = pkg.bin;
+    }
+    else if (pkg.bin && typeof pkg.bin === 'object') {
+        entry = pkg.bin.agentconnect || entry;
+    }
+    const resolved = path.join(pkgRoot, entry);
+    if (!fs.existsSync(resolved)) {
+        throw new Error(`AgentConnect CLI entry not found at ${resolved}`);
+    }
+    return resolved;
+}
+function resolveRuntime(runtime) {
+    if (runtime)
+        return runtime;
+    const override = process.env.AGENTCONNECT_NODE;
+    if (override)
+        return override;
+    if (!process.execPath.toLowerCase().includes('bun'))
+        return process.execPath;
+    return findExecutable('node') || 'node';
+}
+function isPortOpen(host, port, timeoutMs = 300) {
+    return new Promise((resolve) => {
+        const socket = new net.Socket();
+        const finalize = (result) => {
+            socket.destroy();
+            resolve(result);
+        };
+        socket.setTimeout(timeoutMs);
+        socket.once('error', () => finalize(false));
+        socket.once('timeout', () => finalize(false));
+        socket.connect(port, host, () => finalize(true));
+    });
+}
+async function waitForPort(host, port, child, timeoutMs) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        if (await isPortOpen(host, port))
+            return true;
+        if (child?.exitCode !== null)
+            return false;
+        await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    return isPortOpen(host, port);
+}
+function registerCleanup(state) {
+    if (state.cleanupRegistered)
+        return;
+    state.cleanupRegistered = true;
+    process.on('exit', () => {
+        state.child?.kill('SIGTERM');
+    });
+    process.on('SIGINT', () => {
+        state.child?.kill('SIGTERM');
+        process.exit(0);
+    });
+}
+async function startHost(options, state) {
+    const cliPath = resolveCliEntry(options.appPath, options.cliPackage);
+    const args = [
+        cliPath,
+        'dev',
+        '--host',
+        options.host,
+        '--port',
+        String(options.port),
+        '--app',
+        options.appPath,
+    ];
+    const runtime = resolveRuntime(options.runtime);
+    if (options.debug) {
+        console.info('[AgentConnect][Host] starting', { runtime, args });
+    }
+    const child = spawn(runtime, args, { stdio: options.debug ? 'pipe' : 'ignore' });
+    state.child = child;
+    state.status = 'starting';
+    registerCleanup(state);
+    if (options.debug) {
+        child.stdout?.on('data', (chunk) => {
+            console.info('[AgentConnect][Host]', String(chunk).trim());
+        });
+        child.stderr?.on('data', (chunk) => {
+            console.error('[AgentConnect][Host]', String(chunk).trim());
+        });
+    }
+    child.on('error', (error) => {
+        if (options.debug) {
+            console.error('[AgentConnect][Host] spawn error', error);
+        }
+    });
+    child.on('exit', () => {
+        if (state.child === child) {
+            state.status = 'idle';
+            state.child = undefined;
+        }
+    });
+    const started = await waitForPort(options.host, options.port, child, options.timeoutMs);
+    if (!started) {
+        child.kill('SIGTERM');
+        throw new Error('AgentConnect host failed to start. Ensure Node.js 20+ is installed.');
+    }
+    state.status = 'running';
+}
+export async function ensureAgentConnectHost(options = {}) {
+    const state = getState();
+    const resolvedOptions = {
+        host: options.host || process.env.AGENTCONNECT_HOST || '127.0.0.1',
+        port: options.port || Number(process.env.AGENTCONNECT_PORT || 9630),
+        appPath: options.appPath || process.env.AGENTCONNECT_APP_PATH || process.cwd(),
+        cliPackage: options.cliPackage || process.env.AGENTCONNECT_CLI_PACKAGE || '@agentconnect/cli',
+        runtime: options.runtime || '',
+        timeoutMs: options.timeoutMs || 8000,
+        debug: options.debug ?? process.env.AGENTCONNECT_DEBUG === '1',
+    };
+    if (await isPortOpen(resolvedOptions.host, resolvedOptions.port)) {
+        state.status = 'running';
+        return;
+    }
+    if (state.startPromise)
+        return state.startPromise;
+    state.startPromise = startHost(resolvedOptions, state)
+        .catch((error) => {
+        state.status = 'idle';
+        state.child = undefined;
+        throw error;
+    })
+        .finally(() => {
+        state.startPromise = undefined;
+    });
+    return state.startPromise;
+}

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export type ProviderId = 'claude' | 'codex' | 'local';
+export type ProviderId = 'claude' | 'codex' | 'cursor' | 'local';
 export type PackageManager = 'bun' | 'pnpm' | 'npm' | 'brew' | 'unknown';
 export type InstallResult = {
     installed: boolean;
@@ -11,6 +11,13 @@ export type ProviderInfo = {
     installed: boolean;
     loggedIn: boolean;
     version?: string;
+    updateAvailable?: boolean;
+    latestVersion?: string;
+    updateCheckedAt?: number;
+    updateSource?: 'cli' | 'npm' | 'bun' | 'brew' | 'winget' | 'script' | 'unknown';
+    updateCommand?: string;
+    updateMessage?: string;
+    updateInProgress?: boolean;
 };
 export type ReasoningEffortOption = {
     id: string;
@@ -25,30 +32,74 @@ export type ModelInfo = {
     reasoningEfforts?: ReasoningEffortOption[];
     defaultReasoningEffort?: string;
 };
+export type ProviderDetailLevel = 'minimal' | 'raw';
+export type ProviderDetail = {
+    eventType: string;
+    data?: Record<string, unknown>;
+    raw?: unknown;
+};
 export type SessionEvent = {
     type: 'delta';
     text: string;
+    providerSessionId?: string | null;
+    providerDetail?: ProviderDetail;
 } | {
     type: 'final';
     text: string;
     providerSessionId?: string | null;
+    providerDetail?: ProviderDetail;
 } | {
     type: 'usage';
     usage: Record<string, number>;
+    providerSessionId?: string | null;
+    providerDetail?: ProviderDetail;
 } | {
     type: 'status';
     status: 'thinking' | 'idle' | 'error';
     error?: string;
+    providerSessionId?: string | null;
+    providerDetail?: ProviderDetail;
 } | {
     type: 'error';
     message: string;
+    providerSessionId?: string | null;
+    providerDetail?: ProviderDetail;
 } | {
     type: 'raw_line';
     line: string;
+    providerSessionId?: string | null;
+    providerDetail?: ProviderDetail;
+} | {
+    type: 'message';
+    provider?: ProviderId;
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+    contentParts?: unknown;
+    providerSessionId?: string | null;
+    providerDetail?: ProviderDetail;
 } | {
-    type: 'provider_event';
+    type: 'thinking';
     provider?: ProviderId;
-    event: Record<string, unknown>;
+    phase: 'delta' | 'start' | 'completed' | 'error';
+    text?: string;
+    timestampMs?: number;
+    providerSessionId?: string | null;
+    providerDetail?: ProviderDetail;
+} | {
+    type: 'tool_call';
+    provider?: ProviderId;
+    name?: string;
+    callId?: string;
+    input?: unknown;
+    output?: unknown;
+    phase?: 'delta' | 'start' | 'completed' | 'error';
+    providerSessionId?: string | null;
+    providerDetail?: ProviderDetail;
+} | {
+    type: 'detail';
+    provider?: ProviderId;
+    providerSessionId?: string | null;
+    providerDetail: ProviderDetail;
 };
 export type ProviderLoginOptions = {
     baseUrl?: string;
@@ -74,11 +125,13 @@ export type SessionCreateOptions = {
     temperature?: number;
     maxTokens?: number;
     topP?: number;
+    providerDetailLevel?: ProviderDetailLevel;
 };
 export type SessionSendOptions = {
     metadata?: Record<string, unknown>;
     cwd?: string;
     repoRoot?: string;
+    providerDetailLevel?: ProviderDetailLevel;
 };
 export type SessionResumeOptions = {
     model?: string;
@@ -86,6 +139,7 @@ export type SessionResumeOptions = {
     providerSessionId?: string | null;
     cwd?: string;
     repoRoot?: string;
+    providerDetailLevel?: ProviderDetailLevel;
 };
 export interface AgentConnectSession {
     id: string;
@@ -111,6 +165,7 @@ export interface AgentConnectClient {
         list(): Promise<ProviderInfo[]>;
         status(provider: ProviderId): Promise<ProviderInfo>;
         ensureInstalled(provider: ProviderId): Promise<InstallResult>;
+        update(provider: ProviderId): Promise<ProviderInfo>;
         login(provider: ProviderId, options?: ProviderLoginOptions): Promise<{
             loggedIn: boolean;
         }>;

package/dist/index.js

@@ -161,6 +161,7 @@ class AgentConnectSessionImpl {
             metadata: normalized.metadata,
             cwd: normalized.cwd,
             repoRoot: normalized.repoRoot,
+            providerDetailLevel: normalized.providerDetailLevel,
         });
     }
     async cancel() {
@@ -199,7 +200,8 @@ class AgentConnectSessionImpl {
         const candidate = options;
         if ('metadata' in candidate ||
             'cwd' in candidate ||
-            'repoRoot' in candidate) {
+            'repoRoot' in candidate ||
+            'providerDetailLevel' in candidate) {
             return candidate;
         }
         return { metadata: options };
@@ -228,8 +230,34 @@ class AgentConnectClientImpl {
         });
     }
     normalizeEvent(type, data) {
+        const parseProviderDetail = () => {
+            const detail = data?.providerDetail;
+            if (!detail || typeof detail !== 'object')
+                return undefined;
+            const record = detail;
+            const eventType = typeof record.eventType === 'string' ? record.eventType : '';
+            if (!eventType)
+                return undefined;
+            const raw = 'raw' in record ? record.raw : undefined;
+            const dataField = record.data && typeof record.data === 'object'
+                ? record.data
+                : undefined;
+            const out = { eventType };
+            if (dataField)
+                out.data = dataField;
+            if (raw !== undefined)
+                out.raw = raw;
+            return out;
+        };
+        const providerDetail = parseProviderDetail();
+        const providerSessionId = typeof data?.providerSessionId === 'string' ? data.providerSessionId : undefined;
         if (type === 'delta') {
-            return { type: 'delta', text: String(data?.text ?? '') };
+            return {
+                type: 'delta',
+                text: String(data?.text ?? ''),
+                providerSessionId,
+                ...(providerDetail && { providerDetail }),
+            };
         }
         if (type === 'final') {
             const providerSessionId = typeof data?.providerSessionId === 'string'
@@ -237,28 +265,110 @@ class AgentConnectClientImpl {
                 : typeof data?.sessionId === 'string'
                     ? data.sessionId
                     : undefined;
-            return { type: 'final', text: String(data?.text ?? ''), providerSessionId };
+            return {
+                type: 'final',
+                text: String(data?.text ?? ''),
+                providerSessionId,
+                ...(providerDetail && { providerDetail }),
+            };
         }
         if (type === 'usage') {
-            return { type: 'usage', usage: data?.usage ?? {} };
+            return {
+                type: 'usage',
+                usage: data?.usage ?? {},
+                providerSessionId,
+                ...(providerDetail && { providerDetail }),
+            };
         }
         if (type === 'status') {
             const status = String(data?.status ?? 'idle');
             const error = typeof data?.error === 'string' ? data.error : undefined;
-            return { type: 'status', status, error };
+            return {
+                type: 'status',
+                status,
+                error,
+                providerSessionId,
+                ...(providerDetail && { providerDetail }),
+            };
         }
         if (type === 'error') {
-            return { type: 'error', message: String(data?.message ?? 'Unknown error') };
+            return {
+                type: 'error',
+                message: String(data?.message ?? 'Unknown error'),
+                providerSessionId,
+                ...(providerDetail && { providerDetail }),
+            };
         }
         if (type === 'raw_line') {
-            return { type: 'raw_line', line: String(data?.line ?? '') };
+            return {
+                type: 'raw_line',
+                line: String(data?.line ?? ''),
+                providerSessionId,
+                ...(providerDetail && { providerDetail }),
+            };
+        }
+        if (type === 'message') {
+            const provider = typeof data?.provider === 'string' ? data.provider : undefined;
+            const role = data?.role === 'system' || data?.role === 'user' || data?.role === 'assistant'
+                ? data.role
+                : 'assistant';
+            const content = String(data?.content ?? '');
+            const contentParts = data?.contentParts;
+            return {
+                type: 'message',
+                provider,
+                role,
+                content,
+                contentParts,
+                providerSessionId,
+                providerDetail,
+            };
         }
-        if (type === 'provider_event') {
+        if (type === 'thinking') {
             const provider = typeof data?.provider === 'string' ? data.provider : undefined;
-            const event = data?.event && typeof data.event === 'object'
-                ? data.event
-                : {};
-            return { type: 'provider_event', provider, event };
+            const phase = data?.phase === 'start' ||
+                data?.phase === 'completed' ||
+                data?.phase === 'error' ||
+                data?.phase === 'delta'
+                ? data.phase
+                : 'delta';
+            const text = typeof data?.text === 'string' ? data.text : undefined;
+            const timestampMs = typeof data?.timestampMs === 'number' ? data.timestampMs : undefined;
+            return {
+                type: 'thinking',
+                provider,
+                phase,
+                text,
+                timestampMs,
+                providerSessionId,
+                providerDetail,
+            };
+        }
+        if (type === 'tool_call') {
+            const provider = typeof data?.provider === 'string' ? data.provider : undefined;
+            const name = typeof data?.name === 'string' ? data.name : undefined;
+            const callId = typeof data?.callId === 'string' ? data.callId : undefined;
+            const phase = data?.phase === 'start' ||
+                data?.phase === 'completed' ||
+                data?.phase === 'error' ||
+                data?.phase === 'delta'
+                ? data.phase
+                : undefined;
+            return {
+                type: 'tool_call',
+                provider,
+                name,
+                callId,
+                input: data?.input,
+                output: data?.output,
+                phase,
+                providerSessionId,
+                providerDetail,
+            };
+        }
+        if (type === 'detail' && providerDetail) {
+            const provider = typeof data?.provider === 'string' ? data.provider : undefined;
+            return { type: 'detail', provider, providerDetail, providerSessionId };
         }
         return null;
     }
@@ -280,6 +390,10 @@ class AgentConnectClientImpl {
             const res = (await this.request('acp.providers.status', { provider }));
             return res.provider;
         },
+        update: async (provider) => {
+            const res = (await this.request('acp.providers.update', { provider }));
+            return res.provider;
+        },
         ensureInstalled: async (provider) => {
             return (await this.request('acp.providers.ensureInstalled', { provider }));
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentconnect/sdk",
-  "version": "0.1.2",
+  "version": "0.1.5",
   "license": "MIT",
   "type": "module",
   "homepage": "https://github.com/rayzhudev/agent-connect",
@@ -19,6 +19,11 @@
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
+    },
+    "./host": {
+      "import": "./dist/host.js",
+      "types": "./dist/host.d.ts",
+      "default": "./dist/host.js"
     }
   },
   "files": [
@@ -29,6 +34,7 @@
     "dev": "tsc --watch"
   },
   "devDependencies": {
+    "@types/node": "^20.0.0",
     "typescript": "^5.6.2"
   },
   "engines": {