Multi-Agent Collaboration for Team and Friends
TypeScript agent-automationagent-orchestrationagent-workflowai-agentsai-collaborationai-memoryai-workforceautonomous-agentsclaude-codeclaude-code-skillscodexcoding-agentmulti-agentmultiple-agentone-person-businessone-person-companyone-person-teamopencodesolopreneur
fix(web): consistent mobile chat input focus across iOS/Android (#270)
Gener5c5eab73efda
diff --git a/src/web/src/app/globals.css b/src/web/src/app/globals.cssindex 45245288f..f6a6191de 100644--- a/src/web/src/app/globals.css+++ b/src/web/src/app/globals.css@@ -960,7 +960,7 @@-moz-osx-font-smoothing: grayscale;}html {- @apply font-sans;+ @apply font-sans bg-background;font-size: 16px;line-height: 1.6;}@@ -1718,9 +1718,21 @@ html, body {overscroll-behavior: none;-webkit-tap-highlight-color: transparent;-webkit-touch-callout: none;+ touch-action: manipulation;+}++html {+ background-color: oklch(0.93 0.015 80);+ min-height: 100dvh;+}++.dark html,+html.dark {+ background-color: oklch(0.16 0.008 60);}body {+ min-height: 100dvh;padding-top: env(safe-area-inset-top);padding-bottom: env(safe-area-inset-bottom);padding-left: env(safe-area-inset-left);diff --git a/src/web/src/app/layout.tsx b/src/web/src/app/layout.tsxindex a8589077e..07a371654 100644--- a/src/web/src/app/layout.tsx+++ b/src/web/src/app/layout.tsx@@ -51,6 +51,7 @@ export const viewport: Viewport = {width: "device-width",initialScale: 1,viewportFit: "cover",+ interactiveWidget: "resizes-visual",themeColor: [{ media: "(prefers-color-scheme: light)", color: "#f5f0e8" },{ media: "(prefers-color-scheme: dark)", color: "#262320" },diff --git a/src/web/src/components/agent-chat/agent-chat-view.tsx b/src/web/src/components/agent-chat/agent-chat-view.tsxindex 5714320e3..e19cfdd2b 100644--- a/src/web/src/components/agent-chat/agent-chat-view.tsx+++ b/src/web/src/components/agent-chat/agent-chat-view.tsx@@ -2835,7 +2835,7 @@ export function AgentChatView({)}{/* Input */}- <div className="relative z-10 px-3 md:px-5 pt-3 pb-5 md:pb-6">+ <div data-keyboard-offset className="relative z-10 px-3 md:px-5 pt-3 pb-[max(1.25rem,env(safe-area-inset-bottom))] md:pb-6"><div className="mx-auto max-w-2xl relative"><div className="flex items-end gap-2">{/* Overflow menu */}diff --git a/src/web/src/components/agent-chat/chat-composer.tsx b/src/web/src/components/agent-chat/chat-composer.tsxindex feb2d41ac..3fd6e51e6 100644--- a/src/web/src/components/agent-chat/chat-composer.tsx+++ b/src/web/src/components/agent-chat/chat-composer.tsx@@ -7,6 +7,7 @@ import {useRef,useState,} from "react";+import { useKeyboardScroll } from "@/hooks/use-keyboard-scroll";import { useEditor, EditorContent } from "@tiptap/react";import StarterKit from "@tiptap/starter-kit";import Placeholder from "@tiptap/extension-placeholder";@@ -398,6 +399,10 @@ export const ChatComposer = forwardRef<ChatComposerHandle, ChatComposerProps>(return () => observer.disconnect();}, [editor, onMultiLineChange]);+ // iOS Safari fallback: scroll composer into view when the virtual keyboard resizes+ // the visual viewport.+ useKeyboardScroll(contentRef, !!editor?.isFocused);+useImperativeHandle(ref,() => ({diff --git a/src/web/src/hooks/__tests__/use-keyboard-scroll.test.ts b/src/web/src/hooks/__tests__/use-keyboard-scroll.test.tsnew file mode 100644index 000000000..522d80635--- /dev/null+++ b/src/web/src/hooks/__tests__/use-keyboard-scroll.test.ts@@ -0,0 +1,363 @@+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";+import {+ createKeyboardScrollController,+ attachKeyboardScroll,+} from "../use-keyboard-scroll";++function createMockTarget(container?: HTMLElement | null) {+ const scrollIntoView = vi.fn();+ const target = {+ scrollIntoView,+ closest: vi.fn((selector: string) => {+ if (selector === "[data-keyboard-offset]") return container ?? null;+ return null;+ }),+ } as unknown as HTMLElement;+ return { target, scrollIntoView };+}++function createMockContainer() {+ return { style: { transform: "" } } as unknown as HTMLElement;+}++describe("createKeyboardScrollController", () => {+ beforeEach(() => {+ vi.useFakeTimers();+ });++ afterEach(() => {+ vi.useRealTimers();+ });++ it("falls back to scrollIntoView when no visualViewport available", () => {+ const { target, scrollIntoView } = createMockTarget(null);+ Object.defineProperty(globalThis, "window", {+ value: { innerHeight: 800, visualViewport: undefined },+ writable: true,+ configurable: true,+ });+ const { handler } = createKeyboardScrollController(() => target, true);++ handler();+ vi.advanceTimersByTime(100);++ expect(scrollIntoView).toHaveBeenCalledWith({+ block: "end",+ behavior: "smooth",+ });++ Object.defineProperty(globalThis, "window", {+ value: undefined,+ writable: true,+ configurable: true,+ });+ });++ it("applies transform offset when keyboard is open and container exists", () => {+ const container = createMockContainer();+ const { target } = createMockTarget(container);+ Object.defineProperty(globalThis, "window", {+ value: {+ innerHeight: 800,+ visualViewport: { height: 500, offsetTop: 0 },+ },+ writable: true,+ configurable: true,+ });+ const { handler } = createKeyboardScrollController(() => target, true);++ handler();+ vi.advanceTimersByTime(100);++ expect(container.style.transform).toBe("translateY(-300px)");++ Object.defineProperty(globalThis, "window", {+ value: undefined,+ writable: true,+ configurable: true,+ });+ });++ it("clears transform when keyboard offset is zero", () => {+ const container = createMockContainer();+ container.style.transform = "translateY(-300px)";+ const { target } = createMockTarget(container);+ Object.defineProperty(globalThis, "window", {+ value: {+ innerHeight: 800,+ visualViewport: { height: 800, offsetTop: 0 },+ },+ writable: true,+ configurable: true,+ });+ const { handler } = createKeyboardScrollController(() => target, true);++ handler();+ vi.advanceTimersByTime(100);++ expect(container.style.transform).toBe("");++ Object.defineProperty(globalThis, "window", {+ value: undefined,+ writable: true,+ configurable: true,+ });+ });++ it("does NOT fire when not focused", () => {+ const container = createMockContainer();+ const { target } = createMockTarget(container);+ Object.defineProperty(globalThis, "window", {+ value: {+ innerHeight: 800,+ visualViewport: { height: 500, offsetTop: 0 },+ },+ writable: true,+ configurable: true,+ });+ const { handler } = createKeyboardScrollController(() => target, false);++ handler();+ vi.advanceTimersByTime(100);++ expect(container.style.transform).toBe("");++ Object.defineProperty(globalThis, "window", {+ value: undefined,+ writable: true,+ configurable: true,+ });+ });++ it("debounces rapid resize events", () => {+ const container = createMockContainer();+ const { target } = createMockTarget(container);+ Object.defineProperty(globalThis, "window", {+ value: {+ innerHeight: 800,+ visualViewport: { height: 500, offsetTop: 0 },+ },+ writable: true,+ configurable: true,+ });+ const { handler } = createKeyboardScrollController(() => target, true);++ handler();+ vi.advanceTimersByTime(50);+ handler();+ vi.advanceTimersByTime(50);+ handler();+ vi.advanceTimersByTime(100);++ expect(container.style.transform).toBe("translateY(-300px)");++ Object.defineProperty(globalThis, "window", {+ value: undefined,+ writable: true,+ configurable: true,+ });+ });++ it("cleanup clears pending timeout and resets transform", () => {+ const container = createMockContainer();+ container.style.transform = "translateY(-300px)";+ const { target } = createMockTarget(container);+ Object.defineProperty(globalThis, "window", {+ value: {+ innerHeight: 800,+ visualViewport: { height: 500, offsetTop: 0 },+ },+ writable: true,+ configurable: true,+ });+ const { handler, cleanup } = createKeyboardScrollController(+ () => target,+ true,+ );++ handler();+ vi.advanceTimersByTime(50);+ cleanup();+ vi.advanceTimersByTime(100);++ expect(container.style.transform).toBe("");++ Object.defineProperty(globalThis, "window", {+ value: undefined,+ writable: true,+ configurable: true,+ });+ });++ it("allows multiple firings across separate debounce windows", () => {+ const container = createMockContainer();+ const { target } = createMockTarget(container);+ let viewportHeight = 500;+ Object.defineProperty(globalThis, "window", {+ value: {+ innerHeight: 800,+ get visualViewport() {+ return { height: viewportHeight, offsetTop: 0 };+ },+ },+ writable: true,+ configurable: true,+ });+ const { handler } = createKeyboardScrollController(() => target, true);++ handler();+ vi.advanceTimersByTime(100);+ expect(container.style.transform).toBe("translateY(-300px)");++ viewportHeight = 600;+ handler();+ vi.advanceTimersByTime(100);+ expect(container.style.transform).toBe("translateY(-200px)");++ Object.defineProperty(globalThis, "window", {+ value: undefined,+ writable: true,+ configurable: true,+ });+ });++ it("no-ops gracefully when target is null", () => {+ const { handler } = createKeyboardScrollController(() => null, true);+ handler();+ vi.advanceTimersByTime(300);+ });++ it("falls back to scrollIntoView when no container found", () => {+ const { target, scrollIntoView } = createMockTarget(null);+ Object.defineProperty(globalThis, "window", {+ value: {+ innerHeight: 800,+ visualViewport: { height: 500, offsetTop: 0 },+ },+ writable: true,+ configurable: true,+ });+ const { handler } = createKeyboardScrollController(() => target, true);++ handler();+ vi.advanceTimersByTime(100);++ expect(scrollIntoView).toHaveBeenCalledWith({+ block: "end",+ behavior: "smooth",+ });++ Object.defineProperty(globalThis, "window", {+ value: undefined,+ writable: true,+ configurable: true,+ });+ });+});++describe("attachKeyboardScroll", () => {+ let listeners: Map<string, EventListener>;+ let mockVisualViewport: {+ addEventListener: ReturnType<typeof vi.fn>;+ removeEventListener: ReturnType<typeof vi.fn>;+ height: number;+ offsetTop: number;+ };++ beforeEach(() => {+ vi.useFakeTimers();+ listeners = new Map();+ mockVisualViewport = {+ addEventListener: vi.fn((event: string, handler: EventListener) => {+ listeners.set(event, handler);+ }),+ removeEventListener: vi.fn((event: string) => {+ listeners.delete(event);+ }),+ height: 500,+ offsetTop: 0,+ };+ Object.defineProperty(globalThis, "window", {+ value: { visualViewport: mockVisualViewport, innerHeight: 800 },+ writable: true,+ configurable: true,+ });+ });++ afterEach(() => {+ vi.useRealTimers();+ Object.defineProperty(globalThis, "window", {+ value: undefined,+ writable: true,+ configurable: true,+ });+ });++ it("registers resize and scroll listeners and returns a detach function", () => {+ const { target } = createMockTarget(createMockContainer());+ const detach = attachKeyboardScroll(() => target, true);++ expect(detach).toBeTypeOf("function");+ expect(mockVisualViewport.addEventListener).toHaveBeenCalledWith(+ "resize",+ expect.any(Function),+ );+ expect(mockVisualViewport.addEventListener).toHaveBeenCalledWith(+ "scroll",+ expect.any(Function),+ );+ });++ it("detach removes listeners and resets transform", () => {+ const container = createMockContainer();+ const { target } = createMockTarget(container);+ const detach = attachKeyboardScroll(() => target, true)!;++ const handler = listeners.get("resize")!;+ handler(new Event("resize"));+ vi.advanceTimersByTime(100);+ expect(container.style.transform).toBe("translateY(-300px)");++ detach();++ expect(mockVisualViewport.removeEventListener).toHaveBeenCalledWith(+ "resize",+ expect.any(Function),+ );+ expect(container.style.transform).toBe("");+ });++ it("applies transform on resize when focused", () => {+ const container = createMockContainer();+ const { target } = createMockTarget(container);+ attachKeyboardScroll(() => target, true);++ const handler = listeners.get("resize")!;+ handler(new Event("resize"));+ vi.advanceTimersByTime(300);++ expect(container.style.transform).toBe("translateY(-300px)");+ });++ it("does not fire when not focused", () => {+ const container = createMockContainer();+ const { target } = createMockTarget(container);+ attachKeyboardScroll(() => target, false);++ const handler = listeners.get("resize")!;+ handler(new Event("resize"));+ vi.advanceTimersByTime(300);++ expect(container.style.transform).toBe("");+ });++ it("returns null when visualViewport is unavailable", () => {+ Object.defineProperty(globalThis, "window", {+ value: { visualViewport: undefined },+ writable: true,+ configurable: true,+ });+ const detach = attachKeyboardScroll(() => null, true);+ expect(detach).toBeNull();+ });+});diff --git a/src/web/src/hooks/use-keyboard-scroll.ts b/src/web/src/hooks/use-keyboard-scroll.tsnew file mode 100644index 000000000..7354622c7--- /dev/null+++ b/src/web/src/hooks/use-keyboard-scroll.ts@@ -0,0 +1,103 @@+"use client";++import { useEffect, type RefObject } from "react";++export interface KeyboardScrollController {+ handler: () => void;+ cleanup: () => void;+}++/**+ * Creates a resize handler that calculates the keyboard offset from the visual+ * viewport and applies a CSS variable to the target element so its parent+ * container can shift above the keyboard.+ * Exported for testability — the hook wraps this with lifecycle management.+ */+export function createKeyboardScrollController(+ getTarget: () => HTMLElement | null,+ isFocused: boolean,+): KeyboardScrollController {+ let timeoutId: ReturnType<typeof setTimeout> | undefined;+ const handler = () => {+ if (!isFocused) return;+ clearTimeout(timeoutId);+ timeoutId = setTimeout(() => {+ const el = getTarget();+ if (!el) return;+ const vv = window.visualViewport;+ if (!vv) {+ el.scrollIntoView({ block: "end", behavior: "smooth" });+ return;+ }+ const offset = window.innerHeight - vv.height - vv.offsetTop;+ const inputContainer = el.closest(+ "[data-keyboard-offset]",+ ) as HTMLElement | null;+ if (inputContainer) {+ inputContainer.style.transform =+ offset > 0 ? `translateY(-${offset}px)` : "";+ } else {+ el.scrollIntoView({ block: "end", behavior: "smooth" });+ }+ }, 100);+ };+ const cleanup = () => {+ clearTimeout(timeoutId);+ const el = getTarget();+ if (!el) return;+ const inputContainer = el.closest(+ "[data-keyboard-offset]",+ ) as HTMLElement | null;+ if (inputContainer) {+ inputContainer.style.transform = "";+ }+ };+ return { handler, cleanup };+}++/**+ * Subscribes to visualViewport resize and scroll events. On iOS Safari the+ * virtual keyboard shrinks the visual viewport without reflowing the layout,+ * so fixed/sticky elements at the bottom can be hidden behind the keyboard.+ * This handler applies a translateY offset to move the input above the keyboard.+ *+ * Returns null if visualViewport is unavailable (SSR or unsupported browser).+ * Exported for testability without React rendering.+ */+export function attachKeyboardScroll(+ getTarget: () => HTMLElement | null,+ isFocused: boolean,+): (() => void) | null {+ const vv =+ typeof window !== "undefined" ? window.visualViewport : undefined;+ if (!vv) return null;+ const { handler, cleanup } = createKeyboardScrollController(+ getTarget,+ isFocused,+ );+ vv.addEventListener("resize", handler);+ vv.addEventListener("scroll", handler);+ return () => {+ vv.removeEventListener("resize", handler);+ vv.removeEventListener("scroll", handler);+ cleanup();+ };+}++/**+ * On iOS Safari, the virtual keyboard can push the focused input off-screen+ * because the layout viewport doesn't always resize in sync with the visual+ * viewport. This hook listens to `window.visualViewport` resize events and+ * applies a translateY offset to the nearest [data-keyboard-offset] ancestor.+ *+ * No-op when `visualViewport` is unavailable or the editor isn't focused.+ */+export function useKeyboardScroll(+ targetRef: RefObject<HTMLElement | null>,+ isFocused: boolean,+) {+ useEffect(() => {+ const detach = attachKeyboardScroll(() => targetRef.current, isFocused);+ return detach ?? undefined;+ }, [targetRef, isFocused]);+}