@linkshell/host 0.1.0 → 0.1.2

package/dist/host/src/hub.d.ts

@@ -1,8 +1,10 @@
-import { type AgentInfo, type ContentBlock, type SessionEvent, type SessionSummary } from "@linkshell/wire";
+import { type AgentInfo, type ContentBlock, type SessionEvent, type SessionSummary, type SubagentInfo, type GitInfo, type ProjectSummary, type WorktreeEntry } from "@linkshell/wire";
 import type { AgentDriver, DesktopController, DesktopLaunchContext, DriverHost, LaunchSpec } from "./drivers/types.js";
-import type { HostStore } from "./store.js";
+import { type HostStore } from "./store.js";
 export interface Subscriber {
     event(event: SessionEvent): void;
+    /** The backlog that follows starts after `startSeq`, not where the subscriber left off. */
+    window?(startSeq: number): void;
 }
 /**
  * The host's source of truth for sessions. Drivers push native events in;
@@ -12,16 +14,23 @@ export interface Subscriber {
 export declare class SessionHub {
     private readonly store;
     private readonly log;
+    /** Where the host keeps its own files: worktrees go under it. */
+    private readonly home;
     private readonly drivers;
     private readonly live;
     private readonly summaryListeners;
+    private readonly removedListeners;
     private readonly auth;
     /** Terminals (`linkshell <agent>`) currently driving handoff sessions. */
     private readonly desktops;
     private discoveryTimer?;
+    private readonly branches;
+    private worktreeCache?;
     private authRefreshing?;
     readonly driverHost: DriverHost;
-    constructor(store: HostStore, drivers: AgentDriver[], log?: (message: string) => void);
+    constructor(store: HostStore, drivers: AgentDriver[], log?: (message: string) => void, 
+    /** Where the host keeps its own files: worktrees go under it. */
+    home?: string);
     start(options?: {
         discoveryIntervalMs?: number;
     }): Promise<void>;
@@ -41,14 +50,16 @@ export declare class SessionHub {
         sessions: SessionSummary[];
         nextBefore?: number;
     };
-    listProjects(limit?: number): {
-        name: string;
-        cwd: string;
-        lastActiveAt: number;
-        sessionCount: number;
-    }[];
+    /** Projects, each with the branch checked out there now. */
+    listProjects(limit?: number): Promise<ProjectSummary[]>;
+    /** Asked for every project each time the list is: remembered for a moment. */
+    private branchOf;
     getSession(sessionId: string): SessionSummary;
     /** Adds the live-only fields (current activity, first pending permission) to a stored summary. */
+    /** Marks a session that works in one of LinkShell's worktrees. */
+    private withWorktree;
+    /** The worktrees table, read once and again whenever it changes. */
+    private worktrees;
     private decorate;
     createSession(input: {
         agent: string;
@@ -56,17 +67,88 @@ export declare class SessionHub {
         model?: string;
         prompt?: ContentBlock[];
         clientMessageId?: string;
+        /** Start in a new git worktree of `cwd`'s repository. */
+        worktree?: boolean;
+    }): Promise<SessionSummary>;
+    /**
+     * A new session that starts with this one's conversation: all of it, or
+     * through the turn `itemId` is in. With `worktree` it works in a new git
+     * worktree of the project.
+     */
+    fork(sessionId: string, options?: {
+        itemId?: string;
+        worktree?: boolean;
     }): Promise<SessionSummary>;
     /**
-     * Sends everything after `fromSeq`, then streams live events. The backlog read
-     * and the subscriber registration happen in one synchronous step, so no event
-     * can fall between them.
+     * A fork for an agent that can't fork a session itself: a new session that
+     * shows the conversation up to `cut` (its latest page, from our log), whose
+     * agent is told that conversation with the first message sent to it.
+     */
+    private forkByReplay;
+    /** Hands a message to the agent — with the conversation a forked session still owes it, the first time. */
+    private deliver;
+    gitInfo(path: string): Promise<GitInfo | undefined>;
+    private newWorktree;
+    private dropWorktree;
+    listWorktrees(): Promise<WorktreeEntry[]>;
+    /** Removes a worktree and its branch, unless a session uses it or (without `force`) work in it would be lost. */
+    removeWorktree(path: string, force?: boolean): Promise<void>;
+    /**
+     * Sends the backlog, then streams live events. A fresh subscriber (or one too
+     * far behind to catch up) gets the latest turns only, after the standing
+     * state from before them; earlier history is read in pages (`history`).
+     * The backlog read and the subscriber registration happen in one synchronous
+     * step, so no event can fall between them.
+     */
+    subscribe(sessionId: string, fromSeq: number, subscriber: Subscriber): Promise<{
+        session: SessionSummary;
+        startSeq: number;
+    }>;
+    /**
+     * A handoff agent names its commands only once it runs here, so a session
+     * still driven at the desk has none to offer. It borrows the list of the
+     * agent's latest session in the same folder (or its latest anywhere) until
+     * it gets its own: `/compact` typed on the phone works from the first message.
      */
-    subscribe(sessionId: string, fromSeq: number, subscriber: Subscriber): Promise<SessionSummary>;
+    private lendCommands;
+    /** The page of history before `beforeSeq`, oldest first. */
+    history(sessionId: string, beforeSeq: number): {
+        events: SessionEvent[];
+        startSeq: number;
+    };
+    /** The sub-agents the session started, newest first. */
+    subagents(sessionId: string): SubagentInfo[];
+    private subagentsOf;
+    /** Keeps the sub-agent tally current; true when it changed. */
+    private trackSubagent;
+    /** A sub-agent's conversation: its call, then what happened under it. */
+    subagent(sessionId: string, toolCallId: string): SessionEvent[];
+    readEvent(sessionId: string, seq: number): SessionEvent | undefined;
+    /** What still holds at `seq` from the events before it: settings, an open turn, unanswered approvals. */
+    private standingBefore;
     unsubscribe(sessionId: string, subscriber: Subscriber): void;
-    prompt(sessionId: string, clientMessageId: string, content: ContentBlock[]): Promise<"started" | "steered" | "queued" | "duplicate">;
+    prompt(sessionId: string, clientMessageId: string, content: ContentBlock[], whenBusy?: "queue"): Promise<"started" | "steered" | "queued" | "duplicate">;
     /** Retries attaching a session that just became joinable. */
     private attachWhenReady;
+    unqueue(sessionId: string, clientMessageId: string): boolean;
+    reorderQueue(sessionId: string, clientMessageIds: string[]): void;
+    /**
+     * Sends a queued message without waiting for the running turn to end: into
+     * that turn if the agent takes input mid-turn, otherwise by stopping it.
+     */
+    sendQueuedNow(sessionId: string, clientMessageId?: string): Promise<void>;
+    /** A turn ended: the next held message starts the following one. */
+    private sendHeld;
+    onRemoved(listener: (sessionId: string) => void): () => void;
+    archive(sessionId: string, archived: boolean): Promise<SessionSummary>;
+    rename(sessionId: string, title: string): Promise<SessionSummary>;
+    /**
+     * Deletes a session. A worktree only it used goes too when nothing in it
+     * would be lost (or `worktree` says "remove"); "keep" leaves it.
+     */
+    delete(sessionId: string, worktree?: "keep" | "remove"): Promise<void>;
+    /** Drops a session from LinkShell and tells every client. */
+    private forget;
     cancel(sessionId: string): Promise<void>;
     respondPermission(sessionId: string, requestId: string, optionId: string): Promise<void>;
     desktopLaunch(agent: string, args: string[], sessionId: string | undefined, context: DesktopLaunchContext): Promise<LaunchSpec & {
@@ -85,5 +167,7 @@ export declare class SessionHub {
     private ingest;
     private commit;
     private applyToSummary;
+    /** Sends the session's current summary to every client (its queue or activity changed). */
+    private announce;
     private emitSummary;
 }