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

package/src/codex-auth-bridge.ts

@@ -1,385 +0,0 @@
-import fs from "node:fs/promises";
-import { createRequire } from "node:module";
-import path from "node:path";
-import type { ResolvedAcpxPluginConfig } from "./config.js";
-
-const CODEX_ACP_PACKAGE = "@zed-industries/codex-acp";
-const CODEX_ACP_PACKAGE_RANGE = "^0.12.0";
-const CODEX_ACP_BIN = "codex-acp";
-const CLAUDE_ACP_PACKAGE = "@agentclientprotocol/claude-agent-acp";
-const CLAUDE_ACP_PACKAGE_VERSION = "0.31.4";
-const CLAUDE_ACP_BIN = "claude-agent-acp";
-const RUN_CONFIGURED_COMMAND_SENTINEL = "--openclaw-run-configured";
-const requireFromHere = createRequire(import.meta.url);
-
-type PackageManifest = {
-  name?: unknown;
-  bin?: unknown;
-};
-
-function quoteCommandPart(value: string): string {
-  return JSON.stringify(value);
-}
-
-function splitCommandParts(value: string): string[] {
-  const parts: string[] = [];
-  let current = "";
-  let quote: "'" | '"' | null = null;
-  let escaping = false;
-
-  for (const ch of value) {
-    if (escaping) {
-      current += ch;
-      escaping = false;
-      continue;
-    }
-    if (ch === "\\" && quote !== "'") {
-      escaping = true;
-      continue;
-    }
-    if (quote) {
-      if (ch === quote) {
-        quote = null;
-      } else {
-        current += ch;
-      }
-      continue;
-    }
-    if (ch === "'" || ch === '"') {
-      quote = ch;
-      continue;
-    }
-    if (/\s/.test(ch)) {
-      if (current) {
-        parts.push(current);
-        current = "";
-      }
-      continue;
-    }
-    current += ch;
-  }
-
-  if (escaping) {
-    current += "\\";
-  }
-  if (current) {
-    parts.push(current);
-  }
-  return parts;
-}
-
-function basename(value: string): string {
-  return value.split(/[\\/]/).pop() ?? value;
-}
-
-function resolvePackageBinPath(
-  packageJsonPath: string,
-  manifest: PackageManifest,
-  binName: string,
-): string | undefined {
-  const { bin } = manifest;
-  const relativeBinPath =
-    typeof bin === "string"
-      ? bin
-      : bin && typeof bin === "object"
-        ? (bin as Record<string, unknown>)[binName]
-        : undefined;
-  if (typeof relativeBinPath !== "string" || relativeBinPath.trim() === "") {
-    return undefined;
-  }
-  return path.resolve(path.dirname(packageJsonPath), relativeBinPath);
-}
-
-async function resolveInstalledAcpPackageBinPath(
-  packageName: string,
-  binName: string,
-): Promise<string | undefined> {
-  try {
-    const packageJsonPath = requireFromHere.resolve(`${packageName}/package.json`);
-    const manifest = JSON.parse(await fs.readFile(packageJsonPath, "utf8")) as PackageManifest;
-    if (manifest.name !== packageName) {
-      return undefined;
-    }
-    const binPath = resolvePackageBinPath(packageJsonPath, manifest, binName);
-    if (!binPath) {
-      return undefined;
-    }
-    await fs.access(binPath);
-    return binPath;
-  } catch {
-    return undefined;
-  }
-}
-
-async function resolveInstalledCodexAcpBinPath(): Promise<string | undefined> {
-  // Keep OpenClaw's isolated CODEX_HOME wrapper, but launch the plugin-local
-  // Codex ACP adapter when the package dependency is available.
-  return await resolveInstalledAcpPackageBinPath(CODEX_ACP_PACKAGE, CODEX_ACP_BIN);
-}
-
-async function resolveInstalledClaudeAcpBinPath(): Promise<string | undefined> {
-  return await resolveInstalledAcpPackageBinPath(CLAUDE_ACP_PACKAGE, CLAUDE_ACP_BIN);
-}
-
-function buildAdapterWrapperScript(params: {
-  displayName: string;
-  packageSpec: string;
-  binName: string;
-  installedBinPath?: string;
-  envSetup: string;
-}): string {
-  return `#!/usr/bin/env node
-import { existsSync } from "node:fs";
-import path from "node:path";
-import { spawn } from "node:child_process";
-import { fileURLToPath } from "node:url";
-
-${params.envSetup}
-const configuredArgs = process.argv.slice(2);
-
-function resolveNpmCliPath() {
-  const candidate = path.resolve(
-    path.dirname(process.execPath),
-    "..",
-    "lib",
-    "node_modules",
-    "npm",
-    "bin",
-    "npm-cli.js",
-  );
-  return existsSync(candidate) ? candidate : undefined;
-}
-
-const npmCliPath = resolveNpmCliPath();
-const installedBinPath = ${params.installedBinPath ? quoteCommandPart(params.installedBinPath) : "undefined"};
-let defaultCommand;
-let defaultArgs;
-if (installedBinPath) {
-  defaultCommand = process.execPath;
-  defaultArgs = [installedBinPath];
-} else if (npmCliPath) {
-  defaultCommand = process.execPath;
-  defaultArgs = [npmCliPath, "exec", "--yes", "--package", "${params.packageSpec}", "--", "${params.binName}"];
-} else {
-  defaultCommand = process.platform === "win32" ? "npx.cmd" : "npx";
-  defaultArgs = ["--yes", "--package", "${params.packageSpec}", "--", "${params.binName}"];
-}
-const command =
-  configuredArgs[0] === "${RUN_CONFIGURED_COMMAND_SENTINEL}" ? configuredArgs[1] : defaultCommand;
-const args =
-  configuredArgs[0] === "${RUN_CONFIGURED_COMMAND_SENTINEL}"
-    ? configuredArgs.slice(2)
-    : [...defaultArgs, ...configuredArgs];
-
-if (!command) {
-  console.error("[openclaw] missing configured ${params.displayName} ACP command");
-  process.exit(1);
-}
-
-const child = spawn(command, args, {
-  env,
-  stdio: "inherit",
-  windowsHide: true,
-});
-
-for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
-  process.once(signal, () => {
-    child.kill(signal);
-  });
-}
-
-child.on("error", (error) => {
-  console.error(\`[openclaw] failed to launch ${params.displayName} ACP wrapper: \${error.message}\`);
-  process.exit(1);
-});
-
-child.on("exit", (code, signal) => {
-  if (code !== null) {
-    process.exit(code);
-  }
-  process.exit(signal ? 1 : 0);
-});
-`;
-}
-
-function buildCodexAcpWrapperScript(installedBinPath?: string): string {
-  return buildAdapterWrapperScript({
-    displayName: "Codex",
-    packageSpec: `${CODEX_ACP_PACKAGE}@${CODEX_ACP_PACKAGE_RANGE}`,
-    binName: CODEX_ACP_BIN,
-    installedBinPath,
-    envSetup: `const codexHome = fileURLToPath(new URL("./codex-home/", import.meta.url));
-const env = {
-  ...process.env,
-  CODEX_HOME: codexHome,
-};`,
-  });
-}
-
-function buildClaudeAcpWrapperScript(installedBinPath?: string): string {
-  return buildAdapterWrapperScript({
-    displayName: "Claude",
-    // This package is patched in OpenClaw; fallback must not float to an unpatched newer release.
-    packageSpec: `${CLAUDE_ACP_PACKAGE}@${CLAUDE_ACP_PACKAGE_VERSION}`,
-    binName: CLAUDE_ACP_BIN,
-    installedBinPath,
-    envSetup: `const env = {
-  ...process.env,
-};`,
-  });
-}
-
-async function prepareIsolatedCodexHome(baseDir: string): Promise<string> {
-  const codexHome = path.join(baseDir, "codex-home");
-  await fs.mkdir(codexHome, { recursive: true });
-  await fs.writeFile(
-    path.join(codexHome, "config.toml"),
-    "# Generated by OpenClaw for Codex ACP sessions.\n",
-    "utf8",
-  );
-  return codexHome;
-}
-
-async function makeGeneratedWrapperExecutableIfPossible(wrapperPath: string): Promise<void> {
-  try {
-    await fs.chmod(wrapperPath, 0o755);
-  } catch {
-    // The wrapper is invoked via `node wrapper.mjs`; executable mode is only a convenience.
-  }
-}
-
-async function writeCodexAcpWrapper(baseDir: string, installedBinPath?: string): Promise<string> {
-  await fs.mkdir(baseDir, { recursive: true });
-  const wrapperPath = path.join(baseDir, "codex-acp-wrapper.mjs");
-  await fs.writeFile(wrapperPath, buildCodexAcpWrapperScript(installedBinPath), {
-    encoding: "utf8",
-  });
-  await makeGeneratedWrapperExecutableIfPossible(wrapperPath);
-  return wrapperPath;
-}
-
-async function writeClaudeAcpWrapper(baseDir: string, installedBinPath?: string): Promise<string> {
-  await fs.mkdir(baseDir, { recursive: true });
-  const wrapperPath = path.join(baseDir, "claude-agent-acp-wrapper.mjs");
-  await fs.writeFile(wrapperPath, buildClaudeAcpWrapperScript(installedBinPath), {
-    encoding: "utf8",
-  });
-  await makeGeneratedWrapperExecutableIfPossible(wrapperPath);
-  return wrapperPath;
-}
-
-function buildWrapperCommand(wrapperPath: string, args: string[] = []): string {
-  return [process.execPath, wrapperPath, ...args].map(quoteCommandPart).join(" ");
-}
-
-function isAcpPackageSpec(value: string, packageName: string): boolean {
-  const escapedPackageName = packageName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  return new RegExp(`^${escapedPackageName}(?:@.+)?$`, "i").test(value.trim());
-}
-
-function isAcpBinName(value: string, binName: string): boolean {
-  const commandName = basename(value);
-  const escapedBinName = binName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  return new RegExp(`^${escapedBinName}(?:\\.exe|\\.[cm]?js)?$`, "i").test(commandName);
-}
-
-function isPackageRunnerCommand(value: string): boolean {
-  return /^(?:npx|npm|pnpm|bunx)(?:\.cmd|\.exe)?$/i.test(basename(value));
-}
-
-function extractConfiguredAdapterArgs(params: {
-  configuredCommand?: string;
-  packageName: string;
-  binName: string;
-}): string[] | undefined {
-  const trimmedConfiguredCommand = params.configuredCommand?.trim();
-  if (!trimmedConfiguredCommand) {
-    return [];
-  }
-  const parts = splitCommandParts(trimmedConfiguredCommand);
-  if (!parts.length) {
-    return [];
-  }
-
-  const packageIndex = parts.findIndex((part) => isAcpPackageSpec(part, params.packageName));
-  if (packageIndex >= 0) {
-    if (!isPackageRunnerCommand(parts[0] ?? "")) {
-      return undefined;
-    }
-    const afterPackage = parts.slice(packageIndex + 1);
-    if (afterPackage[0] === "--" && isAcpBinName(afterPackage[1] ?? "", params.binName)) {
-      return afterPackage.slice(2);
-    }
-    if (isAcpBinName(afterPackage[0] ?? "", params.binName)) {
-      return afterPackage.slice(1);
-    }
-    return afterPackage[0] === "--" ? afterPackage.slice(1) : afterPackage;
-  }
-
-  if (isAcpBinName(parts[0] ?? "", params.binName)) {
-    return parts.slice(1);
-  }
-  if (basename(parts[0] ?? "") === "node" && isAcpBinName(parts[1] ?? "", params.binName)) {
-    return parts.slice(2);
-  }
-
-  return undefined;
-}
-
-function buildCodexAcpWrapperCommand(wrapperPath: string, configuredCommand?: string): string {
-  const configuredAdapterArgs = extractConfiguredAdapterArgs({
-    configuredCommand,
-    packageName: CODEX_ACP_PACKAGE,
-    binName: CODEX_ACP_BIN,
-  });
-  if (configuredAdapterArgs) {
-    return buildWrapperCommand(wrapperPath, configuredAdapterArgs);
-  }
-  return buildWrapperCommand(wrapperPath, [
-    RUN_CONFIGURED_COMMAND_SENTINEL,
-    ...splitCommandParts(configuredCommand?.trim() ?? ""),
-  ]);
-}
-
-function buildClaudeAcpWrapperCommand(wrapperPath: string, configuredCommand?: string): string {
-  const configuredAdapterArgs = extractConfiguredAdapterArgs({
-    configuredCommand,
-    packageName: CLAUDE_ACP_PACKAGE,
-    binName: CLAUDE_ACP_BIN,
-  });
-  if (configuredAdapterArgs) {
-    return buildWrapperCommand(wrapperPath, configuredAdapterArgs);
-  }
-  return configuredCommand?.trim() || buildWrapperCommand(wrapperPath);
-}
-
-export async function prepareAcpxCodexAuthConfig(params: {
-  pluginConfig: ResolvedAcpxPluginConfig;
-  stateDir: string;
-  logger?: unknown;
-  resolveInstalledCodexAcpBinPath?: () => Promise<string | undefined>;
-  resolveInstalledClaudeAcpBinPath?: () => Promise<string | undefined>;
-}): Promise<ResolvedAcpxPluginConfig> {
-  void params.logger;
-  const codexBaseDir = path.join(params.stateDir, "acpx");
-  await prepareIsolatedCodexHome(codexBaseDir);
-  const installedCodexBinPath = await (
-    params.resolveInstalledCodexAcpBinPath ?? resolveInstalledCodexAcpBinPath
-  )();
-  const installedClaudeBinPath = await (
-    params.resolveInstalledClaudeAcpBinPath ?? resolveInstalledClaudeAcpBinPath
-  )();
-  const wrapperPath = await writeCodexAcpWrapper(codexBaseDir, installedCodexBinPath);
-  const claudeWrapperPath = await writeClaudeAcpWrapper(codexBaseDir, installedClaudeBinPath);
-  const configuredCodexCommand = params.pluginConfig.agents.codex;
-  const configuredClaudeCommand = params.pluginConfig.agents.claude;
-
-  return {
-    ...params.pluginConfig,
-    agents: {
-      ...params.pluginConfig.agents,
-      codex: buildCodexAcpWrapperCommand(wrapperPath, configuredCodexCommand),
-      claude: buildClaudeAcpWrapperCommand(claudeWrapperPath, configuredClaudeCommand),
-    },
-  };
-}

package/src/config-schema.ts

@@ -1,117 +0,0 @@
-import { z } from "openclaw/plugin-sdk/zod";
-
-const ACPX_PERMISSION_MODES = ["approve-all", "approve-reads", "deny-all"] as const;
-export type AcpxPermissionMode = (typeof ACPX_PERMISSION_MODES)[number];
-
-const ACPX_NON_INTERACTIVE_POLICIES = ["deny", "fail"] as const;
-export type AcpxNonInteractivePermissionPolicy = (typeof ACPX_NON_INTERACTIVE_POLICIES)[number];
-
-export const DEFAULT_ACPX_TIMEOUT_SECONDS = 120;
-
-export type McpServerConfig = {
-  command: string;
-  args?: string[];
-  env?: Record<string, string>;
-};
-
-export type AcpxMcpServer = {
-  name: string;
-  command: string;
-  args: string[];
-  env: Array<{ name: string; value: string }>;
-};
-
-export type AcpxPluginConfig = {
-  cwd?: string;
-  stateDir?: string;
-  probeAgent?: string;
-  permissionMode?: AcpxPermissionMode;
-  nonInteractivePermissions?: AcpxNonInteractivePermissionPolicy;
-  pluginToolsMcpBridge?: boolean;
-  openClawToolsMcpBridge?: boolean;
-  strictWindowsCmdWrapper?: boolean;
-  timeoutSeconds?: number;
-  queueOwnerTtlSeconds?: number;
-  mcpServers?: Record<string, McpServerConfig>;
-  agents?: Record<string, { command: string }>;
-};
-
-export type ResolvedAcpxPluginConfig = {
-  cwd: string;
-  stateDir: string;
-  probeAgent?: string;
-  permissionMode: AcpxPermissionMode;
-  nonInteractivePermissions: AcpxNonInteractivePermissionPolicy;
-  pluginToolsMcpBridge: boolean;
-  openClawToolsMcpBridge: boolean;
-  strictWindowsCmdWrapper: boolean;
-  timeoutSeconds?: number;
-  queueOwnerTtlSeconds: number;
-  legacyCompatibilityConfig: {
-    strictWindowsCmdWrapper?: boolean;
-    queueOwnerTtlSeconds?: number;
-  };
-  mcpServers: Record<string, McpServerConfig>;
-  agents: Record<string, string>;
-};
-
-const nonEmptyTrimmedString = (message: string) =>
-  z.string({ error: message }).trim().min(1, { error: message });
-
-const McpServerConfigSchema = z.object({
-  command: nonEmptyTrimmedString("command must be a non-empty string").describe(
-    "Command to run the MCP server",
-  ),
-  args: z
-    .array(z.string({ error: "args must be an array of strings" }), {
-      error: "args must be an array of strings",
-    })
-    .optional()
-    .describe("Arguments to pass to the command"),
-  env: z
-    .record(z.string(), z.string({ error: "env values must be strings" }), {
-      error: "env must be an object of strings",
-    })
-    .optional()
-    .describe("Environment variables for the MCP server"),
-});
-
-export const AcpxPluginConfigSchema = z.strictObject({
-  cwd: nonEmptyTrimmedString("cwd must be a non-empty string").optional(),
-  stateDir: nonEmptyTrimmedString("stateDir must be a non-empty string").optional(),
-  probeAgent: nonEmptyTrimmedString("probeAgent must be a non-empty string").optional(),
-  permissionMode: z
-    .enum(ACPX_PERMISSION_MODES, {
-      error: `permissionMode must be one of: ${ACPX_PERMISSION_MODES.join(", ")}`,
-    })
-    .optional(),
-  nonInteractivePermissions: z
-    .enum(ACPX_NON_INTERACTIVE_POLICIES, {
-      error: `nonInteractivePermissions must be one of: ${ACPX_NON_INTERACTIVE_POLICIES.join(", ")}`,
-    })
-    .optional(),
-  pluginToolsMcpBridge: z.boolean({ error: "pluginToolsMcpBridge must be a boolean" }).optional(),
-  openClawToolsMcpBridge: z
-    .boolean({ error: "openClawToolsMcpBridge must be a boolean" })
-    .optional(),
-  strictWindowsCmdWrapper: z
-    .boolean({ error: "strictWindowsCmdWrapper must be a boolean" })
-    .optional(),
-  timeoutSeconds: z
-    .number({ error: "timeoutSeconds must be a number >= 0.001" })
-    .min(0.001, { error: "timeoutSeconds must be a number >= 0.001" })
-    .default(DEFAULT_ACPX_TIMEOUT_SECONDS),
-  queueOwnerTtlSeconds: z
-    .number({ error: "queueOwnerTtlSeconds must be a number >= 0" })
-    .min(0, { error: "queueOwnerTtlSeconds must be a number >= 0" })
-    .optional(),
-  mcpServers: z.record(z.string(), McpServerConfigSchema).optional(),
-  agents: z
-    .record(
-      z.string(),
-      z.strictObject({
-        command: nonEmptyTrimmedString("agents.<id>.command must be a non-empty string"),
-      }),
-    )
-    .optional(),
-});

package/src/config.test.ts

@@ -1,144 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { describe, expect, it } from "vitest";
-import { resolveAcpxPluginConfig, resolveAcpxPluginRoot } from "./config.js";
-
-describe("embedded acpx plugin config", () => {
-  it("resolves workspace stateDir and cwd by default", () => {
-    const workspaceDir = "/tmp/openclaw-acpx";
-    const resolved = resolveAcpxPluginConfig({
-      rawConfig: undefined,
-      workspaceDir,
-    });
-
-    expect(resolved.cwd).toBe(workspaceDir);
-    expect(resolved.stateDir).toBe(path.join(workspaceDir, "state"));
-    expect(resolved.permissionMode).toBe("approve-reads");
-    expect(resolved.nonInteractivePermissions).toBe("fail");
-    expect(resolved.timeoutSeconds).toBe(120);
-    expect(resolved.agents).toEqual({});
-  });
-
-  it("keeps explicit timeoutSeconds config", () => {
-    const resolved = resolveAcpxPluginConfig({
-      rawConfig: {
-        timeoutSeconds: 300,
-      },
-      workspaceDir: "/tmp/openclaw-acpx",
-    });
-
-    expect(resolved.timeoutSeconds).toBe(300);
-  });
-
-  it("keeps explicit probeAgent config", () => {
-    const resolved = resolveAcpxPluginConfig({
-      rawConfig: {
-        probeAgent: "claude",
-      },
-      workspaceDir: "/tmp/openclaw-acpx",
-    });
-
-    expect(resolved.probeAgent).toBe("claude");
-  });
-
-  it("accepts agent command overrides", () => {
-    const resolved = resolveAcpxPluginConfig({
-      rawConfig: {
-        agents: {
-          claude: { command: "claude --acp" },
-          codex: { command: "codex custom-acp" },
-        },
-      },
-      workspaceDir: "/tmp/openclaw-acpx",
-    });
-
-    expect(resolved.agents).toEqual({
-      claude: "claude --acp",
-      codex: "codex custom-acp",
-    });
-  });
-
-  it("leaves probeAgent undefined by default so the runtime picks its built-in probe agent", () => {
-    const resolved = resolveAcpxPluginConfig({
-      rawConfig: undefined,
-      workspaceDir: "/tmp/openclaw-acpx",
-    });
-
-    expect(resolved.probeAgent).toBeUndefined();
-  });
-
-  it("carries an explicit probeAgent through to the resolved plugin config, trimmed and lowercased", () => {
-    const resolved = resolveAcpxPluginConfig({
-      rawConfig: {
-        probeAgent: "  OpenCode  ",
-      },
-      workspaceDir: "/tmp/openclaw-acpx",
-    });
-
-    expect(resolved.probeAgent).toBe("opencode");
-  });
-
-  it("rejects an empty probeAgent string", () => {
-    expect(() =>
-      resolveAcpxPluginConfig({
-        rawConfig: {
-          probeAgent: "",
-        },
-        workspaceDir: "/tmp/openclaw-acpx",
-      }),
-    ).toThrow(/probeAgent must be a non-empty string/);
-  });
-
-  it("injects the built-in plugin-tools MCP server only when explicitly enabled", () => {
-    const resolved = resolveAcpxPluginConfig({
-      rawConfig: {
-        pluginToolsMcpBridge: true,
-      },
-      workspaceDir: "/tmp/openclaw-acpx",
-    });
-
-    const server = resolved.mcpServers["openclaw-plugin-tools"];
-    expect(server).toBeDefined();
-    expect(server.command).toBe(process.execPath);
-    expect(Array.isArray(server.args)).toBe(true);
-    expect(server.args?.length).toBeGreaterThan(0);
-  });
-
-  it("injects the built-in OpenClaw tools MCP server only when explicitly enabled", () => {
-    const resolved = resolveAcpxPluginConfig({
-      rawConfig: {
-        openClawToolsMcpBridge: true,
-      },
-      workspaceDir: "/tmp/openclaw-acpx",
-    });
-
-    const server = resolved.mcpServers["openclaw-tools"];
-    expect(server).toBeDefined();
-    expect(server.command).toBe(process.execPath);
-    expect(Array.isArray(server.args)).toBe(true);
-    expect(server.args?.length).toBeGreaterThan(0);
-  });
-
-  it("keeps the runtime json schema in sync with the manifest config schema", () => {
-    const pluginRoot = resolveAcpxPluginRoot();
-    const manifest = JSON.parse(
-      fs.readFileSync(path.join(pluginRoot, "openclaw.plugin.json"), "utf8"),
-    ) as { configSchema?: unknown };
-
-    expect(manifest.configSchema).toMatchObject({
-      type: "object",
-      additionalProperties: false,
-      properties: expect.objectContaining({
-        cwd: expect.any(Object),
-        stateDir: expect.any(Object),
-        probeAgent: expect.any(Object),
-        timeoutSeconds: expect.objectContaining({
-          default: 120,
-        }),
-        agents: expect.any(Object),
-        mcpServers: expect.any(Object),
-        openClawToolsMcpBridge: expect.any(Object),
-      }),
-    });
-  });
-});