@interopio/iocd-cli 0.0.91 → 1.0.0

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

@@ -0,0 +1,71 @@
+import { expect } from "chai";
+import type { IOConnectDesktop } from "@interopio/desktop";
+import { $, browser } from "@wdio/globals";
+import { createCleanupRegistry, waitForEvent } from "./common/iocd";
+
+// Starts two instances of the same client app, publishes a Shared Context update
+// from one instance, and verifies that the other instance renders the update.
+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();
+    await io.contexts.destroy(contextName).catch(() => undefined);
+  });
+
+  afterEach(async () => {
+    const io = await browser.io();
+    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 () => {
+    const io = await browser.io();
+    const app = io.appManager.application("shared-context-client")!;
+
+    const publisher = await app.start({}, { title: "Context Publisher" });
+    const subscriber = await app.start({}, { title: "Context Subscriber" });
+    instances = [publisher, subscriber];
+
+    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",
+    });
+
+    const contextUpdate = await waitForEvent<{ clientName?: string }>(
+      (listener) =>
+        io.contexts.subscribe(contextName, (data) => {
+          listener(data as { clientName?: string });
+        }),
+      {
+        predicate: (data) => data.clientName === clientName,
+        timeoutMsg: `Expected the ${contextName} context to select ${clientName}`,
+      }
+    );
+    cleanups.add(contextUpdate.unsubscribe);
+
+    await browser.switchById(publisherWindow.id);
+    await $("#share-client").waitAndClick();
+
+    const receivedContext = await contextUpdate.result;
+    expect(receivedContext.clientName).to.equal(clientName);
+
+    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}`,
+    });
+
+    expect(await selectedClient.getText()).to.equal(clientName);
+  });
+});

package/dist/templates/tests/tests/tests/single-app.spec.ts

@@ -0,0 +1,39 @@
+import { expect } from "chai";
+import type { IOConnectDesktop } from "@interopio/desktop";
+import { $, browser } from "@wdio/globals";
+
+// Starts a single app in io.Connect Desktop, drives its UI with WebdriverIO,
+// and asserts the resulting state. This is the smallest end-to-end shape: the
+// io.Connect API launches the app, then WebdriverIO interacts with and verifies
+// its DOM.
+describe("Single-app UI", () => {
+  let instance: IOConnectDesktop.AppManager.Instance | undefined;
+
+  afterEach(async () => {
+    // Stop the app even if the test failed, so the next test starts clean.
+    await instance?.stop().catch(() => undefined);
+    instance = undefined;
+  });
+
+  it("increments the counter when the button is pressed", async () => {
+    const io = await browser.io();
+
+    // Launch the registered "web" fixture app through the io.Connect API.
+    instance = await io.appManager.application("web")!.start();
+    const window = await instance.getWindow();
+
+    // Move the WebdriverIO context into the app window before touching its DOM.
+    await browser.switchById(window.id);
+
+    // Click the button (waitAndClick waits for it to be visible and clickable).
+    await $("#increment-counter").waitAndClick();
+
+    // Wait for the observable result instead of asserting immediately.
+    const counter = await $("#counter");
+    await browser.waitUntil(async () => (await counter.getText()) === "1", {
+      timeoutMsg: "Expected the counter to increment to 1",
+    });
+
+    expect(await counter.getText()).to.equal("1");
+  });
+});

package/dist/templates/tests/tests/tests/workspace-add-app.spec.ts

@@ -0,0 +1,64 @@
+import { expect } from "chai";
+import type { IOConnectWorkspaces } from "@interopio/workspaces-api";
+import { $, browser } from "@wdio/globals";
+
+// Adds an app to a Workspace by driving the Workspaces App UI with WebdriverIO
+// clicks (the frame's add button and the add-application popup) instead of the
+// workspace.addWindow() API. This relies on the test platform running in
+// universal mode (config/system.json sets "advancedMode": false), where the
+// popup renders inside the frame window rather than a separate popup window.
+describe("Workspace add-app popup", function () {
+  this.timeout(60_000);
+
+  const addedAppName = "workspace-widget";
+  let workspace: IOConnectWorkspaces.Workspace | undefined;
+
+  afterEach(async () => {
+    // Close the workspace (and its windows) after each test.
+    await workspace?.close().catch(() => undefined);
+    workspace = undefined;
+  });
+
+  it("adds an app to a workspace through the add-application popup", async () => {
+    const io = await browser.io();
+
+    // Start from an empty workspace so the frame shows the empty-state add button.
+    workspace = await io.workspaces!.createWorkspace({ children: [] });
+    await browser.switchById(workspace.frameId);
+
+    // Open the add-application popup from the empty container's add button.
+    await $(".wsp-empty-container button.add-button").waitAndClick();
+
+    // Filter the popup's app list down to the target app by its title.
+    const search = await $(".add-application #appSearch");
+    await search.waitForDisplayed();
+    await search.setValue("Workspace Widget");
+
+    // Row markup differs between Workspaces App versions, so match either shape.
+    await $(
+      ".add-application .applicationsList .list-group-item, .add-application li.io-list-item"
+    ).waitAndClick();
+
+    // The click adds the app through the real UI; confirm via the Workspaces API.
+    await browser.waitUntil(
+      async () => {
+        const current = (await io.workspaces!.getAllWorkspaces()).find(
+          (candidate) => candidate.id === workspace!.id
+        );
+        return current?.getAllWindows().length === 1;
+      },
+      { timeoutMsg: "Expected the added app to appear in the workspace" }
+    );
+
+    const current = (await io.workspaces!.getAllWorkspaces()).find(
+      (candidate) => candidate.id === workspace!.id
+    )!;
+    const [addedWindow] = current.getAllWindows();
+    expect(addedWindow.appName).to.equal(addedAppName);
+
+    // Switch into the freshly added window and verify its own UI loaded.
+    await addedWindow.forceLoad();
+    await browser.switchById(addedWindow.getGdWindow().id);
+    await $("#widget-ready").waitForDisplayed();
+  });
+});

package/dist/templates/tests/tests/tests/workspace-interop.spec.ts

@@ -0,0 +1,99 @@
+import { expect } from "chai";
+import type { IOConnectDesktop } from "@interopio/desktop";
+import type { IOConnectWorkspaces } from "@interopio/workspaces-api";
+import { $, $$, browser } from "@wdio/globals";
+
+// A Workspace Layout that places the two fixture apps side by side. The test
+// imports this Layout, restores it, and drives the apps that appear in it.
+const layoutName = "iocd-sample-people-workspace";
+const workspaceLayout = {
+  name: layoutName,
+  type: "Workspace",
+  version: 2,
+  components: [
+    {
+      type: "Workspace",
+      state: {
+        children: [
+          {
+            type: "row",
+            children: [
+              {
+                type: "window",
+                config: { appName: "people-list" },
+              },
+              {
+                type: "window",
+                config: { appName: "person-details" },
+              },
+            ],
+          },
+        ],
+      },
+    },
+  ],
+} as IOConnectDesktop.Layouts.Layout;
+
+// Restores a Workspace containing two apps, selects a person in the list app,
+// and verifies the details app receives that selection over Interop. Exercises
+// Workspaces, cross-app Interop, and switching the WebdriverIO context between
+// workspace windows.
+describe("Workspace app communication", function () {
+  this.timeout(60_000);
+
+  let workspace: IOConnectWorkspaces.Workspace | undefined;
+
+  beforeEach(async () => {
+    // Make the Workspace Layout available to restore during the test.
+    const io = await browser.io();
+    await io.layouts.import([workspaceLayout], "merge");
+  });
+
+  afterEach(async () => {
+    // Close the Workspace and remove the imported Layout so runs stay isolated.
+    const io = await browser.io();
+    await workspace?.close().catch(() => undefined);
+    workspace = undefined;
+    await io.layouts.remove("Workspace", layoutName).catch(() => undefined);
+  });
+
+  it("displays a person selected in another workspace app", async () => {
+    const io = await browser.io();
+
+    // Restore the Workspace and locate its two app windows.
+    workspace = await io.workspaces!.restoreWorkspace(layoutName);
+    const workspaceWindows = workspace.getAllWindows();
+    const peopleListWindow = workspaceWindows.find((window) => window.appName === "people-list");
+    const personDetailsWindow = workspaceWindows.find(
+      (window) => window.appName === "person-details"
+    );
+
+    expect(peopleListWindow, "people-list workspace window").to.exist;
+    expect(personDetailsWindow, "person-details workspace window").to.exist;
+
+    // Force-load both windows so their web content and Interop are running.
+    await Promise.all([peopleListWindow!.forceLoad(), personDetailsWindow!.forceLoad()]);
+
+    // Switch into the list app and pick a random person.
+    await browser.switchById(peopleListWindow!.getGdWindow().id);
+
+    const people = $$("[data-person-name]");
+    const peopleCount = await people.length;
+    const selectedPerson = await people[Math.floor(Math.random() * peopleCount)];
+    const expectedName = await selectedPerson.getText();
+
+    await selectedPerson.waitForEnabled();
+    await selectedPerson.click();
+
+    // The list app invokes an Interop method the details app handles; switch to
+    // the details app and verify it displays the selected name.
+    await browser.switchById(personDetailsWindow!.getGdWindow().id);
+
+    const displayedPerson = await $("#selected-person");
+    await browser.waitUntil(async () => (await displayedPerson.getText()) === expectedName, {
+      timeoutMsg: `Expected the details app to display ${expectedName}`,
+    });
+
+    expect(await displayedPerson.getText()).to.equal(expectedName);
+  });
+});

package/dist/templates/tests/tests/tsconfig.json

@@ -1,11 +1,13 @@
 {
   "compilerOptions": {
     "target": "ES2020",
-    "module": "CommonJS",
-    "moduleResolution": "Node",
-    "outDir": "dist",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
     "esModuleInterop": true,
-    "types": ["node", "@wdio/globals/types", "@wdio/mocha-framework"]
+    "strict": true,
+    "skipLibCheck": true,
+    "types": ["node", "@wdio/globals/types", "@types/mocha"]
   },
-  "include": ["wdio.config.ts", "tests/**/*.ts"]
+  "include": ["./**/*.ts"],
+  "exclude": ["node_modules"]
 }

package/dist/templates/tests/tests/wdio.config.ts

@@ -1,36 +1,40 @@
-import {
-  IOCDBaseConfiguration,
-  IOCDService,
-} from "@interopio/wdio-iocd-service";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { IOCDBaseConfiguration, IOCDService } from "@interopio/wdio-iocd-service";
 
-export const config: WebdriverIO.Config = {
-  ...IOCDBaseConfiguration,
+const rootDir = path.dirname(fileURLToPath(import.meta.url));
+process.env.WDIO_TESTS_ROOT = path.resolve(rootDir, "tests");
+process.env.WDIO_ROOT_DIR = rootDir;
 
-  // Services
-  services: IOCDService(),
+const binary = process.env.BINARY_PATH;
+if (!binary) {
+  throw new Error("BINARY_PATH is not set. Run the suite from the seed root with 'iocd test'.");
+}
 
-  // Capabilities
+export const config: WebdriverIO.Config = {
+  ...IOCDBaseConfiguration,
+  services: IOCDService({ videoRecording: { enabled: false } }),
+  framework: "@interopio/wdio-iocd-service/framework",
+  reporters: ["spec"],
+  logLevel: "warn",
+  waitforInterval: 200,
+  waitforTimeout: 5000,
+  mochaOpts: { ui: "bdd", timeout: 60000, groupSuites: false },
   capabilities: [
     {
       browserName: "iocd",
-      "wdio:specs": ["./tests/**/*.spec.ts"],
+      "iocd:runner": "platform-wdio",
       "iocd:options": {
-        binary: "%BINARY_PATH%",
+        binary,
+        ioInitOptions: {
+          appManager: "full",
+          layouts: "full",
+          channels: true,
+          libraries: ["@interopio/workspaces-api"],
+        },
+        configOverrides: [path.resolve(rootDir, "config/system.json")],
       },
+      "wdio:specs": [["./tests/**/*.spec.ts"]],
     },
   ],
-
-  // WDIO Options
-  logLevel: "warn",
-  framework: "mocha",
-  reporters: ["spec"],
-
-  // TypeScript Autocompile
-  autoCompileOpts: {
-    autoCompile: true,
-    tsNodeOpts: {
-      transpileOnly: true,
-      project: "./tsconfig.json",
-    },
-  },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@interopio/iocd-cli",
-  "version": "0.0.91",
+  "version": "1.0.0",
   "description": "CLI tool for setting up, building and packaging io.Connect Desktop platforms",
   "engines": {
     "node": ">=22.0.0",
@@ -20,7 +20,8 @@
     "lint": "eslint src --ext .ts",
     "lint:fix": "eslint src --ext .ts --fix",
     "format": "prettier --write src/**/*.ts*",
-    "prepublishOnly": "npm run build && npm run gitignore:pre-package",
+    "audit:production": "npm audit --omit=dev --audit-level=critical",
+    "prepublishOnly": "npm run audit:production && npm run build && npm run gitignore:pre-package",
     "postpublish": "npm run gitignore:post-publish",
     "postinstall": "npm run gitignore:post-install",
     "gitignore:pre-package": "node ./scripts/handle-gitignore-templates.js pre-package",
@@ -51,7 +52,7 @@
     "@electron/notarize": "^3.1.0",
     "@electron/osx-sign": "^2.2.0",
     "@sentry/node": "^10.17.0",
-    "adm-zip": "^0.5.17",
+    "adm-zip": "^0.6.0",
     "commander": "^14.0.0",
     "concurrently": "^10.0.3",
     "dotenv": "^17.2.2",

package/dist/templates/tests/tests/tests/sample.spec.ts

@@ -1,73 +0,0 @@
-describe("Example usage of @interopio/wdio-iocd-service", () => {
-  it("should have access to browser.io()", async () => {
-    // A fully working io.Connect Desktop client
-    const io = await browser.io();
-
-    expect(io).toHaveAttribute("appManager");
-    expect(io).toHaveAttribute("contexts");
-    expect(io).toHaveAttribute("channels");
-  });
-
-  it("should raise a test notifications, and then navigate to notifications panel", async () => {
-    const io = await browser.io();
-    await io.notifications.configure({ enable: true });
-    await io.notifications.raise({
-      title: "Test Notification title",
-      body: "Test Notification body",
-      toastExpiry: 999999,
-    });
-
-    await browser.switchToLaunchpad();
-    await browser.$(".notifications-button button").waitAndClick();
-    await browser.switchToNotificationPanel();
-    await browser.pause(2000);
-  });
-
-  it("should allow using the desktop-client prefs API", async () => {
-    const io = await browser.io();
-
-    const sampleApp = "ExampleApplication";
-    const mockedAppPrefs = { lazyLoadAssets: true };
-
-    // used to store the "update" for app prefs
-    let expectedSetPrefs = null;
-
-    // Subscribe for changes on the sampleApp prefs
-    io.prefs.subscribeFor(sampleApp, ({ data }) => (expectedSetPrefs = data));
-
-    await io.prefs.setFor(sampleApp, mockedAppPrefs);
-
-    // expect the changed prefs to match what was set
-    expect(expectedSetPrefs).toMatchObject(mockedAppPrefs);
-  });
-
-  it("should allow opening apps from the appManager API", async () => {
-    const io = await browser.io();
-
-    // Start the client list app
-    const instanceClientList = await io.appManager
-      .application("channelsclientlist")
-      .start();
-
-    // Switch to the client list window
-    const clientListWindow = await instanceClientList.getWindow();
-    await browser.switchById(clientListWindow.id);
-
-    // Check that the app-client-list element exists in DOM
-    const appClientListElement = await $("app-client-list");
-    await expect(appClientListElement).toBeExisting();
-
-    // Start the client portfolio app
-    const instancePortfolio = await io.appManager
-      .application("channelsclientportfolio")
-      .start();
-
-    // Switch to the client portfolio window
-    const clientPortfolioList = await instancePortfolio.getWindow();
-    await browser.switchById(clientPortfolioList.id);
-
-    // Check that the app-client-portfolio element exists in DOM
-    const clientPortfolioElement = await $("app-client-portfolio");
-    await expect(clientPortfolioElement).toBeExisting();
-  });
-});