@deepseek-harness-tui/dsh-tui 0.8.0 → 0.8.1

package/lib/types/plugin-spec/negotiate.js

@@ -0,0 +1,97 @@
+/** Five-state admission decision using dsh-std projection and ProtocolCatalog. */
+import { defineProtocolDeclaration } from '@dsh-std/core';
+import { projectManifest } from '@dsh-std/manifest';
+import { rawScopeCovers } from './permission-scope.js';
+const coordinateKey = (ref) => `${ref.apiVersion}#${ref.kind}`;
+export function negotiate(index, manifest, host, grants = []) {
+    const supported = new Map(host.contracts.map(contract => [coordinateKey(contract), contract]));
+    const required = manifest.requires.contracts.filter(reference => reference.optional !== true);
+    const optional = manifest.requires.contracts.filter(reference => reference.optional === true);
+    const unknown = manifest.requires.contracts.filter(reference => {
+        try {
+            return index.resolveContractRef(reference).unregisteredVersion;
+        }
+        catch {
+            return false;
+        }
+    });
+    if (unknown.length > 0) {
+        return {
+            decision: 'unknown',
+            reasonCode: 'UNKNOWN_PROTOCOL_VERSION',
+            unknownContracts: unknown.map(coordinateKey),
+        };
+    }
+    if (!host.facetApiVersions.includes(manifest.facets.host.apiVersion)) {
+        return {
+            decision: 'rejected',
+            reasonCode: 'FACET_API_VERSION_UNAVAILABLE',
+            facetApiVersion: manifest.facets.host.apiVersion,
+            hostFacetApiVersions: host.facetApiVersions,
+        };
+    }
+    const missingRequired = required.filter(reference => !supported.has(coordinateKey(reference)));
+    const missingOptional = optional.filter(reference => !supported.has(coordinateKey(reference)));
+    if (missingRequired.length > 0) {
+        return {
+            decision: 'rejected',
+            reasonCode: 'REQUIRED_PROTOCOL_UNAVAILABLE',
+            missingRequired: missingRequired.map(coordinateKey),
+        };
+    }
+    const projected = projectManifest(manifest);
+    const facet = projected.spec.facets.find(candidate => candidate.name === 'host');
+    const supportedKeys = new Set(host.contracts.map(contract => coordinateKey(contract)));
+    const declaration = defineProtocolDeclaration({
+        participant: { id: manifest.id },
+        // An optional protocol that is absent is intentionally omitted from the
+        // evaluator input; its degraded state was already recorded above. This
+        // keeps ProtocolCatalog's required-support error meaningful for every
+        // remaining requirement.
+        requires: (facet?.protocols?.requires ?? []).filter(reference => reference.optional !== true || supportedKeys.has(coordinateKey(reference))),
+    });
+    const hostDeclaration = defineProtocolDeclaration({
+        participant: { id: host.hostId },
+        supports: host.contracts.map(contract => ({
+            apiVersion: contract.apiVersion,
+            kind: contract.kind,
+            ...(Object.hasOwn(contract, 'spec') ? { spec: contract.spec } : {}),
+        })),
+    });
+    const report = index.protocols.negotiate([declaration, hostDeclaration]);
+    if (!report.compatible) {
+        return {
+            decision: 'rejected',
+            reasonCode: 'PROTOCOL_NEGOTIATION_FAILED',
+            issues: report.issues,
+        };
+    }
+    const hostPermissions = new Set(host.contracts.flatMap(contract => contract.permissions));
+    const denied = manifest.permissions.filter((request) => {
+        if (!hostPermissions.has(request.name))
+            return true;
+        const definition = index.permissions.permissions.find(permission => permission.name === request.name);
+        if (definition === undefined)
+            return true;
+        const matching = grants.filter(grant => grant.name === request.name
+            && rawScopeCovers(grant.name, grant.scope, request.scope, manifest.id));
+        // Explicit revocation wins over an allow-default permission. This keeps
+        // admission diagnostics aligned with the runtime checkpoint instead of
+        // reporting a plugin as compatible until its first invocation fails.
+        if (matching.some(grant => grant.granted === false))
+            return true;
+        if (definition.default === 'allow')
+            return false;
+        return !matching.some(grant => grant.granted !== false);
+    });
+    if (denied.length > 0) {
+        return {
+            decision: 'waiting_authorization',
+            reasonCode: 'PERMISSION_NOT_GRANTED',
+            deniedPermissions: denied.map(request => `${request.name}@${request.scope}`),
+        };
+    }
+    return missingOptional.length > 0
+        ? { decision: 'compatible_degraded', missingOptional: missingOptional.map(coordinateKey) }
+        : { decision: 'compatible' };
+}

package/lib/types/plugin-spec/permission-scope.d.ts

@@ -0,0 +1,32 @@
+/** Permission scope normalization shared by admission and runtime checks. */
+export declare const STORAGE_PERMISSIONS: Set<string>;
+export declare const INTERCEPT_PERMISSIONS: Set<string>;
+/** The decision point controlled by each intercept permission.  Keeping this
+ * mapping in the scope adapter (rather than accepting every `tui/*` name for
+ * every permission) prevents a manifest or grant from silently crossing an
+ * event boundary. */
+export declare const INTERCEPT_EVENT_SCOPE_BY_PERMISSION: Readonly<Record<string, string>>;
+/** A session scope is carried through the message envelope and may also be
+ * used by an intercept grant. Keep the canonical bound here so admission,
+ * grant evaluation, and runtime delivery cannot disagree about whether a
+ * scope is executable. */
+export declare const SESSION_SCOPE_MAX_CHARS = 256;
+export type ScopeKind = 'component' | 'command' | 'session' | 'event';
+export interface NormalizedPermissionScope {
+    kind: ScopeKind;
+    value: string;
+}
+/** Return undefined when this adapter cannot enforce the supplied scope. */
+export declare function normalizePermissionScope(permission: string, scope: string, componentId: string): NormalizedPermissionScope | undefined;
+export declare function scopeCovers(declared: NormalizedPermissionScope, actual: NormalizedPermissionScope): boolean;
+/**
+ * Permission-aware containment.  An event-point grant is the parent scope of
+ * the sessions delivered through that point, while a session grant can never
+ * be promoted into an event-point grant.  This relation is also used for
+ * denies, so a narrow `session:<id>` deny wins over a broad event grant.
+ */
+export declare function permissionScopeCovers(permission: string, declared: NormalizedPermissionScope, actual: NormalizedPermissionScope): boolean;
+/** Decision permission scopes may be expressed as one named event point. */
+export declare const TUI_EVENT_SCOPE_NAMES: Set<string>;
+export declare function rawScopeCovers(permission: string, declared: string, actual: string, componentId: string): boolean;
+//# sourceMappingURL=permission-scope.d.ts.map

package/lib/types/plugin-spec/permission-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permission-scope.d.ts","sourceRoot":"","sources":["../../../src/plugin-spec/permission-scope.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAE7E,eAAO,MAAM,mBAAmB,aAAyD,CAAA;AACzF,eAAO,MAAM,qBAAqB,aAKhC,CAAA;AAEF;;;qBAGqB;AACrB,eAAO,MAAM,mCAAmC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAK/E,CAAA;AAEF;;;0BAG0B;AAC1B,eAAO,MAAM,uBAAuB,MAAM,CAAA;AAI1C,MAAM,MAAM,SAAS,GAAG,WAAW,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,CAAA;AAErE,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,SAAS,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;CACd;AAED,4EAA4E;AAC5E,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,GAClB,yBAAyB,GAAG,SAAS,CA2BvC;AAED,wBAAgB,WAAW,CAAC,QAAQ,EAAE,yBAAyB,EAAE,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAI3G;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,yBAAyB,EACnC,MAAM,EAAE,yBAAyB,GAChC,OAAO,CAKT;AAED,4EAA4E;AAC5E,eAAO,MAAM,qBAAqB,aAOhC,CAAA;AAEF,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAMjH"}

package/lib/types/plugin-spec/permission-scope.js

@@ -0,0 +1,90 @@
+/** Permission scope normalization shared by admission and runtime checks. */
+export const STORAGE_PERMISSIONS = new Set(['storage.local.read', 'storage.local.write']);
+export const INTERCEPT_PERMISSIONS = new Set([
+    'session.input.intercept',
+    'session.rewind.intercept',
+    'session.switch.intercept',
+    'session.compact.intercept',
+]);
+/** The decision point controlled by each intercept permission.  Keeping this
+ * mapping in the scope adapter (rather than accepting every `tui/*` name for
+ * every permission) prevents a manifest or grant from silently crossing an
+ * event boundary. */
+export const INTERCEPT_EVENT_SCOPE_BY_PERMISSION = Object.freeze({
+    'session.input.intercept': 'tui/input',
+    'session.rewind.intercept': 'tui/rewind-prompt',
+    'session.switch.intercept': 'tui/session-switch',
+    'session.compact.intercept': 'tui/compact',
+});
+/** A session scope is carried through the message envelope and may also be
+ * used by an intercept grant. Keep the canonical bound here so admission,
+ * grant evaluation, and runtime delivery cannot disagree about whether a
+ * scope is executable. */
+export const SESSION_SCOPE_MAX_CHARS = 256;
+const CONTROL_CHARS = /[\x00-\x1f\x7f-\x9f]/u;
+/** Return undefined when this adapter cannot enforce the supplied scope. */
+export function normalizePermissionScope(permission, scope, componentId) {
+    if (typeof scope !== 'string' || scope === '')
+        return undefined;
+    if (STORAGE_PERMISSIONS.has(permission)) {
+        return scope === componentId ? { kind: 'component', value: componentId } : undefined;
+    }
+    if (permission === 'commands.invoke') {
+        return /^[a-z][a-z0-9]*(?:[.-][a-z0-9][a-z0-9-]*)+$/u.test(scope)
+            ? { kind: 'command', value: scope }
+            : undefined;
+    }
+    if (INTERCEPT_PERMISSIONS.has(permission) && TUI_EVENT_SCOPE_NAMES.has(scope)) {
+        return INTERCEPT_EVENT_SCOPE_BY_PERMISSION[permission] === scope
+            ? { kind: 'event', value: scope }
+            : undefined;
+    }
+    if (permission === 'messages.observe.read' || INTERCEPT_PERMISSIONS.has(permission)) {
+        if (scope === 'session:*')
+            return { kind: 'session', value: scope };
+        if (scope.startsWith('session:')
+            && scope.length <= SESSION_SCOPE_MAX_CHARS
+            && scope.length > 'session:'.length
+            && !scope.includes('*')
+            && !CONTROL_CHARS.test(scope)) {
+            return { kind: 'session', value: scope };
+        }
+        return undefined;
+    }
+    return undefined;
+}
+export function scopeCovers(declared, actual) {
+    if (declared.kind !== actual.kind)
+        return false;
+    return declared.value === actual.value
+        || (declared.kind === 'session' && declared.value === 'session:*' && actual.value.startsWith('session:'));
+}
+/**
+ * Permission-aware containment.  An event-point grant is the parent scope of
+ * the sessions delivered through that point, while a session grant can never
+ * be promoted into an event-point grant.  This relation is also used for
+ * denies, so a narrow `session:<id>` deny wins over a broad event grant.
+ */
+export function permissionScopeCovers(permission, declared, actual) {
+    if (scopeCovers(declared, actual))
+        return true;
+    return INTERCEPT_PERMISSIONS.has(permission)
+        && declared.kind === 'event'
+        && actual.kind === 'session';
+}
+/** Decision permission scopes may be expressed as one named event point. */
+export const TUI_EVENT_SCOPE_NAMES = new Set([
+    'tui/input',
+    'tui/rewind-prompt',
+    'tui/rewind-done',
+    'tui/session-switch',
+    'tui/session-switched',
+    'tui/compact',
+]);
+export function rawScopeCovers(permission, declared, actual, componentId) {
+    const normalizedDeclared = normalizePermissionScope(permission, declared, componentId);
+    const normalizedActual = normalizePermissionScope(permission, actual, componentId);
+    return normalizedDeclared !== undefined
+        && normalizedActual !== undefined
+        && permissionScopeCovers(permission, normalizedDeclared, normalizedActual);
+}

package/lib/types/plugin-spec/registry.d.ts

@@ -0,0 +1,23 @@
+/** Load and verify the pinned dsh-TUI admission profile. */
+import type { ContractRegistry, PermissionRegistry, RegistryEntry } from './types.js';
+export declare const DSH_STD_REVISION = "a2faa86243a5693ee4970e3d8b3aaf361edea298";
+export declare const ECOSYSTEM_SPEC_REVISION = "be1e9a219bd01decf79d825e0c3ac1685bde2be4";
+export interface SpecData {
+    dir: string;
+    registry: ContractRegistry;
+    permissions: PermissionRegistry;
+    schemas: {
+        host: Record<string, unknown>;
+        ledger: Record<string, unknown>;
+        claim: Record<string, unknown>;
+    };
+}
+export declare function locateSpecDir(start?: string): string | undefined;
+export declare function loadSpecData(dir?: string | undefined): SpecData | undefined;
+export declare function registryEntries(registry: ContractRegistry): RegistryEntry[];
+export declare function digestFile(dir: string, relative: string): `sha256:${string}`;
+/** Verify definition availability and private profile digest pins. */
+export declare function verifyRegistry(data: SpecData): string[];
+/** Verify the TUI-owned definitions; public definitions live in dsh-std. */
+export declare function verifyContractProfiles(data: SpecData): string[];
+//# sourceMappingURL=registry.d.ts.map

package/lib/types/plugin-spec/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/plugin-spec/registry.ts"],"names":[],"mappings":"AAAA,4DAA4D;AAO5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAErF,eAAO,MAAM,gBAAgB,6CAA6C,CAAA;AAC1E,eAAO,MAAM,uBAAuB,6CAA6C,CAAA;AAEjF,MAAM,WAAW,QAAQ;IACvB,GAAG,EAAE,MAAM,CAAA;IACX,QAAQ,EAAE,gBAAgB,CAAA;IAC1B,WAAW,EAAE,kBAAkB,CAAA;IAC/B,OAAO,EAAE;QACP,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QAC7B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QAC/B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAC/B,CAAA;CACF;AAID,wBAAgB,aAAa,CAAC,KAAK,GAAE,MAAgD,GAAG,MAAM,GAAG,SAAS,CASzG;AA0CD,wBAAgB,YAAY,CAAC,GAAG,GAAE,MAAM,GAAG,SAA2B,GAAG,QAAQ,GAAG,SAAS,CAiB5F;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,gBAAgB,GAAG,aAAa,EAAE,CAI3E;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,UAAU,MAAM,EAAE,CAE5E;AAED,sEAAsE;AACtE,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,EAAE,CAsBvD;AAED,4EAA4E;AAC5E,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,EAAE,CAiC/D"}

package/lib/types/plugin-spec/registry.js

@@ -0,0 +1,157 @@
+/** Load and verify the pinned dsh-TUI admission profile. */
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createAdmissionCatalog } from './tui-extension.js';
+export const DSH_STD_REVISION = 'a2faa86243a5693ee4970e3d8b3aaf361edea298';
+export const ECOSYSTEM_SPEC_REVISION = 'be1e9a219bd01decf79d825e0c3ac1685bde2be4';
+const REGISTRY_FILE = join('registry', 'registry-0.15.json');
+export function locateSpecDir(start = dirname(fileURLToPath(import.meta.url))) {
+    let dir = start;
+    for (let index = 0; index < 8; index++) {
+        if (existsSync(join(dir, 'ecosystem-spec', REGISTRY_FILE)))
+            return join(dir, 'ecosystem-spec');
+        const parent = dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+    return undefined;
+}
+function loadJson(dir, relative) {
+    return JSON.parse(readFileSync(join(dir, relative), 'utf8'));
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function soundEntry(value, privateDefinition) {
+    if (!isRecord(value) || typeof value.name !== 'string' || typeof value.kind !== 'string')
+        return false;
+    if (!isRecord(value.coordinates)
+        || typeof value.coordinates.apiVersion !== 'string'
+        || typeof value.coordinates.kind !== 'string')
+        return false;
+    if (!Array.isArray(value.permissions) || !value.permissions.every(permission => typeof permission === 'string'))
+        return false;
+    if (privateDefinition) {
+        return value.authority === 'dsh-tui'
+            && typeof value.profile === 'string'
+            && typeof value.profileHash === 'string';
+    }
+    return typeof value.package === 'string' && value.package.startsWith('@dsh-std/');
+}
+function structurallySound(data) {
+    if (!isRecord(data.registry)
+        || typeof data.registry.profileVersion !== 'string'
+        || !isRecord(data.registry.std)
+        || !Array.isArray(data.registry.imports)
+        || !Array.isArray(data.registry.definitions)
+        || !Array.isArray(data.registry.facetApiVersions)
+        || !data.registry.facetApiVersions.every(version => typeof version === 'string'))
+        return false;
+    if (!data.registry.imports.every(entry => soundEntry(entry, false)))
+        return false;
+    if (!data.registry.definitions.every(entry => soundEntry(entry, true)))
+        return false;
+    if (!isRecord(data.permissions) || !Array.isArray(data.permissions.permissions))
+        return false;
+    for (const permission of data.permissions.permissions) {
+        if (!isRecord(permission) || typeof permission.name !== 'string'
+            || (permission.default !== 'allow' && permission.default !== 'deny'))
+            return false;
+    }
+    return Object.values(data.schemas).every(isRecord);
+}
+export function loadSpecData(dir = locateSpecDir()) {
+    if (dir === undefined)
+        return undefined;
+    try {
+        const data = {
+            dir,
+            registry: loadJson(dir, REGISTRY_FILE),
+            permissions: loadJson(dir, join('registry', 'permissions-0.1.json')),
+            schemas: {
+                host: loadJson(dir, join('schemas', 'host-descriptor.schema.json')),
+                ledger: loadJson(dir, join('schemas', 'effect-ledger-record.schema.json')),
+                claim: loadJson(dir, join('schemas', 'conformance-claim.schema.json')),
+            },
+        };
+        return structurallySound(data) ? data : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function registryEntries(registry) {
+    return Array.isArray(registry.imports) && Array.isArray(registry.definitions)
+        ? [...registry.imports, ...registry.definitions]
+        : [];
+}
+export function digestFile(dir, relative) {
+    return `sha256:${createHash('sha256').update(readFileSync(join(dir, relative))).digest('hex')}`;
+}
+/** Verify definition availability and private profile digest pins. */
+export function verifyRegistry(data) {
+    const failures = [];
+    if (!Array.isArray(data.registry.imports)
+        || !Array.isArray(data.registry.definitions)) {
+        return ['registry imports/definitions are malformed'];
+    }
+    const { protocols } = createAdmissionCatalog();
+    for (const entry of registryEntries(data.registry)) {
+        const key = `${entry.coordinates.apiVersion}#${entry.coordinates.kind}`;
+        if (!protocols.understands(entry.coordinates))
+            failures.push(`${key}: ProtocolCatalog definition unavailable`);
+        if ('profile' in entry) {
+            let actual;
+            try {
+                actual = digestFile(data.dir, entry.profile);
+            }
+            catch {
+                failures.push(`${entry.name}: private profile unreadable (${entry.profile})`);
+                continue;
+            }
+            if (actual !== entry.profileHash)
+                failures.push(`${entry.name}: profileHash drifted (registry ${entry.profileHash}, actual ${actual})`);
+        }
+    }
+    return failures;
+}
+/** Verify the TUI-owned definitions; public definitions live in dsh-std. */
+export function verifyContractProfiles(data) {
+    const requiredKeys = [
+        'name', 'version', 'kind', 'coordinates', 'caller', 'permissions',
+        'errors', 'concurrency', 'timeout', 'cleanup', 'privacyClass', 'securityBoundary',
+    ];
+    const failures = [];
+    if (!Array.isArray(data.registry.definitions)) {
+        return ['registry definitions are malformed'];
+    }
+    for (const entry of data.registry.definitions) {
+        let profile;
+        try {
+            profile = loadJson(data.dir, entry.profile);
+        }
+        catch {
+            failures.push(`${entry.name}: private profile unreadable (${entry.profile})`);
+            continue;
+        }
+        for (const key of requiredKeys) {
+            if (!(key in profile))
+                failures.push(`${entry.name}: contract profile missing "${key}"`);
+        }
+        const coordinates = profile.coordinates;
+        if (coordinates?.apiVersion !== entry.coordinates.apiVersion || coordinates.kind !== entry.coordinates.kind) {
+            failures.push(`${entry.name}: profile/registry coordinates mismatch`);
+        }
+        const actualPermissions = [...(profile.permissions ?? [])].sort();
+        if (JSON.stringify(actualPermissions) !== JSON.stringify([...entry.permissions].sort())) {
+            failures.push(`${entry.name}: profile/registry permissions mismatch`);
+        }
+        if (!('operations' in profile) || profile.securityBoundary !== false) {
+            failures.push(`${entry.name}: capability boundary is incomplete`);
+        }
+    }
+    return failures;
+}

package/lib/types/plugin-spec/schema-check.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 零依赖 JSON Schema 校验器——上游 `conformance/tests/run.js` 的 check()
+ * 的保真 TS 移植。刻意只实现 vendored schemas 用到的子集：本地 $ref、
+ * oneOf（恰好一个匹配）、const/enum、object（required/additionalProperties:
+ * false/patternProperties）、array（min/maxItems/items/uniqueItems）、
+ * string（min/maxLength/pattern/format uri|date-time）、integer（minimum）、
+ * boolean。遇到子集之外的构件不静默放行——schema 更新引入新构件时这里
+ * 必须显式扩展（fixtures 矩阵会当场抓住）。
+ */
+type JsonSchema = Record<string, unknown>;
+/**
+ * Validate `value` against `schema`; throws an Error with the failing path
+ * (`$.a.b[0]: reason`) on the first violation.
+ */
+export declare function check(value: unknown, schema: JsonSchema, rootSchema?: JsonSchema, where?: string): void;
+export {};
+//# sourceMappingURL=schema-check.d.ts.map

package/lib/types/plugin-spec/schema-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-check.d.ts","sourceRoot":"","sources":["../../../src/plugin-spec/schema-check.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAqCzC;;;GAGG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAE,UAAmB,EAAE,KAAK,SAAM,GAAG,IAAI,CA0G5G"}

package/lib/types/plugin-spec/schema-check.js

@@ -0,0 +1,165 @@
+/**
+ * 零依赖 JSON Schema 校验器——上游 `conformance/tests/run.js` 的 check()
+ * 的保真 TS 移植。刻意只实现 vendored schemas 用到的子集：本地 $ref、
+ * oneOf（恰好一个匹配）、const/enum、object（required/additionalProperties:
+ * false/patternProperties）、array（min/maxItems/items/uniqueItems）、
+ * string（min/maxLength/pattern/format uri|date-time）、integer（minimum）、
+ * boolean。遇到子集之外的构件不静默放行——schema 更新引入新构件时这里
+ * 必须显式扩展（fixtures 矩阵会当场抓住）。
+ */
+/** Canonical JSON encoding for `uniqueItems`.  JSON object member order is not
+ * semantically significant, while `JSON.stringify` preserves insertion order
+ * and therefore lets equivalent objects evade duplicate detection. */
+function canonicalJson(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(',')}]`;
+    switch (typeof value) {
+        case 'object': {
+            const record = value;
+            return `{${Object.keys(record).sort().map(key => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(',')}}`;
+        }
+        case 'string': return JSON.stringify(value);
+        case 'number': return JSON.stringify(value) ?? 'null';
+        case 'boolean': return value ? 'true' : 'false';
+        case 'undefined': return 'undefined';
+        default: return `${typeof value}:${String(value)}`;
+    }
+}
+function resolveRef(rootSchema, ref) {
+    if (!ref.startsWith('#/')) {
+        throw new Error(`external ref is not supported by the zero-dependency checker: ${ref}`);
+    }
+    return ref
+        .slice(2)
+        .split('/')
+        .reduce((value, key) => {
+        const child = value[key.replace(/~1/g, '/').replace(/~0/g, '~')];
+        if (child === null || typeof child !== 'object') {
+            throw new Error(`unresolvable $ref segment "${key}" in ${ref}`);
+        }
+        return child;
+    }, rootSchema);
+}
+/**
+ * Validate `value` against `schema`; throws an Error with the failing path
+ * (`$.a.b[0]: reason`) on the first violation.
+ */
+export function check(value, schema, rootSchema = schema, where = '$') {
+    if (typeof schema.$ref === 'string') {
+        return check(value, resolveRef(rootSchema, schema.$ref), rootSchema, where);
+    }
+    // oneOf: exactly one variant must match (JSON Schema semantics). Variants
+    // are currently mutually exclusive by design; exact-one keeps future
+    // overlap from being silently accepted.
+    if (Array.isArray(schema.oneOf)) {
+        let matched = 0;
+        const errors = [];
+        for (const variant of schema.oneOf) {
+            try {
+                check(value, variant, rootSchema, where);
+                matched += 1;
+            }
+            catch (error) {
+                errors.push(error instanceof Error ? error.message : String(error));
+            }
+        }
+        if (matched !== 1) {
+            throw new Error(`${where}: expected exactly one oneOf match, got ${matched}: ${errors.join(' | ')}`);
+        }
+        return;
+    }
+    if (schema.const !== undefined && value !== schema.const) {
+        throw new Error(`${where}: expected ${JSON.stringify(schema.const)}`);
+    }
+    if (Array.isArray(schema.enum) && !schema.enum.includes(value)) {
+        throw new Error(`${where}: value is not in enum`);
+    }
+    if (schema.type === 'object') {
+        if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+            throw new Error(`${where}: expected object`);
+        }
+        const record = value;
+        for (const key of schema.required ?? []) {
+            if (!(key in record))
+                throw new Error(`${where}.${key}: required`);
+        }
+        // draft-2020-12: additionalProperties consults properties AND
+        // patternProperties — a key matching a declared pattern is not
+        // "additional".
+        if (schema.additionalProperties === false) {
+            const patterns = Object.keys(schema.patternProperties ?? {});
+            for (const key of Object.keys(record)) {
+                const declared = schema.properties?.[key] !== undefined;
+                const patterned = patterns.some(pattern => new RegExp(pattern).test(key));
+                if (!declared && !patterned)
+                    throw new Error(`${where}.${key}: additional property`);
+            }
+        }
+        for (const [key, child] of Object.entries(schema.properties ?? {})) {
+            if (key in record)
+                check(record[key], child, rootSchema, `${where}.${key}`);
+        }
+        if (schema.patternProperties !== undefined) {
+            for (const [pattern, child] of Object.entries(schema.patternProperties)) {
+                for (const name of Object.keys(record)) {
+                    if (new RegExp(pattern).test(name))
+                        check(record[name], child, rootSchema, `${where}.${name}`);
+                }
+            }
+        }
+        return;
+    }
+    if (schema.type === 'array') {
+        if (!Array.isArray(value))
+            throw new Error(`${where}: expected array`);
+        if (schema.minItems !== undefined && value.length < schema.minItems) {
+            throw new Error(`${where}: too few items`);
+        }
+        if (schema.maxItems !== undefined && value.length > schema.maxItems) {
+            throw new Error(`${where}: too many items`);
+        }
+        for (let i = 0; i < value.length; i++) {
+            check(value[i], schema.items, rootSchema, `${where}[${i}]`);
+        }
+        if (schema.uniqueItems === true) {
+            const encoded = value.map(canonicalJson);
+            if (new Set(encoded).size !== encoded.length)
+                throw new Error(`${where}: duplicate items`);
+        }
+        return;
+    }
+    if (schema.type === 'string') {
+        if (typeof value !== 'string')
+            throw new Error(`${where}: expected string`);
+        if (schema.minLength !== undefined && value.length < schema.minLength) {
+            throw new Error(`${where}: too short`);
+        }
+        if (schema.maxLength !== undefined && value.length > schema.maxLength) {
+            throw new Error(`${where}: too long`);
+        }
+        if (schema.pattern !== undefined && !new RegExp(schema.pattern).test(value)) {
+            throw new Error(`${where}: pattern mismatch`);
+        }
+        if (schema.format === 'uri' && !/^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(value)) {
+            throw new Error(`${where}: invalid URI`);
+        }
+        if (schema.format === 'date-time' && Number.isNaN(Date.parse(value))) {
+            throw new Error(`${where}: invalid date-time`);
+        }
+        return;
+    }
+    if (schema.type === 'integer') {
+        if (!Number.isInteger(value))
+            throw new Error(`${where}: expected integer`);
+        if (schema.minimum !== undefined && value < schema.minimum) {
+            throw new Error(`${where}: below minimum`);
+        }
+        return;
+    }
+    if (schema.type === 'boolean') {
+        if (typeof value !== 'boolean')
+            throw new Error(`${where}: expected boolean`);
+    }
+}

package/lib/types/plugin-spec/tui-extension.d.ts

@@ -0,0 +1,16 @@
+/** dsh-TUI private protocol registration on the shared dsh-std catalog. */
+import { ProtocolCatalog, type ProtocolDefinition } from '@dsh-std/core';
+import { ManifestDefinitionCatalog } from '@dsh-std/manifest';
+import type { ContractCoordinate } from './types.js';
+export declare const TUI_EXTENSION_API_VERSION = "tui.dsh/v1alpha1";
+export declare const DECISION_EVENTS_COORDINATE: Readonly<ContractCoordinate>;
+export declare const TUI_DECISION_EVENT_NAMES: readonly ["tui/input", "tui/rewind-prompt", "tui/rewind-done", "tui/session-switch", "tui/session-switched", "tui/compact"];
+export declare const TUI_EXTENSION_PERMISSION_NAMES: readonly ["session.input.intercept", "session.rewind.intercept", "session.switch.intercept", "session.compact.intercept"];
+export declare const decisionEventsDefinition: ProtocolDefinition;
+export interface AdmissionCatalog {
+    protocols: ProtocolCatalog;
+    manifests: ManifestDefinitionCatalog;
+}
+/** Register public and private definitions into one evaluator-owned catalog. */
+export declare function createAdmissionCatalog(): AdmissionCatalog;
+//# sourceMappingURL=tui-extension.d.ts.map

package/lib/types/plugin-spec/tui-extension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tui-extension.d.ts","sourceRoot":"","sources":["../../../src/plugin-spec/tui-extension.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAE3E,OAAO,EAAE,eAAe,EAAE,KAAK,kBAAkB,EAAsB,MAAM,eAAe,CAAA;AAC5F,OAAO,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAA;AAK7D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAEpD,eAAO,MAAM,yBAAyB,qBAAqB,CAAA;AAE3D,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,kBAAkB,CAGlE,CAAA;AAEF,eAAO,MAAM,wBAAwB,6HAO1B,CAAA;AAEX,eAAO,MAAM,8BAA8B,2HAKhC,CAAA;AAiBX,eAAO,MAAM,wBAAwB,EAAE,kBAsBrC,CAAA;AAEF,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,eAAe,CAAA;IAC1B,SAAS,EAAE,yBAAyB,CAAA;CACrC;AAED,gFAAgF;AAChF,wBAAgB,sBAAsB,IAAI,gBAAgB,CASzD"}