@itookit/dsht 0.3.0 → 0.3.3

package/dist/catalog/controller.js

@@ -0,0 +1,88 @@
+import { array, errorText, object, string } from "../transport/wire.js";
+/** Owns model-catalog and preset loads for the selected session. */
+export class CatalogController {
+    store;
+    host;
+    presetClient;
+    revision = 0;
+    tasks = new Set();
+    constructor(store, host) {
+        this.store = store;
+        this.host = host;
+    }
+    /** Drop generation-scoped catalog state at the start of a connection generation. */
+    reset() {
+        this.store.update({ modelError: undefined, defaultModel: undefined, presets: undefined, presetError: undefined });
+    }
+    /** Wait for every in-flight catalog task, so shutdown leaves no pending request. */
+    async settle() { await Promise.all(this.tasks); }
+    /** Load the optional preset roster once per connection, only when a session names a preset. */
+    loadPresetNames() {
+        const client = this.host.client();
+        if (!client || !this.store.state.online || this.presetClient === client)
+            return;
+        this.presetClient = client;
+        const task = client.call('agentPresets/list', {}).then(value => {
+            if (client === this.host.client())
+                this.store.update({ presets: array(object(value).presets).map(object), presetError: undefined });
+        }).catch(error => {
+            if (client === this.host.client())
+                this.store.update({ presets: [], presetError: errorText(error) });
+        });
+        this.tasks.add(task);
+        void task.finally(() => this.tasks.delete(task));
+    }
+    /** Fetch current model routes and adapter-owned reasoning choices for the selected session.
+     * @returns Host catalog; provider failures remain available to the selector.
+     */
+    async modelCatalog() {
+        const sessionId = this.sessionId;
+        const selection = this.store.selection();
+        const value = object(await this.host.require().call('session/modelCatalog', {}));
+        if (selection !== this.store.selection() || sessionId !== this.store.state.sessionId)
+            throw new Error('Session changed while loading models');
+        return value;
+    }
+    /** Select the next request's model; the host also attempts to save its deployment default.
+     * @param provider - Host provider route ID.
+     * @param model - Exact model ID.
+     * @param reasoningEffort - Optional adapter-owned effort ID; omission uses its default.
+     */
+    async selectModel(provider, model, reasoningEffort) {
+        const sessionId = this.sessionId;
+        const selection = this.store.selection();
+        const selected = object(object(await this.host.require().call('session/selectModel', { request: {
+                sessionId, provider, model, ...(reasoningEffort === undefined ? {} : { reasoningEffort }),
+            } })).selected);
+        if (selection !== this.store.selection() || sessionId !== this.store.state.sessionId)
+            return;
+        this.store.update({ status: `Next request: ${string(selected.provider)} / ${string(selected.model)}${selected.reasoningEffort ? ` · ${string(selected.reasoningEffort)}` : ''}` });
+        this.refresh();
+    }
+    /** Reload the default route and provider failures without touching session state. */
+    refresh() {
+        const client = this.host.client();
+        if (!client)
+            return;
+        const revision = ++this.revision;
+        const task = client.call('session/modelCatalog', {}).then(value => {
+            if (client === this.host.client() && revision === this.revision)
+                this.store.update({ defaultModel: object(object(value).default), modelError: undefined });
+        }, error => {
+            if (client === this.host.client() && revision === this.revision)
+                this.store.update({ defaultModel: undefined, modelError: errorText(error) });
+        }).catch(error => {
+            if (client === this.host.client() && revision === this.revision)
+                this.store.update({ defaultModel: undefined, modelError: errorText(error) });
+        });
+        this.tasks.add(task);
+        void task.finally(() => this.tasks.delete(task));
+    }
+    /** @returns The selected session identity, or a `Select a session first` failure. */
+    get sessionId() {
+        const id = this.store.state.sessionId;
+        if (!id)
+            throw new Error('Select a session first');
+        return id;
+    }
+}

package/dist/catalog/index.d.ts

@@ -0,0 +1,2 @@
+/** Catalog domain: model routes, reasoning efforts and agent-preset metadata. */
+export { CatalogController } from './controller.ts';

package/dist/catalog/index.js

@@ -0,0 +1,2 @@
+/** Catalog domain: model routes, reasoning efforts and agent-preset metadata. */
+export { CatalogController } from "./controller.js";

package/dist/{cli.js → cli/index.js}

@@ -1,21 +1,19 @@
 #!/usr/bin/env node
-import { jsx as _jsx } from "react/jsx-runtime";
 /** Standalone executable entry; connects to an existing host and never launches Harness. */
 import { createHash } from 'node:crypto';
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { CostLedger, DEFAULT_PRICES, pricesFrom } from "./cost.js";
+import { CostLedger, loadPrices } from "../cost/index.js";
 import { parseArgs } from 'node:util';
-import { render } from 'ink';
-import { App } from "./app.js";
-import { sessionLabel } from "./navigation.js";
-import { CookieStore, login } from "./auth.js";
-import { Client } from "./client.js";
-import { historyLimits } from "./memory.js";
-import { Controller } from "./controller.js";
-import { endpoint } from "./endpoint.js";
-import { errorText, safeText, string } from "./wire.js";
+import { mount } from "../ui/mount.js";
+import { ensureDirectory } from "../storage/index.js";
+import { sessionLabel } from "../session/navigation.js";
+import { CookieStore, login } from "../transport/auth.js";
+import { Client } from "../transport/client.js";
+import { historyLimits } from "../session/memory.js";
+import { Controller } from "../controller/controller.js";
+import { endpoint } from "../transport/endpoint.js";
+import { errorText, safeText, string } from "../transport/wire.js";
 const HELP = `Usage: dsht [options] [list workspaces|list sessions]
 
 With no command, choose a workspace and session interactively.
@@ -26,14 +24,19 @@ With no command, choose a workspace and session interactively.
   --auth-dir <path>     Private cookie directory (or DSHT_AUTH_DIR)
   --history-records <n> Soft history record limit (default 2000)
   --history-mb <n>      Soft history payload budget in MiB (default 16)
+  --memory-log <path>   Append runtime memory samples; a failing log stops itself
+  --no-memory-log       Disable the runtime memory log (default: enabled)
   --json               Print machine-readable list output
   --help               Show this help
 
 The default host is http://127.0.0.1:3080.
 First login: export DSH_TOKEN, or export DSH_URL as the URL printed by dsh web.
 Cookies are saved per server origin and reused on later starts. Tokens are never saved.
-/cost shows session, today and three-day CNY estimates.
+/cost shows the session and today CNY estimates.
 DSHT_CONFIG_DIR overrides the prices.json directory; DSHT_STATE_DIR overrides usage storage.
+The memory log defaults to <state>/memory.log; DSHT_MEMORY_LOG sets another path or 'off'.
+prices.json overrides the shipped rates and is seeded on first use; every scan re-decides the
+history with the table loaded then, so an edited table reaches past requests on the next scan.
 Examples:
   npx @itookit/dsht
   dsht list workspaces --json
@@ -44,6 +47,7 @@ async function main() {
             url: { type: 'string', default: process.env.DSH_URL ?? 'http://127.0.0.1:3080' },
             'history-records': { type: 'string' }, 'history-mb': { type: 'string' },
             workspace: { type: 'string' }, session: { type: 'string' }, 'auth-dir': { type: 'string' }, json: { type: 'boolean' }, help: { type: 'boolean' },
+            'memory-log': { type: 'string' }, 'no-memory-log': { type: 'boolean' },
         } });
     if (values.help) {
         process.stdout.write(HELP);
@@ -80,24 +84,17 @@ async function main() {
         }
         return;
     }
-    if (!process.stdin.isTTY || !process.stdout.isTTY)
-        throw new Error('Interactive mode requires a terminal. Use list workspaces or list sessions for scripts.');
     const config = process.env.DSHT_CONFIG_DIR ?? join(process.env.XDG_CONFIG_HOME ?? join(homedir(), '.config'), 'dsht');
-    await mkdir(config, { recursive: true, mode: 0o700 });
-    const pricePath = join(config, 'prices.json');
-    try {
-        await writeFile(pricePath, JSON.stringify(DEFAULT_PRICES, null, 2) + '\n', { flag: 'wx', mode: 0o600 });
-    }
-    catch (error) {
-        if (!(error instanceof Error && 'code' in error && error.code === 'EEXIST'))
-            throw error;
-    }
-    const prices = pricesFrom(JSON.parse(await readFile(pricePath, 'utf8')));
-    const costDirectory = join(process.env.DSHT_STATE_DIR ?? join(process.env.XDG_STATE_HOME ?? join(homedir(), '.local', 'state'), 'dsht'), 'cost', createHash('sha256').update(new URL(url).origin).digest('hex'));
-    const costs = new CostLedger(prices, costDirectory);
+    await ensureDirectory(config);
+    const { prices, custom } = await loadPrices(config);
+    const stateRoot = process.env.DSHT_STATE_DIR ?? join(process.env.XDG_STATE_HOME ?? join(homedir(), '.local', 'state'), 'dsht');
+    const costDirectory = join(stateRoot, 'cost', createHash('sha256').update(new URL(url).origin).digest('hex'));
+    const costs = new CostLedger(prices, costDirectory, custom);
     await costs.load();
-    const controller = new Controller(url, token, values.session, undefined, client => login(client, token, store), costs, limits);
-    const app = render(_jsx(App, { controller: controller }), { exitOnCtrlC: false });
+    if (!process.stdin.isTTY || !process.stdout.isTTY)
+        throw new Error('Interactive mode requires a terminal. Use list workspaces or list sessions for scripts.');
+    const controller = new Controller(url, token, values.session, undefined, client => login(client, token, store), costs, limits, memoryLogPath(stateRoot, values['memory-log'], values['no-memory-log']));
+    const app = mount(controller);
     const terminate = () => app.unmount();
     process.once('SIGTERM', terminate);
     controller.start();
@@ -109,4 +106,20 @@ async function main() {
         await controller.shutdown();
     }
 }
+/** Resolve the runtime memory log path: an explicit flag wins, then the environment, then the default.
+ * @param stateRoot - Application state root used for the default path.
+ * @param requested - `--memory-log` value, when given.
+ * @param disabled - `--no-memory-log` flag.
+ * @returns Absolute log path, or undefined when the log is disabled.
+ */
+function memoryLogPath(stateRoot, requested, disabled) {
+    if (requested !== undefined && requested.trim() === '')
+        throw new Error('--memory-log requires a path');
+    if (disabled)
+        return undefined;
+    const chosen = (requested ?? process.env.DSHT_MEMORY_LOG)?.trim();
+    if (chosen === undefined || chosen === '')
+        return join(stateRoot, 'memory.log');
+    return chosen === 'off' ? undefined : chosen;
+}
 main().catch(error => { process.stderr.write(`${errorText(error)}\n`); process.exitCode = 1; });

package/dist/controller/connection.d.ts

@@ -0,0 +1,80 @@
+import { Client } from '../transport/client.ts';
+import { type ObjectValue } from '../transport/wire.ts';
+import type { HostAccess } from '../transport/host.ts';
+import { Telemetry } from '../session/telemetry.ts';
+import type { ConnectionView } from '../session/connection-view.ts';
+import type { ControllerStore } from '../state.ts';
+/** Connection inputs resolved by the CLI or a library consumer. */
+export interface ConnectionOptions {
+    base: string;
+    token: string | undefined;
+    initialSession: string | undefined;
+    /** Factory for one generation's client; replaced in tests. */
+    makeClient: () => Client;
+    /** Authentication used by every generation, including reconnects. */
+    authenticate: (client: Client) => Promise<void>;
+}
+/** Reactions the controller facade owes to connection lifecycle and host events. */
+export interface ConnectionListener {
+    /** A new generation starts; domains drop generation-scoped state. */
+    begin(): void;
+    /** The event stream is ready and the control baseline is applied. */
+    ready(): Promise<void>;
+    /** The generation ended and its socket is closed. */
+    ended(): Promise<void>;
+    /** Deliver a host waterfall; return true when a domain retained it for an answer. */
+    waterfall(frame: ObjectValue): boolean;
+    /** The host cancelled a waterfall a domain retained. */
+    cancelled(eventId: string): void;
+    /** The host reported one session's running state. */
+    status(sessionId: string, running: boolean): void;
+    /** The host reported one session's error. */
+    error(sessionId: unknown, error: unknown): void;
+    /** Model catalogs may have changed. */
+    invalidated(): void;
+    /** A turn finished, so billing may refresh. */
+    idle(): void;
+}
+/** Owns reconnects, subscriptions and the telemetry generation. User commands remain single-attempt operations. */
+export declare class ConnectionController implements HostAccess, ConnectionView {
+    private readonly store;
+    private readonly options;
+    private readonly listener;
+    telemetry: Telemetry;
+    clientId: string;
+    private readonly runningUpdates;
+    private readonly observedRunningAt;
+    private current;
+    private readonly abort;
+    private runTask;
+    private generationFailed;
+    constructor(store: ControllerStore, options: ConnectionOptions, listener: ConnectionListener);
+    /** Start one retry loop, with a fresh snapshot generation after every disconnect. */
+    start(): void;
+    /** Cancel retries and HTTP, close the socket, and wait for the loop to settle. */
+    stop(): Promise<void>;
+    /** @returns The connected client, or undefined while offline. */
+    client(): Client | undefined;
+    /** @returns The connected client, or throws while offline. */
+    require(): Client;
+    /** @returns Whether the current generation applied its host baseline. */
+    online(): boolean;
+    /** @returns The client lifetime signal. */
+    signal(): AbortSignal;
+    /** @returns The projection store of the current generation. */
+    telemetryView(): Telemetry;
+    /** @returns Cached host running state, or undefined when never reported. */
+    runningFor(sessionId: string): boolean | undefined;
+    /** @returns When this client first observed the session, for the elapsed-time fallback. */
+    observedAt(sessionId: string): number | undefined;
+    /** Record an observation start for a session this client just opened. */
+    observe(sessionId: string): void;
+    /** Fail the current generation, so the controller reopens a snapshot. */
+    fail(error: Error): void;
+    /** Answer one retained host waterfall through the event-result endpoint. */
+    reply(frame: ObjectValue, outcome: ObjectValue): Promise<void>;
+    /** Run one generation, then retry with bounded jittered backoff until stopped. */
+    private run;
+    /** Apply one `api-session/status` notification to the running maps and the session view. */
+    private acceptStatus;
+}

package/dist/controller/connection.js

@@ -0,0 +1,190 @@
+/** Owns the physical connection, its generations, and the host event subscriptions. */
+import { setTimeout as delay } from 'node:timers/promises';
+import { AuthenticationRequired } from "../transport/auth.js";
+import { HttpError, RemoteError } from "../transport/client.js";
+import { array, errorText, object, string } from "../transport/wire.js";
+import { Telemetry } from "../session/telemetry.js";
+/** Projection keys this client consumes; the host retains every other capability. */
+const RETAINED_PROJECTIONS = new Set(['title', 'modelSelection', 'contextPressure', 'tokenUsage', 'sessionStats', 'agentPreset']);
+/** Host events that invalidate the model catalog. */
+const CATALOG_EVENTS = ['llm/adapters-updated', 'settings/document-updated', 'credentials/reference-updated'];
+/** Owns reconnects, subscriptions and the telemetry generation. User commands remain single-attempt operations. */
+export class ConnectionController {
+    store;
+    options;
+    listener;
+    telemetry = new Telemetry(RETAINED_PROJECTIONS);
+    clientId = '';
+    runningUpdates = new Map();
+    observedRunningAt = new Map();
+    current;
+    abort = new AbortController();
+    runTask;
+    generationFailed;
+    constructor(store, options, listener) {
+        this.store = store;
+        this.options = options;
+        this.listener = listener;
+    }
+    /** Start one retry loop, with a fresh snapshot generation after every disconnect. */
+    start() { this.runTask ??= this.run(); }
+    /** Cancel retries and HTTP, close the socket, and wait for the loop to settle. */
+    async stop() {
+        this.abort.abort();
+        this.generationFailed?.(new Error('Client stopped'));
+        await this.current?.close();
+        await this.runTask;
+    }
+    /** @returns The connected client, or undefined while offline. */
+    client() { return this.current; }
+    /** @returns The connected client, or throws while offline. */
+    require() {
+        if (!this.current || !this.store.state.online)
+            throw new Error('Not connected');
+        return this.current;
+    }
+    /** @returns Whether the current generation applied its host baseline. */
+    online() { return this.store.state.online; }
+    /** @returns The client lifetime signal. */
+    signal() { return this.abort.signal; }
+    /** @returns The projection store of the current generation. */
+    telemetryView() { return this.telemetry; }
+    /** @returns Cached host running state, or undefined when never reported. */
+    runningFor(sessionId) { return this.runningUpdates.get(sessionId); }
+    /** @returns When this client first observed the session, for the elapsed-time fallback. */
+    observedAt(sessionId) { return this.observedRunningAt.get(sessionId); }
+    /** Record an observation start for a session this client just opened. */
+    observe(sessionId) { if (!this.observedRunningAt.has(sessionId))
+        this.observedRunningAt.set(sessionId, Date.now()); }
+    /** Fail the current generation, so the controller reopens a snapshot. */
+    fail(error) { this.generationFailed?.(error); }
+    /** Answer one retained host waterfall through the event-result endpoint. */
+    async reply(frame, outcome) {
+        await this.require().call('$events/result', { clientId: this.clientId, eventId: string(frame.eventId), outcome });
+    }
+    /** Run one generation, then retry with bounded jittered backoff until stopped. */
+    async run() {
+        let attempt = 0;
+        while (!this.abort.signal.aborted) {
+            this.runningUpdates.clear();
+            this.observedRunningAt.clear();
+            this.telemetry = new Telemetry(RETAINED_PROJECTIONS);
+            this.listener.begin();
+            const client = this.options.makeClient();
+            this.current = client;
+            try {
+                await this.options.authenticate(client);
+                await client.connect();
+                let fail;
+                const disconnected = new Promise(resolve => { fail = resolve; });
+                this.generationFailed = fail;
+                const ready = new Promise((resolve, reject) => {
+                    const timer = setTimeout(() => reject(new Error('Host ready timed out')), client.timeoutMs);
+                    client.subscribe('$events', {}, {
+                        item: value => {
+                            const frame = object(value);
+                            if (frame.type === 'ready') {
+                                this.clientId = string(frame.clientId);
+                                clearTimeout(timer);
+                                resolve();
+                            }
+                            else if (frame.type === 'waterfall') {
+                                if (this.listener.waterfall(frame))
+                                    return;
+                                void client.call('$events/result', { clientId: this.clientId,
+                                    eventId: string(frame.eventId), outcome: { kind: 'next' } }).catch(error => fail(new Error(errorText(error))));
+                            }
+                            else if (frame.type === 'cancel') {
+                                this.listener.cancelled(string(frame.eventId));
+                            }
+                            else if (frame.type === 'emit' && frame.event === 'api-session/status') {
+                                this.acceptStatus(array(frame.args));
+                            }
+                            else if (frame.type === 'emit' && CATALOG_EVENTS.includes(String(frame.event))) {
+                                this.listener.invalidated();
+                            }
+                            else if (frame.type === 'emit' && frame.event === 'api-session/error') {
+                                const args = array(frame.args);
+                                this.listener.error(args[0], args[1]);
+                            }
+                        },
+                        end: error => { clearTimeout(timer); const reason = error ?? new Error('Event stream ended'); reject(reason); fail(reason); },
+                    });
+                });
+                await ready;
+                await new Promise((resolve, reject) => {
+                    const timer = setTimeout(() => reject(new Error('Session control baseline timed out')), client.timeoutMs);
+                    client.subscribe('session/control', {}, {
+                        item: value => {
+                            try {
+                                this.telemetry.accept(value);
+                                this.store.update({});
+                                clearTimeout(timer);
+                                resolve();
+                            }
+                            catch (error) {
+                                clearTimeout(timer);
+                                reject(error);
+                                fail(new Error(errorText(error)));
+                            }
+                        },
+                        end: error => {
+                            clearTimeout(timer);
+                            if (error instanceof RemoteError && error.code === 'gateway/method-unavailable') {
+                                this.store.update({ controlError: 'Live metrics unavailable on this host' });
+                                resolve();
+                            }
+                            else {
+                                const reason = error ?? new Error('Session control stream ended');
+                                reject(reason);
+                                fail(reason);
+                            }
+                        },
+                    });
+                });
+                await this.listener.ready();
+                attempt = 0;
+                const error = await disconnected;
+                if (!this.abort.signal.aborted)
+                    throw error;
+            }
+            catch (error) {
+                if (error instanceof AuthenticationRequired || error instanceof HttpError && [401, 403].includes(error.status)) {
+                    this.store.update({ error: `${errorText(error)}. Set DSH_TOKEN and restart to log in.`, status: 'Login required' });
+                    return;
+                }
+                if (!this.abort.signal.aborted)
+                    this.store.update({ error: errorText(error), status: 'Reconnecting…' });
+            }
+            finally {
+                this.generationFailed = undefined;
+                this.store.update({ online: false, pending: [] });
+                await client.close();
+                await this.listener.ended();
+            }
+            if (!this.abort.signal.aborted) {
+                try {
+                    await delay(Math.min(500 * 2 ** attempt++, 10_000) * (0.8 + Math.random() * 0.4), undefined, { signal: this.abort.signal });
+                }
+                catch (error) {
+                    if (!this.abort.signal.aborted)
+                        throw error;
+                }
+            }
+        }
+    }
+    /** Apply one `api-session/status` notification to the running maps and the session view. */
+    acceptStatus(args) {
+        const sessionId = string(args[0]);
+        if (typeof args[1] !== 'boolean')
+            throw new Error('Invalid session running state');
+        if (args[1] && !this.runningUpdates.get(sessionId))
+            this.observedRunningAt.set(sessionId, Date.now());
+        if (!args[1])
+            this.observedRunningAt.delete(sessionId);
+        this.runningUpdates.set(sessionId, args[1]);
+        this.listener.status(sessionId, args[1]);
+        if (!args[1])
+            this.listener.idle();
+    }
+}