shadow-claw 1.27.0 → 1.28.0

package/src/core/control-plane-client.test.ts

@@ -54,8 +54,13 @@ class MockClientWebSocket {
 
 // Mock EventSource implementation for SSE client testing
 class MockEventSource {
+  static readonly CONNECTING = 0;
+  static readonly OPEN = 1;
+  static readonly CLOSED = 2;
+
   static instances: MockEventSource[] = [];
   url: string;
+  readyState: number = 0; // CONNECTING
   onopen: (() => void) | null = null;
   onmessage: ((event: { data: string }) => void) | null = null;
   onerror: ((err: any) => void) | null = null;
@@ -64,9 +69,11 @@ class MockEventSource {
 
   constructor(url: string) {
     this.url = url;
+    this.readyState = MockEventSource.CONNECTING;
     MockEventSource.instances.push(this);
     setTimeout(() => {
       if (!this.closed) {
+        this.readyState = MockEventSource.OPEN;
         this.onopen?.();
       }
     }, 10);
@@ -80,6 +87,7 @@ class MockEventSource {
 
   close() {
     this.closed = true;
+    this.readyState = MockEventSource.CLOSED;
   }
 
   // Helper for test to simulate server event
@@ -225,6 +233,42 @@ describe("control-plane-client", () => {
 
       client.disconnect();
     });
+
+    it("ensureConnected reconnects and resets backoff for SSE when forced or disconnected", async () => {
+      const client = new ControlPlaneClient({
+        clientId: "sse-client-reconnect",
+        reconnectDelayMs: 500,
+        maxReconnectDelayMs: 30000,
+        EventSourceClass: MockEventSource as any,
+        fetchFn: mockFetch as any,
+      });
+
+      client.connect();
+      expect(MockEventSource.instances).toHaveLength(1);
+      jest.advanceTimersByTime(15);
+      expect(client.getState()).toBe("connected");
+
+      // Calling ensureConnected(false) when healthy is a no-op
+      client.ensureConnected(false);
+      expect(MockEventSource.instances).toHaveLength(1);
+
+      // Simulate disconnection and exponential backoff
+      const es1 = MockEventSource.instances[0];
+      es1.close();
+      es1.onerror?.(new Error("Network drop"));
+      expect(client.getState()).toBe("disconnected");
+
+      // Advance by small time so reconnect delay increases
+      jest.advanceTimersByTime(200);
+
+      // Mobile sleep wake-up: ensureConnected(true) immediately reconnects without waiting for backoff timer
+      client.ensureConnected(true);
+      expect(MockEventSource.instances).toHaveLength(2);
+      jest.advanceTimersByTime(15);
+      expect(client.getState()).toBe("connected");
+
+      client.disconnect();
+    });
   });
 
   describe("WebSocket Transport (Opt-in)", () => {
@@ -256,7 +300,7 @@ describe("control-plane-client", () => {
         clientId: "client-test-1",
         deviceLabel: "Test Device",
         capabilities: ["webmcp", "opfs"],
-        version: "1.23.4",
+        version: "1.27.1",
         transport: "websocket",
       });
 
@@ -411,5 +455,42 @@ describe("control-plane-client", () => {
 
       client.disconnect();
     });
+
+    it("ensureConnected reconnects and resets backoff for WebSocket when forced or disconnected", async () => {
+      const client = new ControlPlaneClient({
+        transport: "websocket",
+        url: "ws://127.0.0.1:8888/ws/control",
+        clientId: "client-ws-ensure",
+        reconnectDelayMs: 500,
+        WebSocketClass: MockClientWebSocket as any,
+      });
+
+      client.connect();
+      expect(MockClientWebSocket.instances).toHaveLength(1);
+      jest.advanceTimersByTime(15);
+      expect(client.getState()).toBe("connected");
+
+      // Non-forced ensureConnected is a no-op when connected
+      client.ensureConnected(false);
+      expect(MockClientWebSocket.instances).toHaveLength(1);
+
+      // Force reconnect (e.g. mobile sleep / app switch wake-up)
+      client.ensureConnected(true);
+      expect(MockClientWebSocket.instances).toHaveLength(2);
+      jest.advanceTimersByTime(15);
+      expect(client.getState()).toBe("connected");
+
+      // Also verify when disconnected and timer is active
+      const ws2 = MockClientWebSocket.instances[1];
+      ws2.close();
+      expect(client.getState()).toBe("disconnected");
+
+      client.ensureConnected(false);
+      expect(MockClientWebSocket.instances).toHaveLength(3);
+      jest.advanceTimersByTime(15);
+      expect(client.getState()).toBe("connected");
+
+      client.disconnect();
+    });
   });
 });

package/src/core/control-plane-client.ts

@@ -71,7 +71,7 @@ export class ControlPlaneClient {
     this._peerId = options.peerId;
     this._deviceLabel = options.deviceLabel || "ShadowClaw Browser Client";
     this._capabilities = options.capabilities || ["webmcp", "opfs", "push"];
-    this._version = options.version || "1.23.4";
+    this._version = options.version || "1.27.1";
     this._token = options.token;
     this._heartbeatIntervalMs = options.heartbeatIntervalMs || 10000;
     this._reconnectDelayMs = options.reconnectDelayMs || 1000;
@@ -113,6 +113,10 @@ export class ControlPlaneClient {
     return this._transport;
   }
 
+  public get version(): string {
+    return this._version;
+  }
+
   public registerHandler(action: string, handler: CommandHandler): void {
     this._handlers.set(action, handler);
   }
@@ -125,6 +129,36 @@ export class ControlPlaneClient {
     return this._state;
   }
 
+  public ensureConnected(force: boolean = false): void {
+    this._isDestroyed = false;
+    if (this._reconnectTimer) {
+      clearTimeout(this._reconnectTimer);
+      this._reconnectTimer = null;
+    }
+    this._currentReconnectDelay = this._reconnectDelayMs;
+
+    if (this._transport === "websocket") {
+      const isWsOpen =
+        this._ws &&
+        (this._ws.readyState === 1 ||
+          this._ws.readyState === (this._WebSocketClass as any)?.OPEN);
+      if (force || !isWsOpen || this._state !== "connected") {
+        this._cleanupConnection();
+        this.connect();
+      }
+    } else {
+      // SSE transport
+      const isEsOpen =
+        this._es &&
+        (this._es.readyState === 1 ||
+          this._es.readyState === (this._EventSourceClass as any)?.OPEN);
+      if (force || !isEsOpen || this._state !== "connected") {
+        this._cleanupConnection();
+        this.connect();
+      }
+    }
+  }
+
   public connect(): void {
     if (
       this._isDestroyed ||

package/src/core/orchestrator/orchestrator.test.ts

@@ -1894,4 +1894,53 @@ describe("Orchestrator", () => {
       }
     });
   });
+
+  describe("ensureAllConnections", () => {
+    it("coordinates Control Plane, channels, task server, and scheduler", async () => {
+      const o = new Orchestrator();
+      const fakeDb = {} as any;
+      o.db = fakeDb;
+      o.taskServerEnabled = true;
+
+      const mockScheduler = {
+        start: jest.fn(),
+        tick: jest.fn().mockResolvedValue(undefined as never),
+      };
+      o.scheduler = mockScheduler as any;
+
+      const ensureControlPlaneSpy = jest
+        .spyOn(o, "ensureControlPlaneConnected")
+        .mockResolvedValue(null as any);
+
+      const peerjsEnsureSpy = jest.fn();
+      (o.peerjs as any).ensureConnected = peerjsEnsureSpy;
+      o.peerjs.running = true;
+      o.channelEnabledByType.peerjs = true;
+      o.peerjsMyPeerId = "my-peer";
+
+      const replaySpy = jest
+        .spyOn(orchestratorStore, "replayTaskSyncOutbox")
+        .mockResolvedValue();
+      const loadTasksSpy = jest
+        .spyOn(orchestratorStore, "loadTasks")
+        .mockResolvedValue();
+
+      await o.ensureAllConnections({ force: true });
+
+      expect(ensureControlPlaneSpy).toHaveBeenCalledWith({
+        orchestrator: o,
+        db: fakeDb,
+        force: true,
+      });
+      expect(peerjsEnsureSpy).toHaveBeenCalledWith(true);
+      expect(replaySpy).toHaveBeenCalledWith(fakeDb);
+      expect(loadTasksSpy).toHaveBeenCalledWith(fakeDb);
+      expect(mockScheduler.start).toHaveBeenCalled();
+      expect(mockScheduler.tick).toHaveBeenCalled();
+
+      ensureControlPlaneSpy.mockRestore();
+      replaySpy.mockRestore();
+      loadTasksSpy.mockRestore();
+    });
+  });
 });

package/src/core/orchestrator/orchestrator.ts

@@ -74,6 +74,8 @@ import {
 
 import { syncWebMcpRegistration } from "./utils/syncWebMcpRegistration.js";
 import { DEFAULT_DIRECT_TOOL_COMMAND_POLICY } from "./utils/types.js";
+import { ensureControlPlaneConnected } from "../utils/initControlPlane.js";
+import { applyAllChannelRunningStates } from "./utils/operations/channel.js";
 
 import type { ShadowClawDatabase } from "../../db/db.js";
 import type { A2UIAction } from "../../ui/a2ui/types.js";
@@ -104,6 +106,9 @@ export class Orchestrator {
     ...DEFAULT_DIRECT_TOOL_COMMAND_POLICY,
   };
 
+  ensureControlPlaneConnected: typeof ensureControlPlaneConnected =
+    ensureControlPlaneConnected;
+
   events: EventBus = new EventBus();
   gitProxyUrl: string = "/git-proxy";
 
@@ -287,6 +292,44 @@ export class Orchestrator {
     unregisterWebMcpTools();
   }
 
+  /**
+   * Ensure all enabled external connections (Control Plane, Channels, Task Server)
+   * are actively connected and healthy (e.g. on initial app load, wake-up from sleep,
+   * switching back from another app, or regaining network connectivity).
+   */
+  async ensureAllConnections(options: { force?: boolean } = {}): Promise<void> {
+    const force = options.force ?? false;
+
+    // 1. Control Plane
+    try {
+      await this.ensureControlPlaneConnected({
+        orchestrator: this,
+        db: this.db || undefined,
+        force,
+      });
+    } catch (err) {
+      console.warn("Error ensuring Control Plane connection:", err);
+    }
+
+    // 2. Messaging Channels
+    try {
+      applyAllChannelRunningStates(this, force);
+    } catch (err) {
+      console.warn("Error ensuring channel connections:", err);
+    }
+
+    // 3. Server Task Scheduling & Local Scheduler
+    if (this.taskServerEnabled && this.db) {
+      void orchestratorStore.replayTaskSyncOutbox(this.db);
+      void orchestratorStore.loadTasks(this.db);
+    }
+
+    if (this.scheduler) {
+      this.scheduler.start();
+      void this.scheduler.tick();
+    }
+  }
+
   stopCurrentRequest(groupId = DEFAULT_GROUP_ID): void {
     if (this.state !== "thinking" && this.state !== "responding") {
       return;

package/src/core/orchestrator/utils/operations/channel.test.ts

@@ -192,6 +192,23 @@ describe("channel operations", () => {
     expect(state.peerjs.stop).toHaveBeenCalled();
   });
 
+  it("applyChannelRunningState invokes ensureConnected if channel is already running", () => {
+    const ensureConnectedMock = jest.fn();
+    const state = makeState({
+      channelEnabledByType: { telegram: true } as any,
+      telegramBotToken: "token",
+      telegram: {
+        running: true,
+        start: jest.fn(),
+        stop: jest.fn(),
+        ensureConnected: ensureConnectedMock,
+      } as any,
+    });
+
+    applyAllChannelRunningStates(state, true);
+    expect(ensureConnectedMock).toHaveBeenCalledWith(true);
+  });
+
   it("clearPeerJsTypingState invokes store update", () => {
     clearPeerJsTypingState("peer:group1");
   });

package/src/core/orchestrator/utils/operations/channel.ts

@@ -191,6 +191,7 @@ export function applyChannelRunningState(
     | "peerjsMyPeerId"
   >,
   channelType: ChannelType,
+  force: boolean = false,
 ): void {
   const channel = getChannelByType(state, channelType);
   if (!channel) {
@@ -198,7 +199,11 @@ export function applyChannelRunningState(
   }
 
   if (shouldRunChannel(state, channelType)) {
-    channel.start();
+    if (!channel.running) {
+      channel.start();
+    } else if (typeof (channel as any).ensureConnected === "function") {
+      (channel as any).ensureConnected(force);
+    }
 
     return;
   }
@@ -218,11 +223,12 @@ export function applyAllChannelRunningStates(
     | "imessageServerUrl"
     | "peerjsMyPeerId"
   >,
+  force: boolean = false,
 ): void {
-  applyChannelRunningState(state, "browser");
-  applyChannelRunningState(state, "telegram");
-  applyChannelRunningState(state, "imessage");
-  applyChannelRunningState(state, "peerjs");
+  applyChannelRunningState(state, "browser", force);
+  applyChannelRunningState(state, "telegram", force);
+  applyChannelRunningState(state, "imessage", force);
+  applyChannelRunningState(state, "peerjs", force);
 }
 
 export function clearPeerJsTypingState(groupId: string): void {

package/src/core/orchestrator/utils/operations/task.test.ts

@@ -57,4 +57,30 @@ describe("task operations", () => {
       expect.objectContaining({ method: "DELETE" }),
     );
   });
+
+  it("syncTaskToServer sets targetAddressSpace private for local hostnames", async () => {
+    await syncTaskToServer(
+      {
+        taskServerUrl: "https://hostname:8888/schedule",
+        taskServerEnabled: true,
+      } as any,
+      {
+        id: "t2",
+        groupId: "br:main",
+        prompt: "hello",
+        schedule: "*/5 * * * *",
+        enabled: true,
+        lastRun: null,
+        createdAt: 1,
+      } as any,
+    );
+
+    expect((globalThis as any).fetch).toHaveBeenCalledWith(
+      "https://hostname:8888/schedule/tasks",
+      expect.objectContaining({
+        method: "POST",
+        targetAddressSpace: "private",
+      }),
+    );
+  });
 });

package/src/core/orchestrator/utils/operations/task.ts

@@ -23,7 +23,14 @@ function getTaskFetchOptions(
       host === "[::1]"
     ) {
       opts.targetAddressSpace = "loopback";
-    } else if (/^(10\.|172\.(1[6-9]|2\d|3[01])\.|192\.168\.)/.test(host)) {
+    } else if (
+      /^(10\.|172\.(1[6-9]|2\d|3[01])\.|192\.168\.)/.test(host) ||
+      !host.includes(".") ||
+      host.endsWith(".local") ||
+      host.endsWith(".lan") ||
+      host.endsWith(".home") ||
+      host.endsWith(".internal")
+    ) {
       opts.targetAddressSpace = "private";
     }
   } catch (_) {}

package/src/core/utils/initControlPlane.test.ts

@@ -3,10 +3,12 @@ import {
   shouldConnectControlPlane,
   detectCapabilities,
   createDefaultControlPlaneClient,
+  ensureControlPlaneConnected,
   executeClientControlCommand,
   getControlPlaneServerUrl,
   getActiveControlPlaneClient,
   stopControlPlaneClient,
+  detectClientVersion,
 } from "./initControlPlane.js";
 
 describe("initControlPlane", () => {
@@ -90,6 +92,65 @@ describe("initControlPlane", () => {
     });
   });
 
+  describe("detectClientVersion", () => {
+    afterEach(() => {
+      document
+        .querySelectorAll('meta[name="version"], meta[name="revision"]')
+        .forEach((el) => el.remove());
+    });
+
+    it("returns default fallback 1.27.1 when no DOM metadata is present", () => {
+      expect(detectClientVersion()).toBe("1.27.1");
+    });
+
+    it("returns '<semver> (<short-rev>)' when both version and revision are present", () => {
+      const metaVersion = document.createElement("meta");
+      metaVersion.setAttribute("name", "version");
+      metaVersion.setAttribute("content", "1.27.1");
+      document.head.appendChild(metaVersion);
+
+      const metaRevision = document.createElement("meta");
+      metaRevision.setAttribute("name", "revision");
+      metaRevision.setAttribute(
+        "content",
+        "ad65dc305c71a18cb2152e4f47da1491148fb07f",
+      );
+      document.head.appendChild(metaRevision);
+
+      expect(detectClientVersion()).toBe("1.27.1 (ad65dc3)");
+    });
+
+    it("returns '<semver>' when only version is present", () => {
+      const metaVersion = document.createElement("meta");
+      metaVersion.setAttribute("name", "version");
+      metaVersion.setAttribute("content", "1.27.1");
+      document.head.appendChild(metaVersion);
+
+      expect(detectClientVersion()).toBe("1.27.1");
+    });
+
+    it("returns '<short-rev>' when only revision is present", () => {
+      const metaRevision = document.createElement("meta");
+      metaRevision.setAttribute("name", "revision");
+      metaRevision.setAttribute(
+        "content",
+        "ad65dc305c71a18cb2152e4f47da1491148fb07f",
+      );
+      document.head.appendChild(metaRevision);
+
+      expect(detectClientVersion()).toBe("ad65dc3");
+    });
+
+    it("handles 7-char short revision directly", () => {
+      const metaRevision = document.createElement("meta");
+      metaRevision.setAttribute("name", "revision");
+      metaRevision.setAttribute("content", "ad65dc3");
+      document.head.appendChild(metaRevision);
+
+      expect(detectClientVersion()).toBe("ad65dc3");
+    });
+  });
+
   describe("isControlPlaneEnabled", () => {
     it("returns false by default (opt-in)", async () => {
       const { isControlPlaneEnabled } = await import("./initControlPlane.js");
@@ -800,6 +861,24 @@ describe("initControlPlane", () => {
       localStorage.removeItem("control_plane_transport");
     });
 
+    it("passes detected or custom version to ControlPlaneClient", () => {
+      const metaVersion = document.createElement("meta");
+      metaVersion.setAttribute("name", "version");
+      metaVersion.setAttribute("content", "1.27.1");
+      document.head.appendChild(metaVersion);
+
+      const client1 = createDefaultControlPlaneClient({ autoConnect: false });
+      expect((client1 as any).version).toBe("1.27.1");
+
+      const client2 = createDefaultControlPlaneClient({
+        autoConnect: false,
+        version: "custom-v2",
+      });
+      expect((client2 as any).version).toBe("custom-v2");
+
+      metaVersion.remove();
+    });
+
     it("manages active client lifecycle and autoConnect", () => {
       stopControlPlaneClient();
       expect(getActiveControlPlaneClient()).toBeNull();
@@ -811,4 +890,63 @@ describe("initControlPlane", () => {
       expect(getActiveControlPlaneClient()).toBeNull();
     });
   });
+
+  describe("ensureControlPlaneConnected", () => {
+    afterEach(() => {
+      stopControlPlaneClient();
+      localStorage.removeItem("control_plane_enabled");
+      localStorage.removeItem("control_plane_url");
+      localStorage.removeItem("control_plane_transport");
+    });
+
+    it("returns null when control plane is disabled", async () => {
+      localStorage.setItem("control_plane_enabled", "false");
+      const client = await ensureControlPlaneConnected();
+      expect(client).toBeNull();
+      expect(getActiveControlPlaneClient()).toBeNull();
+    });
+
+    it("syncs config from db to localStorage and connects when enabled", async () => {
+      const mockDb = {
+        transaction: () => ({
+          objectStore: () => ({
+            get: () => ({
+              onsuccess: null,
+              onerror: null,
+            }),
+          }),
+        }),
+      } as any;
+
+      // Mock getConfig
+      jest.unstable_mockModule("../../db/getConfig.js", () => ({
+        getConfig: jest.fn(async (_db: any, key: string) => {
+          if (key === "control_plane_enabled") return "true";
+          if (key === "control_plane_url") return "http://192.168.1.50:8888";
+          if (key === "control_plane_transport") return "websocket";
+          return undefined;
+        }),
+      }));
+
+      localStorage.removeItem("control_plane_enabled");
+      localStorage.removeItem("control_plane_url");
+
+      const client = await ensureControlPlaneConnected({ db: mockDb });
+      expect(client).not.toBeNull();
+      expect(getActiveControlPlaneClient()).toBe(client);
+      expect(localStorage.getItem("control_plane_enabled")).toBe("true");
+      expect(localStorage.getItem("control_plane_url")).toBe(
+        "http://192.168.1.50:8888",
+      );
+
+      // Subsequent call reuses active client and calls ensureConnected
+      const ensureConnectedSpy = jest.spyOn(client!, "ensureConnected");
+      const client2 = await ensureControlPlaneConnected({
+        db: mockDb,
+        force: true,
+      });
+      expect(client2).toBe(client);
+      expect(ensureConnectedSpy).toHaveBeenCalledWith(true);
+    });
+  });
 });

package/src/core/utils/initControlPlane.ts

@@ -202,11 +202,43 @@ export function detectDeviceLabel(): string {
   return `${device} ${browser}`;
 }
 
+export function detectClientVersion(): string {
+  let version = "";
+  let revision = "";
+
+  if (typeof document !== "undefined") {
+    version =
+      document
+        .querySelector('meta[name="version"]')
+        ?.getAttribute("content")
+        ?.trim() || "";
+    revision =
+      document
+        .querySelector('meta[name="revision"]')
+        ?.getAttribute("content")
+        ?.trim() || "";
+  }
+
+  const shortRevision = revision.length > 7 ? revision.slice(0, 7) : revision;
+
+  if (version && shortRevision) {
+    return `${version} (${shortRevision})`;
+  }
+  if (version) {
+    return version;
+  }
+  if (shortRevision) {
+    return shortRevision;
+  }
+  return "1.27.1";
+}
+
 export interface InitControlPlaneOptions {
   orchestrator?: any;
   clientId?: string;
   transport?: ControlPlaneTransport;
   autoConnect?: boolean;
+  version?: string;
 }
 
 let activeClient: ControlPlaneClient | null = null;
@@ -263,6 +295,7 @@ export async function executeClientControlCommand(
         clientId,
         deviceLabel,
         capabilities,
+        version: options.version || detectClientVersion(),
         activeGroupId:
           options.orchestrator?.activeGroupId ||
           orchestratorStore.activeGroupId ||
@@ -646,6 +679,7 @@ export function createDefaultControlPlaneClient(
     getOrCreateControlPlaneClientId();
   const capabilities = detectCapabilities();
   const deviceLabel = detectDeviceLabel();
+  const version = options.version || detectClientVersion();
 
   let configuredTransport: ControlPlaneTransport | null = null;
   if (typeof localStorage !== "undefined") {
@@ -678,6 +712,7 @@ export function createDefaultControlPlaneClient(
     clientId,
     deviceLabel,
     capabilities,
+    version,
     peerId,
     transport,
     httpUrl,
@@ -718,3 +753,50 @@ export function stopControlPlaneClient(): void {
     activeClient = null;
   }
 }
+
+export async function ensureControlPlaneConnected(
+  options: InitControlPlaneOptions & { db?: any; force?: boolean } = {},
+): Promise<ControlPlaneClient | null> {
+  let db = options.db;
+  if (!db) {
+    try {
+      db = await getDb();
+    } catch (_) {}
+  }
+
+  const enabled = await isControlPlaneEnabled(db);
+  if (!enabled) {
+    stopControlPlaneClient();
+    return null;
+  }
+
+  if (!shouldConnectControlPlane()) {
+    return null;
+  }
+
+  // Synchronize configuration from db to localStorage so synchronous lookups remain consistent
+  if (typeof localStorage !== "undefined" && db) {
+    try {
+      const { getConfig } = await import("../../db/getConfig.js");
+      const [url, transport] = await Promise.all([
+        getConfig(db, CONFIG_KEYS.CONTROL_PLANE_URL),
+        getConfig(db, CONFIG_KEYS.CONTROL_PLANE_TRANSPORT),
+      ]);
+      if (url) {
+        localStorage.setItem(CONFIG_KEYS.CONTROL_PLANE_URL, url);
+      }
+      if (transport) {
+        localStorage.setItem(CONFIG_KEYS.CONTROL_PLANE_TRANSPORT, transport);
+      }
+      localStorage.setItem(CONFIG_KEYS.CONTROL_PLANE_ENABLED, "true");
+    } catch (_) {}
+  }
+
+  const client = getActiveControlPlaneClient();
+  if (client) {
+    client.ensureConnected(options.force);
+    return client;
+  }
+
+  return createDefaultControlPlaneClient(options);
+}