@interopio/iocd-cli 1.1.2 → 1.1.3

package/changelog.md

@@ -5,6 +5,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.1.3](https://github.com/InteropIO/iocd-cli/compare/iocd-cli-v1.1.2...iocd-cli-v1.1.3) (2026-10-06)
+
+
+### Bug Fixes
+
+* **test:** harden seed testing skill and examples ([#124](https://github.com/InteropIO/iocd-cli/issues/124)) ([0ea68f4](https://github.com/InteropIO/iocd-cli/commit/0ea68f41079284feef624569b4da57cb9663c538))
+
 ## [1.1.2](https://github.com/InteropIO/iocd-cli/compare/iocd-cli-v1.1.1...iocd-cli-v1.1.2) (2026-09-23)
 
 

package/dist/templates/tests/.agents/skills/iocd-wdio-testing/SKILL.md

@@ -1,7 +1,6 @@
 ---
 name: iocd-wdio-testing
 description: 'Set up, write, run, and debug end-to-end WebdriverIO tests for an io.Connect Desktop (IOCD) seed project with @interopio/wdio-iocd-service. Use when adding or running IOCD/seed E2E tests, or testing apps, windows, Web Groups, Workspaces, Interop, Channels, Shared Contexts, Layouts, or Notifications in a running io.Connect Desktop platform.'
-argument-hint: 'Describe the IOCD behavior to test, or ask to set up tests'
 ---
 
 # io.Connect Desktop WebdriverIO Testing

package/dist/templates/tests/.agents/skills/iocd-wdio-testing/references/authoring.md

@@ -175,14 +175,20 @@ only when the target app permits it.
 Some renderer calls return a promise that settles only after the user answers a dialog or completes
 another UI workflow. Awaiting that promise while issuing the request blocks the test before it can
 perform the action that resolves the promise. Split the workflow into **start**, **interact**, and
-**collect** phases:
+**collect** phases. This example uses `ModalsDialog`; verify that the installed service exports it
+(see [models](./models.md)). Otherwise, implement the interaction in a local page object using the
+actual dialog DOM. `config`, `requesterWindow`, and `expectedResponse` are test-owned inputs.
 
 ```ts
+import { ModalsDialog } from "@interopio/wdio-iocd-service/models";
+
+type ModalOutcome = { settled: boolean; response?: unknown; error?: string };
+
 // In the app-window helper: start the request and return immediately.
 await browser.execute((requestConfig) => {
   const appWindow = window as typeof window & {
     io: { modals: { dialogs: { request(config: unknown): Promise<unknown> } } };
-    __modalOutcome?: { settled: boolean; response?: unknown; error?: string };
+    __modalOutcome?: ModalOutcome;
   };
 
   appWindow.__modalOutcome = { settled: false };
@@ -195,16 +201,24 @@ await browser.execute((requestConfig) => {
     });
 }, config);
 
-// Switch to the dialog and answer it through WebdriverIO or a service model.
+// Address the dialog raised by this requester and answer it.
+const dialog = ModalsDialog.forTarget(requesterWindow.id);
 await dialog.waitUntilOpen();
-await dialog.clickAction("confirm");
+await dialog.action("confirm").click();
 
 // Switch back to the requester, wait for settlement, then collect/assert the outcome.
 await browser.switchById(requesterWindow.id);
 await browser.waitUntil(
-  () => browser.execute(() => Boolean((window as any).__modalOutcome?.settled)),
+  () => browser.execute(() =>
+    Boolean((window as typeof window & { __modalOutcome?: ModalOutcome }).__modalOutcome?.settled)
+  ),
   { timeoutMsg: "Expected the modal request to settle" }
 );
+const outcome = await browser.execute(() =>
+  (window as typeof window & { __modalOutcome?: ModalOutcome }).__modalOutcome
+);
+expect(outcome?.error).to.equal(undefined);
+expect(outcome?.response).to.deep.equal(expectedResponse);
 ```
 
 Store both resolved and rejected outcomes, clean any app-owned request state after the test, and use
@@ -233,10 +247,13 @@ command only switches focus, it doesn't open the panel. See `notifications.spec.
 - **Wait for state, not time** — events, `browser.waitUntil`, element waits, or `waitFor`. Subscribe
   before triggering the action. For event APIs, use `waitForEvent` from `tests/tests/common/iocd.ts`:
   it filters events, times out with a useful message, and unsubscribes on success or timeout. Track
-  its idempotent `unsubscribe` in a cleanup registry so test failure can't leak the subscription.
+  its idempotent `unsubscribe` in a cleanup registry so test failure cancels the pending wait and
+  removes its timer and subscription. Always await `result` on the success path to assert delivery.
   Don't replace an unknown readiness condition with a fixed pause.
-- **Isolate** — create state in `beforeEach` or the test; clean everything in `afterEach`. Catch
-  cleanup errors only when the resource may already be gone.
+- **Isolate** — register cleanup immediately after each resource is created, before the next
+  fallible operation. Put all cleanup in one registry so a failed unsubscribe cannot prevent apps
+  from stopping or contexts from being destroyed. Catch cleanup errors only when the resource may
+  already be gone.
 - **Don't bypass the behavior under test** — drive the first app as a user would and observe the
   outcome in the receiver, rather than invoking application business logic directly from the test.
 - **One behavior per test**; run the new spec alone while iterating.

package/dist/templates/tests/.agents/skills/iocd-wdio-testing/references/configuration.md

@@ -29,7 +29,11 @@ platform the seed ships — you'd be testing something else. Behavior changes be
 `modifications/`; another *supported* configuration belongs in its own capability (below).
 
 The generated `config/system.json` registers `tests/tests/config/apps.json` as a path app store and
-isolates `folders.userData` to `tests/user-data` (disposable — never commit it or reuse its state).
+isolates `folders.userData` to `tests/user-data`. The test package's `.gitignore` excludes this
+generated profile; check older packages as described in [setup](./setup.md). It persists across
+launches, including cached SSO sessions, so tests must arrange their required state. Use separate
+profile directories for capabilities that require different authenticated users or independent
+persistent state. Never commit the profile or include it in CI artifacts.
 
 ## Tests that need extra config
 
@@ -81,9 +85,10 @@ Rules:
 - **One launch per capability, run sequentially** (`IOCDBaseConfiguration` sets `maxInstances: 1`).
   Budget a full platform startup + shutdown for each — group specs by configuration; never add a
   capability per spec.
-- **`npm test -- --spec <file>` overrides capability spec patterns**, so a single-spec run executes
-  that spec under *every* capability. Config-dependent specs must read the live config and skip when
-  it doesn't apply (below).
+- **`npm test -- --spec <file>` overrides capability spec patterns, but preserves exclusions.**
+  A selected spec runs under each capability that does not exclude it. In the example above, a
+  multi-Channel spec runs only under its variant, while a default spec also runs under the variant.
+  Config-dependent specs must read the live config and skip when it doesn't apply (below).
 
 ### Read the live config in a spec
 
@@ -114,8 +119,10 @@ the configuration that was actually found.
 A seed configured with an interactive login (`ssoAuth` in the system config) reports readiness only
 **after** someone signs in — without automation, `npm test` sits on the login window until the
 startup timeout and no spec runs. The service's `login` option drives that window while the
-platform boots. Requires `@interopio/wdio-iocd-service` 1.0.0-next.3+ (the version currently
-generated) and io.Connect Desktop 10.4+; older test packages must update `tests/package.json` first.
+platform boots. The option was introduced in `@interopio/wdio-iocd-service` 1.0.0-next.3; the handler
+API and supported platform versions vary by service release. Check the installed service's README
+and `dist/services/loginOptions.d.ts` before adapting a login flow. The example below uses the
+`LoginBrowser` API in 1.0.0-next.7, whose login discovery also supports platforms before 10.4.
 
 ```ts
 // tests/wdio.config.ts
@@ -125,8 +132,14 @@ services: IOCDService({
     handler: async (browser) => {
       const username = browser.$("#username");
       const password = browser.$("#password");
-      await username.waitForExist({ timeout: 30000 });
-      await password.waitForExist({ timeout: 30000 });
+      await browser.waitUntil(() => username.isExisting(), {
+        timeout: 30000,
+        timeoutMsg: "The login username field did not appear",
+      });
+      await browser.waitUntil(() => password.isExisting(), {
+        timeout: 30000,
+        timeoutMsg: "The login password field did not appear",
+      });
       await username.setValue(process.env.IOCD_TEST_USER!);
       await password.setValue(process.env.IOCD_TEST_PASSWORD!);
       await browser.$("button[type=submit]").click();
@@ -137,9 +150,12 @@ services: IOCDService({
 
 Rules:
 
-- **The handler runs before the platform is ready.** No `browser.io()`, no models — plain
-  WebdriverIO against the login page only. The WDIO globals (`browser`, `$`, `$$`) are set while it
-  runs, so page objects work.
+- **The handler runs before the platform is ready.** No `browser.io()` or models. In next.7 it
+  receives `LoginBrowser`, a subset of WebdriverIO driven over CDP. Use `$`, `getUrl`, `getTitle`,
+  `waitUntil`, and `execute`; its elements support `setValue`, `click`, `getText`, `getValue`,
+  `isExisting`, and `waitUntil`. Check the installed `dist/services/loginBrowser.d.ts` for the
+  supported surface. WDIO globals resolve during the handler, but `$$` throws and element methods
+  such as `waitForExist` are unavailable. Page objects must use only the supported subset.
 - **The signed-in session belongs to the platform process**, so the apps under test are
   authenticated exactly as in production.
 - **Credentials come from env vars / CI secrets** — never from specs or config files.
@@ -155,10 +171,17 @@ Rules:
 
 ## Add an optional IO library
 
-1. Add the package to `tests/package.json`.
+For libraries that support the worker's Node context:
+
+1. Add the package to `tests/package.json` and install it in the test package.
 2. Add its module specifier to `iocd:options.ioInitOptions.libraries` in `tests/wdio.config.ts`.
 3. Use it via `browser.io()` (optional sub-APIs need `!`).
 
+Renderer-scoped libraries, such as a Modals client that requires an app window, must be installed
+and initialized in a real fixture or application window. Adding them to the worker's `libraries`
+does not supply that window context. See [authoring](./authoring.md#worker-api-vs-app-window-apis)
+for the readiness and interaction pattern.
+
 ## Runners
 
 `platform-wdio` is the default (specs run Node-side and drive the app remotely). `platform-window`,

package/dist/templates/tests/.agents/skills/iocd-wdio-testing/references/models.md

@@ -1,27 +1,29 @@
 # Built-in IOCD UI Models
 
 `@interopio/wdio-iocd-service/models` exports page objects for built-in web UI owned by IOCD. Use
-them for Web Groups, captions, tabs, Channel Selectors, and similar platform surfaces. Use normal
-WebdriverIO selectors for UI owned by the client app.
+available models for Web Groups, captions, tabs, Channel Selectors, dialogs, and other platform
+surfaces. Use normal WebdriverIO selectors for UI owned by the client app.
 
-Models hide generated element IDs and DOM structure behind semantic operations such as
-`group.switchTo()`, `group.frames.waitForCount()`, `tab.close()`, and `waitForDisplayed()`. They also
-handle the WebDriver context and waits expected by the built-in surface. Prefer an available model
-over copying internal IOCD selectors into a spec.
+## Inspect the installed version first
 
-## Current Generated Version
+The generated test package requests the service's `next` tag, so its available models can change
+between installations. The installed package and lockfile are the source of truth. Before choosing
+or importing a model, read these files from the test package:
 
-The generated test package currently pins `@interopio/wdio-iocd-service@1.0.0-next.4`. Its
-`@interopio/wdio-iocd-service/models` subpath exports:
+```text
+tests/node_modules/@interopio/wdio-iocd-service/package.json
+tests/node_modules/@interopio/wdio-iocd-service/dist/models/index.d.ts
+```
 
-| Area | Models and types |
-| --- | --- |
-| Group and frames | `Group`, `Frame`, `WebGroupElement` |
-| Captions and tabs | `CaptionBar`, `Caption`, `Editor`, `MoveArea`, `TabBar`, `TabHeader`, `Tab`, `Tabs`, `PinnedTabs` |
-| Caption controls | `ChannelSelector`, `CloseButton`, `HtmlButtons`, `ButtonsContainer`, `StandardButton`, `StandardButtons`, `CustomButton`, `CustomButtons` |
-| Sizing and snapping | `SizingBorderGroup`, `SizingBorderOrientation`, `SizingBorder`, `SizingBorderType`, `ApproachingMarker`, and the `NeighborFrames` type |
+Then follow the export to its declaration file for constructor arguments, methods, waits, and
+window-context behavior. Check for a suitable popup or dialog model before writing handle-scanning
+helpers or copying internal selectors. Do not assume that a model shown in another repository or
+service version exists locally, or that a missing model in an older version is still unavailable.
 
-For example:
+## Web Group example
+
+The generated Channel Selector spec demonstrates the `Group` model. After verifying its installed
+signature:
 
 ```ts
 import { Group } from "@interopio/wdio-iocd-service/models";
@@ -34,19 +36,10 @@ await frame.captionBar.channelSelector.waitForDisplayed();
 await frame.captionBar.channelSelector.click();
 ```
 
-## Version Rule
-
-The installed package is the source of truth. Before using a model, read:
-
-```text
-tests/node_modules/@interopio/wdio-iocd-service/dist/models/index.d.ts
-```
-
-Do not copy a model import from another repository or a newer service release without checking that
-it exists locally. Newer versions may add models such as `ChannelSelectorPopup`, `PlatformDialog`,
-`ModalsDialog`, or `Alert`; those names aren't exported by the version currently generated in the
-seed.
+Models hide generated IDs and DOM structure behind semantic operations and provide the waits and
+context switching supported by that version. Read their declarations before mixing model calls
+with raw `browser.switchById()` or `browser.switchToWindow()` calls.
 
-Models reduce direct coupling to built-in markup, but remain coupled to the matching Desktop and
-service versions. If no suitable model is exported, prefer a stable `data-testid`, role, or other
-semantic selector and keep the version-sensitive selector in one local page object.
+Models remain coupled to the matching Desktop and service versions. If no suitable model is
+exported, prefer a stable `data-testid`, role, or other semantic selector and keep any
+version-sensitive selector in one local page object.

package/dist/templates/tests/.agents/skills/iocd-wdio-testing/references/setup.md

@@ -13,9 +13,9 @@ npm test
 ```
 
 On the first run the CLI installs the nested test package's dependencies, resolves the executable
-from the configured `iocd` component, and passes its path to WebdriverIO via `BINARY_PATH`. If the
-executable isn't available yet, start the seed once with `npm run dev`, close it, then run `npm test`
-(the service launches and manages its own platform instance). The CLI also makes
+from the configured `iocd` component, and passes its path to WebdriverIO via `BINARY_PATH`. The CLI
+applies the seed's dev modifications before the service launches its own platform instance. If the
+component or executable is missing, run `npm run setup` to install it. The CLI also makes
 `config/iocd.license.key` available to the test platform — keep the license out of specs, config,
 logs, and source control.
 
@@ -32,6 +32,18 @@ version. Fall back to `npx @interopio/iocd-cli@latest test setup` only when the
 on the CLI. Setup creates the test package and the agent skill, installs the test dependencies, and validates the
 setup with the TypeScript compiler. On failure it removes the files it created.
 
+## Existing test package
+
+Check that the test package's `.gitignore` contains `user-data/`. Add that entry if it is missing;
+older scaffolds did not include it. From the seed root, verify it with
+`git check-ignore tests/user-data/Default/Cookies` (substitute the configured `testsDirectory`).
+This path can be checked without creating or reading a cookie file. If the profile is already
+tracked, an ignore rule does not untrack it: remove only that generated directory from the Git index
+with `git rm -r --cached -- tests/user-data`, substituting the configured `testsDirectory` here too
+and keeping its local files. For example, `testsDirectory: "quality/e2e"` requires
+`git rm -r --cached -- quality/e2e/user-data`. Never include profile data in commits or CI artifacts;
+it can contain authenticated sessions.
+
 ## Replacing an existing test package
 
 The CLI never overwrites or migrates an existing test directory. To replace one:
@@ -46,6 +58,7 @@ The CLI never overwrites or migrates an existing test directory. To replace one:
 
 ```text
 tests/                         # test package (Node.js)
+├── .gitignore                 # excludes the generated user-data profile
 ├── package.json
 ├── tsconfig.json
 ├── wdio.config.ts             # WebdriverIO + IOCDService config (platform-wdio runner)

package/dist/templates/tests/tests/.gitignore.template

@@ -0,0 +1 @@
+user-data/

package/dist/templates/tests/tests/README.md

@@ -30,6 +30,7 @@ npm run typecheck
 
 - `wdio.config.ts` — WebdriverIO + `IOCDService` configuration (the `platform-wdio` runner).
 - `config/system.json` — test-only overrides applied to the test process.
+- `.gitignore` — excludes the disposable `user-data/` browser profile from version control.
 - `tests/common/iocd.ts` — polling, event-waiting, and cleanup-registry helpers.
 - `tests/config/apps.json` — fixture app definitions.
 - `tests/assets/applications/` — static fixture app HTML.
@@ -75,7 +76,8 @@ platform, so group specifications by configuration rather than adding a capabili
 the variant specifications from the default capability so they don't run twice, keep the default
 capability on the configuration the seed ships, and let a configuration-dependent specification read
 `globalThis.ioCDPlatformConfig` at `describe` time to skip when it isn't running under its own
-capability (`npm test -- --spec` overrides the capability spec patterns).
+capability (`npm test -- --spec` overrides capability spec patterns, but capability exclusions
+still apply).
 
 ## Sample specifications
 
@@ -117,5 +119,5 @@ package. Use ordinary WebdriverIO selectors for UI owned by your app.
 
 ## More
 
-- Full guide: the **Testing** section of the io.Connect Desktop seed-project documentation.
+- Full guide: [Testing in the io.Connect Desktop seed-project documentation](https://docs.interop.io/desktop/developers/seed-project/index.html#testing).
 - Coding-agent guidance: `.agents/skills/iocd-wdio-testing/` at the seed root.

package/dist/templates/tests/tests/tests/common/iocd.ts

@@ -25,16 +25,20 @@ export function createCleanupRegistry() {
     async run(): Promise<void> {
       const pending = cleanups.splice(0).reverse();
       let firstError: unknown;
+      let failed = false;
 
       for (const cleanup of pending) {
         try {
           await cleanup();
         } catch (error) {
-          firstError ??= error;
+          if (!failed) {
+            firstError = error;
+            failed = true;
+          }
         }
       }
 
-      if (firstError) {
+      if (failed) {
         throw firstError;
       }
     },
@@ -59,67 +63,83 @@ export async function waitForEvent<T>(
 
   let resolveResult!: (value: T) => void;
   let rejectResult!: (error: Error) => void;
-  let subscriptionCleanup: Cleanup | undefined;
-  let cleanupRequested = false;
+  let cleanupPromise: Promise<void> | undefined;
   let settled = false;
 
   const result = new Promise<T>((resolve, reject) => {
     resolveResult = resolve;
     rejectResult = reject;
   });
+  // The trigger can fail or outlast the timeout before the caller awaits result.
+  // Observe rejection immediately, without changing what awaiting result throws.
+  void result.catch(() => undefined);
 
-  const unsubscribe: Cleanup = async () => {
-    if (!subscriptionCleanup) {
-      cleanupRequested = true;
-      return;
-    }
-
-    const cleanup = subscriptionCleanup;
-    subscriptionCleanup = undefined;
-    await cleanup();
+  const cleanupSubscription = (): Promise<void> => {
+    cleanupPromise ??= subscription.then(cleanup => cleanup());
+    return cleanupPromise;
   };
 
-  const timeout = setTimeout(() => {
+  const finish = (outcome: { value: T } | { error: Error }): void => {
     if (settled) {
       return;
     }
 
     settled = true;
-    void (async () => {
-      try {
-        await unsubscribe();
-      } finally {
-        rejectResult(new Error(timeoutMsg));
+    clearTimeout(timeout);
+    void cleanupSubscription().then(
+      () => {
+        if ("error" in outcome) {
+          rejectResult(outcome.error);
+        } else {
+          resolveResult(outcome.value);
+        }
+      },
+      (error: unknown) => {
+        rejectResult("error" in outcome ? outcome.error : toError(error));
       }
-    })().catch(() => undefined);
-  }, timeoutMs);
+    );
+  };
 
-  try {
-    subscriptionCleanup = await subscribe((value) => {
-      if (settled || !predicate(value)) {
+  const timeout = setTimeout(
+    () => finish({ error: new Error(timeoutMsg) }),
+    timeoutMs
+  );
+  // Start in a microtask so even a synchronous callback can wait for the returned
+  // unsubscribe function. Success must not hide an error from delayed cleanup.
+  const subscription = Promise.resolve().then(() =>
+    subscribe(value => {
+      if (settled) {
         return;
       }
 
-      settled = true;
-      clearTimeout(timeout);
-      void (async () => {
-        try {
-          await unsubscribe();
-          resolveResult(value);
-        } catch (error) {
-          rejectResult(error instanceof Error ? error : new Error(String(error)));
+      try {
+        if (predicate(value)) {
+          finish({ value });
         }
-      })();
-    });
+      } catch (error) {
+        finish({ error: toError(error) });
+      }
+    })
+  );
 
-    if (cleanupRequested) {
-      await unsubscribe();
+  const unsubscribe: Cleanup = async () => {
+    if (!settled) {
+      settled = true;
+      clearTimeout(timeout);
+      rejectResult(new Error("Event wait was cancelled."));
     }
+    await cleanupSubscription();
+  };
+
+  try {
+    await subscription;
   } catch (error) {
-    settled = true;
-    clearTimeout(timeout);
-    rejectResult(error instanceof Error ? error : new Error(String(error)));
+    finish({ error: toError(error) });
   }
 
   return { result, unsubscribe };
-}
+}
+
+function toError(error: unknown): Error {
+  return error instanceof Error ? error : new Error(String(error));
+}

package/dist/templates/tests/tests/tests/shared-contexts.spec.ts

@@ -1,5 +1,4 @@
 import { expect } from "chai";
-import type { IOConnectDesktop } from "@interopio/desktop";
 import { $, browser } from "@wdio/globals";
 import { createCleanupRegistry, waitForEvent } from "./common/iocd";
 
@@ -8,21 +7,19 @@ import { createCleanupRegistry, waitForEvent } from "./common/iocd";
 describe("Shared Contexts", () => {
   const contextName = "IOCD.Sample.SelectedClient";
   const clientName = "Ada Lovelace";
-  let instances: IOConnectDesktop.AppManager.Instance[] = [];
   let cleanups = createCleanupRegistry();
 
   beforeEach(async () => {
     const io = await browser.io();
     cleanups = createCleanupRegistry();
+    // Register first so the context is removed after subscriptions and apps.
+    cleanups.add(() => io.contexts.destroy(contextName).catch(() => undefined));
     await io.contexts.destroy(contextName).catch(() => undefined);
   });
 
   afterEach(async () => {
-    const io = await browser.io();
+    // The registry attempts every cleanup, even when an earlier one fails.
     await cleanups.run();
-    await Promise.all(instances.map((instance) => instance.stop().catch(() => undefined)));
-    instances = [];
-    await io.contexts.destroy(contextName).catch(() => undefined);
   });
 
   it("delivers an update from one app instance to another", async () => {
@@ -30,25 +27,30 @@ describe("Shared Contexts", () => {
     const app = io.appManager.application("shared-context-client")!;
 
     const publisher = await app.start({}, { title: "Context Publisher" });
+    cleanups.add(() => publisher.stop());
     const subscriber = await app.start({}, { title: "Context Subscriber" });
-    instances = [publisher, subscriber];
+    cleanups.add(() => subscriber.stop());
 
     const publisherWindow = await publisher.getWindow();
     const subscriberWindow = await subscriber.getWindow();
 
     // Wait until the receiving app has subscribed before publishing the update.
     await browser.switchById(subscriberWindow.id);
-    await browser.waitUntil(async () => (await $("#context-status").getText()) === "Ready", {
-      timeoutMsg: "Expected the subscriber app to initialize its Shared Context subscription",
-    });
+    await browser.waitUntil(
+      async () => (await $("#context-status").getText()) === "Ready",
+      {
+        timeoutMsg:
+          "Expected the subscriber app to initialize its Shared Context subscription",
+      }
+    );
 
     const contextUpdate = await waitForEvent<{ clientName?: string }>(
-      (listener) =>
-        io.contexts.subscribe(contextName, (data) => {
+      listener =>
+        io.contexts.subscribe(contextName, data => {
           listener(data as { clientName?: string });
         }),
       {
-        predicate: (data) => data.clientName === clientName,
+        predicate: data => data.clientName === clientName,
         timeoutMsg: `Expected the ${contextName} context to select ${clientName}`,
       }
     );
@@ -62,10 +64,13 @@ describe("Shared Contexts", () => {
 
     await browser.switchById(subscriberWindow.id);
     const selectedClient = await $("#selected-client");
-    await browser.waitUntil(async () => (await selectedClient.getText()) === clientName, {
-      timeoutMsg: `Expected the subscriber app to receive ${clientName}`,
-    });
+    await browser.waitUntil(
+      async () => (await selectedClient.getText()) === clientName,
+      {
+        timeoutMsg: `Expected the subscriber app to receive ${clientName}`,
+      }
+    );
 
     expect(await selectedClient.getText()).to.equal(clientName);
   });
-});
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@interopio/iocd-cli",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "CLI tool for setting up, building and packaging io.Connect Desktop platforms",
   "engines": {
     "node": ">=22.0.0",