Add a Manus plugin covering API v2

apps/hub/src/connection-live-reconcile.test.ts

@@ -0,0 +1,46 @@
+// The hub connect hook must relaunch a live assistant the moment a
+// `feedsTools` connector (Manus) is stored — not wait for a new invite,
+// and not persist-only. `createHub` is not booted here; this is the
+// hook body `apps/hub/src/index.ts` fires from `settleServiceConnection`.
+import { describe, expect, test } from "bun:test";
+import { CONNECTOR_REGISTRY } from "@workbench/connections/registry";
+import { reconcilePinnedToolPackagesAfterConnect } from "./connection-live-reconcile";
+
+describe("reconcilePinnedToolPackagesAfterConnect", () => {
+  test("manus connect relaunches live assistants that pin @corbits/manus-tools", async () => {
+    const calls: { tenantId: string; packages: readonly string[] }[] = [];
+    const result = await reconcilePinnedToolPackagesAfterConnect(
+      {
+        reconcilePinnedToolPackages: async (tenantId, packageNames) => {
+          calls.push({ tenantId, packages: [...packageNames] });
+          return { scanned: 1, relaunched: 1 };
+        },
+      },
+      { tenantId: "ten_1", connectorId: "manus" },
+    );
+
+    expect(CONNECTOR_REGISTRY["manus"]?.feedsTools).toEqual([
+      "@corbits/manus-tools",
+    ]);
+    expect(result).toEqual({ scanned: 1, relaunched: 1 });
+    expect(calls).toEqual([
+      { tenantId: "ten_1", packages: ["@corbits/manus-tools"] },
+    ]);
+  });
+
+  test("an inference-only connector does not relaunch for tool-package pins", async () => {
+    const calls: unknown[] = [];
+    const result = await reconcilePinnedToolPackagesAfterConnect(
+      {
+        reconcilePinnedToolPackages: async (...args) => {
+          calls.push(args);
+          return { scanned: 0, relaunched: 0 };
+        },
+      },
+      { tenantId: "ten_1", connectorId: "anthropic" },
+    );
+
+    expect(result).toBeUndefined();
+    expect(calls).toEqual([]);
+  });
+});

apps/hub/src/connection-live-reconcile.ts

@@ -0,0 +1,30 @@
+// After a connector's credential lands, live assistants that already
+// pin that connector's `feedsTools` packages still run the snapshot
+// deployed at launch. Bindings for those packages
+// (`pinnedPackageCredentialBindingsFor`) fold only at deploy, so a Myra
+// launched at signup before Manus was pasted cannot `resolve("manus")`
+// until this pass relaunches it. Persist-only (stamp the pin onto the
+// launch row and leave the run) is the bug: the sidecar keeps the old
+// snapshot.
+import { CONNECTOR_REGISTRY } from "@workbench/connections/registry";
+
+export type PinnedToolPackageReconcile = {
+  reconcilePinnedToolPackages(
+    tenantId: string,
+    packageNames: readonly string[],
+  ): Promise<{ scanned: number; relaunched: number }>;
+};
+
+/**
+ * Relaunches live participants in `tenantId` whose pins include this
+ * connector's `feedsTools`. Returns `undefined` when the connector
+ * feeds no tool packages (inference-only, webhook, …).
+ */
+export async function reconcilePinnedToolPackagesAfterConnect(
+  platform: PinnedToolPackageReconcile,
+  info: { readonly tenantId: string; readonly connectorId: string },
+): Promise<{ scanned: number; relaunched: number } | undefined> {
+  const feedsTools = CONNECTOR_REGISTRY[info.connectorId]?.feedsTools ?? [];
+  if (feedsTools.length === 0) return undefined;
+  return platform.reconcilePinnedToolPackages(info.tenantId, feedsTools);
+}

apps/hub/src/index.ts

@@ -358,6 +358,8 @@ import { createBootAssetWiring, REGISTRIES } from "./asset-service-factory";
 import { createRoutineScheduler } from "./routine-scheduler";
 import { createToolGrantsForPins } from "./tool-grants";
 import { createMcpCredentialBindingsFor } from "./mcp-credential-bindings";
+import { reconcilePinnedToolPackagesAfterConnect } from "./connection-live-reconcile";
+import { createPinnedPackageCredentialBindingsFor } from "./pinned-package-credential-bindings";
 import { shutdownHub } from "./shutdown";
 
 // Host policy constants, not configuration.
@@ -717,6 +719,20 @@ export async function createHub(config: HubConfig) {
   );
   // See `./mcp-credential-bindings.ts`'s own doc.
   const mcpCredentialBindingsFor = createMcpCredentialBindingsFor(db);
+  // Same owning check GET /connections uses — see
+  // `@workbench/connections`' `workflow-connection-routes.ts` and the
+  // `createWorkflowConnectionRoutes` wiring below. Not
+  // `listConnectedProviders` (catalog-only).
+  const isConnectorConnected = async (tenantId: string, connectorId: string) =>
+    (await resolveCredentialRequirement(
+      db,
+      tenantId,
+      { providerName: connectorId, source: "tenant" },
+      null,
+      null,
+    )) !== null;
+  const pinnedPackageCredentialBindingsFor =
+    createPinnedPackageCredentialBindingsFor(isConnectorConnected);
   const sidecarRouter = createSidecarRouter({
     hubPublicKey,
     authenticateSidecar: createSidecarTokenAuthenticator({ db }),
@@ -1281,6 +1297,7 @@ export async function createHub(config: HubConfig) {
     credentialCipher,
     toolGrantsForPins,
     mcpCredentialBindingsFor,
+    pinnedPackageCredentialBindingsFor,
     // Chat residents are undeployed on idle again (see the comment above
     // this function): `chatIdleReapMs` (env-overridable via
     // `WORKBENCH_CHAT_IDLE_REAP_MS`, default 30 minutes) is
@@ -1987,6 +2004,7 @@ export async function createHub(config: HubConfig) {
             eventCollectors,
             toolGrantsForPins,
             mcpCredentialBindingsFor,
+            pinnedPackageCredentialBindingsFor,
             cryptoProviderCache: foldedRunCryptoProviders,
             launchMode: AGENT_SECTION_MODE,
             persistLaunch: workbenchLaunchPersistExtra,
@@ -2008,9 +2026,13 @@ export async function createHub(config: HubConfig) {
   // An inference provider's credential landing also re-checks every
   // live participant's deployed inference chain (CL-6687): a rotated
   // key only ever reaches an agent at deploy time, so the relaunch has
-  // to be kicked here, not left for the next message. Not awaited — a
-  // relaunch is a sidecar deploy round-trip, and the connect response
-  // must not wait on it.
+  // to be kicked here, not left for the next message. A tool-package
+  // connector (`feedsTools`, e.g. Manus) is the same shape for a
+  // different payload: `pinnedPackageCredentialBindingsFor` only folds
+  // at deploy, so a live Myra launched at signup before the key was
+  // pasted stays on a snapshot that cannot `resolve("manus")` until
+  // this pass relaunches it. Not awaited — a relaunch is a sidecar
+  // deploy round-trip, and the connect response must not wait on it.
   const settleServiceConnection: ServiceConnectedHook = async (info) => {
     await settleConnectedService(
       {
@@ -2027,15 +2049,27 @@ export async function createHub(config: HubConfig) {
         displayName: info.displayName,
       },
     );
-    if (!isInferenceProvider(info.connectorId)) return;
-    void chatPlatform
-      .reconcileInferenceSources(info.tenantId)
-      .then(({ scanned, relaunched }) => {
-        log.info`inference credential ${info.connectorId} changed on tenant ${info.tenantId}: re-checked ${String(scanned)} live agents, relaunched ${String(relaunched)}`;
+    if (isInferenceProvider(info.connectorId)) {
+      void chatPlatform
+        .reconcileInferenceSources(info.tenantId)
+        .then(({ scanned, relaunched }) => {
+          log.info`inference credential ${info.connectorId} changed on tenant ${info.tenantId}: re-checked ${String(scanned)} live agents, relaunched ${String(relaunched)}`;
+        })
+        .catch((cause: unknown) => {
+          reportError(cause, {
+            operation: "connections.reconcile-inference-sources",
+            tenantId: info.tenantId,
+          });
+        });
+    }
+    void reconcilePinnedToolPackagesAfterConnect(chatPlatform, info)
+      .then((result) => {
+        if (result === undefined) return;
+        log.info`tool-package connector ${info.connectorId} changed on tenant ${info.tenantId}: re-checked ${String(result.scanned)} live agents, relaunched ${String(result.relaunched)}`;
       })
       .catch((cause: unknown) => {
         reportError(cause, {
-          operation: "connections.reconcile-inference-sources",
+          operation: "connections.reconcile-pinned-tool-packages",
           tenantId: info.tenantId,
         });
       });
@@ -2458,18 +2492,9 @@ export async function createHub(config: HubConfig) {
     "/api/workflow-connections",
     createWorkflowConnectionRoutes({
       authenticator: createWorkflowRunAuthenticator({ db }),
-      // The same resolution `buildCredentialDelivery` uses at agent-launch
-      // time to decide whether a tool actually gets a credential — so
-      // `list_connections` reports exactly what an agent could really use,
-      // for an inference provider and a tool connector alike (CL-6492).
-      isConnectorConnected: async (tenantId, connectorId) =>
-        (await resolveCredentialRequirement(
-          db,
-          tenantId,
-          { providerName: connectorId, source: "tenant" },
-          null,
-          null,
-        )) !== null,
+      // Same `isConnectorConnected` the pinned-package factory is wired
+      // with above (CL-6492).
+      isConnectorConnected,
       listMcpServers: (tenantId) => listMcpServerConnections(db, tenantId),
     }),
   );
@@ -2537,6 +2562,7 @@ export async function createHub(config: HubConfig) {
     hubPublicKey,
     toolGrantsForPins,
     mcpCredentialBindingsFor,
+    pinnedPackageCredentialBindingsFor,
   };
 
   // Every genuine top-level deployment run, folded runs (workbench hosts,
@@ -2727,6 +2753,7 @@ export async function createHub(config: HubConfig) {
     credentialCipher,
     toolGrantsForPins,
     mcpCredentialBindingsFor,
+    pinnedPackageCredentialBindingsFor,
     cryptoProviderCache: foldedRunCryptoProviders,
     joinDeliveryWorkbench: (input) =>
       joinRunParticipant({ store: chatStore }, input),

apps/hub/src/pinned-package-credential-bindings.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, test } from "bun:test";
+import {
+  bindingsForConnectedPins,
+  createPinnedPackageCredentialBindingsFor,
+} from "./pinned-package-credential-bindings";
+
+const MANUS_PIN = { name: "@corbits/manus-tools", version: "*" };
+const GRANOLA_PIN = { name: "@corbits/granola-tools", version: "*" };
+
+describe("bindingsForConnectedPins", () => {
+  test("emits a manus tenant binding when manus-tools is pinned and Manus is connected", () => {
+    expect(bindingsForConnectedPins([MANUS_PIN], ["manus"])).toEqual([
+      {
+        package: "@corbits/manus-tools",
+        handle: "manus",
+        provider: "manus",
+        locator: "tenant",
+      },
+    ]);
+  });
+
+  test("returns none when manus-tools is pinned but Manus is not connected", () => {
+    expect(bindingsForConnectedPins([MANUS_PIN], ["granola"])).toEqual([]);
+  });
+
+  test("returns none when Manus is connected but manus-tools is not pinned", () => {
+    expect(bindingsForConnectedPins([GRANOLA_PIN], ["manus"])).toEqual([]);
+  });
+
+  test("emits a granola binding when granola-tools is pinned and Granola is connected", () => {
+    expect(bindingsForConnectedPins([GRANOLA_PIN], ["granola"])).toEqual([
+      {
+        package: "@corbits/granola-tools",
+        handle: "granola",
+        provider: "granola",
+        locator: "tenant",
+      },
+    ]);
+  });
+
+  test("returns none for empty pins even when connectors are connected", () => {
+    expect(bindingsForConnectedPins([], ["manus", "granola"])).toEqual([]);
+  });
+});
+
+describe("createPinnedPackageCredentialBindingsFor", () => {
+  test("emits a manus tenant binding when isConnectorConnected is true for manus", async () => {
+    const bindingsFor = createPinnedPackageCredentialBindingsFor(
+      async (_tenantId, connectorId) => connectorId === "manus",
+    );
+    expect(await bindingsFor("tenant-1", [MANUS_PIN])).toEqual([
+      {
+        package: "@corbits/manus-tools",
+        handle: "manus",
+        provider: "manus",
+        locator: "tenant",
+      },
+    ]);
+  });
+
+  test("emits none when only a catalog-style inference connector is connected", async () => {
+    const bindingsFor = createPinnedPackageCredentialBindingsFor(
+      async (_tenantId, connectorId) => connectorId === "anthropic",
+    );
+    expect(await bindingsFor("tenant-1", [MANUS_PIN])).toEqual([]);
+  });
+});

apps/hub/src/pinned-package-credential-bindings.ts

@@ -0,0 +1,61 @@
+// The `PinnedPackageCredentialBindingsFor` port every `FoldedRunsDeps`
+// below is wired with — see `@corbits/folded-runs`' `types.ts` for why
+// this has to be supplied by the composition root rather than declared as
+// a required assistant `credentialBindings` entry. Static-handle packages
+// (`@corbits/manus-tools`, granola-tools, …) declare
+// `interchange.credentials`, but requiring those binds on the assistant
+// would throw `MissingCredentialError` on signup / first chat. This
+// factory emits a tenant binding only when a pin names a package a
+// `CONNECTOR_REGISTRY` entry `feedsTools` AND the tenant already has a
+// connected credential for that connector (`isConnectorConnected`, the
+// same owning check `createWorkflowConnectionRoutes` uses — not
+// `@corbits/chat`'s catalog-only `listConnectedProviders`).
+import type { CredentialBinding } from "@intx/types";
+import type { ToolPackagePin } from "@intx/types/tool-packages";
+import type { PinnedPackageCredentialBindingsFor } from "@corbits/folded-runs";
+import { CONNECTOR_REGISTRY } from "@workbench/connections/registry";
+
+export type IsConnectorConnected = (
+  tenantId: string,
+  connectorId: string,
+) => Promise<boolean>;
+
+export function bindingsForConnectedPins(
+  pins: readonly ToolPackagePin[],
+  connectedConnectorIds: readonly string[],
+): readonly CredentialBinding[] {
+  const pinNames = new Set(pins.map((pin) => pin.name));
+  if (pinNames.size === 0) return [];
+  const connected = new Set(connectedConnectorIds);
+  const bindings: CredentialBinding[] = [];
+  for (const descriptor of Object.values(CONNECTOR_REGISTRY)) {
+    if (!connected.has(descriptor.id)) continue;
+    for (const toolPackageName of descriptor.feedsTools) {
+      if (!pinNames.has(toolPackageName)) continue;
+      bindings.push({
+        package: toolPackageName,
+        handle: descriptor.id,
+        provider: descriptor.id,
+        locator: "tenant",
+      });
+    }
+  }
+  return bindings;
+}
+
+export function createPinnedPackageCredentialBindingsFor(
+  isConnectorConnected: IsConnectorConnected,
+): PinnedPackageCredentialBindingsFor {
+  return async (tenantId, pins) => {
+    const pinNames = new Set(pins.map((pin) => pin.name));
+    if (pinNames.size === 0) return [];
+    const connectedConnectorIds: string[] = [];
+    for (const descriptor of Object.values(CONNECTOR_REGISTRY)) {
+      if (!descriptor.feedsTools.some((name) => pinNames.has(name))) continue;
+      if (await isConnectorConnected(tenantId, descriptor.id)) {
+        connectedConnectorIds.push(descriptor.id);
+      }
+    }
+    return bindingsForConnectedPins(pins, connectedConnectorIds);
+  };
+}

apps/hub/src/tool-grants.test.ts

@@ -4,6 +4,7 @@
 // `@corbits/folded-runs`' `deployAtHead`, which mints these into
 // `config.grants`.
 import { describe, expect, test } from "bun:test";
+import { describeCorbitsToolPackages } from "@corbits/tool-registry-publish";
 import { createToolGrantsForPins } from "./tool-grants";
 
 const DESCRIPTIONS = [
@@ -85,4 +86,22 @@ describe("createToolGrantsForPins", () => {
     const toolGrantsForPins = createToolGrantsForPins(DESCRIPTIONS);
     expect(toolGrantsForPins([])).toEqual([]);
   });
+
+  test("assistant pin of webhook_create is ask, not allow", async () => {
+    const toolGrantsForPins = createToolGrantsForPins(
+      await describeCorbitsToolPackages(),
+    );
+    const grants = toolGrantsForPins([
+      { name: "@corbits/manus-tools", version: "*" },
+    ]);
+    expect(
+      grants.find((g) => g.resource.endsWith(":webhook_create"))?.effect,
+    ).toBe("ask");
+    expect(
+      grants.find((g) => g.resource.endsWith(":create_slides"))?.effect,
+    ).toBe("allow");
+    expect(grants.find((g) => g.resource.endsWith(":task_list"))?.effect).toBe(
+      "allow",
+    );
+  });
 });