@checkstack/integration-webex-backend 0.0.34 → 0.1.0

package/CHANGELOG.md

@@ -1,5 +1,211 @@
 # @checkstack/integration-webex-backend
 
+## 0.1.0
+
+### Minor Changes
+
+- e2d6f25: feat(automation): connection picker for integration actions + restore Integrations menu
+
+  Connection-backed automation actions (Jira, Teams, Webex) now render a
+  working connection picker plus cascading provider dropdowns in the
+  visual editor, and the Integrations entry is back in the user menu.
+
+  **Contract.** `ActionDefinition` gained an optional
+  `connectionProviderId` (and it is surfaced on `ActionInfoSchema` and
+  mapped in the `listActions` router). It carries the integration
+  provider's fully-qualified id, derived from the provider plugin's own
+  `pluginMetadata.pluginId` (never a hardcoded string), so the editor
+  knows which provider backs an action's dropdowns and it matches the
+  `qualifiedId` the integration provider registry assigns.
+
+  **Providers.** Jira, Teams and Webex each export
+  `*_PROVIDER_LOCAL_ID` / `*_PROVIDER_QUALIFIED_ID`, register their
+  provider with the local id, and add a `CONNECTION_OPTIONS`
+  (`"connectionOptions"`) resolver name. Their `post_message` /
+  issue actions set `connectionProviderId` and expose `connectionId`
+  as an `x-options-resolver` dropdown instead of a hidden field.
+
+  **Frontend bridge.** A new `useConnectionOptionResolvers` hook
+  (`@checkstack/automation-frontend`, which now depends on
+  `@checkstack/integration-common`) turns an action's
+  `x-options-resolver` schema fields into live data: the
+  `connectionOptions` resolver lists the provider's connections via
+  `listConnections`, and every other resolver name is forwarded to
+  `getConnectionOptions` for the selected `connectionId`, passing the
+  live form values as `context` for dependent fields. `ProviderActionBody`
+  now passes this map to `DynamicForm` (it was previously missing
+  entirely, so connection-backed actions had no working dropdowns).
+
+  **frontend-api.** `usePluginClient` procedures now also expose a typed
+  imperative `.call(input)` alongside `.useQuery` / `.useMutation`, for
+  async callbacks that cannot host a hook (such as a `DynamicForm`
+  options resolver). Additive, non-breaking.
+
+  **Integrations menu.** Re-added `IntegrationMenuItem` and a new
+  `IntegrationsLandingPage`, wired into `integration-frontend` as a list
+  route and a `UserMenuItemsSlot` entry under the "Configuration" group.
+
+  **Action card polish.** The action editor's secondary metadata (id,
+  description, failure behaviour) is now grouped into one quiet settings
+  panel with consistent small uppercase "eyebrow" labels, so the action's
+  own configuration stays the focal point. The raw failure checkbox was
+  replaced with the standard `Checkbox` control, and the provider action
+  picker / configuration sections gained consistent section headers and a
+  divider. The per-step "type" dropdown was removed: an action's kind is
+  fixed at creation, so changing it now means adding a new step and
+  deleting the old one (avoids the surprising full-config reset that
+  switching kinds used to trigger).
+
+  **Add-step picker.** Adding a step now opens a Home-Assistant-style
+  dialog where the operator decides the step type up front: an "Actions"
+  tab lists the registered provider actions grouped by category
+  (searchable; picking one presets the step's `action`), and a "Blocks"
+  tab lists the structural building blocks (choose / parallel / repeat /
+  etc.). Because the concrete action is chosen here, the in-card action
+  switcher was removed - a step's action is fixed once created. Composite
+  blocks now start with an empty child list (filled via the nested
+  add-step picker) instead of seeding an unconfigurable empty action.
+
+- 41c77f4: feat(automation): one-time migration of webhook subscriptions + remove legacy integration backend
+
+  **BREAKING CHANGES** (platform is in BETA — no major bump):
+
+  - `IntegrationProvider` no longer carries `config` (subscription
+    config) or `deliver`. The interface now models a connection provider
+    only: connection schema + `getConnectionOptions` + `testConnection`.
+  - The legacy subscription / delivery-log / event endpoints
+    (`listSubscriptions`, `createSubscription`, `getDeliveryLogs`,
+    `listEventTypes`, …) are removed from `integrationContract`.
+  - `delivery-coordinator`, `hook-subscriber`, `event-registry`, and the
+    `integrationEventExtensionPoint` are deleted. Plugins that
+    previously called `integrationEvents.registerEvent(...)` now
+    register their hooks as automation triggers via
+    `automationTriggerExtensionPoint.registerTrigger(...)`.
+  - Frontend pages `IntegrationsPage` and `DeliveryLogsPage` are gone;
+    the integration plugin's only remaining UI is connection
+    management. Subscription management lives under `/automation/...`.
+  - `webhook_subscriptions` and `delivery_logs` tables stay in the
+    database for one release as a safety net (no code reads or writes
+    them), and will be dropped in a follow-up migration.
+
+  **New**:
+
+  - `jira.create_issue`, `teams.post_message`, `webex.post_message`,
+    `webhook.send`, `integration-script.run_shell`, and
+    `integration-script.run_script` actions registered against the
+    Automation Platform with matching `*.message`, `*.delivery`,
+    `shell.result`, and `script.result` artifact types. The script
+    plugin exposes **two** actions — `run_shell` runs bash via the
+    shared `ShellScriptRunner` (Monaco `shell` editor), `run_script`
+    runs an ESM module in a Bun subprocess via `EsmScriptRunner`
+    (Monaco `typescript` editor + `defineIntegration` helper) — to
+    preserve the legacy provider split. `jira.create_issue` keeps the
+    dynamic field-mapping dropdown (driven by
+    `JIRA_RESOLVERS.FIELD_OPTIONS`).
+  - One-time data migration runs on boot in
+    `automation-backend.afterPluginsReady`. It reads
+    `webhook_subscriptions` via a new service RPC
+    `IntegrationApi.listLegacySubscriptions`, translates each row into
+    a single-trigger / single-action automation (marked with
+    `managed_by = "migrated-subscription:<id>"`), and is idempotent
+    across restarts.
+  - Failed translations are recorded in a new
+    `automation_migration_failures` table and surfaced via
+    `AutomationApi.listMigrationFailures` /
+    `acknowledgeMigrationFailure` so admins can review and re-create
+    failed entries by hand.
+
+- 41c77f4: fix(automation): qualify action `produces` / `consumes` with the owning plugin id
+
+  `context.artifacts` showed up untyped (no fields) in the script editor
+  because action `produces` / `consumes` were hand-written full strings
+  (`"jira.issue"`) that did not match the artifact-type registry's
+  qualified id. The registry derives `${pluginId}.${id}`, and the plugin's
+  id is the package name `integration-jira`, so the artifact type actually
+  registers as `integration-jira.issue` — the editor's schema lookup
+  (`produces` vs registered `qualifiedId`) missed, leaving the artifact's
+  fields unknown. (Runtime store/consume happened to agree with each other
+  on the short string, so it "worked" but typed nothing.)
+
+  The action registry now qualifies `produces` with the owning plugin id,
+  exactly as it already qualifies the action's own `id` and as the
+  artifact-type registry qualifies the artifact type id — so the three can
+  never drift. Actions declare the **local** artifact id:
+
+  - `produces: "issue"` → registered as `integration-jira.issue`,
+  - `consumes: ["issue"]` → resolved against the owning plugin's namespace
+    at run time; `consumedArtifacts` is keyed by the local id, so an
+    action's `execute` reads `consumedArtifacts["issue"]`.
+
+  All five artifact-producing integration plugins (jira / teams / webex /
+  webhook / script) now declare local ids. With `produces` matching the
+  registered artifact type, the editor types `context.artifacts[...]` with
+  the real schema (e.g. `issueKey`, `projectKey`, `issueUrl`).
+
+  **BREAKING (beta):** the fully-qualified artifact type ids change from
+  the short form to the plugin-prefixed form, e.g. `jira.issue` →
+  `integration-jira.issue`. This affects how artifacts are referenced in
+  templates (`{{ artifact.integration-jira.issue.issueKey }}`), the TS
+  script `context.artifacts["integration-jira.issue"]`, and shell env names
+  (`$CHECKSTACK_ARTIFACT_INTEGRATION_JIRA_ISSUE_ISSUEKEY`). Artifacts are
+  per-run and ephemeral, so no stored-data migration is needed.
+
+  Note: this keeps the same-plugin produce→consume handoff (the current
+  pattern). Cross-plugin artifact consumption would need a follow-up to
+  allow a fully-qualified `consumes` ref.
+
+### Patch Changes
+
+- 41c77f4: fix(integration): resolve `connectionStoreRef` lazily inside action `execute`
+
+  The Phase 6/7/8 refactor wired every integration backend's
+  `registerInit` deps to include `connectionStore: connectionStoreRef`,
+  expecting `integration-backend` to register the service before the
+  sort. But `integration-backend` calls `env.registerService(connection
+StoreRef, ...)` from inside its own `init()`, not at `register()`
+  time — so at topological-sort time the `providedBy` map doesn't know
+  the service exists yet, and the sort can put a consumer (e.g.
+  `integration-teams`) ahead of `integration-backend`. The dev server
+  then fails at boot with:
+
+  > Service 'integration.connectionStore' not found for plugin
+  > 'integration-teams'
+
+  This change drops the init-time dep from every integration plugin and
+  resolves the connection store **lazily at action-execute time** via
+  `context.getService(connectionStoreRef)`. By the time any action's
+  `execute` runs, every plugin has finished init + afterPluginsReady,
+  so the service is always available. Tests updated to thread a mock
+  store through a typed `getService` stub in the action context.
+
+  No behaviour change at runtime — the actions hit the connection store
+  at the same moment they always did (just inside `execute` rather than
+  through a captured init-time closure).
+
+- Updated dependencies [e2d6f25]
+- Updated dependencies [41c77f4]
+- Updated dependencies [e1a2077]
+- Updated dependencies [41c77f4]
+- Updated dependencies [41c77f4]
+- Updated dependencies [41c77f4]
+- Updated dependencies [41c77f4]
+- Updated dependencies [41c77f4]
+- Updated dependencies [41c77f4]
+- Updated dependencies [6d52276]
+- Updated dependencies [6d52276]
+- Updated dependencies [35bc682]
+  - @checkstack/automation-backend@0.2.0
+  - @checkstack/integration-backend@0.2.0
+  - @checkstack/common@0.12.0
+  - @checkstack/backend-api@0.18.0
+
+## 0.0.35
+
+### Patch Changes
+
+- @checkstack/backend-api@0.17.1
+- @checkstack/integration-backend@0.1.30
+
 ## 0.0.34
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@checkstack/integration-webex-backend",
-  "version": "0.0.34",
+  "version": "0.1.0",
   "type": "module",
   "main": "src/index.ts",
   "checkstack": {
@@ -11,18 +11,21 @@
     "typecheck": "tsgo -b",
     "lint": "bun run lint:code",
     "lint:code": "eslint . --max-warnings 0",
+    "test": "bun test",
     "pack": "bunx @checkstack/scripts plugin-pack"
   },
   "dependencies": {
-    "@checkstack/backend-api": "0.16.0",
-    "@checkstack/integration-backend": "0.1.28",
-    "@checkstack/common": "0.10.0",
+    "@checkstack/backend-api": "0.17.1",
+    "@checkstack/integration-backend": "0.1.30",
+    "@checkstack/automation-backend": "0.1.0",
+    "@checkstack/common": "0.11.0",
     "zod": "^4.2.1"
   },
   "devDependencies": {
     "@types/bun": "^1.0.0",
     "typescript": "^5.0.0",
-    "@checkstack/tsconfig": "0.0.7"
+    "@checkstack/tsconfig": "0.0.7",
+    "@checkstack/test-utils-backend": "0.1.30"
   },
   "description": "Checkstack integration-webex-backend plugin",
   "author": {

package/src/automations.test.ts

@@ -0,0 +1,199 @@
+/**
+ * Behaviour tests for the Webex automation action.
+ *
+ * The ConnectionStore is faked; fetch is stubbed in-process so we can
+ * exercise the full action.execute flow including the connection
+ * lookup + Graph-style response mapping.
+ */
+import { describe, it, expect, beforeEach, mock } from "bun:test";
+import type { Logger } from "@checkstack/backend-api";
+import { createMockLogger } from "@checkstack/test-utils-backend";
+import {
+  connectionStoreRef,
+  type ConnectionStore,
+} from "@checkstack/integration-backend";
+import type { ServiceRef } from "@checkstack/backend-api";
+
+import {
+  createWebexActions,
+  webexMessageArtifactType,
+} from "./automations";
+
+const logger = createMockLogger() as Logger;
+
+interface CapturedFetchCall {
+  url: string;
+  init: RequestInit;
+}
+
+interface StagedResponse {
+  body?: unknown;
+  status?: number;
+  raw?: string;
+}
+
+function setupFetchSequence(responses: StagedResponse[]) {
+  const calls: CapturedFetchCall[] = [];
+  const originalFetch = globalThis.fetch;
+  let i = 0;
+  globalThis.fetch = (async (
+    input: string | URL | Request,
+    init?: RequestInit,
+  ) => {
+    calls.push({ url: String(input), init: init ?? {} });
+    const next = responses[i++] ?? { body: {}, status: 200 };
+    return new Response(
+      next.raw !== undefined ? next.raw : JSON.stringify(next.body ?? {}),
+      {
+        status: next.status ?? 200,
+        headers: { "Content-Type": "application/json" },
+      },
+    );
+  }) as typeof fetch;
+  return {
+    calls,
+    restore: () => {
+      globalThis.fetch = originalFetch;
+    },
+  };
+}
+
+function makeConnectionStore(): ConnectionStore {
+  return {
+    listConnections: mock(async () => []),
+    getConnection: mock(async () => undefined),
+    getConnectionWithCredentials: mock(async (id: string) =>
+      id === "conn-1"
+        ? {
+            id: "conn-1",
+            providerId: "webex",
+            name: "Webex Bot",
+            config: { botToken: "secret-bot-token" },
+            createdAt: new Date(),
+            updatedAt: new Date(),
+          }
+        : undefined,
+    ),
+    createConnection: mock(async () => {
+      throw new Error("not implemented in stub");
+    }),
+    updateConnection: mock(async () => {
+      throw new Error("not implemented in stub");
+    }),
+    deleteConnection: mock(async () => false),
+    findConnectionProvider: mock(async () => undefined),
+  } as unknown as ConnectionStore;
+}
+
+let fetchFixture: ReturnType<typeof setupFetchSequence> | undefined;
+
+beforeEach(() => {
+  fetchFixture?.restore();
+  fetchFixture = undefined;
+});
+
+function makeCtx(store: ConnectionStore) {
+  return {
+    runId: "run-1",
+    automationId: "auto-1",
+    contextKey: null,
+    logger,
+    getService: async <T,>(ref: ServiceRef<T>): Promise<T> => {
+      if (ref.id === connectionStoreRef.id) {
+        return store as unknown as T;
+      }
+      throw new Error(`Unstubbed service requested: ${ref.id}`);
+    },
+  };
+}
+
+const ctxBase = makeCtx(makeConnectionStore());
+
+describe("webexMessageArtifactType", () => {
+  it("validates the canonical artifact shape", () => {
+    const ok = webexMessageArtifactType.schema.safeParse({
+      messageId: "msg-1",
+      roomId: "room-1",
+    });
+    expect(ok.success).toBe(true);
+  });
+
+  it("rejects when messageId is missing", () => {
+    const bad = webexMessageArtifactType.schema.safeParse({
+      roomId: "room-1",
+    });
+    expect(bad.success).toBe(false);
+  });
+});
+
+describe("webex.post_message", () => {
+  it("posts a markdown message and emits a webex.message artifact", async () => {
+    fetchFixture = setupFetchSequence([{ body: { id: "msg-42" } }]);
+    const actions = createWebexActions();
+    const post = actions[0]!;
+    const result = await post.execute({
+      ...ctxBase,
+      consumedArtifacts: {},
+      config: {
+        connectionId: "conn-1",
+        roomId: "room-1",
+        markdown: "**hello**",
+      } as never,
+    });
+    expect(result.success).toBe(true);
+    if (!result.success) return;
+    expect(result.externalId).toBe("msg-42");
+    const artifact = result.artifact as { messageId: string; roomId: string };
+    expect(artifact.messageId).toBe("msg-42");
+    expect(artifact.roomId).toBe("room-1");
+    const call = fetchFixture.calls[0]!;
+    expect(call.url).toBe("https://webexapis.com/v1/messages");
+    expect(call.init.method).toBe("POST");
+    const headers = call.init.headers as Record<string, string>;
+    expect(headers.Authorization).toBe("Bearer secret-bot-token");
+    const body = JSON.parse(call.init.body as string) as {
+      roomId: string;
+      markdown: string;
+    };
+    expect(body.roomId).toBe("room-1");
+    expect(body.markdown).toBe("**hello**");
+  });
+
+  it("returns failure when the connection is missing", async () => {
+    const actions = createWebexActions();
+    const post = actions[0]!;
+    const result = await post.execute({
+      ...ctxBase,
+      consumedArtifacts: {},
+      config: {
+        connectionId: "missing",
+        roomId: "room-1",
+        markdown: "x",
+      } as never,
+    });
+    expect(result.success).toBe(false);
+    if (result.success) return;
+    expect(result.error).toMatch(/connection not found/i);
+  });
+
+  it("returns failure when the Webex API responds non-OK", async () => {
+    fetchFixture = setupFetchSequence([
+      { status: 400, raw: "bad request" },
+    ]);
+    const actions = createWebexActions();
+    const post = actions[0]!;
+    const result = await post.execute({
+      ...ctxBase,
+      consumedArtifacts: {},
+      config: {
+        connectionId: "conn-1",
+        roomId: "room-1",
+        markdown: "x",
+      } as never,
+    });
+    expect(result.success).toBe(false);
+    if (result.success) return;
+    expect(result.error).toMatch(/Webex API error \(400\)/);
+    expect(result.error).toMatch(/bad request/);
+  });
+});

package/src/automations.ts

@@ -0,0 +1,138 @@
+/**
+ * Webex action — post a markdown message to a Webex room.
+ *
+ * Replaces the legacy `webexProvider.deliver`. Template expansion is
+ * handled by the dispatch engine, so `config.markdown` is already the
+ * final string by the time `execute` runs.
+ */
+import { z } from "zod";
+import {
+  configString,
+  Versioned,
+  type Logger,
+} from "@checkstack/backend-api";
+import type { ActionDefinition } from "@checkstack/automation-backend";
+import { connectionStoreRef } from "@checkstack/integration-backend";
+import { extractErrorMessage } from "@checkstack/common";
+
+import {
+  WEBEX_RESOLVERS,
+  WEBEX_PROVIDER_QUALIFIED_ID,
+  type WebexConnectionConfig,
+} from "./provider";
+
+const WEBEX_API_BASE = "https://webexapis.com/v1";
+
+const webexMessageDataSchema = z.object({
+  messageId: z.string(),
+  roomId: z.string(),
+});
+
+export const webexMessageArtifactType = {
+  id: "message",
+  displayName: "Webex Message",
+  description: "A message posted to a Webex room",
+  schema: webexMessageDataSchema,
+} as const;
+
+const webexPostMessageConfigSchema = z.object({
+  connectionId: configString({
+    "x-options-resolver": WEBEX_RESOLVERS.CONNECTION_OPTIONS,
+  }).describe("Webex connection"),
+  roomId: configString({
+    "x-options-resolver": WEBEX_RESOLVERS.ROOM_OPTIONS,
+    "x-depends-on": ["connectionId"],
+  }).describe("Target Webex space"),
+  markdown: configString({ "x-editor-types": ["raw"] })
+    .min(1)
+    .describe("Markdown message body"),
+});
+
+type WebexPostMessageConfig = z.infer<typeof webexPostMessageConfigSchema>;
+
+async function postWebexMessage(params: {
+  botToken: string;
+  roomId: string;
+  markdown: string;
+  logger: Logger;
+}): Promise<
+  { success: true; messageId: string } | { success: false; error: string }
+> {
+  try {
+    const response = await fetch(`${WEBEX_API_BASE}/messages`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${params.botToken}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        roomId: params.roomId,
+        markdown: params.markdown,
+      }),
+      signal: AbortSignal.timeout(10_000),
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      return {
+        success: false,
+        error: `Webex API error (${response.status}): ${errorText.slice(0, 200)}`,
+      };
+    }
+    const data = (await response.json()) as { id: string };
+    return { success: true, messageId: data.id };
+  } catch (error) {
+    return { success: false, error: extractErrorMessage(error, "Unknown error") };
+  }
+}
+
+export function createWebexActions(): ActionDefinition<unknown, unknown>[] {
+  const postMessage: ActionDefinition<
+    WebexPostMessageConfig,
+    z.infer<typeof webexMessageDataSchema>
+  > = {
+    id: "post_message",
+    displayName: "Post Webex Message",
+    description: "Send a markdown message to a Webex space",
+    category: "Webex",
+    icon: "MessageSquare",
+    connectionProviderId: WEBEX_PROVIDER_QUALIFIED_ID,
+    config: new Versioned({
+      version: 1,
+      schema: webexPostMessageConfigSchema,
+    }),
+    produces: "message",
+    // Fetch the connection store lazily here rather than baking it in
+    // at registration time: integration-backend registers
+    // `connectionStoreRef` inside its own `init()`, so the topological
+    // sort can't statically order this plugin's init after that.
+    execute: async ({ config, logger, getService }) => {
+      const connectionStore = await getService(connectionStoreRef);
+      const connection = await connectionStore.getConnectionWithCredentials(
+        config.connectionId,
+      );
+      if (!connection) {
+        return {
+          success: false,
+          error: `Webex connection not found: ${config.connectionId}`,
+        };
+      }
+      const connConfig = connection.config as WebexConnectionConfig;
+      const result = await postWebexMessage({
+        botToken: connConfig.botToken,
+        roomId: config.roomId,
+        markdown: config.markdown,
+        logger,
+      });
+      if (!result.success) {
+        return { success: false, error: result.error };
+      }
+      logger.info(`Posted Webex message ${result.messageId}`);
+      return {
+        success: true,
+        externalId: result.messageId,
+        artifact: { messageId: result.messageId, roomId: config.roomId },
+      };
+    },
+  };
+  return [postMessage as ActionDefinition<unknown, unknown>];
+}

package/src/index.ts

@@ -1,16 +1,37 @@
-import { createBackendPlugin } from "@checkstack/backend-api";
+import { createBackendPlugin, coreServices } from "@checkstack/backend-api";
 import { providerExtensionPoint } from "@checkstack/integration-backend";
+import {
+  automationActionExtensionPoint,
+  automationArtifactTypeExtensionPoint,
+} from "@checkstack/automation-backend";
 import { pluginMetadata } from "./plugin-metadata";
 import { webexProvider } from "./provider";
+import {
+  createWebexActions,
+  webexMessageArtifactType,
+} from "./automations";
 
 export default createBackendPlugin({
   metadata: pluginMetadata,
-
   register(env) {
-    // Get the integration provider extension point
-    const extensionPoint = env.getExtensionPoint(providerExtensionPoint);
+    env
+      .getExtensionPoint(providerExtensionPoint)
+      .addProvider(webexProvider, pluginMetadata);
+    env
+      .getExtensionPoint(automationArtifactTypeExtensionPoint)
+      .registerArtifactType(webexMessageArtifactType, pluginMetadata);
 
-    // Register the Webex provider with our plugin metadata
-    extensionPoint.addProvider(webexProvider, pluginMetadata);
+    env.registerInit({
+      deps: {
+        logger: coreServices.logger,
+      },
+      init: async ({ logger }) => {
+        const actions = env.getExtensionPoint(automationActionExtensionPoint);
+        for (const action of createWebexActions()) {
+          actions.registerAction(action, pluginMetadata);
+        }
+        logger.debug("✅ Webex automation actions registered");
+      },
+    });
   },
 });