@capybara-hq/kernel 0.1.0-rc.4 → 0.1.0-rc.5

package/dist/tools/connectors.service.js

@@ -12,7 +12,8 @@ import { connectorToolKey, ToolError, } from "@capybara-hq/plugin-sdk";
 import { Inject, Injectable } from "@nestjs/common";
 import { sql } from "kysely";
 import { z } from "zod";
-import { assertItemInstallable } from "../catalog/requests.service.js";
+import { connectorTemplateState } from "../catalog/component-state.js";
+import { assertItemInstallable } from "../catalog/request-rules.js";
 import { ApiError } from "../errors.js";
 import { ExtensionRegistry } from "../extensions/registry.js";
 import { audit } from "../identity/audit.js";
@@ -142,6 +143,34 @@ let ConnectorsService = class ConnectorsService {
             .executeTakeFirst();
         return row !== undefined;
     }
+    /**
+     * The first free default name and slug ({@link CreateConnectorInput.slugDefault}), read in the
+     * caller's transaction under the org lock.
+     */
+    async freeName(t, orgId, d) {
+        const base = deriveSlug(d.name ?? d.display) ?? deriveSlug(d.display);
+        if (base === null) {
+            throw fail("slug", `Cannot derive a slug from the name; provide one. ${SLUG_RULE}`);
+        }
+        const taken = new Set((await t
+            .selectFrom("connectors")
+            .select("slug")
+            .where("org_id", "=", orgId)
+            .where("deleted_at", "is", null)
+            .execute()).map((r) => r.slug));
+        for (const m of this.extensions.manifests())
+            taken.add(m.name);
+        for (let n = 1;; n++) {
+            const suffix = n === 1 ? "" : `_${n}`;
+            const slug = `${base.slice(0, 24 - suffix.length).replace(/_+$/, "")}${suffix}`;
+            if (!isValidSlug(slug) || taken.has(slug))
+                continue;
+            const nth = ` ${n}`;
+            const name = d.name ??
+                (n === 1 ? d.display : `${[...d.display].slice(0, 80 - nth.length).join("")}${nth}`);
+            return { name: [...name].slice(0, 80).join(""), slug };
+        }
+    }
     resolveSlug(input) {
         if (input.slug !== undefined) {
             if (!isValidSlug(input.slug))
@@ -253,7 +282,8 @@ let ConnectorsService = class ConnectorsService {
     checkCreateInput(actorAccountId, input) {
         const slug = this.resolveSlug(input);
         const endpoint = this.parseEndpoint(input.connector, input.endpoint);
-        if (this.extensions.manifests().some((m) => m.name === slug)) {
+        // a defaulted slug skips plugin names itself (`freeName`)
+        if (!input.slugDefault && this.extensions.manifests().some((m) => m.name === slug)) {
             throw fail("slug", `Slug "${slug}" is the name of an installed plugin; choose another`);
         }
         const auth = input.auth;
@@ -311,21 +341,21 @@ let ConnectorsService = class ConnectorsService {
         // 自建被禁止时先拒绝（事务里再复核一次）：不该为此触发外连
         if (!input.template)
             await assertCustomAllowed(this.db, "customConnectors");
+        await this.assertKindAvailable(orgId, input.connector);
         const { slug, endpoint, owner, secret } = this.checkCreateInput(actorAccountId, input);
         const id = randomUUID();
         const auth = input.auth;
         const publicUrl = this.config.get().http.publicUrl;
-        // 先做不需要连接的检查：冲突的 slug 不该触发一次外连
-        if (await this.slugTaken(this.db, orgId, slug)) {
+        // 先做不需要连接的检查：冲突的 slug 不该触发一次外连 (a defaulted slug is chosen under the lock)
+        if (!input.slugDefault && (await this.slugTaken(this.db, orgId, slug))) {
             throw new ApiError("connector.slug_taken", "Connector slug is already taken");
         }
         const oauth = isOAuth(auth)
             ? await this.prepareOAuth(auth, endpoint, input.credential, publicUrl)
             : undefined;
-        let rows = [];
-        let issues = [];
+        let listed;
         if (auth.type !== "oauth_code") {
-            const listed = await this.drift.listTools(input.connector, endpoint, async () => {
+            listed = await this.drift.listTools(input.connector, endpoint, async () => {
                 if (auth.type === "none")
                     return { headers: {} };
                 if (oauth?.tokens) {
@@ -335,7 +365,6 @@ let ConnectorsService = class ConnectorsService {
                     throw new CredentialMissing(id, auth.ownership);
                 return this.credentials.injectionFor(id, auth, secret);
             }, { orgId, slug });
-            ({ rows, issues } = snapshot(slug, listed.specs, listed.resources));
         }
         return this.createIn(orgId, actorAccountId, input, actorTokenId, {
             id,
@@ -344,13 +373,12 @@ let ConnectorsService = class ConnectorsService {
             owner,
             secret,
             oauth,
-            rows,
-            issues,
+            listed,
         });
     }
     /** The org-locked, re-checked insert of {@link create} (the outbound checks ran before). */
     async createIn(orgId, actorAccountId, input, actorTokenId, c) {
-        const { id, slug, endpoint, owner, secret, oauth, rows, issues } = c;
+        const { id, endpoint, owner, secret, oauth } = c;
         const auth = input.auth;
         const t = this.db;
         await this.orgLock.lockAndAuthorize(orgId, actorAccountId, "connectors.manage");
@@ -359,22 +387,53 @@ let ConnectorsService = class ConnectorsService {
         }
         else
             await assertCustomAllowed(t, "customConnectors");
-        if (await this.slugTaken(t, orgId, slug)) {
+        let slug = c.slug;
+        let name = input.name;
+        if (input.slugDefault)
+            ({ slug, name } = await this.freeName(t, orgId, input.slugDefault));
+        else if (await this.slugTaken(t, orgId, slug)) {
             throw new ApiError("connector.slug_taken", "Connector slug is already taken");
         }
+        // the snapshot's keys name the final slug
+        const { rows, issues } = c.listed === undefined
+            ? { rows: [], issues: [] }
+            : snapshot(slug, c.listed.specs, c.listed.resources);
+        // A connector made from a platform connector template stays linked to it (ruling E2)
+        const tpl = input.template;
+        const platformTemplate = tpl?.templateId !== undefined
+            ? await t
+                .selectFrom("platform_connector_templates")
+                .select("id")
+                .where("catalog_item_id", "=", tpl.itemId)
+                .where("template_id", "=", tpl.templateId)
+                .where("deleted_at", "is", null)
+                .executeTakeFirst()
+            : undefined;
+        if (tpl?.mustBeOn) {
+            const state = platformTemplate === undefined
+                ? "absent"
+                : await connectorTemplateState(t, orgId, platformTemplate.id);
+            if (state === "absent") {
+                throw new ApiError("component.not_found", "The connector template does not exist or is not available in this organization");
+            }
+            if (state === "off") {
+                throw new ApiError("component.off", "This connector template is off in this organization; switch it (or its plugin) on first");
+            }
+        }
         await t
             .insertInto("connectors")
             .values({
             id,
             org_id: orgId,
             slug,
-            name: input.name,
+            name,
             connector: input.connector,
             endpoint: JSON.stringify(endpoint),
             auth: JSON.stringify(auth),
             created_by: actorAccountId,
             catalog_item_id: input.template?.itemId ?? null,
             catalog_version: input.template?.version ?? null,
+            platform_template_id: platformTemplate?.id ?? null,
             // 授权码连接器安装时没有快照：模板的默认策略留到首个快照时应用
             template_tool_policies: input.template?.defaultToolPolicies
                 ? JSON.stringify(input.template.defaultToolPolicies)
@@ -418,7 +477,7 @@ let ConnectorsService = class ConnectorsService {
         return { connector: await this.detail(t, orgId, id, actorAccountId), issues };
     }
     /**
-     * Checks a template update before anything is written (an org plugin upgrade): the endpoint
+     * Checks a template update before anything is written (the platform plugin update): the endpoint
      * against the connector's schema, and with `resetCredentials` the new credential's shape, or for
      * OAuth the client setup (discovery, dynamic registration or the client credentials token; an
      * outbound failure -> 502 `connector.connect_failed`). Writes nothing.
@@ -534,6 +593,21 @@ let ConnectorsService = class ConnectorsService {
             },
         });
     }
+    /** Refuses a loaded kind whose extension is not enabled in the org (the same notion as {@link kinds}). */
+    async assertKindAvailable(orgId, kind) {
+        if (!this.registry.findConnector(kind))
+            return; // unknown kinds fail in parseEndpoint
+        if (!(await this.registry.connectorKindAvailable(orgId, kind))) {
+            throw new ApiError("connector.kind_unavailable", `Connector kind "${kind}" is not enabled for this organization; enable its plugin first`);
+        }
+    }
+    /**
+     * The connector kinds the org can create connectors of (the install wizard's protocol step): a
+     * kind is listed when its `connector@1` extension is loaded and enabled in the org.
+     */
+    kinds(orgId) {
+        return this.registry.connectorKindsFor(orgId);
+    }
     /**
      * Previews a connector (Ruling A20, for the install wizard): after checking the connector, the
      * endpoint (credential pattern check included) and the credential shape, reads the endpoint
@@ -548,6 +622,7 @@ let ConnectorsService = class ConnectorsService {
     async preview(orgId, input) {
         // 部署禁止组织自建连接器时也不替组织去连任意端点（目录安装不走预览）
         await assertCustomAllowed(this.db, "customConnectors");
+        await this.assertKindAvailable(orgId, input.connector);
         const endpoint = this.parseEndpoint(input.connector, input.endpoint);
         const connector = this.registry.findConnector(input.connector);
         if (!connector)
@@ -684,6 +759,7 @@ let ConnectorsService = class ConnectorsService {
             endpoint: endpointView(r.endpoint),
             auth: r.auth,
             status: r.status,
+            platformTemplateId: r.platform_template_id ?? null,
             createdBy: r.created_by,
             createdAt: r.created_at,
             updatedAt: r.updated_at,
@@ -721,6 +797,7 @@ let ConnectorsService = class ConnectorsService {
                 return {
                     name: t.name,
                     key: connectorToolKey(r.slug, t.name),
+                    title: typeof spec.title === "string" ? spec.title : null,
                     description: spec.description,
                     inputSchema: spec.inputSchema,
                     annotations: spec.annotations ?? null,
@@ -891,7 +968,9 @@ let ConnectorsService = class ConnectorsService {
      * 在调用方事务里软删除连接器（调用方已锁组织行并按需复核角色；应用安装的回滚与卸载用）：删全部凭据与授权，
      * 审计 `connector.deleted`（`reason` 并进 detail）。已删除 / 不存在 → `connector.not_found`。
      */
-    async removeIn(orgId, connectorId, actorAccountId, actorTokenId, reason) {
+    async removeIn(orgId, connectorId, 
+    /** null: the kernel itself (the plugin scope sync uninstalling a plugin). */
+    actorAccountId, actorTokenId, reason) {
         const t = this.db;
         const app = await this.row(t, orgId, connectorId, true);
         await t

package/dist/tools/extension-tools.controller.d.ts

@@ -0,0 +1,14 @@
+import { type OrgContext } from "../orgs/org.guard.js";
+import { type ExtensionToolsOffer, OrgExtensionTools } from "./info.js";
+/**
+ * `GET /api/v1/orgs/:orgId/tools/extensions` (`agents.use`) → `{ extensions }`: the tools of the
+ * extensions enabled in the org, grouped by extension, for the agent form's Tools section (it adds
+ * or removes `{kind:"plugin",plugin,name}` references). Display only; nothing here is model-visible.
+ */
+export declare class ExtensionToolsController {
+    private readonly tools;
+    constructor(tools: OrgExtensionTools);
+    extensions(org: OrgContext): Promise<{
+        extensions: ExtensionToolsOffer[];
+    }>;
+}

package/dist/tools/extension-tools.controller.js

@@ -0,0 +1,37 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Controller, Get, Header, Inject } from "@nestjs/common";
+import { CurrentOrg, OrgAction } from "../orgs/org.guard.js";
+import { OrgExtensionTools } from "./info.js";
+/**
+ * `GET /api/v1/orgs/:orgId/tools/extensions` (`agents.use`) → `{ extensions }`: the tools of the
+ * extensions enabled in the org, grouped by extension, for the agent form's Tools section (it adds
+ * or removes `{kind:"plugin",plugin,name}` references). Display only; nothing here is model-visible.
+ */
+let ExtensionToolsController = class ExtensionToolsController {
+    tools;
+    constructor(tools) {
+        this.tools = tools;
+    }
+    async extensions(org) {
+        return { extensions: await this.tools.list(org.orgId) };
+    }
+};
+__decorate([
+    Get("extensions"),
+    Header("cache-control", "private, no-store"),
+    OrgAction("agents.use"),
+    __param(0, CurrentOrg())
+], ExtensionToolsController.prototype, "extensions", null);
+ExtensionToolsController = __decorate([
+    Controller("api/v1/orgs/:orgId/tools"),
+    __param(0, Inject(OrgExtensionTools))
+], ExtensionToolsController);
+export { ExtensionToolsController };

package/dist/tools/info.d.ts

@@ -1,7 +1,8 @@
-import { type LocalizedName } from "@capybara-hq/plugin-sdk";
+import { type LocalizedName, type ToolAnnotations } from "@capybara-hq/plugin-sdk";
 import { ConversationAccess } from "../conversations/access.js";
 import type { KernelSchemaDb } from "../db/kernel-schema.js";
 import { KernelDb } from "../infra/database/kernel-db.js";
+import { OrgToolSwitches } from "./org-tool-switches.js";
 import { ToolRegistry } from "./registry.js";
 /**
  * Tool presentation metadata for the conversation page (UI refresh B, design spec §6.16.9): the
@@ -84,3 +85,43 @@ export declare class ConversationToolInfo {
     access: Pick<ConversationAccess, "isAccessible">);
     get(orgId: string, conversationId: string, viewerAccountId: string, keys: readonly string[]): Promise<ToolInfo[]>;
 }
+/** One tool of {@link OrgExtensionTools}. Display only, for the agent form. */
+export interface ExtensionToolOffer {
+    /** The tool's registered name (the `name` of a `{kind:"plugin"}` reference). */
+    name: string;
+    /** The model-visible key, `plugin__<plugin>__<name>` (the `toolPolicies` key). */
+    key: string;
+    /** The declared display title (`ToolSpec.title`), or null. */
+    title: string | null;
+    /** The first non-empty line of the tool's description (English, model-facing text). */
+    description: string;
+    annotations: ToolAnnotations;
+    /** The tool's default policy: its `defaultPolicy`, else derived from the annotations. */
+    defaultPolicy: "allow" | "ask";
+    /**
+     * The org turned this tool off (layering spec A §7): still listed, so the form shows it as
+     * unavailable in the agents that selected it.
+     */
+    switchedOff: boolean;
+}
+/** One extension of {@link OrgExtensionTools} with its tools, in registration order. */
+export interface ExtensionToolsOffer {
+    plugin: string;
+    /** The plugin's catalog display name, else its name. */
+    displayName: LocalizedName;
+    tools: ExtensionToolOffer[];
+}
+/**
+ * `GET /orgs/:orgId/tools/extensions`: the tools an agent of this org can reference by
+ * `{kind:"plugin"}` and get at run time, grouped by extension: the extensions loaded on this
+ * replica and enabled in the org (`enabled.ts`, through the host), each with the tools it
+ * registered whose key is valid (`ToolRegistry.forAgent` reports the others unavailable); a tool
+ * the org turned off is listed with `switchedOff`.
+ */
+export declare class OrgExtensionTools {
+    private readonly db;
+    private readonly registry;
+    private readonly switches;
+    constructor(db: KernelDb, registry: Pick<ToolRegistry, "extensionToolSpecs" | "enabledExtensions">, switches: Pick<OrgToolSwitches, "offKeys">);
+    list(orgId: string): Promise<ExtensionToolsOffer[]>;
+}

package/dist/tools/info.js

@@ -16,7 +16,9 @@ import { UUID_RE } from "../ui/registry.js";
 import { BUILTIN_TOOL_KINDS, SANDBOX_TOOL_NAMES } from "./builtin-names.js";
 import { pluginDisplayNames } from "./display-names.js";
 import { isLegacyBuiltinKey, LEGACY_BUILTINS } from "./legacy-keys.js";
-import { ToolRegistry } from "./registry.js";
+import { toolKeyIssue } from "./naming.js";
+import { OrgToolSwitches } from "./org-tool-switches.js";
+import { policyFromAnnotations, ToolRegistry } from "./registry.js";
 export { BUILTIN_TOOL_KINDS } from "./builtin-names.js";
 /** At most this many keys per request, each at most {@link TOOL_INFO_KEY_MAX} characters. */
 export const TOOL_INFO_MAX_KEYS = 100;
@@ -160,3 +162,64 @@ ConversationToolInfo = __decorate([
     __param(2, Inject(ConversationAccess))
 ], ConversationToolInfo);
 export { ConversationToolInfo };
+/**
+ * `GET /orgs/:orgId/tools/extensions`: the tools an agent of this org can reference by
+ * `{kind:"plugin"}` and get at run time, grouped by extension: the extensions loaded on this
+ * replica and enabled in the org (`enabled.ts`, through the host), each with the tools it
+ * registered whose key is valid (`ToolRegistry.forAgent` reports the others unavailable); a tool
+ * the org turned off is listed with `switchedOff`.
+ */
+let OrgExtensionTools = class OrgExtensionTools {
+    db;
+    registry;
+    switches;
+    constructor(db, registry, switches) {
+        this.db = db;
+        this.registry = registry;
+        this.switches = switches;
+    }
+    async list(orgId) {
+        const [enabled, off] = await Promise.all([
+            this.registry.enabledExtensions(orgId),
+            this.switches.offKeys(orgId),
+        ]);
+        const groups = new Map();
+        for (const t of this.registry.extensionToolSpecs()) {
+            if (!enabled.has(t.plugin))
+                continue;
+            const key = extensionToolKey(t.plugin, t.spec.name);
+            if (toolKeyIssue(key) !== null)
+                continue;
+            const tools = groups.get(t.plugin) ?? [];
+            if (tools.some((x) => x.name === t.spec.name))
+                continue;
+            tools.push({
+                name: t.spec.name,
+                key,
+                title: display(t.spec).title,
+                description: firstLine(t.spec.description),
+                annotations: { ...(t.spec.annotations ?? {}) },
+                defaultPolicy: t.spec.defaultPolicy ?? policyFromAnnotations(t.spec.annotations),
+                switchedOff: off.has(key),
+            });
+            groups.set(t.plugin, tools);
+        }
+        const names = await pluginDisplayNames(this.db.db, [...groups.keys()]);
+        return [...groups].map(([plugin, tools]) => ({
+            plugin,
+            displayName: names.get(plugin) ?? { zh: plugin, en: plugin },
+            tools,
+        }));
+    }
+};
+OrgExtensionTools = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(ToolRegistry)),
+    __param(2, Inject(OrgToolSwitches))
+], OrgExtensionTools);
+export { OrgExtensionTools };
+const firstLine = (s) => (typeof s === "string" ? s : "")
+    .split("\n")
+    .map((l) => l.trim())
+    .find((l) => l !== "") ?? "";

package/dist/tools/org-tool-switches.d.ts

@@ -0,0 +1,74 @@
+import { ExtensionHost } from "../extensions/host.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { TransactionHost } from "../infra/database/transaction-host.js";
+import { OrgLock } from "../orgs/org-lock.js";
+/** One tool of an extension with its switch in the org. */
+export interface OrgToolSwitch {
+    tool: string;
+    enabled: boolean;
+}
+/** An org agent whose current version selects the tool being switched off. */
+export interface AffectedAgent {
+    id: string;
+    name: string;
+}
+/**
+ * The result of {@link OrgToolSwitches.set}: the PCM §5 rule 8 preview of a switch-off (the org's
+ * agents that selected the tool and the hash to confirm it with), or the switch applied.
+ */
+export type OrgToolSwitchResult = {
+    applied: false;
+    affectedAgents: AffectedAgent[];
+    confirm: string;
+} | {
+    applied: true;
+};
+/** Model-visible (English): why a turned-off extension tool is not offered. */
+export declare const toolTurnedOffReason: (key: string) => string;
+/**
+ * Per-org switches of single extension tools (layering spec A §7, table `org_tool_switches`): an
+ * org admin turns off one tool an extension registers (`ctx.tools.register`); it is then not
+ * offered to any agent of the org (`ToolRegistry.forAgent`) and refused if called
+ * (`ToolPipeline`). No row means on. A row of a tool the extension stops registering is kept and
+ * applies again if the tool comes back. Builtin and connector tools are out of scope. Read from PG
+ * on every use, no in-process state.
+ */
+export declare class OrgToolSwitches {
+    private readonly kdb;
+    readonly txHost: TransactionHost;
+    private readonly host;
+    /** The org row lock: re-checks `org.extensions.manage` under the lock. */
+    private readonly orgLock;
+    constructor(kdb: KernelDb, txHost: TransactionHost, host: Pick<ExtensionHost, "tools">, 
+    /** The org row lock: re-checks `org.extensions.manage` under the lock. */
+    orgLock: Pick<OrgLock, "lockAndAuthorize">);
+    private get db();
+    /** The tool names `plugin` registers on this replica, in registration order. */
+    private registered;
+    /**
+     * The tools of an extension the org sees: running here and visible under plugin scope, else 404
+     * `extension.not_found` (an invisible one is answered like an unknown one).
+     */
+    private toolsFor;
+    /** The stored switches of the org (all extensions, or one), `false` ones only matter. */
+    private offRows;
+    /** Every tool the extension registers on this replica with its switch (default on). */
+    list(orgId: string, plugin: string): Promise<OrgToolSwitch[]>;
+    /** The model-visible keys (`plugin__<extension>__<tool>`) of the tools turned off in the org. */
+    offKeys(orgId: string): Promise<Set<string>>;
+    /** Whether the org turned off this tool. */
+    isToolOff(orgId: string, plugin: string, tool: string): Promise<boolean>;
+    /**
+     * Switches one tool in the org. On applies at once. Off, while the tool is on: without
+     * `confirm` the preview (the org's agents whose current version selects the tool) and its hash,
+     * with the current hash the switch is written (a changed preview -> 409 `plugin.switch_stale`).
+     * A tool the extension does not register -> 404 `extension.tool_not_found`. A change writes the
+     * audit row `extension.tool_switched`.
+     */
+    set(orgId: string, plugin: string, tool: string, enabled: boolean, actor: {
+        accountId: string;
+        tokenId?: string | undefined;
+    }, confirm?: string): Promise<OrgToolSwitchResult>;
+    /** The org's live agents whose current version selects `{kind:"plugin", plugin, name: tool}`. */
+    private agentsSelecting;
+}

package/dist/tools/org-tool-switches.js

@@ -0,0 +1,184 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { createHash } from "node:crypto";
+import { extensionToolKey } from "@capybara-hq/plugin-sdk";
+import { Inject, Injectable } from "@nestjs/common";
+import { sql } from "kysely";
+import { ApiError } from "../errors.js";
+import { ExtensionHost } from "../extensions/host.js";
+import { extensionVisibleTo } from "../extensions/org-config.js";
+import { audit } from "../identity/audit.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { TransactionHost } from "../infra/database/transaction-host.js";
+import { Transactional } from "../infra/database/transactional.decorator.js";
+import { OrgLock } from "../orgs/org-lock.js";
+/** Model-visible (English): why a turned-off extension tool is not offered. */
+export const toolTurnedOffReason = (key) => `Tool ${key} is turned off in this organization`;
+/** The confirm hash of a switch-off preview. */
+function switchOffHash(orgId, plugin, tool, agents) {
+    return createHash("sha256")
+        .update(JSON.stringify({ orgId, plugin, tool, agents: agents.map((a) => a.id) }))
+        .digest("hex");
+}
+/**
+ * Per-org switches of single extension tools (layering spec A §7, table `org_tool_switches`): an
+ * org admin turns off one tool an extension registers (`ctx.tools.register`); it is then not
+ * offered to any agent of the org (`ToolRegistry.forAgent`) and refused if called
+ * (`ToolPipeline`). No row means on. A row of a tool the extension stops registering is kept and
+ * applies again if the tool comes back. Builtin and connector tools are out of scope. Read from PG
+ * on every use, no in-process state.
+ */
+let OrgToolSwitches = class OrgToolSwitches {
+    kdb;
+    txHost;
+    host;
+    orgLock;
+    constructor(kdb, txHost, host, 
+    /** The org row lock: re-checks `org.extensions.manage` under the lock. */
+    orgLock) {
+        this.kdb = kdb;
+        this.txHost = txHost;
+        this.host = host;
+        this.orgLock = orgLock;
+    }
+    get db() {
+        return this.kdb.db;
+    }
+    /** The tool names `plugin` registers on this replica, in registration order. */
+    registered(plugin) {
+        return [
+            ...new Set(this.host
+                .tools()
+                .filter((t) => t.plugin === plugin)
+                .map((t) => t.spec.name)),
+        ];
+    }
+    /**
+     * The tools of an extension the org sees: running here and visible under plugin scope, else 404
+     * `extension.not_found` (an invisible one is answered like an unknown one).
+     */
+    async toolsFor(orgId, plugin) {
+        const tools = this.registered(plugin);
+        if (tools.length === 0 || !(await extensionVisibleTo(this.db, orgId, plugin))) {
+            throw new ApiError("extension.not_found", `Extension ${plugin} is not installed`);
+        }
+        return tools;
+    }
+    /** The stored switches of the org (all extensions, or one), `false` ones only matter. */
+    async offRows(orgId, plugin) {
+        let q = this.db
+            .selectFrom("org_tool_switches")
+            .select(["plugin", "tool"])
+            .where("org_id", "=", orgId)
+            .where("enabled", "=", false);
+        if (plugin !== undefined)
+            q = q.where("plugin", "=", plugin);
+        return q.execute();
+    }
+    /** Every tool the extension registers on this replica with its switch (default on). */
+    async list(orgId, plugin) {
+        const tools = await this.toolsFor(orgId, plugin);
+        const off = new Set((await this.offRows(orgId, plugin)).map((r) => r.tool));
+        return tools.map((tool) => ({ tool, enabled: !off.has(tool) }));
+    }
+    /** The model-visible keys (`plugin__<extension>__<tool>`) of the tools turned off in the org. */
+    async offKeys(orgId) {
+        return new Set((await this.offRows(orgId)).map((r) => extensionToolKey(r.plugin, r.tool)));
+    }
+    /** Whether the org turned off this tool. */
+    async isToolOff(orgId, plugin, tool) {
+        const row = await this.db
+            .selectFrom("org_tool_switches")
+            .select("enabled")
+            .where("org_id", "=", orgId)
+            .where("plugin", "=", plugin)
+            .where("tool", "=", tool)
+            .executeTakeFirst();
+        return row?.enabled === false;
+    }
+    /**
+     * Switches one tool in the org. On applies at once. Off, while the tool is on: without
+     * `confirm` the preview (the org's agents whose current version selects the tool) and its hash,
+     * with the current hash the switch is written (a changed preview -> 409 `plugin.switch_stale`).
+     * A tool the extension does not register -> 404 `extension.tool_not_found`. A change writes the
+     * audit row `extension.tool_switched`.
+     */
+    async set(orgId, plugin, tool, enabled, actor, confirm) {
+        await this.orgLock.lockAndAuthorize(orgId, actor.accountId, "org.extensions.manage");
+        const tools = await this.toolsFor(orgId, plugin);
+        if (!tools.includes(tool)) {
+            throw new ApiError("extension.tool_not_found", `Extension ${plugin} does not register a tool named ${tool}`);
+        }
+        const from = !(await this.isToolOff(orgId, plugin, tool));
+        if (from === enabled)
+            return { applied: true };
+        if (!enabled) {
+            const affectedAgents = await this.agentsSelecting(orgId, plugin, tool);
+            const hash = switchOffHash(orgId, plugin, tool, affectedAgents);
+            if (confirm === undefined)
+                return { applied: false, affectedAgents, confirm: hash };
+            if (confirm !== hash) {
+                throw new ApiError("plugin.switch_stale", "What switching this tool off affects has changed; review it and confirm again");
+            }
+        }
+        await this.db
+            .insertInto("org_tool_switches")
+            .values({ org_id: orgId, plugin, tool, enabled, updated_by: actor.accountId })
+            .onConflict((oc) => oc.columns(["org_id", "plugin", "tool"]).doUpdateSet({
+            enabled,
+            updated_by: actor.accountId,
+            updated_at: sql `now()`,
+        }))
+            .execute();
+        await audit(this.db, {
+            actorAccountId: actor.accountId,
+            ...(actor.tokenId !== undefined && { actorTokenId: actor.tokenId }),
+            orgId,
+            action: "extension.tool_switched",
+            target: extensionToolKey(plugin, tool),
+            detail: { plugin, tool, from, to: enabled },
+        });
+        return { applied: true };
+    }
+    /** The org's live agents whose current version selects `{kind:"plugin", plugin, name: tool}`. */
+    async agentsSelecting(orgId, plugin, tool) {
+        const rows = await this.db
+            .selectFrom("agents as a")
+            .innerJoin("agent_versions as v", (j) => j.onRef("v.agent_id", "=", "a.id").onRef("v.version", "=", "a.current_version"))
+            .select(["a.id", "v.definition"])
+            .where("a.org_id", "=", orgId)
+            .where("a.deleted_at", "is", null)
+            .orderBy("a.id")
+            .execute();
+        const out = [];
+        for (const r of rows) {
+            const def = r.definition;
+            const refs = Array.isArray(def?.tools) ? def.tools : [];
+            const selects = refs.some((x) => {
+                const ref = x;
+                return ref?.kind === "plugin" && ref.plugin === plugin && ref.name === tool;
+            });
+            if (selects)
+                out.push({ id: r.id, name: typeof def?.name === "string" ? def.name : r.id });
+        }
+        return out;
+    }
+};
+__decorate([
+    Transactional()
+], OrgToolSwitches.prototype, "set", null);
+OrgToolSwitches = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(TransactionHost)),
+    __param(2, Inject(ExtensionHost)),
+    __param(3, Inject(OrgLock))
+], OrgToolSwitches);
+export { OrgToolSwitches };