@wowyuarm/dsh-agent-team 0.1.14 → 0.2.0

package/packages/agent-team/lib/environment-check.js

@@ -0,0 +1,102 @@
+/** The one local environment check: how the running DSH compares to the line this bundle declares. */
+import { evaluatePluginCompatibility, getDshRuntimeVersion } from '@deepseek-ai/dsh-app-boot';
+import { bundleVersionOf, readInstalledManifest } from "./installed-manifest.js";
+/** Prefix of every peer that sits on the DSH version line; the bare scope is not one. */
+const DSH_PEER_PREFIX = '@deepseek-ai/dsh-';
+/** The `>=lower <upper>` shape every DSH peer carries; a comparator series, not a single version. */
+const SUPPORT_RANGE_SHAPE = /^>=(\S+)\s+<(\S+)$/u;
+/**
+ * Read the support line from the installed manifest's DSH peers, or nothing.
+ *
+ * Every `@deepseek-ai/dsh-*` peer must carry exactly the same range, and it must
+ * be a `>=<lower> <upper>` series: the version line is the manifest's own claim
+ * and a partially drifted manifest cannot state one. `scripts/check-version-consistency.mjs`
+ * holds the same shape to the certified baseline, so a run of this bundle
+ * states the same line its README does. Returns `undefined` when the peers
+ * disagree or the shape is unreadable.
+ */
+export function supportRangeOf(manifest) {
+    const fields = manifest;
+    if (typeof fields.peerDependencies !== 'object' || fields.peerDependencies === null)
+        return undefined;
+    const ranges = new Set();
+    for (const [name, range] of Object.entries(fields.peerDependencies)) {
+        if (!name.startsWith(DSH_PEER_PREFIX))
+            continue;
+        if (typeof range !== 'string')
+            return undefined;
+        ranges.add(range);
+    }
+    const distinct = [...ranges];
+    if (distinct.length !== 1)
+        return undefined;
+    const shape = SUPPORT_RANGE_SHAPE.exec(distinct[0]);
+    if (shape === null)
+        return undefined;
+    return Object.freeze({ lower: shape[1], upper: shape[2] });
+}
+/**
+ * Judge one already-resolved triple, so every branch is testable without an
+ * environment. The verdict comes from the Harness's own
+ * `evaluatePluginCompatibility` — the plugin manager decides installability with
+ * that same function, and prerelease ordering is exactly what a hand-written
+ * comparison gets wrong.
+ *
+ * @param manifest - the installed bundle's parsed manifest, the source of the declared support line.
+ * @param runtimeVersion - the running DSH version, or `'unknown'` when it could not be read.
+ * @param bundleVersion - the installed bundle version, or `'unknown'`.
+ * @param unavailable - why the running version is not known, recorded when it is `'unknown'`.
+ * @returns the report the settings page renders.
+ */
+export function evaluateEnvironment(manifest, runtimeVersion, bundleVersion, unavailable) {
+    const range = supportRangeOf(manifest);
+    const base = {
+        bundleVersion,
+        ...(range === undefined ? {} : { certifiedDshVersion: range.lower, supportRange: range }),
+    };
+    if (runtimeVersion === 'unknown') {
+        return Object.freeze({ ...base, verdict: 'undetermined', reason: unavailable ?? 'the running dsh version is unavailable' });
+    }
+    const running = { ...base, dshVersion: runtimeVersion };
+    // A real violation is answered first, and it is never downgraded to
+    // `undetermined`: a peer that drifted to a range of its own is a genuine
+    // "not satisfied" even though no single range can then be stated for the
+    // page. Only when nothing is violated does the question become whether the
+    // declared line can be stated at all.
+    // One evaluation covers every dsh peer in the manifest, and `range` above is
+    // derived from exactly those peers: re-judging the range it prints could not
+    // change this answer.
+    const satisfied = evaluatePluginCompatibility(manifest, {}, runtimeVersion) === undefined;
+    if (!satisfied)
+        return Object.freeze({ ...running, verdict: 'out-of-range' });
+    // Nothing is violated but there is no line to state: the page withholds the
+    // range rather than inventing one.
+    if (range === undefined) {
+        return Object.freeze({ ...base, verdict: 'undetermined', reason: 'the declared dsh support range is unreadable or drifted' });
+    }
+    return Object.freeze({ ...running, verdict: 'ok' });
+}
+/**
+ * Read this Host's own environment: the installed bundle version, the declared
+ * support line, and how the running DSH compares to it.
+ *
+ * The certified DSH version is the range's lower bound, never the newest cut
+ * tested against it: `docs/dsh-release-compatibility.md` §4 records a baseline
+ * inside the declared range without moving the peers, so every version spot
+ * keeps naming the bound. Reading it from anywhere else would reintroduce the
+ * hand-maintained constant this check exists to remove.
+ *
+ * @returns the report, with `verdict: 'undetermined'` for any fact not established.
+ */
+export function reportEnvironment() {
+    const manifest = readInstalledManifest() ?? {};
+    const bundleVersion = bundleVersionOf(manifest);
+    let runtime;
+    try {
+        runtime = getDshRuntimeVersion();
+    }
+    catch (error) {
+        return evaluateEnvironment(manifest, 'unknown', bundleVersion, error instanceof Error ? error.message : String(error));
+    }
+    return evaluateEnvironment(manifest, runtime, bundleVersion);
+}

package/packages/agent-team/lib/human-profile.js

@@ -1,33 +1,65 @@
 import z from '@deepseek-ai/schemastery';
+import { parse } from 'yaml';
+import { bundleVersionOf, readInstalledManifest } from "./installed-manifest.js";
 /**
  * Human identity profile: the one configurable display name plus the avatar
  * reference. `member:human` stays the durable identity everywhere; only the
  * handle shown in team_view, @ matching, and UI follows this profile.
  *
  * Storage split (see spec.md v1):
- * - name + avatarRef live in the Host settings namespace `agent-team-human`
- *   (settings.yaml user layer, live through `ctx.settings`).
- * - avatar bytes live under a persistent directory below; the settings
- *   document holds only the reference, never a data URL. The composer
- *   attachment cache is TTL-bound and must not hold avatar bytes.
+ * - name + avatarRef are the Team Host row's own Config, so they live in the
+ *   active profile's patch document as that row's `config` and the settings
+ *   service derives their form from this schema. rc.1 derives every form from
+ *   a plugin's Config, so the retired `installSection` namespace — a section of
+ *   its own — has no counterpart; the row id below is the settings namespace.
+ * - avatar bytes live under a persistent directory below; the profile holds
+ *   only the reference, never a data URL. The composer attachment cache is
+ *   TTL-bound and must not hold avatar bytes.
+ *
+ * The legacy-section adoption below is transitional: it exists for installs
+ * upgraded from a pre-rc.1 profile document, and retires — with
+ * `LEGACY_HUMAN_PROFILE_SECTION`, `parseLegacyHumanProfile`, and
+ * `planLegacyAdoption` — once such installs are no longer supported. Nothing
+ * else in the Host reads that document.
+ */
+/**
+ * Settings namespace of the Human profile: the Team Host row's id in
+ * `cordis.patch.yml`, which is what the settings service addresses a form and a
+ * write by AND the id the profile-document write patches. It is addressed by
+ * this constant, never by the running Host's `ctx.fiber.entry`: a Remote call
+ * runs under its caller's context, so that lookup names the RPC gateway's row.
+ * `shipping.spec.ts` pins the constant to the row the composition declares.
  */
-export const HUMAN_PROFILE_SETTINGS_NAMESPACE = 'agent-team-human';
+export const HUMAN_PROFILE_SETTINGS_NAMESPACE = 'wowyuarm-agent-team-host';
 /** Fallback display name before any user override is stored. */
 export const HUMAN_PROFILE_DEFAULT_NAME = 'human';
 /** Repository home for the version footnote link. */
 export const HUMAN_PROFILE_REPO_URL = 'https://github.com/wowyuarm/dsh-agent-team';
 /**
- * Bundle version shown in the settings footnote. Kept in sync with the root
- * package.json by hand until the Host build injects it; the footnote is
- * informational only and never gates behavior.
+ * Bundle version shown in the settings footnote, and the current side of the
+ * update check: the version of the package THIS Host runs from — the installed
+ * manifest's, read once at load through `./installed-manifest.ts`, so a `link:`
+ * checkout under the development profile and a registry tarball under stable
+ * each state their own truth. It is not a hand-maintained string: the 0.1.14
+ * bundle shipped with `0.1.13` written in it, which made the footnote name the
+ * previous release and the update check offer the release the user already had.
+ *
+ * An unreadable or malformed manifest degrades to `'unknown'`: the Remote's
+ * `version: string` contract holds and the update comparison simply compares
+ * nothing. The footnote is informational only and never gates behavior.
+ */
+export const HUMAN_PROFILE_VERSION = bundleVersionOf(readInstalledManifest());
+/**
+ * Schemastery schema of the Human profile: the Team Host row's Config. Both
+ * fields are volatile, which is what lets an edit reach the running Host
+ * without remounting it — and what makes the settings service derive a form
+ * from this schema at all.
  */
-export const HUMAN_PROFILE_VERSION = '0.1.13';
-/** Schemastery schema resolving the `agent-team-human` namespace value. */
 export const HUMAN_PROFILE_SETTINGS_SCHEMA = z.object({
-    name: z.string().default(HUMAN_PROFILE_DEFAULT_NAME),
+    name: z.string().default(HUMAN_PROFILE_DEFAULT_NAME).volatile(),
     // Schemastery fields are optional unless `.required()`: a missing avatarRef
     // simply resolves absent, which the profile reads as "no custom avatar".
-    avatarRef: z.string(),
+    avatarRef: z.string().volatile(),
 });
 /** Normalize one candidate display name the way Member handles normalize. */
 export function normalizeHumanName(raw) {
@@ -44,3 +76,68 @@ export function assertValidHumanName(raw) {
         throw new Error('human name must not be empty');
     return name;
 }
+/**
+ * The retired settings section this profile's facts lived in before rc.1.
+ * rc.1 derives every settings form from a plugin's Config, and its legacy
+ * `settings.yaml` importer maps a section to a composition entry id through a
+ * closed built-in list — this third-party section matches nothing there, so
+ * the import rejects it and the values survive only in the renamed document.
+ * This Host owns the section, so adopting what is left belongs here.
+ */
+export const LEGACY_HUMAN_PROFILE_SECTION = 'agent-team-human';
+/**
+ * Read the legacy section out of one legacy settings document. An
+ * unparsable document or a missing section means "nothing to adopt" rather
+ * than an error — the file is retired input, not an authority — and each
+ * field is validated independently so one bad field never costs the other.
+ */
+export function parseLegacyHumanProfile(yamlText) {
+    let document;
+    try {
+        document = parse(yamlText);
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof document !== 'object' || document === null)
+        return undefined;
+    const section = document[LEGACY_HUMAN_PROFILE_SECTION];
+    if (typeof section !== 'object' || section === null)
+        return undefined;
+    const fields = section;
+    let name;
+    if (typeof fields.name === 'string') {
+        try {
+            name = assertValidHumanName(fields.name);
+        }
+        catch {
+            name = undefined;
+        }
+    }
+    const avatarRef = typeof fields.avatarRef === 'string' && fields.avatarRef.trim() !== ''
+        ? fields.avatarRef.trim()
+        : undefined;
+    if (name === undefined && avatarRef === undefined)
+        return undefined;
+    return { ...(name === undefined ? {} : { name }), ...(avatarRef === undefined ? {} : { avatarRef }) };
+}
+/**
+ * Decide what adoption may write: nothing unless the stored profile is still
+ * the pristine default, so a value the Human re-entered after the upgrade
+ * always wins, and never the legacy default name itself. The current profile
+ * carries explicit `undefined` on `avatarRef` — the Host getter spreads the
+ * live Config read — and that shape does not satisfy the optional-property
+ * form under exactOptionalPropertyTypes; taking it directly keeps the Host
+ * call cast-free. The returned fields are exactly the ops the profile page
+ * would have written; byte existence for `avatarRef` is the caller's I/O and
+ * must already hold.
+ */
+export function planLegacyAdoption(current, legacy) {
+    if (current.name !== HUMAN_PROFILE_DEFAULT_NAME || current.avatarRef !== undefined)
+        return undefined;
+    const name = legacy.name !== undefined && legacy.name !== HUMAN_PROFILE_DEFAULT_NAME ? legacy.name : undefined;
+    const avatarRef = legacy.avatarRef;
+    if (name === undefined && avatarRef === undefined)
+        return undefined;
+    return { ...(name === undefined ? {} : { name }), ...(avatarRef === undefined ? {} : { avatarRef }) };
+}