Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

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.css
index 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.tsx
index 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.tsx
index 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.tsx
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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]);
+}