@frockbot/plugin-flock 0.0.0 → 0.1.0

package/src/client/pending-create.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, test } from "bun:test";
+import { randomSheepRecipeV1 } from "../shared.js";
+import {
+  clearPendingSheep,
+  isDefinitiveFlockFailure,
+  pendingCreateKey,
+  pendingSheepKey,
+  readPendingCreate,
+  readPendingSheep,
+  writePendingCreate,
+  writePendingSheep,
+} from "./pending-create.js";
+
+function memoryStorage() {
+  const values = new Map<string, string>();
+  return {
+    values,
+    getItem: (key: string) => values.get(key) ?? null,
+    setItem: (key: string, value: string) => values.set(key, value),
+    removeItem: (key: string) => values.delete(key),
+  };
+}
+
+const sheep = randomSheepRecipeV1(() => 0);
+const command = {
+  schemaVersion: 1 as const,
+  type: "bot/create" as const,
+  commandId: "create-1",
+  expectedRevision: 0,
+  botId: "alpha",
+  name: "Alpha",
+  sheep,
+};
+
+describe("pending Flock commands", () => {
+  test("binds uncertain Bot creation to the authenticated User", () => {
+    const storage = memoryStorage();
+    writePendingCreate("user-a", command, storage);
+    expect(readPendingCreate("user-a", storage)).toEqual(command);
+    expect(readPendingCreate("user-b", storage)).toBeUndefined();
+    expect(storage.values.get(pendingCreateKey("user-a"))).toBe(
+      JSON.stringify(command),
+    );
+  });
+
+  test("persists the exact sheep command for lost-response replay", () => {
+    const storage = memoryStorage();
+    const update = {
+      schemaVersion: 1 as const,
+      type: "bot/update-sheep" as const,
+      commandId: "sheep-1",
+      expectedRevision: 3,
+      botId: "alpha",
+      sheep,
+    };
+    writePendingSheep("user-a", update, storage);
+    expect(readPendingSheep("user-a", "alpha", storage)).toEqual(update);
+    expect(readPendingSheep("user-b", "alpha", storage)).toBeUndefined();
+    clearPendingSheep("user-a", "alpha", storage);
+    expect(storage.values.has(pendingSheepKey("user-a", "alpha"))).toBe(false);
+  });
+
+  test("discards malformed state and classifies only explicit failures", () => {
+    const storage = memoryStorage();
+    storage.values.set(pendingCreateKey("user-a"), "{}");
+    expect(readPendingCreate("user-a", storage)).toBeUndefined();
+    expect(storage.values.has(pendingCreateKey("user-a"))).toBe(false);
+    expect(isDefinitiveFlockFailure({ definitive: true })).toBe(true);
+    expect(isDefinitiveFlockFailure(new Error("network"))).toBe(false);
+  });
+});

package/src/client/pending-create.ts

@@ -0,0 +1,93 @@
+import {
+  decodeCreateBotCommandV1,
+  decodeUpdateSheepCommandV1,
+  type CreateBotCommandV1,
+  type UpdateSheepCommandV1,
+} from "../shared.js";
+
+export const PENDING_CREATE_KEY = "frockbot.flock.pending-create.v1";
+export const PENDING_SHEEP_KEY = "frockbot.flock.pending-sheep.v1";
+
+export function pendingCreateKey(userId: string): string {
+  return `${PENDING_CREATE_KEY}:${encodeURIComponent(userId)}`;
+}
+
+export function pendingSheepKey(userId: string, botId: string): string {
+  return `${PENDING_SHEEP_KEY}:${encodeURIComponent(userId)}:${encodeURIComponent(botId)}`;
+}
+
+export function readPendingCreate(
+  userId: string,
+  storage: Pick<Storage, "getItem" | "removeItem"> = localStorage,
+): CreateBotCommandV1 | undefined {
+  const key = pendingCreateKey(userId);
+  const value = storage.getItem(key);
+  if (!value) return undefined;
+  try {
+    return decodeCreateBotCommandV1(JSON.parse(value));
+  } catch {
+    storage.removeItem(key);
+    return undefined;
+  }
+}
+
+export function writePendingCreate(
+  userId: string,
+  command: CreateBotCommandV1,
+  storage: Pick<Storage, "setItem"> = localStorage,
+): void {
+  storage.setItem(pendingCreateKey(userId), JSON.stringify(command));
+}
+
+export function clearPendingCreate(
+  userId: string,
+  storage: Pick<Storage, "removeItem"> = localStorage,
+): void {
+  storage.removeItem(pendingCreateKey(userId));
+}
+
+export function readPendingSheep(
+  userId: string,
+  botId: string,
+  storage: Pick<Storage, "getItem" | "removeItem"> = localStorage,
+): UpdateSheepCommandV1 | undefined {
+  const key = pendingSheepKey(userId, botId);
+  const value = storage.getItem(key);
+  if (!value) return undefined;
+  try {
+    const command = decodeUpdateSheepCommandV1(JSON.parse(value));
+    if (command.botId !== botId) throw new Error("pending Bot mismatch");
+    return command;
+  } catch {
+    storage.removeItem(key);
+    return undefined;
+  }
+}
+
+export function writePendingSheep(
+  userId: string,
+  command: UpdateSheepCommandV1,
+  storage: Pick<Storage, "setItem"> = localStorage,
+): void {
+  storage.setItem(
+    pendingSheepKey(userId, command.botId),
+    JSON.stringify(command),
+  );
+}
+
+export function clearPendingSheep(
+  userId: string,
+  botId: string,
+  storage: Pick<Storage, "removeItem"> = localStorage,
+): void {
+  storage.removeItem(pendingSheepKey(userId, botId));
+}
+
+export function isDefinitiveFlockFailure(error: unknown): boolean {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "definitive" in error &&
+    error.definitive === true
+  );
+}

package/src/client/sidebar.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, test } from "bun:test";
+import { formatSidebarMessageTimeV1, groupSidebarBotsV1 } from "./sidebar.js";
+
+const bots = [
+  { botId: "alpha" },
+  { botId: "beta" },
+  { botId: "gamma" },
+  { botId: "delta" },
+];
+
+describe("sidebar Bot groups", () => {
+  test("renders one plain list until a visible Bot has a label", () => {
+    expect(groupSidebarBotsV1(bots.slice(0, 2), {})).toEqual({
+      showHeadings: false,
+      groups: [{ key: "all", label: "", bots: bots.slice(0, 2) }],
+    });
+  });
+
+  test("groups case-insensitively, keeps first spelling, and puts Unassigned last", () => {
+    const grouped = groupSidebarBotsV1(bots, {
+      alpha: { label: " Personal " },
+      beta: {},
+      gamma: { label: "personal" },
+      delta: { label: "Work" },
+    });
+    expect(grouped.showHeadings).toBe(true);
+    expect(
+      grouped.groups.map((group) => ({
+        label: group.label,
+        bots: group.bots.map((bot) => bot.botId),
+      })),
+    ).toEqual([
+      { label: "Personal", bots: ["alpha", "gamma"] },
+      { label: "Work", bots: ["delta"] },
+      { label: "Unassigned", bots: ["beta"] },
+    ]);
+  });
+
+  test("treats whitespace-only labels as Unassigned", () => {
+    const grouped = groupSidebarBotsV1(bots.slice(0, 2), {
+      alpha: { label: "\t" },
+      beta: { label: "Work" },
+    });
+    expect(grouped.groups.map((group) => group.label)).toEqual([
+      "Work",
+      "Unassigned",
+    ]);
+  });
+});
+
+describe("sidebar preview times", () => {
+  const now = new Date(2026, 8, 1, 15, 30);
+
+  test("shows a time today, a weekday this week, and M/D when older", () => {
+    expect(
+      formatSidebarMessageTimeV1(
+        new Date(2026, 8, 1, 7, 34).toISOString(),
+        now,
+        "en-US",
+      ),
+    ).toBe("7:34 AM");
+    expect(
+      formatSidebarMessageTimeV1(
+        new Date(2026, 7, 27, 12).toISOString(),
+        now,
+        "en-US",
+      ),
+    ).toBe("Thursday");
+    expect(
+      formatSidebarMessageTimeV1(
+        new Date(2026, 7, 22, 12).toISOString(),
+        now,
+        "en-US",
+      ),
+    ).toBe("8/22");
+  });
+});

package/src/client/sidebar.ts

@@ -0,0 +1,77 @@
+export interface SidebarBotGroupV1<T> {
+  key: string;
+  label: string;
+  bots: T[];
+}
+
+export interface GroupedSidebarBotsV1<T> {
+  showHeadings: boolean;
+  groups: SidebarBotGroupV1<T>[];
+}
+
+/**
+ * Groups labels by their case-insensitive trimmed value while preserving the
+ * spelling of the first Bot in each group. Unassigned is always last. Until a
+ * visible Bot has a label, the sidebar remains one plain list with no heading.
+ */
+export function groupSidebarBotsV1<T extends { botId: string }>(
+  bots: readonly T[],
+  profiles: Readonly<Record<string, { label?: string } | undefined>>,
+): GroupedSidebarBotsV1<T> {
+  const labelled = new Map<string, SidebarBotGroupV1<T>>();
+  const unassigned: T[] = [];
+  for (const bot of bots) {
+    const label = profiles[bot.botId]?.label?.trim() ?? "";
+    if (!label) {
+      unassigned.push(bot);
+      continue;
+    }
+    const key = label.toLowerCase();
+    const group = labelled.get(key);
+    if (group) group.bots.push(bot);
+    else labelled.set(key, { key: `label:${key}`, label, bots: [bot] });
+  }
+  if (labelled.size === 0) {
+    return {
+      showHeadings: false,
+      groups: [{ key: "all", label: "", bots: [...bots] }],
+    };
+  }
+  return {
+    showHeadings: true,
+    groups: [
+      ...labelled.values(),
+      ...(unassigned.length === 0
+        ? []
+        : [{ key: "unassigned", label: "Unassigned", bots: unassigned }]),
+    ],
+  };
+}
+
+/** GrokBot-style local time label for the sidebar's latest message. */
+export function formatSidebarMessageTimeV1(
+  at: string,
+  now: Date = new Date(),
+  locale?: string,
+): string {
+  const message = new Date(at);
+  if (!Number.isFinite(message.getTime())) return "";
+  const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+  const tomorrow = new Date(today);
+  tomorrow.setDate(tomorrow.getDate() + 1);
+  if (message >= today && message < tomorrow) {
+    return new Intl.DateTimeFormat(locale, {
+      hour: "numeric",
+      minute: "2-digit",
+    }).format(message);
+  }
+  const week = new Date(today);
+  week.setDate(week.getDate() - 6);
+  if (message >= week && message < tomorrow) {
+    return new Intl.DateTimeFormat(locale, { weekday: "long" }).format(message);
+  }
+  return new Intl.DateTimeFormat(locale, {
+    month: "numeric",
+    day: "numeric",
+  }).format(message);
+}

package/src/client/state.ts

@@ -0,0 +1,53 @@
+import type { InjectionKey, Ref } from "vue";
+// Shell selection is injected through its public hosted-client interface.
+import type { FrockBotWebData } from "@frockbot/plugin-shell/shared";
+import type { BotUnreadViewV1 } from "@frockbot/plugin-shell/unread";
+import type {
+  BotDirectoryViewV1,
+  BotIdentityViewV1,
+  BotLifecycleStatusV1,
+  SheepIdentityViewV1,
+  SheepRecipeV1,
+} from "../shared.js";
+
+export interface FlockWebData {
+  directory: BotDirectoryViewV1;
+  identities: Record<string, SheepIdentityViewV1>;
+  /** Live Bot identity — the current name, title, avatar and hidden flag. */
+  profiles: Record<string, BotIdentityViewV1>;
+  /** Reveals Bots their own settings hide from the list. */
+  showHidden: boolean;
+  /** Per-Bot unread, as the Bot Durable Objects derive it. Never computed here. */
+  unread: Record<string, BotUnreadViewV1>;
+  loading: boolean;
+  error?: string;
+  overlay?: "create" | "edit" | "archive";
+  lifecycles: Record<string, BotLifecycleStatusV1>;
+  showArchived: boolean;
+  lifecyclePending?: string;
+  draftName: string;
+  draftSheep: SheepRecipeV1;
+  bindShell(shell: Ref<FrockBotWebData>): void;
+  load(): Promise<void>;
+  /** Re-reads the bounded unread fan-out for the whole sidebar. */
+  refreshUnread(): Promise<void>;
+  /** The authenticated read receipt. Never fired from a poll. */
+  markRead(botId: string): Promise<void>;
+  /** User intent: keep this Bot bold until it is opened again. */
+  markUnread(botId: string): Promise<void>;
+  select(botId: string): Promise<void>;
+  openCreate(): void;
+  openEdit(): Promise<void>;
+  toggleArchived(): void;
+  toggleHidden(): void;
+  openArchive(botId: string): void;
+  archive(): Promise<void>;
+  restore(botId: string): Promise<void>;
+  closeOverlay(): void;
+  reroll(): void;
+  create(): Promise<void>;
+  saveSheep(): Promise<void>;
+}
+
+export const flockWebDataKey: InjectionKey<Ref<FlockWebData>> =
+  Symbol("flock-web-data");