@zackbart/connecta 0.21.1 → 0.22.0

package/dist/credentials.js

@@ -110,8 +110,10 @@ export function describeCredentialTestMismatch(mismatch) {
             "`testCredential(value, ctx)` can test, but implements " +
             "`testCredentials`";
 }
-function storageKey(connectorId) {
-    return `conn:${connectorId}:credential:v1`;
+function storageKey(connectorId, owner) {
+    return owner
+        ? `principal:${owner}:conn:${connectorId}:credential:v1`
+        : `conn:${connectorId}:credential:v1`;
 }
 function bytesToBase64(bytes) {
     let binary = "";
@@ -205,11 +207,13 @@ export class CredentialVault {
         }
         this.key = crypto.subtle.importKey("raw", raw, { name: "AES-GCM" }, false, ["encrypt", "decrypt"]);
     }
-    additionalData(connectorId) {
-        return encoder.encode(`connecta:credential:${connectorId}:v1`);
+    additionalData(connectorId, owner) {
+        return encoder.encode(owner
+            ? `connecta:credential:principal:${owner}:${connectorId}:v1`
+            : `connecta:credential:${connectorId}:v1`);
     }
-    async read(connectorId) {
-        const raw = await this.storage.get(storageKey(connectorId));
+    async read(connectorId, owner) {
+        const raw = await this.storage.get(storageKey(connectorId, owner));
         if (!raw)
             return null;
         const envelope = parseEnvelope(raw);
@@ -217,7 +221,7 @@ export class CredentialVault {
             const plaintext = await crypto.subtle.decrypt({
                 name: "AES-GCM",
                 iv: base64ToBytes(envelope.iv),
-                additionalData: this.additionalData(connectorId),
+                additionalData: this.additionalData(connectorId, owner),
             }, await this.key, base64ToBytes(envelope.ciphertext));
             return parsePlaintext(decoder.decode(plaintext));
         }
@@ -225,15 +229,15 @@ export class CredentialVault {
             throw new Error("Stored credential could not be decrypted");
         }
     }
-    async get(connectorId, field = "value") {
-        return (await this.read(connectorId))?.values[field] ?? null;
+    async get(connectorId, field = "value", owner) {
+        return (await this.read(connectorId, owner))?.values[field] ?? null;
     }
-    async getAll(connectorId) {
-        const credential = await this.read(connectorId);
+    async getAll(connectorId, owner) {
+        const credential = await this.read(connectorId, owner);
         return credential ? { ...credential.values } : null;
     }
-    async metadata(connectorId) {
-        const credential = await this.read(connectorId);
+    async metadata(connectorId, owner) {
+        const credential = await this.read(connectorId, owner);
         if (!credential)
             return null;
         const fields = Object.fromEntries(Object.entries(credential.values).map(([field, value]) => [
@@ -254,13 +258,13 @@ export class CredentialVault {
             fields,
         };
     }
-    async set(connectorId, value, updatedBy) {
+    async set(connectorId, value, updatedBy, owner) {
         // `await` (not a bare promise return) so a validation throw inside setAll
         // never sits handler-less for the thenable-adoption microtask — workerd
         // reports that gap as an unhandled rejection.
-        return await this.setAll(connectorId, { value }, updatedBy);
+        return await this.setAll(connectorId, { value }, updatedBy, owner);
     }
-    async setAll(connectorId, values, updatedBy) {
+    async setAll(connectorId, values, updatedBy, owner) {
         const normalized = validateValues(values);
         const plaintext = {
             values: normalized,
@@ -271,7 +275,7 @@ export class CredentialVault {
         const ciphertext = await crypto.subtle.encrypt({
             name: "AES-GCM",
             iv,
-            additionalData: this.additionalData(connectorId),
+            additionalData: this.additionalData(connectorId, owner),
         }, await this.key, encoder.encode(JSON.stringify(plaintext)));
         const envelope = {
             version: 1,
@@ -279,10 +283,10 @@ export class CredentialVault {
             iv: bytesToBase64(iv),
             ciphertext: bytesToBase64(new Uint8Array(ciphertext)),
         };
-        await this.storage.set(storageKey(connectorId), JSON.stringify(envelope));
-        return (await this.metadata(connectorId));
+        await this.storage.set(storageKey(connectorId, owner), JSON.stringify(envelope));
+        return (await this.metadata(connectorId, owner));
     }
-    async delete(connectorId) {
-        await this.storage.delete(storageKey(connectorId));
+    async delete(connectorId, owner) {
+        await this.storage.delete(storageKey(connectorId, owner));
     }
 }

package/dist/executors/quickjs.js

@@ -278,6 +278,10 @@ class QuickJsChildPool {
                 "@zackbart/connecta/quickjs) when bundling the server.");
         }
         const child = fork(childPath, [], {
+            // The child needs only its entry path, exec arguments, and IPC channel.
+            // Do not copy deployment credentials or Node startup configuration into
+            // the process that contains the guest runtime.
+            env: {},
             execArgv: sourceMode ? ["--import", "tsx"] : [],
             stdio: ["ignore", "ignore", "pipe", "ipc"],
         });

package/dist/identity.d.ts

@@ -0,0 +1,4 @@
+import type { IdentityReference } from "./types.js";
+export declare function validIdentityReference(value: IdentityReference | undefined): value is IdentityReference;
+/** Deterministic pseudonymous partition; raw emails and ids do not enter keys. */
+export declare function identityStorageKey(identity: IdentityReference): Promise<string>;

package/dist/identity.js

@@ -0,0 +1,17 @@
+const IDENTITY_PART_RE = /^[\x21-\x7e]{1,256}$/;
+const encoder = new TextEncoder();
+export function validIdentityReference(value) {
+    return Boolean(value &&
+        IDENTITY_PART_RE.test(value.namespace) &&
+        IDENTITY_PART_RE.test(value.id));
+}
+function bytesToHex(bytes) {
+    return [...bytes]
+        .map((byte) => byte.toString(16).padStart(2, "0"))
+        .join("");
+}
+/** Deterministic pseudonymous partition; raw emails and ids do not enter keys. */
+export async function identityStorageKey(identity) {
+    const digest = await crypto.subtle.digest("SHA-256", encoder.encode(`${identity.namespace}\n${identity.id}`));
+    return bytesToHex(new Uint8Array(digest));
+}

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { Registry } from "./registry.js";
 import type { ActivityReadGate, ActivityStore } from "./activity.js";
-import type { Connector, ConnectaBranding, Executor, InboundAuth, KVStorage, Logger } from "./types.js";
+import type { AuthenticatedIdentity, Connector, ConnectaBranding, Executor, IdentityReference, InboundAuth, KVStorage, Logger } from "./types.js";
 /** Payload-free activity storage and operator-read policy. */
 export interface ConnectaActivityConfig {
     /**
@@ -115,10 +115,24 @@ export interface ConnectaAdmissionConfig {
      */
     code?: AdmissionPoolConfig;
 }
+/** Config-owned identity rules for one deployment and tenant. */
+export interface ConnectaIdentityConfig {
+    /** Connector ids this admitted identity may discover and call. */
+    connectorAccess?(identity: Readonly<AuthenticatedIdentity>): "all" | readonly string[] | Promise<"all" | readonly string[]>;
+    /**
+     * Whether a human may manage deployment access tokens and global activity.
+     * Connector access already permits that human to manage the visible
+     * connector's shared or personal auth. Omit to preserve the existing
+     * all-interactive-humans operator rule.
+     */
+    operatorAccess?(principal: Readonly<IdentityReference>): boolean | Promise<boolean>;
+}
 export interface ConnectaConfig {
     connectors: Connector[];
     /** Inbound auth adapters. Includes bearerToken(...); omit for open (dev). */
     auth?: InboundAuth | InboundAuth[];
+    /** Identity-derived connector visibility and deployment operator membership. */
+    identity?: ConnectaIdentityConfig;
     /** KVStorage impl. Defaults to memoryStorage(). */
     storage?: KVStorage;
     /**
@@ -192,6 +206,6 @@ export { CONNECTA_VERSION } from "./version.js";
 export type { Registry } from "./registry.js";
 export type { RemoteMcpOptions, RemoteMcpAuth, RemoteMcpRedirectPolicy, } from "./connectors/remote-mcp.js";
 export type { ApiOptions, ApiTool } from "./connectors/api.js";
-export type { CatalogDriftCounts, CatalogDriftReport, Connector, ConnectorCallAdmissionInput, ConnectorCallAdmissionPolicy, ConnectorCallAdmissionRule, ConnectorRollingWindowBudget, ConnectaBranding, ConnectorCredentialAccess, ConnectorCredentialConfig, ConnectorCredentialFieldConfig, ConnectorCredentialValues, ConnectorContext, ConnectorUsageGuide, ConnectorStatus, CredentialTestResult, AdmittingExecutor, AdmissionSnapshot, ExecuteResult, Executor, ExecutorLease, ExecutorProvider, InboundAuth, InboundAuthRuntimeContext, UiAuthConfig, AuthResult, JsonSchema, KVStorage, Logger, ToolDef, ToolAnnotations, } from "./types.js";
+export type { CatalogDriftCounts, CatalogDriftReport, Connector, ConnectorCallAdmissionInput, ConnectorCallAdmissionPolicy, ConnectorCallAdmissionRule, ConnectorRollingWindowBudget, ConnectaBranding, ConnectorCredentialAccess, ConnectorCredentialConfig, ConnectorCredentialFieldConfig, ConnectorCredentialValues, ConnectorContext, ConnectorUsageGuide, ConnectorStatus, CredentialTestResult, AdmittingExecutor, AdmissionSnapshot, ExecuteResult, Executor, ExecutorLease, ExecutorProvider, InboundAuth, InboundAuthRuntimeContext, UiAuthConfig, AuthResult, AuthenticatedIdentity, IdentityReference, JsonSchema, KVStorage, Logger, ToolDef, ToolAnnotations, } from "./types.js";
 export type { ActivityActor, ActivityCallSource, ActivityOutcome, ActivityPage, ActivityReadActor, ActivityReadEvent, ActivityReader, ActivityReadGate, ActivityReadPage, ActivitySink, ActivityStore, AgentFriction, CatalogDriftActivityEvent, ToolCallActivityEvent, } from "./activity.js";
 export { InvalidActivityCursorError } from "./activity.js";

package/dist/index.js

@@ -51,6 +51,10 @@ const admissionPoolSchema = {
 const CONFIG_SCHEMA = {
     connectors: null,
     auth: null,
+    identity: {
+        connectorAccess: null,
+        operatorAccess: null,
+    },
     storage: null,
     publicUrl: null,
     activity: {
@@ -250,7 +254,7 @@ export function createConnecta(config) {
     const credentialConnectors = config.connectors.filter((c) => c.credential);
     const encryptionKey = config.credentials?.encryptionKey;
     if (credentialConnectors.length > 0 && !encryptionKey) {
-        logger.warn("Operator-managed credentials are unavailable because " +
+        logger.warn("Human-managed credentials are unavailable because " +
             "credentials.encryptionKey is not configured for connectors: " +
             credentialConnectors.map((c) => c.id).join(", "));
     }
@@ -310,6 +314,7 @@ export function createConnecta(config) {
     const handler = createFetchHandler({
         registry,
         auth: inboundAuth,
+        identity: config.identity,
         publicUrl: config.publicUrl,
         serverInfo,
         logger,

package/dist/meta-tools.js

@@ -479,13 +479,18 @@ export function createMetaTools(registry, baseUrl, opts = {}) {
                     },
                     operatorUrl: new URL("/credentials", baseUrl).toString(),
                     instructions: "Have the operator open operatorUrl, set and test the credential, " +
-                        "then retry the original call. No redeploy is needed. Credential " +
-                        "mutation requires a Clerk-authenticated operator.",
+                        "then retry the original call. No redeploy is needed. " +
+                        (connector.authScope === "personal"
+                            ? "Credential mutation requires the signed-in principal who owns this connection."
+                            : "Shared credential mutation requires a signed-in human with access to this connector."),
                 });
             }
             const ctx = registry.contextFor(connector.id, baseUrl, requestScope);
             try {
                 const status = await connector.startAuth(ctx, args.force !== undefined ? { force: args.force } : {});
+                if (status.authorizationUrl) {
+                    await registry.bindOAuthHandoff(connector.id, status.authorizationUrl);
+                }
                 if (status.state === "auth_required" && !status.authorizationUrl) {
                     // auth_required with nothing to open is a dead end for the operator.
                     return errorResult(`Connector "${connector.id}": authorization required but no URL is available — retry authorize_connector.`);