@cjhyy/code-shell-link 0.9.44 → 0.9.47

package/dist/catalog.js

@@ -1,3 +1,4 @@
+import { FIGMA_MCP_ACTION_IDS } from "./figma.js";
 const text = (zh, en) => ({ zh, en });
 function localToken(id, displayName, tokenLabel, tokenPlaceholder, authGuide) {
     return {
@@ -377,7 +378,7 @@ export const LINK_PROVIDER_MANIFESTS = [
         id: "figma",
         displayName: "Figma",
         category: "design",
-        description: text("按需读取设计结构、节点、渲染图、填充图片和评论。", "Read design structure, nodes, rendered images, image fills, and comments on demand."),
+        description: text("API 读取原始节点、图片和评论；需要设计上下文、动画、组件映射或 Make 源码时使用官方 MCP。", "Use the API for nodes, images, and comments; use official MCP when design context, motion, code mappings, or Make source is needed."),
         brandText: "Fi",
         icon: "figma",
         accent: "violet",
@@ -400,9 +401,34 @@ export const LINK_PROVIDER_MANIFESTS = [
                 note: text("Token 只能访问你的 Figma 账号本身有权限的文件。", "The token can only access files already available to your Figma account."),
             }),
             { ...managedOAuth("Figma"), id: "figma-oauth" },
+            {
+                id: "mcp",
+                displayName: text("官方 MCP", "Official MCP"),
+                executionRuntime: "local",
+                secretLocation: "device",
+                authKind: "oauth",
+                availability: "available",
+                oauthProfileId: "figma-mcp",
+                browserAuth: {
+                    kind: "browser-oauth",
+                    flow: "authorization-code-pkce",
+                    displayName: text("连接官方 MCP", "Connect official MCP"),
+                    summary: text("需要高级设计内容时连接；授权保存在本机并自动刷新，连接时不读取文件。", "Connect when advanced design content is needed. Authorization is saved locally and refreshed automatically; connecting does not read files."),
+                    docsUrl: "https://developers.figma.com/docs/figma-mcp-server/remote-server-installation/",
+                    privacyNote: text("授权页面使用本次验证的 Codex 注册名称；Figma 账号权限仍由官方授权页面决定。", "The authorization page uses the verified Codex registration name; Figma account access is controlled by the official consent page."),
+                },
+            },
+        ],
+        fileSelection: { kind: "figma-file", action: "read_design_content", resourceGroup: "files" },
+        actionIds: [
+            "get_file",
+            "read_design_content",
+            "get_comments",
+            "get_nodes",
+            "get_images",
+            "get_image_fills",
+            ...FIGMA_MCP_ACTION_IDS,
         ],
-        fileSelection: { kind: "figma-file", action: "get_file", resourceGroup: "files" },
-        actionIds: ["get_file", "get_comments", "get_nodes", "get_images", "get_image_fills"],
     },
 ];
 export function getLinkProviderManifest(providerId) {

package/dist/figma.d.ts

@@ -0,0 +1,10 @@
+/** Figma-owned routing metadata. Host credentials and MCP lifecycle stay outside this package. */
+export declare const FIGMA_MCP_SERVER_URL = "https://mcp.figma.com/mcp";
+export declare const FIGMA_MCP_SCOPE = "mcp:connect";
+/** User-requested registration name verified against the official endpoint. */
+export declare const FIGMA_MCP_REGISTRATION_CLIENT_NAME = "Codex";
+export declare const FIGMA_MCP_TOOL_IDS: readonly ["get_metadata", "get_design_context", "get_screenshot", "get_variable_defs", "get_motion_context", "get_figjam", "get_code_connect_map", "get_libraries", "search_design_system"];
+/** These actions are always read-only; newly discovered upstream tools are never auto-enabled. */
+export declare const FIGMA_MCP_ACTION_IDS: readonly ["get_metadata", "get_design_context", "get_screenshot", "get_variable_defs", "get_motion_context", "get_figjam", "get_code_connect_map", "get_libraries", "search_design_system", "list_resources", "read_resource"];
+export type FigmaMcpActionId = (typeof FIGMA_MCP_ACTION_IDS)[number];
+export declare function isFigmaMcpAction(action: string): action is FigmaMcpActionId;

package/dist/figma.js

@@ -0,0 +1,25 @@
+/** Figma-owned routing metadata. Host credentials and MCP lifecycle stay outside this package. */
+export const FIGMA_MCP_SERVER_URL = "https://mcp.figma.com/mcp";
+export const FIGMA_MCP_SCOPE = "mcp:connect";
+/** User-requested registration name verified against the official endpoint. */
+export const FIGMA_MCP_REGISTRATION_CLIENT_NAME = "Codex";
+export const FIGMA_MCP_TOOL_IDS = [
+    "get_metadata",
+    "get_design_context",
+    "get_screenshot",
+    "get_variable_defs",
+    "get_motion_context",
+    "get_figjam",
+    "get_code_connect_map",
+    "get_libraries",
+    "search_design_system",
+];
+/** These actions are always read-only; newly discovered upstream tools are never auto-enabled. */
+export const FIGMA_MCP_ACTION_IDS = [
+    ...FIGMA_MCP_TOOL_IDS,
+    "list_resources",
+    "read_resource",
+];
+export function isFigmaMcpAction(action) {
+    return FIGMA_MCP_ACTION_IDS.includes(action);
+}

package/dist/file-selection.d.ts

@@ -5,6 +5,8 @@ export type LinkFileSelectionInput = {
     path: string;
     ref?: string;
     label?: string;
+    /** The path was picked from a provider listing: keep it byte-exact, never trim it. */
+    exact?: boolean;
 } | {
     kind: "figma-file";
     fileUrlOrKey: string;
@@ -13,7 +15,7 @@ export type LinkFileSelectionInput = {
 /** Provider-owned normalization, shared by Hosts without accepting arbitrary action JSON. */
 export declare function resolveLinkFileSelection(providerId: string, input: unknown): {
     providerId: string;
-    action: "get_file";
+    action: "get_file" | "read_design_content";
     scopeId: string;
     params: Record<string, string>;
     resourceId: string;

package/dist/file-selection.js

@@ -1,11 +1,11 @@
 import { getLinkProviderManifest } from "./catalog.js";
-function text(value, field, max) {
+function text(value, field, max, exact = false) {
     if (typeof value !== "string" ||
         !value.trim() ||
         value.length > max ||
         /[\x00-\x1f\x7f]/.test(value))
         throw new Error(`Invalid linked file ${field}`);
-    return value.trim();
+    return exact ? value : value.trim();
 }
 /** Provider-owned normalization, shared by Hosts without accepting arbitrary action JSON. */
 export function resolveLinkFileSelection(providerId, input) {
@@ -16,7 +16,7 @@ export function resolveLinkFileSelection(providerId, input) {
     if (file.kind !== capability.kind)
         throw new Error("Linked file belongs to another provider");
     const allowed = capability.kind === "github-file"
-        ? ["kind", "owner", "repo", "path", "ref", "label"]
+        ? ["kind", "owner", "repo", "path", "ref", "label", "exact"]
         : ["kind", "fileUrlOrKey", "label"];
     if (Object.keys(file).some((key) => !allowed.includes(key)))
         throw new Error("Unknown linked file field");
@@ -29,7 +29,10 @@ export function resolveLinkFileSelection(providerId, input) {
             !/^[a-z0-9_.-]+$/.test(repo) ||
             [".", ".."].includes(repo))
             throw new Error("Invalid GitHub repository");
-        const path = text(file.path, "path", 2_000);
+        if (file.exact !== undefined && typeof file.exact !== "boolean")
+            throw new Error("Invalid linked file exact flag");
+        // Typed paths are trimmed; picked exact paths keep surrounding whitespace (audit HL-01).
+        const path = text(file.path, "path", 2_000, file.exact === true);
         for (const segment of path.split("/")) {
             let decoded = segment;
             try {
@@ -72,6 +75,11 @@ export function resolveLinkFileSelection(providerId, input) {
         scopeId: `${providerId}:${capability.action}`,
         params,
         resourceId,
-        label: label ?? defaultLabel.slice(-512),
+        label: label ?? labelTail(defaultLabel, 512),
     };
 }
+/** Keep the last `max` UTF-16 units without starting on half a surrogate pair. */
+function labelTail(value, max) {
+    const tail = value.slice(-max);
+    return /^[\uDC00-\uDFFF]/.test(tail) ? tail.slice(1) : tail;
+}

package/dist/index.d.ts

@@ -1,5 +1,10 @@
 export { LINK_PROVIDER_MANIFESTS, getLinkProviderManifest, localizeLinkText } from "./catalog.js";
 export { resolveLinkFileSelection } from "./file-selection.js";
+export { LINK_OPERATION_CONTRACTS, getLinkOperationContract } from "./operations.js";
+export { LINK_CONNECTION_RECIPES, getLinkConnectionRecipe, resolveLinkRecipeId, linkConnectionMetadata, } from "./recipes.js";
+export { LinkOperationError, type LinkValueSchema, type LinkResourcePolicy, type LinkOperationContract, type LinkConnectionRecipe, type LinkRecipeId, type LinkOperationRequest, type LinkOperationAuthorization, } from "./operation-types.js";
+export { validateLinkOperationValue, validateLinkOperationInput, snapshotLinkOperationInput, assertLinkOperationResult, filterLinkOperationResult, assertLinkOperationAuthorized, } from "./operation-validation.js";
+export { FIGMA_MCP_SERVER_URL, FIGMA_MCP_SCOPE, FIGMA_MCP_REGISTRATION_CLIENT_NAME, FIGMA_MCP_TOOL_IDS, FIGMA_MCP_ACTION_IDS, isFigmaMcpAction, type FigmaMcpActionId, } from "./figma.js";
 export type { LinkFileSelectionInput } from "./file-selection.js";
 export type { LinkAuthGuide, LinkAuthKind, LinkConnectionMethodManifest, LinkCliSessionAuth, LinkExecutionRuntime, LinkLocalizedText, LinkMethodAvailability, LinkPermissionGuide, LinkPermissionLevel, LinkProviderAccent, LinkProviderCategory, LinkProviderIcon, LinkProviderManifest, LinkSecretLocation, } from "./types.js";
-export type { LinkProviderView, LinkAuthMode, LinkAuthorization, LinkAuthorizationInput, LinkAuthorizationResponse, LinkAuthorizationStep, LinkCredentialFieldView, LinkResourceGroupView, LinkConnectionInput, LinkErrorCode, LinkSnapshot, MaskedLinkConnection, TokenConnectionInput, } from "./management-types.js";
+export type { LinkProviderView, LinkAuthMode, LinkAuthorization, LinkAuthorizationFailure, LinkAuthorizationInput, LinkAuthorizationResponse, LinkAuthorizationStep, LinkCredentialFieldView, LinkResourceGroupView, LinkConnectionInput, LinkErrorCode, LinkSnapshot, MaskedLinkConnection, LinkConnectionState, TokenConnectionInput, } from "./management-types.js";

package/dist/index.js

@@ -1,2 +1,7 @@
 export { LINK_PROVIDER_MANIFESTS, getLinkProviderManifest, localizeLinkText } from "./catalog.js";
 export { resolveLinkFileSelection } from "./file-selection.js";
+export { LINK_OPERATION_CONTRACTS, getLinkOperationContract } from "./operations.js";
+export { LINK_CONNECTION_RECIPES, getLinkConnectionRecipe, resolveLinkRecipeId, linkConnectionMetadata, } from "./recipes.js";
+export { LinkOperationError, } from "./operation-types.js";
+export { validateLinkOperationValue, validateLinkOperationInput, snapshotLinkOperationInput, assertLinkOperationResult, filterLinkOperationResult, assertLinkOperationAuthorized, } from "./operation-validation.js";
+export { FIGMA_MCP_SERVER_URL, FIGMA_MCP_SCOPE, FIGMA_MCP_REGISTRATION_CLIENT_NAME, FIGMA_MCP_TOOL_IDS, FIGMA_MCP_ACTION_IDS, isFigmaMcpAction, } from "./figma.js";

package/dist/management-types.d.ts

@@ -102,13 +102,30 @@ export interface LinkAuthorizationResponse {
     operation: "submit" | "detect-session" | "login-session" | "bind-session" | "confirm" | "refresh-qr";
     input?: Record<string, string | string[] | boolean>;
 }
+export interface LinkConnectionState {
+    authorization: {
+        state: "authorized" | "reauthorization_required" | "unknown";
+    };
+    compatibility: {
+        state: "unknown" | "compatible" | "upgrade_required" | "unsupported";
+    };
+    /** A live operation observation, never inferred from credential verification or refresh. */
+    observation: {
+        state: "unchecked" | "succeeded" | "failed";
+        checkedAt?: string;
+        action?: string;
+        resource?: string;
+    };
+}
 export interface MaskedLinkConnection {
     id: string;
     providerId: string;
     methodId: string;
     label: string;
     runtime: "local" | "server";
-    authSource: "manual-token" | "cli-session" | "browser-oauth" | "remote-link";
+    authSource: "manual-token" | "cli-session" | "browser-oauth" | "mcp-oauth" | "remote-link";
+    recipeId?: import("./operation-types.js").LinkRecipeId;
+    connectionState?: LinkConnectionState;
     status: "connected" | "expired" | "invalid" | "unavailable";
     account?: {
         id?: string;
@@ -145,6 +162,14 @@ export interface LinkSnapshot {
     remoteServer?: {
         issuer: string;
     };
+    /** Discovery health is independent of saved account/grant state. */
+    remoteCatalog?: {
+        state: "unconfigured" | "unknown" | "ready" | "unavailable" | "stale";
+        checkedAt?: string;
+        lastSuccessAt?: string;
+        errorCode?: "network_error" | "http_error" | "invalid_response" | "response_too_large";
+        httpStatus?: number;
+    };
     /** Count only; retired secrets never leave the Host. Retried after restart with backoff. */
     remoteCleanupPending?: number;
     revision: string;
@@ -188,4 +213,13 @@ export interface LinkAuthorization {
     previousGrantRevocationPending?: boolean;
     connection?: MaskedLinkConnection;
     errorCode?: LinkErrorCode;
+    failure?: LinkAuthorizationFailure;
+}
+/** Fixed Host diagnostics only: never upstream messages, response bodies, or credentials. */
+export interface LinkAuthorizationFailure {
+    code: "invalid_request" | "access_denied" | "timeout" | "network_error" | "server_error" | "protocol_error";
+    stage: "validation" | "authorization" | "discovery_registration" | "authorization_callback" | "token_exchange" | "credential_verification";
+    verificationStage?: "credential_binding" | "mcp_initialize" | "tool_discovery" | "account_verification" | "capability_verification";
+    reason?: "binding_mismatch" | "cancelled" | "network_error" | "http_error" | "protocol_error" | "tool_unavailable" | "invalid_pagination" | "response_too_large" | "account_tool_error" | "account_identity_unavailable" | "no_read_capabilities";
+    httpStatus?: number;
 }

package/dist/operation-types.d.ts

@@ -0,0 +1,103 @@
+/** Portable, reviewed operation contracts. These definitions never contain credentials or code. */
+export interface LinkValueSchema {
+    readonly type?: "object" | "array" | "string" | "number" | "integer" | "boolean" | "null";
+    readonly properties?: Readonly<Record<string, LinkValueSchema>>;
+    readonly required?: readonly string[];
+    readonly additionalProperties?: boolean;
+    readonly items?: LinkValueSchema;
+    readonly minLength?: number;
+    readonly maxLength?: number;
+    readonly minimum?: number;
+    readonly maximum?: number;
+    readonly minItems?: number;
+    readonly maxItems?: number;
+    readonly enum?: readonly (string | number | boolean | null)[];
+    /** Only reviewed, bounded patterns from the built-in catalog are accepted. */
+    readonly pattern?: string;
+    readonly anyOf?: readonly LinkValueSchema[];
+    readonly oneOf?: readonly LinkValueSchema[];
+}
+export interface LinkResourcePolicy {
+    /** Always declared, including list operations whose results need grant filtering. */
+    readonly source: "input" | "grant-filtered" | "account";
+    readonly group: string;
+    /** A selected-resource listing must remove every item without a provable authorized identity. */
+    readonly resultFilter?: {
+        readonly collection: string;
+        readonly identityPath: readonly string[];
+        readonly lowercase?: boolean;
+        readonly stripHyphens?: boolean;
+    };
+    readonly selector?: {
+        readonly fields: readonly string[];
+        readonly kind: "joined" | "identifier-or-url" | "slack-permalink";
+        readonly separator?: string;
+        readonly lowercase?: boolean;
+        readonly stripHyphens?: boolean;
+        readonly urlHosts?: readonly string[];
+        readonly urlPathIndex?: number;
+    };
+}
+export interface LinkOperationContract {
+    readonly operationId: string;
+    readonly providerId: string;
+    /** Unqualified v1 wire name: lower-case letters and underscores only. */
+    readonly action: string;
+    readonly effect: "read" | "write";
+    readonly executors: readonly ("api" | "mcp" | "cli")[];
+    readonly inputSchema: LinkValueSchema;
+    readonly outputSchema: LinkValueSchema;
+    readonly resourcePolicy: LinkResourcePolicy;
+    readonly content?: {
+        readonly kind: string;
+        readonly coverage: "summary" | "requested-subtree" | "selected-resource" | "page";
+    };
+    readonly defaults: Readonly<Record<string, string | number | boolean>>;
+    readonly limits: {
+        readonly inputBytes: number;
+        readonly responseBytes: number;
+        readonly inputDepth: number;
+        readonly responseDepth: number;
+    };
+    readonly repeatability: "read-only" | "verified-write-once";
+    /** Existing adapters perform these canonicalizations after structural validation. */
+    readonly normalization: readonly string[];
+}
+export type LinkRecipeId = "api-token" | "api-oauth" | "cli-session" | "broker-oauth" | "mcp-oauth";
+export interface LinkConnectionRecipe {
+    readonly id: LinkRecipeId;
+    readonly auth: "static-secret" | "oauth2" | "external-session";
+    readonly executor: "api" | "mcp" | "cli";
+    readonly route: "direct" | "brokered";
+    readonly credentialOwner: "current-host" | "broker" | "external-session-owner";
+    readonly executorOwner: "current-host" | "broker";
+}
+export interface LinkOperationRequest {
+    readonly connectionId: string;
+    readonly providerId: string;
+    readonly action: string;
+    readonly params: Readonly<Record<string, unknown>>;
+}
+export interface LinkOperationAuthorization {
+    readonly connectionId: string;
+    readonly providerId: string;
+    readonly accountId: string;
+    readonly recipeId: LinkRecipeId;
+    readonly authorityRevision: string;
+    readonly capabilityIds: readonly string[];
+    readonly resources: {
+        readonly kind: "upstream-scoped";
+    } | {
+        readonly kind: "selected-resources";
+        readonly groups: readonly {
+            readonly id: string;
+            readonly items: readonly {
+                readonly id: string;
+            }[];
+        }[];
+    };
+}
+export declare class LinkOperationError extends Error {
+    readonly code: "invalid_input" | "invalid_result" | "unsupported_contract" | "permission_denied" | "resource_not_granted" | "contract_changed";
+    constructor(code: "invalid_input" | "invalid_result" | "unsupported_contract" | "permission_denied" | "resource_not_granted" | "contract_changed", message: string);
+}

package/dist/operation-types.js

@@ -0,0 +1,8 @@
+export class LinkOperationError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "LinkOperationError";
+    }
+}

package/dist/operation-validation.d.ts

@@ -0,0 +1,9 @@
+import { type LinkValueSchema, type LinkOperationAuthorization, type LinkOperationContract } from "./operation-types.js";
+export declare function validateLinkOperationValue(schema: LinkValueSchema, value: unknown): boolean;
+export declare function validateLinkOperationInput(contract: LinkOperationContract, input: unknown): asserts input is Record<string, unknown>;
+export declare function snapshotLinkOperationInput(contract: LinkOperationContract, input: unknown): Record<string, unknown>;
+export declare function assertLinkOperationResult(contract: LinkOperationContract, result: unknown): void;
+/** Applies equally to direct API, CLI, MCP and broker adapters. Missing identity fails closed. */
+export declare function filterLinkOperationResult(contract: LinkOperationContract, result: unknown, authorization: LinkOperationAuthorization): unknown;
+/** Content traits never decide whether an operation needs authorization. */
+export declare function assertLinkOperationAuthorized(contract: LinkOperationContract, params: Record<string, unknown>, authorization: LinkOperationAuthorization): void;

package/dist/operation-validation.js

@@ -0,0 +1,216 @@
+import { LinkOperationError, } from "./operation-types.js";
+import { getLinkConnectionRecipe } from "./recipes.js";
+/** Copy JSON data without invoking getters, toJSON, inherited code or mutable caller objects. */
+function snapshotJson(value, ancestors, depth, maxDepth, forbidKeys) {
+    if (depth > maxDepth)
+        throw new Error("JSON nesting limit");
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return value;
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (!value || typeof value !== "object" || ancestors.has(value))
+        throw new Error("Invalid JSON data");
+    const prototype = Object.getPrototypeOf(value);
+    if ((!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) ||
+        Object.getOwnPropertySymbols(value).length)
+        throw new Error("Invalid JSON object");
+    ancestors.add(value);
+    try {
+        const descriptors = Object.getOwnPropertyDescriptors(value);
+        if (Array.isArray(value)) {
+            if (value.length > 100_000)
+                throw new Error("JSON array limit");
+            return Array.from({ length: value.length }, (_, index) => {
+                const descriptor = descriptors[String(index)];
+                if (descriptor && !Object.hasOwn(descriptor, "value"))
+                    throw new Error("JSON accessor");
+                return descriptor?.value === undefined
+                    ? null
+                    : snapshotJson(descriptor.value, ancestors, depth + 1, maxDepth, forbidKeys);
+            });
+        }
+        const result = Object.create(null);
+        for (const [key, descriptor] of Object.entries(descriptors)) {
+            if (!descriptor.enumerable)
+                continue;
+            if (!Object.hasOwn(descriptor, "value") ||
+                (forbidKeys && ["__proto__", "constructor", "prototype"].includes(key)))
+                throw new Error("Invalid JSON property");
+            if (descriptor.value !== undefined)
+                result[key] = snapshotJson(descriptor.value, ancestors, depth + 1, maxDepth, forbidKeys);
+        }
+        return result;
+    }
+    finally {
+        ancestors.delete(value);
+    }
+}
+function matches(schema, value, depth = 0) {
+    if (depth > 20)
+        return false;
+    if (schema.enum && !schema.enum.includes(value))
+        return false;
+    if (schema.anyOf && !schema.anyOf.some((item) => matches(item, value, depth + 1)))
+        return false;
+    if (schema.oneOf && schema.oneOf.filter((item) => matches(item, value, depth + 1)).length !== 1)
+        return false;
+    if (schema.type === "null")
+        return value === null;
+    if (schema.type === "boolean")
+        return typeof value === "boolean";
+    if (schema.type === "string")
+        return (typeof value === "string" &&
+            value.length >= (schema.minLength ?? 0) &&
+            value.length <= (schema.maxLength ?? Infinity) &&
+            (!schema.pattern || new RegExp(schema.pattern).test(value)));
+    if (schema.type === "number" || schema.type === "integer")
+        return (typeof value === "number" &&
+            Number.isFinite(value) &&
+            (schema.type !== "integer" || Number.isSafeInteger(value)) &&
+            value >= (schema.minimum ?? -Infinity) &&
+            value <= (schema.maximum ?? Infinity));
+    if (schema.type === "array")
+        return (Array.isArray(value) &&
+            value.length >= (schema.minItems ?? 0) &&
+            value.length <= (schema.maxItems ?? Infinity) &&
+            (!schema.items || value.every((item) => matches(schema.items, item, depth + 1))));
+    if (schema.type === "object" || schema.required || schema.properties) {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            return false;
+        const record = value;
+        if (schema.required?.some((key) => !Object.hasOwn(record, key)))
+            return false;
+        return Object.entries(record).every(([key, item]) => {
+            if (["__proto__", "prototype", "constructor"].includes(key))
+                return false;
+            const property = schema.properties && Object.hasOwn(schema.properties, key)
+                ? schema.properties[key]
+                : undefined;
+            return property ? matches(property, item, depth + 1) : schema.additionalProperties !== false;
+        });
+    }
+    return true;
+}
+export function validateLinkOperationValue(schema, value) {
+    return matches(schema, value);
+}
+export function validateLinkOperationInput(contract, input) {
+    snapshotLinkOperationInput(contract, input);
+}
+export function snapshotLinkOperationInput(contract, input) {
+    let detached;
+    let size = Infinity;
+    try {
+        detached = snapshotJson(input, new Set(), 0, contract.limits.inputDepth, true);
+        size = new TextEncoder().encode(JSON.stringify(detached)).length;
+    }
+    catch {
+        /* Reject cyclic/non-JSON inputs. */
+    }
+    if (size > contract.limits.inputBytes || !matches(contract.inputSchema, detached))
+        throw new LinkOperationError("invalid_input", `Invalid parameters for ${contract.operationId}.`);
+    return detached;
+}
+export function assertLinkOperationResult(contract, result) {
+    let detached;
+    let size = Infinity;
+    try {
+        detached = snapshotJson(result, new Set(), 0, contract.limits.responseDepth, false);
+        size = new TextEncoder().encode(JSON.stringify(detached)).length;
+    }
+    catch {
+        /* Fail closed. */
+    }
+    if (size > contract.limits.responseBytes || !matches(contract.outputSchema, detached))
+        throw new LinkOperationError("invalid_result", `Invalid result for ${contract.operationId}.`);
+}
+/** Applies equally to direct API, CLI, MCP and broker adapters. Missing identity fails closed. */
+export function filterLinkOperationResult(contract, result, authorization) {
+    if (authorization.resources.kind === "upstream-scoped" ||
+        contract.resourcePolicy.source !== "grant-filtered")
+        return result;
+    const filter = contract.resourcePolicy.resultFilter;
+    const group = authorization.resources.groups.find((item) => item.id === contract.resourcePolicy.group);
+    if (!filter || !group || !result || typeof result !== "object" || Array.isArray(result))
+        throw new LinkOperationError("invalid_result", "The operation cannot prove its result resource scope.");
+    const values = result[filter.collection];
+    if (!Array.isArray(values))
+        throw new LinkOperationError("invalid_result", "The operation returned an invalid resource listing.");
+    const normalize = (value) => {
+        const normalized = filter.stripHyphens ? value.replaceAll("-", "") : value;
+        return filter.lowercase ? normalized.toLowerCase() : normalized;
+    };
+    const allowed = new Set(group.items.map((item) => normalize(item.id)));
+    return {
+        ...result,
+        [filter.collection]: values.filter((item) => {
+            let value = item;
+            for (const key of filter.identityPath)
+                value =
+                    value && typeof value === "object" ? value[key] : undefined;
+            return ((typeof value === "string" || typeof value === "number") &&
+                allowed.has(normalize(String(value))));
+        }),
+    };
+}
+/** Content traits never decide whether an operation needs authorization. */
+export function assertLinkOperationAuthorized(contract, params, authorization) {
+    const recipe = getLinkConnectionRecipe(authorization.recipeId);
+    if (!recipe ||
+        authorization.providerId !== contract.providerId ||
+        !authorization.connectionId ||
+        !authorization.accountId ||
+        !authorization.authorityRevision ||
+        !contract.executors.includes(recipe.executor) ||
+        !authorization.capabilityIds.includes(contract.operationId))
+        throw new LinkOperationError("permission_denied", "The selected connection does not authorize this operation.");
+    if (contract.effect === "write" && recipe.executor === "cli")
+        throw new LinkOperationError("permission_denied", "CLI connections do not support verified writes.");
+    if (authorization.resources.kind === "upstream-scoped") {
+        if (recipe.route === "brokered")
+            throw new LinkOperationError("permission_denied", "Broker operations require an explicit resource grant.");
+        return;
+    }
+    const group = authorization.resources.groups.find((item) => item.id === contract.resourcePolicy.group);
+    if (!group)
+        throw new LinkOperationError("resource_not_granted", "The selected resource group is not authorized.");
+    if (contract.resourcePolicy.source !== "input")
+        return; // The executor must filter listing results to this group.
+    const selector = contract.resourcePolicy.selector;
+    if (!selector)
+        throw new LinkOperationError("resource_not_granted", "The operation has no reviewed resource selector.");
+    let selected;
+    if (selector.kind === "joined") {
+        const parts = selector.fields.map((field) => params[field]);
+        if (parts.some((part) => typeof part !== "string" || !part))
+            throw new LinkOperationError("invalid_input", "An explicit resource target is required.");
+        selected = parts.join(selector.separator ?? "/");
+    }
+    else {
+        const value = selector.fields.map((field) => params[field]).find((item) => item !== undefined);
+        if (typeof value !== "string" || !value)
+            throw new LinkOperationError("invalid_input", "An explicit resource target is required.");
+        selected = value;
+        if (selector.kind === "slack-permalink" || /^https?:\/\//i.test(value)) {
+            let url;
+            try {
+                url = new URL(value);
+            }
+            catch {
+                throw new LinkOperationError("invalid_input", "Invalid resource URL.");
+            }
+            const allowedHost = selector.kind === "slack-permalink"
+                ? /^[a-z0-9-]+\.slack\.com$/.test(url.hostname)
+                : selector.urlHosts?.includes(url.hostname);
+            if (url.protocol !== "https:" || url.username || url.password || url.port || !allowedHost)
+                throw new LinkOperationError("invalid_input", "Invalid resource URL.");
+            selected = url.pathname.split("/").filter(Boolean)[selector.urlPathIndex ?? 1] ?? "";
+        }
+    }
+    const normalize = (value) => {
+        const normalized = selector.stripHyphens ? value.replaceAll("-", "") : value;
+        return selector.lowercase ? normalized.toLowerCase() : normalized;
+    };
+    if (!group.items.some((item) => normalize(item.id) === normalize(selected)))
+        throw new LinkOperationError("resource_not_granted", "The resource is outside this connection's grant.");
+}

package/dist/operations.d.ts

@@ -0,0 +1,4 @@
+import type { LinkOperationContract } from "./operation-types.js";
+/** Reviewed v1 contracts. Discovery can select these operations, never add executable code. */
+export declare const LINK_OPERATION_CONTRACTS: readonly LinkOperationContract[];
+export declare function getLinkOperationContract(provider: string, action: string): LinkOperationContract | undefined;

package/dist/operations.js

@@ -0,0 +1,312 @@
+import { FIGMA_MCP_ACTION_IDS } from "./figma.js";
+const text = (maxLength = 300, minLength = 1) => ({
+    type: "string",
+    minLength,
+    maxLength,
+});
+const flag = { type: "boolean" };
+// Existing v1 adapters accept numeric strings and clamp pagination. Keep that behavior.
+const integer = { anyOf: [{ type: "integer", minimum: 1 }, text(100)] };
+const number = { anyOf: [{ type: "number" }, text(100)] };
+const list = (items = { type: "object" }, maxItems = 100) => ({
+    type: "array",
+    items,
+    maxItems,
+});
+const object = (properties, required = []) => ({ type: "object", properties, required, additionalProperties: false });
+const output = (properties, required = []) => ({ type: "object", properties, required, additionalProperties: true });
+const listOutput = (key, max = 100) => output({ [key]: list({ type: "object" }, max) }, [key]);
+const groups = {
+    github: "repositories",
+    gitlab: "projects",
+    figma: "files",
+    notion: "pages",
+    linear: "teams",
+    slack: "channels",
+    sentry: "organizations",
+    airtable: "bases",
+    todoist: "projects",
+    vercel: "projects",
+};
+const inputResource = (group, fields, options = {}) => ({
+    source: "input",
+    group,
+    selector: { kind: "joined", fields, ...options },
+});
+const filtered = (provider, action) => {
+    const collection = provider === "notion" ? "results" : action.replace(/^list_/, "");
+    const identityPath = provider === "github"
+        ? ["full_name"]
+        : provider === "sentry"
+            ? ["slug"]
+            : provider === "gitlab" && action === "list_issues"
+                ? ["project_id"]
+                : provider === "todoist" && action === "list_tasks"
+                    ? ["project_id"]
+                    : provider === "linear" && action === "list_issues"
+                        ? ["team", "id"]
+                        : provider === "vercel" && action === "list_deployments"
+                            ? ["projectId"]
+                            : ["id"];
+    return {
+        source: "grant-filtered",
+        group: groups[provider],
+        resultFilter: {
+            collection,
+            identityPath,
+            ...(provider === "github" || provider === "notion" || provider === "linear"
+                ? { lowercase: true }
+                : {}),
+            ...(provider === "notion" ? { stripHyphens: true } : {}),
+        },
+    };
+};
+const repo = { owner: text(100), repo: text(100) };
+const file = { file_url_or_key: text(4096), file_key: text(200) };
+const fileInput = (properties = {}, required = []) => ({
+    ...object({ ...file, ...properties }, required),
+    oneOf: [{ required: ["file_url_or_key"] }, { required: ["file_key"] }],
+});
+const fileResource = inputResource("files", ["file_url_or_key", "file_key"], {
+    kind: "identifier-or-url",
+    urlHosts: ["figma.com", "www.figma.com"],
+    urlPathIndex: 1,
+});
+const nodeList = { anyOf: [text(20_000), list(text(200), 50)] };
+function operation(provider, action, inputSchema, outputSchema, resourcePolicy = filtered(provider, action), options = {}) {
+    const effect = options.effect ?? "read";
+    return {
+        operationId: `${provider}.${action}`,
+        providerId: provider,
+        action,
+        effect,
+        executors: options.executors ??
+            (["github", "gitlab", "notion", "todoist", "vercel"].includes(provider)
+                ? ["api", "cli"]
+                : ["api"]),
+        inputSchema,
+        outputSchema,
+        resourcePolicy,
+        defaults: options.defaults ?? {},
+        limits: {
+            inputBytes: action === "create_issue" ? 256 * 1024 : 65_536,
+            responseBytes: provider === "figma" ? 8 * 1024 * 1024 : 1024 * 1024,
+            inputDepth: 20,
+            responseDepth: 256,
+        },
+        repeatability: effect === "write" ? "verified-write-once" : "read-only",
+        normalization: options.normalization ?? [],
+        ...(options.content ? { content: options.content } : {}),
+    };
+}
+const gh = (action, properties = {}, required = [], result = output({}), options = {}) => operation("github", action, object({ ...repo, ...properties }, ["owner", "repo", ...required]), result, inputResource("repositories", ["owner", "repo"], { lowercase: true }), options);
+const pagination = {
+    defaults: { limit: 30 },
+    normalization: ["limit: positive number or numeric string; clamp to 100"],
+};
+const sourcePagination = {
+    defaults: { page: 1, limit: 30 },
+    normalization: [
+        "page: positive number or numeric string; clamp to 100",
+        "limit: positive integer <= 100",
+        "sha: full hexadecimal commit id",
+    ],
+};
+const content = { kind: "application/json", coverage: "selected-resource" };
+/** Reviewed v1 contracts. Discovery can select these operations, never add executable code. */
+export const LINK_OPERATION_CONTRACTS = [
+    operation("github", "list_repositories", object({ limit: integer }), listOutput("repositories"), undefined, pagination),
+    gh("get_repository", {}, [], output({ id: {}, full_name: text(), private: flag, archived: flag, html_url: text(4096) })),
+    gh("get_starred", {}, [], output({ starred: flag }, ["starred"])),
+    gh("set_starred", { starred: flag }, ["starred"], output({ acknowledged: flag }, ["acknowledged"]), { effect: "write", executors: ["api"] }),
+    gh("get_readme", {}, [], output({ content: text(262_144, 0), truncated: flag }, ["content", "truncated"]), { content: { kind: "text/markdown", coverage: "selected-resource" } }),
+    gh("get_file", { path: text(2000), ref: text(300) }, ["path"], output({ content: text(262_144, 0), truncated: flag }, ["content", "truncated"]), { content: { kind: "text/plain", coverage: "selected-resource" } }),
+    gh("list_issues", { limit: integer, page: integer, state: { enum: ["open", "closed", "all"] } }, [], listOutput("issues"), pagination),
+    gh("list_pull_requests", { limit: integer, page: integer }, [], listOutput("pull_requests"), pagination),
+    gh("get_issue", { issue_number: integer }, ["issue_number"]),
+    gh("get_pull_request", { pull_number: integer }, ["pull_number"]),
+    gh("list_pull_request_files", { pull_number: integer, page: integer, limit: integer }, ["pull_number"], output({ files: list() }), sourcePagination),
+    gh("list_pull_request_commits", { pull_number: integer, page: integer, limit: integer }, ["pull_number"], output({ commits: list() }), sourcePagination),
+    gh("get_commit", { sha: text(40), page: integer, limit: integer }, ["sha"], output({}), sourcePagination),
+    gh("create_issue", { title: text(256), body: text(20_000, 0) }, ["title"], output({
+        number: { type: "integer" },
+        title: text(256),
+        state: text(100),
+        html_url: text(4096),
+        created_at: text(100),
+    }), {
+        effect: "write",
+        executors: ["api"],
+        normalization: [
+            "trim title and body; owner/repo identify the authorized parent repository",
+            "requires independent list_issues/get_issue verification",
+        ],
+    }),
+    gh("update_issue", { issue_number: { type: "integer", minimum: 1 }, state: { enum: ["open", "closed"] } }, ["issue_number", "state"], output({ acknowledged: flag }, ["acknowledged"]), {
+        effect: "write",
+        executors: ["api"],
+        normalization: ["non-PR issue only; verify immutable repository and issue IDs independently"],
+    }),
+    operation("gitlab", "list_projects", object({ limit: integer }), listOutput("projects"), undefined, pagination),
+    operation("gitlab", "list_issues", object({ limit: integer }), listOutput("issues"), undefined, pagination),
+    operation("figma", "get_file", fileInput(), output({ pages: list({}, 100), truncated: flag }, ["pages", "truncated"]), fileResource, {
+        defaults: { depth: 1 },
+        content: { kind: "application/vnd.figma.summary+json", coverage: "summary" },
+        normalization: [
+            "summary only; no document; at most 100 pages; reject all depth/full/ids parameters",
+        ],
+    }),
+    operation("figma", "read_design_content", fileInput({
+        ids: nodeList,
+        node_ids: nodeList,
+        version: text(200),
+        depth: integer,
+        geometry: { enum: ["paths"] },
+        plugin_data: nodeList,
+        branch_data: flag,
+        full: flag,
+    }), output({
+        document: { type: "object" },
+        pages: { type: "array", items: { type: "object" } },
+        truncated: flag,
+    }, ["document"]), fileResource, {
+        defaults: { depth: 2, full: false },
+        content: { kind: "application/vnd.figma.document+json", coverage: "requested-subtree" },
+        normalization: [
+            "reject conflicting file aliases, ids aliases and full/depth",
+            "node-id in URL is an input selector; depth 1..100; full:true must be explicit",
+            "preserve nested node properties; no implicit complete-file read",
+        ],
+    }),
+    operation("figma", "get_nodes", fileInput({
+        ids: nodeList,
+        node_ids: nodeList,
+        version: text(200),
+        depth: integer,
+        geometry: { enum: ["paths"] },
+        plugin_data: nodeList,
+    }), {
+        ...output({ nodes: { type: "object" }, truncated: flag }),
+        anyOf: [{ required: ["nodes"] }, { required: ["err"] }],
+    }, fileResource, {
+        content,
+        normalization: [
+            "require explicit ids or URL node-id; 1..50 node IDs; reject conflicting aliases; depth 1..100",
+        ],
+    }),
+    operation("figma", "get_images", fileInput({
+        ids: nodeList,
+        node_ids: nodeList,
+        version: text(200),
+        scale: number,
+        format: { enum: ["png", "jpg", "svg", "pdf"] },
+        svg_outline_text: flag,
+        svg_include_id: flag,
+        svg_include_node_id: flag,
+        svg_simplify_stroke: flag,
+        contents_only: flag,
+        use_absolute_bounds: flag,
+    }), {
+        ...output({ images: { type: "object" } }),
+        anyOf: [{ required: ["images"] }, { required: ["err"] }],
+    }, fileResource, {
+        normalization: [
+            "require explicit ids or URL node-id; scale 0.01..4; reject conflicting aliases",
+        ],
+    }),
+    operation("figma", "get_image_fills", fileInput(), {
+        ...output({
+            meta: { type: "object", properties: { images: { type: "object" } }, required: ["images"] },
+        }),
+        anyOf: [{ required: ["meta"] }, { required: ["err"] }],
+    }, fileResource),
+    operation("figma", "get_comments", fileInput(), output({ comments: { type: "array", items: { type: "object" } } }), fileResource),
+    ...FIGMA_MCP_ACTION_IDS.map((action) => operation("figma", action, fileInput({
+        file_type: { enum: ["design", "figjam", "make", "slides"] },
+        node_id: text(200),
+        client_languages: text(200, 0),
+        client_frameworks: text(200, 0),
+        force_code: flag,
+        disable_code_connect: flag,
+        recursive: flag,
+        queries: list(text(1000), 20),
+        ...(action === "read_resource" ? { uri: text(4096) } : {}),
+        ...(action === "list_resources" ? { cursor: text(4096, 0) } : {}),
+    }, action === "read_resource" ? ["uri"] : []), output({}), fileResource, {
+        executors: ["mcp"],
+        content: {
+            kind: "application/vnd.figma.mcp+json",
+            coverage: action === "list_resources" ? "page" : "requested-subtree",
+        },
+        normalization: [
+            "official MCP origin and issuer/resource binding; exact reviewed tool allowlist",
+            "detailed reads require node_id; Make uses discovery then selected file URI",
+            "resource URI must belong to selected file and be admitted on this connection",
+        ],
+    })),
+    operation("notion", "search", object({ query: text(200, 0), limit: integer }), listOutput("results"), undefined, pagination),
+    operation("notion", "get_page", object({ page_id: text(100) }, ["page_id"]), output({}), inputResource("pages", ["page_id"], { lowercase: true, stripHyphens: true })),
+    operation("linear", "list_issues", object({ limit: integer }), listOutput("issues", 50), undefined, {
+        defaults: { limit: 30 },
+        normalization: ["limit: positive number or numeric string; clamp to 50"],
+    }),
+    operation("linear", "list_teams", object({ limit: integer }), listOutput("teams", 50)),
+    operation("slack", "list_channels", object({ limit: integer }), listOutput("channels", 200), undefined, {
+        defaults: { limit: 50 },
+        normalization: ["limit: positive number or numeric string; clamp to 200"],
+    }),
+    operation("slack", "get_channel_history", object({ channel: text(100), limit: integer }, ["channel"]), listOutput("messages"), inputResource("channels", ["channel"]), {
+        defaults: { limit: 15 },
+        normalization: ["limit: positive number or numeric string; clamp to 15"],
+    }),
+    operation("slack", "get_message", object({ permalink: text(4096) }, ["permalink"]), output({}), inputResource("channels", ["permalink"], { kind: "slack-permalink", urlPathIndex: 1 }), {
+        normalization: [
+            "parse channel and timestamp from HTTPS Slack permalink; reply URL requires thread_ts",
+            "URL supplies identifiers only; never controls API origin",
+        ],
+    }),
+    operation("slack", "get_thread", object({
+        channel: text(100),
+        ts: text(100),
+        permalink: text(4096),
+        cursor: text(4096, 0),
+        limit: integer,
+    }, ["channel", "ts"]), output({}), inputResource("channels", ["channel"]), {
+        defaults: { limit: 15 },
+        normalization: ["one thread page; maximum limit 15; reject permalink conflicts"],
+    }),
+    operation("sentry", "list_organizations", object({}), listOutput("organizations")),
+    operation("sentry", "list_projects", object({ organization: text(100) }, ["organization"]), listOutput("projects"), inputResource("organizations", ["organization"])),
+    operation("airtable", "list_bases", object({}), listOutput("bases")),
+    operation("airtable", "list_tables", object({ base_id: text(100) }, ["base_id"]), listOutput("tables"), inputResource("bases", ["base_id"])),
+    operation("todoist", "list_projects", object({ limit: integer }), listOutput("projects")),
+    operation("todoist", "list_tasks", object({ limit: integer }), listOutput("tasks"), undefined, {
+        defaults: { limit: 50 },
+        normalization: ["limit: positive number or numeric string; clamp to 100"],
+    }),
+    operation("vercel", "list_projects", object({ team_id: text(100), limit: integer }), listOutput("projects"), undefined, {
+        defaults: { limit: 50 },
+        normalization: [
+            "limit: positive number or numeric string; clamp to 100",
+            "broker checks team_id against installation",
+        ],
+    }),
+    operation("vercel", "list_deployments", object({ team_id: text(100), limit: integer }), listOutput("deployments"), undefined, {
+        defaults: { limit: 50 },
+        normalization: [
+            "limit: positive number or numeric string; clamp to 100",
+            "broker checks team_id against installation; filter deployments by granted project",
+        ],
+    }),
+];
+function freezeContract(value) {
+    if (!value || typeof value !== "object" || Object.isFrozen(value))
+        return;
+    Object.values(value).forEach(freezeContract);
+    Object.freeze(value);
+}
+freezeContract(LINK_OPERATION_CONTRACTS);
+const contracts = new Map(LINK_OPERATION_CONTRACTS.map((contract) => [contract.operationId, contract]));
+export function getLinkOperationContract(provider, action) {
+    return contracts.get(`${provider}.${action}`);
+}

package/dist/recipes.d.ts

@@ -0,0 +1,20 @@
+import type { LinkConnectionRecipe, LinkRecipeId } from "./operation-types.js";
+export declare const LINK_CONNECTION_RECIPES: Readonly<Record<LinkRecipeId, LinkConnectionRecipe>>;
+export declare function getLinkConnectionRecipe(id: string): LinkConnectionRecipe | undefined;
+/** Compatibility at the host boundary; new records identify a reviewed recipe. */
+export declare function resolveLinkRecipeId(metadata: {
+    recordSchemaVersion?: number;
+    linkRecipeId?: string;
+    linkExecutionBackend?: string;
+    linkAuthSource?: string;
+}): LinkRecipeId | undefined;
+interface LinkRoutingMetadata {
+    recordSchemaVersion?: number;
+    linkRecipeId?: string;
+    linkExecutionBackend?: "http-token" | "cli" | "remote" | "mcp";
+    linkExecutionRuntime?: "local" | "server";
+    linkAuthSource?: "manual-token" | "github-cli" | "cli-session" | "browser-oauth" | "mcp-oauth";
+}
+/** Read-only compatibility projection. Persist the recipe, never these derived axes. */
+export declare function linkConnectionMetadata<T extends LinkRoutingMetadata>(metadata: T | undefined): Omit<T, "linkExecutionBackend" | "linkExecutionRuntime" | "linkAuthSource"> & LinkRoutingMetadata;
+export {};

package/dist/recipes.js

@@ -0,0 +1,106 @@
+export const LINK_CONNECTION_RECIPES = Object.freeze({
+    "api-token": Object.freeze({
+        id: "api-token",
+        auth: "static-secret",
+        executor: "api",
+        route: "direct",
+        credentialOwner: "current-host",
+        executorOwner: "current-host",
+    }),
+    "api-oauth": Object.freeze({
+        id: "api-oauth",
+        auth: "oauth2",
+        executor: "api",
+        route: "direct",
+        credentialOwner: "current-host",
+        executorOwner: "current-host",
+    }),
+    "cli-session": Object.freeze({
+        id: "cli-session",
+        auth: "external-session",
+        executor: "cli",
+        route: "direct",
+        credentialOwner: "external-session-owner",
+        executorOwner: "current-host",
+    }),
+    "broker-oauth": Object.freeze({
+        id: "broker-oauth",
+        auth: "oauth2",
+        executor: "api",
+        route: "brokered",
+        credentialOwner: "broker",
+        executorOwner: "broker",
+    }),
+    "mcp-oauth": Object.freeze({
+        id: "mcp-oauth",
+        auth: "oauth2",
+        executor: "mcp",
+        route: "direct",
+        credentialOwner: "current-host",
+        executorOwner: "current-host",
+    }),
+});
+export function getLinkConnectionRecipe(id) {
+    return Object.hasOwn(LINK_CONNECTION_RECIPES, id)
+        ? LINK_CONNECTION_RECIPES[id]
+        : undefined;
+}
+/** Compatibility at the host boundary; new records identify a reviewed recipe. */
+export function resolveLinkRecipeId(metadata) {
+    if (metadata.recordSchemaVersion !== undefined && metadata.recordSchemaVersion !== 2)
+        return undefined;
+    if (metadata.linkRecipeId)
+        return getLinkConnectionRecipe(metadata.linkRecipeId)?.id;
+    if (metadata.recordSchemaVersion === 2)
+        return undefined;
+    if (metadata.linkExecutionBackend === "remote")
+        return "broker-oauth";
+    if (metadata.linkExecutionBackend === "mcp")
+        return "mcp-oauth";
+    if (metadata.linkExecutionBackend === "cli")
+        return "cli-session";
+    if (metadata.linkAuthSource === "github-cli" || metadata.linkAuthSource === "cli-session")
+        return "cli-session";
+    if (metadata.linkAuthSource === "browser-oauth")
+        return "api-oauth";
+    if (metadata.linkExecutionBackend === "http-token")
+        return "api-token";
+    return undefined;
+}
+/** Read-only compatibility projection. Persist the recipe, never these derived axes. */
+export function linkConnectionMetadata(metadata) {
+    const value = metadata ?? {};
+    if (!value.linkRecipeId && value.recordSchemaVersion === undefined) {
+        return value.linkAuthSource === "github-cli"
+            ? { ...value, linkAuthSource: "cli-session" }
+            : { ...value };
+    }
+    const recipeId = resolveLinkRecipeId(value);
+    const recipe = recipeId && getLinkConnectionRecipe(recipeId);
+    return {
+        ...value,
+        linkExecutionBackend: !recipe
+            ? undefined
+            : recipe.route === "brokered"
+                ? "remote"
+                : recipe.executor === "cli"
+                    ? "cli"
+                    : recipe.executor === "mcp"
+                        ? "mcp"
+                        : "http-token",
+        linkExecutionRuntime: !recipe
+            ? undefined
+            : recipe.executorOwner === "broker"
+                ? "server"
+                : "local",
+        linkAuthSource: recipeId === "api-token"
+            ? "manual-token"
+            : recipeId === "api-oauth"
+                ? "browser-oauth"
+                : recipeId === "cli-session"
+                    ? "cli-session"
+                    : recipeId === "mcp-oauth"
+                        ? "mcp-oauth"
+                        : undefined,
+    };
+}

package/dist/types.d.ts

@@ -85,7 +85,7 @@ export interface LinkProviderManifest {
     /** Reviewed exact-file reads; absence means this provider cannot supply file content. */
     fileSelection?: {
         kind: "github-file" | "figma-file";
-        action: "get_file";
+        action: "get_file" | "read_design_content";
         resourceGroup: "repositories" | "files";
     };
     fileSelectionLimitation?: "document-content-unavailable";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell-link",
-  "version": "0.9.44",
+  "version": "0.9.47",
   "description": "Framework-independent provider manifests and authorization guides for CodeShell Link.",
   "type": "module",
   "main": "./dist/index.js",