tmux-ide 2.9.2 → 2.9.4

package/packages/daemon-client/src/first-latest-coordinator.test.ts

@@ -1,175 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import { FirstLatestCoordinator } from "./first-latest-coordinator.ts";
-
-function deferred() {
-  let resolve!: () => void;
-  let reject!: (error: unknown) => void;
-  const promise = new Promise<void>((accept, deny) => {
-    resolve = accept;
-    reject = deny;
-  });
-  return { promise, resolve, reject };
-}
-
-async function settle(): Promise<void> {
-  await Promise.resolve();
-  await Promise.resolve();
-}
-
-describe("FirstLatestCoordinator", () => {
-  it("runs the first and latest request while superseding intermediate work", async () => {
-    const coordinator = new FirstLatestCoordinator();
-    const first = deferred();
-    const latest = deferred();
-    const events: string[] = [];
-    const request = (key: string, execution: Promise<void>) => ({
-      key,
-      execute: () => execution,
-      onSuccess: () => events.push(`${key}:ok`),
-      onFailure: () => events.push(`${key}:failed`),
-      onSuperseded: () => events.push(`${key}:superseded`),
-    });
-
-    expect(coordinator.request(request("80x24", first.promise))).toBe("started");
-    expect(coordinator.request(request("90x30", Promise.resolve()))).toBe("queued");
-    expect(coordinator.request(request("100x40", latest.promise))).toBe("queued");
-    expect(events).toEqual(["90x30:superseded"]);
-    expect(coordinator.snapshot()).toEqual({ activeKey: "80x24", pendingKey: "100x40" });
-
-    first.resolve();
-    await settle();
-    expect(events).toEqual(["90x30:superseded", "80x24:ok"]);
-    latest.resolve();
-    await settle();
-    expect(events).toEqual(["90x30:superseded", "80x24:ok", "100x40:ok"]);
-  });
-
-  it("coalesces equal active/pending keys and fences late retirement", async () => {
-    const coordinator = new FirstLatestCoordinator();
-    const active = deferred();
-    const events: string[] = [];
-    const request = (key: string) => ({
-      key,
-      execute: () => active.promise,
-      onSuccess: () => events.push(`${key}:ok`),
-      onFailure: () => events.push(`${key}:failed`),
-      onSuperseded: () => events.push(`${key}:superseded`),
-    });
-
-    expect(coordinator.request(request("a"))).toBe("started");
-    expect(coordinator.request(request("b"))).toBe("queued");
-    expect(coordinator.request(request("b"))).toBe("coalesced-pending");
-    expect(coordinator.request(request("a"))).toBe("coalesced-active");
-    expect(events).toEqual(["b:superseded"]);
-    coordinator.retire();
-    active.resolve();
-    await settle();
-    expect(events).toEqual(["b:superseded"]);
-    expect(coordinator.snapshot()).toEqual({ activeKey: null, pendingKey: null });
-  });
-
-  it("settles synchronous throws through the failure callback", () => {
-    const coordinator = new FirstLatestCoordinator();
-    const error = new Error("boom");
-    let observed: unknown = null;
-    coordinator.request({
-      key: "bad",
-      execute: () => {
-        throw error;
-      },
-      onSuccess: () => undefined,
-      onFailure: (failure) => (observed = failure),
-    });
-    expect(observed).toBe(error);
-    expect(coordinator.snapshot()).toEqual({ activeKey: null, pendingKey: null });
-  });
-
-  it("drains retained work when success and failure observers throw", async () => {
-    const coordinator = new FirstLatestCoordinator();
-    const first = deferred();
-    const second = deferred();
-    const third = deferred();
-    const executions: string[] = [];
-
-    coordinator.request({
-      key: "first",
-      execute: () => {
-        executions.push("first");
-        return first.promise;
-      },
-      onSuccess: () => {
-        throw new Error("success observer");
-      },
-      onFailure: () => undefined,
-    });
-    coordinator.request({
-      key: "second",
-      execute: () => {
-        executions.push("second");
-        return second.promise;
-      },
-      onSuccess: () => undefined,
-      onFailure: () => {
-        throw new Error("failure observer");
-      },
-    });
-
-    first.resolve();
-    await settle();
-    expect(executions).toEqual(["first", "second"]);
-    expect(coordinator.snapshot()).toEqual({ activeKey: "second", pendingKey: null });
-
-    coordinator.request({
-      key: "third",
-      execute: () => {
-        executions.push("third");
-        return third.promise;
-      },
-      onSuccess: () => undefined,
-      onFailure: () => undefined,
-    });
-    second.reject(new Error("execution failed"));
-    await settle();
-    expect(executions).toEqual(["first", "second", "third"]);
-    expect(coordinator.snapshot()).toEqual({ activeKey: "third", pendingKey: null });
-
-    third.resolve();
-    await settle();
-    expect(coordinator.snapshot()).toEqual({ activeKey: null, pendingKey: null });
-  });
-
-  it("retains the latest request when superseded observers throw and retires cleanly", async () => {
-    const coordinator = new FirstLatestCoordinator();
-    const active = deferred();
-    const latest = deferred();
-    const executions: string[] = [];
-    const request = (key: string, execution: Promise<void>, onSuperseded?: () => void) => ({
-      key,
-      execute: () => {
-        executions.push(key);
-        return execution;
-      },
-      onSuccess: () => undefined,
-      onFailure: () => undefined,
-      onSuperseded,
-    });
-
-    coordinator.request(request("active", active.promise));
-    coordinator.request(
-      request("intermediate", Promise.resolve(), () => {
-        throw new Error("superseded observer");
-      }),
-    );
-    expect(() => coordinator.request(request("latest", latest.promise))).not.toThrow();
-    expect(coordinator.snapshot()).toEqual({ activeKey: "active", pendingKey: "latest" });
-
-    active.resolve();
-    await settle();
-    expect(executions).toEqual(["active", "latest"]);
-    coordinator.retire();
-    latest.resolve();
-    await settle();
-    expect(coordinator.snapshot()).toEqual({ activeKey: null, pendingKey: null });
-  });
-});

package/packages/daemon-client/src/fleet-dial-scheduler.test.ts

@@ -1,114 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { createFleetDialScheduler, fleetReconnectBackoff } from "./fleet-dial-scheduler.ts";
-
-function deferred<T>() {
-  let resolve!: (value: T) => void;
-  const promise = new Promise<T>((done) => {
-    resolve = done;
-  });
-  return { promise, resolve };
-}
-const tick = () => new Promise<void>((done) => setTimeout(done, 0));
-
-describe("fleet dial scheduling", () => {
-  it("bounds 64 handshakes and prioritizes the selected queued route", async () => {
-    const scheduler = createFleetDialScheduler();
-    const gates = Array.from({ length: 64 }, () => deferred<number>());
-    const started: number[] = [];
-    const requests = gates.map((gate, index) =>
-      scheduler.run(
-        String(index),
-        new AbortController().signal,
-        () => {
-          started.push(index);
-          return gate.promise;
-        },
-        () => {},
-      ),
-    );
-    expect(started).toEqual([0, 1, 2, 3]);
-    expect(scheduler.snapshot()).toEqual({ active: 4, queued: 60, limit: 4 });
-    scheduler.prioritize("63");
-    gates[0]!.resolve(0);
-    await tick();
-    expect(started).toEqual([0, 1, 2, 3, 63]);
-    for (let i = 0; i < gates.length; i++) gates[i]!.resolve(i);
-    expect(await Promise.all(requests)).toEqual(gates.map((_, i) => i));
-    await tick();
-    expect(scheduler.snapshot()).toEqual({ active: 0, queued: 0, limit: 4 });
-  });
-
-  it("cancels queued requests without dialing and disposes late active results without oversubscription", async () => {
-    const scheduler = createFleetDialScheduler(1);
-    const first = deferred<number>();
-    const abort = new AbortController();
-    const queuedAbort = new AbortController();
-    const disposed: number[] = [];
-    let queuedStarted = false;
-    const active = scheduler.run(
-      "a",
-      abort.signal,
-      () => first.promise,
-      (value) => {
-        disposed.push(value);
-      },
-    );
-    const queued = scheduler.run(
-      "b",
-      queuedAbort.signal,
-      async () => {
-        queuedStarted = true;
-        return 2;
-      },
-      () => {},
-    );
-    const activeRejected = active.catch((error: Error) => error);
-    const queuedRejected = queued.catch((error: Error) => error);
-    abort.abort();
-    queuedAbort.abort();
-    expect(await activeRejected).toBeInstanceOf(Error);
-    expect(await queuedRejected).toBeInstanceOf(Error);
-    expect(scheduler.snapshot()).toEqual({ active: 1, queued: 0, limit: 1 });
-    expect(queuedStarted).toBe(false);
-    first.resolve(1);
-    await tick();
-    expect(disposed).toEqual([1]);
-    expect(scheduler.snapshot().active).toBe(0);
-  });
-
-  it("releases a failed slot and never dials an already-aborted request", async () => {
-    const scheduler = createFleetDialScheduler(1);
-    const abort = new AbortController();
-    abort.abort();
-    let calls = 0;
-    await expect(
-      scheduler.run(
-        "a",
-        abort.signal,
-        async () => ++calls,
-        () => {},
-      ),
-    ).rejects.toThrow("cancelled");
-    await expect(
-      scheduler.run(
-        "b",
-        new AbortController().signal,
-        () => {
-          throw new Error("dial failed");
-        },
-        () => {},
-      ),
-    ).rejects.toThrow("dial failed");
-    await tick();
-    expect(calls).toBe(0);
-    expect(scheduler.snapshot().active).toBe(0);
-  });
-
-  it("uses bounded nonzero jitter even with invalid random sources", () => {
-    expect(fleetReconnectBackoff(1, () => 0)).toBe(500);
-    expect(fleetReconnectBackoff(1, () => 1)).toBe(1000);
-    expect(fleetReconnectBackoff(100, () => 1)).toBe(30000);
-    expect(fleetReconnectBackoff(100, () => -1)).toBe(15000);
-    expect(fleetReconnectBackoff(100, () => NaN)).toBe(22500);
-  });
-});

package/packages/daemon-client/src/fleet-environments.test.ts

@@ -1,40 +0,0 @@
-import { expect, it } from "bun:test";
-import { groupFleetEnvironments } from "./fleet-environments.ts";
-
-const route = (id: string, ready = true) => ({
-  id,
-  ready,
-  environmentId: "verified-env",
-  generation: "generation-1",
-});
-
-it("joins only authenticated identities and prefers the current healthy route", () => {
-  expect(groupFleetEnvironments([route("a"), route("b")], "b")).toEqual([
-    { environmentId: "verified-env", routeIds: ["a", "b"], primaryRouteId: "b", conflict: false },
-  ]);
-  expect(
-    groupFleetEnvironments([route("a"), { ...route("b"), environmentId: null }], "b"),
-  ).toHaveLength(2);
-  expect(
-    groupFleetEnvironments([route("a"), { ...route("b"), generation: null }], "b"),
-  ).toHaveLength(2);
-});
-
-it("keeps live or cached conflicting generations separate until reverified", () => {
-  const groups = groupFleetEnvironments(
-    [route("a"), { ...route("b", false), generation: "generation-2" }],
-    "a",
-  );
-  expect(groups).toHaveLength(2);
-  expect(groups.every((group) => group.conflict)).toBe(true);
-});
-
-it("offers a healthy display route without changing the selected authority", () => {
-  const preferred = new Map([["verified-env", "a"]]);
-  const groups = groupFleetEnvironments([route("a", false), route("b")], "a", preferred);
-  expect(groups[0]!.primaryRouteId).toBe("b");
-  expect(preferred.get("verified-env")).toBe("a");
-  expect(
-    groupFleetEnvironments([route("a"), route("b")], "local", preferred)[0]!.primaryRouteId,
-  ).toBe("a");
-});

package/packages/daemon-client/src/generation-bound-store-timers.test.ts

@@ -1,74 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import {
-  createGenerationBoundStore,
-  type GenerationBoundClock,
-  type GenerationBoundEventHandlers,
-} from "./generation-bound-store.ts";
-import { runtimeResourceSnapshot } from "./runtime-resource-ledger.ts";
-
-class Clock implements GenerationBoundClock {
-  next = 0;
-  readonly timers = new Map<number, () => void>();
-  now(): number {
-    return 0;
-  }
-  setTimeout(callback: () => void): unknown {
-    const id = ++this.next;
-    this.timers.set(id, callback);
-    return id;
-  }
-  clearTimeout(handle: unknown): void {
-    this.timers.delete(handle as number);
-  }
-  runOne(): void {
-    const entry = this.timers.entries().next().value as [number, () => void] | undefined;
-    if (!entry) throw new Error("no timer");
-    this.timers.delete(entry[0]);
-    entry[1]();
-  }
-}
-
-describe("generation-bound timer ownership", () => {
-  it("retires generation-bound retry timers on disposal", async () => {
-    const baseline = runtimeResourceSnapshot()["runtime-timer"].active;
-    const clock = new Clock();
-    let connects = 0;
-    const store = createGenerationBoundStore(
-      {
-        validateTarget: (value: unknown) => ({
-          ok: true as const,
-          target: String(value),
-          key: String(value),
-        }),
-        fetch: async () => ({ status: "failed" as const, failure: "retry" }),
-        connect: (_target: string, next: GenerationBoundEventHandlers<string>) => {
-          void next;
-          connects += 1;
-          return connects === 1
-            ? { status: "failed" as const, failure: "retry" }
-            : { status: "connected" as const, close: () => undefined };
-        },
-        disposition: () => "retry" as const,
-        rejectionFailure: () => "retry",
-        transportFailure: () => "retry",
-        eventExhaustedFailure: () => "exhausted",
-        project: (view) => view.phase.kind,
-      },
-      "alpha",
-      {
-        clock,
-        retry: {
-          initialDelayMs: 10,
-          maximumDelayMs: 10,
-          maximumAttempts: 3,
-          stabilityWindowMs: 10,
-        },
-      },
-    );
-    await Promise.resolve();
-    await Promise.resolve();
-    expect(runtimeResourceSnapshot()["runtime-timer"].active).toBeGreaterThan(baseline);
-    store.dispose();
-    expect(runtimeResourceSnapshot()["runtime-timer"].active).toBe(baseline);
-  });
-});

package/packages/daemon-client/src/owner-action-client.test.ts

@@ -1,245 +0,0 @@
-import { describe, expect, it, mock } from "bun:test";
-
-import { DaemonActionInvocationError, dispatchOwnerAction } from "./owner-action-client.ts";
-
-const operationId = "10000000-0000-4000-8000-000000000001";
-const daemonInstanceId = "20000000-0000-4000-8000-000000000002";
-const mutation = {
-  operationId,
-  daemonInstanceId,
-  outcome: "applied" as const,
-  workspaceName: "project",
-};
-
-describe("owner action client", () => {
-  it("sends the owner credential and stable operation id", async () => {
-    const request = mock(async (_url: string | URL | Request, init?: RequestInit) => {
-      expect(init?.headers).toEqual({
-        "Content-Type": "application/json",
-        Authorization: "Bearer owner-token",
-        "X-Tmux-Ide-Operation-Id": operationId,
-        "X-Tmux-Ide-Host-Client-Id": "opentui:42",
-      });
-      return Response.json({
-        ok: true,
-        result: {
-          ...mutation,
-          verb: "workspace.window.split",
-          direction: "right",
-          semanticPaneId: "pane.created",
-          displayTitle: "Terminal",
-        },
-      });
-    });
-
-    await expect(
-      dispatchOwnerAction({
-        baseUrl: "http://127.0.0.1:4000",
-        ownerToken: "owner-token",
-        name: "workspace.window.split",
-        input: {
-          workspaceName: "project",
-          semanticPaneId: "pane.editor",
-          direction: "right",
-        },
-        operationId,
-        hostClientId: "opentui:42",
-        fetch: request as typeof fetch,
-      }),
-    ).resolves.toMatchObject({ outcome: "applied", verb: "workspace.window.split" });
-    expect(request).toHaveBeenCalledTimes(1);
-  });
-
-  it("retries one ambiguous response when the operation is idempotent", async () => {
-    const request = mock()
-      .mockRejectedValueOnce(new Error("connection reset"))
-      .mockResolvedValueOnce(
-        Response.json({
-          ok: true,
-          result: {
-            ...mutation,
-            verb: "workspace.pane.kill",
-            windowClosed: false,
-            remainingWindowCount: 1,
-          },
-        }),
-      );
-
-    await expect(
-      dispatchOwnerAction({
-        baseUrl: "http://127.0.0.1:4000",
-        ownerToken: "owner-token",
-        name: "workspace.pane.kill",
-        input: { workspaceName: "project", semanticPaneId: "pane.editor" },
-        operationId,
-        fetch: request as typeof fetch,
-      }),
-    ).resolves.toMatchObject({ outcome: "applied", verb: "workspace.pane.kill" });
-    expect(request).toHaveBeenCalledTimes(2);
-  });
-
-  it("keeps one operation id across a bounded delayed retry schedule", async () => {
-    const request = mock()
-      .mockRejectedValueOnce(new Error("first deadline"))
-      .mockRejectedValueOnce(new Error("second deadline"))
-      .mockResolvedValueOnce(
-        Response.json({
-          ok: true,
-          result: {
-            ...mutation,
-            verb: "workspace.pane.kill",
-            windowClosed: false,
-            remainingWindowCount: 1,
-          },
-        }),
-      );
-    const waits: number[] = [];
-
-    await expect(
-      dispatchOwnerAction({
-        baseUrl: "http://127.0.0.1:4000",
-        ownerToken: "owner-token",
-        name: "workspace.pane.kill",
-        input: { workspaceName: "project", semanticPaneId: "pane.editor" },
-        operationId,
-        fetch: request as typeof fetch,
-        maximumAttempts: 3,
-        retryDelayMs: (completedAttempts) => completedAttempts * 25,
-        wait: async (delayMs) => {
-          waits.push(delayMs);
-        },
-      }),
-    ).resolves.toMatchObject({ outcome: "applied", verb: "workspace.pane.kill" });
-
-    expect(waits).toEqual([25, 50]);
-    expect(request).toHaveBeenCalledTimes(3);
-    for (const [, init] of request.mock.calls) {
-      expect(init?.headers).toMatchObject({ "X-Tmux-Ide-Operation-Id": operationId });
-    }
-  });
-
-  it("recovers a promotion whose first response outlives the client deadline", async () => {
-    const operationIds: Array<string | undefined> = [];
-    let attempt = 0;
-    const request = mock((_url: string | URL | Request, init?: RequestInit) => {
-      operationIds.push((init?.headers as Record<string, string>)?.["X-Tmux-Ide-Operation-Id"]);
-      attempt += 1;
-      if (attempt === 1)
-        return new Promise<Response>((_resolve, reject) => {
-          init?.signal?.addEventListener("abort", () => reject(init.signal?.reason), {
-            once: true,
-          });
-        });
-      return Promise.resolve(
-        Response.json({
-          ok: true,
-          result: {
-            operationId,
-            daemonInstanceId,
-            outcome: "replayed",
-            resource: { resourceVersion: 1, workspaceName: "workspace.alpha" },
-          },
-        }),
-      );
-    });
-
-    await expect(
-      dispatchOwnerAction({
-        baseUrl: "http://127.0.0.1:4000",
-        ownerToken: "owner-token",
-        name: "workspace.promote",
-        input: { sessionId: "session.aaaaaaaaaaaaaaaaaaaa" },
-        operationId,
-        fetch: request as typeof fetch,
-        timeoutMs: 5,
-        maximumAttempts: 2,
-        retryDelayMs: () => 1,
-      }),
-    ).resolves.toMatchObject({ operationId, outcome: "replayed" });
-    expect(operationIds).toEqual([operationId, operationId]);
-  });
-
-  it("surfaces typed daemon refusals", async () => {
-    const request = mock(async () =>
-      Response.json({
-        ok: false,
-        error: { code: "bad_request", message: "Cannot close the last pane" },
-      }),
-    );
-
-    const result = dispatchOwnerAction({
-      baseUrl: "http://127.0.0.1:4000",
-      ownerToken: "owner-token",
-      name: "workspace.pane.kill",
-      input: { workspaceName: "project", semanticPaneId: "pane.editor" },
-      fetch: request as typeof fetch,
-    });
-    await expect(result).rejects.toBeInstanceOf(DaemonActionInvocationError);
-    await expect(result).rejects.toThrow("Cannot close the last pane");
-  });
-});
-
-describe("owner transport ambiguous responses", () => {
-  const options = {
-    baseUrl: "http://localhost:4000/",
-    ownerToken: "token",
-    name: "workspace.pane.kill" as const,
-    input: { workspaceName: "project", semanticPaneId: "pane.editor" },
-  };
-  it("does not retry a refusal even with an operation ID", async () => {
-    const request = mock(async () =>
-      Response.json({ ok: false, error: { code: "refused", message: "Denied" } }),
-    );
-    await expect(
-      dispatchOwnerAction({ ...options, operationId, fetch: request as typeof fetch }),
-    ).rejects.toMatchObject({ code: "refused" });
-    expect(request).toHaveBeenCalledTimes(1);
-  });
-  it.each(["invalid json", "invalid result"])(
-    "retries %s with identical operation and body",
-    async (kind) => {
-      const request = mock()
-        .mockResolvedValueOnce(
-          kind === "invalid json" ? new Response("{") : Response.json({ ok: true, result: {} }),
-        )
-        .mockResolvedValueOnce(
-          Response.json({
-            ok: true,
-            result: {
-              ...mutation,
-              verb: "workspace.pane.kill",
-              windowClosed: false,
-              remainingWindowCount: 1,
-            },
-          }),
-        );
-      await expect(
-        dispatchOwnerAction({ ...options, operationId, fetch: request as typeof fetch }),
-      ).resolves.toMatchObject({ outcome: "applied" });
-      expect(request).toHaveBeenCalledTimes(2);
-      expect(request.mock.calls[0]![1].body).toBe(request.mock.calls[1]![1].body);
-      expect(request.mock.calls[0]![1].headers).toEqual(request.mock.calls[1]![1].headers);
-    },
-  );
-  it("does not retry ambiguity without an operation ID", async () => {
-    const request = mock(async () => new Response("{"));
-    await expect(
-      dispatchOwnerAction({ ...options, maximumAttempts: 3, fetch: request as typeof fetch }),
-    ).resolves.toBeNull();
-    expect(request).toHaveBeenCalledTimes(1);
-  });
-  it.each(["http://localhost:4000", "http://localhost:4000/", "http://localhost:4000/prefix/"])(
-    "normalizes endpoint slash for %s",
-    async (baseUrl) => {
-      const request = mock(async () =>
-        Response.json({ ok: false, error: { code: "refused", message: "Denied" } }),
-      );
-      await expect(
-        dispatchOwnerAction({ ...options, baseUrl, fetch: request as typeof fetch }),
-      ).rejects.toThrow("Denied");
-      expect(request.mock.calls[0]![0]).toBe(
-        baseUrl.replace(/\/$/u, "") + "/api/v2/action/workspace.pane.kill",
-      );
-    },
-  );
-});