neoctl 0.1.20 → 0.1.22

package/dist/web/index.d.ts

@@ -1,2 +1,241 @@
 #!/usr/bin/env node
+import { type ServerResponse } from "node:http";
+import { QueryEngine } from "../core/query-engine.js";
+import { type ModelProviderName } from "../model/config.js";
+import { CommunicationLogger, LoggingModelGateway } from "../model/communication-logger.js";
+import type { ModelUsage, ReasoningConfig } from "../model/model-gateway.js";
+import { ToolRegistry } from "../tools/registry.js";
+import { type AgentToolRuntime } from "../agents/agent-tool.js";
+import { TaskStore } from "../tasks/task-store.js";
+import type { ContextMetrics } from "../types/events.js";
+export interface WebRuntime {
+    engine: QueryEngine;
+    communicationLogger: CommunicationLogger;
+    modelGateway: LoggingModelGateway;
+    agentRuntime: AgentToolRuntime;
+    usage: SessionUsageTracker;
+    taskStore: TaskStore;
+    tools: ToolRegistry;
+    initialMetrics: ContextMetrics;
+    defaultReasoning?: ReasoningConfig | null;
+    envPath: string;
+    envNotice?: string;
+}
+export interface UsageTotals {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    reasoningTokens: number;
+    cachedTokens: number;
+    requests: number;
+    computedTotalTokens: boolean;
+}
+export declare class SessionUsageTracker {
+    private totals;
+    private lastUsage?;
+    add(usage: ModelUsage): void;
+    reset(): void;
+    snapshot(): UsageTotals;
+}
+interface UiLineImage {
+    src: string;
+    label?: string;
+    mimeType: string;
+}
+interface UiLine {
+    id: number;
+    kind: "system" | "user" | "assistant" | "thinking" | "tool" | "error" | "meta";
+    text: string;
+    title?: string;
+    bodyTitle?: string;
+    titleStatus?: "success" | "failure";
+    format?: "markdown" | "ansi" | "plain" | "diff";
+    previewStyle?: "summary";
+    summaryMaxLines?: number;
+    live?: boolean;
+    pendingReplacement?: boolean;
+    collapsible?: boolean;
+    image?: UiLineImage;
+}
+interface UiStatus {
+    phase: string;
+    detail?: string;
+    metrics?: ContextMetrics;
+    usage?: ModelUsage;
+    streamedOutputTokens: number;
+    activityTick: number;
+    inputTokenUpdatedAt?: number;
+    outputTokenUpdatedAt?: number;
+    retryCooldownUntil?: number;
+}
+export interface WebServerOptions {
+    host: string;
+    port: number;
+}
+export interface CreateWebRuntimeOptions {
+    /** Override the initial session id for this runtime. */
+    sessionId?: string;
+    /** Override whether the initial session should resume transcript history. */
+    resume?: boolean;
+    /** Override the QueryEngine agent id. Defaults to main. */
+    agentId?: string;
+}
+export interface WebRuntimeScope {
+    /** Browser-tab or client-instance identifier. Omit for the legacy singleton runtime. */
+    tabId?: string;
+    /** Optional session id used when a scoped runtime is created after page refresh/process restart. */
+    sessionId?: string;
+}
+export interface WebRuntimeRouterOptions {
+    createRuntime?: (options?: CreateWebRuntimeOptions) => Promise<WebRuntime>;
+    createRepl?: (runtime: WebRuntime) => WebRepl;
+}
+type LoginProviderName = ModelProviderName;
+interface LoginFieldDefinition {
+    key: string;
+    label: string;
+    envKey: string;
+    scope: "provider" | "shared";
+    required?: boolean;
+    secret?: boolean;
+    placeholder?: string;
+    options?: readonly string[];
+}
+interface LoginFormPayload {
+    envPath: string;
+    providers: LoginProviderName[];
+    provider: LoginProviderName;
+    fields: LoginFieldDefinition[];
+    values: Record<string, string>;
+}
+interface WebAttachmentPayload {
+    kind: "image";
+    label: string;
+    mimeType: string;
+    data: string;
+}
 export declare function runWebServer(argv?: string[]): Promise<void>;
+export declare function createWebRuntime(options?: CreateWebRuntimeOptions): Promise<WebRuntime>;
+export declare class WebRuntimeRouter {
+    private readonly repls;
+    private readonly createRuntime;
+    private readonly createRepl;
+    constructor(options?: WebRuntimeRouterOptions);
+    get(scope?: WebRuntimeScope): Promise<WebRepl>;
+    snapshot(scope?: WebRuntimeScope, includeCatalog?: boolean): Promise<ReturnType<WebRepl["snapshot"]>>;
+    activeScopes(): string[];
+}
+export declare function createWebRuntimeRouter(options?: WebRuntimeRouterOptions): Promise<WebRuntimeRouter>;
+export declare class WebRepl {
+    private runtime;
+    private readonly subscribers;
+    private lineId;
+    private assistantLineId;
+    private thinkingLineId;
+    private finalizedThinkingLineId;
+    private activeAbortController;
+    private interruptArmed;
+    private readonly toolLineIds;
+    private lines;
+    private status;
+    private busy;
+    private queuedInput;
+    private foregroundRun;
+    private foregroundRunToken;
+    private readonly backgroundSessionRuns;
+    private readonly suppressReattachedStreaming;
+    private backgroundTaskCount;
+    constructor(runtime: WebRuntime);
+    subscribe(res: ServerResponse): void;
+    snapshot(includeCatalog?: boolean): {
+        lines: UiLine[];
+        status: UiStatus;
+        busy: boolean;
+        queuedInput: string | undefined;
+        backgroundTaskCount: number;
+        backgroundTasks: {
+            taskId: string;
+            agentId: string;
+            type: import("../index.js").LocalAgentTaskType;
+            status: import("../index.js").LocalAgentTaskStatus;
+            description: string;
+            createdAt: string;
+        }[];
+        backgroundSessionRunCount: number;
+        runningSessionIds: string[];
+        session: import("../index.js").SessionStoreSnapshot | undefined;
+        catalog: {
+            commands: import("../repl/commands.js").ReplCommandDefinition[];
+            modelIds: string[];
+            reasoning: string[];
+            envPath: string;
+        } | undefined;
+        interactive: {
+            sessions: boolean;
+            login: LoginFormPayload;
+        } | undefined;
+        tips: import("../tips.js").AppTip[] | undefined;
+        tipIndex: number;
+    };
+    submit(text: string, attachments?: WebAttachmentPayload[]): Promise<{
+        ok: true;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    listSessions(): Promise<{
+        sessions: import("../index.js").SessionSummary[];
+        runningSessionIds: string[];
+    }>;
+    resumeSession(sessionId: string): Promise<{
+        ok: true;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    newSession(): Promise<{
+        ok: true;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    private refreshSessionView;
+    deleteSession(sessionId: string): Promise<{
+        ok: true;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    loginForm(providerValue?: string): LoginFormPayload;
+    saveLogin(providerValue: string, values: Record<string, string>): Promise<{
+        ok: true;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    interrupt(): {
+        ok: true;
+        interrupted: boolean;
+    };
+    private append;
+    private updateLine;
+    private replaceLineText;
+    private replaceLine;
+    private setBusy;
+    private setStatus;
+    private finalizeForegroundView;
+    private stopForegroundRun;
+    private backgroundTasks;
+    private detachRunningForeground;
+    private reattachRunningSession;
+    private reduce;
+    private finalizeLiveLine;
+    private finalizeThinkingLine;
+    private finalizeActiveToolLines;
+    private handleEvent;
+    private handleCommandOrPrompt;
+    private runCompaction;
+    private send;
+    private broadcastSync;
+}
+export {};

package/dist/web/index.js

@@ -34,7 +34,7 @@ const highlightPackageDir = path.dirname(require.resolve("@highlightjs/cdn-asset
 const markedAssetPath = path.join(markedPackageDir, "lib", "marked.esm.js");
 const highlightAssetPath = path.join(highlightPackageDir, "highlight.min.js");
 const highlightThemeAssetPath = path.join(highlightPackageDir, "styles", "atom-one-dark.min.css");
-class SessionUsageTracker {
+export class SessionUsageTracker {
     totals = emptyUsageTotals();
     lastUsage;
     add(usage) {
@@ -78,11 +78,11 @@ function sumUsageTokens(left, right) {
         return undefined;
     return (left ?? 0) + (right ?? 0);
 }
+const DEFAULT_WEB_RUNTIME_KEY = "__default__";
 export async function runWebServer(argv = process.argv.slice(2)) {
     const options = parseWebArgs(argv);
-    const runtime = await createRuntime();
-    const repl = new WebRepl(runtime);
-    const server = http.createServer((req, res) => void route(req, res, repl));
+    const router = await createWebRuntimeRouter();
+    const server = http.createServer((req, res) => void route(req, res, router));
     await new Promise((resolve) => server.listen(options.port, options.host, resolve));
     const address = server.address();
     const actualPort = typeof address === "object" && address ? address.port : options.port;
@@ -106,7 +106,7 @@ function parseWebArgs(argv) {
         port = 3000;
     return { host, port: Math.round(port) };
 }
-async function createRuntime() {
+export async function createWebRuntime(options = {}) {
     const envLoad = loadDefaultDotEnvFiles({ override: true });
     const modelConfig = readModelProviderConfig(process.env);
     const communicationLogger = new CommunicationLogger();
@@ -137,7 +137,7 @@ async function createRuntime() {
     for (const tool of createTaskTools(taskStore, resumeHandler))
         tools.register(tool);
     const engine = new QueryEngine({
-        agentId: "main",
+        agentId: options.agentId ?? "main",
         model: modelConfig?.model,
         fallbackModel: modelConfig?.fallbackModel,
         reasoning: modelConfig?.defaultReasoning,
@@ -148,9 +148,9 @@ async function createRuntime() {
         commands: replCommandDefinitions.map((command) => command.usage),
         session: {
             enabled: process.env.AGENT_SESSION_TRANSCRIPT !== "0",
-            sessionId: process.env.AGENT_SESSION_ID,
+            sessionId: options.sessionId ?? process.env.AGENT_SESSION_ID,
             rootDir: process.env.AGENT_SESSION_DIR,
-            resume: parseResumeFlag(process.env.AGENT_SESSION_RESUME),
+            resume: options.resume ?? parseResumeFlag(process.env.AGENT_SESSION_RESUME),
             toolResultThresholdChars: process.env.AGENT_TOOL_RESULT_THRESHOLD_CHARS ? Number(process.env.AGENT_TOOL_RESULT_THRESHOLD_CHARS) : undefined,
         },
     });
@@ -199,7 +199,46 @@ function parseResumeFlag(value) {
         return false;
     return ["1", "true", "yes", "latest"].includes(value.toLowerCase());
 }
-class WebRepl {
+export class WebRuntimeRouter {
+    repls = new Map();
+    createRuntime;
+    createRepl;
+    constructor(options = {}) {
+        this.createRuntime = options.createRuntime ?? createWebRuntime;
+        this.createRepl = options.createRepl ?? ((runtime) => new WebRepl(runtime));
+    }
+    get(scope = {}) {
+        const key = webRuntimeScopeKey(scope);
+        let repl = this.repls.get(key);
+        if (!repl) {
+            repl = this.createRuntime({ sessionId: scope.sessionId, resume: scope.sessionId ? true : scope.tabId ? false : undefined }).then((runtime) => this.createRepl(runtime));
+            this.repls.set(key, repl);
+            repl.catch(() => this.repls.delete(key));
+        }
+        return repl;
+    }
+    async snapshot(scope = {}, includeCatalog = true) {
+        return (await this.get(scope)).snapshot(includeCatalog);
+    }
+    activeScopes() {
+        return [...this.repls.keys()];
+    }
+}
+export async function createWebRuntimeRouter(options = {}) {
+    const router = new WebRuntimeRouter(options);
+    await router.get();
+    return router;
+}
+function webRuntimeScopeKey(scope) {
+    const tabId = scope.tabId?.trim();
+    if (tabId)
+        return `tab:${tabId}`;
+    const sessionId = scope.sessionId?.trim();
+    if (sessionId)
+        return `session:${sessionId}`;
+    return DEFAULT_WEB_RUNTIME_KEY;
+}
+export class WebRepl {
     runtime;
     subscribers = new Set();
     lineId = 0;
@@ -801,7 +840,7 @@ function reqKeepAlive(res) {
     timer.unref?.();
     res.on("close", () => clearInterval(timer));
 }
-async function route(req, res, repl) {
+async function route(req, res, router) {
     const url = new URL(req.url ?? "/", "http://localhost");
     try {
         if (req.method === "GET" && url.pathname === "/")
@@ -812,6 +851,8 @@ async function route(req, res, repl) {
             return sendFile(res, highlightAssetPath, "text/javascript; charset=utf-8");
         if (req.method === "GET" && url.pathname === "/vendor/highlight-theme.css")
             return sendFile(res, highlightThemeAssetPath, "text/css; charset=utf-8");
+        const scope = webRuntimeScopeFromUrl(url);
+        const repl = await router.get(scope);
         if (req.method === "GET" && url.pathname === "/events")
             return repl.subscribe(res);
         if (req.method === "GET" && url.pathname === "/api/state")
@@ -846,6 +887,16 @@ async function route(req, res, repl) {
         sendJson(res, { error: error instanceof Error ? error.message : String(error) }, 500);
     }
 }
+function webRuntimeScopeFromUrl(url) {
+    return {
+        tabId: optionalSearchParam(url, "tabId"),
+        sessionId: optionalSearchParam(url, "sessionId"),
+    };
+}
+function optionalSearchParam(url, key) {
+    const value = url.searchParams.get(key)?.trim();
+    return value ? value : undefined;
+}
 function sendHtml(res, body) {
     res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store" });
     res.end(body);