@steercards/agent-tools 0.0.0-stage → 0.1.1

package/dist/install.js

@@ -0,0 +1,107 @@
+import { readFile, readdir, mkdir, lstat, rename, rm, mkdtemp, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { zipSync } from 'fflate';
+import { validateMcpUrl } from './config.js';
+import { packageRoot, packageInfo } from './package.js';
+export { packageRoot, packageInfo } from './package.js';
+export const skillRoot = join(packageRoot, 'skills', 'steercards');
+export const clients = ['claude-code', 'codex', 'codex-app', 'codex-cli', 'cursor', 'claude-desktop'];
+export function clientConfig(client, options = {}) {
+    if (!clients.includes(client))
+        throw new Error(`Unknown client. Choose ${clients.join(', ')}.`);
+    const mode = options.mode ?? 'compact';
+    if (!['compact', 'full'].includes(mode))
+        throw new Error('Mode must be compact or full.');
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const args = options.local ? [join(packageRoot, 'dist', 'cli.js')] : ['-y', `${packageInfo.name}@${packageInfo.version}`];
+    args.push('serve', '--cwd', cwd, '--mode', mode);
+    if (options.envFile)
+        args.push('--env-file', resolve(cwd, options.envFile));
+    if (options.url) {
+        args.push('--url', validateMcpUrl(options.url));
+    }
+    const command = options.local ? process.execPath : 'npx';
+    if (client.startsWith('codex'))
+        return `[mcp_servers.steercards]\ncommand = ${JSON.stringify(command)}\nargs = ${JSON.stringify(args)}\n`;
+    return JSON.stringify({ mcpServers: { steercards: { ...(client === 'cursor' ? { type: 'stdio' } : {}), command, args } } }, null, 2) + '\n';
+}
+async function skillFiles(root, prefix = '') {
+    const result = {};
+    for (const entry of await readdir(join(root, prefix), { withFileTypes: true })) {
+        const path = prefix ? `${prefix}/${entry.name}` : entry.name;
+        if (entry.isDirectory())
+            Object.assign(result, await skillFiles(root, path));
+        else if (entry.isFile())
+            result[path] = await readFile(join(root, path));
+        else
+            throw new Error('Skill source must contain only regular files and directories.');
+    }
+    return result;
+}
+async function assertNoSymlink(path) {
+    let current = resolve(path);
+    while (true) {
+        try {
+            if ((await lstat(current)).isSymbolicLink())
+                throw new Error('Refusing to install through a symbolic link.');
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+}
+export async function installSkill(options) {
+    const dirs = { 'claude-code': '.claude', codex: '.agents', 'codex-cli': '.agents', 'codex-app': '.agents', cursor: '.cursor' };
+    const dir = dirs[options.client];
+    if (!dir)
+        throw new Error('For Claude Desktop use skill export and upload the ZIP, or read steercards_get_guide through MCP.');
+    const base = options.global ? (options.home ?? homedir()) : resolve(options.cwd ?? process.cwd());
+    const target = join(base, dir, 'skills', 'steercards');
+    await assertNoSymlink(target);
+    const files = await skillFiles(options.source ?? skillRoot);
+    try {
+        const existing = await skillFiles(target);
+        if (Object.keys(existing).length === Object.keys(files).length && Object.entries(files).every(([name, data]) => existing[name] && Buffer.from(data).equals(existing[name])))
+            return { path: target, status: 'unchanged' };
+        throw new Error(`Existing skill differs at ${target}. Review and remove or move that directory before reinstalling.`);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    await mkdir(dirname(target), { recursive: true });
+    const stage = await mkdtemp(join(dirname(target), '.steercards-'));
+    try {
+        for (const [name, data] of Object.entries(files)) {
+            await mkdir(dirname(join(stage, name)), { recursive: true });
+            await writeFile(join(stage, name), data, { flag: 'wx' });
+        }
+        // Reject races with existing installs, including an empty directory.
+        try {
+            await lstat(target);
+            throw new Error('Skill destination was created during installation; retry after reviewing it.');
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        await rename(stage, target);
+    }
+    finally {
+        await rm(stage, { recursive: true, force: true });
+    }
+    return { path: target, status: 'installed' };
+}
+export async function exportSkill(output, source = skillRoot) {
+    const files = await skillFiles(source);
+    const entries = Object.fromEntries(Object.entries(files).map(([name, bytes]) => [`steercards/${name}`, bytes]));
+    const target = resolve(output);
+    await writeFile(target, zipSync(entries), { flag: 'wx' });
+    return target;
+}

package/dist/package.d.ts

@@ -0,0 +1,5 @@
+export declare const packageRoot: string;
+export declare const packageInfo: {
+    name: string;
+    version: string;
+};

package/dist/package.js

@@ -0,0 +1,5 @@
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { join } from 'node:path';
+export const packageRoot = fileURLToPath(new URL('../', import.meta.url));
+export const packageInfo = JSON.parse(await readFile(join(packageRoot, 'package.json'), 'utf8'));

package/dist/runtime.d.ts

@@ -0,0 +1,26 @@
+import { type CallToolResult, type Tool } from '@modelcontextprotocol/sdk/types.js';
+import { type Config } from './config.js';
+export type ToolSummary = Pick<Tool, 'name' | 'title' | 'annotations'> & {
+    description?: string;
+};
+/** One authenticated upstream client. Calls are never automatically retried. */
+export declare class Runtime {
+    private readonly config;
+    private client?;
+    private transport?;
+    private connecting?;
+    private catalog?;
+    private listing?;
+    private closed;
+    constructor(config: Config);
+    /** Redact credentials if a transport or upstream RPC error echoes them. */
+    private safeError;
+    private connection;
+    listTools({ refresh }?: {
+        refresh?: boolean;
+    }): Promise<Tool[]>;
+    searchTools(query: string, limit?: number): Promise<ToolSummary[]>;
+    describeTool(name: string): Promise<Tool>;
+    callTool(name: string, args?: Record<string, unknown>): Promise<CallToolResult>;
+    close(): Promise<void>;
+}

package/dist/runtime.js

@@ -0,0 +1,214 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { CallToolResultSchema, ListToolsResultSchema, ToolListChangedNotificationSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { validateMcpUrl } from './config.js';
+import { packageInfo } from './package.js';
+/** Extract only a small, machine-readable code; arbitrary error prose stays private. */
+async function httpErrorCode(response, agentKey) {
+    if (!response.headers.get('content-type')?.toLowerCase().includes('application/json') || !response.body) {
+        await response.body?.cancel();
+        return undefined;
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let length = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            length += value.length;
+            if (length > 16 * 1024)
+                return undefined;
+            chunks.push(value);
+        }
+        const parsed = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+        const code = parsed?.error?.code;
+        if (typeof code === 'string' && /^[A-Z][A-Z0-9_]{1,79}$/.test(code)
+            && !code.includes(agentKey) && !agentKey.includes(code))
+            return code;
+    }
+    catch { /* A malformed or interrupted diagnostic body is not itself an error. */ }
+    finally {
+        await reader.cancel().catch(() => { });
+    }
+    return undefined;
+}
+/** One authenticated upstream client. Calls are never automatically retried. */
+export class Runtime {
+    config;
+    client;
+    transport;
+    connecting;
+    catalog;
+    listing;
+    closed = false;
+    constructor(config) {
+        this.config = { ...config, url: validateMcpUrl(config.url) };
+        if (!config.agentKey || /\s/.test(config.agentKey))
+            throw new Error('STEERCARDS_AGENT_KEY is invalid.');
+    }
+    /** Redact credentials if a transport or upstream RPC error echoes them. */
+    safeError(error) {
+        const message = error instanceof Error ? error.message : 'Steercards MCP request failed.';
+        return new Error(message.split(this.config.agentKey).join('[redacted]'));
+    }
+    async connection() {
+        if (this.closed)
+            throw new Error('Steercards runtime is closed.');
+        if (this.client)
+            return this.client;
+        if (!this.connecting) {
+            this.connecting = (async () => {
+                const client = new Client({ name: packageInfo.name, version: packageInfo.version });
+                client.setNotificationHandler(ToolListChangedNotificationSchema, async () => { this.catalog = undefined; });
+                const endpoint = this.config.url;
+                const transport = new StreamableHTTPClientTransport(new URL(endpoint), {
+                    requestInit: { headers: { Authorization: `Bearer ${this.config.agentKey}` }, redirect: 'error' },
+                    reconnectionOptions: { maxRetries: 0, initialReconnectionDelay: 1000, maxReconnectionDelay: 1000, reconnectionDelayGrowFactor: 1 },
+                    fetch: async (input, init) => {
+                        // Every request stays on the explicitly selected endpoint. Even same-origin
+                        // redirects are refused so bearer credentials cannot move to another route.
+                        const target = input instanceof Request ? input.url : input.toString();
+                        if (target !== endpoint)
+                            throw new Error('Refused a request outside the configured MCP endpoint.');
+                        const response = await fetch(input, { ...init, redirect: 'error' });
+                        if (!response.ok && response.status !== 405) {
+                            const code = await httpErrorCode(response, this.config.agentKey);
+                            const retry = response.headers.get('retry-after');
+                            const retryHint = retry && /^\d{1,8}$/.test(retry) ? ` Retry-After: ${retry} seconds.` : '';
+                            const hint = code === 'AGENT_AUDIT_UNAVAILABLE'
+                                ? ' The mutation may have committed before audit recording failed. Inspect current state before retrying.'
+                                : response.status === 429 ? ' Rate limit reached; inspect state before retrying an uncertain mutation.' : '';
+                            // SDK errors include HTTP response bodies. Supply a safe diagnostic body
+                            // instead of propagating arbitrary proxy/error pages containing secrets.
+                            return new Response(`HTTP ${response.status}${code ? ` (${code})` : ''}.${retryHint}${hint}`, {
+                                status: response.status, headers: response.headers,
+                            });
+                        }
+                        return response;
+                    },
+                });
+                this.transport = transport;
+                try {
+                    await client.connect(transport);
+                    if (this.closed) {
+                        await client.close();
+                        throw new Error('Steercards runtime is closed.');
+                    }
+                    this.client = client;
+                    return client;
+                }
+                catch (error) {
+                    await client.close().catch(() => { });
+                    if (this.transport === transport)
+                        this.transport = undefined;
+                    throw this.safeError(error);
+                }
+            })().finally(() => { this.connecting = undefined; });
+        }
+        return this.connecting;
+    }
+    async listTools({ refresh = false } = {}) {
+        if (this.closed)
+            throw new Error('Steercards runtime is closed.');
+        if (this.catalog && !refresh)
+            return structuredClone(this.catalog);
+        if (!this.listing) {
+            this.listing = (async () => {
+                try {
+                    const client = await this.connection();
+                    const tools = [];
+                    const cursors = new Set();
+                    const names = new Set();
+                    let cursor;
+                    do {
+                        // Avoid the SDK convenience method's output-schema compilation: a
+                        // proxy must accept and pass through the server's JSON Schemas.
+                        const page = await client.request({ method: 'tools/list', params: cursor ? { cursor } : {} }, ListToolsResultSchema);
+                        for (const tool of page.tools) {
+                            if (names.has(tool.name))
+                                throw new Error('The upstream tool catalog contains duplicate tool names.');
+                            names.add(tool.name);
+                            tools.push(tool);
+                        }
+                        cursor = page.nextCursor;
+                        if (cursor) {
+                            if (cursors.has(cursor))
+                                throw new Error('The upstream tool catalog repeated a pagination cursor.');
+                            cursors.add(cursor);
+                        }
+                    } while (cursor);
+                    this.catalog = tools;
+                    return tools;
+                }
+                catch (error) {
+                    throw this.safeError(error);
+                }
+            })().finally(() => { this.listing = undefined; });
+        }
+        return structuredClone(await this.listing);
+    }
+    async searchTools(query, limit = 10) {
+        if (typeof query !== 'string')
+            throw new Error('query must be a string.');
+        if (!Number.isInteger(limit) || limit < 1 || limit > 100)
+            throw new Error('limit must be an integer from 1 to 100.');
+        const terms = query.toLocaleLowerCase().trim().split(/\s+/).filter(Boolean);
+        // Stateless upstream servers cannot deliver catalog-change notifications.
+        // An explicit discovery search therefore refreshes the current catalog.
+        return (await this.listTools({ refresh: true })).map(tool => {
+            const name = tool.name.toLocaleLowerCase();
+            const text = `${name} ${tool.title ?? ''} ${tool.description ?? ''}`.toLocaleLowerCase();
+            const score = terms.every(term => text.includes(term))
+                ? terms.reduce((sum, term) => sum + (name === term ? 100 : name.includes(term) ? 10 : 1), 0) : -1;
+            return { tool, score };
+        }).filter(item => item.score >= 0)
+            .sort((a, b) => b.score - a.score || a.tool.name.localeCompare(b.tool.name))
+            .slice(0, limit).map(({ tool }) => ({
+            name: tool.name,
+            ...(tool.title ? { title: tool.title } : {}),
+            ...(tool.description ? { description: tool.description.length > 360 ? `${tool.description.slice(0, 357)}...` : tool.description } : {}),
+            ...(tool.annotations ? { annotations: tool.annotations } : {}),
+        }));
+    }
+    async describeTool(name) {
+        if (typeof name !== 'string' || !name)
+            throw new Error('A tool name is required.');
+        let tool = (await this.listTools()).find(item => item.name === name);
+        // A new server tool can be called without restarting the local process.
+        if (!tool)
+            tool = (await this.listTools({ refresh: true })).find(item => item.name === name);
+        if (!tool)
+            throw new Error('Unknown Steercards tool. Search or refresh the upstream catalog.');
+        return tool;
+    }
+    async callTool(name, args = {}) {
+        if (!args || typeof args !== 'object' || Array.isArray(args))
+            throw new Error('Tool arguments must be a JSON object.');
+        await this.describeTool(name);
+        try {
+            // Low-level request deliberately preserves error results without applying an
+            // outputSchema intended for successful results. No mutation retry is made.
+            return await (await this.connection()).request({
+                method: 'tools/call', params: { name, arguments: args },
+            }, CallToolResultSchema);
+        }
+        catch (error) {
+            throw this.safeError(error);
+        }
+    }
+    async close() {
+        this.closed = true;
+        const pending = this.connecting;
+        // Abort an in-flight initialize as well as established requests before
+        // waiting, so closing stdio cannot leave a stalled HTTP handshake running.
+        await this.transport?.close();
+        if (pending)
+            await pending.catch(() => { });
+        await this.client?.close();
+        this.client = undefined;
+        this.transport = undefined;
+        this.catalog = undefined;
+    }
+}

package/dist/server.d.ts

@@ -0,0 +1,9 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import type { Runtime } from './runtime.js';
+export interface ServerOptions {
+    mode: 'compact' | 'full';
+}
+export declare function getGuide(topic?: string): Promise<string>;
+/** Low-level Server preserves arbitrary upstream JSON Schemas and tool metadata. */
+export declare function createServer(runtime: Runtime, { mode }: ServerOptions): Server;
+export declare function startServer(runtime: Runtime, options: ServerOptions): Promise<Server>;

package/dist/server.js

@@ -0,0 +1,121 @@
+import { readFile } from 'node:fs/promises';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ErrorCode, ListResourcesRequestSchema, ListToolsRequestSchema, McpError, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { packageInfo } from './package.js';
+const guideTopics = ['overview', 'discovery', 'cards', 'profiles', 'claims-runs', 'context', 'files', 'collaboration'];
+const guideUri = 'steercards://guide/';
+const instructions = 'Steercards tools use progressive discovery. In compact mode search tool metadata, describe the selected tool to obtain its current schema, then call it with matching arguments. Read the Steercards guide for workflows. Tool schemas are fetched from the authenticated upstream server. Respect isError and structuredContent. Never automatically retry a mutation after a network failure; read current state first. The upstream rate limit is 120 requests per minute; follow Retry-After.';
+export async function getGuide(topic = 'overview') {
+    if (!guideTopics.includes(topic)) {
+        throw new Error(`Unknown guide topic. Choose ${guideTopics.join(', ')}.`);
+    }
+    const path = topic === 'overview' ? '../skills/steercards/SKILL.md' : `../skills/steercards/references/${topic}.md`;
+    return readFile(new URL(path, import.meta.url), 'utf8');
+}
+const compactTools = [
+    {
+        name: 'steercards_search_tools', title: 'Search Steercards tools',
+        description: 'Search the live upstream catalog by tool name and description. Returns compact metadata without schemas; describe a match before calling it. An empty query browses the catalog.',
+        inputSchema: { type: 'object', properties: { query: { type: 'string' }, limit: { type: 'integer', minimum: 1, maximum: 100, default: 10 } }, required: ['query'], additionalProperties: false },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+    },
+    {
+        name: 'steercards_describe_tool', title: 'Describe a Steercards tool',
+        description: 'Get the selected upstream tool’s full current metadata, inputSchema, and outputSchema. The upstream schema is the authority for arguments.',
+        inputSchema: { type: 'object', properties: { name: { type: 'string', minLength: 1 } }, required: ['name'], additionalProperties: false },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+    },
+    {
+        name: 'steercards_call_tool', title: 'Call a Steercards tool',
+        description: 'Call a discovered upstream tool by its exact name with a JSON arguments object. Returns the upstream content, structuredContent, and isError unchanged. May write or delete data depending on the selected tool. Never automatically retry an uncertain mutation.',
+        inputSchema: { type: 'object', properties: { name: { type: 'string', minLength: 1 }, arguments: { type: 'object', additionalProperties: true } }, required: ['name', 'arguments'], additionalProperties: false },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
+    },
+    {
+        name: 'steercards_get_guide', title: 'Read the Steercards guide',
+        description: 'Read agent workflow guidance. Start with overview, then select a topic for the task.',
+        inputSchema: { type: 'object', properties: { topic: { type: 'string', enum: [...guideTopics], default: 'overview' } }, additionalProperties: false },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
+    },
+];
+function jsonResult(value) {
+    return { content: [{ type: 'text', text: JSON.stringify(value) }], structuredContent: value };
+}
+function stringArg(args, name) {
+    if (typeof args[name] !== 'string')
+        throw new McpError(ErrorCode.InvalidParams, `${name} must be a string.`);
+    return args[name];
+}
+function assertKeys(args, keys) {
+    if (Object.keys(args).some(key => !keys.includes(key)))
+        throw new McpError(ErrorCode.InvalidParams, 'Unexpected argument.');
+}
+/** Low-level Server preserves arbitrary upstream JSON Schemas and tool metadata. */
+export function createServer(runtime, { mode }) {
+    if (mode !== 'compact' && mode !== 'full')
+        throw new Error('Server mode must be compact or full.');
+    const server = new Server({ name: packageInfo.name, version: packageInfo.version }, {
+        capabilities: { tools: {}, resources: {} }, instructions,
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: mode === 'compact' ? structuredClone(compactTools) : await runtime.listTools({ refresh: true }),
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const args = request.params.arguments ?? {};
+        if (mode === 'full')
+            return runtime.callTool(request.params.name, args);
+        switch (request.params.name) {
+            case 'steercards_search_tools': {
+                assertKeys(args, ['query', 'limit']);
+                const query = stringArg(args, 'query');
+                if (args.limit !== undefined && (!Number.isInteger(args.limit) || Number(args.limit) < 1 || Number(args.limit) > 100)) {
+                    throw new McpError(ErrorCode.InvalidParams, 'limit must be an integer from 1 to 100.');
+                }
+                return jsonResult({ tools: await runtime.searchTools(query, args.limit) });
+            }
+            case 'steercards_describe_tool':
+                assertKeys(args, ['name']);
+                return jsonResult({ tool: await runtime.describeTool(stringArg(args, 'name')) });
+            case 'steercards_call_tool': {
+                assertKeys(args, ['name', 'arguments']);
+                const name = stringArg(args, 'name');
+                if (!args.arguments || typeof args.arguments !== 'object' || Array.isArray(args.arguments)) {
+                    throw new McpError(ErrorCode.InvalidParams, 'arguments must be a JSON object.');
+                }
+                return runtime.callTool(name, args.arguments);
+            }
+            case 'steercards_get_guide': {
+                assertKeys(args, ['topic']);
+                const topic = args.topic === undefined ? 'overview' : stringArg(args, 'topic');
+                return jsonResult({ topic, guide: await getGuide(topic) });
+            }
+            default: throw new McpError(ErrorCode.InvalidParams, 'Unknown local tool.');
+        }
+    });
+    // Resources cannot collide with any dynamically mirrored upstream tool name.
+    server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+        resources: guideTopics.map(topic => ({ uri: `${guideUri}${topic}`, name: `Steercards guide: ${topic}`, mimeType: 'text/markdown' })),
+    }));
+    server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+        const topic = request.params.uri.startsWith(guideUri) ? request.params.uri.slice(guideUri.length) : '';
+        if (!guideTopics.includes(topic))
+            throw new McpError(ErrorCode.InvalidParams, 'Unknown guide resource.');
+        return { contents: [{ uri: request.params.uri, mimeType: 'text/markdown', text: await getGuide(topic) }] };
+    });
+    server.onclose = () => { void runtime.close().catch(() => { }); };
+    return server;
+}
+export async function startServer(runtime, options) {
+    const server = createServer(runtime, options);
+    await server.connect(new StdioServerTransport());
+    // SDK 1's stdio transport does not close itself on stdin EOF. Explicitly
+    // release upstream HTTP resources when the host disconnects.
+    const onEnd = () => { void server.close().catch(() => { }); };
+    const onClose = server.onclose;
+    server.onclose = () => { process.stdin.off('end', onEnd); onClose?.(); };
+    process.stdin.once('end', onEnd);
+    if (process.stdin.readableEnded)
+        onEnd();
+    return server;
+}

package/dist/setup.d.ts

@@ -0,0 +1,34 @@
+export interface SetupOptions {
+    client: string;
+    cwd?: string;
+    local?: boolean;
+    mode?: string;
+    url?: string;
+    envFile?: string;
+    dryRun?: boolean;
+    home?: string;
+    platform?: NodeJS.Platform;
+    env?: NodeJS.ProcessEnv;
+}
+export interface SetupReport {
+    client: string;
+    version: string;
+    status: 'installed' | 'updated' | 'unchanged' | 'dry-run';
+    paths: {
+        config: string;
+        skill?: string;
+        skillZip?: string;
+        manifest: string;
+    };
+    actions: string[];
+    nextSteps: string[];
+}
+/** Internal dependency injection for isolated upgrade, race, and failure tests. */
+export interface SetupDependencies {
+    source?: string;
+    version?: string;
+    beforeCommit?: () => Promise<void>;
+    beforeWrite?: (path: string, index: number) => Promise<void>;
+}
+/** Configure MCP and the matching skill together, preserving unrelated client data. */
+export declare function setup(options: SetupOptions, dependencies?: SetupDependencies): Promise<SetupReport>;