@crewx/sdk 0.9.0-rc.11 → 0.9.0-rc.110

package/dist/internal/console-decoder.d.ts

@@ -0,0 +1,38 @@
+export interface ConsoleDecoderOptions {
+    platform?: NodeJS.Platform;
+    detectCodePage?: () => Promise<number | null>;
+    codePage?: number | null;
+}
+export interface ConsoleBufferDecodeOptions {
+    platform?: NodeJS.Platform;
+    codePage?: number | null;
+}
+type ConsoleByteChunk = Buffer | Uint8Array<ArrayBufferLike>;
+export declare function parseWindowsConsoleCodePage(output: string): number | null;
+export declare function getWindowsConsoleCodePage(): Promise<number | null>;
+export declare function primeWindowsConsoleCodePage(): void;
+export declare class ConsoleDecoder {
+    private readonly platform;
+    private readonly detectCodePage;
+    private utf8Decoder;
+    private codePage;
+    private fallbackDecoder;
+    private replayTail;
+    private pendingUtf8;
+    private pendingFallback;
+    private pendingBytes;
+    private queue;
+    private ended;
+    constructor(options?: ConsoleDecoderOptions);
+    write(chunk: ConsoleByteChunk): Promise<string>;
+    end(): Promise<string>;
+    private enqueue;
+    private clearPendingCandidate;
+    private resolveCodePage;
+    private getFallbackDecoder;
+    private decodeChunk;
+    private finish;
+}
+export declare function decodeConsoleBuffer(input: ConsoleByteChunk, options?: ConsoleBufferDecodeOptions): string;
+export declare function decodeConsoleBufferAsync(input: ConsoleByteChunk, options?: ConsoleDecoderOptions): Promise<string>;
+export {};

package/dist/internal/windows-spawn.d.ts

@@ -20,15 +20,25 @@ export type WindowsSpawnInvocation = {
     shell?: boolean;
     windowsHide?: boolean;
 };
+export type BinResolutionMode = 'global_first' | 'local_first';
+export type ResolveExecutablePathOptions = {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    resolution?: BinResolutionMode;
+};
 export type ResolveWindowsSpawnProgramParams = {
     command: string;
     platform?: NodeJS.Platform;
     env?: NodeJS.ProcessEnv;
     execPath?: string;
     packageName?: string;
+    cwd?: string;
+    resolution?: BinResolutionMode;
     allowShellFallback?: boolean;
 };
 export type ResolveWindowsSpawnProgramCandidateParams = Omit<ResolveWindowsSpawnProgramParams, 'allowShellFallback'>;
+export declare function resolveExecutablePath(command: string, options?: ResolveExecutablePathOptions): string;
 export declare function resolveWindowsExecutablePath(command: string, env: NodeJS.ProcessEnv): string;
 export declare function resolveWindowsSpawnProgramCandidate(params: ResolveWindowsSpawnProgramCandidateParams): WindowsSpawnProgramCandidate;
 export declare function applyWindowsSpawnProgramPolicy(params: {

package/dist/layout/types.d.ts

@@ -25,6 +25,13 @@ export interface LayoutDefinition {
     template: string;
     propsSchema: Record<string, PropSchema>;
     defaultProps: Record<string, any>;
+    capabilities?: LayoutCapabilities;
+}
+export interface LayoutCapabilities {
+    semanticContinuity?: boolean;
+    continuity?: boolean;
+    continuitySlot?: string;
+    slot?: string;
 }
 export interface CustomLayoutDefinition {
     template: string;
@@ -32,10 +39,15 @@ export interface CustomLayoutDefinition {
     version?: string;
     propsSchema?: Record<string, any>;
     defaultProps?: Record<string, any>;
+    capabilities?: LayoutCapabilities;
 }
 export type InlineLayoutSpec = string | {
     id: string;
     props?: Record<string, any>;
+    capabilities?: LayoutCapabilities;
+} | {
+    template: string;
+    capabilities?: LayoutCapabilities;
 };
 export interface ValidationResult {
     valid: boolean;
@@ -97,6 +109,10 @@ export interface RenderContext {
         [key: string]: any;
     };
     context?: Record<string, any>;
+    semanticContinuity?: import('../conversation/types.js').SemanticContinuityContext;
+    thread_state?: import('../conversation/types.js').ConversationThreadState;
+    threadState?: import('../conversation/types.js').ConversationThreadState;
+    apps?: import('../mcp-app/apps-context.js').McpAppsContext;
     contextOptions?: {
         goals: boolean | string | string[];
         daily: boolean;
@@ -109,7 +125,8 @@ export interface RawLayoutYaml {
     description?: string;
     propsSchema?: Record<string, any>;
     template?: string;
-    layouts?: Record<string, string>;
+    layouts?: Record<string, any>;
+    capabilities?: LayoutCapabilities;
 }
 export declare class LayoutLoadError extends Error {
     readonly layoutId?: string | undefined;

package/dist/lifecycle/task-heartbeat.d.ts

@@ -0,0 +1,41 @@
+import type { TaskRepository } from '../repository/task.repository.js';
+export declare const TASK_HEARTBEAT_INTERVAL_MS = 10000;
+export declare const TASK_HEARTBEAT_STALE_MS = 30000;
+export declare const TASK_HEARTBEAT_HARD_STALE_MS: number;
+export declare const TASK_STOP_POLL_INTERVAL_MS = 1000;
+export declare function resolveTaskHeartbeatIntervalMs(): number;
+export declare function resolveTaskHeartbeatStaleMs(): number;
+export declare function resolveTaskHeartbeatHardStaleMs(): number;
+export interface TaskHeartbeatRow {
+    id?: string;
+    status: string;
+    run_epoch: number | null;
+    stop_requested_at: string | null;
+    stop_requested_epoch: number | null;
+    pid?: number | null;
+    metadata?: string | null;
+    started_at?: string;
+    duration_ms?: number | null;
+}
+export interface HeartbeatTickResult {
+    accepted: boolean;
+    row: TaskHeartbeatRow | null;
+}
+export interface TaskHeartbeatOptions {
+    taskId: string;
+    runEpoch: number;
+    onStopRequested?: (row: TaskHeartbeatRow) => void | Promise<void>;
+}
+export interface TaskHeartbeatHandle {
+    timer: ReturnType<typeof setInterval>;
+    runEpoch: number;
+    stopRequested: boolean;
+    lastHeartbeatAt: number;
+    heartbeatElapsedMs: number;
+}
+export declare const taskHeartbeatRegistry: Map<string, TaskHeartbeatHandle>;
+export declare function runHeartbeatTick(repo: Pick<TaskRepository, 'heartbeatTask' | 'getTask'>, options: TaskHeartbeatOptions & {
+    writeHeartbeat?: boolean;
+}): HeartbeatTickResult;
+export declare function stopTaskHeartbeat(taskId: string, runEpoch?: number | null): boolean;
+export declare function startTaskHeartbeat(repo: Pick<TaskRepository, 'heartbeatTask' | 'getTask'>, options: TaskHeartbeatOptions): boolean;

package/dist/lifecycle/task-stop.d.ts

@@ -0,0 +1,82 @@
+import type { FinalizeTaskForHostShutdownOptions, FinalizeTaskForHostShutdownOutcome, FinalizeTaskStopOptions, TaskRepository, TaskRow, TaskStopOrigin, TaskStopRequestResult } from '../repository/task.repository.js';
+import { checkProcessOwnershipAsync as defaultCheckProcessOwnershipAsync, terminateProcessTree as defaultTerminateProcessTree, type ProcessControlOptions } from '../process/process-control.js';
+export declare const TASK_STOP_DEFAULT_GRACE_MS = 5000;
+export declare const TASK_STOP_DEFAULT_POLL_MS = 250;
+export declare function resolveTaskStopMethod(requestedAt: string | null | undefined, completedAt?: string | number, graceMs?: number): 'cooperative' | 'forced';
+export declare const TASK_STOP_OWNED_PROCESS_MARKERS: readonly ["crewx", "claude", "codex", "opencode", "grok", "node"];
+export type StopTaskStatus = 'stopped' | 'not_running' | 'already_requested' | 'ownership_unverified' | 'failed';
+export interface StopTaskResult {
+    status: StopTaskStatus;
+    method?: 'cooperative' | 'forced';
+    finalStatus: string | null;
+    pid?: number;
+    error?: string;
+}
+export interface StopTaskProcessControl {
+    checkProcessOwnershipAsync?: typeof defaultCheckProcessOwnershipAsync;
+    terminateProcessTree?: typeof defaultTerminateProcessTree;
+}
+export interface StopTaskOptions {
+    origin?: TaskStopOrigin;
+    callerPid?: number;
+    callerTaskId?: string;
+    graceMs?: number;
+    pollMs?: number;
+    platform?: NodeJS.Platform;
+    ownershipMarkers?: readonly string[];
+    processControl?: StopTaskProcessControl;
+    processControlOptions?: ProcessControlOptions;
+}
+export interface StopTaskGenerationForInstructionOptions {
+    taskId: string;
+    targetPid: number | null | undefined;
+    sourceRunEpoch: number;
+    settleRunEpoch: number;
+    workspaceId?: string | null;
+    platform?: NodeJS.Platform;
+    ownershipMarkers?: readonly string[];
+    processControl?: StopTaskProcessControl;
+    processControlOptions?: ProcessControlOptions;
+}
+export interface StopTaskForHostShutdownOptions {
+    taskId: string;
+    expectedRunEpoch: number;
+    workspaceId?: string | null;
+    platform?: NodeJS.Platform;
+    ownershipMarkers?: readonly string[];
+    processControl?: StopTaskProcessControl;
+    processControlOptions?: ProcessControlOptions;
+}
+export declare const INSTRUCTION_STOP_TARGET_PID_MISSING = "INSTRUCTION_STOP_TARGET_PID_MISSING";
+export declare const INSTRUCTION_STOP_EPOCH_MISMATCH = "INSTRUCTION_STOP_EPOCH_MISMATCH";
+export declare const INSTRUCTION_STOP_WORKSPACE_MISMATCH = "INSTRUCTION_STOP_WORKSPACE_MISMATCH";
+export declare const INSTRUCTION_STOP_GENERATION_ALREADY_SETTLED = "INSTRUCTION_STOP_GENERATION_ALREADY_SETTLED";
+export declare const INSTRUCTION_STOP_PROCESS_TERMINATION_FAILED = "INSTRUCTION_STOP_PROCESS_TERMINATION_FAILED";
+export declare const INSTRUCTION_STOP_SETTLE_CAS_FAILED = "INSTRUCTION_STOP_SETTLE_CAS_FAILED";
+export declare const INSTRUCTION_STOP_REQUEST_FAILED = "INSTRUCTION_STOP_REQUEST_FAILED";
+export declare const HOST_SHUTDOWN_EPOCH_MISMATCH = "HOST_SHUTDOWN_EPOCH_MISMATCH";
+export declare const HOST_SHUTDOWN_WORKSPACE_MISMATCH = "HOST_SHUTDOWN_WORKSPACE_MISMATCH";
+export declare const HOST_SHUTDOWN_TARGET_PID_MISSING = "HOST_SHUTDOWN_TARGET_PID_MISSING";
+export declare const HOST_SHUTDOWN_OWNERSHIP_UNVERIFIED = "HOST_SHUTDOWN_OWNERSHIP_UNVERIFIED";
+export declare const HOST_SHUTDOWN_PROCESS_TERMINATION_FAILED = "HOST_SHUTDOWN_PROCESS_TERMINATION_FAILED";
+export declare const HOST_SHUTDOWN_SETTLE_CAS_FAILED = "HOST_SHUTDOWN_SETTLE_CAS_FAILED";
+type StopTaskRepository = Pick<TaskRepository, 'requestTaskStop' | 'stopPendingTask' | 'getTask' | 'finalizeTaskStop'>;
+interface InstructionStopRepository {
+    requestTaskStop: (options: {
+        id: string;
+        requestedAt: string;
+        sourceRunEpoch: number;
+        settleRunEpoch: number;
+        workspaceId?: string | null;
+    }) => TaskStopRequestResult;
+    getTask: (taskId: string) => TaskRow | undefined;
+    finalizeTaskStop: (options: FinalizeTaskStopOptions) => boolean;
+}
+type HostShutdownRepository = Pick<TaskRepository, 'getTask'> & {
+    finalizeTaskForHostShutdown: (options: FinalizeTaskForHostShutdownOptions) => FinalizeTaskForHostShutdownOutcome;
+};
+export declare function stopTaskGenerationForInstruction(repo: InstructionStopRepository, options: StopTaskGenerationForInstructionOptions): Promise<StopTaskResult>;
+export declare function stopTaskForHostShutdown(repo: HostShutdownRepository, options: StopTaskForHostShutdownOptions): Promise<StopTaskResult>;
+export declare function stopTask(taskId: string, options?: StopTaskOptions): Promise<StopTaskResult>;
+export declare function stopTask(repo: StopTaskRepository, taskId: string, options?: StopTaskOptions): Promise<StopTaskResult>;
+export {};

package/dist/lifecycle/update-admission.d.ts

@@ -0,0 +1,44 @@
+export declare const UPDATE_QUIESCE_LOCK_FILENAME = "update-quiesce.lock";
+export declare const UPDATE_ADMISSION_RESERVATION_DIRNAME = "update-admission";
+export declare function resolveUpdateQuiesceLockFile(): string;
+export declare function resolveUpdateAdmissionReservationDir(): string;
+export declare function isProcessAlive(pid: number): boolean;
+export declare function isDurablyQuiescing(): boolean;
+export type DurableQuiesceMarkerState = {
+    kind: 'absent';
+} | {
+    kind: 'owned';
+    ownerPid: number;
+} | {
+    kind: 'unknown';
+};
+export declare function readDurableQuiesceMarkerOwner(): DurableQuiesceMarkerState;
+export type AdmissionMarkerResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};
+export declare function acquireDurableQuiesceMarker(ownerPid: number): AdmissionMarkerResult;
+export declare function releaseDurableQuiesceMarker(ownerPid: number): AdmissionMarkerResult;
+export type ReconcileOutcome = 'absent' | 'cleared' | 'kept-live' | 'kept-unknown';
+export declare function reconcileDurableQuiesceMarkerIfOwnerDead(): ReconcileOutcome;
+export interface UpdateAdmissionReservationEntry {
+    taskId: string;
+    scheduleId: string;
+    corrupt: boolean;
+}
+export declare function reserveUpdateAdmission(taskId: string, scheduleId: string, timeoutMs: number): boolean;
+export declare function releaseUpdateAdmissionReservation(taskId: string): void;
+export declare function readUpdateAdmissionReservations(): UpdateAdmissionReservationEntry[];
+export type DurableTaskAdmission = {
+    ok: true;
+    taskId: string;
+    release: () => void;
+} | {
+    ok: false;
+    reason: 'ADMISSION_UNKNOWN' | 'UPDATE_QUIESCING';
+    message: string;
+};
+export declare const DEFAULT_CLI_ADMISSION_TIMEOUT_MS: number;
+export declare function admitDurableTask(source: string, timeoutMs?: number): DurableTaskAdmission;

package/dist/local-server/base-url.d.ts

@@ -0,0 +1,18 @@
+export declare const LOCAL_SERVER_BASE_URL_MAX_LENGTH = 2048;
+export type LocalServerHostClass = 'loopback' | 'private-ipv4' | 'cgnat' | 'unique-local-ipv6';
+export type LocalServerBaseUrlErrorCode = 'invalid_input' | 'url_too_long' | 'invalid_scheme' | 'invalid_url' | 'userinfo_not_allowed' | 'query_not_allowed' | 'fragment_not_allowed' | 'invalid_port' | 'host_not_ip_literal' | 'zone_id' | 'loopback_not_allowed' | 'metadata_address' | 'link_local' | 'multicast' | 'unspecified' | 'ipv4_mapped_ipv6' | 'ip_not_allowed';
+export interface LocalServerBaseUrlOptions {
+    allowLoopback?: boolean;
+}
+export interface LocalServerBaseUrlSuccess {
+    ok: true;
+    normalizedBaseUrl: string;
+    hostClass: LocalServerHostClass;
+}
+export interface LocalServerBaseUrlFailure {
+    ok: false;
+    code: LocalServerBaseUrlErrorCode;
+}
+export type LocalServerBaseUrlResult = LocalServerBaseUrlSuccess | LocalServerBaseUrlFailure;
+export declare function parseLocalServerBaseUrl(value: unknown, options?: LocalServerBaseUrlOptions): LocalServerBaseUrlResult;
+export declare function isAllowedLocalServerIp(value: string, options?: LocalServerBaseUrlOptions): boolean;

package/dist/local-server/index.d.ts

@@ -0,0 +1,8 @@
+export { isAllowedLocalServerIp, parseLocalServerBaseUrl, } from './base-url';
+export type { LocalServerBaseUrlErrorCode, LocalServerBaseUrlFailure, LocalServerBaseUrlOptions, LocalServerBaseUrlResult, LocalServerBaseUrlSuccess, LocalServerHostClass, } from './base-url';
+export { DEFAULT_LOCAL_SERVER_PROBE_TIMEOUT_MS, probeLocalServer } from './probe';
+export type { LocalServerDefinition, LocalServerFetch, LocalServerKind, LocalServerModel, LocalServerOpenCodeOverlay, LocalServerProbeOptions, LocalServerProbeReason, LocalServerProbeResponse, LocalServerProbeResult, LocalServerSettings, } from './types';
+export { buildLocalServerOpenCodeOverlay, LocalServerOpenCodeOverlayError, } from './opencode';
+export type { LocalServerOpenCodeOverlayErrorCode } from './opencode';
+export { isLocalServerRuntimeEligible, resolveLocalServerRuntime, LocalServerRuntimeError, LOCAL_AI_SERVER_CONFIG_INVALID, } from './runtime';
+export type { LocalServerRuntimeMetadata, LocalServerRuntimeOptions, LocalServerRuntimeResolution, } from './runtime';

package/dist/local-server/opencode.d.ts

@@ -0,0 +1,8 @@
+import type { LocalServerOpenCodeOverlay, LocalServerSettings } from './types';
+export type LocalServerOpenCodeOverlayErrorCode = 'missing_default_model' | 'invalid_default_model' | 'invalid_label' | 'invalid_provider_id' | 'invalid_api_key_env' | 'invalid_base_url';
+export declare class LocalServerOpenCodeOverlayError extends Error {
+    readonly code: LocalServerOpenCodeOverlayErrorCode;
+    readonly name = "LocalServerOpenCodeOverlayError";
+    constructor(code: LocalServerOpenCodeOverlayErrorCode);
+}
+export declare function buildLocalServerOpenCodeOverlay(settings: LocalServerSettings): LocalServerOpenCodeOverlay;

package/dist/local-server/probe.d.ts

@@ -0,0 +1,3 @@
+import type { LocalServerProbeOptions, LocalServerProbeResult } from './types.js';
+export declare const DEFAULT_LOCAL_SERVER_PROBE_TIMEOUT_MS = 3000;
+export declare function probeLocalServer(baseUrl: string, options?: LocalServerProbeOptions): Promise<LocalServerProbeResult>;

package/dist/local-server/runtime.d.ts

@@ -0,0 +1,26 @@
+import type { GlobalSettingsStore } from '../config/global-settings';
+export declare const LOCAL_AI_SERVER_CONFIG_INVALID: "LOCAL_AI_SERVER_CONFIG_INVALID";
+export interface LocalServerRuntimeMetadata {
+    providerId: string;
+    model: string;
+    source: 'global_settings';
+}
+export interface LocalServerRuntimeResolution {
+    model?: string;
+    env?: {
+        OPENCODE_CONFIG_CONTENT: string;
+    };
+    metadata?: LocalServerRuntimeMetadata;
+}
+export interface LocalServerRuntimeOptions {
+    effectiveProviderStr: string;
+    effectiveModel?: string;
+    globalSettings?: GlobalSettingsStore;
+}
+export declare class LocalServerRuntimeError extends Error {
+    readonly name = "LocalServerRuntimeError";
+    readonly code: "LOCAL_AI_SERVER_CONFIG_INVALID";
+    constructor();
+}
+export declare function isLocalServerRuntimeEligible(effectiveProviderStr: string, effectiveModel: string | undefined): boolean;
+export declare function resolveLocalServerRuntime(options: LocalServerRuntimeOptions): LocalServerRuntimeResolution;

package/dist/local-server/types.d.ts

@@ -0,0 +1,43 @@
+export type LocalServerKind = 'ollama' | 'lm-studio' | 'unsloth-desktop';
+export interface LocalServerDefinition {
+    id: string;
+    label: string;
+    kind: LocalServerKind;
+    baseUrl: string;
+    discovery: 'tailscale' | 'manual';
+    defaultModel?: string;
+    auth?: {
+        apiKeyEnv: string;
+    };
+}
+export interface LocalServerSettings {
+    version: 1;
+    definition: LocalServerDefinition;
+    verifiedAt: string;
+}
+export interface LocalServerOpenCodeOverlay {
+    env: {
+        OPENCODE_CONFIG_CONTENT: string;
+    };
+    model: string;
+    providerId: string;
+}
+export interface LocalServerModel {
+    id: string;
+}
+export type LocalServerProbeReason = 'http_error' | 'timeout' | 'network_error' | 'invalid_json' | 'invalid_envelope';
+export interface LocalServerProbeResponse {
+    readonly ok: boolean;
+    json(): Promise<unknown>;
+}
+export type LocalServerFetch = (url: string, init?: RequestInit) => Promise<LocalServerProbeResponse>;
+export interface LocalServerProbeOptions {
+    timeoutMs?: number;
+    fetch?: LocalServerFetch;
+}
+export interface LocalServerProbeResult {
+    ok: boolean;
+    models: LocalServerModel[];
+    latencyMs: number;
+    reason?: LocalServerProbeReason;
+}

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

@@ -0,0 +1,5 @@
+import type { McpAppStateDescriptor } from './types.js';
+export interface McpAppsContext {
+    readonly rendered: string;
+}
+export declare function buildMcpAppsContext(descriptors: readonly McpAppStateDescriptor[] | undefined): McpAppsContext | undefined;

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/discovery.d.ts

@@ -0,0 +1,105 @@
+import type { JsonObject, UiDefinition } from '../ui-instance/types.js';
+import type { UiPluginHandlerMetadata, UiPluginManifestV2, UiPluginNormalizedManifestV2 } from '../ui-plugin/types.js';
+import { AppDiscoveryFsError, NodeAppDiscoveryFs, NodeAppDiscoveryFsAdapter, defaultAppDiscoveryFs, defaultNodeAppDiscoveryFs, type AppDiscoveryFsErrorCode } from './node-app-discovery-fs.js';
+import type { McpAppRegistry } from './types.js';
+export type WorkspaceAppSource = 'apps' | 'skills';
+export type WorkspaceAppDiagnosticCode = 'MANIFEST_MISSING' | 'MANIFEST_INVALID' | 'ENTRY_INVALID' | 'INITIAL_STATE_INVALID' | 'DUPLICATE_ID' | 'RESERVED_ID' | 'PATH_ESCAPED' | 'LIMIT_EXCEEDED' | 'EXEC_DENIED';
+export interface WorkspaceAppDiagnostic {
+    readonly code: WorkspaceAppDiagnosticCode;
+    readonly pluginId?: string;
+    readonly source: WorkspaceAppSource;
+    readonly relativePath: 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 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>;
+}
+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>;
+}
+export interface WorkspaceAppToolNames {
+    readonly read: string;
+    readonly action?: string;
+}
+export interface WorkspaceAppResourceSnapshot {
+    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[];
+    };
+}
+export interface WorkspaceAppCandidate {
+    readonly appId: string;
+    readonly pluginId: string;
+    readonly definitionId: string;
+    readonly version: number;
+    readonly source: WorkspaceAppSource;
+    readonly relativePath: string;
+    readonly manifest: UiPluginManifestV2;
+    readonly normalized: UiPluginNormalizedManifestV2;
+    readonly name: string;
+    readonly description: string;
+    readonly icon?: string;
+    readonly tone?: UiPluginManifestV2['tone'];
+    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 interface WorkspaceAppDiscoveryResult {
+    readonly apps: readonly WorkspaceAppCandidate[];
+    readonly diagnostics: readonly WorkspaceAppDiagnostic[];
+    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, };
+export type { AppDiscoveryFsErrorCode };

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,18 @@
+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, } from './registry.js';
+export { AppDiscoveryFsError, NodeAppDiscoveryFs, NodeAppDiscoveryFsAdapter, defaultAppDiscoveryFs, defaultNodeAppDiscoveryFs, deriveWorkspaceAppToolName, deriveWorkspaceAppToolNames, discoverWorkspaceAppCandidates, discoverWorkspaceApps, LOCAL_APP_TOOL_PREFIX, MCP_APP_WORKSPACE_TOOL_PREFIX, scanWorkspaceApps, WORKSPACE_APP_TOOL_PREFIX, } from './discovery.js';
+export type { AppDiscoveryBytes, AppDiscoveryDiagnostic, AppDiscoveryDirectoryEntry, AppDiscoveryDirectoryEntryKind, AppDiscoveryDirectoryListing, AppDiscoveryFileSystem, AppDiscoveryFsErrorCode, AppDiscoveryMaybePromise, WorkspaceAppDiscoveryOptions as AppDiscoveryOptions, McpAppDiscoveryDiagnostic, WorkspaceAppBuiltinCatalog, WorkspaceAppCandidate, WorkspaceAppDiscoveryOptions, WorkspaceAppDiscoveryResult, WorkspaceAppDiagnostic, WorkspaceAppDiagnosticCode, WorkspaceAppResourceSnapshot, WorkspaceAppReservedCatalog, WorkspaceAppSource, WorkspaceAppToolNames, } 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, buildTerminalMcpAppStateDescriptor, buildTerminalMcpAppStateProjections, createMcpAppToolResult, serializeMcpAppStateJson, serializeMcpAppStateXml, } from './projection.js';
+export { buildMcpAppsContext } from './apps-context.js';
+export type { McpAppsContext } from './apps-context.js';
+export { buildStateSetHandler, createStateSetHandler, } from './state-set.js';
+export type { StateSetHandlerBuildInput } from './state-set.js';
+export { MCP_APP_HOST_TOOL_ALLOWLIST, 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, McpAppHostToolName, McpAppReadToolInput, McpAppSingleActionToolInput, McpAppToolCommonInput, McpAppToolDescriptor, McpAppToolInput, McpAppToolMetadata, McpAppToolRegistration, McpAppToolResult, McpAppToolVisibility, McpAppInstanceResourceBinding, McpAppMcpResourceBinding, McpAppResourceBinding, McpAppLocalResource, McpAppLocalRegistrationInput, McpAppLocalReadToolDescriptor, McpAppLocalActionToolDescriptor, McpAppLocalToolDescriptor, McpAppLocalRegistration, McpAppBuiltinRegistration, McpAppResolvedRegistration, McpAppLocalLauncher, McpAppBuiltinLauncher, McpAppLauncher, WorkspaceAppLauncher, WorkspaceAppResolvedRegistration, McpAppWorkspaceRegistry, WorkspaceAppRegistry, McpAppWorkspaceRegistryInput, } from './types.js';
+export { buildWorkspaceAppSnapshot, discoverWorkspaceAppSnapshot, reconfirmWorkspaceAppSnapshot, } from './workspace-snapshot.js';
+export type { WorkspaceAppSnapshot, WorkspaceAppSnapshotBuildOptions, WorkspaceAppSnapshotOptions, WorkspaceAppSnapshotReconfirmResult, WorkspaceAppSnapshotResource, WorkspaceAppSnapshotInitialState, WorkspaceAppInitialState, } from './workspace-snapshot.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/node-app-discovery-fs.d.ts

@@ -0,0 +1,20 @@
+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 {
+    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>;
+    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/projection.d.ts

@@ -0,0 +1,13 @@
+import type { JsonObject } from '../ui-instance/types.js';
+import type { McpAppServerStateInput, McpAppStateDescriptor, McpAppStateProjections, McpAppToolDescriptor, McpAppToolResult } from './types.js';
+export declare const MCP_APP_PROJECTION_MAX_BYTES: number;
+export declare function buildMcpAppStateDescriptor(input: McpAppServerStateInput): McpAppStateDescriptor;
+export declare function buildTerminalMcpAppStateDescriptor(input: McpAppServerStateInput): McpAppStateDescriptor;
+export declare function serializeMcpAppStateJson(descriptor: McpAppStateDescriptor): string;
+export declare function serializeMcpAppStateXml(descriptor: McpAppStateDescriptor): string;
+export declare function buildMcpAppStateProjections(input: McpAppServerStateInput): McpAppStateProjections;
+export declare function buildTerminalMcpAppStateProjections(input: McpAppServerStateInput): McpAppStateProjections;
+export declare function createMcpAppToolResult(tool: Pick<McpAppToolDescriptor, 'textFallback'>, options?: {
+    structuredContent?: JsonObject;
+    meta?: JsonObject;
+}): McpAppToolResult;

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

@@ -0,0 +1,19 @@
+import { type McpAppDescriptor, type McpAppDescriptorInput, type McpAppInputSchema, type McpAppLocalRegistration, type McpAppLocalRegistrationInput, type McpAppLocalResource, type McpAppRegistry, type McpAppResource, type McpAppWorkspaceRegistry, type McpAppWorkspaceRegistryInput, type McpAppToolDescriptor, type McpAppToolRegistration } from './types.js';
+export declare const MAX_HTML_LENGTH: number;
+export declare function createMcpAppRegistry(): McpAppRegistry;
+export declare function createBuiltinMcpAppRegistry(): McpAppRegistry;
+export declare function registerMcpApp(registry: McpAppRegistry, input: McpAppDescriptorInput): McpAppDescriptor;
+export declare function resolveMcpAppResource(registry: McpAppRegistry, uri: string): McpAppResource | null;
+export declare function requireMcpAppResource(registry: McpAppRegistry, uri: string): McpAppResource;
+export declare function toMcpAppToolRegistration(tool: McpAppToolDescriptor): McpAppToolRegistration;
+export declare function buildMcpAppLocalRegistration(input: McpAppLocalRegistrationInput): McpAppLocalRegistration;
+export declare const createMcpAppLocalRegistration: typeof buildMcpAppLocalRegistration;
+export declare const registerLocalMcpApp: typeof buildMcpAppLocalRegistration;
+export declare function createMcpAppWorkspaceRegistry(input?: McpAppWorkspaceRegistryInput): McpAppWorkspaceRegistry;
+export declare const createWorkspaceAppRegistry: typeof createMcpAppWorkspaceRegistry;
+export declare const createWorkspaceMcpAppRegistry: typeof createMcpAppWorkspaceRegistry;
+export declare function createMcpAppLocalActionInputSchema(actions: readonly {
+    readonly actionId: string;
+    readonly inputSchema: McpAppInputSchema;
+}[]): McpAppInputSchema;
+export declare function resolveLocalMcpAppResource(registry: McpAppWorkspaceRegistry, appId: string, definitionHash?: string): McpAppLocalResource | null;