@truss-harness/tui 0.1.14 → 0.1.18

package/dist/processes.js

@@ -0,0 +1,65 @@
+import { execFile as execFileCallback, spawn, } from "node:child_process";
+import { promisify } from "node:util";
+const execFile = promisify(execFileCallback);
+export async function runTrackedCommand(command, workspaceRoot, onOutput, onProcess) {
+    await new Promise((resolve, reject) => {
+        const child = spawn(command, {
+            cwd: workspaceRoot,
+            shell: true,
+            windowsHide: true,
+        });
+        onProcess?.(child);
+        child.stdout.on("data", (data) => onOutput(data.toString()));
+        child.stderr.on("data", (data) => onOutput(data.toString()));
+        child.on("error", reject);
+        child.on("close", (code) => {
+            onProcess?.(undefined);
+            onOutput(`\n[process exited: ${code ?? "unknown"}]\n`);
+            resolve();
+        });
+    });
+}
+export function detectedPreviewUrl(output) {
+    const match = output.match(/https?:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1\])(?::\d+)?(?:\/[^\s]*)?/i);
+    return match?.[0].replace(/[),.;]+$/, "").replace("0.0.0.0", "127.0.0.1");
+}
+export function normalizedPreviewUrl(value) {
+    const normalized = /^[a-z][a-z\d+.-]*:\/\//i.test(value.trim())
+        ? value.trim()
+        : `http://${value.trim()}`;
+    const url = new URL(normalized);
+    if (url.protocol !== "http:" && url.protocol !== "https:")
+        throw new Error("Preview URLs must use HTTP or HTTPS.");
+    return url.toString();
+}
+export function openExternalPreview(value) {
+    const url = normalizedPreviewUrl(value);
+    const [command, arguments_] = process.platform === "win32"
+        ? ["rundll32.exe", ["url.dll,FileProtocolHandler", url]]
+        : process.platform === "darwin"
+            ? ["open", [url]]
+            : ["xdg-open", [url]];
+    const child = spawn(command, arguments_, {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+    });
+    child.once("error", () => undefined);
+    child.unref();
+}
+export async function readWorkingTreeDiff(workspaceRoot, path) {
+    const { stdout } = await execFile("git", ["diff", "--no-ext-diff", "--", path], { cwd: workspaceRoot, maxBuffer: 1_000_000 });
+    return stdout;
+}
+export async function stopProcessTree(child) {
+    if (process.platform === "win32" && child.pid) {
+        try {
+            await execFile("taskkill", ["/PID", String(child.pid), "/T", "/F"]);
+            return;
+        }
+        catch {
+            // Fall back to the Node process handle if taskkill is unavailable.
+        }
+    }
+    child.kill();
+}

package/dist/runtime-session.d.ts

@@ -0,0 +1,40 @@
+import type { ResolvedConfiguration } from "@truss-harness/cli/config";
+import { type ClientConfiguration } from "@truss-harness/cli/runtime";
+import { type ModelProviderKind } from "@truss-harness/provider-openai-compatible";
+import { type ToolCall, type WorkspacePlan } from "@truss-harness/runtime";
+import type { ChatMessage, RunStatus, Screen } from "./types.js";
+export interface RuntimeSessionOptions {
+    readonly initialConfiguration?: ResolvedConfiguration;
+    readonly workspaceRoot: string;
+    readonly providerKind: ModelProviderKind;
+    readonly endpointInput: string;
+    readonly modelInput: string;
+    readonly agentMode: ClientConfiguration["mode"];
+    readonly permissionMode: ResolvedConfiguration["permission"];
+    readonly internetAccess: boolean;
+    readonly openFilePath?: string;
+    readonly contextWindow: number;
+    readonly appendTerminal: (output: string) => void;
+    readonly showScreen: (screen: Screen) => void;
+}
+export declare function useRuntimeSessionController({ initialConfiguration, workspaceRoot, providerKind, endpointInput, modelInput, agentMode, permissionMode, internetAccess, openFilePath, contextWindow, appendTerminal, showScreen, }: RuntimeSessionOptions): {
+    configuration: ClientConfiguration | undefined;
+    mcpStatuses: readonly import("@truss-harness/mcp").McpServerStatus[];
+    sessionId: string | undefined;
+    chatInput: string;
+    setChatInput: import("react").Dispatch<import("react").SetStateAction<string>>;
+    chat: ChatMessage[];
+    chatScroll: number;
+    setChatScroll: import("react").Dispatch<import("react").SetStateAction<number>>;
+    busy: boolean;
+    runStatus: RunStatus;
+    activePlan: WorkspacePlan | undefined;
+    pendingTool: ToolCall | undefined;
+    tokensPerSecond: number | undefined;
+    configureRuntime: () => Promise<void>;
+    sendPrompt: () => Promise<void>;
+    resolveApproval: (approved: boolean) => void;
+    startNewConversation: () => void;
+    cancelRun: () => void;
+    testMcpConnections: () => void;
+};

package/dist/runtime-session.js

@@ -0,0 +1,287 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { createClientRuntime, } from "@truss-harness/cli/runtime";
+import { cloudProviderDefinition, isCloudProviderId, } from "@truss-harness/provider-openai-compatible";
+import { executeWorkspaceCommand, FileWorkspacePlanStore, } from "@truss-harness/runtime";
+import { useEffect, useRef, useState } from "react";
+import { estimateTokens, truncate } from "./display.js";
+export function useRuntimeSessionController({ initialConfiguration, workspaceRoot, providerKind, endpointInput, modelInput, agentMode, permissionMode, internetAccess, openFilePath, contextWindow, appendTerminal, showScreen, }) {
+    const [configuration, setConfiguration] = useState(initialConfiguration);
+    const [client, setClient] = useState();
+    const [mcpStatuses, setMcpStatuses] = useState(() => Object.entries(initialConfiguration?.mcpServers ?? {}).map(([name, server]) => ({
+        name,
+        state: server.enabled === false ? "disabled" : "idle",
+        toolCount: 0,
+    })));
+    const [sessionId, setSessionId] = useState();
+    const [chatInput, setChatInput] = useState("");
+    const [chat, setChat] = useState([]);
+    const [chatScroll, setChatScroll] = useState(0);
+    const [streamMetrics, setStreamMetrics] = useState({
+        startedAt: 0,
+        generatedTokens: 0,
+    });
+    const [busy, setBusy] = useState(false);
+    const [runStatus, setRunStatus] = useState("ready");
+    const [activePlan, setActivePlan] = useState();
+    const [pendingTool, setPendingTool] = useState();
+    const approvalResolvers = useRef(new Map());
+    const abortController = useRef(undefined);
+    useEffect(() => {
+        void new FileWorkspacePlanStore(workspaceRoot)
+            .load()
+            .then(setActivePlan)
+            .catch(() => undefined);
+    }, [workspaceRoot]);
+    useEffect(() => {
+        if (!client)
+            return;
+        const unsubscribeMcp = client.mcp.subscribe((statuses) => setMcpStatuses((current) => {
+            const merged = new Map(current.map((status) => [status.name, status]));
+            for (const status of statuses)
+                merged.set(status.name, status);
+            return [...merged.values()];
+        }));
+        const unsubscribe = client.events.subscribe((event) => {
+            if (event.type === "text_delta") {
+                setRunStatus("thinking");
+                setChatScroll(0);
+                setStreamMetrics((current) => current.startedAt
+                    ? {
+                        ...current,
+                        generatedTokens: current.generatedTokens + estimateTokens(event.text),
+                    }
+                    : current);
+                setChat((current) => {
+                    const last = current.at(-1);
+                    if (last?.role !== "assistant")
+                        return [...current, { role: "assistant", content: event.text }];
+                    return [
+                        ...current.slice(0, -1),
+                        { role: "assistant", content: last.content + event.text },
+                    ];
+                });
+            }
+            if (event.type === "tool_call_requested") {
+                setRunStatus("tool");
+                appendTerminal(`[tool requested] ${event.tool} ${JSON.stringify(event.input)}`);
+            }
+            if (event.type === "tool_completed") {
+                setRunStatus("thinking");
+                appendTerminal(`[tool completed] ${event.tool}: ${truncate(event.result.content, 160)}`);
+            }
+            if (event.type === "plan_updated")
+                setActivePlan(event.plan);
+            if (event.type === "run_failed") {
+                setRunStatus("ready");
+                appendTerminal(`[agent error] ${event.error.message}`);
+            }
+        });
+        return () => {
+            unsubscribe();
+            unsubscribeMcp();
+            void client.dispose();
+        };
+    }, [client, appendTerminal]);
+    const configureRuntime = async () => {
+        if (!endpointInput.trim() || !modelInput.trim()) {
+            appendTerminal("[configuration] An endpoint and model are required.");
+            return;
+        }
+        const nextConfiguration = {
+            workspaceRoot,
+            provider: providerKind,
+            baseUrl: endpointInput.trim(),
+            model: modelInput.trim(),
+            apiKey: initialConfiguration?.provider === providerKind
+                ? initialConfiguration.apiKey
+                : (process.env.TRUSS_HARNESS_API_KEY ??
+                    (isCloudProviderId(providerKind)
+                        ? process.env[cloudProviderDefinition(providerKind)
+                            .apiKeyEnvironmentVariable]
+                        : undefined)),
+            systemPrompt: process.env.TRUSS_HARNESS_SYSTEM_PROMPT,
+            mode: agentMode,
+            internetAccess,
+            mcpServers: initialConfiguration?.mcpServers,
+            approval: {
+                approve: async (call) => {
+                    const readOnly = [
+                        "read_file",
+                        "list_directory",
+                        "search_files",
+                        "grep",
+                    ].includes(call.name);
+                    if (permissionMode === "auto-all" ||
+                        (permissionMode === "auto-read" && readOnly))
+                        return true;
+                    return new Promise((resolve) => {
+                        approvalResolvers.current.set(call.id, resolve);
+                        setPendingTool(call);
+                        setRunStatus("waiting");
+                        showScreen("approval");
+                    });
+                },
+            },
+        };
+        setConfiguration(nextConfiguration);
+        setRunStatus("thinking");
+        try {
+            const nextClient = await createClientRuntime(nextConfiguration);
+            setClient(nextClient);
+            for (const server of nextClient.mcpServers) {
+                appendTerminal(`[mcp] ${server.name}: ${server.state}${server.error ? ` (${server.error})` : ` (${server.toolCount} tools)`}`);
+            }
+        }
+        catch (error) {
+            appendTerminal(`[mcp] Unable to configure runtime: ${error instanceof Error ? error.message : String(error)}`);
+            setRunStatus("ready");
+            return;
+        }
+        setSessionId(undefined);
+        setChat([]);
+        setChatScroll(0);
+        setStreamMetrics({ startedAt: 0, generatedTokens: 0 });
+        showScreen("workspace");
+        appendTerminal(`[configuration] ${nextConfiguration.provider} ${nextConfiguration.model} at ${nextConfiguration.baseUrl}`);
+        setRunStatus("ready");
+    };
+    // biome-ignore lint/correctness/useExhaustiveDependencies: startup configuration intentionally runs exactly once; subsequent changes are applied explicitly.
+    useEffect(() => {
+        if (initialConfiguration && !client)
+            void configureRuntime();
+    }, []);
+    const openFileContext = async () => {
+        if (!openFilePath)
+            return [];
+        try {
+            const maximumCharacters = Math.max(2_000, Math.min(20_000, contextWindow));
+            const content = await readFile(join(workspaceRoot, openFilePath), "utf8");
+            const clipped = content.slice(0, maximumCharacters);
+            return [
+                {
+                    source: `active-file:${openFilePath}`,
+                    content: `This is the currently open workspace file and the primary context for this request. Tool results produced later in the run take precedence over this request-start snapshot.\n\n${clipped}`,
+                    priority: 1_000,
+                },
+            ];
+        }
+        catch {
+            return [];
+        }
+    };
+    const sendPrompt = async () => {
+        const prompt = chatInput.trim();
+        if (!prompt || busy)
+            return;
+        const command = await executeWorkspaceCommand({
+            workspaceRoot,
+            input: prompt,
+        });
+        if (command.handled) {
+            setChatInput("");
+            setChat((current) => [
+                ...current,
+                { role: "user", content: prompt },
+                { role: "assistant", content: command.message },
+            ]);
+            appendTerminal(`[workspace command] ${command.command ?? prompt}: ${command.ok ? "completed" : "failed"}`);
+            return;
+        }
+        if (!client) {
+            showScreen("settings");
+            appendTerminal("[configuration] Select a local model before sending a prompt.");
+            return;
+        }
+        setChatInput("");
+        setChatScroll(0);
+        setBusy(true);
+        setRunStatus("thinking");
+        setStreamMetrics({ startedAt: Date.now(), generatedTokens: 0 });
+        setChat((current) => [
+            ...current,
+            { role: "user", content: prompt },
+            { role: "assistant", content: "" },
+        ]);
+        const controller = new AbortController();
+        abortController.current = controller;
+        try {
+            const session = sessionId
+                ? await client.runtime.getSession(sessionId)
+                : await client.runtime.createSession();
+            if (!session)
+                throw new Error("Conversation is unavailable.");
+            setSessionId(session.id);
+            await client.runtime.run(session.id, prompt, controller.signal, await openFileContext());
+        }
+        catch (error) {
+            if (!controller.signal.aborted)
+                appendTerminal(`[agent error] ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            setBusy(false);
+            setRunStatus("ready");
+            abortController.current = undefined;
+        }
+    };
+    const resolveApproval = (approved) => {
+        if (pendingTool)
+            approvalResolvers.current.get(pendingTool.id)?.(approved);
+        setPendingTool(undefined);
+        setRunStatus(approved ? "thinking" : "ready");
+        showScreen("workspace");
+    };
+    const startNewConversation = () => {
+        if (busy) {
+            appendTerminal("[conversation] Stop the active run before starting a new conversation.");
+            return;
+        }
+        setSessionId(undefined);
+        setChat([]);
+        setChatInput("");
+        setChatScroll(0);
+        setStreamMetrics({ startedAt: 0, generatedTokens: 0 });
+        appendTerminal("[conversation] Started a new conversation.");
+    };
+    const cancelRun = () => {
+        abortController.current?.abort();
+        setRunStatus("ready");
+        appendTerminal("[agent] Cancellation requested.");
+    };
+    const testMcpConnections = () => {
+        if (!configuration)
+            return;
+        void createClientRuntime({ ...configuration, mode: "edit" })
+            .then(async (inspection) => {
+            setMcpStatuses(inspection.mcpServers);
+            appendTerminal("[mcp] Tested configured servers.");
+            await inspection.dispose();
+        })
+            .catch((error) => appendTerminal(`[mcp] ${error instanceof Error ? error.message : String(error)}`));
+    };
+    const tokensPerSecond = streamMetrics.startedAt && streamMetrics.generatedTokens
+        ? streamMetrics.generatedTokens /
+            Math.max((Date.now() - streamMetrics.startedAt) / 1_000, 0.1)
+        : undefined;
+    return {
+        configuration,
+        mcpStatuses,
+        sessionId,
+        chatInput,
+        setChatInput,
+        chat,
+        chatScroll,
+        setChatScroll,
+        busy,
+        runStatus,
+        activePlan,
+        pendingTool,
+        tokensPerSecond,
+        configureRuntime,
+        sendPrompt,
+        resolveApproval,
+        startNewConversation,
+        cancelRun,
+        testMcpConnections,
+    };
+}

package/dist/terminal-controller.d.ts

@@ -0,0 +1,15 @@
+export interface TerminalLine {
+    readonly id: number;
+    readonly text: string;
+}
+export declare function useTerminalController(workspaceRoot: string): {
+    terminalLines: TerminalLine[];
+    terminalScroll: number;
+    setTerminalScroll: import("react").Dispatch<import("react").SetStateAction<number>>;
+    commandInput: string;
+    setCommandInput: import("react").Dispatch<import("react").SetStateAction<string>>;
+    previewUrl: string | undefined;
+    appendTerminal: (output: string) => void;
+    runTerminalInput: (input: string) => Promise<void>;
+    interruptProcess: () => boolean;
+};

package/dist/terminal-controller.js

@@ -0,0 +1,57 @@
+import { executeWorkspaceCommand } from "@truss-harness/runtime";
+import { useCallback, useRef, useState } from "react";
+import { detectedPreviewUrl, runTrackedCommand, stopProcessTree, } from "./processes.js";
+export function useTerminalController(workspaceRoot) {
+    const nextLineId = useRef(1);
+    const [terminalLines, setTerminalLines] = useState([
+        {
+            id: 0,
+            text: "Terminal ready. Shell commands run in the workspace root; slash commands run locally.",
+        },
+    ]);
+    const [terminalScroll, setTerminalScroll] = useState(0);
+    const [commandInput, setCommandInput] = useState("");
+    const [previewUrl, setPreviewUrl] = useState();
+    const terminalProcess = useRef(undefined);
+    const appendTerminal = useCallback((output) => {
+        const next = output.replace(/\r/g, "").split("\n").filter(Boolean);
+        if (!next.length)
+            return;
+        const detected = detectedPreviewUrl(output);
+        if (detected)
+            setPreviewUrl(detected);
+        setTerminalScroll(0);
+        const entries = next.map((text) => ({ id: nextLineId.current++, text }));
+        setTerminalLines((current) => [...current, ...entries].slice(-110));
+    }, []);
+    const runTerminalInput = async (input) => {
+        const command = await executeWorkspaceCommand({ workspaceRoot, input });
+        if (command.handled) {
+            appendTerminal(`[workspace command] ${command.command ?? input}: ${command.ok ? "completed" : "failed"}`);
+            appendTerminal(command.message);
+            return;
+        }
+        await runTrackedCommand(input, workspaceRoot, appendTerminal, (process) => {
+            terminalProcess.current = process;
+        });
+    };
+    const interruptProcess = () => {
+        if (!terminalProcess.current)
+            return false;
+        const process = terminalProcess.current;
+        terminalProcess.current = undefined;
+        void stopProcessTree(process).then(() => appendTerminal("[terminal] Process stopped."));
+        return true;
+    };
+    return {
+        terminalLines,
+        terminalScroll,
+        setTerminalScroll,
+        commandInput,
+        setCommandInput,
+        previewUrl,
+        appendTerminal,
+        runTerminalInput,
+        interruptProcess,
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,26 @@
+import type { SyntaxToken } from "./file-browser.js";
+export declare const focusOrder: readonly ["files", "editor", "chat", "terminal"];
+export type Focus = (typeof focusOrder)[number];
+export type Screen = "workspace" | "settings" | "approval" | "help" | "file-search" | "agents" | "mcp";
+export type SettingsField = "server" | "endpoint" | "model" | "internet" | "theme";
+export type RunStatus = "ready" | "thinking" | "tool" | "waiting";
+export interface ChatMessage {
+    readonly role: "user" | "assistant";
+    readonly content: string;
+}
+export interface ChatDisplayLine {
+    readonly key: string;
+    readonly role: ChatMessage["role"];
+    readonly text: string;
+    readonly header: boolean;
+}
+export interface EditorDisplayRow {
+    readonly key: string;
+    readonly sourceLine: number;
+    readonly continuation: boolean;
+    readonly tokens: readonly SyntaxToken[];
+}
+export interface Viewport {
+    readonly columns: number;
+    readonly rows: number;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export const focusOrder = ["files", "editor", "chat", "terminal"];

package/dist/workspace-files.d.ts

@@ -0,0 +1,35 @@
+import { type FileEntry } from "./file-browser.js";
+import type { EditorDisplayRow } from "./types.js";
+export declare function collectWorkspaceFiles(root: string, current?: string, result?: FileEntry[]): Promise<FileEntry[]>;
+export interface WorkspaceFilesOptions {
+    readonly workspaceRoot: string;
+    readonly viewportRows: number;
+    readonly editorWidth: number;
+    readonly editorLineCount: number;
+    readonly focusEditor: () => void;
+    readonly closeSearch: () => void;
+}
+export declare function useWorkspaceFiles({ workspaceRoot, viewportRows, editorWidth, editorLineCount, focusEditor, closeSearch, }: WorkspaceFilesOptions): {
+    files: FileEntry[];
+    fileIndex: number;
+    setFileIndex: import("react").Dispatch<import("react").SetStateAction<number>>;
+    fileTree: readonly import("./file-browser.js").FileTreeEntry[];
+    selectedFileTreeEntry: import("./file-browser.js").FileTreeEntry;
+    fileSearchInput: string;
+    setFileSearchInput: import("react").Dispatch<import("react").SetStateAction<string>>;
+    fileSearchIndex: number;
+    setFileSearchIndex: import("react").Dispatch<import("react").SetStateAction<number>>;
+    fileSearchResults: readonly FileEntry[];
+    openFilePath: string | undefined;
+    editorTitle: string;
+    editorScroll: number;
+    setEditorScroll: import("react").Dispatch<import("react").SetStateAction<number>>;
+    editorRows: readonly EditorDisplayRow[];
+    visibleEditorRows: EditorDisplayRow[];
+    fileTreeStart: number;
+    visibleFileTree: import("./file-browser.js").FileTreeEntry[];
+    loadFile: (entry: FileEntry) => Promise<void>;
+    toggleDirectory: (path: string, expand?: boolean) => void;
+    openSearchResult: (entry: FileEntry) => void;
+    toggleDiff: () => Promise<void>;
+};