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

package/dist/sandbox/sandbox.service.d.ts

@@ -1,10 +1,14 @@
-import { type Logger, type SandboxHandle, type SandboxProvider } from "@capybara-hq/plugin-sdk";
+import { type SandboxHandle, type SandboxProvider } from "@capybara-hq/plugin-sdk";
 import type { Redis } from "ioredis";
 import { type Selectable } from "kysely";
 import { type KernelConfig } from "../config/schema.js";
-import type { KernelDb, SandboxesTable } from "../db/kernel-schema.js";
+import type { SandboxesTable } from "../db/kernel-schema.js";
 import { ApiError } from "../errors.js";
+import { KernelConfigService } from "../infra/config/kernel-config.service.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import type { KernelLogger } from "../log.js";
 import { SandboxLeases, type SandboxPathLease } from "./leases.js";
+import { type SandboxProviderEntry, SandboxProviders } from "./providers.js";
 export { SANDBOX_BUSY_PREFIX, SANDBOX_LOCK_PREFIX, SANDBOX_LOCK_TTL_MS, SandboxLockLostError, sandboxBusy, } from "./leases.js";
 /** `withSandbox` 回调的第三个参数。 */
 export interface SandboxUseInfo {
@@ -13,27 +17,7 @@ export interface SandboxUseInfo {
     /** 之前有过实例、但已不在（被销毁、提供方返回 gone、换了提供方），这是重建的空沙箱。 */
     recreated: boolean;
 }
-/** 当前的 `sandbox@1` 提供方：插件名与实现。 */
-export interface SandboxProviderEntry {
-    plugin: string;
-    impl: SandboxProvider;
-}
-export interface SandboxServiceDeps {
-    db: KernelDb;
-    redis: Redis;
-    /** 每次调用时取（提供方在插件加载后才就绪）；没有提供方为 undefined。 */
-    provider: () => SandboxProviderEntry | undefined;
-    /** 按插件名找仍加载着的提供方（销毁换提供方前的旧实例）；省略则视为找不到。 */
-    lookup?: (plugin: string) => SandboxProvider | undefined;
-    config: () => Pick<KernelConfig, "sandbox">;
-    log: Pick<Logger, "info" | "warn">;
-    /** Poll interval while waiting for a lease (ms), default 100; tests make it shorter. */
-    lockPollMs?: number;
-    /** Lease TTL (ms), default {@link SANDBOX_LOCK_TTL_MS}; tests make it shorter to notice a lost lease quickly. */
-    lockTtlMs?: number;
-    /** Lease implementation, default a {@link SandboxLeases} on `redis` (tests may wrap one). */
-    leases?: SandboxLeases;
-}
+export type { SandboxProviderEntry } from "./providers.js";
 type Row = Selectable<SandboxesTable>;
 /**
  * One instance of a conversation's sandbox: its handle and the row's `created_at`, which the
@@ -85,7 +69,7 @@ export declare const sandboxUnavailable: () => ApiError;
  *   first, so a stale exclusive holder's later writes fail. Shared holders write nothing else but
  *   `last_used_at` (monotonic). A lost
  *   lease aborts the signal passed to `fn` and to maintenance provider calls.
- * - **休眠与销毁**由维护队列定期调用 {@link suspendIdle} / {@link destroyInactive}；它们只试一次 exclusive
+ * - **Suspension and destruction**: the sweeps (`SandboxSweepJobs`, crons) call {@link suspendIdle} / {@link destroyInactive}；它们只试一次 exclusive
  *   lease and skip a sandbox with any holder; a sandbox past `maxRunningMinutes` gets the intent for
  *   a short window (about a second) so the suspension can get in when its commands end.
  * - **透明恢复**：已休眠的在下次使用时恢复；恢复返回 `gone`、已销毁、记录的提供方不是当前提供方、
@@ -108,10 +92,21 @@ export declare const sandboxUnavailable: () => ApiError;
  * 没有提供方时 {@link available} 为 false，使用时抛 `sandbox.unavailable`（503）。本身无进程内状态，可多副本共用。
  */
 export declare class SandboxService {
-    private readonly d;
+    private readonly db;
+    /** The record of the instance each holder last used (`capk:sandbox-seen:…`). */
+    private readonly redis;
     private readonly leases;
-    private readonly pollMs;
-    constructor(d: SandboxServiceDeps);
+    /** The `sandbox@1` provider (read at every call: providers are ready after the extension load). */
+    private readonly providers;
+    private readonly config;
+    private readonly log;
+    constructor(db: KernelDb, 
+    /** The record of the instance each holder last used (`capk:sandbox-seen:…`). */
+    redis: Pick<Redis, "set">, leases: SandboxLeases, 
+    /** The `sandbox@1` provider (read at every call: providers are ready after the extension load). */
+    providers: Pick<SandboxProviders, "current" | "lookup">, config: Pick<KernelConfigService, "get">, log: Pick<KernelLogger, "info" | "warn">);
+    /** Poll interval while waiting for a lease (the leases' own). */
+    private get pollMs();
     /** 是否有沙箱提供方。 */
     get available(): boolean;
     /** Concurrent holders the provider gets ({@link sandboxConcurrency} with the current config). */
@@ -192,12 +187,12 @@ export declare class SandboxService {
     /**
      * 休眠：空闲超过 `suspendAfterIdleMinutes`、或连续运行超过 `maxRunningMinutes` 的运行中沙箱。
      * Skips a sandbox with any holder; one past `maxRunningMinutes` gets the intent for one poll
-     * window (about a second) first. 返回本次休眠的个数。由维护队列每分钟调用。
+     * window (about a second) first. 返回本次休眠的个数。Called every minute by the `sandbox-suspend-idle` cron.
      */
     suspendIdle(now: Date): Promise<number>;
     /**
      * 销毁：超过 `destroyAfterInactiveDays` 没用过的、所属组织已删除的、对话已不存在的沙箱
-     * （对话已不存在的，销毁后删掉记录）。有 holder 的跳过。返回本次销毁的个数。由维护队列每小时调用。
+     * （对话已不存在的，销毁后删掉记录）。有 holder 的跳过。返回本次销毁的个数。Called hourly by the `sandbox-destroy-inactive` cron.
      */
     destroyInactive(now: Date): Promise<number>;
     /**

package/dist/sandbox/sandbox.service.js

@@ -1,12 +1,26 @@
+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 { isSandboxGoneError, } from "@capybara-hq/plugin-sdk";
+import { Inject, Injectable } from "@nestjs/common";
 import { sql, } from "kysely";
 import { DEFAULT_MAX_COMMAND_SECONDS, DEFAULT_MAX_RUN_SECONDS, } from "../config/schema.js";
 import { ApiError } from "../errors.js";
 import { readSandboxLimitOverride } from "../identity/settings.js";
+import { KernelConfigService } from "../infra/config/kernel-config.service.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { KERNEL_LOGGER, REDIS } from "../infra/tokens.js";
 import { effectiveSandboxEgress, effectiveSandboxLimits, readOrgSettings, } from "../orgs/settings.service.js";
-import { canonicalJson } from "../tools/registry.js";
-import { SANDBOX_LOCK_TTL_MS, SandboxLeases, SandboxLockLostError, sandboxBusy, } from "./leases.js";
+import { canonicalJson } from "../tools/canonical-json.js";
+import { SandboxLeases, SandboxLockLostError, sandboxBusy, } from "./leases.js";
+import { SandboxProviders } from "./providers.js";
 // Moved to leases.ts (phase C); re-exported for existing importers
 export { SANDBOX_BUSY_PREFIX, SANDBOX_LOCK_PREFIX, SANDBOX_LOCK_TTL_MS, SandboxLockLostError, sandboxBusy, } from "./leases.js";
 /** Margin (ms) of a holder record's TTL beyond the longest command: by then the in-sandbox limit has ended its commands. */
@@ -137,7 +151,7 @@ async function inPool(items, limit, fn) {
  *   first, so a stale exclusive holder's later writes fail. Shared holders write nothing else but
  *   `last_used_at` (monotonic). A lost
  *   lease aborts the signal passed to `fn` and to maintenance provider calls.
- * - **休眠与销毁**由维护队列定期调用 {@link suspendIdle} / {@link destroyInactive}；它们只试一次 exclusive
+ * - **Suspension and destruction**: the sweeps (`SandboxSweepJobs`, crons) call {@link suspendIdle} / {@link destroyInactive}；它们只试一次 exclusive
  *   lease and skip a sandbox with any holder; a sandbox past `maxRunningMinutes` gets the intent for
  *   a short window (about a second) so the suspension can get in when its commands end.
  * - **透明恢复**：已休眠的在下次使用时恢复；恢复返回 `gone`、已销毁、记录的提供方不是当前提供方、
@@ -159,36 +173,43 @@ async function inPool(items, limit, fn) {
  * 换提供方会泄漏旧实例：新提供方销毁不了旧提供方的实例，只有旧提供方仍加载时才能清理（记在 `prev_*` 列）。
  * 没有提供方时 {@link available} 为 false，使用时抛 `sandbox.unavailable`（503）。本身无进程内状态，可多副本共用。
  */
-export class SandboxService {
-    d;
+let SandboxService = class SandboxService {
+    db;
+    redis;
     leases;
-    pollMs;
-    constructor(d) {
-        this.d = d;
-        this.pollMs = d.lockPollMs ?? 100;
-        this.leases =
-            d.leases ??
-                new SandboxLeases({
-                    redis: d.redis,
-                    log: d.log,
-                    ttlMs: d.lockTtlMs ?? SANDBOX_LOCK_TTL_MS,
-                    pollMs: this.pollMs,
-                });
+    providers;
+    config;
+    log;
+    constructor(db, 
+    /** The record of the instance each holder last used (`capk:sandbox-seen:…`). */
+    redis, leases, 
+    /** The `sandbox@1` provider (read at every call: providers are ready after the extension load). */
+    providers, config, log) {
+        this.db = db;
+        this.redis = redis;
+        this.leases = leases;
+        this.providers = providers;
+        this.config = config;
+        this.log = log;
+    }
+    /** Poll interval while waiting for a lease (the leases' own). */
+    get pollMs() {
+        return this.leases.pollMs;
     }
     /** 是否有沙箱提供方。 */
     get available() {
-        return this.d.provider() !== undefined;
+        return this.providers.current() !== undefined;
     }
     /** Concurrent holders the provider gets ({@link sandboxConcurrency} with the current config). */
     effectiveCap(p) {
-        return sandboxConcurrency(p.impl, this.d.config().sandbox.maxConcurrentCommands);
+        return sandboxConcurrency(p.impl, this.config.get().sandbox.maxConcurrentCommands);
     }
     /**
      * 该对话沙箱的对外状态（只读，不拿锁）：`running` / `suspended` 与最近使用时间。
      * 还没有、已销毁、或停在 `creating`（正在创建，或创建失败等下次使用重建）的都返回 null（界面显示「未创建」）。
      */
     async status(orgId, conversationId) {
-        const row = await this.d.db
+        const row = await this.db
             .selectFrom("sandboxes")
             .select(["status", "last_used_at"])
             .where("conversation_id", "=", conversationId)
@@ -231,7 +252,7 @@ export class SandboxService {
             catch (err) {
                 if (!isSandboxGoneError(err))
                     throw err;
-                this.d.log.info("sandbox instance is gone during use; recreating", {
+                this.log.info("sandbox instance is gone during use; recreating", {
                     conversationId: ctx.conversationId,
                 });
                 const gone = { handle: e.handle, createdAt: e.createdAt };
@@ -252,14 +273,14 @@ export class SandboxService {
      */
     async seenBy(conversationId, holder, e) {
         try {
-            const ttl = (this.d.config().sandbox.limits.destroyAfterInactiveDays + 1) * 86_400;
-            const prev = await this.d.redis.set(`capk:sandbox-seen:${conversationId}:${holder}`, String(e.createdAt), "EX", ttl, "GET");
+            const ttl = (this.config.get().sandbox.limits.destroyAfterInactiveDays + 1) * 86_400;
+            const prev = await this.redis.set(`capk:sandbox-seen:${conversationId}:${holder}`, String(e.createdAt), "EX", ttl, "GET");
             if (prev !== null && prev !== String(e.createdAt) && !e.info.recreated) {
                 return { ...e, info: { fresh: e.info.fresh, recreated: true } };
             }
         }
         catch (err) {
-            this.d.log.warn("cannot record the sandbox instance a holder uses", {
+            this.log.warn("cannot record the sandbox instance a holder uses", {
                 conversationId,
                 holder,
                 err,
@@ -283,7 +304,7 @@ export class SandboxService {
     async enter(ctx, p, signal, gone) {
         const conv = ctx.conversationId;
         const cap = this.effectiveCap(p);
-        const deadline = Date.now() + this.d.config().sandbox.lockWaitSeconds * 1000;
+        const deadline = Date.now() + this.config.get().sandbox.lockWaitSeconds * 1000;
         const token = randomUUID();
         let intent = false;
         try {
@@ -322,10 +343,10 @@ export class SandboxService {
     async clearIntent(conv, token) {
         await this.leases
             .clearIntent(conv, token)
-            .catch((err) => this.d.log.warn("cannot clear sandbox intent", { conversationId: conv, err }));
+            .catch((err) => this.log.warn("cannot clear sandbox intent", { conversationId: conv, err }));
     }
     async readRow(ctx) {
-        const row = await this.d.db
+        const row = await this.db
             .selectFrom("sandboxes")
             .selectAll()
             .where("conversation_id", "=", ctx.conversationId)
@@ -358,7 +379,7 @@ export class SandboxService {
             // Bump the fence as every acquisition did before phase C: an exclusive holder whose lease
             // expired unnoticed (a stalled sweep) then fails its next write instead of suspending or
             // destroying the instance under this holder. Shared holders never compare it.
-            await this.d.db
+            await this.db
                 .updateTable("sandboxes")
                 .set((eb) => ({ generation: eb("generation", "+", 1) }))
                 .where("conversation_id", "=", conv)
@@ -379,7 +400,7 @@ export class SandboxService {
                     await this.killLeftovers(conv, row.handle, p, sig, "takeover");
                 }
                 else {
-                    this.d.log.warn("cannot kill leftover sandbox commands: the provider has no killTagged and another holder is live; the in-sandbox time limit ends them", { conversationId: conv });
+                    this.log.warn("cannot kill leftover sandbox commands: the provider has no killTagged and another holder is live; the in-sandbox time limit ends them", { conversationId: conv });
                 }
             }
             return {
@@ -423,24 +444,24 @@ export class SandboxService {
     async leave(conv, e) {
         await this.unregister(conv, e.lease.token);
         await e.lease.release();
-        await this.d.db
+        await this.db
             .updateTable("sandboxes")
             .set({ last_used_at: sql `GREATEST(last_used_at, now())` })
             .where("conversation_id", "=", conv)
             .where("status", "=", "running")
             .execute()
-            .catch((err) => this.d.log.warn("cannot update sandbox last_used_at", { conversationId: conv, err }));
+            .catch((err) => this.log.warn("cannot update sandbox last_used_at", { conversationId: conv, err }));
     }
     async register(conv, token) {
-        const ttl = this.d.config().sandbox.limits.maxCommandSeconds * 1000 + HOLDER_TTL_MARGIN_MS;
+        const ttl = this.config.get().sandbox.limits.maxCommandSeconds * 1000 + HOLDER_TTL_MARGIN_MS;
         await this.leases
             .registerHolder(conv, token, ttl)
-            .catch((err) => this.d.log.warn("cannot record sandbox holder", { conversationId: conv, err }));
+            .catch((err) => this.log.warn("cannot record sandbox holder", { conversationId: conv, err }));
     }
     async unregister(conv, token) {
         await this.leases
             .unregisterHolder(conv, token)
-            .catch((err) => this.d.log.warn("cannot clear sandbox holder record", { conversationId: conv, err }));
+            .catch((err) => this.log.warn("cannot clear sandbox holder record", { conversationId: conv, err }));
     }
     /**
      * Crashed holders' tags (claimed), and an older kernel's busy marker when `exclusiveToken` is
@@ -451,7 +472,7 @@ export class SandboxService {
             return await this.leases.claimDeadHolders(conv, exclusiveToken);
         }
         catch (err) {
-            this.d.log.warn("cannot read sandbox holder records", { conversationId: conv, err });
+            this.log.warn("cannot read sandbox holder records", { conversationId: conv, err });
             return { tags: [], legacyMarker: false };
         }
     }
@@ -460,33 +481,33 @@ export class SandboxService {
         try {
             await call();
             if (why === "takeover") {
-                this.d.log.info("sandbox taken over from a holder that did not finish; leftover commands killed", { conversationId });
+                this.log.info("sandbox taken over from a holder that did not finish; leftover commands killed", { conversationId });
             }
         }
         catch (err) {
             if (signal?.aborted || isSandboxGoneError(err))
                 throw err;
-            this.d.log.warn("cannot kill leftover sandbox commands", { conversationId, err });
+            this.log.warn("cannot kill leftover sandbox commands", { conversationId, err });
         }
     }
     /**
      * 休眠：空闲超过 `suspendAfterIdleMinutes`、或连续运行超过 `maxRunningMinutes` 的运行中沙箱。
      * Skips a sandbox with any holder; one past `maxRunningMinutes` gets the intent for one poll
-     * window (about a second) first. 返回本次休眠的个数。由维护队列每分钟调用。
+     * window (about a second) first. 返回本次休眠的个数。Called every minute by the `sandbox-suspend-idle` cron.
      */
     async suspendIdle(now) {
-        const p = this.d.provider();
+        const p = this.providers.current();
         if (!p)
             return 0;
         const due = this.suspendDue(now, p.plugin);
-        const runningBefore = new Date(now.getTime() - this.d.config().sandbox.limits.maxRunningMinutes * 60_000);
+        const runningBefore = new Date(now.getTime() - this.config.get().sandbox.limits.maxRunningMinutes * 60_000);
         const rows = await this.candidates(due);
         let n = 0;
         await inPool(rows, SWEEP_CONCURRENCY, async (c) => {
             const overdue = c.running_since !== null && c.running_since < runningBefore;
             const done = await this.tryLocked(c.conversation_id, async (lease) => {
                 const id = c.conversation_id;
-                const row = await this.d.db
+                const row = await this.db
                     .selectFrom("sandboxes")
                     .selectAll()
                     .where("conversation_id", "=", id)
@@ -504,7 +525,7 @@ export class SandboxService {
                     running_since: null,
                     sweep_failed_at: null,
                 });
-                this.d.log.info("sandbox suspended", { conversationId: id });
+                this.log.info("sandbox suspended", { conversationId: id });
                 return true;
             }, overdue);
             if (done)
@@ -514,10 +535,10 @@ export class SandboxService {
     }
     /**
      * 销毁：超过 `destroyAfterInactiveDays` 没用过的、所属组织已删除的、对话已不存在的沙箱
-     * （对话已不存在的，销毁后删掉记录）。有 holder 的跳过。返回本次销毁的个数。由维护队列每小时调用。
+     * （对话已不存在的，销毁后删掉记录）。有 holder 的跳过。返回本次销毁的个数。Called hourly by the `sandbox-destroy-inactive` cron.
      */
     async destroyInactive(now) {
-        const p = this.d.provider();
+        const p = this.providers.current();
         if (!p)
             return 0;
         const due = this.destroyDue(now);
@@ -525,7 +546,7 @@ export class SandboxService {
         let n = 0;
         await inPool(rows, SWEEP_CONCURRENCY, async ({ conversation_id: id }) => {
             const done = await this.tryLocked(id, async (lease) => {
-                const row = await this.d.db
+                const row = await this.db
                     .selectFrom("sandboxes")
                     .selectAll()
                     .where("conversation_id", "=", id)
@@ -540,7 +561,7 @@ export class SandboxService {
                 n++;
         });
         // 早先已销毁、对话后来才删除、且没有遗留旧实例的记录
-        await this.d.db
+        await this.db
             .deleteFrom("sandboxes")
             .where("status", "=", "destroyed")
             .where("prev_handle", "is", null)
@@ -556,21 +577,21 @@ export class SandboxService {
      * to 10 minutes. 没有提供方时只记 warn。
      */
     async destroyFor(conversationId) {
-        const row = await this.d.db
+        const row = await this.db
             .selectFrom("sandboxes")
             .select("status")
             .where("conversation_id", "=", conversationId)
             .executeTakeFirst();
         if (!row || row.status === "destroyed")
             return;
-        const p = this.d.provider();
+        const p = this.providers.current();
         if (!p) {
-            this.d.log.warn("cannot destroy sandbox: no sandbox provider", { conversationId });
+            this.log.warn("cannot destroy sandbox: no sandbox provider", { conversationId });
             return;
         }
         const lease = await this.leases.acquireExclusive(conversationId, AbortSignal.timeout(DESTROY_FOR_WAIT_MS), undefined, { intent: true });
         try {
-            const current = await this.d.db
+            const current = await this.db
                 .selectFrom("sandboxes")
                 .selectAll()
                 .where("conversation_id", "=", conversationId)
@@ -591,14 +612,14 @@ export class SandboxService {
         const killAll = p.impl.killAll;
         if (!killAll) {
             if (why === "takeover") {
-                this.d.log.info("sandbox taken over from a holder that did not finish; provider cannot kill its commands", { conversationId });
+                this.log.info("sandbox taken over from a holder that did not finish; provider cannot kill its commands", { conversationId });
             }
             return;
         }
         await this.kill(conversationId, why, () => killAll.call(p.impl, handle, signal), signal);
     }
     require() {
-        const p = this.d.provider();
+        const p = this.providers.current();
         if (!p)
             throw sandboxUnavailable();
         return p;
@@ -609,7 +630,7 @@ export class SandboxService {
     async fenced(lease, id, fence, set) {
         if (lease.signal.aborted)
             throw new SandboxLockLostError(id);
-        const r = await this.d.db
+        const r = await this.db
             .updateTable("sandboxes")
             .set({ ...set, generation: fence.gen + 1 })
             .where("conversation_id", "=", id)
@@ -623,7 +644,7 @@ export class SandboxService {
     }
     /** 扫描的候选：上次扫描失败的排在后面，其余按最久未用在前。 */
     async candidates(due) {
-        return await this.d.db
+        return await this.db
             .selectFrom("sandboxes")
             .select(["conversation_id", "running_since"])
             .where(due)
@@ -653,7 +674,7 @@ export class SandboxService {
             }
         }
         catch (err) {
-            this.d.log.warn("cannot take sandbox lock", { conversationId, err });
+            this.log.warn("cannot take sandbox lock", { conversationId, err });
             return false;
         }
         if (!lease)
@@ -662,8 +683,8 @@ export class SandboxService {
             return await fn(lease);
         }
         catch (err) {
-            this.d.log.warn("sandbox maintenance failed; will retry", { conversationId, err });
-            await this.d.db
+            this.log.warn("sandbox maintenance failed; will retry", { conversationId, err });
+            await this.db
                 .updateTable("sandboxes")
                 .set({ sweep_failed_at: sql `now()` })
                 .where("conversation_id", "=", conversationId)
@@ -682,12 +703,12 @@ export class SandboxService {
      */
     async ensure(ctx, p, held, signal, gone) {
         const id = ctx.conversationId;
-        await this.d.db
+        await this.db
             .insertInto("sandboxes")
             .values({ conversation_id: id, org_id: ctx.orgId, provider: p.plugin, status: "creating" })
             .onConflict((oc) => oc.column("conversation_id").doNothing())
             .execute();
-        const row = await this.d.db
+        const row = await this.db
             .selectFrom("sandboxes")
             .selectAll()
             .where("conversation_id", "=", id)
@@ -725,7 +746,7 @@ export class SandboxService {
                         resumed: true,
                     };
                 }
-                this.d.log.info("sandbox is gone at the provider; recreating", { conversationId: id });
+                this.log.info("sandbox is gone at the provider; recreating", { conversationId: id });
             }
         }
         // 换了提供方且旧实例还没销毁：交给旧提供方（仍加载时）销毁，否则记进 prev_*
@@ -734,7 +755,7 @@ export class SandboxService {
             const kept = await this.retire(id, row.provider, handle, signal);
             if (kept) {
                 if (row.prev_handle) {
-                    this.d.log.warn("sandbox instance of an earlier provider is leaked", {
+                    this.log.warn("sandbox instance of an earlier provider is leaked", {
                         conversationId: id,
                         provider: row.prev_provider,
                     });
@@ -764,11 +785,11 @@ export class SandboxService {
             sweep_failed_at: null,
             ...extra,
         });
-        const cfg = this.d.config().sandbox;
+        const cfg = this.config.get().sandbox;
         // 出站按组织设置收窄（Ruling M19）；只在创建时生效，改设置只影响之后新建的沙箱
-        const egress = effectiveSandboxEgress(cfg.limits, (await readOrgSettings(this.d.db, ctx.orgId)).sandboxEgress);
+        const egress = effectiveSandboxEgress(cfg.limits, (await readOrgSettings(this.db.db, ctx.orgId)).sandboxEgress);
         // cpu / 内存按企业管理员的组织覆盖（C19 / Ruling M16），同样只在创建时生效
-        const sized = effectiveSandboxLimits({ ...cfg.limits, ...egress }, await readSandboxLimitOverride(this.d.db, ctx.orgId));
+        const sized = effectiveSandboxLimits({ ...cfg.limits, ...egress }, await readSandboxLimitOverride(this.db.db, ctx.orgId));
         const limits = {
             cpu: sized.cpu,
             memoryMb: sized.memoryMb,
@@ -792,27 +813,27 @@ export class SandboxService {
             // 锁已丢失、没能记下句柄：尽力销毁刚建好的实例，免得泄漏。
             // 提供方按名字（cap-<对话>）复用实例时（Ruling M10），这个 destroy 可能打到新持有者刚恢复 / 创建的同一个实例。
             // 这能自愈：新持有者下一次提供方调用抛 SandboxGoneError（或 resume 返回 gone），withSandbox 原地重建并重试。
-            await p.impl.destroy(handle, AbortSignal.timeout(SWEEP_OP_TIMEOUT_MS)).catch((err) => this.d.log.warn("cannot destroy sandbox created after the lock was lost", {
+            await p.impl.destroy(handle, AbortSignal.timeout(SWEEP_OP_TIMEOUT_MS)).catch((err) => this.log.warn("cannot destroy sandbox created after the lock was lost", {
                 conversationId: id,
                 err,
             }));
             throw e;
         }
-        this.d.log.info("sandbox created", { conversationId: id, provider: p.plugin });
+        this.log.info("sandbox created", { conversationId: id, provider: p.plugin });
         return { handle, createdAt: createdAt.getTime() };
     }
     /**
      * 用旧提供方销毁别的提供方创建的实例：旧提供方仍加载且销毁成功 → false；否则 warn 并返回 true（需要留着记录）。
      */
     async retire(id, provider, handle, signal) {
-        const old = this.d.lookup?.(provider);
+        const old = this.providers.lookup(provider);
         if (old) {
             try {
                 await old.destroy(handle, AbortSignal.any([signal, AbortSignal.timeout(SWEEP_OP_TIMEOUT_MS)]));
                 return false;
             }
             catch (err) {
-                this.d.log.warn("cannot destroy sandbox instance of the previous provider", {
+                this.log.warn("cannot destroy sandbox instance of the previous provider", {
                     conversationId: id,
                     provider,
                     err,
@@ -820,7 +841,7 @@ export class SandboxService {
                 return true;
             }
         }
-        this.d.log.warn("sandbox was created by another provider that is not loaded; its instance may leak", { conversationId: id, provider });
+        this.log.warn("sandbox was created by another provider that is not loaded; its instance may leak", { conversationId: id, provider });
         return true;
     }
     /** 在锁内：销毁实例（与遗留的旧提供方实例）；对话已不存在的删掉记录，否则标记 destroyed。 */
@@ -848,7 +869,7 @@ export class SandboxService {
         }
         if (!(await held.renew()))
             throw new SandboxLockLostError(id);
-        const conversation = await this.d.db
+        const conversation = await this.db
             .selectFrom("conversations")
             .select("id")
             .where("id", "=", id)
@@ -864,7 +885,7 @@ export class SandboxService {
             });
         }
         else {
-            const r = await this.d.db
+            const r = await this.db
                 .deleteFrom("sandboxes")
                 .where("conversation_id", "=", id)
                 .where("generation", "=", fence.gen)
@@ -872,11 +893,11 @@ export class SandboxService {
             if (Number(r.numDeletedRows) !== 1)
                 throw new SandboxLockLostError(id, "generation");
         }
-        this.d.log.info("sandbox destroyed", { conversationId: id });
+        this.log.info("sandbox destroyed", { conversationId: id });
     }
     /** 该休眠的：本提供方创建、运行中，且空闲到期或连续运行超时。 */
     suspendDue(now, plugin) {
-        const lim = this.d.config().sandbox.limits;
+        const lim = this.config.get().sandbox.limits;
         const idleBefore = new Date(now.getTime() - lim.suspendAfterIdleMinutes * 60_000);
         const runningBefore = new Date(now.getTime() - lim.maxRunningMinutes * 60_000);
         return (eb) => eb.and([
@@ -887,7 +908,7 @@ export class SandboxService {
     }
     /** 该销毁的：未销毁，且不活跃到期、组织已删除或对话已不存在。 */
     destroyDue(now) {
-        const days = this.d.config().sandbox.limits.destroyAfterInactiveDays;
+        const days = this.config.get().sandbox.limits.destroyAfterInactiveDays;
         const before = new Date(now.getTime() - days * 24 * 3_600_000);
         return (eb) => eb.and([
             eb("status", "<>", "destroyed"),
@@ -905,4 +926,14 @@ export class SandboxService {
             ]),
         ]);
     }
-}
+};
+SandboxService = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(REDIS)),
+    __param(2, Inject(SandboxLeases)),
+    __param(3, Inject(SandboxProviders)),
+    __param(4, Inject(KernelConfigService)),
+    __param(5, Inject(KERNEL_LOGGER))
+], SandboxService);
+export { SandboxService };