@crewx/sdk 0.9.0-rc.16 → 0.9.0-rc.161

package/dist/mcp-app/app-schedule.d.ts

@@ -0,0 +1,85 @@
+import { type SkillBackendExecutionRequest, type SkillBackendPayloadV1 } from './skill-backend.js';
+import { type AppScheduleIntervalMinutes, type AppSchedulePeriodicReason, type AppScheduleRunVerdict, type AppScheduleSnapshot } from '../app/schedule-contract.js';
+import type { UiDefinitionInput } from '../ui-instance/types.js';
+import type { WorkspaceAppSource } from './discovery.js';
+export { decideScheduleDirective } from '../app/schedule-contract.js';
+export type { AppScheduleActorKind, ScheduleDirectiveDecision } from '../app/schedule-contract.js';
+export type AppScheduleOwnerSource = WorkspaceAppSource | 'bundled';
+export interface AppScheduleOwner {
+    readonly appId: string;
+    readonly actionId: string;
+    readonly source: AppScheduleOwnerSource;
+}
+export interface AppScheduleBinding extends AppScheduleOwner {
+    readonly enabled: boolean;
+}
+export interface ResolvedAppSchedule {
+    readonly actionId: string;
+    readonly everyMinutes: AppScheduleIntervalMinutes;
+    readonly timeoutMs: number;
+}
+export interface AppScheduleTemplate {
+    readonly cron: string;
+    readonly timeout_ms: number;
+    readonly name: string | null;
+}
+export interface AppScheduleRowView extends AppScheduleTemplate {
+    readonly id: string;
+    readonly app: AppScheduleBinding;
+    readonly last_started_at?: string;
+    readonly last_run?: string;
+    readonly last_outcome?: string;
+    readonly last_error_code?: string;
+    readonly next_run?: string | null;
+}
+export type AppScheduleAvailability = {
+    readonly periodic: 'available';
+} | {
+    readonly periodic: 'unavailable';
+    readonly reason: AppSchedulePeriodicReason;
+};
+export type ScheduleLifecycleEntry = {
+    readonly kind: 'absent';
+} | {
+    readonly kind: 'invalid';
+} | {
+    readonly kind: 'verified';
+    readonly source: AppScheduleOwnerSource;
+    readonly declaration: ResolvedAppSchedule | undefined;
+    readonly name: string | null;
+};
+export type AppScheduledRunPayload = SkillBackendPayloadV1 & {
+    readonly schedule: AppScheduleSnapshot;
+};
+export interface AppScheduledRunPlan {
+    readonly actorKind: 'schedule';
+    readonly instanceId: string;
+    readonly threadId: null;
+    readonly actionId: string;
+    readonly payload: AppScheduledRunPayload;
+}
+export type ScheduledAppLaunchRequest = AppScheduledRunPlan & Pick<SkillBackendExecutionRequest, 'appId' | 'definitionId' | 'definitionVersion' | 'definitionHash' | 'command' | 'entry' | 'relativePath'>;
+export type ScheduleLifecyclePlan = {
+    readonly kind: 'run';
+    readonly run: AppScheduledRunPlan;
+} | {
+    readonly kind: 'refresh';
+    readonly owner: AppScheduleOwner;
+    readonly template: AppScheduleTemplate;
+} | {
+    readonly kind: 'skip';
+    readonly code: 'APP_INVALID' | 'APP_SCHEDULE_OFF';
+} | {
+    readonly kind: 'disable';
+    readonly code: 'APP_SCHEDULE_UNDECLARED' | 'APP_SCHEDULE_SOURCE_CHANGED';
+} | {
+    readonly kind: 'remove';
+    readonly code: 'APP_MISSING';
+};
+export declare function cronExpressionForInterval(everyMinutes: AppScheduleIntervalMinutes): string;
+export declare function appScheduleCommandLabel(owner: Pick<AppScheduleOwner, 'appId' | 'actionId'>): string;
+export declare function resolveDeclaredSchedule(definition: Pick<UiDefinitionInput, 'actions'>): ResolvedAppSchedule | undefined;
+export declare function scheduleTemplateFor(declaration: ResolvedAppSchedule, name: string | null): AppScheduleTemplate;
+export declare function toScheduleSnapshot(row: Pick<AppScheduleRowView, 'app' | 'last_started_at' | 'last_run' | 'last_outcome' | 'last_error_code' | 'next_run'> | undefined, declared: Pick<ResolvedAppSchedule, 'everyMinutes'>, availability: AppScheduleAvailability): AppScheduleSnapshot;
+export declare function toScheduledRunVerdict(response: unknown): AppScheduleRunVerdict;
+export declare function planScheduledFire(row: AppScheduleRowView, entry: ScheduleLifecycleEntry, availability: AppScheduleAvailability): ScheduleLifecyclePlan;

package/dist/mcp-app/apps-context.d.ts

@@ -0,0 +1,32 @@
+import type { McpAppLayoutSnapshot, McpAppStateDescriptor } from './types.js';
+import type { McpAppModelContext } from './model-context.js';
+export interface McpAppsContext {
+    readonly rendered: string;
+    readonly guidanceRendered?: string;
+    readonly available?: ReadonlyArray<{
+        readonly id: string;
+        readonly name: string;
+        readonly description: string;
+        readonly agent: 'direct' | 'approval' | 'none';
+        readonly usage?: 'card' | 'window';
+    }>;
+    readonly availableRendered?: string;
+}
+export interface McpAppsContextOptions {
+    readonly cli?: string;
+    readonly available?: McpAppsContext['available'];
+    readonly appLayoutSnapshot?: McpAppLayoutSnapshot;
+}
+export declare const MCP_APPS_AVAILABLE_MAX_BYTES: number;
+export declare function buildMcpAppsContext(descriptors: readonly McpAppStateDescriptor[] | undefined, modelContext?: McpAppModelContext, optionsOrAvailable?: McpAppsContextOptions | McpAppsContext['available']): McpAppsContext | undefined;
+export declare function attachAvailableApps(context: McpAppsContext | undefined, available: McpAppsContext['available'], cli?: string): McpAppsContext | undefined;
+export interface RunningInstructionApps {
+    readonly guidanceRendered?: string;
+    readonly rendered?: string;
+    readonly omittedCount: number;
+}
+export declare function buildRunningInstructionApps(descriptors: readonly McpAppStateDescriptor[] | undefined, options?: {
+    readonly cli?: string;
+    readonly modelContext?: McpAppModelContext;
+    readonly appLayoutSnapshot?: McpAppLayoutSnapshot;
+}): RunningInstructionApps;

package/dist/mcp-app/bundle-provenance.d.ts

@@ -0,0 +1,3 @@
+export declare function markVerifiedProductAppBundleProvenance<T extends object>(value: T, executableRelativePath?: string): T;
+export declare function isVerifiedProductAppBundleProvenance(value: unknown): value is object;
+export declare function getVerifiedProductAppBundleExecutable(value: unknown): string | undefined;

package/dist/mcp-app/candidate-registration.d.ts

@@ -0,0 +1,4 @@
+import type { WorkspaceAppCandidate } from './discovery.js';
+import type { McpAppLocalRegistration } from './types.js';
+export declare function buildWorkspaceCandidateRegistration(candidate: WorkspaceAppCandidate): McpAppLocalRegistration;
+export declare function validateWorkspaceCandidateRegistration(candidate: WorkspaceAppCandidate): void;

package/dist/mcp-app/card-handler.d.ts

@@ -0,0 +1,7 @@
+export declare const MCP_APP_CARD_HANDLERS: readonly ["card.secret-env"];
+export type McpAppCardHandler = (typeof MCP_APP_CARD_HANDLERS)[number];
+export declare function isMcpAppCardHandler(handler: unknown): handler is McpAppCardHandler;
+export declare function isMcpAppCardAction(usage: string | undefined, backend: {
+    readonly type: string;
+    readonly handler?: unknown;
+} | undefined): boolean;

package/dist/mcp-app/catalog.d.ts

@@ -0,0 +1,7 @@
+import type { CrewxAppCatalogOptions, CrewxAppCatalogResult, CrewxAppDefinitionHashInput } from './types.js';
+export declare function hashCrewxAppDefinition(input: CrewxAppDefinitionHashInput): string;
+export declare const hashAppDefinition: typeof hashCrewxAppDefinition;
+export declare function discoverWorkspaceAppCatalog(workspaceRoot: string, options?: CrewxAppCatalogOptions): Promise<CrewxAppCatalogResult>;
+export declare const listWorkspaceApps: typeof discoverWorkspaceAppCatalog;
+export declare const createWorkspaceAppCatalog: typeof discoverWorkspaceAppCatalog;
+export type { CrewxAppDefinitionHashInput, CrewxAppCatalogOptions, CrewxAppCatalogResult, } from './types.js';

package/dist/mcp-app/content-channel.d.ts

@@ -0,0 +1,86 @@
+import { UI_CONTENT_MAX_BYTES, UI_CONTENT_MAX_LINES, UI_CONTENT_MEDIA_TYPES, countContentLines, sha256Content } from '../app/protocol.js';
+import { isUiContentMediaType, isValidUiAppInstanceId } from './content-declarations.js';
+import type { UiContentMediaType } from './content-declarations.js';
+export { UI_CONTENT_MAX_BYTES, UI_CONTENT_MAX_LINES, UI_CONTENT_MEDIA_TYPES, countContentLines, isUiContentMediaType, isValidUiAppInstanceId, sha256Content, };
+export type { UiContentMediaType };
+export declare const UI_CONTENT_TICKET_TTL_MS = 120000;
+export declare const UI_CONTENT_OUTPUT_TTL_MS = 120000;
+export declare const UI_CONTENT_MAX_MEMORY_BYTES: number;
+export declare const UI_CONTENT_ERROR_CODES: readonly ["CONTENT_SOURCE_UNSUPPORTED", "CONTENT_REQUIRED", "CONTENT_EXPIRED", "CONTENT_BINDING_MISMATCH", "CONTENT_DIGEST_MISMATCH", "CONTENT_TOO_LARGE", "CONTENT_ENCODING_INVALID", "CONTENT_BUSY", "IDENTITY_UNAVAILABLE", "EXEC_OUTPUT_INVALID"];
+export type UiContentErrorCode = (typeof UI_CONTENT_ERROR_CODES)[number];
+export interface UiContentInputDeclaration {
+    readonly mediaType: UiContentMediaType;
+    readonly required?: boolean;
+}
+export interface UiContentOutputDeclaration {
+    readonly mediaType: UiContentMediaType;
+    readonly range?: boolean;
+}
+export interface UiActionContentDeclaration {
+    readonly in?: UiContentInputDeclaration;
+    readonly out?: UiContentOutputDeclaration;
+}
+export interface UiContentRangeRequest {
+    readonly startLine: number;
+    readonly lineCount: number;
+}
+export interface UiContentRange extends UiContentRangeRequest {
+    readonly totalLines: number;
+}
+export interface ContentFrame {
+    readonly bytes: Uint8Array;
+    readonly sha256: string;
+    readonly lines: number;
+    readonly mediaType: UiContentMediaType;
+    readonly range?: UiContentRange;
+    readonly complete?: boolean;
+}
+export interface UiContentBinding {
+    readonly workspaceId: string;
+    readonly threadId: string;
+    readonly instanceId: string;
+    readonly actionId: string;
+    readonly requestId: string;
+}
+export interface UiContentInputTicket {
+    readonly ticket: string;
+    readonly binding: UiContentBinding;
+    readonly sha256: string;
+    readonly bytes: number;
+    readonly lines: number;
+    readonly mediaType: UiContentMediaType;
+    readonly expiresAt: number;
+}
+export interface UiContentChannelPort {
+    putInput(ticket: UiContentInputTicket, frame: ContentFrame): void;
+    lookupInput(ticket: string, now: number): UiContentInputTicket | null;
+    consumeInput(ticket: string, now: number): ContentFrame | null;
+    reserveOutput(binding: UiContentBinding, now: number): boolean;
+    releaseOutput(binding: UiContentBinding): void;
+    putOutput(binding: UiContentBinding, frame: ContentFrame, now: number): void;
+    readOutput(binding: UiContentBinding, now: number): ContentFrame | null;
+}
+export declare class UiContentChannelError extends Error {
+    readonly code: UiContentErrorCode;
+    readonly name = "UiContentChannelError";
+    constructor(code: UiContentErrorCode);
+}
+export declare function decodeContentUtf8(bytes: Uint8Array): string;
+export declare function validateContentBytes(value: unknown, mediaType: unknown): {
+    readonly bytes: Uint8Array;
+    readonly sha256: string;
+    readonly lines: number;
+};
+export interface ValidateContentFrameOptions {
+    readonly direction: 'in' | 'out';
+    readonly mediaType: UiContentMediaType;
+    readonly expectedSha256?: string;
+    readonly expectedBytes?: number;
+    readonly expectedLines?: number;
+    readonly requestedRange?: UiContentRangeRequest;
+}
+export declare function validateContentFrame(value: unknown, options: ValidateContentFrameOptions): ContentFrame;
+export declare function isUiContentDeclaration(value: unknown): value is UiActionContentDeclaration;
+export declare function isUiContentRangeRequest(value: unknown): value is UiContentRangeRequest;
+export declare function contentBindingMatches(left: UiContentBinding, right: UiContentBinding): boolean;
+export declare function isValidUiThreadIdentity(value: unknown): value is string;

package/dist/mcp-app/content-declarations.d.ts

@@ -0,0 +1,31 @@
+import { UI_CONTENT_MEDIA_TYPES } from '../app/content-media-types.js';
+import type { UiContentMediaType } from '../app/content-media-types.js';
+import type { UiDefinition, UiDefinitionRef } from '../ui-instance/types.js';
+export { UI_CONTENT_MEDIA_TYPES };
+export type { UiContentMediaType };
+export interface McpAppContentActionDeclaration {
+    readonly actionId: string;
+    readonly in?: {
+        readonly mediaType: UiContentMediaType;
+        readonly required: boolean;
+    };
+    readonly out?: {
+        readonly mediaType: UiContentMediaType;
+        readonly range: boolean;
+    };
+}
+export interface McpAppContentActions {
+    readonly schemaVersion: 1;
+    readonly instanceId: string;
+    readonly definition: {
+        readonly id: string;
+        readonly version: number;
+        readonly hash: string;
+    };
+    readonly actions: readonly McpAppContentActionDeclaration[];
+}
+export declare function isUiContentMediaType(value: unknown): value is UiContentMediaType;
+export declare function isValidUiAppInstanceId(value: unknown): value is string;
+export declare function buildMcpAppContentActions(instanceId: string, definition: UiDefinition): McpAppContentActions | undefined;
+export declare function isMcpAppContentActions(value: unknown): value is McpAppContentActions;
+export declare function contentActionsMatch(value: unknown, instanceId: string, definitionRef: UiDefinitionRef): boolean;

package/dist/mcp-app/dev-checks.d.ts

@@ -0,0 +1,31 @@
+import type { AppIconDiagnostic } from '../ui-plugin/app-icon.js';
+export type AppDevCheckItem = {
+    readonly rule: 'manifest' | 'external_resource' | 'output_unsafe_string' | 'output_invalid' | 'output_size' | 'call_duration';
+    readonly severity: 'error' | 'warning' | 'ok';
+    readonly code: string;
+    readonly where: string;
+    readonly detail?: Record<string, string | number>;
+};
+export type ExternalResourceKind = 'script' | 'style' | 'image' | 'font' | 'media' | 'frame' | 'object' | 'form' | 'navigation' | 'css' | 'script_network';
+export interface ExternalResourceFinding {
+    readonly line: number;
+    readonly column: number;
+    readonly url: string;
+    readonly directive: string;
+    readonly kind: ExternalResourceKind;
+}
+export interface InspectSkillBackendOutputOptions {
+    readonly actionId: string;
+    readonly dataPaths?: readonly string[];
+    readonly resultProjectionAllow?: readonly string[];
+    readonly durationMs?: number;
+    readonly timedOut?: boolean;
+    readonly contentFramed?: boolean;
+}
+export interface ScanExternalResourcesOptions {
+    readonly csp: string;
+}
+export declare function inspectSkillBackendOutput(stdoutText: string, options: InspectSkillBackendOutputOptions): AppDevCheckItem[];
+export declare function scanExternalResources(html: string, options: ScanExternalResourcesOptions): ExternalResourceFinding[];
+export declare function externalResourceCheckItems(entryRelativePath: string, findings: readonly ExternalResourceFinding[]): AppDevCheckItem[];
+export declare function appIconCheckItems(diagnostics: readonly AppIconDiagnostic[]): AppDevCheckItem[];

package/dist/mcp-app/diagnostic-reason.d.ts

@@ -0,0 +1,3 @@
+import type { AppManifestFileName, AppManifestReason } from '../ui-plugin/app-manifest.js';
+export declare function projectAppManifestReason(value: unknown): AppManifestReason | undefined;
+export declare function projectAppManifestFiles(value: unknown): readonly AppManifestFileName[] | undefined;

package/dist/mcp-app/discovery.d.ts

@@ -0,0 +1,164 @@
+import type { UiDefinitionLineageEntry } from '../ui-instance/lineage.js';
+import type { JsonObject, JsonValue, UiDefinition } from '../ui-instance/types.js';
+import type { AppManifestFileName, AppManifestReason } from '../ui-plugin/index.js';
+import type { AppIconDiagnostic, AppIconFile } from '../ui-plugin/app-icon.js';
+import type { UiPluginHandlerMetadata, UiPluginManifestV2, UiPluginNormalizedManifestV2 } from '../ui-plugin/types.js';
+import { createWorkspaceAppScanCache, type WorkspaceAppScanCache, type WorkspaceAppScanRootIdentity } from './workspace-app-scan-cache.js';
+import { AppDiscoveryFsError, NodeAppDiscoveryFs, NodeAppDiscoveryFsAdapter, defaultAppDiscoveryFs, defaultNodeAppDiscoveryFs, type AppDiscoveryFsErrorCode } from './node-app-discovery-fs.js';
+import type { McpAppRegistry } from './types.js';
+import type { ProductAppBundleFileHash, ProductAppBundleInput, ProductAppBundleProvenance as LoadedProductAppBundleProvenance } from './product-bundle-loader.js';
+export type { ProductAppBundleDefinitionIdentity, ProductAppBundleFileHash, ProductAppBundleIndex, ProductAppBundleInput, ProductAppBundlePackageIndex, ProductAppBundleReservations, } from './product-bundle-loader.js';
+export { productAppBundleReservations } from './product-bundle-loader.js';
+export type WorkspaceAppSource = 'apps' | 'skills';
+export declare function isWorkspacePackage(source: WorkspaceAppSource, relativePath: string): boolean;
+export type WorkspaceAppDiscoverySource = WorkspaceAppSource | 'bundled';
+export interface ProductAppBundleProvenance extends LoadedProductAppBundleProvenance {
+    readonly appId: string;
+    readonly definitionId: string;
+    readonly version: number;
+    readonly definitionHash: string;
+    readonly files: readonly ProductAppBundleFileHash[];
+}
+export type WorkspaceAppDiscoveryIncompleteReason = 'time_limit';
+export type WorkspaceAppDiagnosticCode = 'MANIFEST_MISSING' | 'MANIFEST_INVALID' | 'MANIFEST_DUAL_MISMATCH' | 'ENTRY_INVALID' | 'INITIAL_STATE_INVALID' | 'DUPLICATE_ID' | 'RESERVED_ID' | 'BUNDLE_INTEGRITY' | 'LINEAGE_INVALID' | 'LINEAGE_STALE' | 'PATH_ESCAPED' | 'LIMIT_EXCEEDED' | 'DISCOVERY_TIME_LIMIT' | 'ASSET_CATALOG_INVALID' | 'EXEC_DENIED';
+export interface WorkspaceAppDiagnostic {
+    readonly code: WorkspaceAppDiagnosticCode;
+    readonly pluginId?: string;
+    readonly source: WorkspaceAppDiscoverySource;
+    readonly relativePath: string;
+    readonly reason?: AppManifestReason;
+    readonly files?: readonly AppManifestFileName[];
+}
+export interface ProductAppBundleSnapshotMetadata {
+    readonly indexHash?: string;
+    readonly candidates?: readonly WorkspaceAppCandidate[];
+    readonly diagnostics: readonly WorkspaceAppDiagnostic[];
+    readonly reservedAppIds: readonly string[];
+    readonly reservedDefinitionIds: readonly string[];
+}
+export type McpAppDiscoveryDiagnostic = WorkspaceAppDiagnostic;
+export type AppDiscoveryDiagnostic = WorkspaceAppDiagnostic;
+export type AppDiscoveryDirectoryEntryKind = 'file' | 'directory' | 'symlink' | 'other';
+export interface AppDiscoveryDirectoryEntry {
+    readonly name: string;
+    readonly kind: AppDiscoveryDirectoryEntryKind;
+}
+export interface AppDiscoveryFileFingerprint {
+    readonly dev: bigint;
+    readonly ino: bigint;
+    readonly size: bigint;
+    readonly mtimeNs: bigint;
+    readonly ctimeNs: bigint;
+    readonly candidateRealPath: string;
+}
+export interface AppDiscoveryRootIdentity extends WorkspaceAppScanRootIdentity {
+}
+export type AppDiscoveryDirectoryListing = readonly AppDiscoveryDirectoryEntry[] | readonly string[];
+export type AppDiscoveryBytes = Uint8Array | ArrayBuffer | readonly number[];
+export type AppDiscoveryMaybePromise<T> = T | PromiseLike<T>;
+export interface AppDiscoveryFileSystem {
+    readonly listDirectory?: (root: string, relativePath: string) => AppDiscoveryMaybePromise<AppDiscoveryDirectoryListing>;
+    readonly readDirectory?: (root: string, relativePath: string) => AppDiscoveryMaybePromise<AppDiscoveryDirectoryListing>;
+    readonly readdir?: (root: string, relativePath: string) => AppDiscoveryMaybePromise<AppDiscoveryDirectoryListing>;
+    readonly readVerifiedFile?: (root: string, relativePath: string, byteLimit: number) => AppDiscoveryMaybePromise<AppDiscoveryBytes>;
+    readonly readFileVerified?: (root: string, relativePath: string, byteLimit: number) => AppDiscoveryMaybePromise<AppDiscoveryBytes>;
+    readonly fingerprintVerifiedFile?: (root: string, relativePath: string, byteLimit: number) => AppDiscoveryMaybePromise<AppDiscoveryFileFingerprint>;
+    readonly getRootIdentity?: (root: string) => AppDiscoveryMaybePromise<AppDiscoveryRootIdentity>;
+}
+export interface WorkspaceAppReservedCatalog {
+    readonly appIds?: Iterable<string>;
+    readonly definitionIds?: Iterable<string>;
+    readonly toolNames?: Iterable<string>;
+}
+export type WorkspaceAppBuiltinCatalog = Pick<McpAppRegistry, 'listMcpApps' | 'listMcpAppTools'>;
+export interface WorkspaceAppDiscoveryOptions {
+    readonly filesystem?: AppDiscoveryFileSystem;
+    readonly fileSystem?: AppDiscoveryFileSystem;
+    readonly fs?: AppDiscoveryFileSystem;
+    readonly clock?: () => number;
+    readonly reserved?: WorkspaceAppReservedCatalog;
+    readonly builtin?: WorkspaceAppReservedCatalog;
+    readonly builtins?: WorkspaceAppReservedCatalog | WorkspaceAppBuiltinCatalog;
+    readonly builtinCatalog?: WorkspaceAppBuiltinCatalog;
+    readonly reservedAppIds?: Iterable<string>;
+    readonly reservedDefinitionIds?: Iterable<string>;
+    readonly reservedToolNames?: Iterable<string>;
+    readonly productBundle?: ProductAppBundleInput;
+    readonly productBundleReservationMetadata?: ProductAppBundleSnapshotMetadata;
+    readonly scanCache?: WorkspaceAppScanCache;
+}
+export interface WorkspaceAppToolNames {
+    readonly read: string;
+    readonly action?: string;
+}
+export interface WorkspaceAppResourceSnapshot {
+    readonly provenance?: ProductAppBundleProvenance;
+    readonly entry: {
+        readonly path: 'ui/index.html';
+        readonly hash: string;
+        readonly bytes: readonly number[];
+    };
+    readonly initialState?: {
+        readonly path: 'ui/state.json';
+        readonly hash: string;
+        readonly bytes: readonly number[];
+    };
+}
+interface WorkspaceAppCandidateBase {
+    readonly appId: string;
+    readonly pluginId: string;
+    readonly definitionId: string;
+    readonly version: number;
+    readonly releaseVersion?: string;
+    readonly manifestFile?: AppManifestFileName;
+    readonly mcpb?: Readonly<Record<string, JsonValue>>;
+    readonly relativePath: string;
+    readonly manifest: UiPluginManifestV2;
+    readonly normalized: UiPluginNormalizedManifestV2;
+    readonly name: string;
+    readonly description: string;
+    readonly icon?: string;
+    readonly tone?: UiPluginManifestV2['tone'];
+    readonly iconFile?: AppIconFile;
+    readonly iconDiagnostics?: readonly AppIconDiagnostic[];
+    readonly definition: UiDefinition;
+    readonly handlers: Readonly<Record<string, UiPluginHandlerMetadata>>;
+    readonly resources: WorkspaceAppResourceSnapshot;
+    readonly html: string;
+    readonly entryBytes: readonly number[];
+    readonly entryHash: string;
+    readonly initialState: JsonObject;
+    readonly initialStateBytes?: readonly number[];
+    readonly initialStateHash?: string;
+    readonly sourceHash: string;
+    readonly toolNames: WorkspaceAppToolNames;
+}
+export type WorkspaceAppCandidate = WorkspaceAppCandidateBase & ({
+    readonly source: WorkspaceAppSource;
+    readonly provenance?: never;
+    readonly lineage?: never;
+} | {
+    readonly source?: never;
+    readonly provenance: ProductAppBundleProvenance;
+    readonly lineage: readonly UiDefinitionLineageEntry[];
+});
+export interface WorkspaceAppDiscoveryResult {
+    readonly apps: readonly WorkspaceAppCandidate[];
+    readonly diagnostics: readonly WorkspaceAppDiagnostic[];
+    readonly complete: boolean;
+    readonly incompleteReason?: WorkspaceAppDiscoveryIncompleteReason;
+    readonly productBundleIndexHash?: string;
+    readonly productBundleSnapshotMetadata?: ProductAppBundleSnapshotMetadata;
+    readonly candidates?: readonly WorkspaceAppCandidate[];
+}
+export declare const WORKSPACE_APP_TOOL_PREFIX = "crewx_local_app_";
+export declare const LOCAL_APP_TOOL_PREFIX = "crewx_local_app_";
+export declare const MCP_APP_WORKSPACE_TOOL_PREFIX = "crewx_local_app_";
+export declare function deriveWorkspaceAppToolNames(pluginId: string): WorkspaceAppToolNames;
+export declare function deriveWorkspaceAppToolName(pluginId: string, kind?: 'read' | 'action'): string;
+export declare function discoverWorkspaceApps(workspaceRoot: string, fs?: AppDiscoveryFileSystem, options?: WorkspaceAppDiscoveryOptions): Promise<WorkspaceAppDiscoveryResult>;
+export declare function discoverWorkspaceApps(workspaceRoot: string, options?: WorkspaceAppDiscoveryOptions): Promise<WorkspaceAppDiscoveryResult>;
+export declare const discoverWorkspaceAppCandidates: typeof discoverWorkspaceApps;
+export declare const scanWorkspaceApps: typeof discoverWorkspaceApps;
+export { AppDiscoveryFsError, NodeAppDiscoveryFs, NodeAppDiscoveryFsAdapter, defaultAppDiscoveryFs, defaultNodeAppDiscoveryFs, createWorkspaceAppScanCache, };
+export type { AppDiscoveryFsErrorCode, WorkspaceAppScanCache, };

package/dist/mcp-app/errors.d.ts

@@ -0,0 +1,7 @@
+export type McpAppContractErrorCode = 'APP_ID_INVALID' | 'APP_ID_CONFLICT' | 'TOOL_ID_INVALID' | 'TOOL_ID_CONFLICT' | 'RESOURCE_URI_INVALID' | 'RESOURCE_NOT_FOUND' | 'HTML_INVALID' | 'TOOL_INVALID' | 'STATE_INVALID' | 'STATE_PROJECTION_INVALID' | 'BUTTON_INVALID' | 'SERIALIZATION_INVALID';
+export declare class McpAppContractError extends Error {
+    readonly code: McpAppContractErrorCode;
+    readonly name = "McpAppContractError";
+    constructor(code: McpAppContractErrorCode, message?: string);
+}
+export declare function rejectMcpApp(code: McpAppContractErrorCode, message?: string): never;

package/dist/mcp-app/index.d.ts

@@ -0,0 +1,41 @@
+export type { McpAppContractErrorCode } from './errors.js';
+export { McpAppContractError } from './errors.js';
+export { INSTALLED_APP_ENTRY, InstalledAppRefError, buildInstalledAppRef, validateInstalledAppRef, } from './installed-app-ref.js';
+export type { BuildInstalledAppRefInput, InstalledAppPackageFile, InstalledAppRef, InstalledAppRefErrorCode, } from './installed-app-ref.js';
+export { MAX_HTML_LENGTH, createMcpAppRegistry, createBuiltinMcpAppRegistry, buildMcpAppLocalRegistration, createMcpAppLocalRegistration, registerLocalMcpApp, createMcpAppWorkspaceRegistry, createWorkspaceAppRegistry, createWorkspaceMcpAppRegistry, registerMcpApp, resolveMcpAppResource, resolveLocalMcpAppResource, requireMcpAppResource, toMcpAppToolRegistration, makeUiUri, buildMcpAppBundleRegistrationInput, buildMcpAppBundleAgentActionDescriptors, planProductBundleLegacyToolNames, resolveMcpAppFixedResultCall, } from './registry.js';
+export { AppDiscoveryFsError, NodeAppDiscoveryFs, NodeAppDiscoveryFsAdapter, defaultAppDiscoveryFs, defaultNodeAppDiscoveryFs, createWorkspaceAppScanCache, deriveWorkspaceAppToolName, deriveWorkspaceAppToolNames, discoverWorkspaceAppCandidates, discoverWorkspaceApps, LOCAL_APP_TOOL_PREFIX, MCP_APP_WORKSPACE_TOOL_PREFIX, productAppBundleReservations, scanWorkspaceApps, WORKSPACE_APP_TOOL_PREFIX, } from './discovery.js';
+export { loadProductAppBundleAssets } from './product-bundle-assets.js';
+export type { ProductAppBundleAsset, ProductAppBundleAssetCatalog, ProductAppBundleAssetLoadOptions, } from './product-bundle-assets.js';
+export type { WorkspaceAppAsset, WorkspaceAppAssetCatalog, WorkspaceAppAssetDescriptorV1, WorkspaceAppAssetLocator, } from './workspace-app-assets.js';
+export type { AppDiscoveryBytes, AppDiscoveryDiagnostic, AppDiscoveryDirectoryEntry, AppDiscoveryDirectoryEntryKind, AppDiscoveryDirectoryListing, AppDiscoveryFileSystem, AppDiscoveryFileFingerprint, AppDiscoveryFsErrorCode, AppDiscoveryMaybePromise, AppDiscoveryRootIdentity, WorkspaceAppDiscoveryOptions as AppDiscoveryOptions, McpAppDiscoveryDiagnostic, WorkspaceAppBuiltinCatalog, WorkspaceAppCandidate, WorkspaceAppDiscoveryIncompleteReason, WorkspaceAppDiscoveryOptions, WorkspaceAppDiscoveryResult, WorkspaceAppDiagnostic, WorkspaceAppDiagnosticCode, WorkspaceAppDiscoverySource, WorkspaceAppResourceSnapshot, WorkspaceAppScanCache, WorkspaceAppReservedCatalog, WorkspaceAppSource, WorkspaceAppToolNames, ProductAppBundleDefinitionIdentity, ProductAppBundleFileHash, ProductAppBundleIndex, ProductAppBundleInput, ProductAppBundlePackageIndex, ProductAppBundleReservations, ProductAppBundleProvenance, ProductAppBundleSnapshotMetadata, } from './discovery.js';
+export { createWorkspaceAppCatalog, discoverWorkspaceAppCatalog, hashAppDefinition, hashCrewxAppDefinition, listWorkspaceApps, } from './catalog.js';
+export type { CrewxAppBuiltinCatalog, CrewxAppCapability, CrewxAppCatalogOptions, CrewxAppCatalogResult, CrewxAppDefinitionHashInput, CrewxAppDefinitionSummary, CrewxAppDiagnostic, CrewxAppDiagnosticCode, CrewxAppDiagnosticSource, CrewxAppInstalledProjection, CrewxAppLocalDefinitionRef, CrewxAppOrigin, CrewxAppOwnership, CrewxAppShareability, CrewxAppSharingAvailability, CrewxAppSummary, } from './types.js';
+export { MCP_APP_PROJECTION_MAX_BYTES, buildMcpAppStateDescriptor, buildMcpAppStateProjections, createMcpAppToolResult, projectMcpAppSummaryState, serializeMcpAppStateJson, serializeMcpAppStateXml, } from './projection.js';
+export { attachAvailableApps, buildMcpAppsContext } from './apps-context.js';
+export type { McpAppsContext, McpAppsContextOptions } from './apps-context.js';
+export { UI_CONTENT_ERROR_CODES, UI_CONTENT_MAX_BYTES, UI_CONTENT_MAX_LINES, UI_CONTENT_MAX_MEMORY_BYTES, UI_CONTENT_MEDIA_TYPES, UI_CONTENT_OUTPUT_TTL_MS, UI_CONTENT_TICKET_TTL_MS, UiContentChannelError, contentBindingMatches, countContentLines, decodeContentUtf8, isUiContentDeclaration, isUiContentMediaType, isUiContentRangeRequest, isValidUiAppInstanceId, isValidUiThreadIdentity, sha256Content, validateContentBytes, validateContentFrame, } from './content-channel.js';
+export type { ContentFrame, UiActionContentDeclaration, UiContentBinding, UiContentChannelPort, UiContentErrorCode, UiContentInputDeclaration, UiContentInputTicket, UiContentMediaType, UiContentOutputDeclaration, UiContentRange, UiContentRangeRequest, ValidateContentFrameOptions, } from './content-channel.js';
+export { buildMcpAppContentActions, contentActionsMatch, isMcpAppContentActions, } from './content-declarations.js';
+export type { McpAppContentActionDeclaration, McpAppContentActions, } from './content-declarations.js';
+export { CREWX_OPEN_APP_CAPABILITY, CREWX_OPEN_APP_CAPABILITY_VERSION, CREWX_OPEN_APP_MAX_JSON_DEPTH, CREWX_OPEN_APP_MAX_PARAMS_BYTES, CREWX_OPEN_APP_METHOD, CREWX_OPEN_APP_STATUS_METHOD, CREWX_OPEN_APP_SUCCESS_STATUSES, CrewxOpenAppError, UI_APP_OPEN_CAUSE_CODES, UI_APP_OPEN_ERROR_CODES, canonicalCrewxOpenAppPayload, createCrewxOpenAppCapabilityDeclaration, createCrewxOpenAppErrorResult, createCrewxOpenAppRequestId, createCrewxOpenAppSuccessResult, decideCrewxOpenAppOpen, decideCrewxOpenAppStatus, isSameCrewxOpenAppSourceBinding, parseCrewxOpenAppCapabilityDeclaration, parseCrewxOpenAppRequest, parseCrewxOpenAppResult, parseCrewxOpenAppStatusRequest, resolveCrewxOpenAppActionOutcome, } from './app-handoff.js';
+export type { CrewxOpenAppAction, CrewxOpenAppActionOutcome, CrewxOpenAppCapabilityDeclaration, CrewxOpenAppDecisionInput, CrewxOpenAppErrorResult, CrewxOpenAppIdempotencyDecision, CrewxOpenAppLedgerLookup, CrewxOpenAppLedgerRecord, CrewxOpenAppReceiptLookup, CrewxOpenAppRequest, CrewxOpenAppResult, CrewxOpenAppSourceBinding, CrewxOpenAppStatusRequest, CrewxOpenAppSuccessResult, CrewxOpenAppSuccessStatus, UiAppOpenCauseCode, UiAppOpenErrorCode, } from './app-handoff.js';
+export { MCP_APP_MODEL_CONTEXT_MAX_ARRAY_LENGTH, MCP_APP_MODEL_CONTEXT_MAX_BYTES, MCP_APP_MODEL_CONTEXT_MAX_DEPTH, MCP_APP_MODEL_CONTEXT_MAX_STRING_LENGTH, sanitizeMcpAppModelContext, serializeMcpAppModelContextXml, } from './model-context.js';
+export type { McpAppModelContext, McpAppModelContextInput } from './model-context.js';
+export { resolveAgentAccess, listMcpAppAgentActions } from './agent-access.js';
+export type { McpAppAgentAccess, McpAppAgentAccessAction, McpAppVerifiedBundleAccessContext } from './agent-access.js';
+export { MCP_APP_CARD_HANDLERS, isMcpAppCardHandler, isMcpAppCardAction } from './card-handler.js';
+export type { McpAppCardHandler } from './card-handler.js';
+export { buildStateSetHandler, createStateSetHandler, } from './state-set.js';
+export type { StateSetHandlerBuildInput } from './state-set.js';
+export { SKILL_BACKEND_DEFAULT_TIMEOUT_MS, SKILL_BACKEND_INHERITED_ENV_ALLOWLIST, SKILL_BACKEND_CONTENT_SCHEMA_VERSION, SKILL_BACKEND_MAX_INPUT_BYTES, SKILL_BACKEND_MAX_OUTPUT_BYTES, SKILL_BACKEND_SCHEMA_VERSION, buildSkillBackendChildEnvironment, buildSkillBackendHandler, buildVerifiedBundleSkillBackendHandler, } from './skill-backend.js';
+export type { SkillBackendChildEnvironment, SkillBackendExecutionPort, SkillBackendExecutionRequest, SkillBackendExecutionResponse, SkillBackendHandlerBuildInput, SkillBackendInfrastructureErrorCode, SkillBackendPayload, VerifiedBundleSkillBackendBuildInput, VerifiedBundleSkillRunnerPort, VerifiedBundleSkillSpawnRequest, SkillBackendPayloadV1, SkillBackendPayloadV2, SkillBackendContentInputHeader, SkillBackendContentOutputHeader, } from './skill-backend.js';
+export { externalResourceCheckItems, appIconCheckItems, inspectSkillBackendOutput, scanExternalResources, } from './dev-checks.js';
+export { readWorkspaceAppIconFile } from './app-icon-read.js';
+export type { WorkspaceAppIconBytes } from './app-icon-read.js';
+export type { AppDevCheckItem, ExternalResourceFinding, ExternalResourceKind, InspectSkillBackendOutputOptions, ScanExternalResourcesOptions, } from './dev-checks.js';
+export { MCP_APP_HOST_TOOL_ALLOWLIST, MCP_CORE_TOOL_NAMES, MCP_APP_LOCAL_RESOURCE_MIME_TYPE, MCP_APP_RESOURCE_MIME_TYPE, MCP_APP_RESOURCE_URI_PREFIX, } from './types.js';
+export type { McpAppActionDispatcherToolInput, McpAppActionToolDescriptor, McpAppActionToolInput, McpAppButtonDescriptor, McpAppButtonInput, McpAppDescriptor, McpAppDescriptorInput, McpAppInputSchema, McpAppTone, McpUiResourceCsp, McpAppRegistry, McpAppResource, McpAppServerStateInput, McpAppStateDescriptor, McpAppStateProjections, McpAppHostToolInput, McpAppLayoutSnapshot, McpAppPromptResult, McpAppPromptStatus, McpAppWindowState, McpAppStateView, McpAppHostToolName, McpCoreToolName, McpAppReadToolInput, McpAppSingleActionToolInput, McpAppToolCommonInput, McpAppToolDescriptor, McpAppFixedResult, McpAppFixedResultCall, McpAppFixedResultInvalidParams, McpAppFixedResultResolution, McpAppFixedResultUnavailable, McpAppToolInput, McpAppToolMetadata, McpAppToolRegistration, McpAppToolResult, McpAppToolVisibility, McpAppInstanceResourceBinding, McpAppMcpResourceBinding, McpAppResourceBinding, McpAppLocalResource, McpAppLocalRegistrationInput, McpAppLocalReadToolDescriptor, McpAppLocalActionToolDescriptor, McpAppLocalSingleActionToolDescriptor, McpAppLocalHostToolDescriptor, McpAppLocalToolDiagnostic, McpAppLocalToolDescriptor, McpAppLocalRegistration, McpAppBuiltinRegistration, McpAppResolvedRegistration, McpAppLocalLauncher, McpAppBuiltinLauncher, McpAppLauncher, WorkspaceAppLauncher, WorkspaceAppResolvedRegistration, McpAppWorkspaceRegistry, WorkspaceAppRegistry, McpAppWorkspaceRegistryInput, McpAppRegistryOptions, McpAppBundleHostToolTemplate, McpAppBundleAgentActionDescriptor, } from './types.js';
+export { buildWorkspaceAppSnapshot, discoverWorkspaceAppSnapshot, reconfirmWorkspaceAppSnapshot, } from './workspace-snapshot.js';
+export type { WorkspaceAppSnapshot, WorkspaceAppSnapshotBuildOptions, WorkspaceAppSnapshotOptions, WorkspaceAppSnapshotReconfirmResult, WorkspaceAppSnapshotResource, WorkspaceAppSnapshotInitialState, WorkspaceAppInitialState, } from './workspace-snapshot.js';
+export { appScheduleCommandLabel, cronExpressionForInterval, decideScheduleDirective, planScheduledFire, resolveDeclaredSchedule, scheduleTemplateFor, toScheduledRunVerdict, toScheduleSnapshot, } from './app-schedule.js';
+export type { AppScheduleActorKind, AppScheduleAvailability, AppScheduleBinding, AppScheduleOwner, AppScheduleOwnerSource, AppScheduleRowView, AppScheduleTemplate, AppScheduledRunPayload, AppScheduledRunPlan, ResolvedAppSchedule, ScheduleDirectiveDecision, ScheduleLifecycleEntry, ScheduleLifecyclePlan, ScheduledAppLaunchRequest, } from './app-schedule.js';

package/dist/mcp-app/installed-app-ref.d.ts

@@ -0,0 +1,25 @@
+import type { UiDefinition, UiDefinitionRef } from '../ui-instance/types.js';
+export declare const INSTALLED_APP_ENTRY: "ui/index.html";
+export type InstalledAppRefErrorCode = 'APP_ID_INVALID' | 'DEFINITION_REF_INVALID' | 'ENTRY_DUPLICATE' | 'ENTRY_PATH_INVALID' | 'ENTRY_MISSING' | 'ENTRY_HASH_INVALID' | 'INSTALLED_APP_REF_INVALID';
+export declare class InstalledAppRefError extends Error {
+    readonly code: InstalledAppRefErrorCode;
+    readonly name = "InstalledAppRefError";
+    constructor(code: InstalledAppRefErrorCode, message?: string);
+}
+export interface InstalledAppRef {
+    readonly appId: string;
+    readonly definition: UiDefinitionRef;
+    readonly entry: typeof INSTALLED_APP_ENTRY;
+    readonly entryHash: string;
+}
+export interface InstalledAppPackageFile {
+    readonly path: string;
+    readonly sha256: string;
+}
+export interface BuildInstalledAppRefInput {
+    readonly appId: string;
+    readonly definition: UiDefinition;
+    readonly packageFiles: readonly InstalledAppPackageFile[];
+}
+export declare function validateInstalledAppRef(value: unknown): InstalledAppRef;
+export declare function buildInstalledAppRef(input: BuildInstalledAppRefInput): InstalledAppRef;

package/dist/mcp-app/model-context.d.ts

@@ -0,0 +1,29 @@
+import type { JsonObject } from '../ui-instance/types.js';
+export declare const MCP_APP_MODEL_CONTEXT_MAX_BYTES: number;
+export declare const MCP_APP_MODEL_CONTEXT_MAX_STRING_LENGTH = 2048;
+export declare const MCP_APP_MODEL_CONTEXT_MAX_ARRAY_LENGTH = 200;
+export declare const MCP_APP_MODEL_CONTEXT_MAX_DEPTH = 8;
+export declare const MCP_APP_ACTION_RESULT_MAX_BYTES = 2097152;
+export interface McpAppModelContextInput {
+    readonly instanceId: string;
+    readonly definitionHash: string;
+    readonly revision: number;
+    readonly content?: unknown;
+    readonly structuredContent?: unknown;
+}
+export interface McpAppModelContext {
+    readonly instanceId: string;
+    readonly definitionHash: string;
+    readonly revision: number;
+    readonly content?: readonly {
+        readonly type: 'text';
+        readonly text: string;
+    }[];
+    readonly structuredContent?: JsonObject;
+}
+export declare function sanitizeMcpAppActionResult(value: unknown): JsonObject;
+export declare function prepareMcpAppActionResult(value: unknown, selectedAllow: readonly string[]): JsonObject;
+export declare function sanitizeMcpAppModelContext(value: unknown): McpAppModelContext;
+export declare function serializeMcpAppModelContextXml(context: McpAppModelContext, options?: {
+    readonly stale?: boolean;
+}): string;

package/dist/mcp-app/node-app-discovery-fs.d.ts

@@ -0,0 +1,23 @@
+import type { AppDiscoveryFileFingerprint, AppDiscoveryRootIdentity } from './discovery.js';
+export type AppDiscoveryFsErrorCode = 'NOT_FOUND' | 'READ_DENIED' | 'LIMIT_EXCEEDED' | 'PATH_ESCAPED' | 'IDENTITY_CHANGED' | 'TOCTOU' | 'UNSUPPORTED';
+export declare class AppDiscoveryFsError extends Error {
+    readonly code: AppDiscoveryFsErrorCode;
+    readonly name = "AppDiscoveryFsError";
+    constructor(code: AppDiscoveryFsErrorCode);
+}
+export interface NodeAppDiscoveryDirectoryEntry {
+    readonly name: string;
+    readonly kind: 'file' | 'directory' | 'symlink' | 'other';
+}
+export declare class NodeAppDiscoveryFs {
+    getRootIdentity(root: string): Promise<AppDiscoveryRootIdentity>;
+    listDirectory(root: string, relativePath: string): Promise<readonly NodeAppDiscoveryDirectoryEntry[]>;
+    readdir(root: string, relativePath: string): Promise<readonly NodeAppDiscoveryDirectoryEntry[]>;
+    readDirectory(root: string, relativePath: string): Promise<readonly NodeAppDiscoveryDirectoryEntry[]>;
+    readVerifiedFile(root: string, relativePath: string, byteLimit: number): Promise<Uint8Array>;
+    fingerprintVerifiedFile(root: string, relativePath: string, byteLimit: number): Promise<AppDiscoveryFileFingerprint>;
+    readFileVerified(root: string, relativePath: string, byteLimit: number): Promise<Uint8Array>;
+}
+export declare const defaultAppDiscoveryFs: NodeAppDiscoveryFs;
+export declare const defaultNodeAppDiscoveryFs: NodeAppDiscoveryFs;
+export declare const NodeAppDiscoveryFsAdapter: typeof NodeAppDiscoveryFs;

package/dist/mcp-app/product-bundle-assets.d.ts

@@ -0,0 +1,27 @@
+import type { ProductAppBundleInput } from './product-bundle-loader.js';
+import type { AppDiscoveryFileSystem, WorkspaceAppDiagnostic } from './discovery.js';
+import type { ProductAppBundleProvenance } from './product-bundle-loader.js';
+export declare const MCP_APP_ASSET_MAX_FILE_BYTES: number;
+export declare const MCP_APP_ASSET_MAX_TOTAL_BYTES: number;
+export declare const MCP_APP_ASSET_MAX_LOCATORS = 128;
+export declare function isCanonicalMcpAppAssetFilename(filename: string): boolean;
+export declare function mcpAppAssetContentType(filename: string): string | undefined;
+export interface ProductAppBundleAsset {
+    readonly sha256: string;
+    readonly filename: string;
+    readonly contentType: string;
+    readonly byteLength: number;
+    readonly provenance: ProductAppBundleProvenance;
+    bytes(): Uint8Array;
+}
+export interface ProductAppBundleAssetCatalog {
+    readonly indexHash?: string;
+    readonly complete: boolean;
+    readonly diagnostics: readonly WorkspaceAppDiagnostic[];
+    get(sha256: string, filename: string): ProductAppBundleAsset | undefined;
+}
+export interface ProductAppBundleAssetLoadOptions {
+    readonly filesystem?: AppDiscoveryFileSystem;
+    readonly clock?: () => number;
+}
+export declare function loadProductAppBundleAssets(input: ProductAppBundleInput, options?: ProductAppBundleAssetLoadOptions): Promise<ProductAppBundleAssetCatalog>;