@flrande/browserctl 0.5.0 → 0.6.0

package/packages/core/src/bootstrap.test.ts

@@ -1,10 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-describe("workspace bootstrap", () => {
-  it("loads test runner", () => {
-    const state = expect.getState();
-
-    expect(state.currentTestName).toContain("loads test runner");
-    expect(state.testPath).toContain("bootstrap.test.ts");
-  });
-});

package/packages/core/src/driver-registry.test.ts

@@ -1,45 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import type { BrowserDriver } from "./driver";
-import { DriverRegistry } from "./driver-registry";
-
-function createDriver(): BrowserDriver {
-  return {
-    status: async () => ({ kind: "test" }),
-    listProfiles: async () => [],
-    listTabs: async () => [],
-    openTab: async () => "target:1",
-    focusTab: async () => {},
-    closeTab: async () => {},
-    snapshot: async () => ({ html: "" }),
-    act: async () => ({ ok: true }),
-    armUpload: async () => {},
-    armDialog: async () => {},
-    waitDownload: async () => ({ path: "download.bin" }),
-    triggerDownload: async () => {}
-  };
-}
-
-describe("DriverRegistry", () => {
-  it("returns a registered driver", () => {
-    const registry = new DriverRegistry();
-    const driver = createDriver();
-
-    registry.register("managed", driver);
-
-    expect(registry.get("managed")).toBe(driver);
-  });
-
-  it("throws when registering a duplicate driver name", () => {
-    const registry = new DriverRegistry();
-    registry.register("managed", createDriver());
-
-    expect(() => registry.register("managed", createDriver())).toThrowError("Driver already registered: managed");
-  });
-
-  it("throws when the requested driver is not registered", () => {
-    const registry = new DriverRegistry();
-
-    expect(() => registry.get("missing")).toThrowError("Unknown driver: missing");
-  });
-});

package/packages/core/src/driver-registry.ts

@@ -1,22 +0,0 @@
-import type { BrowserDriver } from "./driver";
-
-export class DriverRegistry {
-  readonly #drivers = new Map<string, BrowserDriver>();
-
-  register(name: string, driver: BrowserDriver): void {
-    if (this.#drivers.has(name)) {
-      throw new Error(`Driver already registered: ${name}`);
-    }
-
-    this.#drivers.set(name, driver);
-  }
-
-  get(name: string): BrowserDriver {
-    const driver = this.#drivers.get(name);
-    if (!driver) {
-      throw new Error(`Unknown driver: ${name}`);
-    }
-
-    return driver;
-  }
-}

package/packages/core/src/driver.ts

@@ -1,47 +0,0 @@
-import type { ProfileId, TargetId } from "./types";
-
-export type DriverScalar = string | number | boolean | null;
-export type DriverValue = DriverScalar | DriverObject | DriverValue[];
-export type DriverObject = { [key: string]: DriverValue };
-
-export type DriverStatus = DriverObject;
-export type DriverSnapshot = DriverObject;
-export type DriverActionPayload = DriverObject;
-export type DriverActionResult = DriverObject;
-export type DriverDownloadResult = DriverObject;
-export type DriverScreenshot = DriverObject;
-
-export type DriverAction<TPayload extends DriverObject = DriverActionPayload> = {
-  type: string;
-  payload?: TPayload;
-};
-
-export type BrowserDriverScreenshot<
-  TScreenshot extends DriverObject = DriverScreenshot
-> = {
-  screenshot(targetId: TargetId, profile?: ProfileId): Promise<TScreenshot>;
-};
-
-export interface BrowserDriver<
-  TStatus extends DriverObject = DriverStatus,
-  TSnapshot extends DriverObject = DriverSnapshot,
-  TAction extends DriverAction = DriverAction,
-  TActionResult extends DriverObject = DriverActionResult,
-  TDownload extends DriverObject = DriverDownloadResult
-> {
-  status(): Promise<TStatus>;
-  listProfiles(): Promise<ProfileId[]>;
-  listTabs(profile?: ProfileId): Promise<TargetId[]>;
-
-  openTab(url: string, profile?: ProfileId): Promise<TargetId>;
-  focusTab(targetId: TargetId, profile?: ProfileId): Promise<void>;
-  closeTab(targetId: TargetId, profile?: ProfileId): Promise<void>;
-
-  snapshot(targetId: TargetId, profile?: ProfileId): Promise<TSnapshot>;
-  act(action: TAction, targetId: TargetId, profile?: ProfileId): Promise<TActionResult>;
-
-  armUpload(targetId: TargetId, files: string[], profile?: ProfileId): Promise<void>;
-  armDialog(targetId: TargetId, profile?: ProfileId): Promise<void>;
-  waitDownload(targetId: TargetId, profile?: ProfileId, path?: string): Promise<TDownload>;
-  triggerDownload(targetId: TargetId, profile?: ProfileId): Promise<void>;
-}

package/packages/core/src/index.ts

@@ -1,6 +0,0 @@
-export * from "./types";
-export * from "./session-store";
-export * from "./navigation-memory";
-export * from "./ref-cache";
-export * from "./driver";
-export * from "./driver-registry";

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

@@ -1,259 +0,0 @@
-import { existsSync } from "node:fs";
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { describe, expect, it } from "vitest";
-
-import { createNavigationMemoryStore } from "./navigation-memory";
-
-describe("navigation memory contracts", () => {
-  it("scopes by domain+profile", async () => {
-    const store = createNavigationMemoryStore({
-      path: ":memory:",
-      now: () => 1_000
-    });
-
-    await store.upsert({
-      domain: "forum.example",
-      profileId: "chrome-relay",
-      intentKey: "open_profile",
-      signals: [{ kind: "urlPattern", value: "/u/*" }]
-    });
-
-    const hit = await store.resolve({
-      domain: "forum.example",
-      profileId: "chrome-relay",
-      intentKey: "open_profile"
-    });
-    const missByProfile = await store.resolve({
-      domain: "forum.example",
-      profileId: "managed-local",
-      intentKey: "open_profile"
-    });
-    const missByDomain = await store.resolve({
-      domain: "news.example",
-      profileId: "chrome-relay",
-      intentKey: "open_profile"
-    });
-
-    expect(hit.hit).toBe(true);
-    expect(hit.entry?.signals).toEqual([{ kind: "urlPattern", value: "/u/*" }]);
-    expect(missByProfile.hit).toBe(false);
-    expect(missByDomain.hit).toBe(false);
-  });
-
-  it("implements the core store API", async () => {
-    let now = 10_000;
-    const store = createNavigationMemoryStore({
-      path: ":memory:",
-      now: () => now,
-      ttlDays: 1
-    });
-
-    const upserted = await store.upsert({
-      domain: "news.example",
-      profileId: "chrome-relay",
-      intentKey: "hot",
-      signals: [{ kind: "selector", value: "#hot-list" }],
-      confidence: 0.7
-    });
-
-    expect(upserted.created).toBe(true);
-    expect((await store.list())).toHaveLength(1);
-    expect(await store.inspect(upserted.entry.id)).toMatchObject({
-      id: upserted.entry.id,
-      domain: "news.example",
-      profileId: "chrome-relay",
-      intentKey: "hot"
-    });
-
-    await store.setMode("ask");
-    await store.setTtlDays(0);
-    expect(store.status()).toMatchObject({
-      mode: "ask",
-      ttlDays: 0,
-      totalEntries: 0
-    });
-
-    now += 1;
-    expect(await store.purgeExpired()).toBe(1);
-    expect(await store.delete(upserted.entry.id)).toBe(false);
-    expect(await store.list()).toHaveLength(0);
-  });
-
-  it("keeps task1 store in-memory even when path is set", async () => {
-    const dirPath = await mkdtemp(join(tmpdir(), "navigation-memory-task1-"));
-    const filePath = join(dirPath, "navigation-memory.json");
-
-    try {
-      const store = createNavigationMemoryStore({
-        path: filePath,
-        now: () => 1_000
-      });
-
-      await store.upsert({
-        domain: "forum.example",
-        profileId: "chrome-relay",
-        intentKey: "open_profile",
-        signals: [{ kind: "urlPattern", value: "/u/*" }]
-      });
-
-      expect(existsSync(filePath)).toBe(false);
-    } finally {
-      await rm(dirPath, { recursive: true, force: true });
-    }
-  });
-
-  it("does not revive expired entries when ttl days changes", async () => {
-    const dayMs = 24 * 60 * 60 * 1000;
-    let now = 5_000;
-    const store = createNavigationMemoryStore({
-      path: ":memory:",
-      now: () => now,
-      ttlDays: 1
-    });
-
-    const upserted = await store.upsert({
-      domain: "forum.example",
-      profileId: "chrome-relay",
-      intentKey: "open_profile",
-      signals: [{ kind: "selector", value: "#profile-link" }]
-    });
-
-    now += dayMs + 1;
-
-    const status = await store.setTtlDays(30);
-    expect(status.totalEntries).toBe(0);
-    expect(await store.inspect(upserted.entry.id)).toBeUndefined();
-  });
-
-  it("supports extracted setMode and setTtlDays calls", async () => {
-    const store = createNavigationMemoryStore({
-      path: ":memory:"
-    });
-
-    const { setMode, setTtlDays } = store;
-
-    const modeStatus = await setMode("ask");
-    expect(modeStatus.mode).toBe("ask");
-
-    const ttlStatus = await setTtlDays(7);
-    expect(ttlStatus.ttlDays).toBe(7);
-
-    expect(store.status()).toMatchObject({
-      mode: "ask",
-      ttlDays: 7
-    });
-  });
-
-  it("renews expireAt when resolve hits", async () => {
-    let now = 10_000;
-    const dayMs = 24 * 60 * 60 * 1000;
-    const store = createNavigationMemoryStore({
-      path: ":memory:",
-      now: () => now,
-      ttlDays: 30
-    });
-
-    const created = await store.upsert({
-      domain: "news.example",
-      profileId: "chrome-relay",
-      intentKey: "hot",
-      signals: []
-    });
-
-    const before = await store.inspect(created.entry.id);
-    now += 60_000;
-
-    const first = await store.resolve({
-      domain: "news.example",
-      profileId: "chrome-relay",
-      intentKey: "hot"
-    });
-
-    expect(first.hit).toBe(true);
-    expect(first.entry).toBeDefined();
-    expect(first.entry!.expireAt).not.toBe(before!.expireAt);
-    expect(first.entry!.expireAt).toBe(new Date(now + 30 * dayMs).toISOString());
-
-    const inspected = await store.inspect(first.entry!.id);
-    expect(inspected!.hitCount).toBe(1);
-    expect(inspected!.expireAt).toBe(first.entry!.expireAt);
-  });
-
-  it("rejects write when mode=ask and no explicit approval", async () => {
-    const store = createNavigationMemoryStore({ path: ":memory:", mode: "ask" });
-
-    await expect(
-      store.upsert({
-        domain: "forum.example",
-        profileId: "chrome-relay",
-        intentKey: "open_profile",
-        signals: [],
-        confirmed: false
-      })
-    ).rejects.toThrow(/confirmation/i);
-  });
-
-  it("returns miss and does not mutate entry when mode=off on resolve", async () => {
-    let now = 10_000;
-    const store = createNavigationMemoryStore({
-      path: ":memory:",
-      now: () => now,
-      ttlDays: 30
-    });
-
-    const created = await store.upsert({
-      domain: "forum.example",
-      profileId: "chrome-relay",
-      intentKey: "open_profile",
-      signals: [{ kind: "selector", value: "#profile-link" }]
-    });
-
-    const before = await store.inspect(created.entry.id);
-    await store.setMode("off");
-    now += 5_000;
-
-    const resolved = await store.resolve({
-      domain: "forum.example",
-      profileId: "chrome-relay",
-      intentKey: "open_profile"
-    });
-
-    expect(resolved.hit).toBe(false);
-    expect(resolved.entry).toBeUndefined();
-
-    const after = await store.inspect(created.entry.id);
-    expect(after).toBeDefined();
-    expect(after!.hitCount).toBe(before!.hitCount);
-    expect(after!.lastHitAt).toBe(before!.lastHitAt);
-    expect(after!.expireAt).toBe(before!.expireAt);
-  });
-
-  it("does not delete expired entry when mode=off resolve is called", async () => {
-    const store = createNavigationMemoryStore({
-      path: ":memory:",
-      now: () => 10_000,
-      ttlDays: 0
-    });
-
-    const created = await store.upsert({
-      domain: "forum.example",
-      profileId: "chrome-relay",
-      intentKey: "open_profile",
-      signals: [{ kind: "selector", value: "#profile-link" }]
-    });
-
-    await store.setMode("off");
-
-    const resolved = await store.resolve({
-      domain: "forum.example",
-      profileId: "chrome-relay",
-      intentKey: "open_profile"
-    });
-
-    expect(resolved.hit).toBe(false);
-    expect(resolved.entry).toBeUndefined();
-    expect(await store.delete(created.entry.id)).toBe(true);
-  });
-});