@flrande/browserctl 0.5.0-dev.22.1 → 0.6.0

package/packages/core/src/navigation-memory.ts

@@ -1,360 +0,0 @@
-const DEFAULT_TTL_DAYS = 30;
-const DAY_MS = 24 * 60 * 60 * 1000;
-
-export type NavigationSignal =
-  | { kind: "urlPattern"; value: string }
-  | { kind: "selector"; value: string }
-  | { kind: "hop"; from: string; to: string };
-
-export type NavigationMemoryEntry = {
-  id: string;
-  domain: string;
-  profileId: string;
-  intentKey: string;
-  signals: NavigationSignal[];
-  confidence: number;
-  createdAt: string;
-  lastHitAt: string;
-  expireAt: string;
-  hitCount: number;
-};
-
-export type NavigationMemoryMode = "off" | "ask" | "auto";
-
-export type NavigationMemoryStoreOptions = {
-  path: string;
-  mode?: NavigationMemoryMode;
-  ttlDays?: number;
-  now?: () => number;
-};
-
-export type NavigationMemoryResolveInput = {
-  domain: string;
-  profileId: string;
-  intentKey: string;
-};
-
-export type NavigationMemoryResolveResult =
-  | { hit: false; entry?: undefined }
-  | { hit: true; entry: NavigationMemoryEntry };
-
-export type NavigationMemoryUpsertInput = {
-  domain: string;
-  profileId: string;
-  intentKey: string;
-  signals: NavigationSignal[];
-  confidence?: number;
-  confirmed?: boolean;
-};
-
-export type NavigationMemoryUpsertResult = {
-  created: boolean;
-  entry: NavigationMemoryEntry;
-};
-
-export type NavigationMemoryListInput = {
-  domain?: string;
-  profileId?: string;
-  intentKey?: string;
-};
-
-export type NavigationMemoryStatus = {
-  path: string;
-  mode: NavigationMemoryMode;
-  ttlDays: number;
-  totalEntries: number;
-};
-
-export type NavigationMemoryStore = {
-  resolve(input: NavigationMemoryResolveInput): Promise<NavigationMemoryResolveResult>;
-  upsert(input: NavigationMemoryUpsertInput): Promise<NavigationMemoryUpsertResult>;
-  list(filter?: NavigationMemoryListInput): Promise<NavigationMemoryEntry[]>;
-  inspect(id: string): Promise<NavigationMemoryEntry | undefined>;
-  delete(id: string): Promise<boolean>;
-  purgeExpired(): Promise<number>;
-  setMode(mode: NavigationMemoryMode): Promise<NavigationMemoryStatus>;
-  setTtlDays(ttlDays: number): Promise<NavigationMemoryStatus>;
-  status(): NavigationMemoryStatus;
-};
-
-function toIso(timestampMs: number): string {
-  return new Date(timestampMs).toISOString();
-}
-
-function parseTime(value: string): number {
-  const parsed = Date.parse(value);
-  return Number.isFinite(parsed) ? parsed : 0;
-}
-
-function normalizeTtlDays(value: number | undefined): number {
-  if (value === undefined) {
-    return DEFAULT_TTL_DAYS;
-  }
-
-  return Math.max(0, Math.trunc(value));
-}
-
-function normalizeConfidence(value: number | undefined): number {
-  if (value === undefined || Number.isNaN(value) || !Number.isFinite(value)) {
-    return 1;
-  }
-
-  if (value <= 0) {
-    return 0;
-  }
-
-  if (value >= 1) {
-    return 1;
-  }
-
-  return value;
-}
-
-function toExpireAt(nowMs: number, ttlDays: number): string {
-  return toIso(nowMs + normalizeTtlDays(ttlDays) * DAY_MS);
-}
-
-function isScopeMatch(
-  entry: NavigationMemoryEntry,
-  input: Pick<NavigationMemoryResolveInput, "domain" | "profileId" | "intentKey">
-): boolean {
-  return entry.domain === input.domain && entry.profileId === input.profileId && entry.intentKey === input.intentKey;
-}
-
-function cloneSignal(signal: NavigationSignal): NavigationSignal {
-  if (signal.kind === "hop") {
-    return {
-      kind: "hop",
-      from: signal.from,
-      to: signal.to
-    };
-  }
-
-  return {
-    kind: signal.kind,
-    value: signal.value
-  };
-}
-
-function cloneEntry(entry: NavigationMemoryEntry): NavigationMemoryEntry {
-  return {
-    ...entry,
-    signals: entry.signals.map((signal) => cloneSignal(signal))
-  };
-}
-
-function isExpired(entry: NavigationMemoryEntry, nowMs: number): boolean {
-  return parseTime(entry.expireAt) <= nowMs;
-}
-
-function isNewer(a: NavigationMemoryEntry, b: NavigationMemoryEntry): boolean {
-  return parseTime(a.lastHitAt) > parseTime(b.lastHitAt);
-}
-
-export function createNavigationMemoryStore(options: NavigationMemoryStoreOptions): NavigationMemoryStore {
-  if (options.path.trim().length === 0) {
-    throw new Error("Navigation memory path must not be empty.");
-  }
-
-  const now = options.now ?? (() => Date.now());
-  let mode: NavigationMemoryMode = options.mode ?? "auto";
-  let ttlDays = normalizeTtlDays(options.ttlDays);
-  const entries = new Map<string, NavigationMemoryEntry>();
-  let nextId = 1;
-
-  function createId(): string {
-    const id = `memory:${nextId}`;
-    nextId += 1;
-    return id;
-  }
-
-  function pruneExpired(): number {
-    const currentTime = now();
-    let removed = 0;
-    for (const [entryId, entry] of entries.entries()) {
-      if (!isExpired(entry, currentTime)) {
-        continue;
-      }
-
-      entries.delete(entryId);
-      removed += 1;
-    }
-
-    return removed;
-  }
-
-  function findScopedEntry(input: NavigationMemoryResolveInput): NavigationMemoryEntry | undefined {
-    let selected: NavigationMemoryEntry | undefined;
-    for (const entry of entries.values()) {
-      if (!isScopeMatch(entry, input)) {
-        continue;
-      }
-
-      if (selected === undefined) {
-        selected = entry;
-        continue;
-      }
-
-      if (entry.confidence > selected.confidence || (entry.confidence === selected.confidence && isNewer(entry, selected))) {
-        selected = entry;
-      }
-    }
-
-    return selected;
-  }
-
-  function getStatus(): NavigationMemoryStatus {
-    const currentTime = now();
-    const totalEntries = Array.from(entries.values()).filter((entry) => !isExpired(entry, currentTime)).length;
-    return {
-      path: options.path,
-      mode,
-      ttlDays,
-      totalEntries
-    };
-  }
-
-  function assertUpsertAllowed(input: NavigationMemoryUpsertInput): void {
-    if (mode === "auto") {
-      return;
-    }
-
-    if (mode === "ask") {
-      if (input.confirmed === true) {
-        return;
-      }
-
-      throw new Error("Navigation memory write requires confirmation in ask mode.");
-    }
-
-    throw new Error("Navigation memory write is disabled when mode is off.");
-  }
-
-  return {
-    async resolve(input: NavigationMemoryResolveInput): Promise<NavigationMemoryResolveResult> {
-      if (mode === "off") {
-        return { hit: false };
-      }
-
-      pruneExpired();
-      const existing = findScopedEntry(input);
-      if (existing === undefined) {
-        return { hit: false };
-      }
-
-      const currentTime = now();
-      const updated: NavigationMemoryEntry = {
-        ...existing,
-        lastHitAt: toIso(currentTime),
-        expireAt: toExpireAt(currentTime, ttlDays),
-        hitCount: existing.hitCount + 1
-      };
-      entries.set(updated.id, updated);
-
-      return {
-        hit: true,
-        entry: cloneEntry(updated)
-      };
-    },
-
-    async upsert(input: NavigationMemoryUpsertInput): Promise<NavigationMemoryUpsertResult> {
-      assertUpsertAllowed(input);
-      pruneExpired();
-      const currentTime = now();
-      const confidence = normalizeConfidence(input.confidence);
-      const signals = input.signals.map((signal) => cloneSignal(signal));
-      const existing = findScopedEntry(input);
-
-      if (existing !== undefined) {
-        const updated: NavigationMemoryEntry = {
-          ...existing,
-          signals,
-          confidence,
-          expireAt: toExpireAt(currentTime, ttlDays)
-        };
-        entries.set(updated.id, updated);
-        return {
-          created: false,
-          entry: cloneEntry(updated)
-        };
-      }
-
-      const createdAt = toIso(currentTime);
-      const created: NavigationMemoryEntry = {
-        id: createId(),
-        domain: input.domain,
-        profileId: input.profileId,
-        intentKey: input.intentKey,
-        signals,
-        confidence,
-        createdAt,
-        lastHitAt: createdAt,
-        expireAt: toExpireAt(currentTime, ttlDays),
-        hitCount: 0
-      };
-      entries.set(created.id, created);
-
-      return {
-        created: true,
-        entry: cloneEntry(created)
-      };
-    },
-
-    async list(filter?: NavigationMemoryListInput): Promise<NavigationMemoryEntry[]> {
-      pruneExpired();
-      return Array.from(entries.values())
-        .filter((entry) => {
-          if (filter === undefined) {
-            return true;
-          }
-          if (filter.domain !== undefined && filter.domain !== entry.domain) {
-            return false;
-          }
-          if (filter.profileId !== undefined && filter.profileId !== entry.profileId) {
-            return false;
-          }
-          if (filter.intentKey !== undefined && filter.intentKey !== entry.intentKey) {
-            return false;
-          }
-          return true;
-        })
-        .map((entry) => cloneEntry(entry));
-    },
-
-    async inspect(id: string): Promise<NavigationMemoryEntry | undefined> {
-      pruneExpired();
-      const entry = entries.get(id);
-      return entry === undefined ? undefined : cloneEntry(entry);
-    },
-
-    async delete(id: string): Promise<boolean> {
-      return entries.delete(id);
-    },
-
-    async purgeExpired(): Promise<number> {
-      return pruneExpired();
-    },
-
-    async setMode(nextMode: NavigationMemoryMode): Promise<NavigationMemoryStatus> {
-      mode = nextMode;
-      return getStatus();
-    },
-
-    async setTtlDays(nextTtlDays: number): Promise<NavigationMemoryStatus> {
-      pruneExpired();
-      ttlDays = normalizeTtlDays(nextTtlDays);
-      const refreshedExpireAt = toExpireAt(now(), ttlDays);
-      for (const [entryId, entry] of entries.entries()) {
-        entries.set(entryId, {
-          ...entry,
-          expireAt: refreshedExpireAt
-        });
-      }
-      return getStatus();
-    },
-
-    status(): NavigationMemoryStatus {
-      return getStatus();
-    }
-  };
-}

package/packages/core/src/ref-cache.test.ts

@@ -1,61 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { RefCache, createRefKey } from "./ref-cache";
-
-describe("RefCache", () => {
-  it("uses sessionId|profile|targetId as cache key", () => {
-    const cache = new RefCache<string>();
-
-    cache.set("session:a", "managed", "target:1", "value-a");
-    cache.set("session:a", "managed", "target:2", "value-b");
-    cache.set("session:a", "chrome-relay", "target:1", "value-c");
-
-    expect(cache.get("session:a", "managed", "target:1")).toBe("value-a");
-    expect(cache.get("session:a", "managed", "target:2")).toBe("value-b");
-    expect(cache.get("session:a", "chrome-relay", "target:1")).toBe("value-c");
-  });
-
-  it("does not collide across sessionIds", () => {
-    const cache = new RefCache<string>();
-
-    cache.set("session:a", "managed", "target:1", "value-a");
-    cache.set("session:b", "managed", "target:1", "value-b");
-
-    expect(cache.get("session:a", "managed", "target:1")).toBe("value-a");
-    expect(cache.get("session:b", "managed", "target:1")).toBe("value-b");
-  });
-
-  it("escapes key segments before joining with |", () => {
-    expect(createRefKey("session|a", "managed|x", "target|1")).toBe("session%7Ca|managed%7Cx|target%7C1");
-  });
-
-  it("does not collide when identifiers contain |", () => {
-    const cache = new RefCache<string>();
-
-    cache.set("session|a", "managed", "target", "value-a");
-    cache.set("session", "a|managed", "target", "value-b");
-
-    expect(cache.get("session|a", "managed", "target")).toBe("value-a");
-    expect(cache.get("session", "a|managed", "target")).toBe("value-b");
-  });
-
-  it("returns undefined for unknown key", () => {
-    const cache = new RefCache<string>();
-
-    expect(cache.get("missing", "managed", "target:1")).toBeUndefined();
-  });
-
-  it("deletes an existing key", () => {
-    const cache = new RefCache<string>();
-    cache.set("session:a", "managed", "target:1", "value-a");
-
-    expect(cache.delete("session:a", "managed", "target:1")).toBe(true);
-    expect(cache.get("session:a", "managed", "target:1")).toBeUndefined();
-  });
-
-  it("returns false when deleting an unknown key", () => {
-    const cache = new RefCache<string>();
-
-    expect(cache.delete("missing", "managed", "target:1")).toBe(false);
-  });
-});

package/packages/core/src/ref-cache.ts

@@ -1,28 +0,0 @@
-import type { ProfileId, SessionId, TargetId } from "./types";
-
-function escapeKeySegment(value: string): string {
-  return encodeURIComponent(value);
-}
-
-export function createRefKey(sessionId: SessionId, profile: ProfileId, targetId: TargetId): string {
-  return `${escapeKeySegment(sessionId)}|${escapeKeySegment(profile)}|${escapeKeySegment(targetId)}`;
-}
-
-export class RefCache<TValue> {
-  private readonly refs = new Map<string, TValue>();
-
-  get(sessionId: SessionId, profile: ProfileId, targetId: TargetId): TValue | undefined {
-    const key = createRefKey(sessionId, profile, targetId);
-    return this.refs.get(key);
-  }
-
-  set(sessionId: SessionId, profile: ProfileId, targetId: TargetId, value: TValue): void {
-    const key = createRefKey(sessionId, profile, targetId);
-    this.refs.set(key, value);
-  }
-
-  delete(sessionId: SessionId, profile: ProfileId, targetId: TargetId): boolean {
-    const key = createRefKey(sessionId, profile, targetId);
-    return this.refs.delete(key);
-  }
-}

package/packages/core/src/session-store.test.ts

@@ -1,82 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { SessionStore } from "./session-store";
-
-describe("SessionStore", () => {
-  it("binds profile to session", () => {
-    const store = new SessionStore();
-
-    store.useProfile("cli:local", "managed");
-
-    expect(store.get("cli:local")?.profile).toBe("managed");
-  });
-
-  it("uses sessionId as the only store key", () => {
-    const store = new SessionStore();
-
-    store.useProfile("session:a", "managed");
-    store.useProfile("session:b", "chrome-relay");
-
-    expect(store.get("session:a")).toEqual({
-      sessionId: "session:a",
-      profile: "managed"
-    });
-    expect(store.get("session:b")).toEqual({
-      sessionId: "session:b",
-      profile: "chrome-relay"
-    });
-  });
-
-  it("returns undefined for unknown session", () => {
-    const store = new SessionStore();
-
-    expect(store.get("missing")).toBeUndefined();
-  });
-
-  it("deletes an existing session", () => {
-    const store = new SessionStore();
-    store.useProfile("cli:local", "managed");
-
-    expect(store.delete("cli:local")).toBe(true);
-    expect(store.get("cli:local")).toBeUndefined();
-  });
-
-  it("returns false when deleting an unknown session", () => {
-    const store = new SessionStore();
-
-    expect(store.delete("missing")).toBe(false);
-  });
-
-  it("expires sessions after ttl and returns undefined", () => {
-    let now = 1_000;
-    const store = new SessionStore({
-      ttlMs: 100,
-      now: () => now
-    });
-
-    store.useProfile("session:ttl", "managed");
-    now += 150;
-
-    expect(store.get("session:ttl")).toBeUndefined();
-  });
-
-  it("cleans up expired sessions and keeps active ones", () => {
-    let now = 1_000;
-    const store = new SessionStore({
-      ttlMs: 100,
-      now: () => now
-    });
-
-    store.useProfile("session:old", "managed");
-    now += 50;
-    store.useProfile("session:active", "managed");
-    now += 60;
-
-    expect(store.cleanupExpired()).toBe(1);
-    expect(store.get("session:old")).toBeUndefined();
-    expect(store.get("session:active")).toEqual({
-      sessionId: "session:active",
-      profile: "managed"
-    });
-  });
-});

package/packages/core/src/session-store.ts

@@ -1,138 +0,0 @@
-import type { ProfileId, SessionId, SessionState, TargetId } from "./types";
-
-function createEmptySession(sessionId: SessionId): SessionState {
-  return { sessionId };
-}
-
-type SessionStoreOptions = {
-  ttlMs?: number;
-  now?: () => number;
-};
-
-type SessionEntry = {
-  state: SessionState;
-  touchedAt: number;
-};
-
-export type SessionSnapshot = {
-  state: SessionState;
-  touchedAt: number;
-};
-
-export class SessionStore {
-  private readonly sessions = new Map<SessionId, SessionEntry>();
-  private readonly ttlMs: number;
-  private readonly now: () => number;
-
-  constructor(options: SessionStoreOptions = {}) {
-    this.ttlMs = options.ttlMs === undefined ? 0 : Math.max(0, Math.trunc(options.ttlMs));
-    this.now = options.now ?? (() => Date.now());
-  }
-
-  private isExpired(entry: SessionEntry, now: number): boolean {
-    return this.ttlMs > 0 && now - entry.touchedAt > this.ttlMs;
-  }
-
-  private readActiveEntry(sessionId: SessionId, touch = false): SessionEntry | undefined {
-    const existing = this.sessions.get(sessionId);
-    if (existing === undefined) {
-      return undefined;
-    }
-
-    const currentTime = this.now();
-    if (this.isExpired(existing, currentTime)) {
-      this.sessions.delete(sessionId);
-      return undefined;
-    }
-
-    if (touch) {
-      const touchedEntry: SessionEntry = {
-        state: existing.state,
-        touchedAt: currentTime
-      };
-      this.sessions.set(sessionId, touchedEntry);
-      return touchedEntry;
-    }
-
-    return existing;
-  }
-
-  get(sessionId: SessionId): SessionState | undefined {
-    return this.readActiveEntry(sessionId)?.state;
-  }
-
-  useProfile(sessionId: SessionId, profile: ProfileId): SessionState {
-    const current = this.readActiveEntry(sessionId, true)?.state ?? createEmptySession(sessionId);
-    const next = { ...current, profile };
-
-    this.sessions.set(sessionId, {
-      state: next,
-      touchedAt: this.now()
-    });
-    return next;
-  }
-
-  useTarget(sessionId: SessionId, targetId: TargetId): SessionState {
-    const current = this.readActiveEntry(sessionId, true)?.state ?? createEmptySession(sessionId);
-    const next = { ...current, targetId };
-
-    this.sessions.set(sessionId, {
-      state: next,
-      touchedAt: this.now()
-    });
-    return next;
-  }
-
-  delete(sessionId: SessionId): boolean {
-    return this.sessions.delete(sessionId);
-  }
-
-  cleanupExpired(): number {
-    if (this.ttlMs <= 0 || this.sessions.size === 0) {
-      return 0;
-    }
-
-    const currentTime = this.now();
-    let removedCount = 0;
-    for (const [sessionId, entry] of this.sessions.entries()) {
-      if (!this.isExpired(entry, currentTime)) {
-        continue;
-      }
-
-      this.sessions.delete(sessionId);
-      removedCount += 1;
-    }
-
-    return removedCount;
-  }
-
-  has(sessionId: SessionId): boolean {
-    return this.readActiveEntry(sessionId) !== undefined;
-  }
-
-  listSnapshots(): SessionSnapshot[] {
-    const snapshots: SessionSnapshot[] = [];
-    const currentTime = this.now();
-    for (const [sessionId, entry] of this.sessions.entries()) {
-      if (this.isExpired(entry, currentTime)) {
-        this.sessions.delete(sessionId);
-        continue;
-      }
-
-      snapshots.push({
-        state: entry.state,
-        touchedAt: entry.touchedAt
-      });
-    }
-
-    return snapshots;
-  }
-
-  list(): SessionState[] {
-    return this.listSnapshots().map((snapshot) => snapshot.state);
-  }
-
-  size(): number {
-    return this.listSnapshots().length;
-  }
-}

package/packages/core/src/types.ts

@@ -1,9 +0,0 @@
-export type SessionId = string;
-export type ProfileId = string;
-export type TargetId = string;
-
-export type SessionState = {
-  sessionId: SessionId;
-  profile?: ProfileId;
-  targetId?: TargetId;
-};