@kolisachint/hoocode-agent 0.4.52 → 0.4.54

package/dist/modes/interactive/interactive-mode.js

@@ -21,6 +21,7 @@ import { formatMissingSessionCwdPrompt, MissingSessionCwdError } from "../../cor
 import { SessionManager } from "../../core/session-manager.js";
 import { BUILTIN_SLASH_COMMANDS } from "../../core/slash-commands.js";
 import { taskStore } from "../../core/task-store.js";
+import { TeamApprovalCoordinator } from "../../core/team-approvals.js";
 import { buildCompactWordmark } from "../../core/wordmark.js";
 import { getChangelogPath, getNewEntries, parseChangelog } from "../../utils/changelog.js";
 import { extensionForImageMimeType, readClipboardImage } from "../../utils/clipboard-image.js";
@@ -53,6 +54,7 @@ import { SessionSelectorComponent } from "./components/session-selector.js";
 import { SettingsSelectorComponent } from "./components/settings-selector.js";
 import { SkillInvocationMessageComponent } from "./components/skill-invocation-message.js";
 import { TaskPanelComponent } from "./components/task-panel.js";
+import { TeamAttachPanelComponent } from "./components/team-attach-panel.js";
 import { ToolExecutionComponent } from "./components/tool-execution.js";
 import { TreeSelectorComponent } from "./components/tree-selector.js";
 import { UserMessageComponent } from "./components/user-message.js";
@@ -184,6 +186,10 @@ export class InteractiveMode {
     widgetContainerBelow;
     // Task panel shown just above the editor (active subagent tasks)
     taskPanel;
+    // hooteams team client (--team): steering + attach share its single SSE stream
+    teamClient = undefined;
+    teamAttachPanel = undefined;
+    teamAttachHandle = undefined;
     // Custom footer from extension (undefined = use built-in footer)
     customFooter = undefined;
     // Header container that holds the built-in or custom header
@@ -306,6 +312,9 @@ export class InteractiveMode {
         this.footer.setAutoCompactEnabled(this.session.autoCompactionEnabled);
         this.footerDataProvider.setSubagentEnabled(this.session.getActiveToolNames().includes("Task"));
         this.taskPanel = new TaskPanelComponent(this.ui);
+        this.taskPanel.onNudge = (role) => this.showTeamNudgeInput(role);
+        this.taskPanel.onAttach = (role) => this.showTeamAttach(role);
+        this.taskPanel.onExitFocus = () => this.exitTeamFocus();
         // Load hide thinking block setting
         this.hideThinkingBlock = this.settingsManager.getHideThinkingBlock();
         // Register themes from resource loader and initialize
@@ -493,6 +502,7 @@ export class InteractiveMode {
                 hint("app.tools.expand", "to expand tools"),
                 hint("app.thinking.toggle", "to expand thinking"),
                 hint("app.tasks.cycleView", "to cycle task panel view"),
+                ...(this.teamClient ? [hint("app.team.focus", "to focus team roster")] : []),
                 hint("app.editor.external", "for external editor"),
                 rawKeyHint("/", "for commands"),
                 rawKeyHint("!", "to run bash"),
@@ -2069,6 +2079,7 @@ export class InteractiveMode {
         this.defaultEditor.onAction("app.tasks.cycleView", () => {
             this.taskPanel.cycleView();
         });
+        this.defaultEditor.onAction("app.team.focus", () => this.enterTeamFocus());
         this.defaultEditor.onAction("app.editor.external", () => this.openExternalEditor());
         this.defaultEditor.onAction("app.message.followUp", () => this.handleFollowUp());
         this.defaultEditor.onAction("app.message.dequeue", () => this.handleDequeue());
@@ -2109,6 +2120,141 @@ export class InteractiveMode {
             // Silently ignore clipboard errors (may not have permission, etc.)
         }
     }
+    // =========================================================================
+    // hooteams team focus (--team): focus role rows, nudge, attach
+    // =========================================================================
+    /**
+     * Wire a hooteams connection into the TUI. Called by main.ts when `--team`
+     * is set, before run(). Enables team focus (app.team.focus), nudging (n),
+     * the attach side panel (a) on the task panel's teams view, and approval
+     * gates: task_paused events (and gates already pending on the server)
+     * surface in the options pane; the answer goes back over
+     * POST /tasks/:id/resume.
+     */
+    attachTeamClient(client) {
+        this.teamClient = client;
+        const approvals = new TeamApprovalCoordinator({
+            present: (approval, signal) => this.presentTeamApproval(approval, signal),
+            resume: (taskId, option) => client.resume(taskId, option),
+            info: (message) => this.showStatus(message),
+            warn: (message) => this.showWarning(message),
+        });
+        client.subscribe((event) => approvals.handleEvent(event));
+        // Gates that opened before we attached don't replay as task_paused.
+        void client.pendingApprovals().then((pending) => {
+            for (const gate of pending)
+                approvals.enqueuePending(gate);
+        }, () => {
+            // Best-effort like the rest of the bridge; live gates still arrive via SSE.
+        });
+    }
+    /**
+     * Show one team approval gate in the options pane and resolve with the
+     * chosen (or free-form) answer, undefined when skipped. Waits politely
+     * while another ask is on screen; the signal (gate answered elsewhere)
+     * dismisses both the wait and the pane.
+     */
+    async presentTeamApproval(approval, signal) {
+        while (this.askOptions && !signal.aborted) {
+            await new Promise((resolve) => setTimeout(resolve, 200));
+        }
+        if (signal.aborted)
+            return undefined;
+        const answers = await this.showAskOptions([
+            {
+                question: approval.question,
+                short: approval.taskId,
+                detail: `team task "${approval.taskId}"${approval.role ? ` (${approval.role})` : ""} is paused until answered`,
+                options: approval.options.map((label) => ({ label })),
+                allowCustom: true,
+            },
+        ], { signal });
+        return answers?.[0];
+    }
+    /** Move keyboard focus to the task panel's team roster. */
+    enterTeamFocus() {
+        if (!this.teamClient) {
+            this.showStatus("No team connected. Start with --team <url> to mirror a hooteams server.");
+            return;
+        }
+        if (!taskStore.agents().some((a) => a.kind === "role")) {
+            this.showStatus("Team roster is empty — waiting for roles from the team server.");
+            return;
+        }
+        this.taskPanel.setView("teams");
+        this.ui.setFocus(this.taskPanel);
+        this.ui.requestRender();
+    }
+    /** Leave team focus: detach any side panel and return focus to the editor. */
+    exitTeamFocus() {
+        this.closeTeamAttach();
+        this.ui.setFocus(this.editor);
+        this.ui.requestRender();
+    }
+    /**
+     * Inline nudge editor for a role (n in team focus or while attached).
+     * Swaps the prompt editor for a one-line input; submit fires POST /steer in
+     * the background (the REPL and team focus are never blocked on the network).
+     */
+    showTeamNudgeInput(role) {
+        const client = this.teamClient;
+        if (!client)
+            return;
+        const restoreFocus = () => {
+            this.editorContainer.clear();
+            this.editorContainer.addChild(this.editor);
+            // Return focus where the nudge came from: the attach panel if one is
+            // open, otherwise the team roster.
+            if (this.teamAttachHandle)
+                this.teamAttachHandle.focus();
+            else
+                this.ui.setFocus(this.taskPanel);
+            this.ui.requestRender();
+        };
+        const input = new ExtensionInputComponent(`Nudge ${role}`, undefined, (value) => {
+            input.dispose();
+            restoreFocus();
+            const message = value.trim();
+            if (!message)
+                return;
+            void client.steer(role, message).then(() => this.showStatus(`Nudged ${role}`), (error) => this.showWarning(`Failed to nudge ${role}: ${String(error)}`));
+        }, () => {
+            input.dispose();
+            restoreFocus();
+        }, { tui: this.ui });
+        this.editorContainer.clear();
+        this.editorContainer.addChild(input);
+        this.ui.setFocus(input);
+        this.ui.requestRender();
+    }
+    /** Open the attach side panel for a role (a in team focus). */
+    showTeamAttach(role) {
+        const client = this.teamClient;
+        if (!client)
+            return;
+        // One attached role at a time: re-attaching swaps the panel.
+        this.closeTeamAttach();
+        const panel = new TeamAttachPanelComponent(role, client, {
+            onDetach: () => this.closeTeamAttach(),
+            onNudge: (attachedRole) => this.showTeamNudgeInput(attachedRole),
+        }, this.ui);
+        this.teamAttachPanel = panel;
+        // preFocus is the task panel (attach is triggered from team focus), so
+        // hiding the overlay drops the user back on the role roster.
+        this.teamAttachHandle = this.ui.showOverlay(panel, {
+            anchor: "top-right",
+            width: "45%",
+            minWidth: 36,
+            margin: { top: 1, right: 1 },
+        });
+    }
+    /** Detach the side panel; the role keeps running. Safe to call when closed. */
+    closeTeamAttach() {
+        this.teamAttachPanel?.dispose();
+        this.teamAttachHandle?.hide();
+        this.teamAttachPanel = undefined;
+        this.teamAttachHandle = undefined;
+    }
     setupEditorSubmitHandler() {
         this.defaultEditor.onSubmit = async (text) => {
             text = text.trim();
@@ -2814,6 +2960,7 @@ export class InteractiveMode {
         // This prevents escape sequences from leaking to the parent shell over slow SSH.
         await this.ui.terminal.drainInput(1000);
         this.taskStoreUnsubscribe?.();
+        this.closeTeamAttach();
         this.taskPanel.dispose();
         this.stop();
         await this.runtimeHost.dispose();