@avantf/dsh-plugin-base 0.3.1

package/dist/compat.d.ts

@@ -0,0 +1,413 @@
+/**
+ * Every line this module logs carries this token, so a support question can be answered
+ * with one grep of the host log.
+ */
+export declare const COMPAT_PREFIX = "compat:";
+/** What the gate needs from a live context: one service lookup. Cordis's `Context` satisfies it. */
+export interface CompatContext {
+    get(name: string): unknown;
+}
+/** One service a plugin calls, and the methods it calls on it. */
+export interface ServiceContract {
+    readonly name: string;
+    /**
+     * `true` ⇒ refuse to load when it (or one of its methods) is gone. This is the CALLER's refusal
+     * policy, not cordis's `inject`: cordis has no optional injection, so a service the plugin can
+     * degrade without is read with `ctx.get()` and declared here as `required: false`.
+     */
+    readonly required: boolean;
+    readonly methods: readonly string[];
+}
+/** What a plugin declares about itself, so the rules can stay generic. */
+export interface CompatSpec {
+    /** The plugin's package id: probe keys and the post-registration check are `<id>#<name>`. */
+    readonly packageId: string;
+    readonly services: readonly ServiceContract[];
+    /**
+     * Package released in lockstep with dsh → the version THIS BUILD was compiled against. Feed it
+     * {@link readBuildVersions} over the JSON the build baked next to the entry, with the peer range's
+     * floor ({@link readDeclaredVersions}) as the per-package fallback: a range floor is a lower bound
+     * the artifact tolerates, not "the dsh I built against".
+     */
+    readonly declared: Readonly<Record<string, string | undefined>>;
+    /**
+     * What THIS BUILD's links resolve to, read by the CALLER from its own module URL
+     * (`readRuntimeVersions(packages, import.meta.url)`). It is NOT the host's identity — a plugin
+     * cannot observe that; see the module header. Omitted ⇒ this package resolves them, which is only
+     * as good as the links IT has.
+     */
+    readonly runtime?: Readonly<Record<string, string | undefined>>;
+    /** Whether `ctx.interval` (the timer plugin's effect-scoped timer) is needed. */
+    readonly needsInterval?: boolean;
+    /**
+     * Build the throwaway tool the tools probe registers, e.g.
+     * `toolProbeDeclaration(defineTool)`. Omitted ⇒ that probe is skipped ("not probed", never a break).
+     */
+    readonly probeTool?: () => unknown;
+    /**
+     * Build the throwaway Typert contribution the wire probe registers. **Pass your real declaration**
+     * (`() => myContribution`), so a pass proves the registration you are about to perform. Omitted ⇒
+     * the wire contract is not probed at all (recorded as a note, never a refusal).
+     *
+     * The rule is absolute, and it is not a style note: this package once shipped a MINIMAL stand-in
+     * (one schema, no invocations, no codecs) as the convenient default, and a live 0.1.6 host proved
+     * the cost — the stand-in passed (it carried no codec to validate) while the plugin's REAL
+     * contribution threw on `strict codec has no create() factory` halfway through `apply`. A probe
+     * that is not the real declaration turns "the host API moved" into a half-mounted plugin, which is
+     * the one outcome this gate exists to prevent.
+     */
+    readonly probeTypert?: (packageId: string) => unknown;
+    /** Wire schema names to verify after registration; omitted means "no post-registration check". */
+    readonly schemaNames?: readonly string[];
+    /** Events the plugin listens to. Reported as an unprovable limit, never checked. */
+    readonly events?: readonly string[];
+}
+/** Coarse outcome of one gate run. */
+export type CompatStatus = 'ok' | 'version-mismatch' | 'version-unknown' | 'probe-skipped' | 'probe-failed';
+/** One service as the live context answers for it. */
+export interface ServiceProbe {
+    readonly name: string;
+    readonly required: boolean;
+    readonly present: boolean;
+    /** Methods the plugin calls that the mounted service does not expose. */
+    readonly missing: readonly string[];
+}
+/** One registry probe: what was tried, and what came back. */
+export interface ProbeOutcome {
+    /** The registry exposed the query surface, so the probe actually ran. */
+    readonly ran: boolean;
+    readonly passed: boolean;
+    /** Expected-vs-actual detail, one entry per failed step (empty when it passed). */
+    readonly problems: readonly string[];
+}
+/** One version comparison: what this build was compiled against vs what its own links resolve now. */
+export interface VersionProbe {
+    readonly package: string;
+    /**
+     * The version this build was compiled against: the exact one baked into the build when there is a
+     * `dsh-build.json` next to the entry, else the peer range's floor (`^0.1.5-rc.2` → `0.1.5-rc.2`).
+     */
+    readonly declared: string | undefined;
+    /** What this build's own links resolve to NOW. The host's identity is never observed. */
+    readonly runtime: string | undefined;
+}
+/** Everything the verdict needs, as plain data. */
+export interface CompatEvidence {
+    readonly services: readonly ServiceProbe[];
+    /** `ctx.interval` — the timer plugin's effect-scoped timer, which the sweep may need. */
+    readonly interval: boolean;
+    /** Whether the caller needs that timer (a plugin with no sweep does not). */
+    readonly needsInterval: boolean;
+    readonly toolsProbe: ProbeOutcome | undefined;
+    readonly typertProbe: ProbeOutcome | undefined;
+    readonly versions: readonly VersionProbe[];
+    /** Events the caller listens to; reported as unprovable, never blocking. */
+    readonly events: readonly string[];
+}
+/** One line to log; `error` marks a proven break. */
+export interface CompatLine {
+    readonly level: 'info' | 'warn' | 'error';
+    readonly message: string;
+}
+/** The decision `apply` branches on, plus everything worth printing. */
+export interface CompatVerdict {
+    /** `false` ⇒ refuse to load: register nothing. */
+    readonly load: boolean;
+    /** No active probe could run: the surface checks still happened, but nothing was proven either way. */
+    readonly skipped: boolean;
+    readonly status: CompatStatus;
+    readonly problems: readonly string[];
+    readonly warnings: readonly string[];
+    readonly notes: readonly string[];
+    readonly lines: readonly CompatLine[];
+    /** One line for the `load: false` case (empty otherwise), for an envelope or a command. */
+    readonly reason: string;
+}
+/** Minimal logging surface the caller supplies (the plugin's own logger satisfies it). */
+export interface CompatLogger {
+    info: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
+}
+/**
+ * Turn one declared peer range into the version FLOOR it names.
+ *
+ * The `declared` side's FALLBACK, used only when a build left no baked version
+ * ({@link readBuildVersions}). Only the floor is read — a caret range's upper bound is a promise
+ * about the future, while the floor is the exact release the range was written against.
+ *
+ * Compound ranges are the everyday form (`>=4.4.3 <5`, `>=0.1.5-rc.2 <0.2.0`), so the FIRST
+ * comparator is read and its trailing bounds are ignored: spacing, a `<`/`<=` bound, or a `||`
+ * alternative must not turn a readable floor into `undefined`. A range whose first comparator is
+ * itself an upper bound (`<2.0.0`, `<=2.0.0`), a tag (`latest`), or a protocol (`workspace:`) names
+ * no floor and yields `undefined`, which reports as unverified rather than as a mismatch.
+ * @param range - the peer range as written in `package.json`.
+ * @returns the version, or `undefined` when it cannot be read out.
+ */
+export declare function floorOf(range: string | undefined): string | undefined;
+/**
+ * Read the version FLOORS a caller declares for the packages that identify the host.
+ *
+ * Taken from the caller's own `package.json` peer ranges, so the value travels with the artifact (a
+ * plugin's manifest ships with it) and cannot drift away from the contract it declares. A floor is a
+ * LOWER BOUND, which is why this is the fallback and not the preferred source: it cannot say which
+ * release the artifact was actually compiled against. {@link readBuildVersions} reads that, and falls
+ * back to these floors only for packages its build did not bake.
+ * @param manifestUrl - the caller's `package.json` (`new URL('../package.json', import.meta.url)`).
+ * @param packages - the packages to read, usually `['@deepseek-ai/dsh-tools', ...]`.
+ * @returns one entry per package; `undefined` means the manifest declares nothing for it.
+ */
+export declare function readDeclaredVersions(manifestUrl: string | URL, packages: readonly string[]): Record<string, string | undefined>;
+/**
+ * The file a build bakes its exact versions into, next to the built entry.
+ *
+ * Named once here so the producer (a repo's build script) and the consumer (its `provision.ts`)
+ * cannot disagree about where it lives. It is a plain JSON object of `package → version`.
+ */
+export declare const BUILD_VERSIONS_FILE = "dsh-build.json";
+/**
+ * Read the exact versions THIS BUILD was compiled against, out of the JSON its build emitted.
+ *
+ * The `declared` side's PREFERRED source. A peer range only records a floor — the lowest release the
+ * artifact tolerates — so after an in-place upgrade of the installed dsh it says nothing about the
+ * copy this build actually linked and compiled against, and the comparison degrades to a weak one.
+ * The build knows that copy exactly, so it bakes it next to the entry (`lib/dsh-build.json`) and this
+ * reads it back from `new URL('./dsh-build.json', import.meta.url)`.
+ *
+ * The file is OPTIONAL by design: a dev tree, a test run and a build made before this file existed
+ * all lack it, and none of them may crash or invent a version. The fallback is per PACKAGE rather
+ * than all-or-nothing, so a partially written file still reports honestly for the entries it has.
+ * @param buildUrl - where the build wrote the JSON (`new URL('./dsh-build.json', import.meta.url)`).
+ * @param packages - the packages to read, usually `['@deepseek-ai/dsh-tools', ...]`.
+ * @param fallback - per-package value for entries the file has none for (the peer floors).
+ * @returns one entry per package; `undefined` means neither source has a version.
+ */
+export declare function readBuildVersions(buildUrl: string | URL, packages: readonly string[], fallback?: Readonly<Record<string, string | undefined>>): Record<string, string | undefined>;
+/**
+ * Resolve the version of a peer copy THIS BUILD's links point at.
+ *
+ * This is the `runtime` side: it answers "what do this artifact's own links resolve to", NOT "which
+ * host is running". The two coincide when the plugin shares the host's copy, and diverge whenever
+ * the links point elsewhere — a checkout host loading a plugin linked to an installed dsh is the
+ * everyday case. Nothing inside a plugin can observe the host's own version (no dsh service exposes
+ * it), so the log wording never claims to; see `README.md` «已知边界».
+ *
+ * A plugin cannot resolve `@deepseek-ai/dsh/package.json` (the core package is not in its
+ * `node_modules`), but the packages below ship in lockstep with it and ARE resolvable
+ * through the same links the rest of the plugin uses. Any failure is "unknown", never a
+ * throw.
+ * `base` decides WHOSE links are used. It defaults to this package, which is right when this package
+ * is the only consumer — but a plugin should pass its own `import.meta.url`: the packages that
+ * identify the host are ITS peers, and the shared package may not be able to see all of them.
+ * @param name - the peer package.
+ * @param base - module URL to resolve from (defaults to this package).
+ * @returns the version string, or `undefined`.
+ */
+export declare function resolveRuntimeVersion(name: string, base?: string | URL): string | undefined;
+/**
+ * Ask the live context for one entry per declared service.
+ *
+ * A service that is present but missing a method the caller declared is a BREAK, not a note: the
+ * caller's code will call it. A service that is absent is a problem only when it is required.
+ * @param ctx - the live context (structural).
+ * @param contracts - what the caller calls.
+ * @returns one probe per contract.
+ */
+export declare function checkServices(ctx: CompatContext, contracts: readonly ServiceContract[]): ServiceProbe[];
+/** Whether the timer plugin's effect-scoped timer is reachable as `ctx.interval`. */
+export declare function checkInterval(ctx: CompatContext): boolean;
+/**
+ * The throwaway tool the probe registers: the same declaration shape `tools.ts` uses,
+ * including the `output` contract the model-facing render depends on.
+ *
+ * Withdrawn in `finally`, so a successful probe leaves the registry exactly as it found
+ * it (a failed withdrawal would show up as a tenth tool in the mount smoke).
+ */
+export declare const COMPAT_PROBE_TOOL = "__dshCompatProbe";
+/**
+ * The caller's declaration helper, typed loosely on purpose: naming `@deepseek-ai/dsh-tools`'s own
+ * options type here is exactly the compile-time dependency on a dsh version this package avoids. The
+ * literal below is verified against the REAL registry by this package's tests, so a wrong shape fails
+ * there rather than silently.
+ */
+export type ToolDeclarationHelper = (options: any) => unknown;
+/**
+ * Build the tools-probe declaration from the CALLER's own declaration helper.
+ *
+ * The helper is injected rather than imported on purpose. This package is a base module: pinning a
+ * dsh version would make it stale with every dsh release, and a dsh-free source is what lets one copy
+ * serve every plugin. The caller also happens to be the right owner — the probe must mirror the
+ * declaration path the caller's REAL tools use, and only the caller has that helper.
+ * @param defineTool - the caller's `defineTool` (from its own `@deepseek-ai/dsh-tools`).
+ * @returns a zero-argument builder for `CompatSpec.probeTool`.
+ */
+export declare function toolProbeDeclaration(defineTool: ToolDeclarationHelper): () => unknown;
+/**
+ * Register the probe tool, check the registry kept it, and withdraw it.
+ *
+ * What this proves that a method-presence check cannot: the registry ACCEPTED our
+ * declaration shape and still lists it. It is the difference between "`register` is a
+ * function" and "registering what we register works".
+ * @param registry - `ctx.tools`.
+ * @returns the outcome; never throws.
+ */
+export declare function probeToolsRegistry(registry: unknown, buildProbe: (() => unknown) | undefined): ProbeOutcome;
+/**
+ * Register the caller's Typert declaration, verify the query surface, and withdraw it.
+ *
+ * The schema is a LIVE zod object, which is the point: `toJSONSchema` runs the HOST's
+ * projector over OUR schema, the cross-copy step that breaks when the codec contract
+ * moves (`TypertSchema{schema}` → `TypertSchemaFactory{create}` did exactly this once).
+ * What is verified — the schema names AND the package face — is read off the declaration, so
+ * handing over the real contribution makes a pass mean "the real registration will land too".
+ * @param registry - `ctx.typert`.
+ * @param packageId - this plugin's package id, which the probe key is built from.
+ * @returns the outcome; never throws.
+ */
+export declare function probeTypertRegistry(registry: unknown, packageId: string, buildProbe: ((packageId: string) => unknown) | undefined): ProbeOutcome;
+/**
+ * Resolve several versions at once, from one caller's links.
+ *
+ * "From one caller's links" is the whole boundary: these are the versions that caller resolves, not
+ * the host's. Pass the caller's own `import.meta.url` so the answer covers its peers.
+ * @param packages - the packages to resolve.
+ * @param base - module URL to resolve from (defaults to this package).
+ * @returns one entry per package; `undefined` means it could not be resolved.
+ */
+export declare function readRuntimeVersions(packages: readonly string[], base?: string | URL): Record<string, string | undefined>;
+/**
+ * Read a live context into the plain evidence the rules consume.
+ *
+ * The probes are throwaway declarations shaped like the real ones: "`register` is a function" and
+ * "registering what we register works" are different claims, and only the second one catches a
+ * moved contract.
+ * @param ctx - the live context (structural: only `get` is used).
+ * @param spec - what the caller declared about itself.
+ * @returns the evidence.
+ */
+export declare function gatherEvidence(ctx: CompatContext, spec: CompatSpec): CompatEvidence;
+/**
+ * The rule set: plain evidence in, decision plus log lines out.
+ *
+ * Kept pure so every branch — including the ones a live host cannot be made to produce —
+ * is unit-tested without a Context.
+ *
+ * Logging policy, so a healthy mount stays one line: warnings and problems are always
+ * logged, and everything merely UNDETERMINABLE lands in `notes` — returned for tests and
+ * support, not printed. A note is not a finding; the plugin that cannot probe a registry
+ * still says so in the verdict the caller holds.
+ * @param evidence - what {@link gatherEvidence} observed.
+ * @returns the verdict.
+ */
+export declare function verdictOf(evidence: CompatEvidence): CompatVerdict;
+/**
+ * Run the check against a live context and log every line.
+ *
+ * Call this FIRST in `apply()`: on a refusal nothing has been registered yet, so "do not
+ * load" costs nothing to unwind. Never throws — a check that cannot be performed leaves
+ * the plugin loading, because "cannot tell" is not "incompatible".
+ * @param ctx - the plugin's context.
+ * @param log - the plugin's logger.
+ * @returns the verdict `apply` branches on.
+ */
+export declare function provision(ctx: CompatContext, log: CompatLogger, spec: CompatSpec): CompatVerdict;
+/**
+ * The caller's copy for {@link compatReport}: the STRUCTURE is the base's, every string is the
+ * caller's (see the function's note). Exported so the interface type
+ * (`BaseRuntimeV1.compatReport`) can name the same shape the implementation takes — a second,
+ * structurally-identical declaration would be exactly the kind of drift the interface snapshot exists
+ * to catch.
+ */
+export interface CompatReportWords {
+    readonly heading: string;
+    readonly fix: string;
+    readonly warningsLabel: string;
+    readonly warnings: readonly string[];
+    /**
+     * Optional because base is a published package: a plugin compiled against an earlier base does not
+     * pass it, and the honest result is no tail line at all rather than one in a language it never
+     * chose.
+     */
+    readonly logPointer?: (prefix: string) => string;
+}
+/**
+ * Build the standard refusal report, so every plugin says the same thing in its own words.
+ *
+ * The STRUCTURE belongs here (heading, problems, warnings, the fix, where the full log is); the
+ * wording belongs to the caller, which passes every string in its own language. That includes the
+ * last line — this used to be a hardcoded Chinese sentence, which meant a caller that had translated
+ * everything else still got half a sentence in a language it never chose.
+ *
+ * `logPointer` is OPTIONAL because base is a published package: a plugin compiled against an earlier
+ * base does not pass it, and the honest result for that caller is no tail line at all rather than one
+ * in the wrong language.
+ * @param verdict - the refusal to report.
+ * @param words - the caller's copy.
+ * @param words.logPointer - the caller's sentence for "the full diagnostics are the log lines that
+ *   start with `<prefix>`"; receive the prefix so the sentence can place it naturally.
+ * @returns the report text.
+ */
+export declare function compatReport(verdict: CompatVerdict, words: CompatReportWords): string;
+/**
+ * Keep one megaphone when a plugin refuses to load.
+ *
+ * Registering a command in a broken host is a judgment call: the plugin provides nothing else, and
+ * the alternative is a user watching a surface that says "not available" with no way to ask why. A
+ * host too broken to register one leaves the log as the only channel — which must not throw either.
+ * @param input - the context, the logger, the command to register, and the text it should print.
+ */
+export declare function registerMegaphone(input: {
+    readonly ctx: CompatContext;
+    readonly log: CompatLogger;
+    readonly command: {
+        readonly name: string;
+        readonly description: string;
+    };
+    readonly text: string;
+}): void;
+/**
+ * The schema names a Typert contribution declares, read from the contribution itself.
+ *
+ * Derived, never hardcoded: a schema added to a wire face must widen the post-registration check on
+ * its own.
+ * @param contribution - the object passed to `register` (`{ schemas: [{ name }] }`).
+ * @returns the names, in declaration order.
+ */
+export declare function schemaNamesFrom(contribution: unknown): string[];
+/**
+ * The registry keys those names become: `<packageId>#<name>`.
+ * @param packageId - the contributing package.
+ * @param names - the schema names.
+ * @returns the keys the registry is expected to list.
+ */
+export declare function declaredSchemaKeys(packageId: string, names: readonly string[]): string[];
+/**
+ * The SECOND phase: after the real faces registered, confirm every one of them is visible.
+ *
+ * The pre-load probe proves the declaration SHAPE is accepted; it cannot prove that all of the real
+ * registrations landed. A silently dropped schema or tool fails exactly the way this whole module
+ * exists to prevent — the panel renders nothing, or the model never sees a tool — with no error
+ * anywhere. So the keys are counted by EXACT key after registration (never by a bare total, which
+ * an un-withdrawn probe would inflate) and every tool name is read back.
+ *
+ * Warn-only, for the reason the memory plugin records for its own post-registration count: by now
+ * the plugin is mounted, so there is no clean "do not load" left to take. Silent when everything is
+ * there — a healthy boot keeps its single `compat: ok` line.
+ *
+ * Known limit: invocation ENDPOINTS are not observable through the documented query surface
+ * (`list`/`listPackages` expose schemas and the package model only), so the four descriptors are
+ * covered through the schema keys they use, not counted themselves.
+ * @param input - the live context, the real tool names, and the logger.
+ * @returns the registrations that did not show up (empty on success).
+ */
+export declare function verifyRegisteredFaces(input: {
+    readonly ctx: CompatContext;
+    readonly packageId: string;
+    /** Wire schema names the caller registered; skipped when omitted. */
+    readonly schemaNames?: readonly string[];
+    readonly toolNames: readonly string[];
+    readonly log: CompatLogger;
+}): {
+    readonly missing: readonly string[];
+};
+//# sourceMappingURL=compat.d.ts.map

package/dist/compat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compat.d.ts","sourceRoot":"","sources":["../src/compat.ts"],"names":[],"mappings":"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"}