dsh-agy-cli 0.0.0-stage → 0.12.0

package/lib/provider/tool-schema-file.d.ts

@@ -0,0 +1,11 @@
+import type { StructuredToolProtocol } from './tool-protocol.js';
+export interface StagedToolSchema {
+    readonly path: string;
+    readonly cleanup: () => Promise<void>;
+}
+/**
+ * Stage one bounded schema outside the user workspace. The returned path is
+ * intended only for AGY argv; callers must invoke cleanup on every outcome.
+ */
+export declare function stageToolSchema(protocol: StructuredToolProtocol): Promise<StagedToolSchema>;
+//# sourceMappingURL=tool-schema-file.d.ts.map

package/lib/provider/tool-schema-file.js

@@ -0,0 +1,27 @@
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+/**
+ * Stage one bounded schema outside the user workspace. The returned path is
+ * intended only for AGY argv; callers must invoke cleanup on every outcome.
+ */
+export async function stageToolSchema(protocol) {
+    const directory = await mkdtemp(join(tmpdir(), 'dsh-agy-tool-schema-'));
+    const path = join(directory, 'schema.json');
+    let cleaned = false;
+    const cleanup = async () => {
+        if (cleaned)
+            return;
+        cleaned = true;
+        await rm(directory, { recursive: true, force: true });
+    };
+    try {
+        await writeFile(path, protocol.schemaJson, { encoding: 'utf8', flag: 'wx', mode: 0o600 });
+        return { path, cleanup };
+    }
+    catch (error) {
+        await cleanup();
+        throw error;
+    }
+}
+//# sourceMappingURL=tool-schema-file.js.map

package/lib/session/file-store.d.ts

@@ -0,0 +1,56 @@
+import type { SessionFingerprint, SessionRecord, SessionStore } from './store.js';
+/**
+ * How many conversation bindings to keep. Each DSH session leaves one AGY
+ * conversation database on disk, so the map must not grow without bound; past
+ * this cap the oldest-touched records are dropped and those sessions fall back
+ * to the full DSH history on their next turn.
+ */
+export declare const MAX_SESSION_RECORDS = 2000;
+export interface FileSessionStoreOptions {
+    readonly path: string;
+    /** Injectable for tests; production uses `Date.now`. */
+    readonly now?: () => number;
+    /** Records older than this are dropped on load. Default 30 days. */
+    readonly maxAgeMs?: number;
+    /** Injectable cap; production uses `MAX_SESSION_RECORDS`. */
+    readonly maxRecords?: number;
+}
+/** Default location for the durable `sessionId -> AGY conversationId` map. */
+export declare function defaultSessionStorePath(): string;
+/**
+ * The default on-disk location is used verbatim; anything else is taken as a
+ * directory so a test or a profile can point the store at a scratch folder.
+ */
+export declare function resolveSessionStorePath(configured: string | undefined): string;
+/**
+ * Durable `DSH sessionId -> AGY conversationId` map.
+ *
+ * The in-memory store was the reason a long conversation re-sent its entire
+ * history: AGY keeps every conversation on disk (`--conversation <id>` resumes
+ * across process boundaries, verified), but the mapping lived only in the
+ * adapter. After a host restart the map was empty, so the first turn of every
+ * pre-existing session went back to `requestMode: 'bootstrap'` and serialized
+ * the whole DSH history into one prompt — pinned at the input limit, missing the
+ * upstream prompt cache, and timing out on long sessions.
+ *
+ * Writes are best-effort and coalesced: a failed write only costs the binding,
+ * and the next turn re-bootstraps that session. Reads never throw.
+ */
+export declare class FileSessionStore implements SessionStore {
+    private readonly path;
+    private readonly now;
+    private readonly maxAgeMs;
+    private readonly maxRecords;
+    private records;
+    private dirty;
+    constructor(options: FileSessionStoreOptions);
+    private load;
+    private persist;
+    get(sessionId: string): SessionRecord | undefined;
+    set(sessionId: string, conversationId: string, fingerprint?: SessionFingerprint): SessionRecord;
+    delete(sessionId: string): boolean;
+    clear(): void;
+    /** Test/diagnostic view of the in-memory projection. */
+    list(): readonly SessionRecord[];
+}
+//# sourceMappingURL=file-store.d.ts.map

package/lib/session/file-store.js

@@ -0,0 +1,186 @@
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+/**
+ * How many conversation bindings to keep. Each DSH session leaves one AGY
+ * conversation database on disk, so the map must not grow without bound; past
+ * this cap the oldest-touched records are dropped and those sessions fall back
+ * to the full DSH history on their next turn.
+ */
+export const MAX_SESSION_RECORDS = 2_000;
+const DEFAULT_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;
+function resolveDshHome() {
+    return process.env.DSH_HOME?.trim() || join(homedir(), '.dsh');
+}
+/** Default location for the durable `sessionId -> AGY conversationId` map. */
+export function defaultSessionStorePath() {
+    return join(resolveDshHome(), 'agy-cli', 'sessions.json');
+}
+/**
+ * The default on-disk location is used verbatim; anything else is taken as a
+ * directory so a test or a profile can point the store at a scratch folder.
+ */
+export function resolveSessionStorePath(configured) {
+    const trimmed = configured?.trim();
+    if (trimmed === undefined || trimmed.length === 0)
+        return defaultSessionStorePath();
+    return trimmed.toLowerCase().endsWith('.json') ? trimmed : join(trimmed, 'sessions.json');
+}
+function isRecord(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const record = value;
+    return typeof record.sessionId === 'string'
+        && record.sessionId.length > 0
+        && typeof record.conversationId === 'string'
+        && record.conversationId.length > 0
+        && typeof record.updatedAt === 'number'
+        && Number.isFinite(record.updatedAt);
+}
+function parsePersisted(text) {
+    const records = new Map();
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        // A truncated or hand-edited file must not break the provider: an empty map
+        // means every session bootstraps from the full DSH history, which is the
+        // behaviour before this store existed.
+        return records;
+    }
+    const list = Array.isArray(parsed)
+        ? parsed
+        : parsed !== null && typeof parsed === 'object' && Array.isArray(parsed.sessions)
+            ? parsed.sessions
+            : [];
+    for (const entry of list) {
+        if (!isRecord(entry))
+            continue;
+        records.set(entry.sessionId, {
+            sessionId: entry.sessionId,
+            conversationId: entry.conversationId,
+            updatedAt: entry.updatedAt,
+            ...(typeof entry.chainHash === 'string' && typeof entry.messageCount === 'number'
+                ? { chainHash: entry.chainHash, messageCount: entry.messageCount }
+                : {}),
+        });
+    }
+    return records;
+}
+/**
+ * Durable `DSH sessionId -> AGY conversationId` map.
+ *
+ * The in-memory store was the reason a long conversation re-sent its entire
+ * history: AGY keeps every conversation on disk (`--conversation <id>` resumes
+ * across process boundaries, verified), but the mapping lived only in the
+ * adapter. After a host restart the map was empty, so the first turn of every
+ * pre-existing session went back to `requestMode: 'bootstrap'` and serialized
+ * the whole DSH history into one prompt — pinned at the input limit, missing the
+ * upstream prompt cache, and timing out on long sessions.
+ *
+ * Writes are best-effort and coalesced: a failed write only costs the binding,
+ * and the next turn re-bootstraps that session. Reads never throw.
+ */
+export class FileSessionStore {
+    path;
+    now;
+    maxAgeMs;
+    maxRecords;
+    records;
+    dirty = false;
+    constructor(options) {
+        this.path = options.path;
+        this.now = options.now ?? Date.now;
+        this.maxAgeMs = options.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
+        this.maxRecords = options.maxRecords ?? MAX_SESSION_RECORDS;
+    }
+    load() {
+        if (this.records !== undefined)
+            return this.records;
+        let loaded = new Map();
+        try {
+            loaded = parsePersisted(readFileSync(this.path, 'utf8'));
+        }
+        catch {
+            loaded = new Map();
+        }
+        // Drop bindings AGY itself may have pruned: an attempt against a stale id is
+        // harmless (AGY starts a fresh conversation and the provider detects the id
+        // mismatch and retries with the full history), but keeping dead ids wastes
+        // the cap.
+        const cutoff = this.now() - this.maxAgeMs;
+        for (const [key, record] of loaded) {
+            if (record.updatedAt < cutoff)
+                loaded.delete(key);
+        }
+        this.records = loaded;
+        return loaded;
+    }
+    persist() {
+        if (!this.dirty)
+            return;
+        const list = [...(this.records ?? []).values()];
+        // Unpredictable temp name: two processes pointing at the same file must not
+        // be able to win each other's rename.
+        const temporary = `${this.path}.tmp-${process.pid}-${Date.now().toString(36)}`;
+        try {
+            mkdirSync(dirname(this.path), { recursive: true });
+            // Temp file plus rename: a crash mid-write leaves the previous map intact.
+            writeFileSync(temporary, JSON.stringify({ sessions: list }, null, 2), 'utf8');
+            renameSync(temporary, this.path);
+            this.dirty = false;
+        }
+        catch {
+            try {
+                rmSync(temporary, { force: true });
+            }
+            catch {
+                // Nothing to clean up, or the cleanup itself failed.
+            }
+            // A read-only or unwritable location degrades to in-memory behaviour only.
+            this.dirty = false;
+        }
+    }
+    get(sessionId) {
+        const record = this.load().get(sessionId);
+        return record === undefined ? undefined : { ...record };
+    }
+    set(sessionId, conversationId, fingerprint) {
+        const records = this.load();
+        const record = {
+            sessionId,
+            conversationId,
+            updatedAt: this.now(),
+            ...(fingerprint === undefined ? {} : { chainHash: fingerprint.chainHash, messageCount: fingerprint.messageCount }),
+        };
+        records.set(sessionId, record);
+        if (records.size > this.maxRecords) {
+            const sorted = [...records.values()].sort((a, b) => a.updatedAt - b.updatedAt);
+            for (const stale of sorted.slice(0, records.size - this.maxRecords)) {
+                records.delete(stale.sessionId);
+            }
+        }
+        this.dirty = true;
+        this.persist();
+        return { ...record };
+    }
+    delete(sessionId) {
+        const removed = this.load().delete(sessionId);
+        if (removed) {
+            this.dirty = true;
+            this.persist();
+        }
+        return removed;
+    }
+    clear() {
+        this.load().clear();
+        this.dirty = true;
+        this.persist();
+    }
+    /** Test/diagnostic view of the in-memory projection. */
+    list() {
+        return [...this.load().values()];
+    }
+}
+//# sourceMappingURL=file-store.js.map

package/lib/session/store.d.ts

@@ -0,0 +1,49 @@
+export interface SessionRecord {
+    readonly sessionId: string;
+    readonly conversationId: string;
+    readonly updatedAt: number;
+    /**
+     * Fingerprint of the DSH history this conversation already holds, as
+     * `sha256(serialize(system + messages))` (first 16 hex chars), plus the
+     * message count it covered. Design borrowed from dsh-agy-safe's history
+     * chain: on a resumed turn the prefix is re-serialized locally and compared,
+     * so an edited, compacted or truncated DSH history is detected before a
+     * delta prompt lands on stale AGY context — the turn then falls back to the
+     * full-history replay instead of answering from the wrong conversation.
+     * Both fields are optional: records written before the chain existed simply
+     * skip the check.
+     */
+    readonly chainHash?: string;
+    readonly messageCount?: number;
+}
+/** Optional fingerprint metadata carried alongside a conversation binding. */
+export interface SessionFingerprint {
+    readonly chainHash: string;
+    readonly messageCount: number;
+}
+export interface SessionStore {
+    get(sessionId: string): SessionRecord | undefined;
+    set(sessionId: string, conversationId: string, fingerprint?: SessionFingerprint): SessionRecord;
+    delete(sessionId: string): boolean;
+    clear(): void;
+}
+/** In-memory mapping; losing it on plugin restart falls back to full DSH history. */
+export declare class InMemorySessionStore implements SessionStore {
+    private readonly records;
+    get(sessionId: string): SessionRecord | undefined;
+    set(sessionId: string, conversationId: string, fingerprint?: SessionFingerprint): SessionRecord;
+    delete(sessionId: string): boolean;
+    clear(): void;
+}
+/** Serialize calls for one Session while allowing different Sessions to run concurrently. */
+export declare class SessionRegistry implements SessionStore {
+    private readonly store;
+    private readonly locks;
+    constructor(store?: SessionStore);
+    get(sessionId: string): SessionRecord | undefined;
+    set(sessionId: string, conversationId: string, fingerprint?: SessionFingerprint): SessionRecord;
+    delete(sessionId: string): boolean;
+    clear(): void;
+    acquire(sessionId: string): Promise<() => void>;
+}
+//# sourceMappingURL=store.d.ts.map

package/lib/session/store.js

@@ -0,0 +1,62 @@
+/** In-memory mapping; losing it on plugin restart falls back to full DSH history. */
+export class InMemorySessionStore {
+    records = new Map();
+    get(sessionId) {
+        const record = this.records.get(sessionId);
+        return record === undefined ? undefined : { ...record };
+    }
+    set(sessionId, conversationId, fingerprint) {
+        const record = {
+            sessionId,
+            conversationId,
+            updatedAt: Date.now(),
+            ...(fingerprint === undefined ? {} : { chainHash: fingerprint.chainHash, messageCount: fingerprint.messageCount }),
+        };
+        this.records.set(sessionId, record);
+        return { ...record };
+    }
+    delete(sessionId) {
+        return this.records.delete(sessionId);
+    }
+    clear() {
+        this.records.clear();
+    }
+}
+/** Serialize calls for one Session while allowing different Sessions to run concurrently. */
+export class SessionRegistry {
+    store;
+    locks = new Map();
+    constructor(store = new InMemorySessionStore()) {
+        this.store = store;
+    }
+    get(sessionId) {
+        return this.store.get(sessionId);
+    }
+    set(sessionId, conversationId, fingerprint) {
+        return this.store.set(sessionId, conversationId, fingerprint);
+    }
+    delete(sessionId) {
+        return this.store.delete(sessionId);
+    }
+    clear() {
+        this.store.clear();
+    }
+    async acquire(sessionId) {
+        const previous = this.locks.get(sessionId) ?? Promise.resolve();
+        let releaseCurrent;
+        const current = new Promise(resolve => { releaseCurrent = resolve; });
+        const tail = previous.then(() => current);
+        this.locks.set(sessionId, tail);
+        await previous;
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            releaseCurrent();
+            if (this.locks.get(sessionId) === tail)
+                this.locks.delete(sessionId);
+        };
+    }
+}
+//# sourceMappingURL=store.js.map

package/lib/web/router.d.ts

@@ -0,0 +1,19 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { Config as ConfigType } from '../provider/config.js';
+import type { AgyModelDiscovery } from '../agy/models.js';
+/** Record the outcome of one boot registration step (called from apply()). */
+export declare function noteRegistration(step: string, detail: string): void;
+interface CardPing {
+    at: number;
+    props: string[];
+}
+/** Record one card mount reported by the browser half. */
+export declare function noteCardPing(props: string[]): void;
+/** Snapshot for `/plugins/agy-cli/diagnose`. */
+export declare function getAttachDiagnostics(): {
+    notes: Record<string, string>;
+    cardPings: CardPing[];
+};
+export declare function setupWebRoutes(ctx: Context, activeConfig: ConfigType, modelDiscovery?: AgyModelDiscovery): () => void;
+export {};
+//# sourceMappingURL=router.d.ts.map