Skip to content

High-performance browser automation bridge and multi-instance orchestrator with advanced stealth injection and real-time dashboard.

6.1 KB
Raw Blame
import { describe, it, beforeEach, afterEach } from "node:test";
import assert from "node:assert";
import { getLastTabId, setLastTabId, resolveProfile, isLocalHost, formatDiscoveredBaseUrl, ensureReady, invalidateReadiness } from "./session.ts";

describe("tab session state", () => {
  beforeEach(() => {
    setLastTabId(undefined);
    setLastTabId(undefined, { agentId: "main" });
    setLastTabId(undefined, { agentId: "writer" });
  });

  it("starts with undefined tabId", () => {
    assert.strictEqual(getLastTabId(), undefined);
  });

  it("stores and retrieves tabId", () => {
    setLastTabId("tab123");
    assert.strictEqual(getLastTabId(), "tab123");
  });

  it("keeps tab state isolated per agent", () => {
    setLastTabId("main-tab", { agentId: "main", sessionId: "s1" });
    setLastTabId("writer-tab", { agentId: "writer", sessionId: "s2" });
    assert.strictEqual(getLastTabId({ agentId: "main" }), "main-tab");
    assert.strictEqual(getLastTabId({ agentId: "writer" }), "writer-tab");
    assert.strictEqual(getLastTabId(), undefined);
  });

  it("can clear tabId", () => {
    setLastTabId("tab123");
    setLastTabId(undefined);
    assert.strictEqual(getLastTabId(), undefined);
  });
});

describe("resolveProfile", () => {
  it("returns empty object for default openclaw profile", () => {
    const result = resolveProfile({}, undefined);
    assert.deepStrictEqual(result, {});
  });

  it("returns attach:true for user profile", () => {
    const result = resolveProfile({}, "user");
    assert.deepStrictEqual(result, { attach: true });
  });

  it("uses config defaultProfile", () => {
    const cfg = { defaultProfile: "user" };
    const result = resolveProfile(cfg, undefined);
    assert.deepStrictEqual(result, { attach: true });
  });

  it("returns custom profile config", () => {
    const cfg = {
      profiles: {
        staging: { instanceId: "staging-instance" },
        custom: { instanceId: "custom-id", attach: true },
      },
    };
    assert.deepStrictEqual(resolveProfile(cfg, "staging"), { instanceId: "staging-instance" });
    assert.deepStrictEqual(resolveProfile(cfg, "custom"), { instanceId: "custom-id", attach: true });
  });

  it("falls back to builtin for unknown profile", () => {
    const cfg = { profiles: { staging: { instanceId: "staging" } } };
    const result = resolveProfile(cfg, "unknown");
    assert.deepStrictEqual(result, {});
  });

  it("profile param overrides defaultProfile", () => {
    const cfg = { defaultProfile: "user", profiles: { staging: { instanceId: "s1" } } };
    const result = resolveProfile(cfg, "staging");
    assert.deepStrictEqual(result, { instanceId: "s1" });
  });
});

describe("isLocalHost", () => {
  it("returns true for localhost", () => {
    assert.strictEqual(isLocalHost("http://localhost:9867"), true);
    assert.strictEqual(isLocalHost("http://localhost"), true);
    assert.strictEqual(isLocalHost("http://LOCALHOST:9867"), true);
  });

  it("returns true for 127.0.0.1", () => {
    assert.strictEqual(isLocalHost("http://127.0.0.1:9867"), true);
    assert.strictEqual(isLocalHost("http://127.0.0.1"), true);
  });

  it("returns true for IPv6 localhost", () => {
    assert.strictEqual(isLocalHost("http://[::1]:9867"), true);
    assert.strictEqual(isLocalHost("http://[::1]"), true);
  });

  it("returns false for remote hosts", () => {
    assert.strictEqual(isLocalHost("http://example.com"), false);
    assert.strictEqual(isLocalHost("http://192.168.1.1:9867"), false);
    assert.strictEqual(isLocalHost("http://pinchtab.local:9867"), false);
    assert.strictEqual(isLocalHost("https://api.pinchtab.com"), false);
  });

  it("returns false for invalid URLs", () => {
    assert.strictEqual(isLocalHost("not-a-url"), false);
    assert.strictEqual(isLocalHost(""), false);
  });
});


describe("formatDiscoveredBaseUrl", () => {
  it("brackets IPv6 loopback binds", () => {
    assert.strictEqual(formatDiscoveredBaseUrl("::1", 9867), "http://[::1]:9867");
  });

  it("normalizes wildcard binds to local loopback", () => {
    assert.strictEqual(formatDiscoveredBaseUrl("0.0.0.0", 9867), "http://127.0.0.1:9867");
    assert.strictEqual(formatDiscoveredBaseUrl("::", 9867), "http://[::1]:9867");
  });
});

describe("readiness cache", () => {
  const cfg = { baseUrl: "http://localhost:9999", token: "t" };
  let originalFetch: typeof globalThis.fetch;
  let healthCalls = 0;
  let instancesCalls = 0;

  beforeEach(() => {
    invalidateReadiness(cfg);
    healthCalls = 0;
    instancesCalls = 0;
    originalFetch = globalThis.fetch;
    globalThis.fetch = (async (url: any) => {
      const u = String(url);
      if (u.includes("/instances")) {
        instancesCalls++;
        return new Response(JSON.stringify([{ id: "i1", status: "running" }]), {
          status: 200,
          headers: { "content-type": "application/json" },
        });
      }
      if (u.includes("/health")) {
        healthCalls++;
        return new Response(JSON.stringify({ status: "ok" }), {
          status: 200,
          headers: { "content-type": "application/json" },
        });
      }
      return new Response("{}", { status: 200, headers: { "content-type": "application/json" } });
    }) as any;
  });

  afterEach(() => {
    globalThis.fetch = originalFetch;
    invalidateReadiness(cfg);
  });

  it("probes on the first call and serves subsequent ones from cache", async () => {
    const r1 = await ensureReady(cfg);
    assert.strictEqual(r1.ok, true);
    assert.ok(healthCalls >= 1, "first call probes /health");
    assert.ok(instancesCalls >= 1, "first call probes /instances");

    const healthAfterFirst = healthCalls;
    const instancesAfterFirst = instancesCalls;

    const r2 = await ensureReady(cfg);
    assert.strictEqual(r2.ok, true);
    assert.strictEqual(healthCalls, healthAfterFirst, "cached: no extra /health probe");
    assert.strictEqual(instancesCalls, instancesAfterFirst, "cached: no extra /instances probe");
  });

  it("re-probes after the latch is invalidated", async () => {
    await ensureReady(cfg);
    const healthAfterFirst = healthCalls;

    invalidateReadiness(cfg);

    await ensureReady(cfg);
    assert.ok(healthCalls > healthAfterFirst, "re-probes after invalidation");
  });
});