@openclaw/acpx 2026.5.2-beta.2 → 2026.5.3-beta.2

package/src/service.test.ts

@@ -1,401 +0,0 @@
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-const { runtimeRegistry } = vi.hoisted(() => ({
-  runtimeRegistry: new Map<string, { runtime: unknown; healthy?: () => boolean }>(),
-}));
-const { prepareAcpxCodexAuthConfigMock } = vi.hoisted(() => ({
-  prepareAcpxCodexAuthConfigMock: vi.fn(
-    async ({ pluginConfig }: { pluginConfig: unknown }) => pluginConfig,
-  ),
-}));
-const { acpxRuntimeConstructorMock, createAgentRegistryMock, createFileSessionStoreMock } =
-  vi.hoisted(() => ({
-    acpxRuntimeConstructorMock: vi.fn(function AcpxRuntime(options: unknown) {
-      return {
-        cancel: vi.fn(async () => {}),
-        close: vi.fn(async () => {}),
-        doctor: vi.fn(async () => ({ ok: true, message: "ok" })),
-        ensureSession: vi.fn(async () => ({
-          backend: "acpx",
-          runtimeSessionName: "agent:codex:acp:test",
-          sessionKey: "agent:codex:acp:test",
-        })),
-        getCapabilities: vi.fn(async () => ({ controls: [] })),
-        getStatus: vi.fn(async () => ({ summary: "ready" })),
-        isHealthy: vi.fn(() => true),
-        prepareFreshSession: vi.fn(async () => {}),
-        probeAvailability: vi.fn(async () => {}),
-        runTurn: vi.fn(async function* () {}),
-        setConfigOption: vi.fn(async () => {}),
-        setMode: vi.fn(async () => {}),
-        __options: options,
-      };
-    }),
-    createAgentRegistryMock: vi.fn(() => ({})),
-    createFileSessionStoreMock: vi.fn(() => ({})),
-  }));
-
-vi.mock("../runtime-api.js", () => ({
-  getAcpRuntimeBackend: (id: string) => runtimeRegistry.get(id),
-  registerAcpRuntimeBackend: (entry: { id: string; runtime: unknown; healthy?: () => boolean }) => {
-    runtimeRegistry.set(entry.id, entry);
-  },
-  unregisterAcpRuntimeBackend: (id: string) => {
-    runtimeRegistry.delete(id);
-  },
-}));
-
-vi.mock("./runtime.js", () => ({
-  ACPX_BACKEND_ID: "acpx",
-  AcpxRuntime: acpxRuntimeConstructorMock,
-  createAgentRegistry: createAgentRegistryMock,
-  createFileSessionStore: createFileSessionStoreMock,
-}));
-
-vi.mock("./codex-auth-bridge.js", () => ({
-  prepareAcpxCodexAuthConfig: prepareAcpxCodexAuthConfigMock,
-}));
-
-import { getAcpRuntimeBackend } from "../runtime-api.js";
-import { createAcpxRuntimeService } from "./service.js";
-
-const tempDirs: string[] = [];
-
-async function makeTempDir(): Promise<string> {
-  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-acpx-service-"));
-  tempDirs.push(dir);
-  return dir;
-}
-
-afterEach(async () => {
-  runtimeRegistry.clear();
-  prepareAcpxCodexAuthConfigMock.mockClear();
-  acpxRuntimeConstructorMock.mockClear();
-  createAgentRegistryMock.mockClear();
-  createFileSessionStoreMock.mockClear();
-  delete process.env.OPENCLAW_ACPX_RUNTIME_STARTUP_PROBE;
-  delete process.env.OPENCLAW_SKIP_ACPX_RUNTIME;
-  delete process.env.OPENCLAW_SKIP_ACPX_RUNTIME_PROBE;
-  for (const dir of tempDirs.splice(0)) {
-    await fs.rm(dir, { recursive: true, force: true });
-  }
-});
-
-function createServiceContext(workspaceDir: string) {
-  return {
-    workspaceDir,
-    stateDir: path.join(workspaceDir, ".openclaw-plugin-state"),
-    config: {},
-    logger: {
-      info: vi.fn(),
-      warn: vi.fn(),
-      error: vi.fn(),
-      debug: vi.fn(),
-    },
-  };
-}
-
-function createMockRuntime(overrides: Record<string, unknown> = {}) {
-  return {
-    ensureSession: vi.fn(),
-    runTurn: vi.fn(),
-    cancel: vi.fn(),
-    close: vi.fn(),
-    probeAvailability: vi.fn(async () => {}),
-    isHealthy: vi.fn(() => true),
-    doctor: vi.fn(async () => ({ ok: true, message: "ok" })),
-    ...overrides,
-  };
-}
-
-describe("createAcpxRuntimeService", () => {
-  it("registers and unregisters the embedded backend", async () => {
-    const workspaceDir = await makeTempDir();
-    const ctx = createServiceContext(workspaceDir);
-    const runtime = createMockRuntime();
-    const service = createAcpxRuntimeService({
-      runtimeFactory: () => runtime as never,
-    });
-
-    await service.start(ctx);
-
-    expect(getAcpRuntimeBackend("acpx")?.runtime).toBe(runtime);
-
-    await service.stop?.(ctx);
-
-    expect(getAcpRuntimeBackend("acpx")).toBeUndefined();
-  });
-
-  it("creates the embedded runtime state directory without probing at startup by default", async () => {
-    const workspaceDir = await makeTempDir();
-    const stateDir = path.join(workspaceDir, "custom-state");
-    const ctx = createServiceContext(workspaceDir);
-    const probeAvailability = vi.fn(async () => {
-      await fs.access(stateDir);
-    });
-    const runtime = createMockRuntime({
-      doctor: async () => ({ ok: true, message: "ok" }),
-      isHealthy: () => true,
-      probeAvailability,
-    });
-    const service = createAcpxRuntimeService({
-      pluginConfig: { stateDir },
-      runtimeFactory: () => runtime as never,
-    });
-
-    await service.start(ctx);
-
-    await fs.access(stateDir);
-    expect(probeAvailability).not.toHaveBeenCalled();
-    expect(getAcpRuntimeBackend("acpx")?.healthy).toBeUndefined();
-
-    await service.stop?.(ctx);
-  });
-
-  it("registers the default backend without importing ACPX runtime until first use", async () => {
-    const workspaceDir = await makeTempDir();
-    const ctx = createServiceContext(workspaceDir);
-    const service = createAcpxRuntimeService();
-
-    await service.start(ctx);
-
-    const backend = getAcpRuntimeBackend("acpx");
-    expect(backend?.runtime).toBeDefined();
-    expect(acpxRuntimeConstructorMock).not.toHaveBeenCalled();
-
-    await backend?.runtime.ensureSession({
-      agent: "codex",
-      mode: "oneshot",
-      sessionKey: "agent:codex:acp:test",
-    });
-
-    expect(acpxRuntimeConstructorMock).toHaveBeenCalledOnce();
-
-    await service.stop?.(ctx);
-  });
-
-  it("can run the embedded runtime probe at startup when explicitly enabled", async () => {
-    process.env.OPENCLAW_ACPX_RUNTIME_STARTUP_PROBE = "1";
-    const workspaceDir = await makeTempDir();
-    const ctx = createServiceContext(workspaceDir);
-    const probeAvailability = vi.fn(async () => {});
-    const runtime = createMockRuntime({
-      probeAvailability,
-      isHealthy: () => true,
-    });
-    const service = createAcpxRuntimeService({
-      runtimeFactory: () => runtime as never,
-    });
-
-    await service.start(ctx);
-
-    expect(probeAvailability).toHaveBeenCalledOnce();
-    expect(getAcpRuntimeBackend("acpx")?.healthy?.()).toBe(true);
-
-    await service.stop?.(ctx);
-  });
-
-  it("passes the default runtime timeout to the embedded runtime factory", async () => {
-    const workspaceDir = await makeTempDir();
-    const ctx = createServiceContext(workspaceDir);
-    const runtime = createMockRuntime();
-    const runtimeFactory = vi.fn(() => runtime as never);
-    const service = createAcpxRuntimeService({
-      runtimeFactory,
-    });
-
-    await service.start(ctx);
-
-    expect(runtimeFactory).toHaveBeenCalledWith(
-      expect.objectContaining({
-        pluginConfig: expect.objectContaining({
-          timeoutSeconds: 120,
-        }),
-      }),
-    );
-
-    await service.stop?.(ctx);
-  });
-
-  it("forwards a configured probeAgent to the runtime factory so the probe does not hardcode the default", async () => {
-    const workspaceDir = await makeTempDir();
-    const ctx = createServiceContext(workspaceDir);
-    const runtime = {
-      ensureSession: vi.fn(),
-      runTurn: vi.fn(),
-      cancel: vi.fn(),
-      close: vi.fn(),
-      probeAvailability: vi.fn(async () => {}),
-      isHealthy: vi.fn(() => true),
-      doctor: vi.fn(async () => ({ ok: true, message: "ok" })),
-    };
-    const runtimeFactory = vi.fn(() => runtime as never);
-    const service = createAcpxRuntimeService({
-      pluginConfig: { probeAgent: "opencode" },
-      runtimeFactory,
-    });
-
-    await service.start(ctx);
-
-    expect(runtimeFactory).toHaveBeenCalledWith(
-      expect.objectContaining({
-        pluginConfig: expect.objectContaining({
-          probeAgent: "opencode",
-        }),
-      }),
-    );
-
-    await service.stop?.(ctx);
-  });
-
-  it("uses the first allowed ACP agent as the default probe agent", async () => {
-    const workspaceDir = await makeTempDir();
-    const ctx = createServiceContext(workspaceDir);
-    ctx.config = {
-      acp: {
-        allowedAgents: ["  OpenCode  ", "codex"],
-      },
-    };
-    const runtime = createMockRuntime();
-    const runtimeFactory = vi.fn(() => runtime as never);
-    const service = createAcpxRuntimeService({
-      runtimeFactory,
-    });
-
-    await service.start(ctx);
-
-    expect(runtimeFactory).toHaveBeenCalledWith(
-      expect.objectContaining({
-        pluginConfig: expect.objectContaining({
-          probeAgent: "opencode",
-        }),
-      }),
-    );
-
-    await service.stop?.(ctx);
-  });
-
-  it("keeps explicit probeAgent ahead of acp.allowedAgents", async () => {
-    const workspaceDir = await makeTempDir();
-    const ctx = createServiceContext(workspaceDir);
-    ctx.config = {
-      acp: {
-        allowedAgents: ["opencode"],
-      },
-    };
-    const runtime = createMockRuntime();
-    const runtimeFactory = vi.fn(() => runtime as never);
-    const service = createAcpxRuntimeService({
-      pluginConfig: { probeAgent: "codex" },
-      runtimeFactory,
-    });
-
-    await service.start(ctx);
-
-    expect(runtimeFactory).toHaveBeenCalledWith(
-      expect.objectContaining({
-        pluginConfig: expect.objectContaining({
-          probeAgent: "codex",
-        }),
-      }),
-    );
-
-    await service.stop?.(ctx);
-  });
-
-  it("warns when legacy compatibility config is explicitly ignored", async () => {
-    const workspaceDir = await makeTempDir();
-    const ctx = createServiceContext(workspaceDir);
-    const runtime = createMockRuntime();
-    const service = createAcpxRuntimeService({
-      pluginConfig: {
-        queueOwnerTtlSeconds: 30,
-        strictWindowsCmdWrapper: false,
-      },
-      runtimeFactory: () => runtime as never,
-    });
-
-    await service.start(ctx);
-
-    expect(ctx.logger.warn).toHaveBeenCalledWith(
-      expect.stringContaining(
-        "embedded acpx runtime ignores legacy compatibility config: queueOwnerTtlSeconds, strictWindowsCmdWrapper=false",
-      ),
-    );
-
-    await service.stop?.(ctx);
-  });
-
-  it("can skip the embedded runtime probe via env", async () => {
-    process.env.OPENCLAW_ACPX_RUNTIME_STARTUP_PROBE = "1";
-    process.env.OPENCLAW_SKIP_ACPX_RUNTIME_PROBE = "1";
-    const workspaceDir = await makeTempDir();
-    const ctx = createServiceContext(workspaceDir);
-    const probeAvailability = vi.fn(async () => {});
-    const runtime = createMockRuntime({
-      doctor: async () => ({ ok: false, message: "nope" }),
-      isHealthy: () => false,
-      probeAvailability,
-    });
-    const service = createAcpxRuntimeService({
-      runtimeFactory: () => runtime as never,
-    });
-
-    await service.start(ctx);
-
-    expect(probeAvailability).not.toHaveBeenCalled();
-    expect(getAcpRuntimeBackend("acpx")).toBeTruthy();
-
-    await service.stop?.(ctx);
-  });
-
-  it("formats non-string doctor details without losing object payloads", async () => {
-    process.env.OPENCLAW_ACPX_RUNTIME_STARTUP_PROBE = "1";
-    const workspaceDir = await makeTempDir();
-    const ctx = createServiceContext(workspaceDir);
-    const runtime = createMockRuntime({
-      doctor: async () => ({
-        ok: false,
-        message: "probe failed",
-        details: [{ code: "ACP_CLOSED", agent: "codex" }, new Error("stdin closed")],
-      }),
-      isHealthy: () => false,
-    });
-    const service = createAcpxRuntimeService({
-      runtimeFactory: () => runtime as never,
-    });
-
-    await service.start(ctx);
-
-    await vi.waitFor(() => {
-      expect(ctx.logger.warn).toHaveBeenCalledWith(
-        'embedded acpx runtime backend probe failed: probe failed ({"code":"ACP_CLOSED","agent":"codex"}; stdin closed)',
-      );
-    });
-
-    await service.stop?.(ctx);
-  });
-
-  it("can skip the embedded runtime backend via env", async () => {
-    process.env.OPENCLAW_SKIP_ACPX_RUNTIME = "1";
-    const workspaceDir = await makeTempDir();
-    const ctx = createServiceContext(workspaceDir);
-    const runtimeFactory = vi.fn(() => {
-      throw new Error("runtime factory should not run when ACPX is skipped");
-    });
-    const service = createAcpxRuntimeService({
-      runtimeFactory: runtimeFactory as never,
-    });
-
-    await service.start(ctx);
-
-    expect(runtimeFactory).not.toHaveBeenCalled();
-    expect(getAcpRuntimeBackend("acpx")).toBeUndefined();
-    expect(ctx.logger.info).toHaveBeenCalledWith(
-      "skipping embedded acpx runtime backend (OPENCLAW_SKIP_ACPX_RUNTIME=1)",
-    );
-  });
-});

package/src/service.ts

@@ -1,278 +0,0 @@
-import fs from "node:fs/promises";
-import { inspect } from "node:util";
-import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-import type {
-  AcpRuntime,
-  OpenClawPluginService,
-  OpenClawPluginServiceContext,
-  PluginLogger,
-} from "../runtime-api.js";
-import { registerAcpRuntimeBackend, unregisterAcpRuntimeBackend } from "../runtime-api.js";
-import { prepareAcpxCodexAuthConfig } from "./codex-auth-bridge.js";
-import {
-  resolveAcpxPluginConfig,
-  toAcpMcpServers,
-  type ResolvedAcpxPluginConfig,
-} from "./config.js";
-
-type AcpxRuntimeLike = AcpRuntime & {
-  probeAvailability(): Promise<void>;
-  isHealthy(): boolean;
-  doctor?(): Promise<{
-    ok: boolean;
-    message: string;
-    details?: string[];
-  }>;
-};
-
-const ENABLE_STARTUP_PROBE_ENV = "OPENCLAW_ACPX_RUNTIME_STARTUP_PROBE";
-const ACPX_BACKEND_ID = "acpx";
-
-type AcpxRuntimeModule = typeof import("./runtime.js");
-let runtimeModulePromise: Promise<AcpxRuntimeModule> | null = null;
-
-type AcpxRuntimeFactoryParams = {
-  pluginConfig: ResolvedAcpxPluginConfig;
-  logger?: PluginLogger;
-};
-
-type CreateAcpxRuntimeServiceParams = {
-  pluginConfig?: unknown;
-  runtimeFactory?: (params: AcpxRuntimeFactoryParams) => AcpxRuntimeLike | Promise<AcpxRuntimeLike>;
-};
-
-function loadRuntimeModule(): Promise<AcpxRuntimeModule> {
-  runtimeModulePromise ??= import("./runtime.js");
-  return runtimeModulePromise;
-}
-
-function createLazyDefaultRuntime(params: AcpxRuntimeFactoryParams): AcpxRuntimeLike {
-  let runtime: AcpxRuntimeLike | null = null;
-  let runtimePromise: Promise<AcpxRuntimeLike> | null = null;
-
-  async function resolveRuntime(): Promise<AcpxRuntimeLike> {
-    if (runtime) {
-      return runtime;
-    }
-    runtimePromise ??= loadRuntimeModule().then((module) => {
-      runtime = new module.AcpxRuntime({
-        cwd: params.pluginConfig.cwd,
-        sessionStore: module.createFileSessionStore({
-          stateDir: params.pluginConfig.stateDir,
-        }),
-        agentRegistry: module.createAgentRegistry({
-          overrides: params.pluginConfig.agents,
-        }),
-        probeAgent: params.pluginConfig.probeAgent,
-        mcpServers: toAcpMcpServers(params.pluginConfig.mcpServers),
-        permissionMode: params.pluginConfig.permissionMode,
-        nonInteractivePermissions: params.pluginConfig.nonInteractivePermissions,
-        timeoutMs:
-          params.pluginConfig.timeoutSeconds != null
-            ? params.pluginConfig.timeoutSeconds * 1_000
-            : undefined,
-      }) as AcpxRuntimeLike;
-      return runtime;
-    });
-    return await runtimePromise;
-  }
-
-  return {
-    async ensureSession(input) {
-      return await (await resolveRuntime()).ensureSession(input);
-    },
-    async *runTurn(input) {
-      yield* (await resolveRuntime()).runTurn(input);
-    },
-    async getCapabilities(input) {
-      return (await (await resolveRuntime()).getCapabilities?.(input)) ?? { controls: [] };
-    },
-    async getStatus(input) {
-      return (await (await resolveRuntime()).getStatus?.(input)) ?? {};
-    },
-    async setMode(input) {
-      await (await resolveRuntime()).setMode?.(input);
-    },
-    async setConfigOption(input) {
-      await (await resolveRuntime()).setConfigOption?.(input);
-    },
-    async doctor() {
-      return (await (await resolveRuntime()).doctor?.()) ?? { ok: true, message: "ok" };
-    },
-    async prepareFreshSession(input) {
-      await (await resolveRuntime()).prepareFreshSession?.(input);
-    },
-    async cancel(input) {
-      await (await resolveRuntime()).cancel(input);
-    },
-    async close(input) {
-      await (await resolveRuntime()).close(input);
-    },
-    async probeAvailability() {
-      await (await resolveRuntime()).probeAvailability();
-    },
-    isHealthy() {
-      return runtime?.isHealthy() ?? false;
-    },
-  };
-}
-
-function warnOnIgnoredLegacyCompatibilityConfig(params: {
-  pluginConfig: ResolvedAcpxPluginConfig;
-  logger?: PluginLogger;
-}): void {
-  const ignoredFields: string[] = [];
-  if (params.pluginConfig.legacyCompatibilityConfig.queueOwnerTtlSeconds != null) {
-    ignoredFields.push("queueOwnerTtlSeconds");
-  }
-  if (params.pluginConfig.legacyCompatibilityConfig.strictWindowsCmdWrapper === false) {
-    ignoredFields.push("strictWindowsCmdWrapper=false");
-  }
-  if (ignoredFields.length === 0) {
-    return;
-  }
-  params.logger?.warn(
-    `embedded acpx runtime ignores legacy compatibility config: ${ignoredFields.join(", ")}`,
-  );
-}
-
-function formatDoctorDetail(detail: unknown): string | null {
-  if (!detail) {
-    return null;
-  }
-  if (typeof detail === "string") {
-    return detail.trim() || null;
-  }
-  if (detail instanceof Error) {
-    return formatErrorMessage(detail);
-  }
-  if (typeof detail === "object") {
-    try {
-      return JSON.stringify(detail) ?? inspect(detail, { breakLength: Infinity, depth: 3 });
-    } catch {
-      return inspect(detail, { breakLength: Infinity, depth: 3 });
-    }
-  }
-  if (
-    typeof detail === "number" ||
-    typeof detail === "boolean" ||
-    typeof detail === "bigint" ||
-    typeof detail === "symbol"
-  ) {
-    return detail.toString();
-  }
-  return inspect(detail, { breakLength: Infinity, depth: 3 });
-}
-
-function formatDoctorFailureMessage(report: { message: string; details?: unknown[] }): string {
-  const detailText = report.details?.map(formatDoctorDetail).filter(Boolean).join("; ").trim();
-  return detailText ? `${report.message} (${detailText})` : report.message;
-}
-
-function normalizeProbeAgent(value: string | undefined): string | undefined {
-  const normalized = value?.trim().toLowerCase();
-  return normalized ? normalized : undefined;
-}
-
-function resolveAllowedAgentsProbeAgent(ctx: OpenClawPluginServiceContext): string | undefined {
-  for (const agent of ctx.config.acp?.allowedAgents ?? []) {
-    const normalized = normalizeProbeAgent(agent);
-    if (normalized) {
-      return normalized;
-    }
-  }
-  return undefined;
-}
-
-function shouldRunStartupProbe(env: NodeJS.ProcessEnv = process.env): boolean {
-  return env[ENABLE_STARTUP_PROBE_ENV] === "1";
-}
-
-export function createAcpxRuntimeService(
-  params: CreateAcpxRuntimeServiceParams = {},
-): OpenClawPluginService {
-  let runtime: AcpxRuntimeLike | null = null;
-  let lifecycleRevision = 0;
-
-  return {
-    id: "acpx-runtime",
-    async start(ctx: OpenClawPluginServiceContext): Promise<void> {
-      if (process.env.OPENCLAW_SKIP_ACPX_RUNTIME === "1") {
-        ctx.logger.info("skipping embedded acpx runtime backend (OPENCLAW_SKIP_ACPX_RUNTIME=1)");
-        return;
-      }
-
-      const basePluginConfig = resolveAcpxPluginConfig({
-        rawConfig: params.pluginConfig,
-        workspaceDir: ctx.workspaceDir,
-      });
-      const effectiveBasePluginConfig: ResolvedAcpxPluginConfig = {
-        ...basePluginConfig,
-        probeAgent: basePluginConfig.probeAgent ?? resolveAllowedAgentsProbeAgent(ctx),
-      };
-      const pluginConfig = await prepareAcpxCodexAuthConfig({
-        pluginConfig: effectiveBasePluginConfig,
-        stateDir: ctx.stateDir,
-        logger: ctx.logger,
-      });
-      await fs.mkdir(pluginConfig.stateDir, { recursive: true });
-      warnOnIgnoredLegacyCompatibilityConfig({
-        pluginConfig,
-        logger: ctx.logger,
-      });
-
-      runtime = params.runtimeFactory
-        ? await params.runtimeFactory({
-            pluginConfig,
-            logger: ctx.logger,
-          })
-        : createLazyDefaultRuntime({
-            pluginConfig,
-            logger: ctx.logger,
-          });
-
-      registerAcpRuntimeBackend({
-        id: ACPX_BACKEND_ID,
-        runtime,
-        ...(shouldRunStartupProbe() ? { healthy: () => runtime?.isHealthy() ?? false } : {}),
-      });
-      ctx.logger.info(`embedded acpx runtime backend registered (cwd: ${pluginConfig.cwd})`);
-
-      if (!shouldRunStartupProbe() || process.env.OPENCLAW_SKIP_ACPX_RUNTIME_PROBE === "1") {
-        return;
-      }
-
-      lifecycleRevision += 1;
-      const currentRevision = lifecycleRevision;
-      void (async () => {
-        try {
-          await runtime?.probeAvailability();
-          if (currentRevision !== lifecycleRevision) {
-            return;
-          }
-          if (runtime?.isHealthy()) {
-            ctx.logger.info("embedded acpx runtime backend ready");
-            return;
-          }
-          const doctorReport = await runtime?.doctor?.();
-          if (currentRevision !== lifecycleRevision) {
-            return;
-          }
-          ctx.logger.warn(
-            `embedded acpx runtime backend probe failed: ${doctorReport ? formatDoctorFailureMessage(doctorReport) : "backend remained unhealthy after probe"}`,
-          );
-        } catch (err) {
-          if (currentRevision !== lifecycleRevision) {
-            return;
-          }
-          ctx.logger.warn(`embedded acpx runtime setup failed: ${formatErrorMessage(err)}`);
-        }
-      })();
-    },
-    async stop(_ctx: OpenClawPluginServiceContext): Promise<void> {
-      lifecycleRevision += 1;
-      unregisterAcpRuntimeBackend(ACPX_BACKEND_ID);
-      runtime = null;
-    },
-  };
-}

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "extends": "../tsconfig.package-boundary.base.json",
-  "compilerOptions": {
-    "rootDir": "."
-  },
-  "include": ["./*.ts", "./src/**/*.ts"],
-  "exclude": [
-    "./**/*.test.ts",
-    "./dist/**",
-    "./node_modules/**",
-    "./src/test-support/**",
-    "./src/**/*test-helpers.ts",
-    "./src/**/*test-harness.ts",
-    "./src/**/*test-support.ts"
-  ]
-}