harness-mix 0.1.0

package/src/native-ui/shared-contracts/test/harness-models.test.ts

@@ -0,0 +1,390 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  HARNESS_MODEL_REF_MAX_LENGTH,
+  HARNESS_THINKING_OPTION_ID_MAX_LENGTH,
+  THREAD_OWNERSHIP_LIST_MAX_LENGTH,
+  harnessInspectParamsSchema,
+  harnessInspectionSchema,
+  harnessModelCatalogSchema,
+  harnessModelRefSchema,
+  harnessModelSelectionStateSchema,
+  harnessThinkingOptionIdSchema,
+  harnessWebUiOpenParamsSchema,
+  harnessWebUiOpenResultSchema,
+  threadInspectionParamsSchema,
+  threadInspectionSchema,
+  threadModelSelectParamsSchema,
+  threadThinkingSelectParamsSchema,
+  threadOwnershipListParamsSchema,
+  threadOwnershipListResultSchema,
+} from "@codexhost/shared-contracts";
+
+const firstRef = { id: "pi-model-v1.cHJvdmlkZXI6bW9kZWw" };
+const secondRef = { id: "pi-model-v1.b3RoZXI6bW9kZWw" };
+
+function readyInspection() {
+  return {
+    status: "ready",
+    catalog: {
+      models: [
+        {
+          ref: firstRef,
+          label: "provider / model",
+          resolvedModelLabel: "runtime/model-v1",
+          supportedThinkingOptionIds: ["off", "high"],
+        },
+        { ref: secondRef, label: "other / model" },
+      ],
+      defaultModel: firstRef,
+      thinkingOptions: [
+        { id: "off", label: "Off" },
+        { id: "high", label: "High" },
+      ],
+      defaultThinkingOptionId: "high",
+    },
+    capabilities: {
+      configuration: {
+        selectModel: true,
+        selectThinkingOption: true,
+        selectPermissionMode: false,
+        permissionModeScope: "live",
+      },
+      history: { fork: true, forkAcrossCwd: true, rollbackLastTurn: true },
+    },
+  };
+}
+
+describe("Harness Model runtime contracts", () => {
+  it("exposes only a credential-free Harness Web UI action", () => {
+    expect(
+      harnessInspectionSchema.parse({
+        ...readyInspection(),
+        webUi: { open: true },
+      }),
+    ).toMatchObject({ webUi: { open: true } });
+    expect(harnessWebUiOpenParamsSchema.parse({ harnessId: "deepseek-harness" })).toEqual({
+      harnessId: "deepseek-harness",
+    });
+    expect(harnessWebUiOpenResultSchema.parse({})).toEqual({});
+    expect(
+      harnessWebUiOpenResultSchema.safeParse({ url: "http://127.0.0.1/?token=secret" }).success,
+    ).toBe(false);
+  });
+
+  it("accepts a strict browser-safe ready inspection", () => {
+    expect(harnessInspectionSchema.parse(readyInspection())).toEqual(readyInspection());
+    expect(
+      harnessModelSelectionStateSchema.parse({
+        effectiveModel: firstRef,
+        resolvedModelLabel: "runtime/model-v1",
+        effectiveThinkingOptionId: "high",
+        availableThinkingOptions: [
+          { id: "off", label: "Off" },
+          { id: "high", label: "High" },
+        ],
+      }),
+    ).toMatchObject({
+      effectiveModel: firstRef,
+      resolvedModelLabel: "runtime/model-v1",
+      effectiveThinkingOptionId: "high",
+    });
+    expect(JSON.parse(JSON.stringify(harnessInspectionSchema.parse(readyInspection())))).toEqual(
+      readyInspection(),
+    );
+  });
+
+  it("rejects native configuration and unknown fields", () => {
+    expect(
+      harnessInspectionSchema.safeParse({
+        ...readyInspection(),
+        capabilities: {
+          configuration: {
+            selectModel: true,
+            selectThinkingOption: true,
+            selectPermissionMode: false,
+          },
+          history: { fork: true },
+        },
+      }).success,
+    ).toBe(false);
+    expect(
+      harnessInspectionSchema.safeParse({
+        ...readyInspection(),
+        capabilities: {
+          configuration: {
+            selectModel: true,
+            selectThinkingOption: true,
+            selectPermissionMode: false,
+          },
+          history: { fork: false, forkAcrossCwd: true, rollbackLastTurn: false },
+        },
+      }).success,
+    ).toBe(false);
+    expect(
+      harnessInspectionSchema.safeParse({
+        ...readyInspection(),
+        catalog: {
+          ...readyInspection().catalog,
+          models: [
+            {
+              ref: firstRef,
+              label: "provider / model",
+              provider: { baseUrl: "https://private.invalid", apiKey: "secret" },
+            },
+          ],
+        },
+      }).success,
+    ).toBe(false);
+    expect(
+      harnessModelSelectionStateSchema.safeParse({
+        effectiveModel: firstRef,
+        nativeState: { modelId: "private" },
+      }).success,
+    ).toBe(false);
+    expect(
+      threadModelSelectParamsSchema.safeParse({
+        threadId: "thread-1",
+        model: firstRef,
+        resolvedModelLabel: "runtime/model-v1",
+      }).success,
+    ).toBe(false);
+    for (const resolvedModelLabel of ["", "   ", "x".repeat(257)]) {
+      expect(
+        harnessModelSelectionStateSchema.safeParse({
+          effectiveModel: firstRef,
+          resolvedModelLabel,
+        }).success,
+      ).toBe(false);
+    }
+  });
+
+  it("requires bounded transport-safe opaque Model refs", () => {
+    for (const id of [
+      "",
+      "   ",
+      "provider/model",
+      "provider:model",
+      "provider model",
+      "x".repeat(HARNESS_MODEL_REF_MAX_LENGTH + 1),
+    ]) {
+      expect(harnessModelRefSchema.safeParse({ id }).success).toBe(false);
+    }
+    expect(harnessModelRefSchema.parse(firstRef)).toEqual(firstRef);
+    for (const id of [
+      "",
+      "thinking option",
+      "thinking/option",
+      "x".repeat(HARNESS_THINKING_OPTION_ID_MAX_LENGTH + 1),
+    ]) {
+      expect(harnessThinkingOptionIdSchema.safeParse(id).success).toBe(false);
+    }
+    expect(harnessThinkingOptionIdSchema.parse("xhigh")).toBe("xhigh");
+  });
+
+  it("rejects duplicate refs and a default outside the catalog", () => {
+    expect(
+      harnessModelCatalogSchema.safeParse({
+        models: [
+          { ref: firstRef, label: "first" },
+          { ref: firstRef, label: "duplicate" },
+        ],
+        defaultModel: firstRef,
+        thinkingOptions: [],
+      }).success,
+    ).toBe(false);
+    expect(
+      harnessModelCatalogSchema.safeParse({
+        models: [{ ref: firstRef, label: "first" }],
+        defaultModel: secondRef,
+        thinkingOptions: [],
+      }).success,
+    ).toBe(false);
+    expect(
+      harnessModelCatalogSchema.safeParse({
+        models: [
+          {
+            ref: firstRef,
+            label: "first",
+            supportedThinkingOptionIds: ["missing"],
+          },
+        ],
+        defaultModel: firstRef,
+        thinkingOptions: [{ id: "off", label: "Off" }],
+        defaultThinkingOptionId: "missing",
+      }).success,
+    ).toBe(false);
+    expect(
+      harnessModelCatalogSchema.safeParse({
+        models: [
+          {
+            ref: firstRef,
+            label: "first",
+            supportedThinkingOptionIds: ["off", "off"],
+          },
+        ],
+        thinkingOptions: [{ id: "off", label: "Off" }],
+      }).success,
+    ).toBe(false);
+    expect(
+      harnessModelSelectionStateSchema.safeParse({
+        effectiveThinkingOptionId: "high",
+        availableThinkingOptions: [{ id: "off", label: "Off" }],
+      }).success,
+    ).toBe(false);
+  });
+
+  it("keeps inspection and Thread selection params method-specific", () => {
+    expect(
+      harnessInspectParamsSchema.parse({
+        harnessId: "pi",
+        cwd: "/synthetic",
+        refresh: true,
+      }),
+    ).toEqual({ harnessId: "pi", cwd: "/synthetic", refresh: true });
+    expect(harnessInspectParamsSchema.parse({ harnessId: "claude-code" })).toEqual({
+      harnessId: "claude-code",
+    });
+    expect(threadModelSelectParamsSchema.parse({ threadId: "thread-1", model: firstRef })).toEqual({
+      threadId: "thread-1",
+      model: firstRef,
+    });
+    expect(
+      threadThinkingSelectParamsSchema.parse({
+        threadId: "thread-1",
+        thinkingOptionId: "high",
+      }),
+    ).toEqual({ threadId: "thread-1", thinkingOptionId: "high" });
+
+    expect(
+      harnessInspectParamsSchema.safeParse({
+        harnessId: "pi",
+        model: firstRef,
+      }).success,
+    ).toBe(false);
+    expect(
+      harnessInspectParamsSchema.safeParse({
+        harnessId: "pi",
+        method: "get_available_models",
+      }).success,
+    ).toBe(false);
+    expect(
+      threadModelSelectParamsSchema.safeParse({
+        threadId: "thread-1",
+        model: firstRef,
+        provider: "private-provider",
+      }).success,
+    ).toBe(false);
+  });
+
+  it("validates fixed Thread ownership inspection without Native details", () => {
+    expect(threadInspectionParamsSchema.parse({ threadId: "thread-1" })).toEqual({
+      threadId: "thread-1",
+    });
+    expect(
+      threadInspectionSchema.parse({
+        owner: "external",
+        harnessId: "pi",
+        transportModelId: "codexhost/pi-native",
+        effectiveModel: firstRef,
+        resolvedModelLabel: "runtime/model-v1",
+        effectiveThinkingOptionId: "high",
+        availableThinkingOptions: [
+          { id: "off", label: "Off" },
+          { id: "high", label: "High" },
+        ],
+        history: { fork: true, forkAcrossCwd: true, rollbackLastTurn: false },
+        locked: true,
+      }),
+    ).toMatchObject({ owner: "external", harnessId: "pi", locked: true });
+    expect(threadInspectionSchema.parse({ owner: "codex", locked: true })).toEqual({
+      owner: "codex",
+      locked: true,
+    });
+    expect(
+      threadInspectionSchema.safeParse({
+        owner: "external",
+        harnessId: "pi",
+        transportModelId: "codexhost/pi-native",
+        history: { fork: true, forkAcrossCwd: true, rollbackLastTurn: false },
+        locked: true,
+        nativeSessionRef: { nativeSessionId: "secret" },
+      }).success,
+    ).toBe(false);
+  });
+
+  it("validates strict bounded Thread ownership lists", () => {
+    const params = { threadIds: ["official-thread", "pi-thread", "claude-thread"] };
+    const result = {
+      threads: [
+        { threadId: "official-thread", owner: "codex" as const },
+        { threadId: "pi-thread", owner: "external" as const, harnessId: "pi" },
+        {
+          threadId: "claude-thread",
+          owner: "external" as const,
+          harnessId: "claude-code",
+        },
+      ],
+    };
+
+    expect(threadOwnershipListParamsSchema.parse(params)).toEqual(params);
+    expect(threadOwnershipListResultSchema.parse(result)).toEqual(result);
+    for (const invalid of [
+      { threadIds: [] },
+      { threadIds: ["thread-1", "thread-1"] },
+      {
+        threadIds: Array.from(
+          { length: THREAD_OWNERSHIP_LIST_MAX_LENGTH + 1 },
+          (_, index) => `thread-${index}`,
+        ),
+      },
+      { threadIds: ["thread-1"], nativeMethod: "get_entries" },
+    ]) {
+      expect(threadOwnershipListParamsSchema.safeParse(invalid).success).toBe(false);
+    }
+    expect(
+      threadOwnershipListResultSchema.safeParse({
+        threads: [
+          {
+            threadId: "pi-thread",
+            owner: "external",
+            harnessId: "pi",
+            nativeSessionRef: { nativeSessionId: "private" },
+          },
+        ],
+      }).success,
+    ).toBe(false);
+    expect(
+      threadOwnershipListResultSchema.safeParse({
+        threads: [
+          { threadId: "thread-1", owner: "codex" },
+          { threadId: "thread-1", owner: "codex" },
+        ],
+      }).success,
+    ).toBe(false);
+  });
+
+  it("validates normalized inspection failures without arbitrary diagnostics", () => {
+    expect(
+      harnessInspectionSchema.parse({
+        status: "notInstalled",
+        error: {
+          code: "notInstalled",
+          message: "Pi is not installed",
+          retryable: false,
+        },
+      }),
+    ).toMatchObject({ status: "notInstalled", error: { code: "notInstalled" } });
+    expect(
+      harnessInspectionSchema.safeParse({
+        status: "error",
+        error: {
+          code: "nativeFailure",
+          message: "Private failure",
+          retryable: false,
+          nativePayload: { apiKey: "secret" },
+        },
+      }).success,
+    ).toBe(false);
+  });
+});

package/src/native-ui/shared-contracts/test/harness-permission-modes.test.ts

@@ -0,0 +1,134 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  HARNESS_PERMISSION_MODE_ID_MAX_LENGTH,
+  harnessConfigurationStateSchema,
+  harnessInspectionSchema,
+  harnessPermissionModeCatalogSchema,
+  harnessPermissionModeIdSchema,
+  permissionModeFixedAtCreate,
+  threadPermissionModeSelectParamsSchema,
+} from "@codexhost/shared-contracts";
+
+const permissionModes = {
+  modes: [
+    { id: "default", label: "Default" },
+    {
+      id: "bypassPermissions",
+      label: "Bypass permissions",
+      description: "Skip native permission checks.",
+      dangerous: true,
+    },
+  ],
+  defaultModeId: "default",
+};
+
+function readyInspection(selectPermissionMode: boolean) {
+  return {
+    status: "ready" as const,
+    catalog: { models: [], thinkingOptions: [] },
+    ...(selectPermissionMode ? { permissionModes } : {}),
+    capabilities: {
+      configuration: {
+        selectModel: false,
+        selectThinkingOption: false,
+        selectPermissionMode,
+        permissionModeScope: "live" as const,
+      },
+      history: { fork: false, forkAcrossCwd: false, rollbackLastTurn: false },
+    },
+  };
+}
+
+describe("Harness Permission Mode runtime contracts", () => {
+  it("accepts a finite opaque catalog and effective configuration state", () => {
+    expect(harnessPermissionModeCatalogSchema.parse(permissionModes)).toEqual(permissionModes);
+    expect(harnessInspectionSchema.parse(readyInspection(true))).toEqual(readyInspection(true));
+    expect(harnessConfigurationStateSchema.parse({ effectivePermissionModeId: "default" })).toEqual(
+      { effectivePermissionModeId: "default" },
+    );
+    expect(
+      threadPermissionModeSelectParamsSchema.parse({
+        threadId: "thread-1",
+        permissionModeId: "bypassPermissions",
+      }),
+    ).toEqual({ threadId: "thread-1", permissionModeId: "bypassPermissions" });
+  });
+
+  it("defaults Permission Mode scope to live and treats atCreate as fixed", () => {
+    const parsed = harnessInspectionSchema.parse({
+      ...readyInspection(true),
+      capabilities: {
+        configuration: {
+          selectModel: false,
+          selectThinkingOption: false,
+          selectPermissionMode: true,
+        },
+        history: { fork: false, forkAcrossCwd: false, rollbackLastTurn: false },
+      },
+    });
+    if (parsed.status !== "ready") throw new Error("Inspection is not ready");
+    expect(parsed.capabilities.configuration.permissionModeScope).toBe("live");
+    expect(permissionModeFixedAtCreate(parsed.capabilities.configuration)).toBe(false);
+    expect(permissionModeFixedAtCreate({ permissionModeScope: "atCreate" })).toBe(true);
+    expect(
+      harnessInspectionSchema.parse({
+        ...readyInspection(true),
+        capabilities: {
+          configuration: {
+            selectModel: false,
+            selectThinkingOption: false,
+            selectPermissionMode: true,
+            permissionModeScope: "atCreate",
+          },
+          history: { fork: false, forkAcrossCwd: false, rollbackLastTurn: false },
+        },
+      }),
+    ).toMatchObject({
+      capabilities: { configuration: { permissionModeScope: "atCreate" } },
+    });
+  });
+
+  it("requires catalog and structural capability to agree", () => {
+    expect(
+      harnessInspectionSchema.safeParse({
+        ...readyInspection(false),
+        permissionModes,
+      }).success,
+    ).toBe(false);
+    const missingCatalog = readyInspection(true) as Record<string, unknown>;
+    delete missingCatalog.permissionModes;
+    expect(harnessInspectionSchema.safeParse(missingCatalog).success).toBe(false);
+  });
+
+  it("rejects duplicate, missing-default, unsafe, unbounded, and extended values", () => {
+    expect(
+      harnessPermissionModeCatalogSchema.safeParse({
+        modes: [
+          { id: "default", label: "Default" },
+          { id: "default", label: "Duplicate" },
+        ],
+        defaultModeId: "default",
+      }).success,
+    ).toBe(false);
+    expect(
+      harnessPermissionModeCatalogSchema.safeParse({
+        modes: [{ id: "default", label: "Default" }],
+        defaultModeId: "missing",
+      }).success,
+    ).toBe(false);
+    expect(harnessPermissionModeIdSchema.safeParse("provider/mode").success).toBe(false);
+    expect(
+      harnessPermissionModeIdSchema.safeParse(
+        `m${"x".repeat(HARNESS_PERMISSION_MODE_ID_MAX_LENGTH)}`,
+      ).success,
+    ).toBe(false);
+    expect(
+      threadPermissionModeSelectParamsSchema.safeParse({
+        threadId: "thread-1",
+        permissionModeId: "default",
+        nativeMode: "dontAsk",
+      }).success,
+    ).toBe(false);
+  });
+});

package/src/native-ui/shared-contracts/test/harness-plugins.test.ts

@@ -0,0 +1,113 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  HARNESS_PLUGIN_ROUTE_PREFIX,
+  decodeHarnessPluginRoute,
+  encodeHarnessPluginRoute,
+  harnessPluginConfigurationSchema,
+  harnessPluginManifestSchema,
+  harnessPluginRouteSchema,
+} from "../src/index.js";
+
+const manifest = {
+  manifestVersion: 1,
+  id: "sample-agent",
+  name: "Sample Agent",
+  version: "1.0.0",
+  adapterApiVersion: 1,
+  entry: "dist/plugin.js",
+};
+
+describe("Harness plugin public contracts", () => {
+  it("accepts an arbitrary portable external identity and a future API version as data", () => {
+    expect(harnessPluginManifestSchema.parse({ ...manifest, adapterApiVersion: 2 }).id).toBe(
+      "sample-agent",
+    );
+  });
+
+  it.each(["codex", "../agent", "UPPER", "", "a/b", "a..b"])("rejects identity %j", (id) => {
+    expect(harnessPluginManifestSchema.safeParse({ ...manifest, id }).success).toBe(false);
+  });
+
+  it.each([
+    "../plugin.js",
+    "/plugin.js",
+    "C:\\plugin.js",
+    "dist/../../plugin.js",
+    "file:plugin.js",
+    "a//b.js",
+    "a.js#fragment",
+    "a.js?query",
+  ])("rejects resource %j", (entry) => {
+    expect(harnessPluginManifestSchema.safeParse({ ...manifest, entry }).success).toBe(false);
+  });
+
+  it.each([
+    "javascript:alert(1)",
+    "file:///private/file",
+    "http://example.com",
+    "https://user:secret@example.com",
+  ])("rejects documentation link %j", (documentation) => {
+    expect(
+      harnessPluginManifestSchema.safeParse({ ...manifest, links: { documentation } }).success,
+    ).toBe(false);
+  });
+
+  it("rejects duplicate enablement and backend data in the public manifest", () => {
+    expect(
+      harnessPluginConfigurationSchema.safeParse({
+        version: 1,
+        enabled: ["sample-agent", "sample-agent"],
+      }).success,
+    ).toBe(false);
+    expect(harnessPluginManifestSchema.safeParse({ ...manifest, apiKey: "secret" }).success).toBe(
+      false,
+    );
+  });
+});
+
+describe("versioned browser-safe Harness route", () => {
+  it("round trips identity and every configuration field without any Harness-specific codec", () => {
+    const route = harnessPluginRouteSchema.parse({
+      harnessId: "unknown.plugin",
+      model: { id: "opaque-model_1" },
+      thinkingOptionId: "high",
+      permissionModeId: "ask-first",
+    });
+    expect(decodeHarnessPluginRoute(encodeHarnessPluginRoute(route))).toEqual(route);
+    const minimal = harnessPluginRouteSchema.parse({ harnessId: "unknown.plugin" });
+    expect(decodeHarnessPluginRoute(encodeHarnessPluginRoute(minimal))).toEqual(minimal);
+  });
+
+  it.each([undefined, null, 1, "gpt-5", "codexhost/pi-native"])(
+    "leaves other protocols untouched (%j)",
+    (value) => {
+      expect(decodeHarnessPluginRoute(value)).toBeNull();
+    },
+  );
+
+  it.each(["", "xx", "7", "7B7D", "00", "7b7d", "00".repeat(4096)])(
+    "rejects malformed owned route case %#",
+    (payload) => {
+      expect(() => decodeHarnessPluginRoute(HARNESS_PLUGIN_ROUTE_PREFIX + payload)).toThrow(
+        "Invalid Harness plugin route",
+      );
+    },
+  );
+
+  it("rejects reordered, extra, or noncanonical JSON instead of passing it to Codex", () => {
+    for (const json of [
+      '{ "harnessId": "sample-agent" }',
+      '{"harnessId":"sample-agent","extra":true}',
+      '{"harnessId":"codex"}',
+      '{"harnessId":"sample-agent","harnessId":"other-agent"}',
+    ]) {
+      const payload = [...json]
+        .map((char) => char.charCodeAt(0).toString(16).padStart(2, "0"))
+        .join("");
+      expect(() => decodeHarnessPluginRoute(HARNESS_PLUGIN_ROUTE_PREFIX + payload)).toThrow(
+        "Invalid Harness plugin route",
+      );
+    }
+  });
+});