thinkwork-cli 0.12.12 → 0.12.16

package/dist/plugins/n8n/n8n-app/src/lib/n8n-app-data.ts

@@ -0,0 +1,190 @@
+export type N8nReadinessState =
+  | "ready"
+  | "blocked_not_ready"
+  | "disabled"
+  | "unknown";
+
+export type N8nBridgeRun = {
+  id: string;
+  threadId?: string | null;
+  threadTurnId?: string | null;
+  status: string;
+  resumeStatus: string;
+  summary?: string | null;
+  errorMessage?: string | null;
+  updatedAt: string;
+};
+
+export type N8nAppWorkflowRow = {
+  externalWorkflowId: string;
+  name: string;
+  active?: boolean | null;
+  triggerTypes: string[];
+  lastModifiedAt?: string | null;
+  lastExecutionAt?: string | null;
+  connectedWorkflowId?: string | null;
+  connectedBindingId?: string | null;
+  readinessState: N8nReadinessState;
+  readinessReasons: unknown;
+  nativeWorkflowUrl?: string | null;
+  warnings: string[];
+};
+
+export type N8nAppExecutionRow = {
+  externalExecutionId: string;
+  externalWorkflowId: string;
+  workflowName?: string | null;
+  status: string;
+  mode?: string | null;
+  startedAt?: string | null;
+  finishedAt?: string | null;
+  durationMs?: number | null;
+  failureMessage?: string | null;
+  nativeExecutionUrl: string;
+  nativeWorkflowUrl: string;
+  bridgeRuns: N8nBridgeRun[];
+  warnings: string[];
+};
+
+export type N8nAppData = {
+  installId: string;
+  workflowReadinessState: N8nReadinessState;
+  workflowReadinessReasons: unknown;
+  executionReadinessState: N8nReadinessState;
+  executionReadinessReasons: unknown;
+  nativeBaseUrl?: string | null;
+  workflows: N8nAppWorkflowRow[];
+  executions: N8nAppExecutionRow[];
+};
+
+export type N8nAppViewMode = "workflows" | "executions";
+
+export function filterN8nWorkflows(
+  workflows: N8nAppWorkflowRow[],
+  query: string,
+  readiness: "all" | N8nReadinessState = "all",
+): N8nAppWorkflowRow[] {
+  const normalizedQuery = normalizeSearch(query);
+  return workflows.filter((workflow) => {
+    if (readiness !== "all" && workflow.readinessState !== readiness) {
+      return false;
+    }
+    if (!normalizedQuery) return true;
+    return searchableWorkflowText(workflow).includes(normalizedQuery);
+  });
+}
+
+export function filterN8nExecutions(
+  executions: N8nAppExecutionRow[],
+  query: string,
+  status: "all" | string = "all",
+): N8nAppExecutionRow[] {
+  const normalizedQuery = normalizeSearch(query);
+  const normalizedStatus = normalizeSearch(status);
+  return executions.filter((execution) => {
+    if (
+      status !== "all" &&
+      normalizeSearch(execution.status) !== normalizedStatus
+    ) {
+      return false;
+    }
+    if (!normalizedQuery) return true;
+    return searchableExecutionText(execution).includes(normalizedQuery);
+  });
+}
+
+export function executionStatuses(
+  executions: N8nAppExecutionRow[],
+): string[] {
+  return Array.from(
+    new Set(
+      executions
+        .map((execution) => execution.status.trim())
+        .filter((status) => status.length > 0),
+    ),
+  ).sort((a, b) => a.localeCompare(b));
+}
+
+export function readinessLabel(state: N8nReadinessState): string {
+  if (state === "ready") return "ready";
+  if (state === "blocked_not_ready") return "blocked";
+  if (state === "disabled") return "disabled";
+  return "unknown";
+}
+
+export function connectionLabel(workflow: N8nAppWorkflowRow): string {
+  if (workflow.connectedWorkflowId && workflow.connectedBindingId) {
+    return "linked";
+  }
+  if (workflow.connectedWorkflowId || workflow.connectedBindingId) {
+    return "partial";
+  }
+  return "unlinked";
+}
+
+export function formatDuration(durationMs?: number | null): string {
+  if (durationMs == null) return "-";
+  if (durationMs < 1000) return `${durationMs} ms`;
+  const seconds = durationMs / 1000;
+  if (seconds < 60) return `${seconds.toFixed(1)} s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = Math.floor(seconds % 60);
+  return `${minutes}m ${remainingSeconds}s`;
+}
+
+export function formatDateTime(value?: string | null): string {
+  if (!value) return "-";
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return value;
+  return new Intl.DateTimeFormat(undefined, {
+    dateStyle: "medium",
+    timeStyle: "short",
+  }).format(date);
+}
+
+export function bridgeThreadPath(run: N8nBridgeRun): string | null {
+  if (!run.threadId) return null;
+  return `/threads/${run.threadId}`;
+}
+
+function normalizeSearch(value: string): string {
+  return value.trim().toLowerCase();
+}
+
+function searchableWorkflowText(workflow: N8nAppWorkflowRow): string {
+  return normalizeSearch(
+    [
+      workflow.name,
+      workflow.externalWorkflowId,
+      workflow.triggerTypes.join(" "),
+      workflow.readinessState,
+      connectionLabel(workflow),
+      workflow.warnings.join(" "),
+    ].join(" "),
+  );
+}
+
+function searchableExecutionText(execution: N8nAppExecutionRow): string {
+  return normalizeSearch(
+    [
+      execution.externalExecutionId,
+      execution.externalWorkflowId,
+      execution.workflowName ?? "",
+      execution.status,
+      execution.mode ?? "",
+      execution.failureMessage ?? "",
+      execution.bridgeRuns
+        .map((run) =>
+          [
+            run.id,
+            run.status,
+            run.resumeStatus,
+            run.summary ?? "",
+            run.errorMessage ?? "",
+          ].join(" "),
+        )
+        .join(" "),
+      execution.warnings.join(" "),
+    ].join(" "),
+  );
+}

package/dist/plugins/n8n/n8n-app/src/vite-env.d.ts

@@ -0,0 +1,7 @@
+interface ImportMetaEnv {
+  readonly DEV: boolean;
+}
+
+interface ImportMeta {
+  readonly env: ImportMetaEnv;
+}

package/dist/plugins/n8n/n8n-app/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "target": "ES2022",
+    "types": ["node"],
+    "skipLibCheck": true,
+    "noEmit": true
+  },
+  "include": ["src/**/*.ts", "src/**/*.tsx"]
+}

package/dist/plugins/n8n/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@thinkwork/plugin-n8n",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "main": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./manifest": "./src/manifest.ts",
+    "./deployment/managed-app": "./src/deployment/managed-app.ts",
+    "./deployment/image-build": "./src/deployment/image-build.ts",
+    "./package-config": "./src/package-config.ts",
+    "./n8n-app": "./n8n-app/src/front-components/thinkwork-workflows.front-component.tsx",
+    "./n8n-app-data": "./n8n-app/src/lib/n8n-app-data.ts"
+  },
+  "scripts": {
+    "build": "tsc --build",
+    "typecheck": "tsc --noEmit && tsc -p n8n-app/tsconfig.json --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@noble/hashes": "^2.0.1",
+    "@tanstack/react-table": "^8.21.3",
+    "@thinkwork/ui": "workspace:*",
+    "react": "^19.2.0"
+  },
+  "devDependencies": {
+    "@thinkwork/deployment-runner": "workspace:*",
+    "@thinkwork/plugin-catalog": "workspace:*",
+    "@types/node": "^25.6.0",
+    "@types/react": "^19.2.0",
+    "typescript": "^5.5.0",
+    "vitest": "^2.0.0"
+  }
+}

package/dist/plugins/n8n/runtime/Dockerfile

@@ -0,0 +1,18 @@
+ARG N8N_BASE_IMAGE=n8nio/n8n:2.27.3@sha256:a772d24e6b4f9b3848be5a57c5e45437eed1965bbbcefa2f9a93f4835b6639fa
+FROM ${N8N_BASE_IMAGE}
+
+USER root
+
+COPY package.json package-lock.json /tmp/thinkwork-n8n-packages/
+RUN cd /tmp/thinkwork-n8n-packages \
+    && npm ci --omit=dev --ignore-scripts \
+    && mkdir -p /usr/local/lib/node_modules/n8n/node_modules \
+    && if [ -d node_modules ]; then cp -R node_modules/. /usr/local/lib/node_modules/n8n/node_modules/; fi \
+    && npm cache clean --force \
+    && rm -rf /tmp/thinkwork-n8n-packages
+
+ENV NODE_PATH=/usr/local/lib/node_modules/n8n/node_modules
+
+COPY n8n-task-runners.json /etc/n8n-task-runners.json
+
+USER node

package/dist/plugins/n8n/runtime/n8n-task-runners.json

@@ -0,0 +1,14 @@
+{
+  "task-runners": [
+    {
+      "runner-type": "javascript",
+      "env-overrides": {
+        "NODE_FUNCTION_ALLOW_EXTERNAL": ""
+      }
+    },
+    {
+      "runner-type": "python",
+      "env-overrides": {}
+    }
+  ]
+}

package/dist/plugins/n8n/runtime/n8n-task-runners.json.template

@@ -0,0 +1,14 @@
+{
+  "task-runners": [
+    {
+      "runner-type": "javascript",
+      "env-overrides": {
+        "NODE_FUNCTION_ALLOW_EXTERNAL": "{{NODE_FUNCTION_ALLOW_EXTERNAL}}"
+      }
+    },
+    {
+      "runner-type": "python",
+      "env-overrides": {}
+    }
+  ]
+}

package/dist/plugins/n8n/runtime/package-lock.json

@@ -0,0 +1,13 @@
+{
+  "name": "thinkwork-n8n-runtime-packages",
+  "version": "0.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "thinkwork-n8n-runtime-packages",
+      "version": "0.0.0",
+      "dependencies": {}
+    }
+  }
+}

package/dist/plugins/n8n/runtime/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "thinkwork-n8n-runtime-packages",
+  "version": "0.0.0",
+  "private": true,
+  "description": "Generated dependency context for the ThinkWork n8n runtime wrapper.",
+  "dependencies": {}
+}

package/dist/plugins/n8n/scripts/sync-thinkwork-app.mjs

@@ -0,0 +1,268 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { pathToFileURL } from "node:url";
+
+const DEFAULT_APP_DIR = "plugins/n8n/n8n-app";
+const DEFAULT_APP_ROUTE = "/apps/n8n/workflows";
+
+function parseArgs(argv) {
+  const args = {
+    appDir: process.env.N8N_THINKWORK_APP_DIR || DEFAULT_APP_DIR,
+    route: process.env.N8N_THINKWORK_APP_ROUTE || DEFAULT_APP_ROUTE,
+    dryRun: process.env.N8N_THINKWORK_APP_SYNC_DRY_RUN !== "0",
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--app-dir") {
+      args.appDir = requireValue(argv, ++index, arg);
+    } else if (arg === "--url" || arg === "--thinkwork-url") {
+      args.url = requireValue(argv, ++index, arg);
+    } else if (arg === "--install-id") {
+      args.installId = requireValue(argv, ++index, arg);
+    } else if (arg === "--api-key") {
+      args.apiKey = requireValue(argv, ++index, arg);
+    } else if (arg === "--auth-secret") {
+      args.authSecret = requireValue(argv, ++index, arg);
+    } else if (arg === "--id-token") {
+      args.idToken = requireValue(argv, ++index, arg);
+    } else if (arg === "--dry-run") {
+      args.dryRun = true;
+    } else if (arg === "--apply") {
+      args.dryRun = false;
+    } else {
+      throw new Error(`Unknown argument: ${arg}`);
+    }
+  }
+
+  args.url ||= first(
+    process.env.THINKWORK_PUBLIC_URL,
+    process.env.THINKWORK_WEB_URL,
+    process.env.SMOKE_THINKWORK_URL,
+  );
+  args.apiKey ||= first(
+    process.env.VITE_GRAPHQL_API_KEY,
+    process.env.GRAPHQL_API_KEY,
+  );
+  args.authSecret ||= first(
+    process.env.API_AUTH_SECRET,
+    process.env.THINKWORK_API_SECRET,
+  );
+  args.idToken ||= first(
+    process.env.SMOKE_COGNITO_ID_TOKEN,
+    process.env.COGNITO_ID_TOKEN,
+  );
+  return args;
+}
+
+function requireValue(argv, index, flag) {
+  const value = argv[index];
+  if (!value || value.startsWith("--")) {
+    throw new Error(`${flag} requires a value.`);
+  }
+  return value;
+}
+
+export function validateN8nAppPackage(appDir = DEFAULT_APP_DIR) {
+  const required = [
+    "README.md",
+    "package.json",
+    "tsconfig.json",
+    "src/application-config.ts",
+    "src/front-components/thinkwork-workflows.front-component.tsx",
+    "src/lib/n8n-app-data.ts",
+  ];
+  const missing = required.filter((relativePath) => {
+    return !fs.existsSync(path.resolve(appDir, relativePath));
+  });
+  if (missing.length > 0) {
+    throw new Error(`Missing n8n app package file(s): ${missing.join(", ")}`);
+  }
+  return {
+    appDir,
+    required,
+    packageName: JSON.parse(
+      fs.readFileSync(path.resolve(appDir, "package.json"), "utf8"),
+    ).name,
+  };
+}
+
+export function buildN8nAppSyncPlan(args) {
+  const packageStatus = validateN8nAppPackage(args.appDir);
+  return {
+    app: "n8n Workflows",
+    mode: args.dryRun ? "dry-run" : "apply",
+    appDir: packageStatus.appDir,
+    packageName: packageStatus.packageName,
+    route: args.route,
+    thinkworkUrl: args.url ? normalizeUrl(args.url) : null,
+    installId: args.installId ?? null,
+    dryRun: args.dryRun
+      ? {
+          mutates: false,
+          verifies: [
+            "local n8n app package files exist",
+            "ThinkWork app route is /apps/n8n/workflows",
+            "apply prerequisites are known",
+          ],
+          requiredForApply: [
+            "THINKWORK_PUBLIC_URL or --thinkwork-url",
+            "one GraphQL credential: API_AUTH_SECRET, GRAPHQL_API_KEY, or COGNITO_ID_TOKEN",
+            "optional SMOKE_N8N_INSTALL_ID or --install-id for n8nAppData verification",
+          ],
+        }
+      : null,
+  };
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const plan = buildN8nAppSyncPlan(args);
+
+  if (args.dryRun) {
+    printJson({
+      ok: true,
+      ...plan,
+      note:
+        "Dry run validates the package and apply prerequisites without publishing, installing, or mutating n8n.",
+    });
+    return;
+  }
+
+  if (!args.url) {
+    throw new Error("Set THINKWORK_PUBLIC_URL or pass --thinkwork-url.");
+  }
+  if (!args.apiKey && !args.authSecret && !args.idToken) {
+    throw new Error(
+      "Set API_AUTH_SECRET, THINKWORK_API_SECRET, GRAPHQL_API_KEY, COGNITO_ID_TOKEN, or pass --api-key/--auth-secret/--id-token.",
+    );
+  }
+
+  const graphqlUrl = graphqlEndpoint(args.url);
+  const installedApps = await gql(
+    graphqlUrl,
+    authHeaders(args),
+    `query N8nInstalledApps {
+      installedPluginApps {
+        pluginInstallId
+        pluginKey
+        appKey
+        routeSegment
+        readiness { state message nextAction }
+      }
+    }`,
+    {},
+  );
+  const n8nApp = installedApps.installedPluginApps.find(
+    (app) =>
+      app.pluginKey === "n8n" &&
+      app.appKey === "n8n-workflow-operations" &&
+      app.routeSegment === "workflows",
+  );
+  if (!n8nApp) {
+    throw new Error("n8n Workflows app is not returned by installedPluginApps.");
+  }
+
+  let appData = null;
+  const installId = args.installId || n8nApp.pluginInstallId;
+  if (installId) {
+    appData = await gql(
+      graphqlUrl,
+      authHeaders(args),
+      `query N8nSyncAppData($installId: ID!, $executionLimit: Int) {
+        n8nAppData(installId: $installId, executionLimit: $executionLimit) {
+          workflowReadinessState
+          executionReadinessState
+          workflows { externalWorkflowId }
+          executions { externalExecutionId bridgeRuns { id threadId } }
+        }
+      }`,
+      { installId, executionLimit: 25 },
+    );
+  }
+
+  printJson({
+    ok: true,
+    ...plan,
+    note:
+      "Apply verified the deployed ThinkWork-hosted n8n app contract. It did not mutate n8n workflows or ThinkWork plugin settings.",
+    graphqlUrl,
+    installedApp: n8nApp,
+    appData: appData
+      ? {
+          workflowReadinessState: appData.n8nAppData.workflowReadinessState,
+          executionReadinessState: appData.n8nAppData.executionReadinessState,
+          workflowCount: appData.n8nAppData.workflows.length,
+          executionCount: appData.n8nAppData.executions.length,
+          bridgeLinkedExecutionCount: appData.n8nAppData.executions.filter(
+            (execution) => execution.bridgeRuns.length > 0,
+          ).length,
+        }
+      : null,
+  });
+}
+
+async function gql(url, headers, query, variables) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      accept: "application/json",
+      ...headers,
+    },
+    body: JSON.stringify({ query, variables }),
+  });
+  const payload = await response.json().catch(() => ({}));
+  if (!response.ok || payload.errors?.length) {
+    throw new Error(
+      `GraphQL request failed: HTTP ${response.status} ${redact(
+        JSON.stringify(payload.errors ?? payload).slice(0, 500),
+      )}`,
+    );
+  }
+  return payload.data;
+}
+
+function authHeaders(args) {
+  if (args.idToken) return { authorization: `Bearer ${args.idToken}` };
+  if (args.authSecret) return { "x-api-secret": args.authSecret };
+  if (args.apiKey) return { "x-api-key": args.apiKey };
+  return {};
+}
+
+function graphqlEndpoint(baseUrl) {
+  return new URL("/graphql", normalizeUrl(baseUrl)).toString();
+}
+
+function normalizeUrl(value) {
+  const parsed = new URL(value);
+  if (parsed.protocol !== "https:" && parsed.hostname !== "localhost") {
+    throw new Error(`ThinkWork URL must be HTTPS or localhost, got ${value}.`);
+  }
+  return parsed.toString().replace(/\/$/, "");
+}
+
+function first(...values) {
+  return values.find((value) => value !== undefined && value !== "") ?? null;
+}
+
+function printJson(value) {
+  console.log(redact(JSON.stringify(value, null, 2)));
+}
+
+function redact(value) {
+  return value
+    .replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/g, "Bearer [redacted]")
+    .replace(/"x-api-key"\s*:\s*"[^"]+"/gi, '"x-api-key":"[redacted]"')
+    .replace(/"x-api-secret"\s*:\s*"[^"]+"/gi, '"x-api-secret":"[redacted]"')
+    .replace(/(api[_-]?key|token|secret|credential)["=: ]+[^",\s]+/gi, "$1=[redacted]");
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1]).href) {
+  main().catch((error) => {
+    console.error(redact(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  });
+}

package/dist/plugins/n8n/smoke/README.md

@@ -0,0 +1,95 @@
+# n8n Smoke Scripts
+
+These scripts verify the ThinkWork-managed n8n application path. They default
+to dry-run mode so CI and deploy workflows can record the expected live inputs
+without requiring tenant secrets.
+
+## Managed App Runtime
+
+```bash
+node plugins/n8n/smoke/n8n-managed-app-smoke.mjs
+```
+
+Set `SMOKE_ENABLE_N8N_MANAGED_APP=1` after the plugin is installed and deployed
+to verify runtime evidence, service outputs, and the public n8n health path.
+
+## Native n8n MCP
+
+```bash
+node plugins/n8n/smoke/n8n-mcp-smoke.mjs
+```
+
+Set `SMOKE_ENABLE_N8N_MCP=1` to verify native n8n MCP tool discovery and safe
+workflow read operations through either the ThinkWork proxy path or direct n8n
+MCP diagnostics.
+
+## Agent-Step Bridge
+
+```bash
+node plugins/n8n/smoke/n8n-agent-step-bridge-smoke.mjs
+```
+
+Set `SMOKE_ENABLE_N8N_AGENT_STEP_BRIDGE=1` to prove the deployed n8n ->
+ThinkWork -> n8n bridge path. The preferred live setup is a disposable n8n
+workflow using stock nodes:
+
+1. A Webhook or other trigger starts the smoke workflow.
+2. An HTTP Request node calls ThinkWork's
+   `/api/integrations/n8n/agent-steps` endpoint with the tenant bridge
+   credential.
+3. A Wait node uses On webhook call and passes `$execution.resumeUrl` to
+   ThinkWork.
+4. Downstream nodes branch on the resumed `status`, `output`, `error`,
+   `summary`, and `links` payload.
+
+Typical live env:
+
+```bash
+SMOKE_ENABLE_N8N_AGENT_STEP_BRIDGE=1 \
+SMOKE_N8N_MCP_URL=https://n8n.example.com/mcp-server/http \
+SMOKE_N8N_MCP_SERVICE_TOKEN="$N8N_MCP_SERVICE_TOKEN" \
+SMOKE_N8N_BRIDGE_TRIGGER_URL="https://n8n.example.com/webhook/..." \
+SMOKE_N8N_BRIDGE_CORRELATION_ID="bridge-smoke-$(date +%s)" \
+SMOKE_GRAPHQL_HTTP_URL="$GRAPHQL_HTTP_URL" \
+SMOKE_TENANT_ID="$TENANT_ID" \
+API_AUTH_SECRET="$API_AUTH_SECRET" \
+SMOKE_EVIDENCE_FILE=deploy-artifacts/n8n-agent-step-bridge-smoke.json \
+node plugins/n8n/smoke/n8n-agent-step-bridge-smoke.mjs
+```
+
+The smoke records the n8n workflow/execution, ThinkWork bridge run, ThinkWork
+thread, resume status, compact result fields, and evidence URI when configured.
+It never prints or persists bridge bearer tokens, n8n MCP tokens, raw resume
+URLs, or resolved IP addresses.
+
+## Integrated ThinkWork App
+
+```bash
+node plugins/n8n/smoke/n8n-integrated-app-smoke.mjs
+```
+
+Set `SMOKE_ENABLE_N8N_INTEGRATED_APP=1` after the plugin is installed and the
+managed n8n runtime is deployed. The live smoke verifies the ThinkWork-hosted
+app path:
+
+1. `installedPluginApps` returns `n8n-workflow-operations` at
+   `/apps/n8n/workflows`.
+2. `n8nAppData` returns workflow readiness and workflow table rows.
+3. `n8nAppData` returns execution readiness and bounded execution table rows.
+4. Bridge-linked execution evidence is present when
+   `SMOKE_N8N_BRIDGE_THREAD_ID` is supplied.
+
+Typical live env:
+
+```bash
+SMOKE_ENABLE_N8N_INTEGRATED_APP=1 \
+SMOKE_THINKWORK_URL=https://app.example.com \
+SMOKE_N8N_INSTALL_ID=<plugin-install-id> \
+SMOKE_COGNITO_ID_TOKEN=<operator-id-token> \
+SMOKE_EVIDENCE_FILE=deploy-artifacts/n8n-integrated-app-smoke.json \
+node plugins/n8n/smoke/n8n-integrated-app-smoke.mjs
+```
+
+The smoke records readiness states, row counts, sample workflow/execution ids,
+and bridge-linked counts. It does not print n8n API keys, bearer tokens, raw
+execution payloads, bridge credentials, or callback URLs.