@deepseek-harness-tui/dsh-tui 0.14.1 → 0.16.0

package/lib/types/dsh-adapter/plugin-completions.js

@@ -0,0 +1,80 @@
+import { getLang, LANGS } from '../i18n.js';
+import { extraBundles, pluginManagerOf, pluginTitleIn } from './plugin-manager.js';
+import { cleanScalarText } from './sanitize.js';
+/**
+ * Display-cell budget for one description. The popup truncates to its own row
+ * width at render, so this only bounds what a bundle's metadata may park in the
+ * cache — a title is host input and arrives as wide as it likes.
+ */
+const DESCRIPTION_CELLS = 200;
+/**
+ * What one bundle answers to, version included, in every shipped language. The
+ * title is host metadata landing in the popup's row, so it is sanitized and
+ * capped as a display string (`cleanScalarText`: a newline in a title would
+ * leave the row, ANSI would paint it). Every language is built at warm time
+ * because the cache loads once; `CommandSuggestions` resolves `descriptions` at
+ * render (`localizedDescription`), so `/lang` repaints the popup without a
+ * reload and the popup titles a bundle exactly as `/plugin info` does.
+ */
+function bundleDescriptions(bundle) {
+    const version = bundle.version === undefined ? '' : ` · ${bundle.version}`;
+    const built = {};
+    for (const lang of LANGS) {
+        built[lang] = cleanScalarText(`${pluginTitleIn(bundle, lang, bundle.name)}${version}`, DESCRIPTION_CELLS);
+    }
+    return built;
+}
+/** The warm-and-read pair the slash completion tree consumes. */
+export function createPluginCompletionCatalog(ctx, deps) {
+    let nodes;
+    let load;
+    const warmPluginNames = () => {
+        if (load !== undefined)
+            return;
+        const manager = pluginManagerOf(ctx);
+        if (manager === undefined) {
+            nodes = [];
+            return;
+        }
+        let pending;
+        try {
+            pending = manager.listBundles();
+        }
+        catch {
+            // The service threw before it returned a promise; `.catch` only covers a
+            // rejection, so the raw throw would otherwise reach the keystroke path
+            // that asked for the names. Answer an empty list like an absent service,
+            // and leave `load` unset so a later warm can try again.
+            nodes = [];
+            return;
+        }
+        const live = () => deps.owner.current() && !deps.owner.signal.aborted;
+        load = pending.then(bundles => {
+            // A late answer after a release would write into a dead channel; let a
+            // later warm try again instead of pinning the empty result.
+            if (!live()) {
+                load = undefined;
+                return;
+            }
+            nodes = extraBundles(bundles).map(bundle => {
+                // The package name is what `/plugin info` matches, so it is the token;
+                // the title and version are what a person recognizes in the popup. Both
+                // come from the report's own reader, per language, so the two never
+                // disagree — and neither renders raw host metadata.
+                const descriptions = bundleDescriptions(bundle);
+                return {
+                    name: bundle.name,
+                    description: descriptions[getLang()] ?? bundle.name,
+                    descriptions,
+                    ...(bundle.enabled ? {} : { tag: 'off' }),
+                };
+            });
+            deps.emit();
+        }).catch(() => {
+            load = undefined;
+            if (live())
+                nodes = [];
+        });
+    };
+    return { warmPluginNames, pluginNames: () => nodes ?? [] };
+}

package/lib/types/dsh-adapter/plugin-declaration.d.ts

@@ -0,0 +1,119 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { type BackendSpec } from '../adapter/spec/tui-contributions.js';
+/** One package's declaration: the file it lives in and its exact bytes. */
+export interface PluginDeclaration {
+    readonly path: string;
+    readonly source: string;
+}
+/**
+ * The package-root `dsh-plugin.json` of `packageName`, or `undefined` when the
+ * package is not resolvable from this composition or ships no declaration.
+ * Tolerant by design: a broken install answers "no declaration", never a throw.
+ */
+export declare function pluginDeclarationOf(ctx: Context, packageName: string): PluginDeclaration | undefined;
+/**
+ * One `Backend` contribution a package declaration carries, as this host's own
+ * `Backend` definition reads it (D-1).
+ */
+export interface DeclaredBackend {
+    /** The declaration's own `name` (the contribution's local name, distinct from
+     *  the backend id its `spec` carries). */
+    readonly name: string;
+    /** The public declaration, already validated: `validateBackendSpec()`'s result. */
+    readonly spec: BackendSpec;
+}
+/** What one declaration contributes, and what could not be read out of it. */
+export interface DeclaredBackends {
+    readonly backends: readonly DeclaredBackend[];
+    /** Entries that announced themselves as `Backend` contributions but are not
+     *  one this host can read; each names the entry and why. Empty is the normal
+     *  answer for a package that contributes no backend. */
+    readonly problems: readonly string[];
+}
+/**
+ * The `Backend` contributions of one `dsh-plugin.json` record.
+ *
+ * One reader for every consumer — the C-5 residue watch (`plugin-manage.ts`) and
+ * the D-1 assembly both ask this — so the two cannot disagree about which entries
+ * are backend contributions. It applies the same gates the admission path
+ * applies, in the same order: the definition's own coordinate (`apiVersion` +
+ * `kind`), the contribution's outer `id`, the definition's metadata rule
+ * (`name`), then the family validator. An entry that fails any of them is
+ * reported in `problems` rather than dropped in silence; a `null`/non-object
+ * record simply contributes nothing. Below that, silence means absence only: a
+ * `contributes` that is not an object, and an `x-dsh-tui` point that is not an
+ * array, are malformed declarations, reported like any other gate (the canonical
+ * validator refuses both shapes).
+ *
+ * `projectManifest` drops contributions without a string outer `id`; this
+ * reader must not register one either. That contribution id may differ from
+ * the backend id in `spec.id`.
+ *
+ * Identity is deliberately not this function's business: it reads a record the
+ * caller already obtained, and says nothing about which package that record
+ * belongs to (#1568 — a manifest counts only beside the package root that
+ * establishes it).
+ * A claimed backend also requires a valid canonical manifest projection; in
+ * particular, duplicate contribution identities must not bypass admission.
+ */
+export declare function declaredBackendsOf(record: unknown): DeclaredBackends;
+/**
+ * {@link declaredBackendsOf} over a declaration's raw bytes. A declaration that
+ * does not parse is a problem, not an empty answer: the file is there and says
+ * something this host cannot read.
+ */
+export declare function declaredBackendsIn(source: string): DeclaredBackends;
+/** This application's own package: the composition, never a plugin of it. */
+export declare const COMPOSITION_PACKAGE = "@deepseek-harness-tui/dsh-tui";
+/**
+ * What a listed bundle belongs to the composition itself rather than to the
+ * plugins a person installs. Gate 1 is a statement about *plugins* ("this
+ * package declares no TUI contribution"), so applying it to the host's own
+ * rows — or to this application — would report the composition as a missing
+ * declaration. Everything else is judged by its declaration alone.
+ */
+export declare function isCompositionOwned(packageName: string): boolean;
+/**
+ * The package-root declaration of a directory that is not installed yet: a
+ * `/plugin install <path>` spec names its directory, so the pre-install notice
+ * can read the same file the admission path will read after the install.
+ * Tolerant like {@link pluginDeclarationOf}: a missing or unreadable file
+ * answers "no declaration", never a throw. A spec that names a tarball, a git
+ * URL or a registry package has no directory here — the caller reports the
+ * notice as unjudged rather than guessing.
+ */
+export declare function pluginDeclarationIn(directory: string): PluginDeclaration | undefined;
+/**
+ * Gate 1's pre-install statement about a package, as data (Stage C-4).
+ *
+ * `unjudged` is the honest answer for anything whose declaration is not on
+ * this machine yet — a registry spec has no package-root file to read before
+ * the install runs. The notice therefore never claims "this package supports
+ * dsh-tui"; it says either what it read, or that the answer arrives with the
+ * install (the standing tag in `/plugin` is what really reports it, C-3).
+ */
+export type PluginInstallNotice = 
+/** A declaration was read and this profile accepts it. */
+{
+    readonly kind: 'declared';
+}
+/** Read, and the package ships no package-root `dsh-plugin.json`. */
+ | {
+    readonly kind: 'undeclared';
+}
+/**
+ * Read, and this profile cannot accept it: it does not parse, does not
+ * project, or fails the admission catalog's validation. The five-state
+ * negotiation is deliberately not part of this answer — it is a statement
+ * about a *running* host, and the standing tag in `/plugin` reports it after
+ * the install.
+ */
+ | {
+    readonly kind: 'invalid';
+    readonly error: string;
+}
+/** Nothing on disk to read yet: the answer arrives with the install. */
+ | {
+    readonly kind: 'unjudged';
+};
+//# sourceMappingURL=plugin-declaration.d.ts.map

package/lib/types/dsh-adapter/plugin-declaration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-declaration.d.ts","sourceRoot":"","sources":["../../../src/dsh-adapter/plugin-declaration.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,EAAgC,KAAK,WAAW,EAAE,MAAM,sCAAsC,CAAA;AAIrG,2EAA2E;AAC3E,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS,CAepG;AAED;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B;8CAC0C;IAC1C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,mFAAmF;IACnF,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;CAC3B;AAED,8EAA8E;AAC9E,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,QAAQ,EAAE,SAAS,eAAe,EAAE,CAAA;IAC7C;;4DAEwD;IACxD,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAA;CACrC;AAID;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,GAAG,gBAAgB,CAwDpE;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,CAQnE;AAED,6EAA6E;AAC7E,eAAO,MAAM,mBAAmB,kCAAkC,CAAA;AAElE;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAE/D;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS,CAQpF;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,mBAAmB;AAC7B,0DAA0D;AACxD;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;CAAE;AAC/B,qEAAqE;GACnE;IAAE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;CAAE;AACjC;;;;;;GAMG;GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE;AACtD,wEAAwE;GACtE;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;CAAE,CAAA"}

package/lib/types/dsh-adapter/plugin-declaration.js

@@ -0,0 +1,183 @@
+/**
+ * Where a plugin package states what it contributes (gate 1's evidence).
+ *
+ * A plugin declares itself by shipping a package-root `dsh-plugin.json` — the
+ * pinned `@dsh-std/manifest` shape this profile's admission catalog validates
+ * (`docs/plugin-admission-and-development.md`). That is the same artifact the
+ * plugin-host admits third-party activations from (`./admission-loader.ts`),
+ * so the list and the admission path read one declaration, not two.
+ *
+ * Resolution follows `./bundled-presets.ts`: bare package names resolve from
+ * the composition's `baseUrl` (the profile directory a `dsh --profile` boot
+ * sets), so this reads the profile's own install tree and never scans
+ * node_modules. The package.json hop goes through `findPackageJSON`, which
+ * still finds the package when its `exports` map hides the extra file.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { findPackageJSON } from 'node:module';
+import { dirname, join } from 'node:path';
+import { BACKEND, validateBackendSpec } from '../adapter/spec/tui-contributions.js';
+import { projectManifest } from '../adapter/standard/protocols.js';
+/**
+ * The package-root `dsh-plugin.json` of `packageName`, or `undefined` when the
+ * package is not resolvable from this composition or ships no declaration.
+ * Tolerant by design: a broken install answers "no declaration", never a throw.
+ */
+export function pluginDeclarationOf(ctx, packageName) {
+    let manifestPath;
+    try {
+        manifestPath = findPackageJSON(packageName, ctx.baseUrl ?? import.meta.url);
+    }
+    catch {
+        return undefined;
+    }
+    if (manifestPath === undefined)
+        return undefined;
+    const file = join(dirname(manifestPath), 'dsh-plugin.json');
+    if (!existsSync(file))
+        return undefined;
+    try {
+        return { path: file, source: readFileSync(file, 'utf8') };
+    }
+    catch {
+        return undefined;
+    }
+}
+const NO_BACKENDS = Object.freeze({ backends: Object.freeze([]), problems: Object.freeze([]) });
+/**
+ * The `Backend` contributions of one `dsh-plugin.json` record.
+ *
+ * One reader for every consumer — the C-5 residue watch (`plugin-manage.ts`) and
+ * the D-1 assembly both ask this — so the two cannot disagree about which entries
+ * are backend contributions. It applies the same gates the admission path
+ * applies, in the same order: the definition's own coordinate (`apiVersion` +
+ * `kind`), the contribution's outer `id`, the definition's metadata rule
+ * (`name`), then the family validator. An entry that fails any of them is
+ * reported in `problems` rather than dropped in silence; a `null`/non-object
+ * record simply contributes nothing. Below that, silence means absence only: a
+ * `contributes` that is not an object, and an `x-dsh-tui` point that is not an
+ * array, are malformed declarations, reported like any other gate (the canonical
+ * validator refuses both shapes).
+ *
+ * `projectManifest` drops contributions without a string outer `id`; this
+ * reader must not register one either. That contribution id may differ from
+ * the backend id in `spec.id`.
+ *
+ * Identity is deliberately not this function's business: it reads a record the
+ * caller already obtained, and says nothing about which package that record
+ * belongs to (#1568 — a manifest counts only beside the package root that
+ * establishes it).
+ * A claimed backend also requires a valid canonical manifest projection; in
+ * particular, duplicate contribution identities must not bypass admission.
+ */
+export function declaredBackendsOf(record) {
+    if (record === null || typeof record !== 'object')
+        return NO_BACKENDS;
+    const contributes = record.contributes;
+    // Absent declares nothing — the normal answer for a package that contributes no
+    // TUI row. Present but not an object (`null`, a primitive, an array) is a
+    // malformed declaration, not an empty one: the canonical validator refuses those
+    // shapes too (`contributes must be an object`), and reading them as "nothing
+    // declared" would pass the bundle over without a word.
+    if (contributes === undefined)
+        return NO_BACKENDS;
+    if (contributes === null || typeof contributes !== 'object' || Array.isArray(contributes)) {
+        return { backends: [], problems: ['contributes must be an object'] };
+    }
+    const entries = contributes['x-dsh-tui'];
+    // The same rule one level down, for the same reason.
+    if (entries === undefined)
+        return NO_BACKENDS;
+    if (!Array.isArray(entries)) {
+        return { backends: [], problems: [`contributes['x-dsh-tui'] must be an array`] };
+    }
+    const backends = [];
+    const problems = [];
+    for (const [index, entry] of entries.entries()) {
+        if (entry === null || typeof entry !== 'object')
+            continue;
+        const candidate = entry;
+        if (candidate.kind !== BACKEND.kind)
+            continue;
+        const where = `contributes['x-dsh-tui'][${index}]`;
+        if (candidate.apiVersion !== BACKEND.apiVersion) {
+            problems.push(`${where} is a ${BACKEND.kind} of ${String(candidate.apiVersion)}, not ${BACKEND.apiVersion}`);
+            continue;
+        }
+        // The canonical projection drops such a contribution before it reads its
+        // spec (`@dsh-std/manifest`'s extension loop), so a backend it does not
+        // count must not be registered here either.
+        if (typeof candidate.id !== 'string') {
+            problems.push(`${where}.id is missing or not a string`);
+            continue;
+        }
+        const name = candidate.name;
+        if (typeof name !== 'string' || !/^[a-z][a-z0-9_-]*$/u.test(name)) {
+            problems.push(`${where}.name is missing or invalid`);
+            continue;
+        }
+        try {
+            backends.push({ name, spec: validateBackendSpec(candidate.spec) });
+        }
+        catch (error) {
+            problems.push(`${where} (${name}) has an invalid Backend content: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    if (backends.length > 0) {
+        try {
+            projectManifest(record);
+        }
+        catch (error) {
+            problems.push(`the declaration could not be projected (${error instanceof Error ? error.message : String(error)})`);
+            return { backends: [], problems };
+        }
+    }
+    return { backends, problems };
+}
+/**
+ * {@link declaredBackendsOf} over a declaration's raw bytes. A declaration that
+ * does not parse is a problem, not an empty answer: the file is there and says
+ * something this host cannot read.
+ */
+export function declaredBackendsIn(source) {
+    let parsed;
+    try {
+        parsed = JSON.parse(source);
+    }
+    catch (error) {
+        return { backends: [], problems: [`the declaration is not valid JSON (${error instanceof Error ? error.message : String(error)})`] };
+    }
+    return declaredBackendsOf(parsed);
+}
+/** This application's own package: the composition, never a plugin of it. */
+export const COMPOSITION_PACKAGE = '@deepseek-harness-tui/dsh-tui';
+/**
+ * What a listed bundle belongs to the composition itself rather than to the
+ * plugins a person installs. Gate 1 is a statement about *plugins* ("this
+ * package declares no TUI contribution"), so applying it to the host's own
+ * rows — or to this application — would report the composition as a missing
+ * declaration. Everything else is judged by its declaration alone.
+ */
+export function isCompositionOwned(packageName) {
+    return packageName.startsWith('@deepseek-ai/') || packageName === COMPOSITION_PACKAGE;
+}
+/**
+ * The package-root declaration of a directory that is not installed yet: a
+ * `/plugin install <path>` spec names its directory, so the pre-install notice
+ * can read the same file the admission path will read after the install.
+ * Tolerant like {@link pluginDeclarationOf}: a missing or unreadable file
+ * answers "no declaration", never a throw. A spec that names a tarball, a git
+ * URL or a registry package has no directory here — the caller reports the
+ * notice as unjudged rather than guessing.
+ */
+export function pluginDeclarationIn(directory) {
+    const file = join(directory, 'dsh-plugin.json');
+    if (!existsSync(file))
+        return undefined;
+    try {
+        return { path: file, source: readFileSync(file, 'utf8') };
+    }
+    catch {
+        return undefined;
+    }
+}

package/lib/types/dsh-adapter/plugin-feed.d.ts

@@ -0,0 +1,94 @@
+/** The shipped feed, relative to the package root. */
+export declare const FIRST_PARTY_FEED_FILE = "tui-profile/feed/first-party.json";
+/** One curated entry: the exact artifact this project vouches for. */
+export interface FirstPartyEntry {
+    /**
+     * The full package name, scope included. Matched verbatim. `feedVersion: 1`
+     * carries scoped names only: an unscoped name has no publisher a file can
+     * assert offline, so admitting one is a deliberate format decision (a new
+     * feedVersion), not an entry somebody adds.
+     */
+    readonly name: string;
+    /**
+     * The expected publisher. Must equal the name's own scope — npm lets only
+     * that scope's owners publish under it, which is the whole offline publisher
+     * argument the feed can make. The gate holds the two fields together; the
+     * verdict itself reads the name, because the name already carries the scope.
+     */
+    readonly scope: string;
+    /** The exact version. Ranges are rejected by the gate, never resolved here. */
+    readonly version: string;
+}
+export interface FirstPartyFeed {
+    readonly feedVersion: 1;
+    readonly entries: readonly FirstPartyEntry[];
+}
+/** Why an artifact is not on the feed. Every value is a fail-closed answer. */
+export type FirstPartyReason = 
+/** The feed file is missing or unreadable: nothing can be vouched for. */
+'no-feed'
+/** The spec named no package (a path, a git URL the upstream left unnamed). */
+ | 'unidentified'
+/** The feed carries entries, but not this name. */
+ | 'not-listed'
+/** The name is listed, but not at this exact version (or at no version). */
+ | 'version-mismatch'
+/**
+ * The artifact is not a published one: a directory, tarball or git checkout
+ * can call itself anything, and its manifest is the artifact vouching for
+ * itself. The feed lists what we published, so it has nothing to say here.
+ */
+ | 'unverifiable-source';
+export type FirstPartyVerdict = {
+    readonly kind: 'first-party';
+    readonly entry: FirstPartyEntry;
+    /**
+     * The provenance seam. Any future source of publisher identity starts
+     * here: an answer that contradicts {@link entry} must demote this verdict
+     * to the third-party branch (one vote to veto); it may never upgrade a
+     * third-party verdict to this one.
+     */
+    readonly corroboration: 'unavailable';
+} | {
+    readonly kind: 'third-party';
+    readonly reason: FirstPartyReason;
+    /** What the loader said when the feed itself was the problem. */
+    readonly detail?: string;
+};
+/** The feed as the loader found it: present and shaped, or not usable at all. */
+export type FirstPartyFeedLoad = {
+    readonly kind: 'ok';
+    readonly path: string;
+    readonly feed: FirstPartyFeed;
+} | {
+    readonly kind: 'unavailable';
+    readonly reason: string;
+};
+/**
+ * Where the feed lives, in both the `src/` (tsx) and the compiled npm layouts —
+ * the same pair `packagedPresetRoot()` uses, for the same reason.
+ */
+export declare function firstPartyFeedCandidates(moduleUrl?: string): string[];
+/**
+ * Read the shipped feed. Tolerant about the world, strict about the file: an
+ * absent, unreadable, unparsable or unrecognized feed answers `unavailable`
+ * with a readable reason, and never throws — the caller decides what to say
+ * and always falls back to "third-party".
+ */
+export declare function loadFirstPartyFeed(moduleUrl?: string): FirstPartyFeedLoad;
+/**
+ * Whether an artifact is the exact one the feed pins. Pure: the feed is an
+ * argument, so a caller can answer the same question for a fixture, and the
+ * gate can drive every branch without a filesystem.
+ *
+ * Only a registry artifact can be first-party. A directory or git checkout is
+ * inspected from the manifest it ships, so treating its `name`/`version` as
+ * evidence would let whoever wrote that directory claim any feed entry and skip
+ * the trust confirmation — the one decision this verdict makes.
+ */
+export declare function firstPartyVerdict(load: FirstPartyFeedLoad, artifact: {
+    readonly name?: string | undefined;
+    readonly version?: string | undefined;
+    readonly kind?: string | undefined;
+}): FirstPartyVerdict;
+//# sourceMappingURL=plugin-feed.d.ts.map

package/lib/types/dsh-adapter/plugin-feed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-feed.d.ts","sourceRoot":"","sources":["../../../src/dsh-adapter/plugin-feed.ts"],"names":[],"mappings":"AAmCA,sDAAsD;AACtD,eAAO,MAAM,qBAAqB,sCAAsC,CAAA;AAExE,sEAAsE;AACtE,MAAM,WAAW,eAAe;IAC9B;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,+EAA+E;IAC/E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,WAAW,EAAE,CAAC,CAAA;IACvB,QAAQ,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,CAAA;CAC7C;AAED,+EAA+E;AAC/E,MAAM,MAAM,gBAAgB;AAC1B,0EAA0E;AACxE,SAAS;AACX,+EAA+E;GAC7E,cAAc;AAChB,mDAAmD;GACjD,YAAY;AACd,4EAA4E;GAC1E,kBAAkB;AACpB;;;;GAIG;GACD,qBAAqB,CAAA;AAEzB,MAAM,MAAM,iBAAiB,GACzB;IACA,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAA;IAC5B,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAA;IAC/B;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAA;CACtC,GACC;IACA,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAA;IAC5B,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAA;IACjC,iEAAiE;IACjE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CACzB,CAAA;AAEH,iFAAiF;AACjF,MAAM,MAAM,kBAAkB,GAC1B;IAAE,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAA;CAAE,GAC7E;IAAE,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AAE7D;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,GAAE,MAAwB,GAAG,MAAM,EAAE,CAGtF;AAgBD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,GAAE,MAAwB,GAAG,kBAAkB,CAgC1F;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,kBAAkB,EACxB,QAAQ,EAAE;IAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,GAC1H,iBAAiB,CASnB"}

package/lib/types/dsh-adapter/plugin-feed.js

@@ -0,0 +1,135 @@
+/**
+ * The first-party feed: the curated list of plugin packages this project
+ * publishes, pinned per release (Stage C-4; the file's own README is
+ * `tui-profile/feed/README.md`).
+ *
+ * The feed is a packaged **data** file, not a protocol artifact. It answers one
+ * question for gate 3's trust routing — "is this exact artifact one we
+ * published?" — offline, with no registry round trip. It never replaces the
+ * admission registry (`tui-profile/registry/`); a miss only means the caller
+ * asks the person to confirm, which is what any third-party install does.
+ *
+ * Two policies here are deliberate:
+ *
+ * - A missing or malformed file is NOT the same as "no entry matched". The
+ *   loader answers `unavailable` with a reason, so a caller can say what is
+ *   wrong instead of quietly trusting everything — or refusing everything
+ *   without saying why. (A silent `undefined`, the `loadSpecData()` posture, is
+ *   the anti-pattern this avoids: for a trust input, "absent" and "unreadable"
+ *   must stay distinguishable.)
+ * - Every uncertain answer is third-party (fail closed). A spec without a
+ *   version resolves to "latest" at install time, which is not the artifact the
+ *   feed pinned, so that is a version mismatch rather than a hit.
+ *
+ * Provenance is a seam, not an implementation: the host service's published
+ * surface carries no provenance/publisher/attestation API at all, and this
+ * package has no registry client, so the first-party branch records
+ * `corroboration: 'unavailable'`. The rule that keeps the seam honest — a
+ * source that ever contradicts an entry must demote the verdict to
+ * third-party (one vote to veto, never a vote to allow) — is written down in
+ * the feed README and `tui-profile/notes/0009-backend-contribution.md`.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/** The shipped feed, relative to the package root. */
+export const FIRST_PARTY_FEED_FILE = 'tui-profile/feed/first-party.json';
+/**
+ * Where the feed lives, in both the `src/` (tsx) and the compiled npm layouts —
+ * the same pair `packagedPresetRoot()` uses, for the same reason.
+ */
+export function firstPartyFeedCandidates(moduleUrl = import.meta.url) {
+    const directory = dirname(fileURLToPath(moduleUrl));
+    return [join(directory, '../../', FIRST_PARTY_FEED_FILE), join(directory, '../../../', FIRST_PARTY_FEED_FILE)];
+}
+/** One entry, structurally. `undefined` for anything the feed must not carry. */
+function asEntry(value) {
+    if (typeof value !== 'object' || value === null)
+        return undefined;
+    const record = value;
+    const keys = Object.keys(record);
+    if (keys.length !== 3 || !keys.includes('name') || !keys.includes('scope') || !keys.includes('version'))
+        return undefined;
+    const { name, scope, version } = record;
+    if (typeof name !== 'string' || name.length === 0)
+        return undefined;
+    if (typeof scope !== 'string' || scope.length === 0)
+        return undefined;
+    if (typeof version !== 'string' || version.length === 0)
+        return undefined;
+    if (!/^@[^/]+\/[^/]+$/u.test(name) || scope !== name.slice(0, name.indexOf('/')))
+        return undefined;
+    return { name, scope, version };
+}
+/**
+ * Read the shipped feed. Tolerant about the world, strict about the file: an
+ * absent, unreadable, unparsable or unrecognized feed answers `unavailable`
+ * with a readable reason, and never throws — the caller decides what to say
+ * and always falls back to "third-party".
+ */
+export function loadFirstPartyFeed(moduleUrl = import.meta.url) {
+    const candidates = firstPartyFeedCandidates(moduleUrl);
+    const path = candidates.find(candidate => existsSync(candidate));
+    if (path === undefined)
+        return { kind: 'unavailable', reason: `feed file is missing (checked ${candidates.join(', ')})` };
+    let source;
+    try {
+        source = readFileSync(path, 'utf8');
+    }
+    catch (error) {
+        return { kind: 'unavailable', reason: `feed file is unreadable: ${error instanceof Error ? error.message : String(error)}` };
+    }
+    let value;
+    try {
+        value = JSON.parse(source);
+    }
+    catch (error) {
+        return { kind: 'unavailable', reason: `feed file is not JSON: ${error instanceof Error ? error.message : String(error)}` };
+    }
+    if (typeof value !== 'object' || value === null)
+        return { kind: 'unavailable', reason: 'feed file is not an object' };
+    const record = value;
+    const keys = Object.keys(record);
+    if (keys.length !== 2 || !keys.includes('feedVersion') || !keys.includes('entries')) {
+        return { kind: 'unavailable', reason: `feed file carries unexpected top-level fields: ${keys.join(', ')}` };
+    }
+    if (record.feedVersion !== 1)
+        return { kind: 'unavailable', reason: `feed file has an unknown feedVersion: ${String(record.feedVersion)}` };
+    if (!Array.isArray(record.entries))
+        return { kind: 'unavailable', reason: 'feed file entries is not an array' };
+    const entries = [];
+    for (const candidate of record.entries) {
+        const entry = asEntry(candidate);
+        if (entry === undefined)
+            return { kind: 'unavailable', reason: `feed file carries an unrecognized entry: ${JSON.stringify(candidate)}` };
+        entries.push(entry);
+    }
+    if (entries.length === 0)
+        return { kind: 'unavailable', reason: 'feed file carries no entries' };
+    return { kind: 'ok', path, feed: { feedVersion: 1, entries } };
+}
+/**
+ * Whether an artifact is the exact one the feed pins. Pure: the feed is an
+ * argument, so a caller can answer the same question for a fixture, and the
+ * gate can drive every branch without a filesystem.
+ *
+ * Only a registry artifact can be first-party. A directory or git checkout is
+ * inspected from the manifest it ships, so treating its `name`/`version` as
+ * evidence would let whoever wrote that directory claim any feed entry and skip
+ * the trust confirmation — the one decision this verdict makes.
+ */
+export function firstPartyVerdict(load, artifact) {
+    if (load.kind !== 'ok')
+        return { kind: 'third-party', reason: 'no-feed', detail: load.reason };
+    if (artifact.kind !== undefined && artifact.kind !== 'registry')
+        return { kind: 'third-party', reason: 'unverifiable-source' };
+    const name = artifact.name;
+    if (typeof name !== 'string' || name.length === 0)
+        return { kind: 'third-party', reason: 'unidentified' };
+    const entry = load.feed.entries.find(candidate => candidate.name === name);
+    if (entry === undefined)
+        return { kind: 'third-party', reason: 'not-listed' };
+    if (artifact.version !== entry.version)
+        return { kind: 'third-party', reason: 'version-mismatch' };
+    return { kind: 'first-party', entry, corroboration: 'unavailable' };
+}