tmux-ide 2.9.2 → 2.9.4

package/packages/contracts/src/__tests__/tmux-server-scope.test.ts

@@ -1,166 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  TmuxServerScopeSchemaZ,
-  tmuxServerPaneStreamPath,
-  isTmuxServerPaneStreamPath,
-  TmuxServerDescriptorSchemaZ,
-  TmuxServersResourceSchemaZ,
-  TmuxServerPaneTargetSchemaZ,
-  resolveTmuxServerScope,
-  tmuxServerScopedResourceKey,
-  type TmuxServerScope,
-  type TmuxServerDescriptor,
-} from "../tmux-server-scope.ts";
-
-import { PaneStreamLoopbackWebSocketUrlSchemaZ, PANE_STREAM_REDEEM_PATH } from "../pane-stream.ts";
-
-const a: TmuxServerScope = {
-  serverId: `tmux-server.${"a".repeat(32)}`,
-  generation: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
-};
-const b: TmuxServerScope = { ...a, serverId: `tmux-server.${"b".repeat(32)}` };
-const replacement: TmuxServerScope = { ...a, generation: "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb" };
-const online = (scope: TmuxServerScope): TmuxServerDescriptor => ({
-  ...scope,
-  label: "default",
-  state: "online",
-});
-const offline = (scope: TmuxServerScope): TmuxServerDescriptor => ({
-  serverId: scope.serverId,
-  label: "default",
-  state: "offline",
-  generation: null,
-});
-
-describe("server-scoped identities", () => {
-  it("keeps registration identity separate from each live incarnation", () => {
-    expect(TmuxServerScopeSchemaZ.parse(a)).toEqual(a);
-    expect(TmuxServerScopeSchemaZ.parse(replacement).serverId).toBe(a.serverId);
-    for (const serverId of ["/tmp/tmux/socket", "default", "%0", "tmux-server.short"]) {
-      expect(TmuxServerScopeSchemaZ.safeParse({ ...a, serverId }).success).toBe(false);
-    }
-    expect(TmuxServerScopeSchemaZ.safeParse({ ...a, socketPath: "/tmp/socket" }).success).toBe(
-      false,
-    );
-    expect(TmuxServerScopeSchemaZ.safeParse({ ...a, generation: "1234" }).success).toBe(false);
-  });
-
-  it("publishes no live generation for offline registrations", () => {
-    expect(TmuxServerDescriptorSchemaZ.parse(online(a))).toEqual(online(a));
-    expect(TmuxServerDescriptorSchemaZ.parse(offline(a))).toEqual(offline(a));
-    expect(TmuxServerDescriptorSchemaZ.safeParse({ ...online(a), generation: null }).success).toBe(
-      false,
-    );
-    expect(
-      TmuxServerDescriptorSchemaZ.safeParse({ ...offline(a), generation: a.generation }).success,
-    ).toBe(false);
-  });
-
-  it("versions the new resource explicitly and refuses duplicate registrations", () => {
-    expect(
-      TmuxServersResourceSchemaZ.safeParse({ version: 1, servers: [online(a), online(b)] }).success,
-    ).toBe(true);
-    expect(TmuxServersResourceSchemaZ.safeParse({ version: 2, servers: [] }).success).toBe(false);
-    expect(
-      TmuxServersResourceSchemaZ.safeParse({ version: 1, servers: [online(a), offline(a)] })
-        .success,
-    ).toBe(false);
-  });
-
-  it("requires complete server scope for copied pane stamps", () => {
-    const target = {
-      server: a,
-      liveSessionId: `live-session.${"a".repeat(20)}`,
-      semanticPaneId: "pane.copied",
-    };
-    expect(TmuxServerPaneTargetSchemaZ.safeParse(target).success).toBe(true);
-    expect(TmuxServerPaneTargetSchemaZ.safeParse({ ...target, server: undefined }).success).toBe(
-      false,
-    );
-    expect(TmuxServerPaneTargetSchemaZ.safeParse({ ...target, runtimePaneId: "%0" }).success).toBe(
-      false,
-    );
-  });
-
-  it("keys copied stamps, native IDs and generations without delimiter collisions", () => {
-    const keys = [
-      tmuxServerScopedResourceKey(a, "pane", "copied"),
-      tmuxServerScopedResourceKey(b, "pane", "copied"),
-      tmuxServerScopedResourceKey(replacement, "pane", "copied"),
-      tmuxServerScopedResourceKey(a, "window", "copied"),
-      tmuxServerScopedResourceKey(a, "pane:copied", ""),
-      tmuxServerScopedResourceKey(a, "pane", ":copied"),
-    ];
-    expect(new Set(keys).size).toBe(keys.length);
-    expect(tmuxServerScopedResourceKey(a, "pane", "%0")).not.toBe(
-      tmuxServerScopedResourceKey(b, "pane", "%0"),
-    );
-  });
-});
-
-describe("server selection authority", () => {
-  it("routes exact scope despite identical display labels", () => {
-    expect(resolveTmuxServerScope([online(a), online(b)], b)).toEqual({
-      status: "matched",
-      scope: b,
-    });
-  });
-
-  it("rejects old generations without falling back to another live server", () => {
-    expect(resolveTmuxServerScope([online(replacement), online(b)], a)).toEqual({
-      status: "stale-generation",
-    });
-    expect(resolveTmuxServerScope([online(b)], a)).toEqual({ status: "not-found" });
-    expect(resolveTmuxServerScope([offline(a), online(b)], a)).toEqual({ status: "offline" });
-  });
-
-  it("allows legacy selection only with one registered live owner", () => {
-    expect(resolveTmuxServerScope([online(a)])).toEqual({ status: "matched", scope: a });
-    expect(resolveTmuxServerScope([])).toEqual({ status: "not-found" });
-    expect(resolveTmuxServerScope([offline(a)])).toEqual({ status: "offline" });
-    expect(resolveTmuxServerScope([online(a), online(b)])).toEqual({ status: "ambiguous" });
-    expect(resolveTmuxServerScope([offline(a), online(b)])).toEqual({ status: "ambiguous" });
-  });
-
-  it("fails closed if malformed registry repeats an identity", () => {
-    expect(resolveTmuxServerScope([online(a), online(a)], a)).toEqual({ status: "ambiguous" });
-  });
-});
-
-describe("server-scoped pane stream addresses", () => {
-  it("separates owners and generations and accepts canonical loopback URLs", () => {
-    const paths = [a, b, replacement].map(tmuxServerPaneStreamPath);
-    expect(new Set(paths).size).toBe(3);
-    for (const path of [...paths, PANE_STREAM_REDEEM_PATH]) {
-      expect(
-        PaneStreamLoopbackWebSocketUrlSchemaZ.safeParse(`ws://127.0.0.1:1234${path}`).success,
-      ).toBe(true);
-    }
-  });
-
-  it("refuses unscoped, malformed, encoded and credentialed paths", () => {
-    const path = tmuxServerPaneStreamPath(a);
-    for (const badPath of [
-      path + "/",
-      path + "/other",
-      path.replace(a.serverId, "default"),
-      path.replace(a.generation, "old"),
-      path.replace("tmux-server.", "tmux-server%2e"),
-      "/v2/tmux-servers/pane-streams/redeem",
-    ]) {
-      expect(isTmuxServerPaneStreamPath(badPath)).toBe(false);
-      expect(
-        PaneStreamLoopbackWebSocketUrlSchemaZ.safeParse(`ws://127.0.0.1:1234${badPath}`).success,
-      ).toBe(false);
-    }
-    for (const url of [
-      `ws://127.0.0.1:1234${path}?generation=${b.generation}`,
-      `ws://127.0.0.1:1234${path}#fragment`,
-      `ws://user@127.0.0.1:1234${path}`,
-      `ws://example.com:1234${path}`,
-      `wss://127.0.0.1:1234${path}`,
-      `ws://127.0.0.1${path}`,
-    ])
-      expect(PaneStreamLoopbackWebSocketUrlSchemaZ.safeParse(url).success).toBe(false);
-  });
-});

package/packages/contracts/src/__tests__/transport-contract-loading.test.ts

@@ -1,91 +0,0 @@
-import { readFileSync } from "node:fs";
-import { resolve, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import ts from "typescript";
-import { describe, expect, it } from "vitest";
-import {
-  DesktopDaemonCapabilityErrorSchemaZ,
-  DesktopDaemonCapabilityErrorCodeSchemaZ,
-} from "../desktop-daemon-capability-error.ts";
-import { DesktopDaemonCapabilityErrorSchemaZ as legacySchema } from "../desktop-host.ts";
-import { DesktopDaemonCapabilityErrorSchemaZ as publicSchema } from "../index.ts";
-
-/** Follow runtime imports, including re-exports, rather than erased type edges. */
-function runtimeModules(entry: string, visited = new Set<string>()): Set<string> {
-  if (visited.has(entry)) return visited;
-  visited.add(entry);
-  const source = ts.createSourceFile(entry, readFileSync(entry, "utf8"), ts.ScriptTarget.Latest);
-  for (const statement of source.statements) {
-    if (!ts.isImportDeclaration(statement) && !ts.isExportDeclaration(statement)) continue;
-    const specifier = statement.moduleSpecifier;
-    if (!specifier || !ts.isStringLiteral(specifier) || !specifier.text.startsWith(".")) continue;
-    if (ts.isImportDeclaration(statement)) {
-      if (statement.importClause?.isTypeOnly) continue;
-      const bindings = statement.importClause?.namedBindings;
-      if (
-        !statement.importClause?.name &&
-        bindings &&
-        ts.isNamedImports(bindings) &&
-        bindings.elements.every((element) => element.isTypeOnly)
-      )
-        continue;
-    } else {
-      if (statement.isTypeOnly) continue;
-      if (
-        statement.exportClause &&
-        ts.isNamedExports(statement.exportClause) &&
-        statement.exportClause.elements.every((element) => element.isTypeOnly)
-      )
-        continue;
-    }
-    runtimeModules(resolve(dirname(entry), specifier.text), visited);
-  }
-  return visited;
-}
-
-describe("transport contract loading", () => {
-  it("preserves the exact public error schema and strict validation", () => {
-    expect(publicSchema).toBe(DesktopDaemonCapabilityErrorSchemaZ);
-    expect(legacySchema).toBe(DesktopDaemonCapabilityErrorSchemaZ);
-    for (const code of DesktopDaemonCapabilityErrorCodeSchemaZ.options) {
-      expect(publicSchema.parse({ code, reason: "unavailable" })).toEqual({
-        code,
-        reason: "unavailable",
-      });
-    }
-    for (const invalid of [
-      { code: "unknown-error", reason: "unavailable" },
-      { code: "disposed", reason: "" },
-      { code: "disposed", reason: "x".repeat(241) },
-      { code: "disposed", reason: "closed", extra: true },
-    ])
-      expect(publicSchema.safeParse(invalid).success).toBe(false);
-  });
-
-  it("keeps mutation and error contracts independent of optional desktop resources", () => {
-    for (const name of [
-      "desktop-daemon-capability-error",
-      "workspace-multiplexer",
-      "workspace-pane-creation",
-      "workspace-open",
-      "workspace-open-handoff",
-      "workspace-promotion",
-      "app-window-mutation",
-      "widget-asset",
-    ]) {
-      const entry = fileURLToPath(new URL(`../${name}.ts`, import.meta.url));
-      const modules = [...runtimeModules(entry)];
-      for (const forbidden of [
-        "desktop-host.ts",
-        "workspace-files-resource.ts",
-        "workspace-changes-resource.ts",
-        "workspace-missions-resource.ts",
-        "cohesion-fixture.ts",
-      ])
-        expect(
-          modules.some((path) => path.endsWith(`/${forbidden}`)),
-          `${name} loaded ${forbidden}`,
-        ).toBe(false);
-    }
-  });
-});

package/packages/contracts/src/__tests__/visual-tokens.test.ts

@@ -1,224 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  BUILTIN_VISUAL_THEMES,
-  VisualHostDefaultsV1SchemaZ,
-  VisualThemeDocumentV1SchemaZ,
-  VisualTokensV1SchemaZ,
-  contrastRatio,
-  deriveAttentionBlend,
-  deriveFocusedHeader,
-  loadVisualThemeDocument,
-  readableForeground,
-  resolveVisualTheme,
-  type RendererNeutralColor,
-} from "../visual-tokens.ts";
-
-const rgb = (red: number, green: number, blue: number): RendererNeutralColor => ({
-  space: "srgb",
-  red,
-  green,
-  blue,
-  alpha: 255,
-});
-
-describe("visual token contracts", () => {
-  it("round-trips both complete built-in themes", () => {
-    for (const tokens of Object.values(BUILTIN_VISUAL_THEMES)) {
-      expect(VisualTokensV1SchemaZ.parse(JSON.parse(JSON.stringify(tokens)))).toEqual(tokens);
-    }
-  });
-
-  it("keeps built-in light surfaces nearer extended xterm gray than mutable ANSI white", () => {
-    const light = BUILTIN_VISUAL_THEMES.light.surfaces;
-    const pureWhite = rgb(255, 255, 255);
-    const extendedWhite = rgb(238, 238, 238);
-    const distance = (left: RendererNeutralColor, right: RendererNeutralColor) =>
-      Math.hypot(left.red - right.red, left.green - right.green, left.blue - right.blue);
-
-    for (const surface of [light.panel, light.panelRaised, light.terminal, light.command]) {
-      expect(surface).not.toEqual(pureWhite);
-      expect(distance(surface, extendedWhite)).toBeLessThan(distance(surface, pureWhite));
-    }
-  });
-
-  it("migrates version zero without mutating caller data", () => {
-    const source = {
-      version: 0,
-      id: "legacy",
-      name: "Legacy",
-      appearance: "light",
-      tokens: { text: { primary: rgb(1, 2, 3) } },
-    };
-    const before = JSON.stringify(source);
-    const loaded = loadVisualThemeDocument(source, "user");
-
-    expect(JSON.stringify(source)).toBe(before);
-    expect(loaded.status).toBe("ready");
-    if (loaded.status !== "ready") throw new Error("expected ready theme");
-    expect(loaded.sourceVersion).toBe(0);
-    expect(loaded.migrated).toBe(true);
-    expect(loaded.document).toEqual({
-      version: 1,
-      id: "legacy",
-      name: "Legacy",
-      appearance: "light",
-      overrides: { text: { primary: rgb(1, 2, 3) } },
-    });
-    expect(loaded.diagnostics.map(({ code }) => code)).toContain("migrated");
-  });
-
-  it("keeps valid siblings while defaulting invalid and unknown tokens", () => {
-    const loaded = loadVisualThemeDocument(
-      {
-        version: 1,
-        id: "mixed",
-        name: "Mixed",
-        overrides: {
-          text: { primary: rgb(9, 8, 7), secondary: "not-a-color", invented: rgb(1, 1, 1) },
-          inventedGroup: { value: 1 },
-        },
-      },
-      "project",
-    );
-    expect(loaded.status).toBe("ready");
-    if (loaded.status !== "ready") throw new Error("expected ready theme");
-    expect(loaded.document.overrides).toEqual({ text: { primary: rgb(9, 8, 7) } });
-    expect(loaded.diagnostics).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({ code: "invalid-token", path: "text.secondary" }),
-        expect.objectContaining({ code: "unknown-token", path: "text.invented" }),
-        expect.objectContaining({ code: "unknown-token", path: "inventedGroup" }),
-      ]),
-    );
-  });
-
-  it("protects future versions from accidental rewriting", () => {
-    const future = { version: 72, id: "future", name: "Future", overrides: {} };
-    const loaded = loadVisualThemeDocument(future, "project");
-    expect(loaded).toEqual(
-      expect.objectContaining({
-        status: "future-version",
-        sourceVersion: 72,
-        writable: false,
-        document: null,
-      }),
-    );
-
-    const resolved = resolveVisualTheme({
-      appearance: "dark",
-      projectTheme: future,
-    });
-    expect(resolved.futureSources).toEqual(["project"]);
-    expect(resolved.tokens).toEqual(BUILTIN_VISUAL_THEMES.dark);
-  });
-
-  it("layers defaults, user, project, then accessibility", () => {
-    const userPrimary = rgb(1, 2, 3);
-    const projectPrimary = rgb(4, 5, 6);
-    const user = VisualThemeDocumentV1SchemaZ.parse({
-      version: 1,
-      id: "user",
-      name: "User",
-      appearance: "light",
-      overrides: {
-        text: { primary: userPrimary },
-        motion: { fast: { unit: "ms", value: 999 } },
-      },
-    });
-    const project = VisualThemeDocumentV1SchemaZ.parse({
-      version: 1,
-      id: "project",
-      name: "Project",
-      overrides: { text: { primary: projectPrimary } },
-    });
-    const resolved = resolveVisualTheme({
-      appearance: "dark",
-      userTheme: user,
-      projectTheme: project,
-      accessibility: { reducedMotion: true, increasedContrast: true },
-    });
-
-    expect(resolved.appearance).toBe("light");
-    expect(resolved.tokens.text.primary).toEqual(projectPrimary);
-    expect(resolved.tokens.motion.fast).toEqual({ unit: "ms", value: 0 });
-    expect(resolved.tokens.motion.easing).toEqual({ standard: "linear", emphasized: "linear" });
-    expect(resolved.tokens.focus.focusContrast).toEqual({ unit: "ratio", value: 7 });
-    expect(resolved.tokens.borders.focused).toEqual(resolved.tokens.focus.highContrastOutline);
-    expect(resolved.tokens.windowActivity.inactive).toEqual({
-      opacity: { unit: "ratio", value: 1 },
-      contrast: { unit: "ratio", value: 1 },
-    });
-  });
-
-  it("layers renderer-neutral host defaults below user and project themes", () => {
-    const hostPrimary = rgb(11, 22, 33);
-    const userPrimary = rgb(44, 55, 66);
-    const projectPanel = rgb(77, 88, 99);
-    const hostDefaults = VisualHostDefaultsV1SchemaZ.parse({
-      appearance: "light",
-      overrides: {
-        surfaces: { canvas: rgb(240, 241, 242), panel: rgb(230, 231, 232) },
-        text: { primary: hostPrimary },
-      },
-    });
-    const resolved = resolveVisualTheme({
-      appearance: "light",
-      hostDefaults,
-      userTheme: {
-        version: 1,
-        id: "host-precedence-user",
-        name: "Host precedence user",
-        overrides: { text: { primary: userPrimary } },
-      },
-      projectTheme: {
-        version: 1,
-        id: "host-precedence-project",
-        name: "Host precedence project",
-        overrides: { surfaces: { panel: projectPanel } },
-      },
-      accessibility: { increasedContrast: true },
-    });
-
-    expect(resolved.appearance).toBe("light");
-    expect(resolved.tokens.surfaces.canvas).toEqual(rgb(240, 241, 242));
-    expect(resolved.tokens.surfaces.panel).toEqual(projectPanel);
-    expect(resolved.tokens.text.primary).toEqual(userPrimary);
-    expect(resolved.tokens.borders.focused).toEqual(resolved.tokens.focus.highContrastOutline);
-  });
-
-  it("does not apply host defaults across an explicit appearance boundary", () => {
-    const resolved = resolveVisualTheme({
-      appearance: "dark",
-      hostDefaults: VisualHostDefaultsV1SchemaZ.parse({
-        appearance: "light",
-        overrides: { surfaces: { canvas: rgb(250, 250, 250) } },
-      }),
-    });
-    expect(resolved.appearance).toBe("dark");
-    expect(resolved.tokens).toEqual(BUILTIN_VISUAL_THEMES.dark);
-  });
-
-  it("derives deterministic renderer-neutral colors and readable foregrounds", () => {
-    const black = rgb(0, 0, 0);
-    const white = rgb(255, 255, 255);
-    const focus = rgb(100, 200, 250);
-    expect(contrastRatio(black, white)).toBeCloseTo(21);
-    expect(readableForeground(black, black, white)).toEqual(white);
-    expect(deriveFocusedHeader(black, focus)).toEqual(deriveFocusedHeader(black, focus));
-    expect(deriveAttentionBlend(white, focus)).toEqual(deriveAttentionBlend(white, focus));
-  });
-
-  it("serializes only renderer-neutral units", () => {
-    const units = new Set<string>();
-    const walk = (value: unknown): void => {
-      if (Array.isArray(value)) return value.forEach(walk);
-      if (!value || typeof value !== "object") return;
-      for (const [key, child] of Object.entries(value)) {
-        if (key === "unit" && typeof child === "string") units.add(child);
-        walk(child);
-      }
-    };
-    walk(BUILTIN_VISUAL_THEMES);
-    expect([...units].sort()).toEqual(["ms", "ratio", "rhythm"]);
-  });
-});