@timurproko/a1 0.1.8-dev.137 → 0.1.8-dev.151

package/dist/integrations/pi/{owned-ui → session-ui}/session-shell.js

@@ -2,6 +2,7 @@ import { MOUSE_TRACKING_OFF, MOUSE_TRACKING_ON, parseMouseInput } from "../../..
 import { PINNED_PI_HIDDEN_COMMAND_NAMES, PINNED_PI_WORKFLOW_COMMAND_NAMES, } from "../engine/index.js";
 import { createPiExtensionUiBridge, createPiQueuedInputStatus, createPiShellArmin, createPiShellAuthProviderSelector, createPiShellChangelog, createPiShellDaxnuts, createPiShellDialog, createPiShellEarendilAnnouncement, createPiShellEditor, createPiShellExtensionSelector, createPiShellFooter, createPiShellHeader, createPiShellHotkeys, createPiShellLoadedResources, createPiShellLoginDialog, createPiShellModelSelector, createPiShellOperationLoader, createPiShellReloadBox, createPiShellScopedModelsSelector, createPiShellSelector, createPiShellSessionInfo, createPiShellSessionSelector, createPiShellSettingsSelector, createPiShellStatus, createPiShellTranscriptComponent, createPiShellTreeSelector, createPiShellTrustSelector, createPiShellUserMessageSelector, onPiThemeChange, piTheme, renderPiShellPackageUpdateNotice, renderPiShellStartupDiagnostic, renderPiShellStatusText, renderPiShellTranscriptBlock, } from "../components/index.js";
 import { PiTuiRuntimeAdapter, } from "../tui-runtime/index.js";
+import { preloadSystemClipboard, readSystemClipboardContent, writeSystemClipboardText, } from "./system-clipboard.js";
 import { OwnedUiSessionShellRoot, shellResourceEntries, } from "./session-shell-root.js";
 export { OwnedUiSessionShellRoot } from "./session-shell-root.js";
 export class OwnedUiSessionShell {
@@ -15,14 +16,19 @@ export class OwnedUiSessionShell {
     #stopped;
     #resolveStopped;
     #dialogId;
+    #dialogSource;
     #routeHost;
     #dialogHandle;
     #sequence = 0;
     #started = false;
     #disposed = false;
     #pointerReporting = false;
+    #customViewport;
+    #removeViewportPreInput;
+    #unsubscribeSettings;
     #compactionQueue = [];
     #lastClearTime = 0;
+    #lastEscapeTime = 0;
     #activeLoginDialog;
     #sessionGeneration;
     constructor(options) {
@@ -30,14 +36,18 @@ export class OwnedUiSessionShell {
         this.#sessionGeneration = this.backend.sessionGeneration;
         this.#cwd = options.cwd;
         this.#routeHost = options.routeHost ?? null;
+        this.#customViewport = options.sessionLayout === "custom-viewport";
+        if (this.#customViewport && options.clipboard === undefined)
+            preloadSystemClipboard();
         this.#stopped = new Promise(resolve => {
             this.#resolveStopped = resolve;
         });
         let runtime;
+        let pendingClipboardWrite = Promise.resolve();
         this.root = new OwnedUiSessionShellRoot(this.backend.view(), options.cwd, {
             getColumns: () => runtime?.viewport().columns ?? options.terminal?.columns ?? 80,
             getRows: () => runtime?.viewport().rows ?? options.terminal?.rows ?? 24,
-            requestRender: () => runtime?.requestRender(),
+            requestRender: force => runtime?.requestRender(force),
             onSubmit: text => { void this.submit(text); },
             onInterrupt: () => { void this.interrupt(); },
             onClear: () => { void this.clearOrExit(); },
@@ -52,19 +62,73 @@ export class OwnedUiSessionShell {
             onMessageCopy: () => { void this.runWorkflow({ command: "copy", argument: "" }); },
             onFollowUp: () => { void this.queueFollowUp(); },
             onDequeue: () => this.restoreQueuedInput(),
+            onCopyText: text => {
+                runtime?.writeControl(`\u001b]52;c;${Buffer.from(text, "utf8").toString("base64")}\u0007`);
+                const write = options.clipboard === undefined
+                    ? writeSystemClipboardText(text)
+                    : options.clipboard.writeText?.(text) ?? Promise.resolve();
+                pendingClipboardWrite = write.catch(() => { });
+            },
+            readClipboardContent: async () => {
+                await pendingClipboardWrite;
+                if (options.clipboard === undefined)
+                    return readSystemClipboardContent();
+                const image = await options.clipboard.readImage?.();
+                if (image !== null && image !== undefined)
+                    return { kind: "image", ...image };
+                const text = await options.clipboard.readText();
+                return text === null ? null : { kind: "text", text };
+            },
         }, {
             ...options.startup,
             resources: options.startup?.resources ?? shellResourceEntries(this.backend),
         }, this.backend.agentDir, {
             getMessageRenderer: customType => this.backend.pinnedMessageRenderer(customType),
             getToolDefinition: toolName => this.backend.pinnedToolDefinition(toolName),
-        });
-        const tuiMode = this.backend.disposed ? "regular" : this.backend.pinnedSettingsSnapshot().tuiMode;
-        const runtimeOptions = options.terminal === undefined
-            ? { root: this.root, mode: tuiMode, layoutRoot: this.root.layoutRoot(), hardwareCursor: this.backend.view().terminal.hardwareCursor }
-            : { root: this.root, mode: tuiMode, layoutRoot: this.root.layoutRoot(), terminal: options.terminal, hardwareCursor: this.backend.view().terminal.hardwareCursor };
+        }, options.sessionLayout);
+        // Bare A1 owns a bounded viewport and therefore always runs on the alternate
+        // fullscreen surface. The pinned comparison profiles still honor Pi's mode.
+        const tuiMode = this.#customViewport
+            ? "fullscreen"
+            : this.backend.disposed ? "regular" : this.backend.pinnedSettingsSnapshot().tuiMode;
+        const runtimeOptions = {
+            root: this.root,
+            mode: tuiMode,
+            ...(this.#customViewport ? {} : { layoutRoot: this.root.layoutRoot() }),
+            ...(options.terminal === undefined ? {} : { terminal: options.terminal }),
+            hardwareCursor: this.backend.view().terminal.hardwareCursor,
+        };
         runtime = new PiTuiRuntimeAdapter(runtimeOptions);
         this.runtime = runtime;
+        this.#removeViewportPreInput = this.#customViewport
+            ? this.runtime.addPreInputListener(data => {
+                // An overlay or editor-replacement screen owns its entire pointer
+                // surface. Letting the transcript pre-router inspect those reports
+                // steals settings value menus and numeric +/- controls before the
+                // settings app can receive them.
+                if (this.runtime.hasOverlay() || !this.root.usesDefaultInputSurface())
+                    return undefined;
+                const routed = this.root.handleViewportPreInput(data, true);
+                if (routed.copyText !== undefined) {
+                    this.runtime.writeControl(`\u001b]52;c;${Buffer.from(routed.copyText, "utf8").toString("base64")}\u0007`);
+                }
+                if (!routed.consumed)
+                    return routed.data === data ? undefined : { data: routed.data };
+                return routed.data.length === 0 ? { consume: true } : { data: routed.data };
+            })
+            : () => { };
+        const applyViewportSettings = () => {
+            const snapshot = options.viewportSettings?.snapshot();
+            this.root.setViewportConfig(snapshot ?? {
+                scrollbarAppearance: "auto",
+                scrollbarStyle: "thin",
+                scrollbarSpeed: "normal",
+            });
+        };
+        applyViewportSettings();
+        this.#unsubscribeSettings = this.#customViewport && options.viewportSettings
+            ? options.viewportSettings.onChange(settings => this.root.setViewportConfig(settings))
+            : () => { };
         this.#extensionBridge = createPiExtensionUiBridge({
             runtime: {
                 getColumns: () => this.runtime.viewport().columns,
@@ -102,9 +166,14 @@ export class OwnedUiSessionShell {
             // A streamed chunk names one block, and touching only that block is what keeps the
             // cost of a chunk the same in a long session as in a new one. Everything else
             // resynchronizes the view, which is cheap next to re-reading the transcript.
+            if (event.type === "agent-run-started")
+                this.root.resumeViewportFollowing();
+            if (event.type === "assistant-message-completed")
+                this.root.noteCompletedAssistantMessage();
+            const semanticOnly = event.type === "agent-run-started" || event.type === "assistant-message-completed";
             const view = event.type === "transcript-block" && this.#sessionGeneration === this.backend.sessionGeneration
                 ? this.#syncBlock(event.block)
-                : this.#syncView();
+                : semanticOnly ? this.view() : this.#syncView();
             if (view.lifecycle === "ready" && this.#compactionQueue.length > 0)
                 void this.#flushCompactionQueue();
             if (event.type === "session-lifecycle" && event.lifecycle === "stopped")
@@ -121,6 +190,8 @@ export class OwnedUiSessionShell {
             return;
         this.#started = true;
         this.runtime.start();
+        if (this.#customViewport)
+            this.#setPointerReporting(true);
         void this.backend.bindExtensionUi(this.#extensionBridge.context, () => { void this.shutdown(); });
         this.#syncView();
     }
@@ -133,16 +204,18 @@ export class OwnedUiSessionShell {
         return this.#stopped;
     }
     async submit(text) {
-        const input = text.trim();
-        if (!input)
+        const displayInput = text.trim();
+        if (!displayInput)
             return { outcome: "completed", diagnostic: null };
-        if (input.startsWith("/"))
-            return this.#slashCommand(input);
+        if (displayInput.startsWith("/"))
+            return this.#slashCommand(displayInput);
+        const prepared = this.root.preparePromptSubmission(displayInput);
+        const input = prepared.text.trim();
         if (input.startsWith("!")) {
             const excludeFromContext = input.startsWith("!!");
             const command = input.slice(excludeFromContext ? 2 : 1).trim();
             if (command) {
-                this.root.editor.addToHistory(input);
+                this.root.editor.addToHistory(displayInput);
                 try {
                     const result = await this.backend.executeBashWorkflow(command, excludeFromContext);
                     const workflow = {
@@ -164,19 +237,21 @@ export class OwnedUiSessionShell {
             }
         }
         if (this.view().status.workingMessage?.startsWith("Compacting") === true) {
-            this.root.editor.addToHistory(input);
+            this.root.editor.addToHistory(displayInput);
             this.#compactionQueue.push({ text: input, type: "steer" });
             this.root.appendWorkflowResult({ command: "compact", outcome: "completed", message: `Queued during compaction: ${input}` });
             this.runtime.requestRender();
             return { outcome: "completed", diagnostic: null };
         }
         const type = this.view().lifecycle === "busy" ? "steer" : "prompt";
-        this.root.editor.addToHistory(input);
+        this.root.editor.addToHistory(displayInput);
+        this.root.resumeViewportFollowing();
         return this.#execute({
             type,
             correlationId: this.#correlation(type),
             sessionId: this.backend.sessionId,
             text: input,
+            ...(prepared.images.length === 0 ? {} : { images: prepared.images }),
         });
     }
     async clearOrExit(now = Date.now()) {
@@ -187,14 +262,29 @@ export class OwnedUiSessionShell {
         this.runtime.requestRender();
         return { outcome: "completed", diagnostic: null };
     }
-    async interrupt() {
+    async interrupt(now = Date.now()) {
         if (this.view().lifecycle === "busy")
             return this.abort();
-        if (this.root.editor.getText().length > 0) {
+        if (this.root.editor.getText().trim().length > 0) {
             this.root.editor.setText("");
             return { outcome: "completed", diagnostic: null };
         }
-        return { outcome: "rejected", diagnostic: "nothing to interrupt" };
+        // Match Pi: with an empty editor, two escapes inside 500 ms open the
+        // configured session navigator. The first escape intentionally does not
+        // interrupt or mutate the prompt.
+        const action = this.backend.pinnedSettingsSnapshot().doubleEscapeAction;
+        if (action === "none")
+            return { outcome: "rejected", diagnostic: "nothing to interrupt" };
+        if (now - this.#lastEscapeTime < 500) {
+            this.#lastEscapeTime = 0;
+            if (action === "tree")
+                this.showTreeSelector();
+            else
+                this.showForkSelector();
+            return { outcome: "completed", diagnostic: null };
+        }
+        this.#lastEscapeTime = now;
+        return { outcome: "completed", diagnostic: null };
     }
     async abort() {
         return this.#execute(this.#simple("abort"));
@@ -251,6 +341,7 @@ export class OwnedUiSessionShell {
             return rejected("nothing to queue");
         this.root.editor.addToHistory(text);
         this.root.editor.setText("");
+        this.root.resumeViewportFollowing();
         if (this.view().status.workingMessage?.startsWith("Compacting") === true) {
             this.#compactionQueue.push({ text, type: "follow-up" });
             return { outcome: "completed", diagnostic: null };
@@ -272,6 +363,8 @@ export class OwnedUiSessionShell {
     }
     showSelector(title, options, onSelect, onCancel) {
         this.#dialogHandle?.hide();
+        this.#dialogSource = "local";
+        this.#dialogId = undefined;
         const component = createPiShellSelector({
             title,
             options,
@@ -279,10 +372,12 @@ export class OwnedUiSessionShell {
                 onSelect(id);
                 this.#dialogHandle?.hide();
                 this.#dialogHandle = undefined;
+                this.#dialogSource = undefined;
             },
             onCancel: () => {
                 this.#dialogHandle?.hide();
                 this.#dialogHandle = undefined;
+                this.#dialogSource = undefined;
                 onCancel?.();
             },
         });
@@ -486,6 +581,10 @@ export class OwnedUiSessionShell {
                     return;
                 }
                 if (callback === "onTuiModeChange") {
+                    // The custom bare-A1 surface is permanently fullscreen; this callback
+                    // remains available only to pinned comparison profiles.
+                    if (this.#customViewport)
+                        return;
                     if (value !== "regular" && value !== "fullscreen")
                         return;
                     if (!this.runtime.switchMode(value)) {
@@ -493,6 +592,10 @@ export class OwnedUiSessionShell {
                         this.runtime.requestRender();
                         return;
                     }
+                    if (this.#customViewport) {
+                        this.#pointerReporting = false;
+                        this.#setPointerReporting(true);
+                    }
                 }
                 const result = this.backend.applyPinnedSettingValue(callback, value);
                 if (result.outcome === "failed")
@@ -704,19 +807,23 @@ export class OwnedUiSessionShell {
      * button instead of scrolling and selecting itself, so leaving it on outlives the
      * screen that wanted it and takes the terminal's own scrolling and selection with it.
      */
-    #setPointerReporting(enabled) {
-        if (this.#pointerReporting === enabled)
+    #setPointerReporting(enabled, forceOff = false) {
+        const effective = forceOff ? false : this.#customViewport || enabled;
+        if (this.#pointerReporting === effective)
             return;
-        this.#pointerReporting = enabled;
+        this.#pointerReporting = effective;
         if (!this.runtime.active)
             return;
-        this.runtime.writeControl(enabled ? MOUSE_TRACKING_ON : MOUSE_TRACKING_OFF);
+        this.runtime.writeControl(effective ? MOUSE_TRACKING_ON : MOUSE_TRACKING_OFF);
     }
     async dispose() {
         if (this.#disposed)
             return;
         this.#disposed = true;
-        this.#setPointerReporting(false);
+        this.root.clearViewportPointerState();
+        this.#setPointerReporting(false, true);
+        this.#removeViewportPreInput();
+        this.#unsubscribeSettings();
         this.#unsubscribe();
         this.#dialogHandle?.hide();
         await this.backend.unbindExtensionUi();
@@ -741,7 +848,12 @@ export class OwnedUiSessionShell {
             this.#sessionGeneration = this.backend.sessionGeneration;
             this.#activeLoginDialog = undefined;
             this.#extensionBridge.reset();
-            // A replaced session takes its screens with it, pointer reporting included.
+            // A replaced session takes its transient viewport and owned-route state with it.
+            this.root.resetViewport();
+            this.#dialogHandle?.hide();
+            this.#dialogHandle = undefined;
+            this.#dialogId = undefined;
+            this.#dialogSource = undefined;
             this.#setPointerReporting(false);
             this.root.setInputSurface(null);
             this.root.resetExtensionUi();
@@ -761,6 +873,7 @@ export class OwnedUiSessionShell {
         if (!this.runtime.active)
             return { outcome: "failed", diagnostic: "runtime is not active" };
         this.#dialogHandle?.hide();
+        this.#dialogSource = "route";
         // Any-event reporting: hover and drag are what the screen is driven by, and
         // it also stops the terminal treating a drag as a text selection.
         this.#setPointerReporting(true);
@@ -784,13 +897,32 @@ export class OwnedUiSessionShell {
             // stray interrupt while it is up.
             return { consume: true };
         });
+        let removeSurfacePreInput = () => { };
         const closeSurface = () => {
+            removeSurfacePreInput();
             removeInterruptWatch();
             this.#setPointerReporting(false);
             this.#dialogHandle?.hide();
             this.#dialogHandle = undefined;
             this.#dialogId = undefined;
+            this.#dialogSource = undefined;
         };
+        // Fullscreen Pi owns a fallback text-selection layer before focused overlay
+        // components see pointer input. Route every mouse report to the owned screen
+        // at the pre-input boundary so dropdowns, value hover, and numeric +/- work,
+        // and consume even unhandled reports so settings content is never selected.
+        removeSurfacePreInput = this.runtime.addPreInputListener(data => {
+            const { events, rest } = parseMouseInput(data);
+            if (events.length === 0)
+                return undefined;
+            for (const event of events)
+                surface.handleMouse(event);
+            if (surface.isClosed())
+                closeSurface();
+            else
+                this.runtime.requestRender();
+            return rest.length === 0 ? { consume: true } : { data: rest };
+        });
         const rows = () => Math.max(1, this.runtime.viewport().rows);
         const component = {
             render: (width) => [...surface.render(Math.max(1, width), rows())],
@@ -821,22 +953,32 @@ export class OwnedUiSessionShell {
         if (!this.runtime.active)
             return;
         if (dialog === null) {
+            // Locally owned routes (notably /settings) are independent of backend
+            // lifecycle/status events and remain open while an agent is working.
+            if (this.#dialogSource !== "backend")
+                return;
             this.#dialogHandle?.hide();
             this.#dialogHandle = undefined;
             this.#dialogId = undefined;
+            this.#dialogSource = undefined;
             return;
         }
-        if (this.#dialogId === dialog.id)
+        if (this.#dialogSource === "backend" && this.#dialogId === dialog.id)
             return;
         this.#dialogHandle?.hide();
+        this.#dialogSource = "backend";
         const component = createPiShellDialog(dialog, {
             onSelect: () => {
                 this.#dialogHandle?.hide();
                 this.#dialogHandle = undefined;
+                this.#dialogId = undefined;
+                this.#dialogSource = undefined;
             },
             onCancel: () => {
                 this.#dialogHandle?.hide();
                 this.#dialogHandle = undefined;
+                this.#dialogId = undefined;
+                this.#dialogSource = undefined;
             },
         });
         this.#dialogHandle = this.runtime.showOverlay(component, { width: "70%", maxHeight: "80%", anchor: "center" });
@@ -853,6 +995,7 @@ export class OwnedUiSessionShell {
             return this.runWorkflow({ command: name, argument });
         // Unknown slash input, prompt templates, skills, and extension commands remain Pi prompt input.
         this.root.editor.addToHistory(text);
+        this.root.resumeViewportFollowing();
         return this.#execute({
             type: this.view().lifecycle === "busy" ? "steer" : "prompt",
             correlationId: this.#correlation("prompt-command"),

package/dist/integrations/pi/session-ui/session-viewport-controller.d.ts

@@ -0,0 +1,39 @@
+import type { OwnedUiViewportSettings } from "../../../contracts/owned-ui/index.js";
+import { type TranscriptViewportFrame, type TranscriptViewportFrameInput } from "../../../ui/components/index.js";
+import type { PiShellEditorPort } from "../components/index.js";
+export interface SessionViewportControllerOptions {
+    readonly enabled: boolean;
+    readonly editor: PiShellEditorPort;
+    readonly requestRender: (force?: boolean) => void;
+    /** Whether mutable editor URL chips need an immediate forced repaint on deletion. */
+    readonly hasEditorLinks?: () => boolean;
+}
+export interface SessionViewportInputResult {
+    readonly data: string;
+    readonly consumed: boolean;
+    readonly copyText?: string;
+}
+/**
+ * Owns the stateful interaction policy of the bare-A1 session viewport. The
+ * shell root supplies semantic rows and dock geometry; this controller owns
+ * follow state, selection, pointer latches, timers, and input routing.
+ */
+export declare class SessionViewportController {
+    #private;
+    constructor(options: SessionViewportControllerOptions);
+    get config(): OwnedUiViewportSettings;
+    get editorPointerSelecting(): boolean;
+    get transcriptPointerSelecting(): boolean;
+    setEditorPointerFrame(frame: {
+        readonly rowStart: number;
+        readonly rowEnd: number;
+    } | undefined): void;
+    compose(input: TranscriptViewportFrameInput): TranscriptViewportFrame;
+    /** Returns true when document wrapping may have changed. */
+    setConfig(config: OwnedUiViewportSettings): boolean;
+    resumeFollowing(): void;
+    noteCompletedAssistantMessage(): void;
+    reset(): void;
+    clearPointerState(): void;
+    handlePreInput(data: string, allowWheel?: boolean, now?: number): SessionViewportInputResult;
+}