@itookit/dsht 0.2.1 → 0.3.0

package/dist/cli.js

@@ -12,6 +12,7 @@ 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";
@@ -23,6 +24,8 @@ With no command, choose a workspace and session interactively.
   --workspace <id>      Filter list sessions by workspace
   --session <id>        Open a session directly
   --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)
   --json               Print machine-readable list output
   --help               Show this help
 
@@ -39,6 +42,7 @@ Examples:
 async function main() {
     const { values, positionals } = parseArgs({ allowPositionals: true, options: {
             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' },
         } });
     if (values.help) {
@@ -52,6 +56,7 @@ async function main() {
         throw new Error('--json and --workspace apply to list commands');
     if (list && values.session)
         throw new Error('--session applies to interactive mode');
+    const limits = historyLimits(values['history-records'], values['history-mb']);
     const { url, token } = endpoint(values.url, process.env.DSH_TOKEN);
     const store = new CookieStore(values['auth-dir']);
     if (list) {
@@ -91,7 +96,7 @@ async function main() {
     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 costs.load();
-    const controller = new Controller(url, token, values.session, undefined, client => login(client, token, store), costs);
+    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 });
     const terminate = () => app.unmount();
     process.once('SIGTERM', terminate);

package/dist/client.d.ts

@@ -37,17 +37,26 @@ export declare class Client {
         cookie: string;
         expiresAt: number;
     } | undefined;
+    /** Download the authenticated host ZIP without using a mutation or ordinary RPC deadline.
+     * @param sessionId - Selected session identity.
+     * @param signal - Cancels the streaming response.
+     * @returns Response whose body the caller must consume or cancel.
+     */
+    sessionLog(sessionId: string, signal: AbortSignal): Promise<Response>;
     /** Invoke an exact endpoint once. Mutations are never automatically retried.
      * @param endpoint - Namespace/method endpoint.
      * @param args - Host parameter names and JSON values.
      * @param signal - Optional caller cancellation, combined with client close and timeout.
+     * @param timeoutMs - Per-call timeout; null waits for caller cancellation or client close.
      * @returns The decoded result value; HTTP, remote, and cancellation errors reject.
      */
-    call(endpoint: string, args?: ObjectValue, signal?: AbortSignal): Promise<Json | undefined>;
+    call(endpoint: string, args?: ObjectValue, signal?: AbortSignal, timeoutMs?: number | null): Promise<Json | undefined>;
     /** Connect the physical mux. A disconnected instance may reconnect with its cookie. */
     connect(): Promise<void>;
     /** Subscribe on the existing mux; each subscription has a fresh stream identity. */
     subscribe(endpoint: string, args: ObjectValue, listener: Listener): Subscription;
+    /** Archived session IDs from the latest authoritative workspace baseline. */
+    archivedSessionIds: ReadonlySet<string>;
     /** List workspaces by consuming and cancelling the authoritative opening baseline. */
     listWorkspaces(): Promise<ObjectValue[]>;
     /** List visible sessions, optionally filtering by the workspace's accounted IDs. */

package/dist/client.js

@@ -69,18 +69,35 @@ export class Client {
     get persistentCookie() {
         return this.expiresAt === undefined ? undefined : { cookie: this.cookie, expiresAt: this.expiresAt };
     }
+    /** Download the authenticated host ZIP without using a mutation or ordinary RPC deadline.
+     * @param sessionId - Selected session identity.
+     * @param signal - Cancels the streaming response.
+     * @returns Response whose body the caller must consume or cancel.
+     */
+    async sessionLog(sessionId, signal) {
+        const url = new URL('/api/session.export', this.base);
+        url.searchParams.set('sessionId', sessionId);
+        const response = await fetch(url, { redirect: 'error', headers: { cookie: this.cookie },
+            signal: AbortSignal.any([this.lifetime.signal, signal]) });
+        if (!response.ok) {
+            await response.body?.cancel();
+            throw new HttpError(response.status, 'Session log export');
+        }
+        return response;
+    }
     /** Invoke an exact endpoint once. Mutations are never automatically retried.
      * @param endpoint - Namespace/method endpoint.
      * @param args - Host parameter names and JSON values.
      * @param signal - Optional caller cancellation, combined with client close and timeout.
+     * @param timeoutMs - Per-call timeout; null waits for caller cancellation or client close.
      * @returns The decoded result value; HTTP, remote, and cancellation errors reject.
      */
-    async call(endpoint, args = {}, signal) {
+    async call(endpoint, args = {}, signal, timeoutMs = this.timeoutMs) {
         if (!/^[\w$-]+\/[\w$-]+$/.test(endpoint))
             throw new Error('Invalid RPC endpoint');
         const rpcId = randomUUID();
         const response = await fetch(new URL(`/api/${endpoint}`, this.base), {
-            method: 'POST', redirect: 'error', signal: signal ? AbortSignal.any([this.signal(), signal]) : this.signal(),
+            method: 'POST', redirect: 'error', signal: signal ? AbortSignal.any([this.signal(timeoutMs), signal]) : this.signal(timeoutMs),
             headers: { 'content-type': 'application/json', cookie: this.cookie },
             body: JSON.stringify({ type: 'client-request', rpcId, method: endpoint, payload: { args } }),
         });
@@ -160,6 +177,8 @@ export class Client {
                     socket.send(JSON.stringify({ type: 'cancel', streamId }));
             } };
     }
+    /** Archived session IDs from the latest authoritative workspace baseline. */
+    archivedSessionIds = new Set();
     /** List workspaces by consuming and cancelling the authoritative opening baseline. */
     async listWorkspaces() {
         return new Promise((resolve, reject) => {
@@ -174,6 +193,7 @@ export class Client {
                             const frame = object(value);
                             if (frame.type !== 'baseline')
                                 throw new Error('Workspace stream omitted its baseline');
+                            this.archivedSessionIds = new Set(array(object(frame.value).archivedSessionIds).map(string));
                             resolve(array(object(frame.value).items).map(object));
                         }
                         catch (error) {
@@ -212,8 +232,8 @@ export class Client {
             await closed;
         }
     }
-    signal() {
-        return AbortSignal.any([this.lifetime.signal, AbortSignal.timeout(this.timeoutMs)]);
+    signal(timeoutMs = this.timeoutMs) {
+        return timeoutMs === null ? this.lifetime.signal : AbortSignal.any([this.lifetime.signal, AbortSignal.timeout(timeoutMs)]);
     }
     fail(error) {
         const listeners = [...this.listeners.values()];

package/dist/controller.d.ts

@@ -2,8 +2,17 @@ import { Client } from './client.ts';
 import { CostLedger } from './cost.ts';
 import { Telemetry } from './telemetry.ts';
 import { Transcript } from './transcript.ts';
+import { type HistoryLimits } from './memory.ts';
 import { type FileReference } from './references.ts';
 import { type Json, type ObjectValue } from './wire.ts';
+/** Resolved navigation-removal identity; empty marks a fresh blank, idle session eligible for immediate archival. */
+export interface RemovalTarget {
+    kind: 'workspace' | 'session';
+    id: string;
+    name: string;
+    path?: string;
+    empty?: boolean;
+}
 /** State shared by the picker and conversation view. */
 export interface State {
     version: number;
@@ -20,9 +29,28 @@ export interface State {
     pending: ObjectValue[];
     controlError?: string;
     modelError?: string;
+    presetError?: string;
+    presets?: ObjectValue[];
     defaultModel?: ObjectValue;
     transcript: Transcript;
 }
+/** Bounded search results contain navigation summaries, never complete message bodies. */
+export interface HistorySearch {
+    items: {
+        seq: number;
+        role: string;
+        preview: string;
+    }[];
+    truncated: boolean;
+}
+/** Wire addresses for one `session/list` row, in the order the cost scan should try them.
+ *
+ * A subagent child is reachable only under its durable parent, and the list row omits the delivery
+ * mode, so both modes are offered with the continuable form first.
+ * @param session - One row from the host session list.
+ * @returns One plain-session address, or both subagent forms when the row is a child.
+ */
+export declare function costAddresses(session: ObjectValue): ObjectValue[];
 /** Owns reconnects and subscriptions. User commands remain single-attempt operations. */
 export declare class Controller {
     readonly base: string;
@@ -30,8 +58,10 @@ export declare class Controller {
     private makeClient;
     private authenticate;
     readonly costs?: CostLedger | undefined;
+    readonly historyLimits: HistoryLimits;
     state: State;
     private observers;
+    private interactions;
     private abort;
     private client;
     private clientId;
@@ -39,8 +69,10 @@ export declare class Controller {
     private runTask;
     private generationFailed;
     private selection;
+    private historyPinned;
     telemetry: Telemetry;
     private observedRunningAt;
+    private presetClient?;
     private catalogRevision;
     private catalogTasks;
     private runningUpdates;
@@ -55,6 +87,20 @@ export declare class Controller {
     get running(): boolean;
     /** Current title projection, falling back to the list title and then the session ID. */
     get sessionName(): string | undefined;
+    /** Current agent-preset name, matching the web header's built-in labels and custom metadata. */
+    get sessionMode(): string | undefined;
+    /** Load the optional preset roster once per connection, only when a session names a preset. */
+    loadPresetNames(): void;
+    /** Fetch current model routes and adapter-owned reasoning choices for the selected session.
+     * @returns Host catalog; provider failures remain available to the selector.
+     */
+    modelCatalog(): Promise<ObjectValue>;
+    /** 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.
+     */
+    selectModel(provider: string, model: string, reasoningEffort?: string): Promise<void>;
     /** Epoch start from the retained turn log, or when this client first observed the run. */
     get workingSince(): number | undefined;
     /** Stop the selected turn, or allow exit only while idle. Repeated keys share one request.
@@ -62,7 +108,7 @@ export declare class Controller {
      * @returns True when the caller may exit; cancellation failures retain the client.
      */
     interrupt(force?: boolean): Promise<boolean>;
-    constructor(base: string, token: string | undefined, initialSession?: string | undefined, makeClient?: () => Client, authenticate?: (client: Client) => Promise<void>, costs?: CostLedger | undefined);
+    constructor(base: string, token: string | undefined, initialSession?: string | undefined, makeClient?: () => Client, authenticate?: (client: Client) => Promise<void>, costs?: CostLedger | undefined, historyLimits?: HistoryLimits);
     /** React-compatible state subscription. */
     subscribe: (listener: () => void) => (() => void);
     /** Snapshot identity changes only when the controller publishes. */
@@ -71,6 +117,12 @@ export declare class Controller {
     start(): void;
     /** Cancel retries and HTTP, close the socket, and wait for the loop to settle. */
     stop(): Promise<void>;
+    /** Keep history stable while the user reads, searches, or expands it; trim again at the live tail.
+     * @param pinned - Whether the main transcript is actively being read away from its tail.
+     */
+    pinHistory(pinned: boolean): void;
+    private reclaimHistory;
+    private releaseTranscript;
     /** Stop the selected turn and then close, so quitting does not leave host work running.
      * An idle session stays untouched, and an in-flight cancellation is awaited rather than repeated.
      */
@@ -81,8 +133,22 @@ export declare class Controller {
      * @param signal - Optional cancellation for an explicit /cost refresh.
      */
     refreshCosts(signal?: AbortSignal): Promise<void>;
+    /** Read one session's complete cost history, retrying a subagent child with its other delivery mode. */
+    private sessionCostHistory;
+    /** Page one addressed session's history into the billing events the ledger folds. */
+    private readCostHistory;
     /** Refresh both lists from the host, then show the requested picker. */
     showPicker(screen: 'workspaces' | 'sessions'): Promise<void>;
+    /** Resolve a removal command to one reviewable object without changing the selection.
+     * @param kind - Workspace registration removal or session archival.
+     * @param query - Exact name, ID, or unambiguous ID prefix.
+     * @returns The fixed identity and display details for confirmation.
+     */
+    removalTarget(kind: 'workspace' | 'session', query: string): Promise<RemovalTarget>;
+    /** Apply a confirmed removal or freshly verified empty-session archival; directories and logs are preserved.
+     * @param target - Exact workspace or session identity reviewed by the user.
+     */
+    removeTarget(target: RemovalTarget): Promise<void>;
     /** Pick a workspace, or use all sessions when the identity is omitted. */
     pickWorkspace(workspaceId?: string): void;
     /** Open a workspace picker, or resolve a workspace by ID, exact title/path, or unique ID prefix. */
@@ -117,12 +183,40 @@ export declare class Controller {
      * @returns Validated candidates in host order.
      */
     references(query: string, signal: AbortSignal): Promise<FileReference[]>;
-    /** Admit a prompt once; a failed response can have an uncertain delivery outcome. */
-    prompt(text: string, mode?: 'queue' | 'steer'): Promise<void>;
+    /** Execute a human command directly, outside the model prompt queue.
+     * @param line - Complete slash command, including arguments.
+     * @param signal - Cancels the request while the host performs compaction.
+     * @returns The host's successful command result text.
+     */
+    command(line: string, signal: AbortSignal): Promise<string>;
+    /** Remove one host-owned pending input; an already claimed item reports a host error.
+     * @param itemId - Queue occurrence identity from session/control.
+     */
+    removeQueued(itemId: string): Promise<void>;
+    /** Export the selected host log to a new local ZIP file.
+     * @param path - Optional local destination; existing files are never overwritten.
+     * @param signal - Cancels the download and removes an incomplete file.
+     * @returns Absolute saved filename.
+     */
+    exportLog(path: string | undefined, signal: AbortSignal): Promise<string>;
+    /** Admit text once as steering while running, or a new turn while idle; a lost response can leave delivery uncertain. */
+    prompt(text: string): Promise<void>;
     /** Cancel the active turn; pending queue items remain host-owned. */
     cancelTurn(): Promise<void>;
     /** Add a page before the retained window using its fixed opening cut. */
-    older(signal?: AbortSignal): Promise<void>;
+    older(signal?: AbortSignal, transcript?: Transcript): Promise<void>;
+    /** Search one page at a time, preserving only the first 200 matches and releasing temporary content.
+     * @param query - Literal, case-insensitive text including folded reasoning.
+     * @param signal - Cancels HTTP and processing without cancelling the agent.
+     * @returns Newest-first bounded summaries and an explicit truncation flag.
+     */
+    searchHistory(query: string, signal: AbortSignal): Promise<HistorySearch>;
+    /** Load a separate small window ending at a search target; the live transcript keeps following.
+     * @param target - Durable message sequence to display.
+     * @param signal - Cancels the target-page request.
+     * @returns A caller-owned historical window that must be disposed when closed.
+     */
+    historyAt(target: number, signal: AbortSignal): Promise<Transcript>;
     /** Load the prefix required for an explicit history jump; never loop on an unadvancing page.
      * @param target - Visible record sequence, or first for the oldest available history.
      * @param signal - Cancels local paging without interrupting the remote agent.
@@ -138,7 +232,6 @@ export declare class Controller {
     private get sessionId();
     private update;
     private reply;
-    private releasePending;
     private refreshCatalog;
     private run;
 }