@linxin666/dsh-pet 0.1.1 → 0.1.3

package/lib/types/routes.js

@@ -0,0 +1,158 @@
+/**
+ * Pet HTTP routes — the browser half talks to the host through plain
+ * same-origin JSON endpoints (`/api/pet/*`) and loads the whale-girl atlas
+ * from `/pet/whale/*`. The `/plugins/` endpoint only serves client bundles
+ * and RPC domains are platform-registered, so the pet serves its own API
+ * and media — the same pattern as dsh-remote-web-ui's `/api/pair` family.
+ * @module @linxin666/dsh-pet/routes
+ */
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/** Browser-facing base path of the pet API. */
+export const PET_API_PREFIX = '/api/pet';
+/** Browser-facing base path of the pet asset routes. */
+export const PET_ASSET_PREFIX = '/pet/whale';
+/** Relative (to package root) asset files exposed under the prefix. */
+const ASSET_FILES = [
+    { name: 'spritesheet.webp', mime: 'image/webp' },
+    { name: 'pet.json', mime: 'application/json' },
+];
+/** Absolute package root, resolved from this module's own location (lib/). */
+export function petPackageRoot(importMetaUrl) {
+    return fileURLToPath(new URL('../', importMetaUrl));
+}
+/** Write one JSON response. */
+function json(res, status, body) {
+    res.writeHead(status, { 'content-type': 'application/json; charset=utf-8' });
+    res.end(JSON.stringify(body));
+}
+/** Require the method or answer 405. */
+function requireMethod(req, res, method) {
+    if (req.method === method)
+        return true;
+    json(res, 405, { ok: false, error: 'method-not-allowed' });
+    return false;
+}
+/** Read a JSON request body (bounded). */
+function readJsonBody(req) {
+    return new Promise((resolve, reject) => {
+        let size = 0;
+        const chunks = [];
+        req.on('data', (chunk) => {
+            size += chunk.length;
+            if (size > 64 * 1024) {
+                // Reject first so the error handler can write the 400 response,
+                // then close the connection once the response is flushed.
+                reject(new Error('body-too-large'));
+                queueMicrotask(() => req.destroy());
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on('end', () => {
+            if (chunks.length === 0) {
+                resolve({});
+                return;
+            }
+            try {
+                resolve(JSON.parse(Buffer.concat(chunks).toString('utf8')));
+            }
+            catch {
+                reject(new Error('invalid-json'));
+            }
+        });
+        req.on('error', reject);
+    });
+}
+/** Wrap one async service call as a GET JSON route. */
+function getRoute(path, run) {
+    return {
+        kind: 'exact',
+        path,
+        handler: (req, res) => {
+            if (!requireMethod(req, res, 'GET'))
+                return;
+            run().then((value) => json(res, 200, value), (error) => {
+                json(res, 500, { ok: false, error: error instanceof Error ? error.message : String(error) });
+            });
+        },
+    };
+}
+/** Wrap one async service call as a POST JSON route (body passed through). */
+function postRoute(path, run) {
+    return {
+        kind: 'exact',
+        path,
+        handler: (req, res) => {
+            if (!requireMethod(req, res, 'POST'))
+                return Promise.resolve();
+            return readJsonBody(req).then((body) => {
+                const record = (typeof body === 'object' && body !== null) ? body : {};
+                return run(record).then((value) => json(res, 200, value), (error) => {
+                    json(res, 400, { ok: false, error: error instanceof Error ? error.message : String(error) });
+                });
+            }, (error) => {
+                json(res, 400, { ok: false, error: error instanceof Error ? error.message : String(error) });
+            });
+        },
+    };
+}
+/** Build the full route family (API + assets) for one service + package root. */
+export function makePetRoutes(deps) {
+    const { service, packageRoot } = deps;
+    const apiRoutes = [
+        getRoute(`${PET_API_PREFIX}/state`, () => service.state()),
+        postRoute(`${PET_API_PREFIX}/interact`, (body) => {
+            const kind = body.kind;
+            if (kind !== 'pet' && kind !== 'feed')
+                return Promise.reject(new Error('invalid-kind'));
+            return service.interact(kind);
+        }),
+        postRoute(`${PET_API_PREFIX}/set-visible`, (body) => {
+            const visible = body.visible;
+            if (typeof visible !== 'boolean')
+                return Promise.reject(new Error('invalid-visible'));
+            return service.setVisible(visible);
+        }),
+        postRoute(`${PET_API_PREFIX}/set-config`, (body) => service.setConfig({
+            ...(typeof body.size === 'number' ? { size: body.size } : {}),
+            ...(typeof body.right === 'number' ? { right: body.right } : {}),
+            ...(typeof body.bottom === 'number' ? { bottom: body.bottom } : {}),
+            ...(typeof body.visible === 'boolean' ? { visible: body.visible } : {}),
+        })),
+        postRoute(`${PET_API_PREFIX}/set-name`, (body) => {
+            const name = body.name;
+            if (typeof name !== 'string')
+                return Promise.reject(new Error('invalid-name'));
+            return service.setName(name);
+        }),
+    ];
+    const assetRoutes = ASSET_FILES.map((file) => ({
+        kind: 'exact',
+        path: `${PET_ASSET_PREFIX}/${file.name}`,
+        handler: (req, res) => {
+            if (req.method !== 'GET' && req.method !== 'HEAD') {
+                res.writeHead(405);
+                res.end();
+                return;
+            }
+            return readFile(join(packageRoot, 'assets', 'whale', file.name)).then((body) => {
+                res.writeHead(200, {
+                    'content-type': file.mime,
+                    'content-length': String(body.byteLength),
+                    'cache-control': 'no-cache',
+                });
+                if (req.method === 'HEAD') {
+                    res.end();
+                    return;
+                }
+                res.end(body);
+            }, () => {
+                res.writeHead(404);
+                res.end();
+            });
+        },
+    }));
+    return [...apiRoutes, ...assetRoutes];
+}

package/lib/types/service.js

@@ -0,0 +1,255 @@
+/**
+ * Pet host service — the `pet.*` RPC domain. Owns the state machine wiring
+ * (consumes `activity/status` session events and session lifecycle), the
+ * affinity ledger, and the persisted display config. The API gateway maps
+ * this service's methods onto `pet.state` / `pet.interact` /
+ * `pet.setVisible` / `pet.setConfig` for browser consumers.
+ * @module @linxin666/dsh-pet/service
+ */
+import { Service } from '@deepseek-ai/cordis';
+import { applyInteraction, applyTurnReward, defaultAffinityConfig, rankOf, } from "./affinity.js";
+import { loadPetPersist, petHomeDir, savePetPersist, DISPLAY_SIZE_MAX, DISPLAY_SIZE_MIN, DISPLAY_INSET_MAX, PET_NAME_MAX_LENGTH, } from "./persist.js";
+import { defaultTreatConfig, settleTreatGrants, consumeTreat, } from "./treats.js";
+import { defaultPetStateConfig, PetStateMachine, } from "./state.js";
+/** Settings namespace of the pet capability. Spelled here rather than imported: the browser half spells the same value. */
+export const PET_SETTINGS_NAMESPACE = 'pet';
+/**
+ * Cordis service exposing the pet RPC domain. Lazy: nothing is scanned or
+ * written until a query or interaction arrives; event listeners update only
+ * in-memory state, and persistence happens on interaction/config changes
+ * plus every completed turn.
+ */
+export class PetService extends Service {
+    static inject = [];
+    machine;
+    affinityConfig;
+    treatConfig;
+    persistDir;
+    persist;
+    lastTurnRewardAt = 0;
+    enabled;
+    disposeActivity;
+    constructor(ctx, config = {}) {
+        super(ctx, 'pet');
+        this.persistDir = config.persistDir ?? petHomeDir();
+        this.affinityConfig = { ...defaultAffinityConfig, ...(config.affinity ?? {}) };
+        this.treatConfig = { ...defaultTreatConfig, ...(config.treats ?? {}) };
+        this.machine = new PetStateMachine({
+            ...defaultPetStateConfig,
+            ...(config.state ?? {}),
+        });
+        this.persist = loadPetPersist(this.persistDir);
+        this.enabled = config.enabled ?? true;
+        this.syncActivity();
+    }
+    /** Whether the pet service consumes session activity while enabled. */
+    isEnabled() {
+        return this.enabled;
+    }
+    /** RPC: current pet state snapshot. */
+    async state() {
+        return this.view();
+    }
+    /** Current persisted display config (read-only view). */
+    display() {
+        return { ...this.persist.display };
+    }
+    /** Current persisted pet name (read-only view). */
+    petName() {
+        return this.persist.name;
+    }
+    /** Start or stop the session-activity listeners that drive the pet. */
+    setEnabled(enabled) {
+        this.enabled = enabled;
+        this.syncActivity();
+    }
+    syncActivity() {
+        if (this.disposeActivity !== undefined) {
+            this.disposeActivity();
+            this.disposeActivity = undefined;
+        }
+        if (!this.enabled)
+            return;
+        this.disposeActivity = (() => {
+            const disposers = [
+                this.ctx.on('session/event', (_session, event) => {
+                    if (event.type !== 'activity/status')
+                        return;
+                    const payload = (event.data ?? {});
+                    if (payload.phase === undefined)
+                        return;
+                    const phase = payload.phase;
+                    // Guard against unknown phases from newer activity trackers.
+                    if (!['idle', 'waiting', 'thinking', 'tool', 'done'].includes(phase))
+                        return;
+                    this.machine.onActivityStatus({
+                        phase,
+                        ...(typeof payload.line === 'string' ? { line: payload.line } : {}),
+                        ...(typeof payload.phrase === 'string' ? { phrase: payload.phrase } : {}),
+                    });
+                    this.machine.onSessionActive();
+                    if (phase === 'done')
+                        this.rewardTurn();
+                }),
+                this.ctx.on('session/disposed', () => {
+                    this.machine.onSessionDisposed();
+                }),
+            ];
+            return () => { for (const dispose of disposers)
+                dispose(); };
+        })();
+    }
+    /** RPC: pet or feed the pet. */
+    async interact(kind) {
+        const nowMs = Date.now();
+        // Feeding consumes a treat: settle the economy first (work + time
+        // output since the last settlement), then gate on the feed cooldown
+        // BEFORE spending stock — a feed inside the cooldown must not burn a
+        // treat for nothing.
+        if (kind === 'feed')
+            this.settleTreats(nowMs);
+        const outcome = applyInteraction(this.persist.affinity, kind, nowMs, this.affinityConfig);
+        if (kind === 'feed' && !outcome.accepted) {
+            return { reaction: outcome.reaction, delta: 0, affinity: this.affinityView(this.persist.affinity) };
+        }
+        if (kind === 'feed') {
+            const consume = consumeTreat(this.persist.treats);
+            if (!consume.ok) {
+                const affinity = this.affinityView(this.persist.affinity);
+                return {
+                    reaction: '没有小鱼干了，多陪鲸鱼娘工作一会儿吧～',
+                    delta: 0,
+                    affinity,
+                };
+            }
+            this.persist = { ...this.persist, treats: consume.ledger };
+        }
+        if (outcome.accepted) {
+            this.persist = { ...this.persist, affinity: outcome.affinity };
+            this.flush();
+        }
+        const affinity = this.affinityView(outcome.affinity);
+        return { reaction: outcome.reaction, delta: outcome.delta, affinity };
+    }
+    /** RPC: show or hide the pet. */
+    async setVisible(visible) {
+        this.persist = { ...this.persist, display: { ...this.persist.display, visible } };
+        this.flush();
+        this.syncSettingsFromPet();
+        return { ok: true, display: this.persist.display };
+    }
+    /** RPC: update display config (size / position). Values are clamped to whole pixels. */
+    async setConfig(patch) {
+        const next = { ...this.persist.display, ...patch };
+        next.size = Math.round(Math.min(DISPLAY_SIZE_MAX, Math.max(DISPLAY_SIZE_MIN, next.size)));
+        next.right = Math.round(Math.min(DISPLAY_INSET_MAX, Math.max(0, next.right)));
+        next.bottom = Math.round(Math.min(DISPLAY_INSET_MAX, Math.max(0, next.bottom)));
+        this.persist = { ...this.persist, display: next };
+        this.flush();
+        this.syncSettingsFromPet();
+        return { ok: true, display: this.persist.display };
+    }
+    /** RPC: rename the pet (trimmed, 1–20 chars). */
+    async setName(name) {
+        const trimmed = name.trim();
+        if (trimmed === '')
+            return { ok: false, error: 'name-empty' };
+        if (trimmed.length > PET_NAME_MAX_LENGTH)
+            return { ok: false, error: 'name-too-long' };
+        this.persist = { ...this.persist, name: trimmed };
+        this.flush();
+        this.syncSettingsFromPet();
+        return { ok: true, name: trimmed };
+    }
+    /**
+     * Apply a committed settings section to the persisted display config. Called
+     * by the settings surface on every change; values are clamped exactly like
+     * the setConfig RPC so both write paths converge.
+     * @param section - the resolved settings section.
+     */
+    applySettingsSection(section) {
+        const next = { ...this.persist.display };
+        next.visible = section.visible && (section.enabled ?? true);
+        next.size = Math.round(Math.min(DISPLAY_SIZE_MAX, Math.max(DISPLAY_SIZE_MIN, section.size)));
+        next.right = Math.round(Math.min(DISPLAY_INSET_MAX, Math.max(0, section.right)));
+        next.bottom = Math.round(Math.min(DISPLAY_INSET_MAX, Math.max(0, section.bottom)));
+        this.persist = { ...this.persist, display: next, name: section.name.trim() };
+        this.flush();
+    }
+    /** Mirror the persisted display config into the settings document (best-effort). */
+    syncSettingsFromPet() {
+        const settings = this.ctx.get('settings', false);
+        if (settings === undefined)
+            return;
+        void settings.update(PET_SETTINGS_NAMESPACE, {
+            visible: this.persist.display.visible,
+            size: this.persist.display.size,
+            right: this.persist.display.right,
+            bottom: this.persist.display.bottom,
+            name: this.persist.name,
+        }).catch(() => {
+            // A settings write failure must not break the pet's own persistence.
+        });
+    }
+    /** Award the turn reward once per done phase (idempotent per transition). */
+    rewardTurn() {
+        const nowMs = Date.now();
+        // A done phase can repeat while celebrating; only reward the first.
+        if (nowMs - this.lastTurnRewardAt < 5_000)
+            return;
+        this.lastTurnRewardAt = nowMs;
+        this.persist = { ...this.persist, affinity: applyTurnReward(this.persist.affinity, this.affinityConfig) };
+        this.flush();
+    }
+    /**
+     * Settle the treat economy (work + time output since the last
+     * settlement); persists only when treats were actually granted.
+     */
+    settleTreats(nowMs) {
+        const settlement = settleTreatGrants(this.persist.treats, this.persist.affinity.turns, nowMs, this.treatConfig);
+        if (settlement.gained > 0) {
+            this.persist = { ...this.persist, treats: settlement.ledger };
+            this.flush();
+        }
+    }
+    view() {
+        const snapshot = this.machine.render();
+        // Time-output treats accrue while the host is idle too; settle on read.
+        this.settleTreats(Date.now());
+        return {
+            animation: snapshot.animation,
+            ...(snapshot.bubble === undefined ? {} : { bubble: snapshot.bubble }),
+            phase: snapshot.phase,
+            sessionActive: snapshot.sessionActive,
+            affinity: this.affinityView(this.persist.affinity),
+            display: { ...this.persist.display },
+            name: this.persist.name,
+            treats: {
+                stocked: this.persist.treats.treats,
+                max: this.treatConfig.maxTreats,
+            },
+        };
+    }
+    affinityView(affinity) {
+        const nowMs = Date.now();
+        const rank = rankOf(affinity.points);
+        return {
+            points: affinity.points,
+            rank: rank.name,
+            rankEmoji: rank.emoji,
+            pets: affinity.pets,
+            feeds: affinity.feeds,
+            turns: affinity.turns,
+            petCooldown: nowMs - affinity.lastPetAt < this.affinityConfig.petCooldownMs,
+            feedCooldown: nowMs - affinity.lastFeedAt < this.affinityConfig.feedCooldownMs,
+        };
+    }
+    flush() {
+        try {
+            savePetPersist(this.persist, this.persistDir);
+        }
+        catch {
+            // Persistence is best-effort; the in-memory ledger keeps working.
+        }
+    }
+}

package/lib/types/state.js

@@ -0,0 +1,106 @@
+/**
+ * Pet state machine — pure, clock-injected. Maps the DSH `activity/status`
+ * phase vocabulary (session events) onto the 9-state Codex pet
+ * animation contract, plus the session lifecycle transitions the web UI
+ * exposes (turn end celebration, no-session idle).
+ *
+ * The machine is deliberately dumb: it holds the last input phase, the
+ * animation decision, and a one-shot "celebration" window after `done` so the
+ * pet visibly jumps before settling back to idle. Everything here is a pure
+ * function of (input, nowMs); persistence and RPC live in the service.
+ * @module @linxin666/dsh-pet/state
+ */
+export const defaultPetStateConfig = { celebrateMs: 2400 };
+/**
+ * Map one activity phase onto the animation contract.
+ * - thinking / tool → `running` (focused work), with `running-right` as the
+ *   side-alternating variant the client may use for tool activity.
+ * - waiting → `waiting` (expectant pose, needs user input).
+ * - done → `jumping` (celebration), then back to `idle` after the window.
+ * - idle → `idle` (calm breathing loop).
+ * `failed` has no DSH phase source yet; the machine keeps the mapping table
+ * so a future error event can light it up.
+ */
+export function animationForPhase(phase) {
+    switch (phase) {
+        case 'thinking': return 'running';
+        case 'tool': return 'running-right';
+        case 'waiting': return 'waiting';
+        case 'done': return 'jumping';
+        case 'idle': return 'idle';
+    }
+}
+/** The spritesheet row index for one animation track. */
+export function rowOf(animation) {
+    const rows = {
+        'idle': 0,
+        'running-right': 1,
+        'running-left': 2,
+        'waving': 3,
+        'jumping': 4,
+        'failed': 5,
+        'waiting': 6,
+        'running': 7,
+        'review': 8,
+    };
+    return rows[animation];
+}
+/**
+ * PetStateMachine — one instance per host process. Holds only the latest
+ * input snapshot and the celebration timing; no storage, no side effects.
+ */
+export class PetStateMachine {
+    config;
+    now;
+    phase = 'idle';
+    line;
+    phrase;
+    sessionActive = false;
+    doneAt;
+    constructor(config = defaultPetStateConfig, now = Date.now) {
+        this.config = config;
+        this.now = now;
+    }
+    /** Consume one `activity/status` session event. */
+    onActivityStatus(input) {
+        this.phase = input.phase;
+        this.line = input.line;
+        this.phrase = input.phrase;
+        if (input.phase === 'done')
+            this.doneAt = this.now();
+    }
+    /** A session became the active one (or a fresh session started). */
+    onSessionActive() {
+        this.sessionActive = true;
+    }
+    /** The active session was disposed (or none left). */
+    onSessionDisposed() {
+        this.sessionActive = false;
+        this.phase = 'idle';
+        this.line = undefined;
+        this.phrase = undefined;
+        this.doneAt = undefined;
+    }
+    /** Render the current animation decision. */
+    render() {
+        const nowMs = this.now();
+        let animation = animationForPhase(this.phase);
+        // Celebration window: after `done`, jump for celebrateMs then settle idle.
+        if (this.phase === 'done' && this.doneAt !== undefined) {
+            if (nowMs - this.doneAt < this.config.celebrateMs) {
+                animation = 'jumping';
+            }
+            else {
+                animation = 'idle';
+            }
+        }
+        const bubble = this.phrase ?? this.line;
+        return {
+            animation,
+            ...(bubble === undefined ? {} : { bubble }),
+            animationStartedAt: nowMs,
+            phase: this.phase,
+            sessionActive: this.sessionActive,
+        };
+    }
+}

package/lib/types/treats.js

@@ -0,0 +1,63 @@
+/**
+ * Treat (小鱼干) economy — pure, clock-injected. The pet's food comes from
+ * two sources, both tied to companionship:
+ *  - work output: every N completed turns grant one treat;
+ *  - time output: every T minutes of wall-clock time grant one treat.
+ * Feeding consumes one treat. Settlement is lazy: it runs whenever the host
+ * serves a state snapshot or an interaction, so there is no timer and no
+ * drift — elapsed periods are computed from the persisted last-grant marks.
+ * @module @linxin666/dsh-pet/treats
+ */
+export const defaultTreatConfig = {
+    turnsPerTreat: 3,
+    timeTreatMs: 30 * 60_000,
+    maxTreats: 20,
+};
+export function emptyTreatLedger() {
+    return { treats: 0, lastTreatGrantAt: 0, turnsAtLastTreatGrant: 0 };
+}
+function cap(treats, max) {
+    return Math.min(max, Math.max(0, treats));
+}
+/**
+ * Settle treat grants from both sources against one ledger snapshot.
+ * Work output counts whole periods since the last work settlement
+ * (turnsDelta / turnsPerTreat) and advances only the work anchor;
+ * time output counts whole periods since the time anchor
+ * (`lastTreatGrantAt`) and advances only the time anchor. The two sources
+ * are independent so a continuously working user still earns time treats.
+ * 0 time history never backfills — the clock starts at the first settlement.
+ * Both sources are clamped by the stock cap.
+ */
+export function settleTreatGrants(ledger, turns, nowMs, config = defaultTreatConfig) {
+    const turnDelta = Math.max(0, turns - ledger.turnsAtLastTreatGrant);
+    const workGrants = Math.floor(turnDelta / config.turnsPerTreat);
+    // The time clock starts at the first settlement (no backfill of pre-first
+    // idle history); thereafter only time grants move it forward.
+    const timeAnchor = ledger.lastTreatGrantAt === 0 ? nowMs : ledger.lastTreatGrantAt;
+    const timeGrants = Math.floor(Math.max(0, nowMs - timeAnchor) / config.timeTreatMs);
+    const gained = workGrants + timeGrants;
+    if (gained <= 0)
+        return { ledger, gained: 0 };
+    return {
+        ledger: {
+            treats: cap(ledger.treats + gained, config.maxTreats),
+            lastTreatGrantAt: timeGrants > 0
+                ? timeAnchor + timeGrants * config.timeTreatMs
+                : timeAnchor,
+            turnsAtLastTreatGrant: workGrants > 0
+                ? turns - (turnDelta % config.turnsPerTreat)
+                : ledger.turnsAtLastTreatGrant,
+        },
+        gained,
+    };
+}
+/**
+ * Consume one treat for a feed. Returns the outcome; a feed with no stocked
+ * treats is refused.
+ */
+export function consumeTreat(ledger) {
+    if (ledger.treats <= 0)
+        return { ok: false };
+    return { ok: true, ledger: { ...ledger, treats: ledger.treats - 1 } };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@linxin666/dsh-pet",
   "description": "鲸鱼娘宠物插件 for the dsh web GUI: a soft healing whale-girl companion that reacts to model activity (idle/waiting/thinking/tool/done), with petting/feeding interactions and an affinity score",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
   "engines": {
     "node": "^22.19.0 || >=24.0.0"
@@ -25,14 +25,13 @@
     "./package.json": "./package.json"
   },
   "files": [
-    "lib/index.js",
-    "lib/invariant.js",
-    "lib/client.js",
-    "lib/types/**/*.d.ts",
-    "lib/types/**/*.d.ts.map",
+    "lib/**/*.js",
+    "lib/**/*.js.map",
+    "lib/**/*.d.ts",
+    "lib/**/*.d.ts.map",
     "src",
-    "assets",
-    "cordis.patch.yml"
+    "cordis.patch.yml",
+    "assets"
   ],
   "license": "BSD-3-Clause",
   "dsh": {
@@ -44,7 +43,6 @@
         "@deepseek-ai/dsh-client-runtime",
         "@deepseek-ai/dsh-client-connection",
         "@deepseek-ai/dsh-client-ui-settings",
-        "@deepseek-ai/dsh-client-ui-slots",
         "@deepseek-ai/dsh-client-ui-conversation"
       ],
       "platform": "web"
@@ -92,6 +90,10 @@
     "vite-tsconfig-paths": "^6.1.1",
     "vitest": "^4.1.8"
   },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zhu1090093659/dsh-web-ui.git"
+  },
   "scripts": {
     "build": "tsc -b && tsdown",
     "test": "vitest run",