@vellumai/assistant 0.8.1 → 0.8.3

package/src/__tests__/host-app-control-proxy.test.ts

@@ -27,10 +27,8 @@ interface RegisteredInteraction {
 const registeredInteractions: RegisteredInteraction[] = [];
 
 mock.module("../runtime/pending-interactions.js", () => ({
-  register: (
-    _requestId: string,
-    entry: RegisteredInteraction,
-  ) => registeredInteractions.push(entry),
+  register: (_requestId: string, entry: RegisteredInteraction) =>
+    registeredInteractions.push(entry),
   resolve: (requestId: string) => {
     resolvedInteractionIds.push(requestId);
     return undefined;
@@ -44,6 +42,7 @@ mock.module("../runtime/pending-interactions.js", () => ({
 const {
   HostAppControlProxy,
   _getActiveAppControlSession,
+  _getConfirmedAppControlSession,
   _resetActiveAppControlSession,
   _setActiveAppControlSession,
 } = await import("../daemon/host-app-control-proxy.js");
@@ -594,6 +593,504 @@ describe("HostAppControlProxy", () => {
     });
   });
 
+  // -------------------------------------------------------------------------
+  // (c.1) Failed re-start restores the prior session
+  // -------------------------------------------------------------------------
+
+  describe("failed re-start restores prior session", () => {
+    test("non-running re-start in the same conversation restores the prior session", async () => {
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctrl = new AbortController();
+
+      // Establish an active session targeting the editor.
+      const p1 = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.editor" },
+        "conv-1",
+        ctrl.signal,
+      );
+      proxy.resolve(
+        (sentMessages[0] as Record<string, unknown>).requestId as string,
+        payload({ pngBase64: PNG_A }),
+      );
+      await p1;
+      expect(_getActiveAppControlSession()?.app).toBe("com.example.editor");
+
+      // Re-start against a different app — host returns "missing".
+      sentMessages.length = 0;
+      const p2 = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.other" },
+        "conv-1",
+        ctrl.signal,
+      );
+      proxy.resolve(
+        (sentMessages[0] as Record<string, unknown>).requestId as string,
+        payload({ state: "missing" }),
+      );
+      await p2;
+
+      // Prior session restored (editor) — not stranded as undefined and not
+      // overwritten with the failed re-start target.
+      const session = _getActiveAppControlSession();
+      expect(session?.conversationId).toBe("conv-1");
+      expect(session?.app).toBe("com.example.editor");
+
+      proxy.dispose();
+    });
+
+    test("dispatch failure on re-start in the same conversation restores the prior session", async () => {
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctrl = new AbortController();
+
+      const p1 = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.editor" },
+        "conv-1",
+        ctrl.signal,
+      );
+      proxy.resolve(
+        (sentMessages[0] as Record<string, unknown>).requestId as string,
+        payload({ pngBase64: PNG_A }),
+      );
+      await p1;
+      expect(_getActiveAppControlSession()?.app).toBe("com.example.editor");
+
+      // Re-start against a different app, then abort before the host
+      // responds. The catch path in `request()` should restore the prior
+      // session rather than stranding the lock.
+      sentMessages.length = 0;
+      const reCtrl = new AbortController();
+      const p2 = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.other" },
+        "conv-1",
+        reCtrl.signal,
+      );
+      reCtrl.abort();
+      const r = await p2;
+      expect(r.isError).toBe(true);
+      expect(r.content).toContain("Aborted");
+
+      const session = _getActiveAppControlSession();
+      expect(session?.conversationId).toBe("conv-1");
+      expect(session?.app).toBe("com.example.editor");
+
+      proxy.dispose();
+    });
+
+    test("late-failing start does not clobber a newer successful start (out-of-order rollback)", async () => {
+      // Overlapping starts from the same conversation where the older one
+      // fails AFTER the newer succeeds. Identity-keyed rollback must make
+      // the stale failure a no-op rather than restoring the pre-A session.
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctrl = new AbortController();
+
+      // Establish prior session A.
+      const pA = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.a" },
+        "conv-1",
+        ctrl.signal,
+      );
+      const reqIdA = (sentMessages[0] as Record<string, unknown>)
+        .requestId as string;
+      proxy.resolve(reqIdA, payload({ pngBase64: PNG_A }));
+      await pA;
+      expect(_getActiveAppControlSession()?.app).toBe("com.example.a");
+
+      // Start B is dispatched but its host response is delayed.
+      sentMessages.length = 0;
+      const pB = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.b" },
+        "conv-1",
+        ctrl.signal,
+      );
+      const reqIdB = (sentMessages[0] as Record<string, unknown>)
+        .requestId as string;
+
+      // Start C overtakes B and succeeds first.
+      sentMessages.length = 0;
+      const pC = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.c" },
+        "conv-1",
+        ctrl.signal,
+      );
+      const reqIdC = (sentMessages[0] as Record<string, unknown>)
+        .requestId as string;
+      proxy.resolve(reqIdC, payload({ pngBase64: PNG_A }));
+      await pC;
+      expect(_getActiveAppControlSession()?.app).toBe("com.example.c");
+
+      // Now B finally fails — rollback must NOT restore A or clobber C.
+      proxy.resolve(reqIdB, payload({ state: "missing" }));
+      await pB;
+
+      const session = _getActiveAppControlSession();
+      expect(session?.conversationId).toBe("conv-1");
+      expect(session?.app).toBe("com.example.c");
+
+      proxy.dispose();
+    });
+
+    test("both-fail overlapping starts release the lock (no phantom session)", async () => {
+      // Two same-conversation starts overlap, both fail. The later
+      // rollback must release the lock instead of resurrecting the
+      // earlier (never-confirmed) optimistic write.
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctrl = new AbortController();
+
+      const pA = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.a" },
+        "conv-1",
+        ctrl.signal,
+      );
+      const reqIdA = (sentMessages[0] as Record<string, unknown>)
+        .requestId as string;
+
+      sentMessages.length = 0;
+      const pC = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.c" },
+        "conv-1",
+        ctrl.signal,
+      );
+      const reqIdC = (sentMessages[0] as Record<string, unknown>)
+        .requestId as string;
+      expect(_getActiveAppControlSession()?.app).toBe("com.example.c");
+
+      // A fails first — identity check makes it a no-op (C is live).
+      proxy.resolve(reqIdA, payload({ state: "missing" }));
+      await pA;
+      expect(_getActiveAppControlSession()?.app).toBe("com.example.c");
+
+      // C fails second — must roll back to confirmed (undefined), not
+      // to A's never-confirmed optimistic write.
+      proxy.resolve(reqIdC, payload({ state: "missing" }));
+      await pC;
+
+      expect(_getActiveAppControlSession()).toBeUndefined();
+
+      proxy.dispose();
+    });
+
+    test("late running confirmation from older overlapping start is preserved", async () => {
+      // Same-conversation overlapping starts where the older one's `running`
+      // response arrives AFTER a newer optimistic start has superseded it,
+      // and the newer one then fails. The host has actually confirmed A as
+      // running, so the lock must remain held for A rather than going
+      // undefined and desyncing from the host.
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctrl = new AbortController();
+
+      // A is dispatched; do not resolve yet.
+      const pA = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.a" },
+        "conv-1",
+        ctrl.signal,
+      );
+      const reqIdA = (sentMessages[0] as Record<string, unknown>)
+        .requestId as string;
+
+      // C is dispatched, overwriting the optimistic active pointer to C.
+      sentMessages.length = 0;
+      const pC = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.c" },
+        "conv-1",
+        ctrl.signal,
+      );
+      const reqIdC = (sentMessages[0] as Record<string, unknown>)
+        .requestId as string;
+      expect(_getActiveAppControlSession()?.app).toBe("com.example.c");
+
+      // A finally returns running — by object identity active is no longer A,
+      // but the host has confirmed A so we must still record it as confirmed.
+      proxy.resolve(reqIdA, payload({ pngBase64: PNG_A }));
+      await pA;
+      // Active is still the newer optimistic C; nothing has rolled it back.
+      expect(_getActiveAppControlSession()?.app).toBe("com.example.c");
+
+      // C fails — rollback must restore active to A (the current confirmed),
+      // not to undefined (the snapshot prior at C's dispatch time).
+      proxy.resolve(reqIdC, payload({ state: "missing" }));
+      await pC;
+
+      const session = _getActiveAppControlSession();
+      expect(session?.conversationId).toBe("conv-1");
+      expect(session?.app).toBe("com.example.a");
+
+      proxy.dispose();
+    });
+
+    test("both-succeed older-arrives-last does not overwrite newer confirmed session", async () => {
+      // Two same-conversation starts both succeed, but the older one's
+      // `running` response arrives AFTER the newer one's. With a
+      // conversation-only ownership guard, the older response would
+      // overwrite the newer confirmed session — a latent bug that surfaces
+      // on a subsequent rollback. Verify the confirmed pointer stays on the
+      // newer session (C), and that a later rollback restores to C, not A.
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctrl = new AbortController();
+
+      const pA = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.a" },
+        "conv-1",
+        ctrl.signal,
+      );
+      const reqIdA = (sentMessages[0] as Record<string, unknown>)
+        .requestId as string;
+
+      sentMessages.length = 0;
+      const pC = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.c" },
+        "conv-1",
+        ctrl.signal,
+      );
+      const reqIdC = (sentMessages[0] as Record<string, unknown>)
+        .requestId as string;
+      expect(_getActiveAppControlSession()?.app).toBe("com.example.c");
+
+      // C succeeds first → active = C, confirmed = C.
+      proxy.resolve(reqIdC, payload({ pngBase64: PNG_A }));
+      await pC;
+      expect(_getActiveAppControlSession()?.app).toBe("com.example.c");
+      expect(_getConfirmedAppControlSession()?.app).toBe("com.example.c");
+
+      // A succeeds second (older arrives last). The conversation-ownership
+      // check passes for A, but A is no longer the live optimistic write
+      // and a session is already confirmed — must NOT overwrite confirmed.
+      proxy.resolve(reqIdA, payload({ pngBase64: PNG_B }));
+      await pA;
+      expect(_getConfirmedAppControlSession()?.app).toBe("com.example.c");
+      expect(_getActiveAppControlSession()?.app).toBe("com.example.c");
+
+      // A later restart D that fails must roll back to C (the true
+      // confirmed), not to A — guards against the latent-bug case.
+      sentMessages.length = 0;
+      const pD = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.d" },
+        "conv-1",
+        ctrl.signal,
+      );
+      const reqIdD = (sentMessages[0] as Record<string, unknown>)
+        .requestId as string;
+      proxy.resolve(reqIdD, payload({ state: "missing" }));
+      await pD;
+
+      const session = _getActiveAppControlSession();
+      expect(session?.conversationId).toBe("conv-1");
+      expect(session?.app).toBe("com.example.c");
+
+      proxy.dispose();
+    });
+
+    test("rollback after confirmed-A,dispatch-B,dispatch-C,B-confirms,C-fails restores B (Codex P2)", async () => {
+      // A is confirmed, then B and C are dispatched. B's `running` arrives
+      // while C is the live write; under the dispatch-counter rule that
+      // confirmation must promote because B is newer than A. A subsequent
+      // failure of C must then roll back to B, not back to A.
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctrl = new AbortController();
+
+      const pA = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.a" },
+        "conv-1",
+        ctrl.signal,
+      );
+      const reqIdA = (sentMessages[0] as Record<string, unknown>)
+        .requestId as string;
+      proxy.resolve(reqIdA, payload({ pngBase64: PNG_A }));
+      await pA;
+      expect(_getConfirmedAppControlSession()?.app).toBe("com.example.a");
+
+      sentMessages.length = 0;
+      const pB = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.b" },
+        "conv-1",
+        ctrl.signal,
+      );
+      const reqIdB = (sentMessages[0] as Record<string, unknown>)
+        .requestId as string;
+
+      sentMessages.length = 0;
+      const pC = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.c" },
+        "conv-1",
+        ctrl.signal,
+      );
+      const reqIdC = (sentMessages[0] as Record<string, unknown>)
+        .requestId as string;
+      expect(_getActiveAppControlSession()?.app).toBe("com.example.c");
+
+      // B confirms (newer than A): confirmed should move to B even though
+      // C is the live optimistic write.
+      proxy.resolve(reqIdB, payload({ pngBase64: PNG_B }));
+      await pB;
+      expect(_getConfirmedAppControlSession()?.app).toBe("com.example.b");
+      expect(_getActiveAppControlSession()?.app).toBe("com.example.c");
+
+      // C fails → rollback restores to confirmed (B), not A.
+      proxy.resolve(reqIdC, payload({ state: "missing" }));
+      await pC;
+      const session = _getActiveAppControlSession();
+      expect(session?.conversationId).toBe("conv-1");
+      expect(session?.app).toBe("com.example.b");
+
+      proxy.dispose();
+    });
+
+    test("three-overlapping-starts A-confirms,B-confirms,C-fails restores B (Devin P2)", async () => {
+      // A, B, C dispatched in order with no prior confirmed session.
+      // A confirms first (confirmed = A), B confirms second (confirmed
+      // must move forward to B because B is newer), C fails → rollback
+      // restores to B, not A.
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctrl = new AbortController();
+
+      const pA = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.a" },
+        "conv-1",
+        ctrl.signal,
+      );
+      const reqIdA = (sentMessages[0] as Record<string, unknown>)
+        .requestId as string;
+
+      sentMessages.length = 0;
+      const pB = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.b" },
+        "conv-1",
+        ctrl.signal,
+      );
+      const reqIdB = (sentMessages[0] as Record<string, unknown>)
+        .requestId as string;
+
+      sentMessages.length = 0;
+      const pC = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.c" },
+        "conv-1",
+        ctrl.signal,
+      );
+      const reqIdC = (sentMessages[0] as Record<string, unknown>)
+        .requestId as string;
+      expect(_getActiveAppControlSession()?.app).toBe("com.example.c");
+
+      proxy.resolve(reqIdA, payload({ pngBase64: PNG_A }));
+      await pA;
+      expect(_getConfirmedAppControlSession()?.app).toBe("com.example.a");
+
+      proxy.resolve(reqIdB, payload({ pngBase64: PNG_B }));
+      await pB;
+      expect(_getConfirmedAppControlSession()?.app).toBe("com.example.b");
+      expect(_getActiveAppControlSession()?.app).toBe("com.example.c");
+
+      proxy.resolve(reqIdC, payload({ state: "missing" }));
+      await pC;
+      const session = _getActiveAppControlSession();
+      expect(session?.conversationId).toBe("conv-1");
+      expect(session?.app).toBe("com.example.b");
+
+      proxy.dispose();
+    });
+
+    test("confirmed-A,dispatch-B,dispatch-C,C-fails-first,B-confirms syncs active to B", async () => {
+      // A confirmed, B and C dispatched, C returns `missing` first →
+      // rollback restores active to A. Then B returns `running` →
+      // confirmed advances to B; active must advance alongside it,
+      // otherwise the tool reports B started while
+      // app_control_observe/actions for B target A.
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctrl = new AbortController();
+
+      const pA = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.a" },
+        "conv-1",
+        ctrl.signal,
+      );
+      const reqIdA = (sentMessages[0] as Record<string, unknown>)
+        .requestId as string;
+      proxy.resolve(reqIdA, payload({ pngBase64: PNG_A }));
+      await pA;
+      expect(_getConfirmedAppControlSession()?.app).toBe("com.example.a");
+
+      sentMessages.length = 0;
+      const pB = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.b" },
+        "conv-1",
+        ctrl.signal,
+      );
+      const reqIdB = (sentMessages[0] as Record<string, unknown>)
+        .requestId as string;
+
+      sentMessages.length = 0;
+      const pC = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.c" },
+        "conv-1",
+        ctrl.signal,
+      );
+      const reqIdC = (sentMessages[0] as Record<string, unknown>)
+        .requestId as string;
+      expect(_getActiveAppControlSession()?.app).toBe("com.example.c");
+
+      // C fails first → rollback restores active to confirmed (A).
+      proxy.resolve(reqIdC, payload({ state: "missing" }));
+      await pC;
+      expect(_getActiveAppControlSession()?.app).toBe("com.example.a");
+      expect(_getConfirmedAppControlSession()?.app).toBe("com.example.a");
+
+      // B confirms after C's rollback. Confirmed advances to B AND active
+      // must advance to B too — otherwise non-start tool calls against B
+      // would be rejected because active still targets A.
+      proxy.resolve(reqIdB, payload({ pngBase64: PNG_B }));
+      await pB;
+      expect(_getConfirmedAppControlSession()?.app).toBe("com.example.b");
+      const session = _getActiveAppControlSession();
+      expect(session?.conversationId).toBe("conv-1");
+      expect(session?.app).toBe("com.example.b");
+
+      proxy.dispose();
+    });
+
+    test("first-start failure releases the lock (no prior session to restore)", async () => {
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctrl = new AbortController();
+
+      // No prior session; re-start the first time and get a non-running.
+      const p1 = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.editor" },
+        "conv-1",
+        ctrl.signal,
+      );
+      proxy.resolve(
+        (sentMessages[0] as Record<string, unknown>).requestId as string,
+        payload({ state: "missing" }),
+      );
+      await p1;
+
+      // Lock released so another conversation can acquire.
+      expect(_getActiveAppControlSession()).toBeUndefined();
+
+      proxy.dispose();
+    });
+  });
+
   // -------------------------------------------------------------------------
   // (d) dispose releases the lock
   // -------------------------------------------------------------------------
@@ -805,8 +1302,8 @@ describe("HostAppControlProxy", () => {
         { tool: "observe", app: "com.example.app" },
         "conv-1",
         ctrl.signal,
-        "actor-principal-1",    // sourceActorPrincipalId
-        "client-A",             // targetClientId
+        "actor-principal-1", // sourceActorPrincipalId
+        "client-A", // targetClientId
       );
 
       expect(sentMessages).toHaveLength(1);
@@ -840,8 +1337,8 @@ describe("HostAppControlProxy", () => {
         { tool: "observe", app: "com.example.app" },
         "conv-1",
         ctrl.signal,
-        "user-1",    // sourceActorPrincipalId
-        "client-A",  // targetClientId → hub resolves actorPrincipalId = "user-1"
+        "user-1", // sourceActorPrincipalId
+        "client-A", // targetClientId → hub resolves actorPrincipalId = "user-1"
       );
 
       const sent = sentMessages[0] as Record<string, unknown>;
@@ -863,8 +1360,8 @@ describe("HostAppControlProxy", () => {
         { tool: "start", app: "com.example.app" },
         "conv-1",
         ctrl.signal,
-        "user-1",    // sourceActorPrincipalId
-        undefined,   // no targetClientId
+        "user-1", // sourceActorPrincipalId
+        undefined, // no targetClientId
       );
 
       const sent = sentMessages[0] as Record<string, unknown>;