@margay/ccl-core 1.3.5-rc.6

package/dist/sdk/types.d.ts

@@ -0,0 +1,423 @@
+/**
+ * ccl-sdk public types — the embeddable SDK form of CCL (issue: CCL 改造升级,
+ * 抽出可内嵌的 SDK 形态支撑 margay 内嵌 CoS 常驻运行).
+ *
+ * The interface shape deliberately mirrors the Anthropic Claude Agent SDK
+ * (query() + canUseTool callback + session resume) so a host like margay can
+ * keep a single call seam and swap between ccl-sdk (domestic-model customers)
+ * and the Anthropic Agent SDK (Claude customers).
+ *
+ * Wire contract: these types mirror the stream-json control protocol that
+ * cli/print.ts + cli/structuredIO.ts already speak. The SDK is the HOST side
+ * of that protocol; the CLI subprocess is the agent side. Keep field names in
+ * sync with utils/permissions/PermissionPromptToolResultSchema.ts and
+ * entrypoints/sdk/controlSchemas.ts.
+ */
+import type { McpSdkServerConfigWithInstance } from './mcpServer.js';
+/** Result of the host's permission callback for one tool call. */
+export type CanUseToolResult = {
+    behavior: 'allow';
+    /**
+     * Optionally rewrite the tool input ("modify" semantics). Omit or pass
+     * an empty object to run the tool with its original input.
+     */
+    updatedInput?: Record<string, unknown>;
+} | {
+    behavior: 'deny';
+    message?: string;
+    /** Also interrupt the current turn instead of letting the agent continue. */
+    interrupt?: boolean;
+} | {
+    /**
+     * Suspend the session at this tool call (issue P0-2 pending): the tool
+     * does NOT execute, the pending approval is persisted to the session
+     * store, the subprocess is terminated, and query() ends with a
+     * `suspended` event. The host process may exit. Later, from any
+     * process, resumeWithDecision(sessionId, {behavior:'allow'|'deny'})
+     * continues the session; on allow the tool executes with exactly the
+     * recorded (or host-updated) input.
+     */
+    behavior: 'pending';
+};
+export type CanUseToolContext = {
+    toolUseId: string;
+    agentId?: string;
+    /** CLI-side rule that put this call on the 'ask' path, when available. */
+    decisionReason?: string;
+    blockedPath?: string;
+    /** Permission rule suggestions the CLI offered (opaque; pass to UIs). */
+    suggestions?: unknown[];
+};
+export type CanUseToolFn = (toolName: string, input: Record<string, unknown>, context: CanUseToolContext) => Promise<CanUseToolResult> | CanUseToolResult;
+export type QueryOptions = {
+    /** Working directory for the agent session. */
+    cwd?: string;
+    /** Replace the system prompt entirely (sent via initialize, no ARG_MAX limit). */
+    systemPrompt?: string;
+    /** Append to the default system prompt instead of replacing it. */
+    appendSystemPrompt?: string;
+    /** Model or routing alias, forwarded to --model. */
+    model?: string;
+    /** Tool allowlist, forwarded to --allowed-tools. */
+    allowedTools?: string[];
+    /** Tool denylist, forwarded to --disallowed-tools. */
+    disallowedTools?: string[];
+    /**
+     * Permission callback. When set, the CLI runs with
+     * --permission-prompt-tool stdio and every 'ask'-path tool call is routed
+     * here before execution. Fail-closed: throw/timeout/unrecognized result ⇒
+     * deny, the tool does not execute.
+     */
+    canUseTool?: CanUseToolFn;
+    /**
+     * Milliseconds before an unresolved canUseTool callback is treated as a
+     * deny (fail-closed). Default 300_000. Pass 0 to disable the timeout
+     * (NOT recommended for unattended hosts).
+     */
+    canUseToolTimeoutMs?: number;
+    /** Fixed session ID (UUID) for this session, forwarded to --session-id. */
+    sessionId?: string;
+    /** Resume an existing session by ID, forwarded to --resume. */
+    resume?: string;
+    /** With resume: fork to a new session ID instead of appending. */
+    forkSession?: boolean;
+    /** Max agentic turns for this query, forwarded to --max-turns. */
+    maxTurns?: number;
+    /** Max spend for this query, forwarded to --max-budget-usd. */
+    maxBudgetUsd?: number;
+    /** Forwarded to --permission-mode. */
+    permissionMode?: string;
+    /** Plugin directories (skills/agents/hooks), repeatable --plugin-dir. */
+    pluginDirs?: string[];
+    /** Extra directories the agent may touch, forwarded to --add-dir. */
+    addDirs?: string[];
+    /** Settings file path or JSON string, forwarded to --settings. */
+    settings?: string;
+    /** Inline agent definitions JSON, forwarded to --agents. */
+    agents?: string;
+    /** Set false to disable transcript persistence (--no-session-persistence). */
+    persistSession?: boolean;
+    /** Extra environment variables for the subprocess. */
+    env?: Record<string, string>;
+    /** Abort the whole query (kills the subprocess). */
+    signal?: AbortSignal;
+    /**
+     * Path to the CCL CLI entrypoint (dist/cli.js). Defaults to resolving
+     * "ccl" from PATH; hosts embedding a pinned build should set this.
+     */
+    cliPath?: string;
+    /** Node/bun executable used to run cliPath. Defaults to process.execPath. */
+    execPath?: string;
+    /** Escape hatch: extra argv appended verbatim. */
+    extraArgs?: string[];
+    /** Emit `raw` passthrough events for every subprocess message. */
+    includeRaw?: boolean;
+    /**
+     * slice sdk-token-streaming (G3): emit `stream_event` deltas as they arrive (token-level
+     * streaming). Passes `--include-partial-messages` to the CLI so the subprocess streams
+     * Anthropic raw message stream events (content_block_delta/text_delta, etc.). Default off →
+     * unchanged behavior; the full-block `assistant_text` events are still emitted alongside.
+     */
+    includePartialMessages?: boolean;
+    /**
+     * slice sdk-json-schema-output (G4): a JSON Schema for structured output. When set, the CLI
+     * validates the final result against it (retrying the model) and returns `structuredOutput` on
+     * the result event. Passed over the initialize control_request (not argv). Default → unset,
+     * unchanged behavior.
+     */
+    jsonSchema?: Record<string, unknown>;
+    /**
+     * slice sdk-input-external-mcp (G2): external MCP servers to launch for this query, keyed by name
+     * (standard MCP config, e.g. `{ myserver: { command: 'npx', args: [...] } }`). Serialized to the
+     * CLI's `--mcp-config`. Distinct from `sdkMcpServers` (in-process host tools). Default → none.
+     */
+    mcpServers?: Record<string, unknown>;
+    /**
+     * slice sdk-input-external-mcp (G6): full content blocks for the first user message (multimodal
+     * input, e.g. text + image). When set, REPLACES the plain `prompt` text content. Vision requires a
+     * vision-capable model. Default → the string `prompt` is sent as a single text block.
+     */
+    promptContentBlocks?: Array<{
+        type: string;
+        [key: string]: unknown;
+    }>;
+    /**
+     * Explicit skills directories (issue P1-5), independent of cwd. Each dir
+     * must contain `<name>/SKILL.md` entries; the SDK wraps each as an
+     * ephemeral plugin (skills symlink) loaded via --plugin-dir, the CLI's
+     * cwd-independent skill channel.
+     */
+    skillsDirs?: string[];
+    /**
+     * Model provider (issue P0-4). 'anthropic' maps to --base-url/--api-key
+     * (any Anthropic-protocol endpoint). 'openai-compatible' maps to CCL's
+     * gateway channel (CCL_GATEWAY_URL/CCL_GATEWAY_KEY) — CCL reaches
+     * OpenAI-compatible models through its gateway, which normalizes
+     * tool-calling and rejects models without native function calling instead
+     * of silently degrading. Omit to inherit the CLI's configured provider.
+     */
+    provider?: ProviderConfig;
+    /** Lifecycle hooks (issue P1-6). Errors are swallowed; hooks never block a decision. */
+    hooks?: LifecycleHooks;
+    /**
+     * Session store for pending approvals + usage accumulation. Defaults to
+     * the local-file store (fileSessionStore()). Pass a custom implementation
+     * to back it with Redis/DB.
+     */
+    store?: SessionStore;
+    /**
+     * Internal to resumeWithDecision(): the approval decision to apply to the
+     * recorded pending tool call on resume. When set, query() does not send a
+     * user prompt — the CLI auto-continues the interrupted turn.
+     */
+    pendingDecision?: PendingDecision;
+    /**
+     * slice sdk-in-process-mcp-server (G1): host-defined in-process MCP servers. Build each with
+     * `createSdkMcpServer({ name, tools: [tool(...)] })`. The agent (in the spawned CLI subprocess)
+     * can call these tools; each call is bridged back to the host's JS handler over the control
+     * protocol AND still passes through canUseTool for gating. Omit → unchanged behavior.
+     */
+    sdkMcpServers?: McpSdkServerConfigWithInstance[];
+};
+export type ProviderConfig = {
+    type: 'anthropic';
+    baseUrl?: string;
+    apiKey?: string;
+} | {
+    type: 'openai-compatible';
+    baseUrl: string;
+    apiKey?: string;
+};
+export type LifecycleHooks = {
+    /**
+     * slice sdk-observability-hooks-usage (G5): once, when the first session_id is observed.
+     * Observability only (never affects control flow).
+     */
+    onSessionStart?: (event: {
+        sessionId: string;
+    }) => void | Promise<void>;
+    /**
+     * slice sdk-observability-hooks-usage (G5): when the host's prompt is submitted to the agent.
+     */
+    onUserPromptSubmit?: (event: {
+        prompt: string;
+        sessionId?: string;
+    }) => void | Promise<void>;
+    /** After each tool execution (fires on the tool_result). */
+    onToolUse?: (event: {
+        toolUseId: string;
+        toolName?: string;
+        content: unknown;
+        isError: boolean;
+        sessionId?: string;
+    }) => void | Promise<void>;
+    /**
+     * After each assistant turn (one model response). `usage` (G7) carries that turn's token usage
+     * when the assistant message reported it.
+     */
+    onTurnEnd?: (event: {
+        turn: number;
+        sessionId?: string;
+        usage?: Usage;
+    }) => void | Promise<void>;
+    /** Once per query, on the terminal result or fatal error. */
+    onSessionEnd?: (event: {
+        sessionId?: string;
+        subtype: string;
+        isError: boolean;
+        usage?: Usage;
+    }) => void | Promise<void>;
+};
+/** A tool call suspended for out-of-band approval, persisted by the store. */
+export type PendingApproval = {
+    sessionId: string;
+    requestId: string;
+    toolUseId: string;
+    toolName: string;
+    input: Record<string, unknown>;
+    createdAt: string;
+};
+/** Host decision applied on resume for a recorded pending approval. */
+export type PendingDecision = {
+    behavior: 'allow';
+    /** Override the approved input; defaults to the recorded pending input. */
+    updatedInput?: Record<string, unknown>;
+} | {
+    behavior: 'deny';
+    message?: string;
+};
+export type AccumulatedUsage = {
+    queries: number;
+    inputTokens: number;
+    outputTokens: number;
+    cacheCreationInputTokens: number;
+    cacheReadInputTokens: number;
+    totalCostUsd: number;
+};
+export type SessionStore = {
+    savePendingApproval: (record: PendingApproval) => Promise<void>;
+    loadPendingApproval: (sessionId: string) => Promise<PendingApproval | null>;
+    deletePendingApproval: (sessionId: string) => Promise<void>;
+    addUsage: (sessionId: string, usage: Usage, costUsd?: number) => Promise<AccumulatedUsage>;
+    getUsage: (sessionId: string) => Promise<AccumulatedUsage | null>;
+};
+/** Token usage as reported by the CLI result message (provider-raw values). */
+export type Usage = {
+    input_tokens?: number;
+    output_tokens?: number;
+    cache_creation_input_tokens?: number;
+    cache_read_input_tokens?: number;
+    [k: string]: unknown;
+};
+/**
+ * Events yielded by query(). All events are JSON-serializable. This is the
+ * minimal set from the issue (P0-1) plus `permission_resolved` (audit trail)
+ * and optional `raw` passthrough.
+ */
+export type SDKEvent = {
+    type: 'assistant_text';
+    text: string;
+    sessionId?: string;
+} | {
+    type: 'tool_use';
+    toolName: string;
+    input: Record<string, unknown>;
+    toolUseId: string;
+    sessionId?: string;
+} | {
+    type: 'tool_result';
+    toolUseId: string;
+    content: unknown;
+    isError: boolean;
+    sessionId?: string;
+} | {
+    type: 'permission_request';
+    requestId: string;
+    toolName: string;
+    input: Record<string, unknown>;
+    toolUseId: string;
+    agentId?: string;
+} | {
+    type: 'permission_resolved';
+    requestId: string;
+    toolUseId: string;
+    behavior: 'allow' | 'deny';
+    /** Why the SDK decided this way when the host callback did not decide. */
+    failClosedReason?: string;
+    /** 'pending_decision' when resolved by resumeWithDecision, not the live callback. */
+    source?: 'callback' | 'pending_decision';
+} | {
+    /** Terminal event of a query suspended by a pending approval (P0-2). */
+    type: 'suspended';
+    sessionId: string;
+    requestId: string;
+    toolUseId: string;
+    toolName: string;
+    input: Record<string, unknown>;
+} | {
+    type: 'result';
+    subtype: string;
+    usage?: Usage;
+    totalCostUsd?: number;
+    numTurns?: number;
+    durationMs?: number;
+    isError: boolean;
+    sessionId?: string;
+    result?: string;
+    /**
+     * slice sdk-json-schema-output (G4): the schema-validated structured output, present only
+     * when the query was run with `jsonSchema`. undefined otherwise. subtype
+     * 'error_max_structured_output_retries' means validation failed after retries.
+     */
+    structuredOutput?: unknown;
+} | {
+    type: 'error';
+    message: string;
+    fatal: boolean;
+    code?: string;
+} | {
+    type: 'raw';
+    message: Record<string, unknown>;
+}
+/**
+ * slice sdk-token-streaming (G3): one Anthropic raw message stream event (token-level delta),
+ * emitted only when `includePartialMessages` is set. `event.type` is one of
+ * content_block_start / content_block_delta / content_block_stop / message_delta /
+ * message_start / message_stop; e.g. a content_block_delta carries `delta.text` (text_delta).
+ */
+ | {
+    type: 'stream_event';
+    event: {
+        type: string;
+        [key: string]: unknown;
+    };
+    sessionId?: string;
+};
+/**
+ * Parsed initialize control_response payload (P1). Field shapes follow
+ * SDKControlInitializeResponseSchema in entrypoints/sdk/controlSchemas.ts.
+ */
+export type InitializationResult = {
+    commands?: unknown[];
+    agents?: unknown[];
+    models?: unknown[];
+    account?: Record<string, unknown>;
+    output_style?: string;
+    available_output_styles?: string[];
+    [k: string]: unknown;
+};
+/**
+ * Query handle (P1 sdk-query-handle): the async event stream of a query plus
+ * control methods speaking the control_request/control_response wire protocol
+ * of entrypoints/sdk/controlSchemas.ts. Control methods resolve without the
+ * host iterating events; events are buffered and replayed to the iterator so
+ * the stream is identical to the bare queryWithTransport generator.
+ */
+export interface Query extends AsyncGenerator<SDKEvent, void, unknown> {
+    interrupt(): Promise<unknown>;
+    setPermissionMode(mode: string): Promise<unknown>;
+    setModel(model?: string): Promise<unknown>;
+    setMaxThinkingTokens(n: number | null): Promise<unknown>;
+    mcpServerStatus(): Promise<unknown>;
+    reconnectMcpServer(name: string): Promise<unknown>;
+    toggleMcpServer(name: string, enabled: boolean): Promise<unknown>;
+    setMcpServers(servers: Record<string, unknown>): Promise<unknown>;
+    stopTask(id: string): Promise<unknown>;
+    applyFlagSettings(settings: Record<string, unknown>): Promise<unknown>;
+    /**
+     * Rewind file changes made since a user message (control_request subtype
+     * "rewind_files"; wire fields user_message_id / dry_run per
+     * entrypoints/sdk/controlSchemas.ts). Pass `{ dry_run: true }` in options
+     * for a preview. Unlike other control methods it stays callable after the
+     * result event — rewinding is a post-run operation.
+     */
+    rewindFiles(userMessageId: string, options?: Record<string, unknown>): Promise<unknown>;
+    initializationResult(): Promise<InitializationResult>;
+    reinitialize(): Promise<InitializationResult>;
+    supportedCommands(): Promise<unknown>;
+    supportedModels(): Promise<unknown>;
+    supportedAgents(): Promise<unknown>;
+    accountInfo(): Promise<unknown>;
+    close(): Promise<void>;
+}
+/** One NDJSON message to/from the subprocess. */
+export type WireMessage = Record<string, unknown> & {
+    type: string;
+};
+/**
+ * Transport seam: production uses a managed subprocess (see transport.ts);
+ * tests inject a fake. read() yields parsed inbound messages until the
+ * process/stream ends.
+ */
+export type Transport = {
+    read: () => AsyncIterable<WireMessage>;
+    write: (message: WireMessage) => Promise<void>;
+    /** Terminate the underlying process/stream. Idempotent. */
+    close: () => Promise<void>;
+    /** Resolves with the exit code once the underlying process ends. */
+    exited: Promise<number | null>;
+    /** Child process id when the transport wraps a real subprocess (host-side
+     * monitoring/cleanup; pgrep-by-argv is unreliable once process.title is
+     * rewritten). Absent for in-memory test transports. */
+    pid?: number;
+};

package/dist/sdk/types.js

@@ -0,0 +1,16 @@
+/**
+ * ccl-sdk public types — the embeddable SDK form of CCL (issue: CCL 改造升级,
+ * 抽出可内嵌的 SDK 形态支撑 margay 内嵌 CoS 常驻运行).
+ *
+ * The interface shape deliberately mirrors the Anthropic Claude Agent SDK
+ * (query() + canUseTool callback + session resume) so a host like margay can
+ * keep a single call seam and swap between ccl-sdk (domestic-model customers)
+ * and the Anthropic Agent SDK (Claude customers).
+ *
+ * Wire contract: these types mirror the stream-json control protocol that
+ * cli/print.ts + cli/structuredIO.ts already speak. The SDK is the HOST side
+ * of that protocol; the CLI subprocess is the agent side. Keep field names in
+ * sync with utils/permissions/PermissionPromptToolResultSchema.ts and
+ * entrypoints/sdk/controlSchemas.ts.
+ */
+export {};

package/dist/vendor/ripgrep/VERSION

@@ -0,0 +1,8 @@
+ripgrep 14.1.1 (rev 4649aa9700)
+source: https://github.com/BurntSushi/ripgrep/releases/tag/14.1.1
+fetched: 2026-07-17 (official release archives, extracted rg binaries only)
+
+0e0cb83f5195f1f51bb8feef1fff5b0b171e82bd1db6bd35deee701a3e7102f8  arm64-darwin/rg
+923dcc25cab57d33f4e7dd0476d4b74a554401a38817e246a8d6101dcd51c50f  x64-darwin/rg
+f401154e2393f9002ac77e419f9ee5521c18f4f8cd3e32293972f493ba06fce7  x64-linux/rg
+f162b54de2adfc72d78adb1dbada2dedda111ae0a5e2f6e9500f4f909664c5d2  x64-win32/rg.exe

package/package.json

@@ -0,0 +1,149 @@
+{
+  "name": "@margay/ccl-core",
+  "version": "1.3.5-rc.6",
+  "description": "Core runtime extracted from Claude Code (ccl) for Margay integration",
+  "license": "SEE LICENSE IN README.md",
+  "type": "module",
+  "bin": {
+    "margay": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "QUICKSTART.md",
+    "INTENT-GATEWAY-GUIDE.md"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "build": "bun run scripts/build.mjs && npm run build:sdk && node scripts/check-feature-gates.mjs",
+    "prepublishOnly": "bun run build",
+    "test": "vitest run",
+    "test:smoke": "vitest run -c vitest.smoke.config.ts",
+    "build:sdk": "tsc -p tsconfig.sdk.json"
+  },
+  "dependencies": {
+    "@alcalzone/ansi-tokenize": "^0.3.0",
+    "@anthropic-ai/bedrock-sdk": "^0.27.0",
+    "@anthropic-ai/sdk": "^0.39.0",
+    "@anthropic-ai/vertex-sdk": "^0.14.4",
+    "@aws-sdk/client-bedrock": "^3.1024.0",
+    "@aws-sdk/client-bedrock-runtime": "^3.1024.0",
+    "@aws-sdk/client-sts": "^3.1024.0",
+    "@aws-sdk/credential-provider-node": "^3.972.29",
+    "@aws-sdk/credential-providers": "^3.1024.0",
+    "@azure/identity": "^4.13.1",
+    "@commander-js/extra-typings": "^14.0.0",
+    "@growthbook/growthbook": "^1.6.5",
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/api-logs": "^0.214.0",
+    "@opentelemetry/core": "^2.6.1",
+    "@opentelemetry/exporter-logs-otlp-grpc": "^0.214.0",
+    "@opentelemetry/exporter-logs-otlp-http": "^0.214.0",
+    "@opentelemetry/exporter-logs-otlp-proto": "^0.214.0",
+    "@opentelemetry/exporter-metrics-otlp-grpc": "^0.214.0",
+    "@opentelemetry/exporter-metrics-otlp-http": "^0.214.0",
+    "@opentelemetry/exporter-metrics-otlp-proto": "^0.214.0",
+    "@opentelemetry/exporter-prometheus": "^0.214.0",
+    "@opentelemetry/exporter-trace-otlp-grpc": "^0.214.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.214.0",
+    "@opentelemetry/exporter-trace-otlp-proto": "^0.214.0",
+    "@opentelemetry/resources": "^2.6.1",
+    "@opentelemetry/sdk-logs": "^0.214.0",
+    "@opentelemetry/sdk-metrics": "^2.6.1",
+    "@opentelemetry/sdk-trace-base": "^2.6.1",
+    "@opentelemetry/semantic-conventions": "^1.40.0",
+    "@smithy/core": "^3.23.13",
+    "@smithy/node-http-handler": "^4.5.1",
+    "@vitest/coverage-v8": "3",
+    "asciichart": "^1.5.25",
+    "auto-bind": "^5.0.1",
+    "axios": "^1.14.0",
+    "bidi-js": "^1.0.3",
+    "cacache": "^20.0.4",
+    "chalk": "^5.6.2",
+    "chokidar": "^5.0.0",
+    "cli-boxes": "^4.0.1",
+    "cli-highlight": "^2.1.11",
+    "code-excerpt": "^4.0.0",
+    "diff": "^8.0.4",
+    "emoji-regex": "^10.6.0",
+    "env-paths": "^4.0.0",
+    "execa": "^9.6.1",
+    "fflate": "^0.8.2",
+    "figures": "^6.1.0",
+    "fuse.js": "^7.3.0",
+    "get-east-asian-width": "^1.5.0",
+    "google-auth-library": "^10.6.2",
+    "highlight.js": "^11.11.1",
+    "https-proxy-agent": "^9.0.0",
+    "ignore": "^7.0.5",
+    "indent-string": "^5.0.0",
+    "jsonc-parser": "^3.3.1",
+    "lodash-es": "^4.17.21",
+    "lru-cache": "^11.2.7",
+    "marked": "^17.0.5",
+    "p-map": "^7.0.4",
+    "playwright": "^1.59.1",
+    "plist": "^3.1.0",
+    "proper-lockfile": "^4.1.2",
+    "qrcode": "^1.5.4",
+    "react-reconciler": "^0.33.0",
+    "semver": "^7.7.4",
+    "sharp": "^0.34.5",
+    "shell-quote": "^1.8.3",
+    "signal-exit": "^4.1.0",
+    "stack-utils": "^2.0.6",
+    "strip-ansi": "^7.1.0",
+    "supports-hyperlinks": "^4.4.0",
+    "tree-kill": "^1.2.2",
+    "turndown": "^7.2.4",
+    "type-fest": "^5.5.0",
+    "undici": "^8.0.2",
+    "usehooks-ts": "^3.1.1",
+    "vscode-jsonrpc": "^8.2.1",
+    "vscode-languageserver-protocol": "^3.17.5",
+    "vscode-languageserver-types": "^3.17.5",
+    "wrap-ansi": "^10.0.0",
+    "ws": "^8.20.0",
+    "xss": "^1.0.15",
+    "yaml": "^2.8.3",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "@types/cacache": "^20.0.1",
+    "@types/diff": "^7.0.2",
+    "@types/lodash-es": "^4.17.12",
+    "@types/node": "^22.0.0",
+    "@types/plist": "^3.0.5",
+    "@types/proper-lockfile": "^4.1.4",
+    "@types/qrcode": "^1.5.6",
+    "@types/react": "^19.0.0",
+    "@types/semver": "^7.7.1",
+    "@types/shell-quote": "^1.7.5",
+    "@types/turndown": "^5.0.6",
+    "@types/ws": "^8.18.1",
+    "node-pty": "^1.1.0",
+    "typescript": "^5.8.0",
+    "vitest": "^3.1.0"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "exports": {
+    "./sdk": {
+      "types": "./dist/sdk/index.d.ts",
+      "import": "./dist/sdk/index.js"
+    },
+    "./dist/*": "./dist/*",
+    "./package.json": "./package.json"
+  }
+}