@saadnvd1/agent-os 0.3.647 → 0.3.653

package/lib/keybindings/focus.ts

@@ -0,0 +1,29 @@
+const NON_TEXT = new Set([
+  "checkbox",
+  "radio",
+  "button",
+  "submit",
+  "reset",
+  "range",
+  "color",
+  "file",
+  "image",
+]);
+
+// Whether a vertical-arrow chord should be left to the focused field: it has
+// text, so ⌘↑/⌘↓ move its caret. An empty field, a terminal, or no field
+// at all lets the app have the key. A dialog (the palette) keeps its keys.
+export function fieldOwnsKey(target: EventTarget | null): boolean {
+  const el = target as HTMLElement | null;
+  if (!el || typeof el.closest !== "function") return false;
+  if (el.closest(".xterm")) return false;
+  if (el.closest('[role="dialog"]')) return true;
+  const tag = el.tagName;
+  if (tag === "TEXTAREA") return (el as HTMLTextAreaElement).value.length > 0;
+  if (tag === "INPUT") {
+    const input = el as HTMLInputElement;
+    return !NON_TEXT.has(input.type) && input.value.length > 0;
+  }
+  if (el.isContentEditable) return (el.textContent ?? "").trim().length > 0;
+  return false;
+}

package/lib/keybindings/registry.ts

@@ -0,0 +1,84 @@
+import { matchChord, parseChord, type Chord, type KeyLike } from "./chord";
+
+/**
+ * Key chords tied to commands. Features register theirs under a source name
+ * and take them back the same way; one keydown listener serves them all.
+ *
+ * To add a shortcut, add one line to the `useKeybindings` call of the
+ * feature that owns the action: { id, keys: "ctrl+b", when, run }.
+ */
+export interface Keybinding {
+  id: string;
+  // "ctrl+b", "shift+tab", "esc": modifiers must match exactly.
+  keys: string;
+  // Whether it applies right now. The key is left alone when it doesn't.
+  when?: (e: KeyboardEvent) => boolean;
+  // Also fire while the key is held down.
+  repeat?: boolean;
+  run: () => void;
+}
+
+interface Compiled {
+  binding: Keybinding;
+  chord: Chord;
+}
+
+export class KeybindingRegistry {
+  private sources = new Map<string, Compiled[]>();
+  private attached = false;
+
+  constructor(
+    private target: Pick<Window, "addEventListener" | "removeEventListener">
+  ) {}
+
+  // Replaces what a source binds; returns how to take it back.
+  register(source: string, bindings: Keybinding[]): () => void {
+    const compiled = bindings.map((binding) => ({
+      binding,
+      chord: parseChord(binding.keys),
+    }));
+    this.sources.set(source, compiled);
+    this.attach();
+    return () => {
+      if (this.sources.get(source) !== compiled) return;
+      this.sources.delete(source);
+      if (!this.sources.size) this.detach();
+    };
+  }
+
+  // Runs the first binding whose chord matches and whose `when` holds, and
+  // reports whether one did (the caller then stops the key).
+  handle(e: KeyboardEvent): boolean {
+    for (const list of this.sources.values())
+      for (const { binding, chord } of list) {
+        if (!matchChord(chord, e as KeyLike)) continue;
+        if (e.isComposing || (e.repeat && !binding.repeat)) continue;
+        if (binding.when && !binding.when(e)) continue;
+        e.preventDefault();
+        binding.run();
+        return true;
+      }
+    return false;
+  }
+
+  private onKey = (e: Event) => {
+    this.handle(e as KeyboardEvent);
+  };
+
+  private attach() {
+    if (this.attached) return;
+    this.attached = true;
+    this.target.addEventListener("keydown", this.onKey, true);
+  }
+
+  private detach() {
+    this.attached = false;
+    this.target.removeEventListener("keydown", this.onKey, true);
+  }
+}
+
+export const keybindings = new KeybindingRegistry(
+  typeof window === "undefined"
+    ? { addEventListener() {}, removeEventListener() {} }
+    : window
+);

package/lib/sidebar/visible-order.ts

@@ -0,0 +1,56 @@
+import type { MachineGroup } from "./machines";
+import { doneLimit, type Shelves, type SidebarRow } from "./shelves";
+
+export interface ShelfFolds {
+  doneCollapsed: boolean;
+  snoozedCollapsed: boolean;
+  donePages: number;
+}
+
+// The Snoozed and Done rows the sidebar draws: none while folded, Done cut
+// to the pages shown. SessionShelves renders from this too, so the two agree.
+export function shownShelves(shelves: Shelves, folds: ShelfFolds) {
+  return {
+    snoozed: folds.snoozedCollapsed ? [] : shelves.snoozed,
+    done: folds.doneCollapsed
+      ? []
+      : shelves.done.slice(0, doneLimit(folds.donePages)),
+  };
+}
+
+const flatten = (rows: SidebarRow[]): string[] =>
+  rows.flatMap((r) => [r.session.id, ...flatten(r.workers)]);
+
+// Session ids top to bottom, as the sidebar draws them: folded shelves are
+// out, a conductor's workers follow it. The one order for switching sessions.
+export function visibleSessionIds(
+  shelves: Shelves,
+  machines: MachineGroup[],
+  folds: ShelfFolds
+): string[] {
+  const shown = shownShelves(shelves, folds);
+  return flatten([
+    ...shelves.orchestrators,
+    ...shelves.pinned,
+    ...shelves.needsYou,
+    ...shelves.working,
+    ...shelves.inReview,
+    ...shelves.ongoing,
+    ...shown.snoozed,
+    ...shown.done,
+    ...machines.flatMap((g) => g.rows),
+  ]);
+}
+
+// The neighbour of `activeId` one step up (-1) or down (1); null at either
+// end (no wrap), and the first or last row when nothing is active yet.
+export function neighbourSession(
+  ids: string[],
+  activeId: string | undefined,
+  step: 1 | -1
+): string | null {
+  if (!ids.length) return null;
+  const at = activeId ? ids.indexOf(activeId) : -1;
+  if (at < 0) return step === 1 ? ids[0] : ids[ids.length - 1];
+  return ids[at + step] ?? null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.647",
+  "version": "0.3.653",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"