@cueloop/client 0.1.0-alpha.11 → 0.1.0-alpha.110

package/src/settings/use-thread-harness-setting.test.tsx

@@ -0,0 +1,87 @@
+import { expect, test } from "bun:test";
+import React, { useState } from "react";
+import { testRender } from "@opentui/react/test-utils";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import type { ThreadAgentClient } from "../thread/use-thread-agent";
+import type { ThreadAgentState } from "@cueloop/schema";
+import { clickText, isolateUserConfig, waitForText } from "../testing/test-support";
+import { useThreadHarnessSetting } from "./use-thread-harness-setting";
+
+function TestHarnessSwitchQueue({ client }: { client: ThreadAgentClient }) {
+  const [preferred, setPreferred] = useState("pending");
+  const setting = useThreadHarnessSetting({
+    thread: { id: "switch-queue" },
+    enabled: true,
+    owner: true,
+    preferred: "pi",
+    client,
+    onState() {},
+    onPreferred: setPreferred,
+    onError: (message) => setPreferred(message),
+  });
+
+  return (
+    <box>
+      <text onMouseDown={() => setting.switchHarness("fx")}>Select fx</text>
+      <text onMouseDown={() => setting.switchHarness("pi")}>Select pi</text>
+      <text>Preference: {preferred}</text>
+    </box>
+  );
+}
+
+test("a delayed switch cannot overtake the latest click or persist an older preference", async () => {
+  const home = mkdtempSync(join(tmpdir(), "cueloop-switch-queue-"));
+  const restore = isolateUserConfig(home);
+  const started = Promise.withResolvers<void>();
+  const release = Promise.withResolvers<void>();
+  const calls: string[] = [];
+  const state: ThreadAgentState = {
+    threadId: "switch-queue",
+    phase: { kind: "idle" },
+    messages: [],
+    comments: [],
+    tools: [],
+  };
+  const setup = await testRender(
+    <TestHarnessSwitchQueue
+      client={{
+        agentGet: async () => state,
+        agentPrompt: async () => state,
+        agentCancel: async () => state,
+        agentComment: async () => state,
+        agentPermission: async () => state,
+        async agentConfigure(params) {
+          calls.push(params.value!);
+
+          if (calls.length === 1) {
+            started.resolve();
+            await release.promise;
+          }
+
+          return state;
+        },
+      }}
+    />,
+    { width: 60, height: 10 },
+  );
+
+  try {
+    await waitForText(setup, "Select fx");
+    await clickText(setup, "Select fx");
+    await started.promise;
+    await clickText(setup, "Select pi");
+    await clickText(setup, "Select fx");
+    await clickText(setup, "Select pi");
+    expect(calls).toEqual(["fx"]);
+    release.resolve();
+    await waitForText(setup, "Preference: pi");
+    expect(calls).toEqual(["fx", "pi"]);
+  } finally {
+    release.resolve();
+    setup.renderer.destroy();
+    restore();
+    rmSync(home, { recursive: true, force: true });
+  }
+});

package/src/settings/use-thread-harness-setting.ts

@@ -0,0 +1,86 @@
+import { useRef, useEffect } from "react";
+import { DaemonClient } from "@cueloop/daemon/client";
+import type { ThreadAgentState, Thread } from "@cueloop/schema";
+import type { ThreadAgentClient } from "../thread/use-thread-agent";
+import { persistThreadHarness } from "./config";
+
+interface ThreadHarnessSettingOptions {
+  home?: string;
+  thread?: Pick<Thread, "id"> | null;
+  enabled: boolean;
+  owner: boolean;
+  state?: ThreadAgentState;
+  preferred: "pi" | "fx";
+  client?: ThreadAgentClient;
+  onState: (state: ThreadAgentState) => void;
+  onPreferred: (harness: "pi" | "fx") => void;
+  onError: (message: string) => void;
+}
+
+/** Preferences apply to new Threads; a bound Thread switches through the owner's daemon. */
+export function useThreadHarnessSetting(options: ThreadHarnessSettingOptions) {
+  const latest = useRef(options);
+  const generation = useRef(0);
+  const pending = useRef(Promise.resolve());
+
+  useEffect(() => {
+    latest.current = options;
+  });
+  const threadId = options.thread?.id;
+  const current = options.state?.threadId === threadId ? options.state : undefined;
+  const selected =
+    current?.handoff?.requestedTarget ??
+    current?.handoff?.target ??
+    current?.harness?.id ??
+    options.preferred;
+
+  return {
+    enabled: options.enabled && options.owner,
+    harness: selected === "fx" ? ("fx" as const) : ("pi" as const),
+    switchHarness(harness: "pi" | "fx") {
+      const request = latest.current;
+      const requestedId = request.thread?.id;
+
+      if (!request.enabled || !request.owner) return;
+
+      const requestedGeneration = ++generation.current;
+
+      pending.current = pending.current.then(async () => {
+        if (generation.current !== requestedGeneration) return;
+
+        let connection: DaemonClient | undefined;
+
+        try {
+          if (requestedId) {
+            const api =
+              request.client ??
+              (connection = await DaemonClient.connect({ home: request.home, autostart: true }));
+
+            if (generation.current !== requestedGeneration) return;
+
+            if (!api.agentConfigure) throw new Error("Thread harness switching is unavailable");
+
+            const state = await api.agentConfigure({
+              id: requestedId,
+              configId: "harness",
+              value: harness,
+            });
+
+            if (generation.current !== requestedGeneration) return;
+
+            if (latest.current.thread?.id === requestedId) latest.current.onState(state);
+          }
+
+          persistThreadHarness(harness);
+          latest.current.onPreferred(harness);
+        } catch (failure) {
+          if (generation.current !== requestedGeneration) return;
+
+          latest.current.onError(failure instanceof Error ? failure.message : String(failure));
+        } finally {
+          connection?.close();
+        }
+      });
+    },
+  };
+}