@pellux/goodvibes-sdk 0.18.14 → 0.18.16

package/dist/_internal/platform/runtime/remote/runner-registry.js

@@ -0,0 +1,377 @@
+import { mkdirSync } from 'node:fs';
+import { readFile, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+const DEFAULT_ARTIFACT_DIR = '.goodvibes/remote-artifacts';
+const DEFAULT_SESSION_BUNDLE_DIR = '.goodvibes/remote-sessions';
+function buildCapabilityCeiling(agent) {
+    return Object.freeze({
+        allowedTools: [...agent.tools],
+        capabilityCeilingTools: [...(agent.capabilityCeilingTools ?? agent.tools)],
+        executionProtocol: agent.executionProtocol,
+        reviewMode: agent.reviewMode,
+        communicationLane: agent.communicationLane,
+        orchestrationDepth: agent.orchestrationDepth,
+        successCriteria: [...(agent.successCriteria ?? [])],
+        requiredEvidence: [...(agent.requiredEvidence ?? [])],
+        writeScope: [...(agent.writeScope ?? [])],
+    });
+}
+function buildEvidenceSummary(agent, connection) {
+    return Object.freeze({
+        toolCallCount: agent.toolCallCount,
+        messageCount: connection?.messageCount ?? 0,
+        errorCount: connection?.errorCount ?? 0,
+        transportState: connection?.transportState ?? 'disconnected',
+        connectedAt: connection?.connectedAt,
+        lastError: connection?.lastError ?? agent.error,
+        hasKnowledgeInjections: (agent.knowledgeInjections?.length ?? 0) > 0,
+    });
+}
+function summarizeOutput(agent) {
+    const raw = agent.fullOutput ?? agent.progress ?? agent.error ?? 'No output recorded.';
+    const normalized = raw.replace(/\s+/g, ' ').trim();
+    return normalized.length <= 180 ? normalized : `${normalized.slice(0, 177)}...`;
+}
+function buildContract(agent, connection, existing) {
+    return Object.freeze({
+        id: `runner:${agent.id}`,
+        runnerId: agent.id,
+        poolId: existing?.poolId,
+        taskId: connection?.taskId,
+        label: connection?.label ?? `${agent.template} runner`,
+        sourceTransport: connection ? 'acp' : 'daemon',
+        trustClass: connection ? 'self-hosted-acp' : 'local-daemon',
+        template: agent.template,
+        parentAgentId: agent.parentAgentId,
+        orchestrationGraphId: agent.orchestrationGraphId,
+        orchestrationNodeId: agent.orchestrationNodeId,
+        capabilityCeiling: buildCapabilityCeiling(agent),
+        createdAt: agent.startedAt,
+        lastUpdatedAt: agent.completedAt ?? Date.now(),
+        transport: Object.freeze({
+            state: connection?.transportState ?? 'disconnected',
+            connectedAt: connection?.connectedAt,
+            messageCount: connection?.messageCount ?? 0,
+            errorCount: connection?.errorCount ?? 0,
+            lastError: connection?.lastError,
+        }),
+    });
+}
+function buildArtifact(agent, contract, connection) {
+    return Object.freeze({
+        id: `artifact:${agent.id}:${Date.now()}`,
+        runnerId: agent.id,
+        createdAt: Date.now(),
+        runnerContract: contract,
+        task: Object.freeze({
+            task: agent.task,
+            status: agent.status,
+            startedAt: agent.startedAt,
+            completedAt: agent.completedAt,
+            summary: summarizeOutput(agent),
+            fullOutput: agent.fullOutput,
+            error: agent.error,
+            progress: agent.progress,
+        }),
+        evidence: buildEvidenceSummary(agent, connection),
+        knowledgeInjections: Object.freeze([...(agent.knowledgeInjections ?? [])]),
+    });
+}
+function summarizeTaskOutput(task) {
+    if (!task)
+        return 'No task output recorded.';
+    const payload = (typeof task.result === 'string'
+        ? task.result
+        : task.error
+            ?? (task.result !== undefined ? JSON.stringify(task.result) : task.description)
+            ?? task.title);
+    const normalized = String(payload).replace(/\s+/g, ' ').trim();
+    return normalized.length <= 180 ? normalized : `${normalized.slice(0, 177)}...`;
+}
+function findTaskForContract(contract, store) {
+    if (!store)
+        return undefined;
+    const tasks = store.getState().tasks.tasks;
+    if (contract.taskId) {
+        const byTaskId = tasks.get(contract.taskId);
+        if (byTaskId)
+            return byTaskId;
+    }
+    for (const task of tasks.values()) {
+        if (task.owner === contract.runnerId && task.kind === 'acp') {
+            return task;
+        }
+    }
+    return undefined;
+}
+function mapTaskStatus(task) {
+    switch (task?.status) {
+        case 'queued':
+            return 'pending';
+        case 'running':
+        case 'blocked':
+            return 'running';
+        case 'completed':
+            return 'completed';
+        case 'failed':
+            return 'failed';
+        case 'cancelled':
+            return 'cancelled';
+        default:
+            return 'running';
+    }
+}
+function buildArtifactFromStore(contract, store) {
+    const connection = contract.runnerId ? store?.getState().acp.connections.get(contract.runnerId) : undefined;
+    const task = findTaskForContract(contract, store);
+    return Object.freeze({
+        id: `artifact:${contract.runnerId}:${Date.now()}`,
+        runnerId: contract.runnerId,
+        createdAt: Date.now(),
+        runnerContract: contract,
+        task: Object.freeze({
+            task: task?.description ?? task?.title ?? contract.label,
+            status: mapTaskStatus(task),
+            startedAt: task?.startedAt ?? contract.createdAt,
+            completedAt: task?.endedAt,
+            summary: summarizeTaskOutput(task),
+            ...(typeof task?.result === 'string' ? { fullOutput: task.result } : {}),
+            ...(task?.error ? { error: task.error } : {}),
+        }),
+        evidence: Object.freeze({
+            toolCallCount: 0,
+            messageCount: connection?.messageCount ?? contract.transport.messageCount,
+            errorCount: connection?.errorCount ?? contract.transport.errorCount,
+            transportState: connection?.transportState ?? contract.transport.state,
+            connectedAt: connection?.connectedAt ?? contract.transport.connectedAt,
+            lastError: connection?.lastError ?? contract.transport.lastError,
+            hasKnowledgeInjections: false,
+        }),
+        knowledgeInjections: Object.freeze([]),
+    });
+}
+export class RemoteRunnerRegistry {
+    agentManager;
+    contracts = new Map();
+    artifacts = new Map();
+    pools = new Map();
+    constructor(agentManager) {
+        this.agentManager = agentManager;
+    }
+    resolveConnection(agentId, store) {
+        return store?.getState().acp.connections.get(agentId);
+    }
+    upsertContractForAgent(agentId, store) {
+        const agent = this.agentManager.getStatus(agentId);
+        if (!agent)
+            return null;
+        const contract = buildContract(agent, this.resolveConnection(agentId, store), this.contracts.get(agentId) ?? undefined);
+        this.contracts.set(agentId, contract);
+        if (contract.poolId) {
+            this.assignRunnerToPool(contract.poolId, contract.runnerId);
+        }
+        return contract;
+    }
+    getContract(agentId) {
+        return this.contracts.get(agentId) ?? null;
+    }
+    registerContract(contract) {
+        this.contracts.set(contract.runnerId, contract);
+        if (contract.poolId) {
+            this.assignRunnerToPool(contract.poolId, contract.runnerId);
+        }
+        return contract;
+    }
+    listContracts() {
+        return [...this.contracts.values()].sort((a, b) => b.lastUpdatedAt - a.lastUpdatedAt);
+    }
+    createPool(input) {
+        const existing = this.pools.get(input.id);
+        const now = Date.now();
+        const pool = Object.freeze({
+            id: input.id,
+            label: input.label ?? existing?.label ?? input.id,
+            description: input.description ?? existing?.description,
+            trustClass: input.trustClass ?? existing?.trustClass ?? 'self-hosted-acp',
+            preferredTemplate: input.preferredTemplate ?? existing?.preferredTemplate,
+            maxRunners: input.maxRunners ?? existing?.maxRunners,
+            runnerIds: existing?.runnerIds ?? [],
+            createdAt: existing?.createdAt ?? now,
+            lastUpdatedAt: now,
+        });
+        this.pools.set(pool.id, pool);
+        return pool;
+    }
+    getPool(poolId) {
+        return this.pools.get(poolId) ?? null;
+    }
+    listPools() {
+        return [...this.pools.values()].sort((a, b) => b.lastUpdatedAt - a.lastUpdatedAt);
+    }
+    assignRunnerToPool(poolId, runnerId) {
+        const contract = this.contracts.get(runnerId);
+        const pool = this.pools.get(poolId) ?? this.createPool({ id: poolId, label: poolId });
+        if (pool.maxRunners !== undefined && !pool.runnerIds.includes(runnerId) && pool.runnerIds.length >= pool.maxRunners) {
+            return null;
+        }
+        const nextRunnerIds = pool.runnerIds.includes(runnerId)
+            ? pool.runnerIds
+            : [...pool.runnerIds, runnerId];
+        const nextPool = Object.freeze({
+            ...pool,
+            runnerIds: nextRunnerIds,
+            lastUpdatedAt: Date.now(),
+        });
+        this.pools.set(poolId, nextPool);
+        if (contract && contract.poolId !== poolId) {
+            this.contracts.set(runnerId, Object.freeze({ ...contract, poolId, lastUpdatedAt: Date.now() }));
+        }
+        return nextPool;
+    }
+    removeRunnerFromPool(poolId, runnerId) {
+        const pool = this.pools.get(poolId);
+        if (!pool)
+            return null;
+        const nextPool = Object.freeze({
+            ...pool,
+            runnerIds: pool.runnerIds.filter((id) => id !== runnerId),
+            lastUpdatedAt: Date.now(),
+        });
+        this.pools.set(poolId, nextPool);
+        const contract = this.contracts.get(runnerId);
+        if (contract?.poolId === poolId) {
+            this.contracts.set(runnerId, Object.freeze({ ...contract, poolId: undefined, lastUpdatedAt: Date.now() }));
+        }
+        return nextPool;
+    }
+    captureArtifactForAgent(agentId, store) {
+        const agent = this.agentManager.getStatus(agentId);
+        if (!agent)
+            return null;
+        const connection = this.resolveConnection(agentId, store);
+        const contract = this.upsertContractForAgent(agentId, store) ?? buildContract(agent, connection);
+        const artifact = buildArtifact(agent, contract, connection);
+        this.artifacts.set(artifact.id, artifact);
+        return artifact;
+    }
+    captureArtifactForRunner(runnerId, store) {
+        const byAgent = this.captureArtifactForAgent(runnerId, store);
+        if (byAgent)
+            return byAgent;
+        const contract = this.contracts.get(runnerId);
+        if (!contract)
+            return null;
+        const artifact = buildArtifactFromStore(contract, store);
+        this.artifacts.set(artifact.id, artifact);
+        return artifact;
+    }
+    getArtifact(artifactId) {
+        return this.artifacts.get(artifactId) ?? null;
+    }
+    listArtifacts() {
+        return [...this.artifacts.values()].sort((a, b) => b.createdAt - a.createdAt);
+    }
+    async exportArtifact(artifactId, explicitPath) {
+        const artifact = this.getArtifact(artifactId);
+        if (!artifact)
+            return null;
+        const path = explicitPath
+            ? resolve(explicitPath)
+            : resolve(DEFAULT_ARTIFACT_DIR, `${artifact.id.replace(/[:]/g, '_')}.json`);
+        mkdirSync(dirname(path), { recursive: true });
+        await writeFile(path, `${JSON.stringify(artifact, null, 2)}\n`, 'utf-8');
+        return { artifact, path };
+    }
+    async importArtifact(path) {
+        const raw = await readFile(resolve(path), 'utf-8');
+        const parsed = JSON.parse(raw);
+        this.artifacts.set(parsed.id, parsed);
+        this.contracts.set(parsed.runnerId, parsed.runnerContract);
+        return parsed;
+    }
+    buildSessionBundle(store) {
+        this.ensureContractsFromStore(store);
+        const activeConnectionIds = store?.getState().acp.activeConnectionIds ?? [];
+        return Object.freeze({
+            version: 1,
+            exportedAt: Date.now(),
+            sessionId: store?.getState().session.id || 'unknown-session',
+            activeConnectionIds: Object.freeze([...activeConnectionIds]),
+            pools: Object.freeze(this.listPools()),
+            contracts: Object.freeze(this.listContracts()),
+            artifacts: Object.freeze(this.listArtifacts()),
+        });
+    }
+    async exportSessionBundle(store, explicitPath) {
+        const bundle = this.buildSessionBundle(store);
+        const path = explicitPath
+            ? resolve(explicitPath)
+            : resolve(DEFAULT_SESSION_BUNDLE_DIR, `${bundle.sessionId}-${bundle.exportedAt}.json`);
+        mkdirSync(dirname(path), { recursive: true });
+        await writeFile(path, `${JSON.stringify(bundle, null, 2)}\n`, 'utf-8');
+        return { bundle, path };
+    }
+    async importSessionBundle(path) {
+        const raw = await readFile(resolve(path), 'utf-8');
+        const parsed = JSON.parse(raw);
+        for (const pool of parsed.pools) {
+            this.pools.set(pool.id, pool);
+        }
+        for (const contract of parsed.contracts) {
+            this.contracts.set(contract.runnerId, contract);
+        }
+        for (const artifact of parsed.artifacts) {
+            this.artifacts.set(artifact.id, artifact);
+        }
+        return parsed;
+    }
+    buildReviewSummary(artifactId) {
+        const artifact = this.getArtifact(artifactId);
+        if (!artifact)
+            return null;
+        const lines = [
+            `Remote Artifact ${artifact.id}`,
+            `  runner: ${artifact.runnerId}`,
+            `  template: ${artifact.runnerContract.template}`,
+            `  status: ${artifact.task.status}`,
+            `  summary: ${artifact.task.summary}`,
+            `  tools: ${artifact.runnerContract.capabilityCeiling.allowedTools.join(', ') || '(none)'}`,
+            `  evidence: toolCalls=${artifact.evidence.toolCallCount} messages=${artifact.evidence.messageCount} errors=${artifact.evidence.errorCount}`,
+        ];
+        if (artifact.task.error)
+            lines.push(`  error: ${artifact.task.error}`);
+        if (artifact.knowledgeInjections.length > 0) {
+            lines.push(`  knowledge: ${artifact.knowledgeInjections.map((entry) => entry.id).join(', ')}`);
+        }
+        return lines.join('\n');
+    }
+    ensureContractsFromStore(store) {
+        for (const agent of this.agentManager.list()) {
+            if (agent.orchestrationGraphId || agent.parentAgentId || store?.getState().acp.connections.has(agent.id)) {
+                this.upsertContractForAgent(agent.id, store);
+            }
+        }
+    }
+    clear() {
+        this.contracts.clear();
+        this.artifacts.clear();
+        this.pools.clear();
+    }
+}
+export async function exportRemoteArtifactForAgent(registry, agentId, store, path) {
+    const artifact = registry.captureArtifactForAgent(agentId, store);
+    if (!artifact)
+        return null;
+    return registry.exportArtifact(artifact.id, path);
+}
+export async function importRemoteArtifact(registry, path) {
+    try {
+        return await registry.importArtifact(path);
+    }
+    catch (error) {
+        logger.debug('RemoteRunnerRegistry.importArtifact failed', { path, error: summarizeError(error) });
+        throw error;
+    }
+}

package/dist/_internal/platform/runtime/remote/supervisor.d.ts

@@ -0,0 +1,19 @@
+import type { RuntimeStore } from '../store/index.js';
+import { RemoteRunnerRegistry } from './runner-registry.js';
+import type { RemoteRunnerPool } from '@pellux/goodvibes-sdk/platform/runtime/remote/types';
+import { type RemoteSessionStateSnapshot } from '@pellux/goodvibes-sdk/platform/runtime/remote/session-state';
+export interface RemoteSupervisorSnapshot {
+    readonly capturedAt: number;
+    readonly totalConnections: number;
+    readonly activeConnections: number;
+    readonly degradedConnections: number;
+    readonly pools: readonly RemoteRunnerPool[];
+    readonly sessions: readonly RemoteSessionStateSnapshot[];
+}
+export declare class RemoteSupervisor {
+    private readonly remoteRegistry;
+    constructor(remoteRegistry: RemoteRunnerRegistry);
+    getSnapshot(store: RuntimeStore): RemoteSupervisorSnapshot;
+    private describeRunner;
+}
+//# sourceMappingURL=supervisor.d.ts.map

package/dist/_internal/platform/runtime/remote/supervisor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"supervisor.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/remote/supervisor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAwB,gBAAgB,EAAE,MAAM,qDAAqD,CAAC;AAKlH,OAAO,EAAmC,KAAK,0BAA0B,EAAE,MAAM,6DAA6D,CAAC;AAE/I,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,KAAK,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAC5C,QAAQ,CAAC,QAAQ,EAAE,SAAS,0BAA0B,EAAE,CAAC;CAC1D;AAMD,qBAAa,gBAAgB;IACf,OAAO,CAAC,QAAQ,CAAC,cAAc;gBAAd,cAAc,EAAE,oBAAoB;IAE1D,WAAW,CAAC,KAAK,EAAE,YAAY,GAAG,wBAAwB;IAqBjE,OAAO,CAAC,cAAc;CAsBvB"}

package/dist/_internal/platform/runtime/remote/supervisor.js

@@ -0,0 +1,53 @@
+import { RemoteRunnerRegistry } from './runner-registry.js';
+import { deriveRemoteCapabilities } from '@pellux/goodvibes-sdk/platform/runtime/remote/capabilities';
+import { deriveRemoteHeartbeat } from '@pellux/goodvibes-sdk/platform/runtime/remote/heartbeat';
+import { deriveRemoteNegotiation } from '@pellux/goodvibes-sdk/platform/runtime/remote/negotiation';
+import { deriveRemoteRecoveryActions } from '@pellux/goodvibes-sdk/platform/runtime/remote/recovery';
+import { buildRemoteSessionStateSnapshot } from '@pellux/goodvibes-sdk/platform/runtime/remote/session-state';
+function stateIsDegraded(state) {
+    return state === 'degraded' || state === 'reconnecting' || state === 'terminal_failure';
+}
+export class RemoteSupervisor {
+    remoteRegistry;
+    constructor(remoteRegistry) {
+        this.remoteRegistry = remoteRegistry;
+    }
+    getSnapshot(store) {
+        this.remoteRegistry.ensureContractsFromStore(store);
+        const state = store.getState();
+        const pools = this.remoteRegistry.listPools();
+        const contracts = this.remoteRegistry.listContracts();
+        const connections = [...state.acp.connections.values()];
+        const runnerIds = new Set([
+            ...connections.map((connection) => connection.agentId),
+            ...contracts.map((contract) => contract.runnerId),
+        ]);
+        const sessions = [...runnerIds].map((runnerId) => this.describeRunner(runnerId, connections, contracts));
+        return Object.freeze({
+            capturedAt: Date.now(),
+            totalConnections: connections.length,
+            activeConnections: state.acp.activeConnectionIds.length,
+            degradedConnections: sessions.filter((session) => stateIsDegraded(session.transportState) || session.heartbeat.status !== 'fresh').length,
+            pools,
+            sessions,
+        });
+    }
+    describeRunner(runnerId, connections, contracts) {
+        const connection = connections.find((entry) => entry.agentId === runnerId) ?? null;
+        const contract = contracts.find((entry) => entry.runnerId === runnerId) ?? null;
+        const capabilities = deriveRemoteCapabilities(contract, connection);
+        const heartbeat = deriveRemoteHeartbeat(connection, contract);
+        const negotiation = deriveRemoteNegotiation(contract, connection);
+        const recovery = deriveRemoteRecoveryActions(connection, contract, heartbeat);
+        return buildRemoteSessionStateSnapshot({
+            runnerId,
+            label: connection?.label ?? contract?.label ?? runnerId,
+            connection,
+            contract,
+            heartbeat,
+            negotiation,
+            capabilities,
+            recovery,
+        });
+    }
+}

package/dist/_internal/platform/runtime/runtime-hook-api.d.ts

@@ -0,0 +1,3 @@
+import { createHookApi, type HookApi } from '../hooks/hook-api.js';
+export declare function createRuntimeHookApi(options: Parameters<typeof createHookApi>[0]): HookApi;
+//# sourceMappingURL=runtime-hook-api.d.ts.map

package/dist/_internal/platform/runtime/runtime-hook-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-hook-api.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/runtime/runtime-hook-api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,KAAK,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAEnE,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAE1F"}

package/dist/_internal/platform/runtime/runtime-hook-api.js

@@ -0,0 +1,4 @@
+import { createHookApi } from '../hooks/hook-api.js';
+export function createRuntimeHookApi(options) {
+    return createHookApi(options);
+}

package/dist/_internal/platform/runtime/runtime-knowledge-api.d.ts

@@ -0,0 +1,6 @@
+import { type KnowledgeApi } from '../knowledge/knowledge-api.js';
+import type { RuntimeServices } from './services.js';
+export interface RuntimeKnowledgeApiServices extends Pick<RuntimeServices, 'knowledgeService' | 'memoryRegistry'> {
+}
+export declare function createRuntimeKnowledgeApi(runtimeServices: RuntimeKnowledgeApiServices): KnowledgeApi;
+//# sourceMappingURL=runtime-knowledge-api.d.ts.map

package/dist/_internal/platform/runtime/runtime-knowledge-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-knowledge-api.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/runtime/runtime-knowledge-api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsD,KAAK,YAAY,EAAE,MAAM,+BAA+B,CAAC;AACtH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAErD,MAAM,WAAW,2BACf,SAAQ,IAAI,CAAC,eAAe,EAAE,kBAAkB,GAAG,gBAAgB,CAAC;CAAG;AAEzE,wBAAgB,yBAAyB,CACvC,eAAe,EAAE,2BAA2B,GAC3C,YAAY,CAKd"}

package/dist/_internal/platform/runtime/runtime-knowledge-api.js

@@ -0,0 +1,7 @@
+import { createKnowledgeApi } from '../knowledge/knowledge-api.js';
+export function createRuntimeKnowledgeApi(runtimeServices) {
+    const options = {
+        memoryRegistry: runtimeServices.memoryRegistry,
+    };
+    return createKnowledgeApi(runtimeServices.knowledgeService, options);
+}

package/dist/_internal/platform/runtime/runtime-mcp-api.d.ts

@@ -0,0 +1,3 @@
+import { type McpApi, type McpApiRegistry } from '../mcp/mcp-api.js';
+export declare function createRuntimeMcpApi(registry: McpApiRegistry): McpApi;
+//# sourceMappingURL=runtime-mcp-api.d.ts.map

package/dist/_internal/platform/runtime/runtime-mcp-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-mcp-api.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/runtime/runtime-mcp-api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,MAAM,EAAE,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnF,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM,CAEpE"}

package/dist/_internal/platform/runtime/runtime-mcp-api.js

@@ -0,0 +1,4 @@
+import { createMcpApi } from '../mcp/mcp-api.js';
+export function createRuntimeMcpApi(registry) {
+    return createMcpApi(registry);
+}

package/dist/_internal/platform/runtime/runtime-ops-api.d.ts

@@ -0,0 +1,13 @@
+import type { OpsApi } from './ops-api.js';
+import type { OpsControlPlane } from './ops/control-plane.js';
+import type { UiTasksSnapshot } from './ui-read-models.js';
+import type { TaskManager } from '@pellux/goodvibes-sdk/platform/runtime/tasks/types';
+export interface RuntimeOpsApiOptions {
+    readonly tasksReadModel: {
+        getSnapshot(): UiTasksSnapshot;
+    };
+    readonly taskManager: TaskManager;
+    readonly opsControlPlane?: Pick<OpsControlPlane, 'cancelTask' | 'pauseTask' | 'resumeTask' | 'retryTask' | 'cancelAgent'>;
+}
+export declare function createRuntimeOpsApi(options: RuntimeOpsApiOptions): OpsApi;
+//# sourceMappingURL=runtime-ops-api.d.ts.map

package/dist/_internal/platform/runtime/runtime-ops-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-ops-api.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/runtime/runtime-ops-api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oDAAoD,CAAC;AAEtF,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,cAAc,EAAE;QACvB,WAAW,IAAI,eAAe,CAAC;KAChC,CAAC;IACF,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;IAClC,QAAQ,CAAC,eAAe,CAAC,EAAE,IAAI,CAC7B,eAAe,EACf,YAAY,GAAG,WAAW,GAAG,YAAY,GAAG,WAAW,GAAG,aAAa,CACxE,CAAC;CACH;AAwBD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,oBAAoB,GAAG,MAAM,CA8CzE"}

package/dist/_internal/platform/runtime/runtime-ops-api.js

@@ -0,0 +1,64 @@
+function normalizeLimit(limit) {
+    if (!Number.isFinite(limit))
+        return 1;
+    return Math.max(1, Math.floor(limit));
+}
+function listTasksSnapshot(snapshot, limit = 100) {
+    return snapshot.tasks.slice(0, normalizeLimit(limit));
+}
+function getTaskSnapshot(snapshot, taskId) {
+    return snapshot.tasks.find((task) => task.id === taskId) ?? null;
+}
+function requireControlPlane(controlPlane) {
+    if (!controlPlane) {
+        throw new Error('Ops control plane is not available in this runtime.');
+    }
+    return controlPlane;
+}
+export function createRuntimeOpsApi(options) {
+    return {
+        tasks: {
+            snapshot() {
+                return options.tasksReadModel.getSnapshot();
+            },
+            list(limit = 100) {
+                return listTasksSnapshot(options.tasksReadModel.getSnapshot(), limit);
+            },
+            get(taskId) {
+                return getTaskSnapshot(options.tasksReadModel.getSnapshot(), taskId);
+            },
+            running() {
+                return options.tasksReadModel.getSnapshot().tasks.filter((task) => task.status === 'running');
+            },
+            create(input) {
+                return options.taskManager.createTask(input);
+            },
+            update(taskId, input) {
+                return options.taskManager.updateTask(taskId, input);
+            },
+            complete(taskId, result) {
+                return options.taskManager.completeTask(taskId, result);
+            },
+            fail(taskId, input) {
+                return options.taskManager.failTask(taskId, input);
+            },
+            cancel(taskId, note) {
+                requireControlPlane(options.opsControlPlane).cancelTask(taskId, note);
+            },
+            pause(taskId, note) {
+                requireControlPlane(options.opsControlPlane).pauseTask(taskId, note);
+            },
+            resume(taskId, note) {
+                requireControlPlane(options.opsControlPlane).resumeTask(taskId, note);
+            },
+            retry(taskId, note) {
+                requireControlPlane(options.opsControlPlane).retryTask(taskId, note);
+            },
+        },
+        agents: {
+            cancel(agentId, note) {
+                requireControlPlane(options.opsControlPlane).cancelAgent(agentId, note);
+            },
+        },
+    };
+}

package/dist/_internal/platform/runtime/runtime-provider-api.d.ts

@@ -0,0 +1,6 @@
+import { type ProviderApi } from '../providers/provider-api.js';
+import type { RuntimeServices } from './services.js';
+export interface RuntimeProviderApiServices extends Pick<RuntimeServices, 'benchmarkStore' | 'favoritesStore' | 'providerRegistry'> {
+}
+export declare function createRuntimeProviderApi(runtimeServices: RuntimeProviderApiServices): ProviderApi;
+//# sourceMappingURL=runtime-provider-api.d.ts.map

package/dist/_internal/platform/runtime/runtime-provider-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-provider-api.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/runtime/runtime-provider-api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,WAAW,EAAE,MAAM,8BAA8B,CAAC;AACnF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAErD,MAAM,WAAW,0BAA2B,SAAQ,IAAI,CACtD,eAAe,EACf,gBAAgB,GAAG,gBAAgB,GAAG,kBAAkB,CACzD;CAAG;AAEJ,wBAAgB,wBAAwB,CACtC,eAAe,EAAE,0BAA0B,GAC1C,WAAW,CAMb"}

package/dist/_internal/platform/runtime/runtime-provider-api.js

@@ -0,0 +1,8 @@
+import { createProviderApi } from '../providers/provider-api.js';
+export function createRuntimeProviderApi(runtimeServices) {
+    return createProviderApi({
+        providerRegistry: runtimeServices.providerRegistry,
+        favoritesStore: runtimeServices.favoritesStore,
+        benchmarkStore: runtimeServices.benchmarkStore,
+    });
+}

package/dist/_internal/platform/runtime/sandbox/backend.d.ts

@@ -0,0 +1,29 @@
+import type { SandboxBackendProbe, SandboxLaunchPlan, SandboxProfile } from './types.js';
+import { type ConfigManagerLike } from './manager.js';
+export declare function probeSandboxBackends(manager: ConfigManagerLike): SandboxBackendProbe;
+export declare function buildSandboxLaunchPlan(profile: SandboxProfile, label: string, manager: ConfigManagerLike, workspaceRoot: string): SandboxLaunchPlan;
+export interface SandboxCommandPlan {
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly summary: string;
+    readonly env?: NodeJS.ProcessEnv;
+}
+export declare function resolveSandboxCommandPlan(launchPlan: SandboxLaunchPlan, command: string, args: readonly string[], manager?: ConfigManagerLike): SandboxCommandPlan;
+export interface SandboxCommandResult {
+    readonly status: number | null;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export declare function executeSandboxCommand(launchPlan: SandboxLaunchPlan, command: string, args: readonly string[], options?: {
+    readonly cwd?: string;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly timeoutMs?: number;
+    readonly input?: string;
+}): SandboxCommandResult;
+export declare function executeSandboxManagedCommand(launchPlan: SandboxLaunchPlan, command: string, args: readonly string[], manager: ConfigManagerLike, options?: {
+    readonly cwd?: string;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly timeoutMs?: number;
+    readonly input?: string;
+}): SandboxCommandResult;
+//# sourceMappingURL=backend.d.ts.map

package/dist/_internal/platform/runtime/sandbox/backend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/sandbox/backend.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAEV,mBAAmB,EACnB,iBAAiB,EACjB,cAAc,EAEf,MAAM,YAAY,CAAC;AACpB,OAAO,EAAqD,KAAK,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAmEzG,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,iBAAiB,GACzB,mBAAmB,CA+CrB;AAMD,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,cAAc,EACvB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,iBAAiB,EAC1B,aAAa,EAAE,MAAM,GACpB,iBAAiB,CAiCnB;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CAClC;AAED,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,iBAAiB,EAC7B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,kBAAkB,CA0CpB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AA8BD,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,iBAAiB,EAC7B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,OAAO,GAAE;IACP,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACjC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACpB,GACL,oBAAoB,CAEtB;AAED,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,iBAAiB,EAC7B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,OAAO,EAAE,iBAAiB,EAC1B,OAAO,GAAE;IACP,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACjC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACpB,GACL,oBAAoB,CAEtB"}