peaks-cli 1.3.5 → 1.3.6

package/dist/src/services/mcp/mcp-apply-service.d.ts

@@ -1,31 +0,0 @@
-import { type PlanMcpInstallOptions, type McpInstallEnvCheck } from './mcp-plan-service.js';
-export type McpApplyAction = 'add' | 'update' | 'claimed' | 'noop';
-export type McpApplyBackupInfo = {
-    path: string | null;
-    skipped: boolean;
-};
-export type McpApplyResult = {
-    capabilityId: string;
-    action: McpApplyAction;
-    backup: McpApplyBackupInfo;
-    written: {
-        settingsPath: string;
-        managedMarkerPath: string;
-    };
-    envCheck: McpInstallEnvCheck;
-};
-export type McpApplyOptions = PlanMcpInstallOptions & {
-    claim?: boolean;
-    backupRoot?: string;
-    clock?: () => string;
-};
-export type McpRollbackOptions = {
-    backupPath: string;
-    globalSettingsPath?: string;
-};
-export type McpRollbackResult = {
-    restoredFrom: string;
-    restoredTo: string;
-};
-export declare function applyMcpInstall(capabilityId: string, options?: McpApplyOptions): Promise<McpApplyResult>;
-export declare function rollbackMcpInstall(options: McpRollbackOptions): Promise<McpRollbackResult>;

package/dist/src/services/mcp/mcp-apply-service.js

@@ -1,112 +0,0 @@
-import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { mkdir, writeFile } from 'node:fs/promises';
-import { pathExists, readText } from '../../shared/fs.js';
-import { planMcpInstall } from './mcp-plan-service.js';
-function defaultGlobalSettingsPath() {
-    return join(homedir(), '.claude', 'settings.json');
-}
-function defaultManagedMarkerPath() {
-    return join(homedir(), '.peaks', 'mcp-managed.json');
-}
-function defaultBackupRoot() {
-    return join(homedir(), '.peaks-artifacts', 'mcp-backups');
-}
-function defaultClock() {
-    return new Date().toISOString().replace(/[:.]/g, '-');
-}
-async function readJsonFile(path) {
-    if (!(await pathExists(path))) {
-        return {};
-    }
-    const raw = await readText(path);
-    if (raw.length === 0) {
-        return {};
-    }
-    const parsed = JSON.parse(raw);
-    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        return {};
-    }
-    return parsed;
-}
-async function writeJsonFile(path, data) {
-    await mkdir(dirname(path), { recursive: true });
-    await writeFile(path, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
-}
-function buildServerConfig(spec) {
-    const env = {};
-    for (const key of spec.envKeys) {
-        env[key] = `\${${key}}`;
-    }
-    return { command: spec.command, args: [...spec.args], env };
-}
-async function createBackup(settingsPath, backupRoot, timestamp) {
-    if (!(await pathExists(settingsPath))) {
-        return null;
-    }
-    const backupPath = join(backupRoot, timestamp, 'settings.json');
-    await mkdir(dirname(backupPath), { recursive: true });
-    await writeFile(backupPath, await readText(settingsPath), 'utf8');
-    return backupPath;
-}
-async function updateManagedMarker(markerPath, name) {
-    const marker = await readJsonFile(markerPath);
-    const existing = Array.isArray(marker.servers)
-        ? marker.servers.filter((entry) => typeof entry === 'string')
-        : [];
-    if (!existing.includes(name)) {
-        existing.push(name);
-    }
-    await writeJsonFile(markerPath, { ...marker, servers: existing });
-}
-export async function applyMcpInstall(capabilityId, options = {}) {
-    const plan = await planMcpInstall(capabilityId, options);
-    if (plan.action === 'unknown-capability' || plan.spec === null) {
-        throw new Error(`No MCP install spec registered for capability ${capabilityId} (unknown-capability)`);
-    }
-    if (plan.envCheck.missing.length > 0) {
-        throw new Error(`Refusing to apply: missing required env vars: ${plan.envCheck.missing.join(', ')}`);
-    }
-    if (plan.action === 'conflict' && options.claim !== true) {
-        throw new Error(`Refusing to apply: server ${plan.spec.name} exists but is not peaks-managed (conflict). Re-run with --claim to take ownership.`);
-    }
-    const settingsPath = options.globalSettingsPath ?? defaultGlobalSettingsPath();
-    const markerPath = options.managedMarkerPath ?? defaultManagedMarkerPath();
-    const backupRoot = options.backupRoot ?? defaultBackupRoot();
-    const clock = options.clock ?? defaultClock;
-    if (plan.action === 'noop') {
-        return {
-            capabilityId,
-            action: 'noop',
-            backup: { path: null, skipped: true },
-            written: { settingsPath, managedMarkerPath: markerPath },
-            envCheck: plan.envCheck
-        };
-    }
-    const backupPath = await createBackup(settingsPath, backupRoot, clock());
-    const settings = await readJsonFile(settingsPath);
-    const existingServers = settings.mcpServers !== null && typeof settings.mcpServers === 'object' && !Array.isArray(settings.mcpServers)
-        ? settings.mcpServers
-        : {};
-    const nextServers = { ...existingServers, [plan.spec.name]: buildServerConfig(plan.spec) };
-    await writeJsonFile(settingsPath, { ...settings, mcpServers: nextServers });
-    await updateManagedMarker(markerPath, plan.spec.name);
-    const action = plan.action === 'conflict' ? 'claimed' : plan.action;
-    return {
-        capabilityId,
-        action,
-        backup: { path: backupPath, skipped: false },
-        written: { settingsPath, managedMarkerPath: markerPath },
-        envCheck: plan.envCheck
-    };
-}
-export async function rollbackMcpInstall(options) {
-    if (!(await pathExists(options.backupPath))) {
-        throw new Error(`Refusing to rollback: backup file not found at ${options.backupPath}`);
-    }
-    const target = options.globalSettingsPath ?? defaultGlobalSettingsPath();
-    const content = await readText(options.backupPath);
-    await mkdir(dirname(target), { recursive: true });
-    await writeFile(target, content, 'utf8');
-    return { restoredFrom: options.backupPath, restoredTo: target };
-}

package/dist/src/services/mcp/mcp-call-service.d.ts

@@ -1,17 +0,0 @@
-import { type McpInstallSpec } from './mcp-install-registry.js';
-import { type McpClientTransport } from './mcp-client-service.js';
-export type McpCallTransportFactory = (spec: McpInstallSpec, env: Record<string, string | undefined>) => McpClientTransport;
-export type McpCallOptions = {
-    capabilityId: string;
-    toolName: string;
-    transportFactory: McpCallTransportFactory;
-    args?: Record<string, unknown>;
-    env?: Record<string, string | undefined>;
-    timeoutMs?: number;
-};
-export type McpCallResult = {
-    capabilityId: string;
-    toolName: string;
-    result: unknown;
-};
-export declare function callMcpTool(options: McpCallOptions): Promise<McpCallResult>;

package/dist/src/services/mcp/mcp-call-service.js

@@ -1,34 +0,0 @@
-import { findMcpInstallSpec } from './mcp-install-registry.js';
-import { createMcpClient } from './mcp-client-service.js';
-function checkRequiredEnv(spec, env) {
-    return spec.envKeys.filter((key) => {
-        const value = env[key];
-        return value === undefined || value.length === 0;
-    });
-}
-export async function callMcpTool(options) {
-    const spec = findMcpInstallSpec(options.capabilityId);
-    if (spec === null) {
-        throw new Error(`No MCP install spec registered for capability ${options.capabilityId}`);
-    }
-    const env = options.env ?? process.env;
-    const missing = checkRequiredEnv(spec, env);
-    if (missing.length > 0) {
-        throw new Error(`Refusing to call ${spec.name}: missing required env vars: ${missing.join(', ')}`);
-    }
-    const transport = options.transportFactory(spec, env);
-    const clientOptions = options.timeoutMs !== undefined
-        ? { transport, timeoutMs: options.timeoutMs }
-        : { transport };
-    const client = createMcpClient(clientOptions);
-    try {
-        const result = await client.request('tools/call', {
-            name: options.toolName,
-            arguments: options.args ?? {}
-        });
-        return { capabilityId: options.capabilityId, toolName: options.toolName, result };
-    }
-    finally {
-        await client.close();
-    }
-}

package/dist/src/services/mcp/mcp-client-service.d.ts

@@ -1,14 +0,0 @@
-export type McpClientTransport = {
-    send: (line: string) => Promise<void>;
-    onLine: (handler: (line: string) => void) => void;
-    close: () => Promise<void>;
-};
-export type McpClientOptions = {
-    transport: McpClientTransport;
-    timeoutMs?: number;
-};
-export type McpClientHandle = {
-    request: (method: string, params?: unknown) => Promise<unknown>;
-    close: () => Promise<void>;
-};
-export declare function createMcpClient(options: McpClientOptions): McpClientHandle;

package/dist/src/services/mcp/mcp-client-service.js

@@ -1,49 +0,0 @@
-import { buildRequest, parseMessages, serializeMessage } from './mcp-protocol.js';
-const DEFAULT_TIMEOUT_MS = 30000;
-export function createMcpClient(options) {
-    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    let nextId = 1;
-    let buffer = '';
-    const pending = new Map();
-    function deliver(message) {
-        const entry = pending.get(message.id);
-        if (entry === undefined) {
-            return;
-        }
-        pending.delete(message.id);
-        clearTimeout(entry.timer);
-        if (message.error !== undefined) {
-            entry.reject(new Error(`MCP error ${message.error.code}: ${message.error.message}`));
-            return;
-        }
-        entry.resolve(message.result);
-    }
-    options.transport.onLine((line) => {
-        buffer += line;
-        const { messages, remainder } = parseMessages(buffer);
-        buffer = remainder;
-        for (const message of messages) {
-            deliver(message);
-        }
-    });
-    async function request(method, params) {
-        const id = nextId++;
-        const message = serializeMessage(buildRequest(id, method, params));
-        return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                pending.delete(id);
-                reject(new Error(`MCP request ${method} timed out after ${timeoutMs}ms`));
-            }, timeoutMs);
-            pending.set(id, { resolve, reject, timer });
-            options.transport.send(message).catch((error) => {
-                clearTimeout(timer);
-                pending.delete(id);
-                reject(error instanceof Error ? error : new Error(String(error)));
-            });
-        });
-    }
-    async function close() {
-        await options.transport.close();
-    }
-    return { request, close };
-}

package/dist/src/services/mcp/mcp-install-registry.d.ts

@@ -1,11 +0,0 @@
-import type { McpServerScope } from './mcp-types.js';
-export type McpInstallSpec = {
-    capabilityId: string;
-    name: string;
-    scope: McpServerScope;
-    command: string;
-    args: string[];
-    envKeys: string[];
-};
-export declare const seedMcpInstalls: ReadonlyArray<McpInstallSpec>;
-export declare function findMcpInstallSpec(capabilityId: string): McpInstallSpec | null;

package/dist/src/services/mcp/mcp-install-registry.js

@@ -1,38 +0,0 @@
-export const seedMcpInstalls = [
-    {
-        capabilityId: 'context7.docs-lookup',
-        name: 'context7',
-        scope: 'global',
-        command: 'npx',
-        args: ['-y', '@upstash/context7-mcp@latest'],
-        envKeys: ['CONTEXT7_API_KEY']
-    },
-    {
-        capabilityId: 'playwright-mcp.browser-validation',
-        name: 'playwright',
-        scope: 'global',
-        command: 'npx',
-        args: ['-y', '@playwright/mcp@latest'],
-        envKeys: []
-    },
-    {
-        capabilityId: 'chrome-devtools-mcp.browser-debug',
-        name: 'chrome-devtools',
-        scope: 'global',
-        command: 'npx',
-        args: ['-y', 'chrome-devtools-mcp@latest'],
-        envKeys: []
-    },
-    {
-        capabilityId: 'figma-context-mcp.design-context',
-        name: 'figma',
-        scope: 'global',
-        command: 'npx',
-        args: ['-y', 'figma-developer-mcp@latest', '--stdio'],
-        envKeys: ['FIGMA_API_KEY']
-    }
-];
-export function findMcpInstallSpec(capabilityId) {
-    const match = seedMcpInstalls.find((spec) => spec.capabilityId === capabilityId);
-    return match ?? null;
-}

package/dist/src/services/mcp/mcp-plan-service.d.ts

@@ -1,29 +0,0 @@
-import { type McpScanOptions } from './mcp-scan-service.js';
-import { type McpInstallSpec } from './mcp-install-registry.js';
-import type { McpServerConfig } from './mcp-types.js';
-export type McpInstallAction = 'add' | 'update' | 'noop' | 'conflict' | 'unknown-capability';
-export type McpInstallEnvCheck = {
-    missing: string[];
-};
-export type McpInstallDiffEntry<T> = {
-    before: T;
-    after: T;
-};
-export type McpInstallDiff = {
-    command?: McpInstallDiffEntry<string>;
-    args?: McpInstallDiffEntry<string[]>;
-    envKeys?: McpInstallDiffEntry<string[]>;
-};
-export type McpInstallPlan = {
-    capabilityId: string;
-    action: McpInstallAction;
-    spec: McpInstallSpec | null;
-    current: McpServerConfig | null;
-    envCheck: McpInstallEnvCheck;
-    diff: McpInstallDiff | null;
-    nextActions: string[];
-};
-export type PlanMcpInstallOptions = McpScanOptions & {
-    env?: Record<string, string | undefined>;
-};
-export declare function planMcpInstall(capabilityId: string, options?: PlanMcpInstallOptions): Promise<McpInstallPlan>;

package/dist/src/services/mcp/mcp-plan-service.js

@@ -1,109 +0,0 @@
-import { scanMcpServers } from './mcp-scan-service.js';
-import { findMcpInstallSpec } from './mcp-install-registry.js';
-function arraysEqual(a, b) {
-    if (a.length !== b.length) {
-        return false;
-    }
-    return a.every((value, index) => value === b[index]);
-}
-function buildEnvCheck(spec, env) {
-    const missing = spec.envKeys.filter((key) => {
-        const value = env[key];
-        return value === undefined || value.length === 0;
-    });
-    return { missing };
-}
-function buildDiff(spec, current) {
-    const diff = {};
-    if (current.command !== spec.command) {
-        diff.command = { before: current.command, after: spec.command };
-    }
-    if (!arraysEqual(current.args, spec.args)) {
-        diff.args = { before: current.args, after: spec.args };
-    }
-    if (!arraysEqual(current.envKeys, spec.envKeys)) {
-        diff.envKeys = { before: current.envKeys, after: spec.envKeys };
-    }
-    return Object.keys(diff).length === 0 ? null : diff;
-}
-function buildNextActions(action, capabilityId, envMissing) {
-    const actions = [];
-    if (action === 'unknown-capability') {
-        actions.push(`No MCP install spec registered for capability ${capabilityId}`);
-        return actions;
-    }
-    if (envMissing.length > 0) {
-        actions.push(`Set required env vars before apply: ${envMissing.join(', ')}`);
-    }
-    if (action === 'add') {
-        actions.push(`Run peaks mcp apply --capability ${capabilityId} --yes to write the new server`);
-    }
-    else if (action === 'update') {
-        actions.push(`Run peaks mcp apply --capability ${capabilityId} --yes to update the existing peaks-managed server`);
-    }
-    else if (action === 'conflict') {
-        actions.push(`Re-run with --claim to take ownership of the existing non-peaks-managed entry, or rename the conflicting server`);
-    }
-    else if (action === 'noop') {
-        actions.push(`Server already matches the install spec; nothing to apply`);
-    }
-    return actions;
-}
-export async function planMcpInstall(capabilityId, options = {}) {
-    const spec = findMcpInstallSpec(capabilityId);
-    if (spec === null) {
-        return {
-            capabilityId,
-            action: 'unknown-capability',
-            spec: null,
-            current: null,
-            envCheck: { missing: [] },
-            diff: null,
-            nextActions: buildNextActions('unknown-capability', capabilityId, [])
-        };
-    }
-    const env = options.env ?? process.env;
-    const envCheck = buildEnvCheck(spec, env);
-    const scanOptions = {};
-    if (options.globalSettingsPath !== undefined) {
-        scanOptions.globalSettingsPath = options.globalSettingsPath;
-    }
-    if (options.projectRoot !== undefined) {
-        scanOptions.projectRoot = options.projectRoot;
-    }
-    if (options.managedMarkerPath !== undefined) {
-        scanOptions.managedMarkerPath = options.managedMarkerPath;
-    }
-    if (options.pluginsRegistryPath !== undefined) {
-        scanOptions.pluginsRegistryPath = options.pluginsRegistryPath;
-    }
-    const report = await scanMcpServers(scanOptions);
-    const current = report.servers.find((server) => server.name === spec.name && server.scope === spec.scope) ?? null;
-    const pluginDuplicate = report.servers.find((server) => server.source === 'plugin' && server.name === spec.name) ?? null;
-    let action;
-    let diff = null;
-    if (current === null) {
-        action = 'add';
-    }
-    else if (current.source !== 'peaks') {
-        action = 'conflict';
-    }
-    else {
-        diff = buildDiff(spec, current);
-        action = diff === null ? 'noop' : 'update';
-    }
-    const nextActions = buildNextActions(action, capabilityId, envCheck.missing);
-    if (pluginDuplicate !== null) {
-        const pluginLabel = pluginDuplicate.pluginName ?? 'a Claude Code plugin';
-        nextActions.push(`An MCP server named "${spec.name}" is already loaded by plugin ${pluginLabel}; installing via peaks would duplicate it`);
-    }
-    return {
-        capabilityId,
-        action,
-        spec,
-        current,
-        envCheck,
-        diff,
-        nextActions
-    };
-}

package/dist/src/services/mcp/mcp-protocol.d.ts

@@ -1,24 +0,0 @@
-export type McpJsonRpcRequest = {
-    jsonrpc: '2.0';
-    id: number;
-    method: string;
-    params?: unknown;
-};
-export type McpJsonRpcError = {
-    code: number;
-    message: string;
-    data?: unknown;
-};
-export type McpJsonRpcResponse = {
-    jsonrpc: '2.0';
-    id: number;
-    result?: unknown;
-    error?: McpJsonRpcError;
-};
-export type ParsedMessages = {
-    messages: McpJsonRpcResponse[];
-    remainder: string;
-};
-export declare function buildRequest(id: number, method: string, params?: unknown): McpJsonRpcRequest;
-export declare function serializeMessage(message: McpJsonRpcRequest | McpJsonRpcResponse): string;
-export declare function parseMessages(buffer: string): ParsedMessages;

package/dist/src/services/mcp/mcp-protocol.js

@@ -1,41 +0,0 @@
-export function buildRequest(id, method, params) {
-    if (params === undefined) {
-        return { jsonrpc: '2.0', id, method };
-    }
-    return { jsonrpc: '2.0', id, method, params };
-}
-export function serializeMessage(message) {
-    return `${JSON.stringify(message)}\n`;
-}
-function isJsonRpcResponse(value) {
-    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
-        return false;
-    }
-    const record = value;
-    if (record.jsonrpc !== '2.0') {
-        return false;
-    }
-    return typeof record.id === 'number';
-}
-export function parseMessages(buffer) {
-    const lastNewline = buffer.lastIndexOf('\n');
-    const remainder = lastNewline === -1 ? buffer : buffer.slice(lastNewline + 1);
-    const completePart = lastNewline === -1 ? '' : buffer.slice(0, lastNewline);
-    const messages = [];
-    for (const line of completePart.split('\n')) {
-        if (line.length === 0) {
-            continue;
-        }
-        let parsed;
-        try {
-            parsed = JSON.parse(line);
-        }
-        catch {
-            continue;
-        }
-        if (isJsonRpcResponse(parsed)) {
-            messages.push(parsed);
-        }
-    }
-    return { messages, remainder };
-}

package/dist/src/services/mcp/mcp-scan-service.d.ts

@@ -1,8 +0,0 @@
-import type { McpScanReport } from './mcp-types.js';
-export type McpScanOptions = {
-    globalSettingsPath?: string;
-    projectRoot?: string;
-    managedMarkerPath?: string;
-    pluginsRegistryPath?: string;
-};
-export declare function scanMcpServers(options?: McpScanOptions): Promise<McpScanReport>;