@zackbart/connecta 0.23.0 → 0.24.0

package/examples/worker/README.md

@@ -120,96 +120,80 @@ discover the skew in production ([#376](https://github.com/zackbart/connecta/iss
 no Clerk import, secret, package, or fallback provider. Docker deployments keep
 the Clerk path in the Node template.
 
-Then point an MCP client at `<PUBLIC_URL>/mcp`, and open `<PUBLIC_URL>/` for
-Connections. Credentials is at `/credentials`, named MCP access tokens are at
-`/tokens`, Activity is at `/activity`, and legacy `/ui` redirects to `/`. Each
-of those three appears in the nav only when this deployment can serve it — see
-the next section for what turns each one on.
-
-## The operator surface
-
-This example ships the whole operator feature set. Three quarters of it is on
-as deployed; the fourth needs a database, so it is commented in place.
-
-**Operator sign-in** is the `cloudflareAccessAuth()` entry in `src/index.ts`.
-Access authenticates before the Worker runs. A human Access identity can use
-MCP and human-management pages; a service-token identity can use MCP but cannot
-write a credential, run downstream OAuth, or issue a connecta token. Cloudflare
-still owns the outer application admission policy, but Connecta's user roster,
-connector access, and deployment roles stay in `src/index.ts`.
-
-**Several users** need no second auth system or Connecta account dashboard.
-Uncomment the `identity` block in `src/index.ts` to derive connector ids and
-deployment-operator membership from the Access principal. Connectors remain
-visible to everyone and every human remains an operator when that block is
-absent. A signed-in human may edit auth for every connector their view includes.
-Add `authScope: "personal"` when each user should connect a different downstream
-account; leave it shared only when any user with connector access may rotate the
-deployment-wide grant. Static headers stay shared because their value lives in
-deployment configuration. See [inbound identity](../../documentation/auth.md#principals-visibility-and-operators)
-for the resolver contract.
-
-**The credential vault** is `credentials: { encryptionKey: … }`, backed by the
-same KV namespace as everything else and encrypted with the
-`CREDENTIAL_ENCRYPTION_KEY` secret before a value reaches it. Generate one with:
+Then point an MCP client at `<PUBLIC_URL>/mcp`. The example explicitly enables
+`ui: operatorUi()`; open `<PUBLIC_URL>/` for Connections and each connection's
+authentication controls. There is no separate Credentials or Tokens tab.
+
+## Select optional modules
+
+`cloudflareAccessAuth()` reads trusted identity after Access admits the Worker
+request. Humans may use their code-derived connector view; service identities
+can use MCP but cannot manage personal or shared auth as an interactive human.
+Keep users, groups, and admission in Access. Connector visibility and management
+permissions belong in `src/index.ts`.
+
+`identity.connectorAccess` selects discoverable and callable connectors.
+`credentialAdministration` separately allows shared credential and OAuth
+management, while `personalConnection` allows a human to connect their own
+account. Both management permissions default to none. Grant the intended
+owner's shared permissions explicitly, and grant users personal permissions
+only for connectors configured with `authScope: "personal"`. Static headers
+remain deployment configuration. `activityAccess` governs global history reads.
+See [inbound identity](../../documentation/auth.md#principals-visibility-and-operators).
+
+### UI and encrypted credentials
+
+Import `operatorUi` from `@zackbart/connecta/ui` and set `ui: operatorUi()`.
+Branding belongs in `operatorUi({ branding })`. Omit the import and option to
+serve no UI routes; OAuth callbacks still work in core for authorized
+interactive MCP callers.
+
+Import `encryptedCredentialVault` from `@zackbart/connecta/credentials` and set
+`vault: encryptedCredentialVault(storage, env.CREDENTIAL_ENCRYPTION_KEY)` when
+the secret is configured. Keep this base64 32-byte key in Worker secrets:
 
 ```sh
 node -e "console.log(crypto.randomBytes(32).toString('base64'))"
 ```
 
-Leave the secret unset and the deployment still runs — `/credentials` stays
-read-only and connecta says so at startup. Keep the key in Worker secrets and
-nowhere near KV: it is the only thing that makes a copied namespace useless.
-Rotation takes effect on the next call, with no redeploy and no liveness probe,
-because credentials fail at use.
-
-The vault is ready here, and the Credentials page is still hidden, because that
-page lists connector credential slots rather than deployments. Neither
-connector in `src/index.ts` declares one — Notion carries a deployment-owned
-static header and echo has no secret — so nothing would be on the page. Add
-`credential: { label: "API token" }` to an `api()` connector (the commented
-shape on `echo` is exactly it) or use a provider connector such as `notion()`,
-which declares its own, and Credentials appears for a signed-in operator on the
-next load.
-
-**Access tokens** are `accessTokens: {}`. A signed-in human operator mints named,
-revocable Bearer tokens at `/tokens` for header-capable clients that will not do
-OAuth. Secrets are shown once and only their hashes enter KV; a lost token is
-reissued, never recovered. Note the KV caveat above — revocation is visible
-everywhere only as fast as the namespace converges.
-
-Worker-level Access still runs before these tokens. A `cta_…` token therefore
-does not reach connecta by itself; retain the feature as a rollback path or for
-a caller that already supplies separate Access service-token headers. Normal
-interactive MCP clients should use Managed OAuth, and unattended clients should
-use Access service tokens.
-
-**Activity** is the commented block in `src/index.ts` and the commented
-`d1_databases` binding in `wrangler.jsonc`; the section below creates the
-database and applies the schema.
-
-None of these change what agents can reach. Operator routes manage the
-authentication material behind capabilities `src/index.ts` already declares —
-never the connector set, the tool catalog, or its annotations.
-
-`connecta doctor` reports the same line here as for a deployment with none of
-this on: connector count, executor, seven tools. The executor it names is this
-one — `DynamicWorkerExecutor executed`, not the Node template's QuickJS, which
-is what doctor used to claim everywhere
-([#368](https://github.com/zackbart/connecta/issues/368)). Against Access it
-carries `CF_ACCESS_CLIENT_ID` and `CF_ACCESS_CLIENT_SECRET`, and the service
-identity learns the model-facing surface rather than deployment topology:
+Reuse the same key and KV namespace during upgrades. Without the secret, omit
+the vault; declared credential slots remain unmanageable. Keep the key outside
+KV because it protects a copied namespace. Credential replacement takes effect
+on the next call without redeploying; no liveness probe runs in the background.
+
+The shipped Notion connector uses a deployment-owned static header and echo
+needs no secret. To exercise vault controls, declare a `credential` slot on an
+`api()` connector or use a provider such as `notion()` that declares its own.
+Authorized users manage that slot inside the connection. Configuring a vault
+does not create credentials or permissions by itself.
+
+### Client authentication and activity
+
+Interactive MCP clients use Access Managed OAuth. Unattended clients use Access
+service tokens when needed. Connecta-issued `cta_` tokens and their management
+routes are removed; a configured Connecta bearer cannot cross the Access edge
+alone. See the [migration guide](../../documentation/upgrading.md#0240-optional-modules)
+if an older deployment still issues tokens.
+
+Activity uses `activityHistory({ store: d1ActivityStore(env.ACTIVITY_DB) })`
+from `@zackbart/connecta/activity`. Enable the database and bindings described
+below. Omit the module and store wiring to record no history and show no
+Activity tab. Diagnostics remain independent; `logger: "silent"` suppresses
+them explicitly.
+
+Verify MCP health and the exact seven tools with:
 
 ```sh
 CF_ACCESS_CLIENT_ID=… CF_ACCESS_CLIENT_SECRET=… \
   npx connecta doctor --url "$PUBLIC_URL"
 ```
 
-Confirm the operator surface the way an operator will: sign in at
-`<PUBLIC_URL>/` and check that Tokens is live. Credentials joins it
-once a connector declares a `credential` slot, and Activity once the D1 wiring
-below is on — the nav shows a page when the deployment can actually serve it,
-so a missing page is the honest report that its half is still off.
+Doctor reports the configured `DynamicWorkerExecutor`, not a presumed Node
+executor. Verify the UI separately as a human: check visible connections,
+explicit shared and personal auth permissions, and Activity only when enabled.
+The configured list loads before live connector checks; a slow provider must
+not prevent other connections from appearing. All capability and access changes
+still require a deployment-code change.
 
 ## Code mode
 
@@ -295,19 +279,19 @@ To enable it:
    the failure and returns the tool result unharmed — so the symptom is not an
    error your agent sees, it is an activity log that quietly stops recording.
 
-3. In `src/index.ts`, uncomment the `d1ActivityStore` import, the `ACTIVITY_DB`
-   field on `Env`, and the `activity` block — the three commented fragments
-   that together read:
+3. In `src/index.ts`, enable the `activityHistory` and `d1ActivityStore` imports,
+   the `ACTIVITY_DB` field on `Env`, and the `activity` option:
 
    ```ts
+   import { activityHistory } from "@zackbart/connecta/activity";
    import { d1ActivityStore } from "./d1-activity.js";
 
    createConnecta({
      // …
-     activity: {
+     activity: activityHistory({
        store: d1ActivityStore(env.ACTIVITY_DB),
        deploymentId: "production",
-     },
+     }),
    });
    ```
 

package/examples/worker/src/d1-activity.ts

@@ -2,7 +2,7 @@ import type {
   ActivityPage,
   ActivityStore,
 } from "@zackbart/connecta";
-import { InvalidActivityCursorError } from "@zackbart/connecta";
+import { InvalidActivityCursorError } from "@zackbart/connecta/activity";
 import {
   activityEventToRow,
   activityRowToEvent,

package/examples/worker/src/index.ts

@@ -1,3 +1,6 @@
+import { operatorUi } from "@zackbart/connecta/ui";
+// import { activityHistory } from "@zackbart/connecta/activity";
+import { encryptedCredentialVault } from "@zackbart/connecta/credentials";
 /**
  * connecta on Cloudflare Workers.
  *
@@ -63,9 +66,10 @@ interface Env {
 }
 
 function build(env: Env) {
+  const storage = cloudflareKvStorage(env.CONNECTA_KV);
   return createConnecta({
     publicUrl: env.PUBLIC_URL,
-    storage: cloudflareKvStorage(env.CONNECTA_KV),
+    storage,
     executor: new DynamicWorkerExecutor({ loader: env.LOADER }),
     auth: [
       // Access owns admission policy. A human identity may use MCP and the
@@ -83,7 +87,7 @@ function build(env: Env) {
     //     principal?.id === "ACCESS_USER_UUID"
     //       ? ["notion", "echo"]
     //       : ["echo"],
-    //   operatorAccess: ({ id }) => id === "ACCESS_USER_UUID",
+    //   activityAccess: ({ id }) => id === "ACCESS_USER_UUID",
     // },
     // Connectors that declare a `credential` slot become editable by every
     // signed-in human who can see that connector at /credentials, encrypted
@@ -98,19 +102,20 @@ function build(env: Env) {
     // ready and the page empty. Declare a slot (see the commented shape on
     // `echo`, or use a provider connector like `notion()`, which declares its
     // own) and the page appears on the next load.
-    credentials: { encryptionKey: env.CREDENTIAL_ENCRYPTION_KEY },
+    vault: encryptedCredentialVault(storage, env.CREDENTIAL_ENCRYPTION_KEY),
     // Eligible human operators can create named, revocable MCP Bearer tokens
     // at /tokens. Under Worker-level Access those tokens are a rollback tool,
     // not standalone edge credentials: Access still runs before connecta.
-    accessTokens: {},
+    ui: operatorUi(),
+    identity: { credentialAdministration: () => "all", personalConnection: () => "all" },
     // Payload-free activity at /activity, off until a database exists to hold
     // it. Uncomment the `d1_databases` binding in wrangler.jsonc, apply the
     // schema in README.md § "Activity history", then these three lines and the
     // import above.
-    // activity: {
+    // activity: activityHistory({
     //   store: d1ActivityStore(env.ACTIVITY_DB),
     //   deploymentId: "production",
-    // },
+    // }),
     connectors: [
       remoteMcp("notion", {
         url: "https://mcp.notion.com/mcp",

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@zackbart/connecta",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "type": "module",
   "sideEffects": false,
-  "description": "One MCP to rule them all — a single MCP endpoint aggregating many downstream connectors behind a code-first surface of seven meta-tools.",
+  "description": "One MCP to rule them all \u2014 a single MCP endpoint aggregating many downstream connectors behind a code-first surface of seven meta-tools.",
   "license": "MIT",
   "engines": {
     "node": ">=22.0.0"
@@ -94,6 +94,22 @@
     "./providers/vercel": {
       "types": "./dist/providers/vercel.d.ts",
       "import": "./dist/providers/vercel.js"
+    },
+    "./ui": {
+      "types": "./dist/ui.d.ts",
+      "import": "./dist/ui.js"
+    },
+    "./credentials": {
+      "types": "./dist/credentials.d.ts",
+      "import": "./dist/credentials.js"
+    },
+    "./activity": {
+      "types": "./dist/activity.d.ts",
+      "import": "./dist/activity.js"
+    },
+    "./auth/bearer": {
+      "types": "./dist/auth/bearer.d.ts",
+      "import": "./dist/auth/bearer.js"
     }
   },
   "scripts": {

package/templates/node/AGENTS.md

@@ -12,12 +12,14 @@ This repository is deployment configuration, not a copy of Connecta itself.
   Do not copy or modify Connecta package internals here.
 - Prefer `api()` when the agent must see an exact reviewed capability surface;
   `remoteMcp()` follows the downstream server's evolving tool catalog.
-- The operator surface — Clerk sign-in, credential vault, access tokens,
-  activity — ships as commented blocks in `src/index.ts`. Enable one by
-  uncommenting it and setting the variables it names in `.env`, never by
-  inventing a parallel configuration path. `README.md` § "Turn on the operator
-  surface" is the walkthrough; `src/file-activity.ts` is the deployment-owned
-  activity store the activity block wires.
+- The UI, encrypted credential vault, and activity history use explicit module
+  imports and typed `ui`, `vault`, and `activity` options in `src/index.ts`.
+  Follow README "Select optional modules". Auth management requires explicit
+  `credentialAdministration` or `personalConnection` permissions; visibility
+  alone never grants it. Configured bearer auth is a client option, not a human
+  management identity. Connecta-issued access tokens are removed.
+  `src/file-activity.ts` remains the deployment-owned history store.
+
 - Run `npm run typecheck` after configuration changes. With the server running,
   run `CONNECTA_TOKEN=... npm run doctor` before calling setup complete.
 - `Dockerfile` and `docker-compose.yml` containerize *this* source; they are

package/templates/node/README.md

@@ -44,79 +44,72 @@ So commit the `package-lock.json` that the `npm install` above wrote on this
 machine: from then on the build context carries it and every build takes the
 reproducible `npm ci` path.
 
-## Turn on the operator surface
+## Select optional modules
 
-Out of the box this deployment serves the seven-tool MCP surface and a
-read-only operator UI: open `http://localhost:8787/`, paste the bearer, and you
-get Connections. The other three pages are configuration away, and each one is
-a commented block in `src/index.ts` — uncomment it, set the variables it names
-in `.env`, restart. Do them in this order; the last two lean on the first, and
-Credentials wants one thing more than a block, called out in step 2.
+The template explicitly enables `ui: operatorUi()` from
+`@zackbart/connecta/ui`. Open `http://localhost:8787/` and supply the configured
+bearer to inspect Connections. Omit that option and import for an API-only
+server. OAuth callbacks remain in core even with no UI.
 
-**1. Operator sign-in (Clerk).** A bearer token is a client key. It may call
-tools and read connector status, but it may not write a credential or issue an
-access token — that would make one shared secret a deployment-admin key. An
-interactive identity is what unlocks the actionable half:
+Connection management needs an interactive identity. A configured bearer is a
+client key and never authorizes browser credential mutations. To enable Clerk:
 
 ```sh
-npm install @clerk/backend    # optional peer; it does not install with Connecta
+npm install @clerk/backend
 ```
 
-Set `CLERK_PUBLISHABLE_KEY` and `CLERK_SECRET_KEY`, uncomment the `clerkAuth`
-import, the two `process.env.CLERK_*` reads, and the `clerkAuth({ … })` entry in
-`auth`. Enable Dynamic Client Registration on the Clerk instance (OAuth
-Applications → DCR) if MCP clients should sign in through it too, and set
-`PUBLIC_URL` first — Clerk redirects back to it.
+Set `CLERK_PUBLISHABLE_KEY` and `CLERK_SECRET_KEY`, enable the corresponding
+`clerkAuth` import and auth entry in `src/index.ts`, and set `PUBLIC_URL`.
+Enable Dynamic Client Registration on the Clerk instance if MCP clients should
+sign in with OAuth. Connecta no longer issues named client access tokens; keep
+the configured bearer only for clients that need it.
 
-Clerk remains the identity provider when several people share this Docker
-deployment. Uncomment the `identity` block in `src/index.ts` to give each Clerk
-principal a config-derived connector view and to choose operators. Add
-`authScope: "personal"` to a connector when each person should supply their own
-credential or finish their own downstream OAuth flow. Without those options,
-all connectors and auth stay shared exactly as before.
+Set the code-owned identity resolvers deliberately. `connectorAccess` governs
+use; `credentialAdministration` permits shared-auth changes, and
+`personalConnection` permits the signed-in principal's personal-auth changes.
+Both management permissions default to none. Use `authScope: "personal"` for a
+connector where each person should connect their own downstream account.
+`activityAccess` separately selects readers of global activity.
 
-**2. Credential vault.** Uncomment `credentials` and set
+### Credential vault
+
+Import `encryptedCredentialVault` from `@zackbart/connecta/credentials`, then
+set `vault: encryptedCredentialVault(storage, credentialKey)`. Set
 `CONNECTA_CREDENTIAL_KEY` to a base64 32-byte AES key:
 
 ```sh
 node -e "console.log(crypto.randomBytes(32).toString('base64'))"
 ```
 
-Every connector that declares a `credential` slot then becomes editable at
-`/credentials`, with values encrypted in the state file. The shipped `time`
-connector declares none — telling the time needs no secret — so the key alone
-leaves the page hidden, which is the honest state for a page with nothing on
-it. Add `credential: { label: "API token" }` to an `api()` connector (the
-commented shape is in `src/index.ts`) and read it in a handler with
-`await ctx.credential?.get()`, or use a provider connector such as `notion()`,
-which declares its own; Credentials appears for a signed-in operator on the
-next restart. Keep the key anywhere
-except that file — it is the only thing standing between a copied state file
-and the secrets in it — and note that losing it makes stored values
-unreadable. A saved replacement takes effect on the next call; nothing
-restarts, and the deployment never probes a credential to see whether it still
-works. It fails at use, loudly, and the agent is routed to `/credentials`.
-
-**3. Access tokens.** Uncomment `accessTokens: {}`. A signed-in operator can
-then mint named, revocable Bearer tokens at `/tokens` for header-capable
-clients that will not do OAuth. Secrets are shown once and only their hashes
-are stored, so a lost token is reissued, never recovered.
-
-**4. Activity.** Uncomment the `activity` block and the `fileActivityStore`
-import. `/activity` then answers with who called what, when, how long it took,
-and whether it worked — never arguments, results, generated code, or raw error
-messages, because the store is never handed one. `src/file-activity.ts` is
-yours: it appends a line per call and rewrites the log down to the newest 5,000
-events once it runs a slack window past that, so the file holds a few hundred
-more than the ceiling between rewrites rather than being rewritten on every
-call. That is a retention policy chosen for a single container and worth
-revisiting for anything busier. In Docker the log lands on the same volume as
-the state file.
-
-None of this changes what agents can reach. Operator pages manage the
-authentication material behind capabilities this file already declares; the
-connector set, the tool catalog, and its annotations are `src/index.ts`'s
-business and stay that way.
+Keep this key outside the state file. Losing it makes saved values unreadable;
+upgrades must reuse it. The shipped `time` connector declares no credential
+slot. Add `credential: { label: "API token" }` to an `api()` connector and read
+it through `await ctx.credential?.get()`, or use a provider such as `notion()`
+that declares its own slot. Authorized humans manage the slot inside that
+connection on `/`; there is no separate Credentials tab.
+
+A saved replacement takes effect on the next call. Connecta tests credentials
+only on an explicit action and otherwise fails at use. Without a vault or UI,
+static credential recovery reports unavailable instead of offering a dead link.
+
+### Activity history and diagnostics
+
+Import `activityHistory` from `@zackbart/connecta/activity` and wire the template's
+`fileActivityStore` through `activity: activityHistory({ store })`. The Activity
+tab appears for authorized readers when the store supports listing. Omit this
+option and its store wiring to record no activity.
+
+`src/file-activity.ts` belongs to the deployment. It appends payload-free events
+and periodically retains the newest 5,000, allowing a small slack window between
+rewrites. Docker stores the log on the state volume. It records no arguments,
+results, generated code, or raw errors. Adjust retention in that file if needed.
+
+Diagnostics are independent. Keep the default logger or provide your own;
+`logger: "silent"` suppresses diagnostic output explicitly.
+
+The UI displays connections and current permissions. Configuration still owns
+the connector set, tool definitions, and access rules. There is no token tab,
+team roster, or policy editor.
 
 ## Deployment contract
 
@@ -153,11 +146,7 @@ Connecta doctor passed: 1 connector(s), QuickJS executed, prescribed seven-tool
 `QuickJS` is this deployment's sandbox, reported by the deployment itself —
 swap the executor and doctor names the one that actually ran the program.
 
-That is deliberate. Doctor holds a bearer, and a bearer learns the model-facing
-surface, not the deployment's configuration topology: whether this deployment
-issues access tokens or keeps a credential vault is operator data, and a client
-key is not an operator. Confirm the operator surface the way an operator will —
-sign in at `/` and check that the pages you turned on are there: Tokens and
-Activity once their blocks are uncommented, and Credentials once the vault has
-a connector credential slot to show. The nav lists a page only when this
-deployment can serve it, so an absent page is a report, not a fault.
+Doctor verifies the MCP contract. Verify UI behavior separately: sign in at `/`,
+confirm the visible connections and their permitted auth controls, and check
+Activity only when you enabled a readable history store. A missing optional
+feature should not leave a tab behind.

package/templates/node/package.json

@@ -15,7 +15,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@zackbart/connecta": "0.23.0",
+    "@zackbart/connecta": "0.24.0",
     "quickjs-emscripten": "0.32.0"
   },
   "devDependencies": {

package/templates/node/src/file-activity.ts

@@ -27,7 +27,7 @@ import type {
   ActivityStore,
   ToolCallActivityEvent,
 } from "@zackbart/connecta";
-import { InvalidActivityCursorError } from "@zackbart/connecta";
+import { InvalidActivityCursorError } from "@zackbart/connecta/activity";
 
 /**
  * Events allowed past `maxEvents` before the log is rewritten. Trimming on the

package/templates/node/src/index.ts

@@ -1,3 +1,7 @@
+import { bearerToken } from "@zackbart/connecta/auth/bearer";
+import { operatorUi } from "@zackbart/connecta/ui";
+// import { encryptedCredentialVault } from "@zackbart/connecta/credentials";
+// import { activityHistory } from "@zackbart/connecta/activity";
 /**
  * Prescribed Connecta deployment.
  *
@@ -20,7 +24,7 @@
  *   CONNECTA_CREDENTIAL_KEY  vault key, once the credentials block is on
  *   CONNECTA_ACTIVITY_FILE   activity log, once the activity block is on
  */
-import { api, bearerToken, createConnecta } from "@zackbart/connecta";
+import { api, createConnecta } from "@zackbart/connecta";
 import { fileStorage, listen } from "@zackbart/connecta/node";
 import { quickJsExecutor } from "@zackbart/connecta/quickjs";
 // Operator sign-in. Needs `npm install @clerk/backend` — it is an optional
@@ -74,7 +78,7 @@ const connecta = createConnecta({
   // identity: {
   //   connectorAccess: ({ principal }) =>
   //     principal?.id === "user_admin" ? "all" : ["time"],
-  //   operatorAccess: ({ id }) => id === "user_admin",
+  //   activityAccess: ({ id }) => id === "user_admin",
   // },
   publicUrl,
   // Required: model-written programs run in a bounded QuickJS child.
@@ -84,24 +88,19 @@ const connecta = createConnecta({
   // with this key — so keep the key out of that file and out of source:
   //   node -e "console.log(crypto.randomBytes(32).toString('base64'))"
   // Rotating a credential takes effect on the next call; no restart.
-  // credentials: { encryptionKey: process.env.CONNECTA_CREDENTIAL_KEY },
-  //
-  // Named, revocable Bearer tokens for MCP clients, issued at /tokens by a
-  // signed-in operator. Secrets are shown once; only their hashes are stored.
-  // Requires the Clerk block above — there is nobody to authorize issuance
-  // otherwise.
-  // accessTokens: {},
-  //
+  // vault: encryptedCredentialVault(storage, process.env.CONNECTA_CREDENTIAL_KEY!),
   // Payload-free activity history at /activity: who called what, when, how
   // long it took, and whether it worked. Never arguments, results, generated
   // code, or raw error messages. Commented because retention is yours to
   // choose — see src/file-activity.ts.
-  // activity: {
+  // activity: activityHistory({
   //   store: fileActivityStore(
   //     process.env.CONNECTA_ACTIVITY_FILE || "./.connecta-activity.jsonl",
   //   ),
   //   deploymentId: "production",
-  // },
+  // }),
+  ui: operatorUi(),
+  identity: { credentialAdministration: () => "all", personalConnection: () => "all" },
   connectors: [
     api("time", {
       description: "Time — current timestamp",

package/dist/access-tokens.d.ts

@@ -1,31 +0,0 @@
-import type { IdentityReference, InboundAuth, KVStorage } from "./types.js";
-export interface AccessTokenMetadata {
-    id: string;
-    name: string;
-    tokenPrefix: string;
-    createdAt: string;
-    revokedAt?: string;
-}
-export interface CreatedAccessToken {
-    token: string;
-    accessToken: AccessTokenMetadata;
-}
-/**
- * Deployment-scoped personal access tokens. Secret material is never
- * recoverable: authentication indexes a SHA-256 digest of a random 256-bit
- * token, while separately enumerable metadata powers operator management.
- */
-export declare class AccessTokenManager {
-    private readonly storage;
-    readonly auth: InboundAuth;
-    private readonly maxActive;
-    constructor(storage: KVStorage, options?: {
-        maxActive?: number;
-    });
-    private read;
-    list(): Promise<AccessTokenMetadata[]>;
-    create(name: unknown, createdBy: string | IdentityReference): Promise<CreatedAccessToken>;
-    rename(id: string, name: unknown): Promise<AccessTokenMetadata | null>;
-    revoke(id: string, revokedBy: string): Promise<AccessTokenMetadata | null>;
-    private authorize;
-}