@capybara-hq/kernel 0.1.0-rc.0 → 0.1.0-rc.2

package/dist/channels/connections.service.js

@@ -1,18 +1,36 @@
+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 { randomUUID } from "node:crypto";
 import { CHANNEL_EXTENSION_POINT, } from "@capybara-hq/plugin-sdk";
+import { Inject, Injectable } from "@nestjs/common";
 import { sql } from "kysely";
 import { configFields, getPath, secretValues } from "../config/fields.js";
 import { queryEnabledPlugins } from "../ctx/create-ctx.js";
 import { createSecrets } from "../ctx/secrets.js";
 import { ApiError } from "../errors.js";
+import { toIssues } from "../extensions/config-issues.js";
 import { configToJsonSchema } from "../extensions/config-json-schema.js";
 import { enabledExtensionsByOrg } from "../extensions/enabled.js";
-import { toIssues } from "../extensions/org-config.js";
+import { ExtensionRegistry } from "../extensions/registry.js";
 import { audit } from "../identity/audit.js";
+import { KernelConfigService } from "../infra/config/kernel-config.service.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 { KernelEvents } from "../infra/events/kernel-events.js";
+import { KERNEL_BUS, KERNEL_LOGGER, KEYRING, REDIS } from "../infra/tokens.js";
 import { createRedactor } from "../log.js";
-import { lockOrgAndAuthorize } from "../orgs/org-lock.js";
+import { OrgLock } from "../orgs/org-lock.js";
 import { readOrgSettings } from "../orgs/settings.service.js";
 import { adaptToFeatures } from "./features.js";
+import { ChannelJobs } from "./jobs.js";
 import { webhookBase, webhookUrlOf } from "./webhook-url.js";
 /** 内核 secrets 命名空间（插件名不能取 `kernel`）。 */
 const SECRETS_NAMESPACE = "kernel";
@@ -91,17 +109,56 @@ const COLUMNS = [
  * （命名空间 `kernel`，键 `channels:<id>:config`）。写操作在组织行锁内实时复核 `channels.manage`，写审计；
  * 改动提交后经内核 bus 广播 `channel.changed`，持有该连接的副本据此断开（下一轮扫描按新配置重连）。
  */
-export class ChannelConnections {
-    deps;
-    constructor(deps) {
-        this.deps = deps;
+let ChannelConnections = class ChannelConnections {
+    db;
+    orgLock;
+    keyring;
+    registry;
+    bus;
+    redis;
+    jobs;
+    config;
+    log;
+    txHost;
+    unsubscribe;
+    constructor(db, 
+    /** The org row lock (orgs/org-lock.ts): joins the transaction of the write. */
+    orgLock, keyring, registry, bus, redis, 
+    /** A connection that can deliver again catches up its conversations (`resumeConnection`). */
+    jobs, 
+    /** `channels.webhookBaseUrl`: without it webhook mode is unavailable. */
+    config, events, 
+    /** Secret values handled here (written or decrypted) are redacted from the logs (`addOrgSecrets`). */
+    log, txHost) {
+        this.db = db;
+        this.orgLock = orgLock;
+        this.keyring = keyring;
+        this.registry = registry;
+        this.bus = bus;
+        this.redis = redis;
+        this.jobs = jobs;
+        this.config = config;
+        this.log = log;
+        this.txHost = txHost;
+        this.unsubscribe = [
+            // a deleted org's channel connections drop their long connections at once
+            events.on("org.deleted", ({ orgId }) => this.notifyOrgChanged(orgId)),
+            // an org disabling an extension drops that extension's channel connections at once (the
+            // supervisor's periodic re-check is the fallback)
+            events.on("extension.org-disabled", ({ orgId, plugin }) => this.notifyOrgChanged(orgId, plugin)),
+        ];
+    }
+    /** Unsubscribes after the stop phases: events emitted while they drain are still handled. */
+    onApplicationShutdown() {
+        for (const off of this.unsubscribe)
+            off();
     }
     /** The extension's `channel@1`; not loaded or not provided -> `extension.not_found`. */
     channel(plugin) {
         return this.channelEntry(plugin).impl;
     }
     channelEntry(plugin) {
-        const e = this.deps.host
+        const e = this.registry
             .list("channel")
             .find((x) => x.plugin === plugin && x.capability === CHANNEL_EXTENSION_POINT);
         if (!e)
@@ -110,7 +167,7 @@ export class ChannelConnections {
     }
     /** The extension is not enabled in this organization -> `extension.not_enabled`. */
     async assertEnabled(orgId, plugin) {
-        if (!(await queryEnabledPlugins(this.deps.db, orgId)).has(plugin)) {
+        if (!(await queryEnabledPlugins(this.db.db, orgId)).has(plugin)) {
             throw new ApiError("extension.not_enabled", `Extension ${plugin} is not enabled for this organization`);
         }
     }
@@ -141,10 +198,10 @@ export class ChannelConnections {
     reportSecrets(schema, config) {
         const values = secretValues(schema, config);
         if (values.length > 0)
-            this.deps.onSecrets?.(values);
+            this.log.addOrgSecrets(values);
     }
-    async assertAgent(t, orgId, agentId) {
-        const a = await t
+    async assertAgent(orgId, agentId) {
+        const a = await this.db
             .selectFrom("agents")
             .select("id")
             .where("id", "=", agentId)
@@ -155,7 +212,7 @@ export class ChannelConnections {
             throw new ApiError("agent.not_found", "Agent not found");
     }
     async readSecrets(orgId, id) {
-        const raw = await createSecrets(this.deps.db, this.deps.keyring, SECRETS_NAMESPACE).get(orgId, connectionSecretKey(id));
+        const raw = await createSecrets(this.db.db, this.keyring, SECRETS_NAMESPACE).get(orgId, connectionSecretKey(id));
         return raw === null ? {} : JSON.parse(raw);
     }
     view(r, setPaths) {
@@ -193,8 +250,7 @@ export class ChannelConnections {
         };
     }
     webhookBase() {
-        const config = this.deps.config?.();
-        return config === undefined ? undefined : webhookBase(config);
+        return webhookBase(this.config.get());
     }
     /**
      * Switching to webhook mode needs a plugin that implements `Channel.webhook` and a configured
@@ -212,7 +268,7 @@ export class ChannelConnections {
         return this.view(row, new Set(Object.keys(await this.readSecrets(row.org_id, row.id))));
     }
     live(orgId) {
-        return this.deps.db
+        return this.db
             .selectFrom("channel_connections")
             .select(COLUMNS)
             .where("org_id", "=", orgId)
@@ -234,46 +290,58 @@ export class ChannelConnections {
         await this.assertEnabled(orgId, input.plugin);
         const schema = channel.connectionSchema;
         const full = this.parse(input.plugin, schema, input.config);
-        await this.assertAgent(this.deps.db, orgId, input.agentId);
+        await this.assertAgent(orgId, input.agentId);
         const verified = await this.verify(channel, full);
         const id = randomUUID();
         const { plain, secrets } = split(schema, full);
-        const row = await this.deps.db.transaction().execute(async (t) => {
-            await lockOrgAndAuthorize(t, orgId, actorAccountId, "channels.manage");
-            await this.assertAgent(t, orgId, input.agentId);
-            if (Object.keys(secrets).length > 0) {
-                await createSecrets(t, this.deps.keyring, SECRETS_NAMESPACE).set(orgId, connectionSecretKey(id), JSON.stringify(secrets));
-            }
-            const inserted = await t
-                .insertInto("channel_connections")
-                .values({
-                id,
-                org_id: orgId,
-                plugin: input.plugin,
-                name: input.name,
-                agent_id: input.agentId,
-                config: JSON.stringify(plain),
-                unbound_policy: input.unboundPolicy ?? "bind",
-                bot_user_id: verified.botUserId,
-                tenant_id: verified.tenantId,
-                created_by: actorAccountId,
-            })
-                .returning(COLUMNS)
-                .executeTakeFirstOrThrow();
-            await audit(t, {
-                actorAccountId,
-                ...(actorTokenId !== undefined && { actorTokenId }),
-                orgId,
-                action: "channel.created",
-                target: id,
-                detail: { plugin: input.plugin, agentId: input.agentId },
-            });
-            return inserted;
+        const row = await this.insertIn({
+            orgId,
+            id,
+            input,
+            plain,
+            secrets,
+            verified,
+            actorAccountId,
+            actorTokenId,
         });
         this.reportSecrets(schema, full);
         await this.changed(id, false);
         return this.view(row, new Set(Object.keys(secrets)));
     }
+    /** The rows of {@link create}, in their own transaction (the caller publishes after the commit). */
+    async insertIn(a) {
+        const { orgId, id, input, actorAccountId, actorTokenId } = a;
+        await this.orgLock.lockAndAuthorize(orgId, actorAccountId, "channels.manage");
+        await this.assertAgent(orgId, input.agentId);
+        if (Object.keys(a.secrets).length > 0) {
+            await createSecrets(this.db.db, this.keyring, SECRETS_NAMESPACE).set(orgId, connectionSecretKey(id), JSON.stringify(a.secrets));
+        }
+        const inserted = await this.db
+            .insertInto("channel_connections")
+            .values({
+            id,
+            org_id: orgId,
+            plugin: input.plugin,
+            name: input.name,
+            agent_id: input.agentId,
+            config: JSON.stringify(a.plain),
+            unbound_policy: input.unboundPolicy ?? "bind",
+            bot_user_id: a.verified.botUserId,
+            tenant_id: a.verified.tenantId,
+            created_by: actorAccountId,
+        })
+            .returning(COLUMNS)
+            .executeTakeFirstOrThrow();
+        await audit(this.db.db, {
+            actorAccountId,
+            ...(actorTokenId !== undefined && { actorTokenId }),
+            orgId,
+            action: "channel.created",
+            target: id,
+            detail: { plugin: input.plugin, agentId: input.agentId },
+        });
+        return inserted;
+    }
     /**
      * 修改名称、agent、未绑定策略、启停，或轮换凭据（新配置同样先 `verify`，失败什么都不改）。
      * 插件在该组织停用时仍可轮换凭据，此时不 verify，返回 `verifySkipped: true`。
@@ -288,7 +356,7 @@ export class ChannelConnections {
         if (patch.config !== undefined) {
             const channel = this.channel(current.plugin);
             // 插件在该组织停用时也允许轮换（泄露的密钥要能立刻换掉），但不调用插件 verify：重新启用后长连接按新凭据连接
-            const enabled = (await queryEnabledPlugins(this.deps.db, orgId)).has(current.plugin);
+            const enabled = (await queryEnabledPlugins(this.db.db, orgId)).has(current.plugin);
             const schema = channel.connectionSchema;
             const before = await this.readSecrets(orgId, id);
             const next = structuredClone(patch.config);
@@ -310,55 +378,15 @@ export class ChannelConnections {
         if (modeChanged && patch.inboundMode === "webhook")
             this.assertWebhookAvailable(current.plugin);
         if (patch.agentId !== undefined)
-            await this.assertAgent(this.deps.db, orgId, patch.agentId);
-        const row = await this.deps.db.transaction().execute(async (t) => {
-            await lockOrgAndAuthorize(t, orgId, actorAccountId, "channels.manage");
-            if (patch.agentId !== undefined)
-                await this.assertAgent(t, orgId, patch.agentId);
-            if (rotated) {
-                const secrets = createSecrets(t, this.deps.keyring, SECRETS_NAMESPACE);
-                if (Object.keys(rotated.secrets).length > 0) {
-                    await secrets.set(orgId, connectionSecretKey(id), JSON.stringify(rotated.secrets));
-                }
-                else {
-                    await secrets.delete(orgId, connectionSecretKey(id));
-                }
-            }
-            const updated = await t
-                .updateTable("channel_connections")
-                .set({
-                ...(patch.name !== undefined && { name: patch.name }),
-                ...(patch.agentId !== undefined && { agent_id: patch.agentId }),
-                ...(patch.unboundPolicy !== undefined && { unbound_policy: patch.unboundPolicy }),
-                ...(patch.status !== undefined && { status: patch.status }),
-                ...(patch.inboundMode !== undefined && { inbound_mode: patch.inboundMode }),
-                ...(rotated && { config: JSON.stringify(rotated.plain) }),
-                // 跳过了 verify：机器人 id 与租户保留原值（重新启用后插件按新凭据连接，入站以连接行的租户判断外部人员）
-                ...(verified && { bot_user_id: verified.botUserId, tenant_id: verified.tenantId }),
-                ...((rotated || patch.status === "active") && { last_error: null }),
-                updated_at: sql `now()`,
-            })
-                .where("id", "=", id)
-                .where("org_id", "=", orgId)
-                .where("deleted_at", "is", null)
-                .returning(COLUMNS)
-                .executeTakeFirst();
-            if (!updated)
-                throw notFound();
-            await audit(t, {
-                actorAccountId,
-                ...(actorTokenId !== undefined && { actorTokenId }),
-                orgId,
-                action: "channel.updated",
-                target: id,
-                detail: {
-                    changed: [
-                        ...Object.keys(patch).filter((k) => k !== "config" && patch[k] !== undefined),
-                        ...(rotated ? ["config"] : []),
-                    ],
-                },
-            });
-            return updated;
+            await this.assertAgent(orgId, patch.agentId);
+        const row = await this.updateIn({
+            orgId,
+            id,
+            patch,
+            rotated,
+            verified,
+            actorAccountId,
+            actorTokenId,
         });
         if (rotated)
             this.reportSecrets(rotated.schema, rotated.full);
@@ -366,50 +394,103 @@ export class ChannelConnections {
         if (rotated ||
             patch.status === "active" ||
             (modeChanged && patch.inboundMode === "long_connection")) {
-            await this.deps.redis
+            await this.redis
                 .del(channelBackoffKey(id), channelFailsKey(id))
-                .catch((err) => this.deps.log.warn("cannot clear channel backoff", { err }));
+                .catch((err) => this.log.warn("cannot clear channel backoff", { err }));
         }
         // A mode switch also reconnects: the holder drops the long connection when going to webhook (F9)
         await this.changed(id, rotated !== undefined || patch.status !== undefined || modeChanged);
         if ((rotated || patch.status === "active") && row.status === "active") {
-            await this.deps
-                .onResume?.(id)
-                .catch((err) => this.deps.log.warn("cannot resume channel deliveries", { err }));
+            await this.jobs
+                .resumeConnection(id)
+                .catch((err) => this.log.warn("cannot resume channel deliveries", { err }));
         }
         return { channel: await this.viewOf(row), verifySkipped };
     }
+    /** The rows of {@link update}, in their own transaction (the caller publishes after the commit). */
+    async updateIn(a) {
+        const { orgId, id, patch, rotated, verified, actorAccountId, actorTokenId } = a;
+        await this.orgLock.lockAndAuthorize(orgId, actorAccountId, "channels.manage");
+        if (patch.agentId !== undefined)
+            await this.assertAgent(orgId, patch.agentId);
+        if (rotated) {
+            const secrets = createSecrets(this.db.db, this.keyring, SECRETS_NAMESPACE);
+            if (Object.keys(rotated.secrets).length > 0) {
+                await secrets.set(orgId, connectionSecretKey(id), JSON.stringify(rotated.secrets));
+            }
+            else {
+                await secrets.delete(orgId, connectionSecretKey(id));
+            }
+        }
+        const updated = await this.db
+            .updateTable("channel_connections")
+            .set({
+            ...(patch.name !== undefined && { name: patch.name }),
+            ...(patch.agentId !== undefined && { agent_id: patch.agentId }),
+            ...(patch.unboundPolicy !== undefined && { unbound_policy: patch.unboundPolicy }),
+            ...(patch.status !== undefined && { status: patch.status }),
+            ...(patch.inboundMode !== undefined && { inbound_mode: patch.inboundMode }),
+            ...(rotated && { config: JSON.stringify(rotated.plain) }),
+            // 跳过了 verify：机器人 id 与租户保留原值（重新启用后插件按新凭据连接，入站以连接行的租户判断外部人员）
+            ...(verified && { bot_user_id: verified.botUserId, tenant_id: verified.tenantId }),
+            ...((rotated || patch.status === "active") && { last_error: null }),
+            updated_at: sql `now()`,
+        })
+            .where("id", "=", id)
+            .where("org_id", "=", orgId)
+            .where("deleted_at", "is", null)
+            .returning(COLUMNS)
+            .executeTakeFirst();
+        if (!updated)
+            throw notFound();
+        await audit(this.db.db, {
+            actorAccountId,
+            ...(actorTokenId !== undefined && { actorTokenId }),
+            orgId,
+            action: "channel.updated",
+            target: id,
+            detail: {
+                changed: [
+                    ...Object.keys(patch).filter((k) => k !== "config" && patch[k] !== undefined),
+                    ...(rotated ? ["config"] : []),
+                ],
+            },
+        });
+        return updated;
+    }
     /** 删除（软删除，同一事务删掉密钥）；持有长连接的副本收到广播后断开。 */
     async remove(orgId, id, actorAccountId, actorTokenId) {
-        await this.deps.db.transaction().execute(async (t) => {
-            await lockOrgAndAuthorize(t, orgId, actorAccountId, "channels.manage");
-            const r = await t
-                .updateTable("channel_connections")
-                .set({ deleted_at: sql `now()`, updated_at: sql `now()` })
-                .where("id", "=", id)
-                .where("org_id", "=", orgId)
-                .where("deleted_at", "is", null)
-                .executeTakeFirst();
-            if (r.numUpdatedRows === 0n)
-                throw notFound();
-            await createSecrets(t, this.deps.keyring, SECRETS_NAMESPACE).delete(orgId, connectionSecretKey(id));
-            await audit(t, {
-                actorAccountId,
-                ...(actorTokenId !== undefined && { actorTokenId }),
-                orgId,
-                action: "channel.deleted",
-                target: id,
-            });
-        });
+        await this.removeIn(orgId, id, actorAccountId, actorTokenId);
         await this.changed(id, true);
     }
+    /** The rows of {@link remove}, in their own transaction (the caller publishes after the commit). */
+    async removeIn(orgId, id, actorAccountId, actorTokenId) {
+        await this.orgLock.lockAndAuthorize(orgId, actorAccountId, "channels.manage");
+        const r = await this.db
+            .updateTable("channel_connections")
+            .set({ deleted_at: sql `now()`, updated_at: sql `now()` })
+            .where("id", "=", id)
+            .where("org_id", "=", orgId)
+            .where("deleted_at", "is", null)
+            .executeTakeFirst();
+        if (r.numUpdatedRows === 0n)
+            throw notFound();
+        await createSecrets(this.db.db, this.keyring, SECRETS_NAMESPACE).delete(orgId, connectionSecretKey(id));
+        await audit(this.db.db, {
+            actorAccountId,
+            ...(actorTokenId !== undefined && { actorTokenId }),
+            orgId,
+            action: "channel.deleted",
+            target: id,
+        });
+    }
     /** 提交后广播；失败只记日志（持有方每轮续租时也会复核连接状态）。 */
     async changed(connectionId, reconnect) {
         try {
-            await this.deps.bus.publish(CHANNEL_CHANGED_TOPIC, { connectionId, reconnect });
+            await this.bus.publish(CHANNEL_CHANGED_TOPIC, { connectionId, reconnect });
         }
         catch (err) {
-            this.deps.log.warn("channel.changed publish failed", { connectionId, err });
+            this.log.warn("channel.changed publish failed", { connectionId, err });
         }
     }
     /**
@@ -417,10 +498,10 @@ export class ChannelConnections {
      * `pluginEnabled` 为插件此刻是否在该组织启用（入站与卡片操作每次都实时复核）。
      */
     async row(id) {
-        const r = await this.deps.db
+        const r = await this.db
             .selectFrom("channel_connections as c")
             .innerJoin("orgs", "orgs.id", "c.org_id")
-            .leftJoin(enabledExtensionsByOrg(this.deps.db).as("p"), (j) => j.onRef("p.plugin", "=", "c.plugin").onRef("p.org_id", "=", "c.org_id"))
+            .leftJoin(enabledExtensionsByOrg(this.db.db).as("p"), (j) => j.onRef("p.plugin", "=", "c.plugin").onRef("p.org_id", "=", "c.org_id"))
             .select([
             "c.id",
             "c.org_id",
@@ -453,7 +534,7 @@ export class ChannelConnections {
      * 持有长连接的副本立即断开（扫描复核只是兜底）。只广播，失败只记日志。
      */
     async notifyOrgChanged(orgId, plugin) {
-        let q = this.deps.db
+        let q = this.db.db
             .selectFrom("channel_connections")
             .select("id")
             .where("org_id", "=", orgId)
@@ -465,7 +546,7 @@ export class ChannelConnections {
             rows = await q.execute();
         }
         catch (err) {
-            this.deps.log.warn("cannot list channel connections to notify", { orgId, err });
+            this.log.warn("cannot list channel connections to notify", { orgId, err });
             return;
         }
         for (const r of rows)
@@ -485,7 +566,7 @@ export class ChannelConnections {
         const entry = this.channelEntry(row.plugin);
         const channel = entry.impl;
         await this.assertEnabled(row.orgId, row.plugin);
-        const stored = await this.deps.db
+        const stored = await this.db
             .selectFrom("channel_connections")
             .select("config")
             .where("id", "=", id)
@@ -505,7 +586,7 @@ export class ChannelConnections {
     async outbound(connectionId) {
         const { row, channel, config } = await this.runtime(connectionId);
         // 组织语言随每次发送 / 更新交给插件（Ruling A22）；本次会话内不变
-        const { locale } = await readOrgSettings(this.deps.db, row.orgId);
+        const { locale } = await readOrgSettings(this.db.db, row.orgId);
         return {
             row,
             features: channel.features,
@@ -531,4 +612,28 @@ export class ChannelConnections {
     async send(connectionId, target, message, idempotencyKey) {
         return (await this.outbound(connectionId)).send(target, message, idempotencyKey);
     }
-}
+};
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], ChannelConnections.prototype, "insertIn", null);
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], ChannelConnections.prototype, "updateIn", null);
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], ChannelConnections.prototype, "removeIn", null);
+ChannelConnections = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(OrgLock)),
+    __param(2, Inject(KEYRING)),
+    __param(3, Inject(ExtensionRegistry)),
+    __param(4, Inject(KERNEL_BUS)),
+    __param(5, Inject(REDIS)),
+    __param(6, Inject(ChannelJobs)),
+    __param(7, Inject(KernelConfigService)),
+    __param(8, Inject(KernelEvents)),
+    __param(9, Inject(KERNEL_LOGGER)),
+    __param(10, Inject(TransactionHost))
+], ChannelConnections);
+export { ChannelConnections };

package/dist/channels/inbound.d.ts

@@ -1,13 +1,17 @@
 import type { ChannelCard, InboundEvent, InboundSender, Logger } from "@capybara-hq/plugin-sdk";
 import type { Redis } from "ioredis";
-import type { ConversationsService } from "../conversations/conversations.service.js";
-import type { KernelDb } from "../db/kernel-schema.js";
-import type { IdentityBinding } from "../identity/binding.js";
-import type { ExternalIdentities } from "../identity/external.js";
-import type { ApprovalsService } from "../tools/approvals.service.js";
-import type { QuestionsService } from "../tools/questions.service.js";
-import type { ChannelConnectionRow, ChannelConnections } from "./connections.service.js";
+import { ConversationsService } from "../conversations/conversations.service.js";
+import { IdentityBinding } from "../identity/binding.js";
+import { ExternalIdentities } from "../identity/external.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { LockService } from "../infra/lock/lock.service.js";
+import { DirectorySync } from "../orgs/directory-sync.js";
+import { ApprovalsService } from "../tools/approvals.service.js";
+import { QuestionsService } from "../tools/questions.service.js";
+import { type ChannelConnectionRow, ChannelConnections } from "./connections.service.js";
+import { ChannelJobs } from "./jobs.js";
 import { type ChannelLocale, type ChannelPhrase } from "./phrases.js";
+import { AnonymousGuests } from "./threads.js";
 /** 入站消息去重键的保留时长（秒）：平台在这段时间内重投同一条消息只处理一次。 */
 export declare const MESSAGE_DEDUPE_TTL_SECONDS = 86400;
 /** Dedupe key states: the enqueue is running (`pending`) or has succeeded (`done`). */
@@ -19,35 +23,6 @@ export declare const DEDUPE_PENDING_TTL_SECONDS = 60;
 export declare const messageDedupeKey: (connectionId: string, messageId: string) => string;
 /** 带平台事件 id 的卡片点击的去重键（Ruling A26，Redis 键，可以含 `:`）。 */
 export declare const actionDedupeKey: (connectionId: string, eventId: string) => string;
-/** 通讯录同步的投递接口（实现见 orgs/directory-sync.ts：按 (组织, 插件) 每分钟去重的维护队列任务）。 */
-export interface DirectorySyncScheduler {
-    /** 返回值（如 job id）不使用。 */
-    enqueue(orgId: string, plugin: string): Promise<unknown>;
-}
-/** 出站投递的投递接口（实现见 outbound.ts：把会话的新事件按 `channel_deliveries.last_seq` 续投到 IM）。 */
-export interface ChannelOutboundScheduler {
-    enqueue(conversationId: string): Promise<void>;
-}
-/** 入站任务的投递接口（实现见 outbound.ts：同一队列 `cap-kernel-channels` 的 `inbound` 任务）。 */
-export interface ChannelInboundQueue {
-    enqueueInbound(connectionId: string, event: InboundEvent, jobId: string): Promise<void>;
-}
-export interface ChannelInboundDeps {
-    db: KernelDb;
-    redis: Redis;
-    connections: Pick<ChannelConnections, "row" | "send">;
-    conversations: Pick<ConversationsService, "create" | "postUserMessage">;
-    external: Pick<ExternalIdentities, "findAccount">;
-    binding: Pick<IdentityBinding, "createBindToken">;
-    directorySync: DirectorySyncScheduler;
-    outbound: ChannelOutboundScheduler;
-    /** 入站任务队列（`onEvent` 只去重并入队，处理在 worker 上执行 {@link ChannelInbound.handle}）。 */
-    queue: ChannelInboundQueue;
-    /** 卡片操作：审批决定与提问回答（授权由这两个服务按点击者映射到的账号判定）。 */
-    approvals: Pick<ApprovalsService, "decide">;
-    questions: Pick<QuestionsService, "answer">;
-    log: Pick<Logger, "warn" | "info">;
-}
 /**
  * 渠道入站（Ruling A21：持久化处理）。
  * - `onEvent`（插件 `connect` 的回调，必须快）：消息按 `capk:channel-msg:<连接>:<消息>` `SET NX` 24 小时去重，
@@ -74,9 +49,30 @@ export interface ChannelInboundDeps {
  * 处理在写入用户消息之后失败而重试时，固定话术 / 卡片回复可能再发一次。
  */
 export declare class ChannelInbound {
-    private readonly deps;
+    private readonly kdb;
+    private readonly redis;
+    /** The two-state dedupe markers (`lease` / `holderOf` / `releaseIf`; keys unchanged). */
+    private readonly locks;
+    private readonly connections;
+    private readonly conversations;
+    private readonly external;
+    private readonly binding;
+    /** 通讯录同步的投递（按 (组织, 插件) 每分钟去重的维护队列任务）。 */
+    private readonly directorySync;
+    /** The channel queue: inbound jobs (`onEvent` only dedupes and enqueues) and deliveries. */
+    private readonly jobs;
+    private readonly guests;
+    private readonly log;
     private readonly actions;
-    constructor(deps: ChannelInboundDeps);
+    constructor(kdb: KernelDb, redis: Pick<Redis, "set">, 
+    /** The two-state dedupe markers (`lease` / `holderOf` / `releaseIf`; keys unchanged). */
+    locks: Pick<LockService, "lease" | "holderOf" | "releaseIf">, connections: Pick<ChannelConnections, "row" | "send">, conversations: Pick<ConversationsService, "create" | "postUserMessage">, external: Pick<ExternalIdentities, "findAccount">, binding: Pick<IdentityBinding, "createBindToken">, 
+    /** 通讯录同步的投递（按 (组织, 插件) 每分钟去重的维护队列任务）。 */
+    directorySync: Pick<DirectorySync, "enqueue">, 
+    /** The channel queue: inbound jobs (`onEvent` only dedupes and enqueues) and deliveries. */
+    jobs: Pick<ChannelJobs, "enqueue" | "enqueueInbound">, 
+    /** 卡片操作：审批决定与提问回答（授权由这两个服务按点击者映射到的账号判定）。 */
+    approvals: Pick<ApprovalsService, "decide">, questions: Pick<QuestionsService, "answer">, guests: Pick<AnonymousGuests, "ensure">, log: Pick<Logger, "warn" | "info">);
     /**
      * 插件 `onEvent`：去重并入队后返回（见类注释）。返回后插件才向平台确认；抛错时插件不确认。
      */