@useorgx/openclaw-plugin 0.4.9 → 0.7.2

package/dist/http/helpers/autopilot-runtime.js

@@ -1,8 +1,150 @@
-import { chmodSync, createWriteStream, mkdirSync, writeFileSync, } from "node:fs";
+import { chmodSync, createWriteStream, existsSync, mkdtempSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
 import { spawn } from "node:child_process";
-import { dirname, resolve, sep } from "node:path";
+import { homedir, tmpdir } from "node:os";
+import { dirname, join, resolve, sep } from "node:path";
+import { getOrgxPluginConfigDir } from "../../paths.js";
 import { normalizeCodexArgs } from "./autopilot-slice-utils.js";
 export function createAutopilotRuntime(deps) {
+    function hasExplicitCodexSubcommand(args) {
+        const first = (args[0] ?? "").trim();
+        if (!first || first.startsWith("-"))
+            return false;
+        return true;
+    }
+    function envFlag(name, defaultValue) {
+        const raw = (process.env[name] ?? "").trim().toLowerCase();
+        if (!raw)
+            return defaultValue;
+        return !(raw === "0" || raw === "false" || raw === "no" || raw === "off");
+    }
+    function readFirstExisting(paths) {
+        for (const pathname of paths) {
+            if (!pathname)
+                continue;
+            try {
+                if (!existsSync(pathname))
+                    continue;
+                return readFileSync(pathname, "utf8");
+            }
+            catch {
+                // continue
+            }
+        }
+        return null;
+    }
+    function extractOrgxOpenclawUrl(configToml) {
+        if (!configToml)
+            return null;
+        const lines = configToml.split(/\r?\n/);
+        let inTargetSection = false;
+        for (const rawLine of lines) {
+            const line = rawLine.trim();
+            if (!line)
+                continue;
+            if (/^\[mcp_servers\.(?:"orgx-openclaw"|orgx-openclaw)\]\s*$/i.test(line)) {
+                inTargetSection = true;
+                continue;
+            }
+            if (inTargetSection && line.startsWith("[")) {
+                break;
+            }
+            if (!inTargetSection)
+                continue;
+            const urlMatch = line.match(/^url\s*=\s*("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')\s*(?:#.*)?$/i);
+            if (!urlMatch)
+                continue;
+            const token = (urlMatch[1] ?? "").trim();
+            if (token.length < 2)
+                continue;
+            const quote = token[0];
+            const unescaped = token
+                .slice(1, -1)
+                .replace(quote === '"' ? /\\"/g : /\\'/g, quote)
+                .trim();
+            const rawUrl = unescaped;
+            if (rawUrl.length > 0)
+                return rawUrl;
+        }
+        return null;
+    }
+    function prepareAutopilotCodexHome() {
+        const configuredHome = (process.env.ORGX_AUTOPILOT_CODEX_HOME ?? "").trim();
+        const preferredHome = configuredHome.length > 0
+            ? configuredHome
+            : join(getOrgxPluginConfigDir(), "codex-autopilot-home");
+        const sourceHome = (process.env.CODEX_HOME ?? "").trim() || join(homedir(), ".codex");
+        const sourceConfigCandidates = [
+            join(sourceHome, "config.toml"),
+            join(homedir(), ".codex", "config.toml"),
+            join(homedir(), ".config", "codex", "config.toml"),
+        ];
+        const mcpModeRaw = (process.env.ORGX_AUTOPILOT_CODEX_MCP_MODE ?? "").trim().toLowerCase();
+        const mcpMode = mcpModeRaw.length > 0 ? mcpModeRaw : "orgx-openclaw";
+        const sourceConfig = readFirstExisting(sourceConfigCandidates);
+        const extractedOrgxOpenclawUrl = extractOrgxOpenclawUrl(sourceConfig);
+        const defaultOrgxOpenclawUrl = (process.env.ORGX_AUTOPILOT_ORGX_MCP_URL ?? "").trim() ||
+            extractedOrgxOpenclawUrl ||
+            "http://127.0.0.1:18789/orgx/mcp";
+        const configLines = [
+            "# Autogenerated by OrgX autopilot runtime. This isolates codex slices",
+            "# from broken or noisy global MCP entries in ~/.codex/config.toml.",
+            "",
+        ];
+        if (mcpMode === "none") {
+            configLines.push("mcp_servers = {}", "");
+        }
+        else {
+            configLines.push('[mcp_servers."orgx-openclaw"]', `url = ${JSON.stringify(defaultOrgxOpenclawUrl)}`, "");
+        }
+        const writeAutopilotHome = (targetHome) => {
+            try {
+                mkdirSync(targetHome, { recursive: true, mode: 0o700 });
+                try {
+                    chmodSync(targetHome, 0o700);
+                }
+                catch {
+                    // best effort
+                }
+            }
+            catch {
+                return false;
+            }
+            const sourceAuthPath = join(sourceHome, "auth.json");
+            const targetAuthPath = join(targetHome, "auth.json");
+            try {
+                if (existsSync(sourceAuthPath)) {
+                    const authRaw = readFileSync(sourceAuthPath, "utf8");
+                    writeFileSync(targetAuthPath, authRaw, { encoding: "utf8", mode: 0o600 });
+                }
+            }
+            catch {
+                // best effort
+            }
+            try {
+                writeFileSync(join(targetHome, "config.toml"), `${configLines.join("\n")}\n`, {
+                    encoding: "utf8",
+                    mode: 0o600,
+                });
+            }
+            catch {
+                return false;
+            }
+            return true;
+        };
+        if (writeAutopilotHome(preferredHome))
+            return preferredHome;
+        // Hard fallback: use an ephemeral isolated CODEX_HOME so slices do not
+        // inherit potentially broken global MCP config.
+        try {
+            const fallbackHome = mkdtempSync(join(tmpdir(), "orgx-autopilot-codex-home-"));
+            if (writeAutopilotHome(fallbackHome))
+                return fallbackHome;
+        }
+        catch {
+            // best effort
+        }
+        return null;
+    }
     function ensurePrivateDirForFile(pathname) {
         const dir = dirname(pathname);
         mkdirSync(dir, { recursive: true, mode: 0o700 });
@@ -13,14 +155,49 @@ export function createAutopilotRuntime(deps) {
             // best effort
         }
     }
+    function createSafeAppendStream(pathname) {
+        const stream = createWriteStream(pathname, { flags: "a" });
+        stream.on("error", () => {
+            // Best-effort logging only.
+        });
+        return stream;
+    }
+    function hasSliceOutput(pathname) {
+        try {
+            if (!existsSync(pathname))
+                return false;
+            const raw = readFileSync(pathname, "utf8");
+            return raw.trim().length > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    function writeFallbackSliceOutput(input) {
+        if (hasSliceOutput(input.outputPath))
+            return false;
+        try {
+            writeFileSync(input.outputPath, `${JSON.stringify({
+                status: "error",
+                summary: `Worker exited without structured output (${input.reason}; code=${String(input.code)}, signal=${String(input.signal)}).`,
+                workstream_id: input.workstreamId ?? "unknown",
+                workstream_title: input.workstreamTitle ?? null,
+                slice_id: input.runId,
+            }, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     function spawnCodexSliceWorker(input) {
         ensurePrivateDirForFile(input.logPath);
         ensurePrivateDirForFile(input.outputPath);
         const workerKind = (process.env.ORGX_AUTOPILOT_WORKER_KIND ?? "").trim().toLowerCase();
         if (workerKind === "mock") {
             const scriptPath = resolve(dirname(deps.filename), "..", "..", "scripts", "mock-autopilot-slice-worker.mjs");
-            const logStream = createWriteStream(input.logPath, { flags: "a" });
-            const outStream = createWriteStream(input.outputPath, { flags: "a" });
+            const logStream = createSafeAppendStream(input.logPath);
+            const outStream = createSafeAppendStream(input.outputPath);
             logStream.write(`\n==== ${new Date().toISOString()} :: mock slice ${input.runId} ====\n`);
             const child = spawn("node", [scriptPath], {
                 cwd: input.cwd,
@@ -64,7 +241,19 @@ export function createAutopilotRuntime(deps) {
             child.on("close", (code, signal) => {
                 deps.autoContinueSliceChildren.delete(input.runId);
                 const stamp = new Date().toISOString();
+                const wroteFallback = writeFallbackSliceOutput({
+                    outputPath: input.outputPath,
+                    runId: input.runId,
+                    workstreamId: input.env.ORGX_WORKSTREAM_ID,
+                    workstreamTitle: input.env.ORGX_WORKSTREAM_TITLE,
+                    code,
+                    signal,
+                    reason: "mock worker close",
+                });
                 try {
+                    if (wroteFallback) {
+                        logStream.write(`fallback output synthesized at ${input.outputPath}\n`);
+                    }
                     logStream.write(`\n==== ${stamp} :: exit code=${String(code)} signal=${String(signal)} ====\n`);
                 }
                 catch {
@@ -108,21 +297,91 @@ export function createAutopilotRuntime(deps) {
             return { pid: child.pid ?? null };
         }
         if (workerKind === "claude-code" || workerKind === "claude_code") {
+            const hasArgFlag = (args, flag) => args.includes(flag) || args.some((arg) => typeof arg === "string" && arg.startsWith(`${flag}=`));
+            const readArgValue = (args, flag) => {
+                const inline = args.find((arg) => typeof arg === "string" && arg.startsWith(`${flag}=`));
+                if (inline)
+                    return inline.slice(flag.length + 1).trim() || null;
+                const index = args.indexOf(flag);
+                const next = index >= 0 ? args[index + 1] : null;
+                return typeof next === "string" && next.trim().length > 0 ? next.trim() : null;
+            };
             const claudeBin = (process.env.ORGX_CLAUDE_CODE_BIN ?? "").trim() || "claude";
             const rawArgs = (process.env.ORGX_CLAUDE_CODE_ARGS ?? "").trim();
             const args = rawArgs.length > 0 ? rawArgs.split(/\s+/).filter(Boolean) : [];
-            const logStream = createWriteStream(input.logPath, { flags: "a" });
-            const outStream = createWriteStream(input.outputPath, { flags: "a" });
+            const hasPrint = hasArgFlag(args, "--print") || args.includes("-p");
+            const hasOutputFormat = hasArgFlag(args, "--output-format");
+            const hasJsonSchema = hasArgFlag(args, "--json-schema");
+            const hasNoSessionPersistence = hasArgFlag(args, "--no-session-persistence");
+            const hasPermissionMode = hasArgFlag(args, "--permission-mode");
+            const hasDangerousSkipPermissions = hasArgFlag(args, "--dangerously-skip-permissions");
+            const hasAllowDangerousSkipPermissions = hasArgFlag(args, "--allow-dangerously-skip-permissions");
+            const explicitOutputFormat = readArgValue(args, "--output-format");
+            const explicitJsonSchemaArg = readArgValue(args, "--json-schema");
+            const explicitPermissionMode = readArgValue(args, "--permission-mode");
+            let schemaArg = null;
+            if (input.outputSchemaPath && !hasJsonSchema) {
+                try {
+                    const schemaRaw = readFileSync(input.outputSchemaPath, "utf8").trim();
+                    if (schemaRaw.length > 0)
+                        schemaArg = schemaRaw;
+                }
+                catch {
+                    schemaArg = null;
+                }
+            }
+            const claudeExtraArgs = [];
+            if (!hasPrint)
+                claudeExtraArgs.push("--print");
+            if (!hasOutputFormat)
+                claudeExtraArgs.push("--output-format", "json");
+            if (!hasNoSessionPersistence)
+                claudeExtraArgs.push("--no-session-persistence");
+            if (!hasPermissionMode)
+                claudeExtraArgs.push("--permission-mode", "bypassPermissions");
+            if (!hasDangerousSkipPermissions && !hasAllowDangerousSkipPermissions) {
+                claudeExtraArgs.push("--dangerously-skip-permissions");
+            }
+            if (schemaArg)
+                claudeExtraArgs.push("--json-schema", schemaArg);
+            const logStream = createSafeAppendStream(input.logPath);
+            const outStream = createSafeAppendStream(input.outputPath);
             logStream.write(`\n==== ${new Date().toISOString()} :: claude slice ${input.runId} ====\n`);
-            // Claude Code invocation is environment-specific; ORGX_CLAUDE_CODE_ARGS should be set to
-            // a headless-compatible command shape. We pass the prompt as the final argument.
-            const child = spawn(claudeBin, [...args, input.prompt], {
+            logStream.write(`claude_bin: ${claudeBin}\n`);
+            if (claudeExtraArgs.length > 0) {
+                const claudeArgsForLog = claudeExtraArgs.map((arg) => {
+                    if (schemaArg && arg === schemaArg)
+                        return "<json-schema>";
+                    return arg.length > 160 ? `${arg.slice(0, 157)}...` : arg;
+                });
+                logStream.write(`claude_args_injected: ${claudeArgsForLog.join(" ")}\n`);
+            }
+            if (schemaArg && input.outputSchemaPath) {
+                logStream.write(`claude_json_schema: ${input.outputSchemaPath}\n`);
+            }
+            else if (hasJsonSchema) {
+                logStream.write(`claude_json_schema: ${explicitJsonSchemaArg ?? "provided-via-args"}\n`);
+            }
+            else if (input.outputSchemaPath && !hasJsonSchema) {
+                logStream.write(`claude_json_schema: unavailable (${input.outputSchemaPath})\n`);
+            }
+            logStream.write(`claude_output_format: ${hasOutputFormat ? explicitOutputFormat ?? "provided" : "json"}\n`);
+            logStream.write(`claude_permission_mode: ${hasPermissionMode ? explicitPermissionMode ?? "provided" : "bypassPermissions"}\n`);
+            logStream.write(`claude_skip_permissions: ${hasDangerousSkipPermissions || hasAllowDangerousSkipPermissions ? "provided" : "dangerously-skip-permissions"}\n`);
+            const childEnv = {
+                ...process.env,
+                ...deps.resolveByokEnvOverrides(),
+                ...input.env,
+            };
+            if (claudeBin.includes(sep)) {
+                const binDir = dirname(claudeBin);
+                childEnv.PATH = childEnv.PATH ? `${binDir}:${childEnv.PATH}` : binDir;
+            }
+            // Force non-interactive structured output by default for parity with codex output-schema mode.
+            // If callers already pass explicit print/output/schema flags, we preserve their args unchanged.
+            const child = spawn(claudeBin, [...args, ...claudeExtraArgs, input.prompt], {
                 cwd: input.cwd,
-                env: {
-                    ...process.env,
-                    ...deps.resolveByokEnvOverrides(),
-                    ...input.env,
-                },
+                env: childEnv,
                 stdio: ["ignore", "pipe", "pipe"],
                 detached: true,
             });
@@ -152,7 +411,19 @@ export function createAutopilotRuntime(deps) {
             child.on("close", (code, signal) => {
                 deps.autoContinueSliceChildren.delete(input.runId);
                 const stamp = new Date().toISOString();
+                const wroteFallback = writeFallbackSliceOutput({
+                    outputPath: input.outputPath,
+                    runId: input.runId,
+                    workstreamId: input.env.ORGX_WORKSTREAM_ID,
+                    workstreamTitle: input.env.ORGX_WORKSTREAM_TITLE,
+                    code,
+                    signal,
+                    reason: "claude worker close",
+                });
                 try {
+                    if (wroteFallback) {
+                        logStream.write(`fallback output synthesized at ${input.outputPath}\n`);
+                    }
                     logStream.write(`\n==== ${stamp} :: exit code=${String(code)} signal=${String(signal)} ====\n`);
                 }
                 catch {
@@ -199,17 +470,14 @@ export function createAutopilotRuntime(deps) {
         const codexInfo = deps.resolveCodexBinInfo();
         const codexBin = codexInfo.bin;
         const rawArgs = (process.env.ORGX_CODEX_ARGS ?? "").trim();
-        const args = normalizeCodexArgs(rawArgs.length > 0 ? rawArgs.split(/\s+/).filter(Boolean) : ["--full-auto"]);
-        // Autopilot slices should not fail just because an unrelated MCP server is flaky.
-        // Default: disable firecrawl unless explicitly re-enabled.
-        const disableFirecrawlRaw = (process.env.ORGX_AUTOPILOT_DISABLE_FIRECRAWL ?? "").trim().toLowerCase();
-        const disableFirecrawl = disableFirecrawlRaw !== "false" && disableFirecrawlRaw !== "0" && disableFirecrawlRaw !== "no";
-        const hasFirecrawlOverride = args.some((arg) => String(arg).includes("mcp_servers.firecrawl"));
+        const normalizedArgs = normalizeCodexArgs(rawArgs.length > 0
+            ? rawArgs.split(/\s+/).filter(Boolean)
+            : ["exec", "--ephemeral", "--full-auto", "--skip-git-repo-check"]);
+        const args = hasExplicitCodexSubcommand(normalizedArgs)
+            ? normalizedArgs
+            : ["exec", ...normalizedArgs];
         const extraArgs = [];
-        if (disableFirecrawl && !hasFirecrawlOverride) {
-            extraArgs.push("-c", "mcp_servers.firecrawl.enabled=false");
-        }
-        const logStream = createWriteStream(input.logPath, { flags: "a" });
+        const logStream = createSafeAppendStream(input.logPath);
         logStream.write(`\n==== ${new Date().toISOString()} :: slice ${input.runId} ====\n`);
         logStream.write(`codex_bin: ${codexBin}${codexInfo.versionString ? ` (${codexInfo.versionString})` : ""}\n`);
         const childEnv = {
@@ -217,6 +485,21 @@ export function createAutopilotRuntime(deps) {
             ...deps.resolveByokEnvOverrides(),
             ...input.env,
         };
+        const shouldIsolateCodexHome = envFlag("ORGX_AUTOPILOT_ISOLATE_CODEX_HOME", true);
+        const autopilotCodexHome = prepareAutopilotCodexHome();
+        if (autopilotCodexHome) {
+            childEnv.CODEX_HOME = autopilotCodexHome;
+            logStream.write(shouldIsolateCodexHome
+                ? `codex_home: ${autopilotCodexHome}\n`
+                : `codex_home: ${autopilotCodexHome} (forced-safe override while ORGX_AUTOPILOT_ISOLATE_CODEX_HOME=false)\n`);
+        }
+        else if (shouldIsolateCodexHome) {
+            delete childEnv.CODEX_HOME;
+            logStream.write("codex_home: isolation unavailable (default lookup)\n");
+        }
+        else {
+            logStream.write("codex_home: forced-safe override unavailable (inheriting global CODEX_HOME)\n");
+        }
         if (codexBin.includes(sep)) {
             const binDir = dirname(codexBin);
             childEnv.PATH = childEnv.PATH ? `${binDir}:${childEnv.PATH}` : binDir;
@@ -226,7 +509,15 @@ export function createAutopilotRuntime(deps) {
         const outputArgs = hasOutputLastMessage
             ? []
             : ["--output-last-message", input.outputPath];
-        const child = spawn(codexBin, [...args, ...extraArgs, ...outputArgs, input.prompt], {
+        const hasOutputSchema = args.includes("--output-schema") ||
+            args.some((arg) => typeof arg === "string" && arg.startsWith("--output-schema="));
+        const outputSchemaArgs = input.outputSchemaPath && !hasOutputSchema
+            ? ["--output-schema", input.outputSchemaPath]
+            : [];
+        if (outputSchemaArgs.length > 0) {
+            logStream.write(`output_schema: ${input.outputSchemaPath}\n`);
+        }
+        const child = spawn(codexBin, [...args, ...extraArgs, ...outputArgs, ...outputSchemaArgs, input.prompt], {
             cwd: input.cwd,
             env: childEnv,
             stdio: ["ignore", "pipe", "pipe"],
@@ -252,7 +543,19 @@ export function createAutopilotRuntime(deps) {
         child.on("close", (code, signal) => {
             deps.autoContinueSliceChildren.delete(input.runId);
             const stamp = new Date().toISOString();
+            const wroteFallback = writeFallbackSliceOutput({
+                outputPath: input.outputPath,
+                runId: input.runId,
+                workstreamId: input.env.ORGX_WORKSTREAM_ID,
+                workstreamTitle: input.env.ORGX_WORKSTREAM_TITLE,
+                code,
+                signal,
+                reason: "codex worker close",
+            });
             try {
+                if (wroteFallback) {
+                    logStream.write(`fallback output synthesized at ${input.outputPath}\n`);
+                }
                 logStream.write(`\n==== ${stamp} :: exit code=${String(code)} signal=${String(signal)} ====\n`);
             }
             catch {

package/dist/http/helpers/autopilot-slice-utils.d.ts

@@ -13,6 +13,11 @@ export declare function createCodexBinResolver(): {
     resolveCodexBinInfo: () => CodexBinInfo;
     getCachedCodexProbeSummary: () => string | null;
 };
+export declare function buildSliceOutputInstructions(input: {
+    runId: string;
+    schemaPath: string;
+    requiredSkills: string[];
+}): string;
 export declare function buildWorkstreamSlicePrompt(input: {
     initiativeTitle: string;
     initiativeId: string;
@@ -33,6 +38,19 @@ export declare function buildWorkstreamSlicePrompt(input: {
         domain: string;
         requiredSkills: string[];
     };
+    behaviorConfig?: {
+        configId?: string | null;
+        version?: string | null;
+        hash?: string | null;
+        policySource?: string | null;
+        context?: string | null;
+    } | null;
     runId: string;
     schemaPath: string;
 }): string;
+export type BuildScopeDirectiveScope = "task" | "milestone" | "workstream";
+export declare function buildScopeDirective(scope: BuildScopeDirectiveScope, meta: {
+    milestoneTitles?: string[];
+    workstreamTitle?: string;
+    taskCount: number;
+}): string;