@runfusion/fusion 0.43.1 → 0.45.0

package/dist/client/version.json

@@ -1 +1 @@
-{"version":"f7635faf3-7ebf82ef"}
+{"version":"192a2f2e9-7a1b1370"}

package/dist/droid-cli/index.ts

@@ -24,31 +24,27 @@ type StreamSimpleHandler = NonNullable<Parameters<ExtensionAPI["registerProvider
 function runCliValidationOnce(): Promise<void> {
   if (cliValidationPromise) return cliValidationPromise;
   cliValidationPromise = (async () => {
-    const presence = await validateCliPresenceAsync();
-    if (!presence.ok) {
-      console.warn(`[droid-cli] ${presence.error.message}`);
-      return;
+    try {
+      const presence = await validateCliPresenceAsync();
+      if (!presence.ok) {
+        console.warn(`[droid-cli] ${presence.error.message}`);
+        return;
+      }
+      await validateCliAuthAsync();
+    } catch (error) {
+      console.warn("[droid-cli] CLI validation failed; continuing without blocking the session", error);
     }
-    await validateCliAuthAsync();
   })();
   return cliValidationPromise;
 }
 
-async function getDiscoveredModels() {
+export async function discoverDroidProviderModels() {
   if (!discoveredModelsPromise) {
     discoveredModelsPromise = (async () => {
       try {
         const ids = Array.from(new Set(await discoverDroidModels()));
         if (ids.length === 0) return [];
-        return ids.map((id) => ({
-          id,
-          name: id,
-          reasoning: true,
-          input: ["text", "image"] as Array<"text" | "image">,
-          cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-          contextWindow: 200_000,
-          maxTokens: 8_192,
-        }));
+        return toProviderModels(ids);
       } catch (error) {
         console.warn("[droid-cli] model auto-discovery failed; registering provider with empty model list", error);
         return [];
@@ -60,6 +56,18 @@ async function getDiscoveredModels() {
 
 let cachedMcpConfig: { hash: string; configPath: string } | undefined;
 
+function toProviderModels(ids: string[]): DiscoveredModel[] {
+  return ids.map((id) => ({
+    id,
+    name: id,
+    reasoning: true,
+    input: ["text", "image"] as Array<"text" | "image">,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 200_000,
+    maxTokens: 8_192,
+  }));
+}
+
 function ensureMcpConfig(
   pi: ExtensionAPI,
   contextTools?: ReadonlyArray<{
@@ -93,8 +101,35 @@ function ensureMcpConfig(
   }
 }
 
+function registerDroidProvider(pi: ExtensionAPI, models: DiscoveredModel[]) {
+  pi.registerProvider(PROVIDER_ID, {
+    baseUrl: "droid-cli",
+    apiKey: "unused",
+    api: "droid-cli",
+    models,
+    streamSimple: ((model, context, options) => {
+      void runCliValidationOnce();
+      const configPath = ensureMcpConfig(
+        pi,
+        (context as { tools?: ReadonlyArray<{ name: string; description: string; parameters: Record<string, unknown> }> }).tools,
+      );
+      return streamViaCli(
+        model,
+        context as never,
+        { ...(options ?? {}), mcpConfigPath: configPath } as never,
+      ) as unknown as ReturnType<StreamSimpleHandler>;
+    }) as StreamSimpleHandler,
+  });
+}
+
 export default function (pi: ExtensionAPI) {
-  void runCliValidationOnce();
+  /*
+  FNXC:CliRuntime 2026-06-21-18:43:
+  Engine and dashboard startup must not start the local Droid CLI merely because the optional extension loaded. Register the provider synchronously with an empty model list, defer validation until an actual droid stream starts, and leave model discovery to explicit picker/status callers so boot with `useDroidCli` enabled still performs zero `droid` spawns.
+
+  FNXC:CliRuntime 2026-06-21-12:00:
+  Engine and dashboard startup must not wait for local Droid CLI probes. Every surviving validation/discovery helper remains fire-and-forget, bounded, non-interactive, and resolve-only so a missing or wedged `droid` binary cannot stall extension loading or a session start.
+  */
 
   pi.on("session_start", async () => {
     const allTools = pi.getAllTools();
@@ -103,28 +138,9 @@ export default function (pi: ExtensionAPI) {
     }
   });
 
-  void (async () => {
-    const models = await getDiscoveredModels();
-    try {
-      pi.registerProvider(PROVIDER_ID, {
-        baseUrl: "droid-cli",
-        apiKey: "unused",
-        api: "droid-cli",
-        models,
-        streamSimple: ((model, context, options) => {
-          const configPath = ensureMcpConfig(
-            pi,
-            (context as { tools?: ReadonlyArray<{ name: string; description: string; parameters: Record<string, unknown> }> }).tools,
-          );
-          return streamViaCli(
-            model,
-            context as never,
-            { ...(options ?? {}), mcpConfigPath: configPath } as never,
-          ) as unknown as ReturnType<StreamSimpleHandler>;
-        }) as StreamSimpleHandler,
-      });
-    } catch (err) {
-      console.error("[droid-cli] Failed to register provider:", err);
-    }
-  })();
+  try {
+    registerDroidProvider(pi, []);
+  } catch (err) {
+    console.error("[droid-cli] Failed to register provider:", err);
+  }
 }

package/dist/droid-cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fusion/droid-cli",
-  "version": "0.11.32",
+  "version": "0.11.34",
   "description": "First-party Fusion pi extension that routes LLM calls through the Droid CLI subprocess.",
   "license": "MIT",
   "private": true,

package/dist/droid-cli/src/__tests__/execsync-guard.test.ts

@@ -0,0 +1,17 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+
+describe("process-manager execSync guard", () => {
+  it("keeps Droid CLI probing non-blocking", () => {
+    const sourcePath = path.resolve(
+      import.meta.dirname,
+      "../../../../plugins/fusion-plugin-droid-runtime/src/process-manager.ts",
+    );
+
+    expect(existsSync(sourcePath)).toBe(true);
+    const src = readFileSync(sourcePath, "utf-8");
+
+    expect(/\bexecSync\b/.test(src)).toBe(false);
+  });
+});

package/dist/droid-cli/src/__tests__/index.test.ts

@@ -58,7 +58,7 @@ describe("droid-cli extension entrypoint", () => {
     vi.restoreAllMocks();
   });
 
-  it("registers provider droid-cli with discovered model mapping and streamSimple", async () => {
+  it("registers provider droid-cli synchronously without starting droid probes or discovery", async () => {
     const registerProvider = vi.fn();
     const mockPi = {
       registerProvider,
@@ -68,19 +68,20 @@ describe("droid-cli extension entrypoint", () => {
     };
 
     const mod = await import("../../index");
-    mod.default(mockPi as never);
+    const result = mod.default(mockPi as never);
     await flushAsyncRegistration();
 
-    expect(runtimeMocks.validateCliPresenceAsync).toHaveBeenCalledTimes(1);
-    expect(runtimeMocks.validateCliAuthAsync).toHaveBeenCalledTimes(1);
-    expect(runtimeMocks.discoverDroidModels).toHaveBeenCalledTimes(1);
+    expect(result).toBeUndefined();
+    expect(runtimeMocks.validateCliPresenceAsync).not.toHaveBeenCalled();
+    expect(runtimeMocks.validateCliAuthAsync).not.toHaveBeenCalled();
+    expect(runtimeMocks.discoverDroidModels).not.toHaveBeenCalled();
 
     expect(registerProvider).toHaveBeenCalledTimes(1);
     const [providerId, config] = registerProvider.mock.calls[0] as [string, {
       baseUrl: string;
       api: string;
       apiKey: string;
-      models: Array<{ id: string; name: string; contextWindow: number; maxTokens: number }>;
+      models: unknown[];
       streamSimple: Function;
     }];
 
@@ -88,11 +89,43 @@ describe("droid-cli extension entrypoint", () => {
     expect(config.baseUrl).toBe("droid-cli");
     expect(config.api).toBe("droid-cli");
     expect(config.apiKey).toBe("unused");
-    expect(config.models).toEqual([
+    expect(config.models).toEqual([]);
+    expect(typeof config.streamSimple).toBe("function");
+  });
+
+  it("runs validation once when a droid stream is actually used", async () => {
+    const registerProvider = vi.fn();
+    const mockPi = {
+      registerProvider,
+      on: vi.fn(),
+      getAllTools: vi.fn(() => []),
+      setActiveTools: vi.fn(),
+    };
+
+    const mod = await import("../../index");
+    mod.default(mockPi as never);
+    const config = registerProvider.mock.calls[0]?.[1] as {
+      streamSimple: (model: unknown, context: unknown, options?: Record<string, unknown>) => unknown;
+    };
+
+    config.streamSimple({ id: "droid-pro" }, { messages: [] }, {});
+    config.streamSimple({ id: "droid-pro" }, { messages: [] }, {});
+    await flushAsyncRegistration();
+
+    expect(runtimeMocks.validateCliPresenceAsync).toHaveBeenCalledTimes(1);
+    expect(runtimeMocks.validateCliAuthAsync).toHaveBeenCalledTimes(1);
+    expect(runtimeMocks.discoverDroidModels).not.toHaveBeenCalled();
+  });
+
+  it("discovers provider models only when explicitly requested", async () => {
+    const mod = await import("../../index");
+
+    await expect(mod.discoverDroidProviderModels()).resolves.toEqual([
       expect.objectContaining({ id: "droid-pro", name: "droid-pro", contextWindow: 200_000, maxTokens: 8_192 }),
       expect.objectContaining({ id: "droid-max", name: "droid-max", contextWindow: 200_000, maxTokens: 8_192 }),
     ]);
-    expect(typeof config.streamSimple).toBe("function");
+
+    expect(runtimeMocks.discoverDroidModels).toHaveBeenCalledTimes(1);
   });
 
   it("activates all registered tools on session_start", async () => {
@@ -132,31 +165,24 @@ describe("droid-cli extension entrypoint", () => {
 
     const mod = await import("../../index");
     mod.default(mockPi as never);
+    const config = mockPi.registerProvider.mock.calls[0]?.[1] as {
+      streamSimple: (model: unknown, context: unknown, options?: Record<string, unknown>) => unknown;
+    };
+    config.streamSimple({ id: "droid-pro" }, { messages: [] }, {});
     await flushAsyncRegistration();
 
     expect(warnSpy).toHaveBeenCalledWith("[droid-cli] droid CLI missing");
     expect(runtimeMocks.validateCliAuthAsync).not.toHaveBeenCalled();
-    expect(mockPi.registerProvider).toHaveBeenCalledTimes(1);
+    expect(mockPi.registerProvider).toHaveBeenCalledWith("droid-cli", expect.objectContaining({ models: [] }));
   });
 
   it("falls back to empty models when discovery throws", async () => {
     const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
     runtimeMocks.discoverDroidModels.mockRejectedValue(new Error("boom"));
 
-    const registerProvider = vi.fn();
-    const mockPi = {
-      registerProvider,
-      on: vi.fn(),
-      getAllTools: vi.fn(() => []),
-      setActiveTools: vi.fn(),
-    };
-
     const mod = await import("../../index");
-    mod.default(mockPi as never);
-    await flushAsyncRegistration();
+    await expect(mod.discoverDroidProviderModels()).resolves.toEqual([]);
 
-    const config = registerProvider.mock.calls[0]?.[1] as { models: unknown[] };
-    expect(config.models).toEqual([]);
     expect(warnSpy).toHaveBeenCalledWith(
       "[droid-cli] model auto-discovery failed; registering provider with empty model list",
       expect.any(Error),

package/dist/droid-cli/src/__tests__/process-manager.test.ts

@@ -16,7 +16,6 @@ vi.mock("node:child_process", () => ({
     proc.pid = 12345;
     return proc;
   }),
-  execSync: vi.fn(),
 }));
 
 const mocks = vi.hoisted(() => ({
@@ -38,15 +37,13 @@ vi.mock("node:os", () => ({
   tmpdir: mocks.tmpdir,
 }));
 
-import { spawn, execSync } from "node:child_process";
+import { spawn } from "node:child_process";
 import {
   spawnDroid,
   buildDroidSpawnArgs,
   writeUserMessage,
   cleanupProcess,
   captureStderr,
-  validateCliPresence,
-  validateCliAuth,
   validateCliPresenceAsync,
   validateCliAuthAsync,
   forceKillProcess,
@@ -369,47 +366,6 @@ describe("captureStderr", () => {
   });
 });
 
-describe("validateCliPresence", () => {
-  it("does not throw when droid --version succeeds", () => {
-    (execSync as any).mockReturnValue(Buffer.from("1.0.0"));
-    expect(() => validateCliPresence()).not.toThrow();
-  });
-
-  it("throws with install instructions when droid --version fails", () => {
-    (execSync as any).mockImplementation(() => {
-      throw new Error("command not found");
-    });
-
-    expect(() => validateCliPresence()).toThrow();
-    try {
-      validateCliPresence();
-    } catch (e: any) {
-      expect(e.message).toContain("Droid CLI not found");
-      expect(e.message).toContain("Install Droid CLI");
-    }
-  });
-});
-
-describe("validateCliAuth", () => {
-  it("returns true when droid auth status succeeds", () => {
-    (execSync as any).mockReturnValue(Buffer.from("Logged in"));
-    expect(validateCliAuth()).toBe(true);
-  });
-
-  it("returns false and warns when droid auth status fails", () => {
-    (execSync as any).mockImplementation(() => {
-      throw new Error("not authenticated");
-    });
-    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
-
-    expect(validateCliAuth()).toBe(false);
-    expect(warnSpy).toHaveBeenCalledWith(
-      expect.stringContaining("not authenticated"),
-    );
-    warnSpy.mockRestore();
-  });
-});
-
 describe("validateCliPresenceAsync", () => {
   beforeEach(() => {
     vi.clearAllMocks();
@@ -459,6 +415,16 @@ describe("validateCliPresenceAsync", () => {
     const result = await validateCliPresenceAsync();
     expect(result.ok).toBe(false);
   });
+
+  it("resolves ok=false instead of rejecting when droid spawn throws synchronously", async () => {
+    (spawn as any).mockImplementationOnce(() => {
+      throw new Error("Real AI CLI launch blocked during tests: droid --version");
+    });
+
+    await expect(validateCliPresenceAsync()).resolves.toMatchObject({
+      ok: false,
+    });
+  });
 });
 
 describe("validateCliAuthAsync", () => {
@@ -496,6 +462,21 @@ describe("validateCliAuthAsync", () => {
     );
     warnSpy.mockRestore();
   });
+
+  it("resolves false instead of rejecting when droid auth spawn throws synchronously", async () => {
+    (spawn as any).mockImplementationOnce(() => {
+      throw new Error(
+        "Real AI CLI launch blocked during tests: droid auth status",
+      );
+    });
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+    await expect(validateCliAuthAsync()).resolves.toBe(false);
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining("not authenticated"),
+    );
+    warnSpy.mockRestore();
+  });
 });
 
 describe("CLI flags", () => {
@@ -767,52 +748,44 @@ describe("discoverDroidModels", () => {
     vi.clearAllMocks();
   });
 
-  it("parses model ids from JSON output", async () => {
+  it("parses model ids from droid exec --help output", async () => {
     (spawn as any).mockImplementationOnce(() => {
       const EventEmitter = require("node:events");
       const proc = new EventEmitter();
       proc.stdout = new EventEmitter();
       proc.stderr = new EventEmitter();
       setTimeout(() => {
-        proc.stdout.emit("data", Buffer.from('[{"id":"droid-pro"},{"name":"droid-max"}]'));
+        proc.stdout.emit("data", Buffer.from(`Usage: droid exec [options] [prompt]
+
+Available Models:
+  droid-pro                 Droid Pro
+  droid-max                 Droid Max
+
+Model details:
+  - Droid Pro: prose, not a model id
+`));
         proc.emit("exit", 0);
       }, 0);
       return proc;
     });
 
     await expect(discoverDroidModels()).resolves.toEqual(["droid-pro", "droid-max"]);
+    expect(spawn).toHaveBeenCalledWith("droid", ["exec", "--help"], expect.anything());
   });
 
-  it("falls back across attempts and parses newline output", async () => {
-    (spawn as any)
-      .mockImplementationOnce(() => {
-        const EventEmitter = require("node:events");
-        const proc = new EventEmitter();
-        proc.stdout = new EventEmitter();
-        proc.stderr = new EventEmitter();
-        setTimeout(() => proc.emit("exit", 1), 0);
-        return proc;
-      })
-      .mockImplementationOnce(() => {
-        const EventEmitter = require("node:events");
-        const proc = new EventEmitter();
-        proc.stdout = new EventEmitter();
-        proc.stderr = new EventEmitter();
-        setTimeout(() => proc.emit("exit", 1), 0);
-        return proc;
-      })
-      .mockImplementationOnce(() => {
-        const EventEmitter = require("node:events");
-        const proc = new EventEmitter();
-        proc.stdout = new EventEmitter();
-        proc.stderr = new EventEmitter();
-        setTimeout(() => {
-          proc.stdout.emit("data", Buffer.from("droid-lite\ndroid-lite\ndroid-pro\n"));
-          proc.emit("exit", 0);
-        }, 0);
-        return proc;
-      });
-
-    await expect(discoverDroidModels()).resolves.toEqual(["droid-lite", "droid-pro"]);
+  it("returns [] when droid exec --help exits without a model section", async () => {
+    (spawn as any).mockImplementationOnce(() => {
+      const EventEmitter = require("node:events");
+      const proc = new EventEmitter();
+      proc.stdout = new EventEmitter();
+      proc.stderr = new EventEmitter();
+      setTimeout(() => {
+        proc.stdout.emit("data", Buffer.from("Usage: droid exec\n\nOptions:\n  --help\n"));
+        proc.emit("exit", 0);
+      }, 0);
+      return proc;
+    });
+
+    await expect(discoverDroidModels()).resolves.toEqual([]);
   });
 });