@crewx/sdk 0.9.0-rc.17 → 0.9.0-rc.170

package/dist/mcp-app/app-job-bridge.d.ts

@@ -0,0 +1,30 @@
+import { type AppJobChannel, type AppJobView, type AppJobWireHandle } from '../app/job-wire.js';
+import type { AppJobOperation, AppJobStopReason, AppJobTrigger } from '../app/job-contract.js';
+import { AppJobCoordinator, type AppJobHandle, type AppJobLaunchRequest, type AppJobOwner, type AppJobSnapshot, type ResolvedAppJob } from './app-job.js';
+export interface AppJobControlSession {
+    readonly coordinator: AppJobCoordinator;
+    readonly owner: AppJobOwner;
+    readonly definitionHash: string;
+    readonly job: ResolvedAppJob | undefined;
+    readonly actionId: string;
+    readonly operations: readonly AppJobOperation[];
+    readonly trigger: AppJobTrigger;
+}
+export type AppJobControlAnswer = {
+    readonly kind: 'reply';
+    readonly line: string;
+} | {
+    readonly kind: 'close';
+    readonly code: 'APP_JOB_BRIDGE_INVALID';
+};
+export declare function answerAppJobControlLine(session: AppJobControlSession, line: string): AppJobControlAnswer;
+export interface AppJobRunBinding {
+    readonly coordinator: AppJobCoordinator;
+    readonly handle: AppJobHandle;
+}
+export type AppJobRunAnswer = 'accepted' | 'ignored' | 'invalid';
+export declare function answerAppJobRunLine(binding: AppJobRunBinding, line: string): AppJobRunAnswer;
+export declare function encodeAppJobStopPush(handle: AppJobWireHandle, reason: AppJobStopReason): string;
+export declare function toAppJobView(snapshot: AppJobSnapshot): AppJobView;
+export declare function buildAppJobRunChannel(request: Pick<AppJobLaunchRequest, 'handle'>, fd: number): AppJobChannel;
+export declare function buildAppJobControlChannel(operations: readonly AppJobOperation[], fd: number): AppJobChannel;

package/dist/mcp-app/app-job-bridge.example.d.ts

@@ -0,0 +1,36 @@
+import type { UiDefinitionInput } from '../ui-instance/types.js';
+import { type AppJobControlSession } from './app-job-bridge.js';
+import { AppJobCoordinator, type AppJobOwner } from './app-job.js';
+export declare const CODE_MAP_HOST_FD = 3;
+export interface HostPipeEnd {
+    write(line: string): void;
+    onData(listener: (chunk: string) => void): void;
+    onEnd(listener: () => void): void;
+    close(): void;
+}
+export interface HostChild {
+    readonly pipe: HostPipeEnd;
+    kill(): Promise<void>;
+}
+export type HostSpawn = (options: {
+    readonly env: Readonly<Record<string, string>>;
+    readonly fd: number;
+}) => HostChild;
+export interface CodeMapHostOptions {
+    readonly owner: AppJobOwner;
+    readonly definitionHash: string;
+    readonly definition: UiDefinitionInput;
+    readonly spawnRun: HostSpawn;
+    readonly now: () => number;
+    readonly stopGraceMs?: number;
+    readonly newRunId?: () => string;
+}
+export interface CodeMapHost {
+    readonly coordinator: AppJobCoordinator;
+    sessionFor(call: {
+        readonly actionId: string;
+        readonly actorKind: 'user' | 'agent' | 'schedule';
+    }): AppJobControlSession;
+    serveControlChild(session: AppJobControlSession, pipe: HostPipeEnd): void;
+}
+export declare function createCodeMapHost(options: CodeMapHostOptions): CodeMapHost;

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

@@ -0,0 +1,168 @@
+import { type AppJobOutcome, type AppJobRefusalCode, type AppJobState, type AppJobStopReason, type AppJobTrigger } from '../app/job-contract.js';
+export type { AppJobRefusalCode, AppJobStopReason } from '../app/job-contract.js';
+import type { UiDefinitionInput } from '../ui-instance/types.js';
+import type { AppScheduleOwnerSource } from './app-schedule.js';
+export interface AppJobOwner {
+    readonly workspaceId: string;
+    readonly appId: string;
+    readonly source: AppScheduleOwnerSource;
+}
+export interface ResolvedAppJob {
+    readonly actionId: string;
+    readonly deadlineMs: number;
+}
+export declare function resolveDeclaredJob(definition: Pick<UiDefinitionInput, 'actions'>): ResolvedAppJob | undefined;
+export declare function appJobOwnerKey(owner: AppJobOwner): string;
+export interface AppJobError {
+    readonly code: string;
+    readonly recoverable: boolean;
+}
+export interface AppJobHandle {
+    readonly runId: string;
+    readonly generation: number;
+    readonly ownerKey: string;
+}
+export interface AppJobLaunchRequest {
+    readonly handle: AppJobHandle;
+    readonly owner: AppJobOwner;
+    readonly actionId: string;
+    readonly definitionHash: string;
+    readonly deadlineMs: number;
+    readonly trigger: AppJobTrigger;
+    readonly resumeFromRunId: string | null;
+}
+export interface AppJobExecutionPort {
+    launch(request: AppJobLaunchRequest): Promise<string>;
+    requestStop(ref: string): Promise<void>;
+    terminate(ref: string): Promise<void>;
+}
+export type AppJobReport = {
+    readonly kind: 'heartbeat';
+} | {
+    readonly kind: 'progress';
+    readonly phase: string;
+    readonly completed?: number;
+    readonly total?: number;
+    readonly resumable?: boolean;
+} | {
+    readonly kind: 'completed';
+} | {
+    readonly kind: 'failed';
+    readonly code: string;
+    readonly recoverable: boolean;
+} | {
+    readonly kind: 'exited';
+};
+export type AppJobReportResult = 'accepted' | 'ignored' | 'invalid';
+export interface AppJobStartRequest {
+    readonly owner: AppJobOwner;
+    readonly definitionHash: string;
+    readonly job: ResolvedAppJob | undefined;
+    readonly trigger: AppJobTrigger;
+    readonly authorizedActionId: string;
+}
+export type AppJobStartRefusalCode = Extract<AppJobRefusalCode, ('APP_JOB_NOT_DECLARED' | 'APP_JOB_NOT_AUTHORIZED' | 'APP_JOB_SELF_START' | 'APP_JOB_OWNER_INVALID' | 'APP_JOB_DEFINITION_INVALID' | 'APP_JOB_DEFINITION_CHANGED' | 'APP_JOB_DEADLINE_INVALID' | 'APP_JOB_SHUTTING_DOWN')>;
+export type AppJobStartResult = {
+    readonly kind: 'started';
+    readonly snapshot: AppJobSnapshot;
+} | {
+    readonly kind: 'attached';
+    readonly snapshot: AppJobSnapshot;
+} | {
+    readonly kind: 'refused';
+    readonly code: AppJobStartRefusalCode;
+};
+export type AppJobCancelRefusalCode = 'APP_JOB_OWNER_MISMATCH' | 'APP_JOB_STALE_HANDLE' | 'APP_JOB_NOT_ACTIVE';
+export type AppJobCancelResult = {
+    readonly kind: 'stopping';
+    readonly snapshot: AppJobSnapshot;
+} | {
+    readonly kind: 'refused';
+    readonly code: AppJobCancelRefusalCode;
+};
+export interface AppJobSnapshot {
+    readonly handle: AppJobHandle;
+    readonly state: AppJobState;
+    readonly stopReason: AppJobStopReason | null;
+    readonly trigger: AppJobTrigger;
+    readonly definitionHash: string;
+    readonly resumedFromRunId: string | null;
+    readonly outcome: AppJobOutcome | null;
+    readonly phase: string | null;
+    readonly completed: number | null;
+    readonly total: number | null;
+    readonly resumable: boolean;
+    readonly lastHeartbeatAt: string | null;
+    readonly startedAt: string;
+    readonly finishedAt: string | null;
+    readonly error: AppJobError | null;
+}
+export interface AppJobRecord {
+    readonly runId: string;
+    readonly owner: AppJobOwner;
+    readonly generation: number;
+    readonly actionId: string;
+    readonly definitionHash: string;
+    readonly deadlineMs: number;
+    readonly trigger: AppJobTrigger;
+    readonly resumedFromRunId: string | null;
+    readonly state: AppJobState;
+    readonly outcome: AppJobOutcome | null;
+    readonly phase: string | null;
+    readonly completed: number | null;
+    readonly total: number | null;
+    readonly resumable: boolean;
+    readonly startedAt: number;
+    readonly lastHeartbeatAt: number | null;
+    readonly finishedAt: number | null;
+    readonly error: AppJobError | null;
+}
+export interface AppJobEvent {
+    readonly kind: 'started' | 'attached' | 'stop_requested' | 'finished';
+    readonly runId: string;
+    readonly generation: number;
+    readonly owner: AppJobOwner;
+    readonly trigger: AppJobTrigger;
+    readonly stopReason: AppJobStopReason | null;
+    readonly outcome: AppJobOutcome | null;
+    readonly errorCode: string | null;
+    readonly at: string;
+}
+export interface AppJobCoordinatorOptions {
+    readonly port: AppJobExecutionPort;
+    readonly now: () => number;
+    readonly records?: readonly AppJobRecord[];
+    readonly onEvent?: (event: AppJobEvent) => void;
+    readonly newRunId?: () => string;
+    readonly stopGraceMs?: number;
+}
+export declare class AppJobCoordinator {
+    private readonly port;
+    private readonly now;
+    private readonly newRunId;
+    private readonly onEvent;
+    private readonly stopGraceMs;
+    private readonly runs;
+    private readonly latestByOwner;
+    private readonly drainWaiters;
+    private shuttingDown;
+    constructor(options: AppJobCoordinatorOptions);
+    start(request: AppJobStartRequest): AppJobStartResult;
+    cancel(handle: AppJobHandle): AppJobCancelResult;
+    report(handle: AppJobHandle, report: AppJobReport): AppJobReportResult;
+    status(owner: AppJobOwner): AppJobSnapshot | null;
+    tick(): void;
+    shutdown(): Promise<void>;
+    records(): readonly AppJobRecord[];
+    private launch;
+    private beginStop;
+    private requestStop;
+    private terminate;
+    private finish;
+    private restore;
+    private settle;
+    private emit;
+    private unfinishedCount;
+    private drain;
+    private snapshot;
+}

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;