codex-toys 0.135.0

package/dist/cli/turn-automation.js

@@ -0,0 +1,718 @@
+import { spawn } from "node:child_process";
+import { readdir, readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseJsonText } from "./json.js";
+const MODULE_RESULT_PREFIX = "TURN_AUTOMATION_MODULE_RESULT ";
+const DEFAULT_TURN_WAIT_TIMEOUT_MS = 30 * 60 * 1000;
+const DEFAULT_TURN_WAIT_POLL_INTERVAL_MS = 1000;
+export async function runTurnAutomationScript(options) {
+    const scriptPath = path.resolve(options.scriptPath);
+    const context = turnAutomationContext({ ...options, scriptPath });
+    const command = nodeCommandPath(scriptPath);
+    const subprocess = spawn(command[0] ?? process.execPath, command.slice(1), {
+        cwd: options.automation?.root ?? process.cwd(),
+        env: {
+            ...process.env,
+            ...options.env,
+        },
+        stdio: ["ignore", "pipe", "pipe", "ipc"],
+    });
+    subprocess.on("message", (message) => {
+        void handleHostMessage(subprocess, options.host, message);
+    });
+    await sendChildMessage(subprocess, {
+        type: "turnAutomation.context",
+        context,
+    });
+    const timer = setTimeout(() => subprocess.kill("SIGTERM"), options.timeoutMs);
+    const [stdout, stderr, exitCode] = await Promise.all([
+        collectText(subprocess.stdout),
+        collectText(subprocess.stderr),
+        exitCodeFor(subprocess),
+    ]).finally(() => clearTimeout(timer));
+    if (exitCode !== 0) {
+        throw new Error(`Turn automation script failed:\n${stderr || stdout}`);
+    }
+    const parsed = parseTurnAutomationResult(stdout);
+    return {
+        context,
+        ...parsed,
+        stdout,
+        stderr,
+    };
+}
+export function parseTurnAutomationResult(stdout) {
+    return normalizeTurnAutomationResult(parseModuleResult(stdout));
+}
+export function formatTurnAutomationRun(run) {
+    return [
+        "automation action   result",
+        `result              ${previewJson(run.result)}`,
+        run.turn ? `turn surface        ${run.turn.via}` : undefined,
+        run.turn ? `thread id           ${run.turn.threadId}` : undefined,
+        run.turn ? `turn id             ${run.turn.turnId}` : undefined,
+    ].filter(Boolean).join("\n") + "\n";
+}
+export function createTurnAutomationHost(options) {
+    return async (call) => {
+        if (call.method === "app.call") {
+            const params = record(call.params);
+            return await options.appRequest(requiredString(params.method, "ctx.app.call method"), params.params);
+        }
+        if (call.method === "workspace.call") {
+            if (!options.workspaceRequest) {
+                throw new Error("ctx.workspace.call is only available through a codex-toys toybox");
+            }
+            const params = record(call.params);
+            return await options.workspaceRequest(requiredString(params.method, "ctx.workspace.call method"), params.params);
+        }
+        if (call.method === "delegate.list") {
+            return await workspaceHostRequest(options, "delegation.list", call.params ?? {});
+        }
+        if (call.method === "delegate.start") {
+            const params = delegationStartParamsFromHostParams(record(call.params), options.defaults);
+            const started = await workspaceHostRequest(options, "delegation.start", params);
+            return compactUndefined({
+                id: optionalString(record(call.params).id),
+                delegation: started.delegation,
+                turnId: started.turnId,
+            });
+        }
+        if (call.method === "delegate.send") {
+            return await workspaceHostRequest(options, "delegation.send", call.params ?? {});
+        }
+        if (call.method === "delegate.read") {
+            return await readAutomationDelegationWithRequest(options, delegationRefFromValue(call.params, "ctx.delegate.read"));
+        }
+        if (call.method === "delegate.wait") {
+            const params = record(call.params);
+            return await waitAutomationDelegationWithRequest(options, delegationRefFromValue(params.delegation ?? call.params, "ctx.delegate.wait"), waitOptionsFromValue(params.options));
+        }
+        if (call.method === "turn.start") {
+            const params = record(call.params);
+            const turn = turnStartParamsFromHostParams(params, options.defaults);
+            return await startAutomationTurnWithRequest(options.via, turn, options.appRequest, optionalString(params.id));
+        }
+        if (call.method === "turn.read") {
+            return await readAutomationTurnWithRequest(options.via, options.appRequest, turnRefFromValue(call.params, "ctx.turn.read"));
+        }
+        if (call.method === "turn.wait") {
+            const params = record(call.params);
+            return await waitAutomationTurnWithRequest(options.via, options.appRequest, turnRefFromValue(params.turn ?? call.params, "ctx.turn.wait"), waitOptionsFromValue(params.options));
+        }
+        if (call.method === "turn.waitAll") {
+            const params = record(call.params);
+            if (!Array.isArray(params.turns)) {
+                throw new Error("ctx.turn.waitAll requires an array of turns");
+            }
+            const waitOptions = waitOptionsFromValue(params.options);
+            return await Promise.all(params.turns.map(async (entry) => await waitAutomationTurnWithRequest(options.via, options.appRequest, turnRefFromValue(entry, "ctx.turn.waitAll"), waitOptions)));
+        }
+        throw new Error(`Unknown turn automation host method: ${call.method}`);
+    };
+}
+async function workspaceHostRequest(options, method, params) {
+    if (!options.workspaceRequest) {
+        throw new Error("context.delegate is only available through a codex-toys toybox");
+    }
+    return await options.workspaceRequest(method, params);
+}
+export async function startAutomationTurnWithRequest(via, turn, request, id) {
+    validateTurnPermissionOptions(turn);
+    let threadId = turn.threadId;
+    let thread = null;
+    const existingThread = Boolean(threadId);
+    if (!threadId) {
+        const threadResponse = await request("thread/start", threadStartParamsFromAutomation(turn));
+        threadId = nestedId(threadResponse, "thread", "thread/start");
+        thread = record(threadResponse).thread ?? threadResponse;
+    }
+    const turnResponse = await request("turn/start", turnStartParamsFromAutomation(threadId, turn, {
+        includeSandboxPolicy: existingThread,
+    }));
+    return compactUndefined({
+        id,
+        via,
+        threadId,
+        turnId: nestedId(turnResponse, "turn", "turn/start"),
+        thread,
+        turn: record(turnResponse).turn ?? turnResponse,
+    });
+}
+export async function readAutomationTurnWithRequest(via, request, ref) {
+    const threadResponse = await request("thread/read", {
+        threadId: ref.threadId,
+        includeTurns: true,
+    });
+    const thread = record(threadResponse).thread ?? threadResponse;
+    const turn = array(record(thread).turns)
+        .map(record)
+        .find((candidate) => candidate.id === ref.turnId);
+    if (!turn) {
+        throw new Error(`thread/read did not return turn ${ref.turnId}`);
+    }
+    return compactUndefined({
+        id: ref.id,
+        via,
+        threadId: ref.threadId,
+        turnId: ref.turnId,
+        status: optionalString(turn.status) ?? "unknown",
+        outputText: finalTextFromTurn(turn),
+        error: turn.error,
+        thread,
+        turn,
+    });
+}
+export async function waitAutomationTurnWithRequest(via, request, ref, options = {}) {
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TURN_WAIT_TIMEOUT_MS;
+    const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_TURN_WAIT_POLL_INTERVAL_MS;
+    const startedAt = Date.now();
+    while (true) {
+        const snapshot = await readAutomationTurnWithRequest(via, request, ref);
+        if (snapshot.status !== "inProgress") {
+            if (snapshot.status === "failed" &&
+                options.throwOnFailure !== false) {
+                throw new Error(`Turn ${ref.turnId} failed`);
+            }
+            return snapshot;
+        }
+        if (Date.now() - startedAt >= timeoutMs) {
+            throw new Error(`Timed out waiting for turn ${ref.turnId}`);
+        }
+        await delay(Math.min(pollIntervalMs, Math.max(0, timeoutMs - (Date.now() - startedAt))));
+    }
+}
+export async function readAutomationDelegationWithRequest(options, ref) {
+    const response = await workspaceHostRequest(options, "delegation.read", ref);
+    return compactUndefined({
+        id: optionalString(ref.id),
+        delegation: response.delegation,
+        turnId: response.delegation.lastTurnId,
+        status: response.delegation.status,
+        latestTurnId: response.latestTurnId,
+        latestStatus: response.latestStatus,
+        outputText: response.lastFinal?.text ?? response.delegation.lastFinal ?? "",
+        error: response.delegation.status === "failed"
+            ? response.delegation.lastStatus
+            : undefined,
+    });
+}
+export async function waitAutomationDelegationWithRequest(options, ref, waitOptions = {}) {
+    const timeoutMs = waitOptions.timeoutMs ?? DEFAULT_TURN_WAIT_TIMEOUT_MS;
+    const pollIntervalMs = waitOptions.pollIntervalMs ?? DEFAULT_TURN_WAIT_POLL_INTERVAL_MS;
+    const startedAt = Date.now();
+    while (true) {
+        const snapshot = await readAutomationDelegationWithRequest(options, ref);
+        if (snapshot.status !== "active" && snapshot.status !== "idle") {
+            if (snapshot.status === "failed" && waitOptions.throwOnFailure !== false) {
+                throw new Error(`Delegation ${snapshot.delegation.id} failed`);
+            }
+            return snapshot;
+        }
+        if (Date.now() - startedAt >= timeoutMs) {
+            throw new Error(`Timed out waiting for delegation ${optionalString(ref.delegationId) ?? optionalString(ref.id) ?? optionalString(ref.threadId) ?? "unknown"}`);
+        }
+        await delay(Math.min(pollIntervalMs, Math.max(0, timeoutMs - (Date.now() - startedAt))));
+    }
+}
+export async function listTurnAutomations(options = {}) {
+    const cwd = path.resolve(options.cwd ?? process.cwd());
+    const roots = options.roots?.map((root) => path.resolve(cwd, root)) ??
+        [
+            path.join(cwd, ".codex", "automations"),
+            path.join(cwd, "automations"),
+        ];
+    const loaded = [];
+    const seen = new Set();
+    for (const root of roots) {
+        for (const manifestPath of await automationManifestPaths(root)) {
+            const automation = await loadTurnAutomationManifest(manifestPath, cwd);
+            if (seen.has(automation.name)) {
+                continue;
+            }
+            seen.add(automation.name);
+            loaded.push(automation);
+        }
+    }
+    return loaded.sort((left, right) => left.name.localeCompare(right.name));
+}
+export async function resolveTurnAutomationTarget(target, options = {}) {
+    const cwd = path.resolve(options.cwd ?? process.cwd());
+    if (target.includes("/") || target.includes("\\") || target.endsWith(".ts") || target.endsWith(".js")) {
+        throw new Error(`Turn automation target must be a named automation, got ${JSON.stringify(target)}`);
+    }
+    const automations = await listTurnAutomations({ ...options, cwd });
+    const automation = automations.find((entry) => entry.name === target);
+    if (!automation) {
+        throw new Error(`No turn automation named ${JSON.stringify(target)} was found`);
+    }
+    return targetFromAutomation(automation);
+}
+export function formatTurnAutomationList(automations) {
+    if (automations.length === 0) {
+        return "No turn automations found.\n";
+    }
+    return automations.map((automation) => {
+        const description = automation.manifest.description
+            ? ` - ${automation.manifest.description}`
+            : "";
+        return `${automation.name}${description}`;
+    }).join("\n") + "\n";
+}
+function turnAutomationContext(options) {
+    return compactUndefined({
+        automation: {
+            scriptPath: options.scriptPath,
+            name: options.automation?.name,
+            manifestPath: options.automation?.manifestPath,
+            config: options.automation?.manifest.config,
+        },
+        runtime: {
+            startedAt: new Date().toISOString(),
+        },
+        event: options.event,
+        prompt: options.prompt,
+        cwd: options.cwd,
+        workspaceRoot: options.automation?.workspaceRoot,
+    });
+}
+async function automationManifestPaths(root) {
+    if (!await isDirectory(root)) {
+        return [];
+    }
+    const entries = await readdir(root, { withFileTypes: true });
+    const manifests = [];
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            const manifestPath = path.join(root, entry.name, "automation.json");
+            if (await isFile(manifestPath)) {
+                manifests.push(manifestPath);
+            }
+        }
+    }
+    return manifests.sort();
+}
+async function loadTurnAutomationManifest(manifestPath, workspaceRoot) {
+    const root = path.dirname(manifestPath);
+    const resolvedWorkspaceRoot = path.resolve(workspaceRoot);
+    const parsed = parseJsonText(await readFile(manifestPath, "utf8"), manifestPath);
+    if (!isRecord(parsed)) {
+        throw new Error(`Turn automation manifest must be an object: ${manifestPath}`);
+    }
+    const script = optionalString(parsed.script);
+    if (!script) {
+        throw new Error(`Turn automation manifest requires script: ${manifestPath}`);
+    }
+    const name = optionalString(parsed.name) ?? path.basename(root);
+    const manifest = compactUndefined({
+        name,
+        description: optionalString(parsed.description),
+        script,
+        prompt: optionalString(parsed.prompt),
+        promptFile: optionalString(parsed.promptFile),
+        cwd: optionalString(parsed.cwd),
+        skills: stringArray(parsed.skills),
+        config: recordOrUndefined(parsed.config),
+    });
+    const prompt = manifest.promptFile
+        ? await readFile(path.resolve(root, manifest.promptFile), "utf8")
+        : manifest.prompt;
+    return compactUndefined({
+        name,
+        root,
+        workspaceRoot: resolvedWorkspaceRoot,
+        manifestPath,
+        manifest,
+        scriptPath: path.resolve(root, script),
+        prompt,
+        cwd: manifest.cwd ? resolveAutomationPath({
+            automationRoot: root,
+            workspaceRoot: resolvedWorkspaceRoot,
+            value: manifest.cwd,
+            label: "cwd",
+        }) : undefined,
+        skills: manifest.skills,
+    });
+}
+function targetFromAutomation(automation) {
+    return compactUndefined({
+        scriptPath: automation.scriptPath,
+        automation,
+        prompt: automation.prompt,
+        cwd: automation.cwd,
+        skills: automation.skills,
+    });
+}
+async function isFile(filePath) {
+    try {
+        return (await stat(filePath)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function isDirectory(filePath) {
+    try {
+        return (await stat(filePath)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function resolveAutomationPath(options) {
+    const { automationRoot, workspaceRoot, value, label } = options;
+    if (value === "@") {
+        return workspaceRoot;
+    }
+    if (value.startsWith("@/") || value.startsWith("@\\")) {
+        const resolved = path.resolve(workspaceRoot, value.slice(2));
+        if (!isPathInsideOrEqual(workspaceRoot, resolved)) {
+            throw new Error(`Turn automation manifest ${label} must stay inside workspace root when using @/: ${value}`);
+        }
+        return resolved;
+    }
+    return path.isAbsolute(value) ? value : path.resolve(automationRoot, value);
+}
+function isPathInsideOrEqual(parent, child) {
+    const relative = path.relative(parent, child);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+function parseModuleResult(stdout) {
+    for (const line of stdout.split(/\r?\n/).reverse()) {
+        const index = line.indexOf(MODULE_RESULT_PREFIX);
+        if (index === -1) {
+            continue;
+        }
+        return parseJsonText(line.slice(index + MODULE_RESULT_PREFIX.length).trim(), "turn automation module result");
+    }
+    throw new Error("Turn automation module did not return a result");
+}
+function normalizeTurnAutomationResult(value) {
+    if (!isRecord(value)) {
+        throw new Error("Turn automation result must be a JSON object");
+    }
+    return { result: value };
+}
+function turnStartParamsFromHostParams(params, defaults = {}) {
+    const prompt = optionalString(params.prompt) ?? defaults.prompt;
+    if (!prompt) {
+        throw new Error("ctx.turn.start requires a prompt or automation prompt default");
+    }
+    return compactUndefined({
+        prompt,
+        threadId: optionalString(params.threadId),
+        cwd: optionalString(params.cwd) ?? defaults.cwd,
+        model: optionalString(params.model) ?? defaults.model,
+        serviceTier: optionalString(params.serviceTier),
+        sandbox: sandboxModeValue(params.sandbox) ?? defaults.sandbox,
+        approvalPolicy: approvalPolicyValue(params.approvalPolicy) ??
+            defaults.approvalPolicy,
+        permissions: optionalString(params.permissions) ?? defaults.permissions,
+        responsesapiClientMetadata: stringRecord(params.responsesapiClientMetadata),
+        outputSchema: params.outputSchema,
+        skills: stringArray(params.skills) ?? defaults.skills,
+    });
+}
+function delegationStartParamsFromHostParams(params, defaults = {}) {
+    const prompt = optionalString(params.prompt) ?? defaults.prompt;
+    return compactUndefined({
+        id: optionalString(params.id),
+        cwd: requiredString(params.cwd ?? defaults.cwd, "ctx.delegate.start cwd"),
+        prompt,
+        title: optionalString(params.title),
+        groupId: optionalString(params.groupId),
+        returnMode: optionalString(params.returnMode),
+        allowAbsoluteCwd: optionalBoolean(params.allowAbsoluteCwd),
+        model: optionalString(params.model) ?? defaults.model,
+        serviceTier: optionalString(params.serviceTier),
+        sandbox: sandboxModeValue(params.sandbox) ?? defaults.sandbox,
+        approvalPolicy: approvalPolicyValue(params.approvalPolicy) ??
+            defaults.approvalPolicy,
+        permissions: optionalString(params.permissions) ?? defaults.permissions,
+    });
+}
+function delegationRefFromValue(value, label) {
+    const params = record(value);
+    const delegation = record(params.delegation);
+    const id = optionalString(params.delegationId) ??
+        optionalString(params.id) ??
+        optionalString(delegation.id);
+    const threadId = optionalString(params.threadId) ??
+        optionalString(delegation.codexThreadId);
+    if (!id && !threadId) {
+        throw new Error(`${label} requires delegationId, id, or threadId`);
+    }
+    return compactUndefined({
+        id: optionalString(params.id),
+        delegationId: id,
+        threadId,
+    });
+}
+function turnRefFromValue(value, label) {
+    const params = record(value);
+    return compactUndefined({
+        id: optionalString(params.id),
+        threadId: requiredString(params.threadId, `${label} threadId`),
+        turnId: requiredString(params.turnId, `${label} turnId`),
+    });
+}
+function waitOptionsFromValue(value) {
+    const params = record(value);
+    return compactUndefined({
+        timeoutMs: optionalNumber(params.timeoutMs),
+        pollIntervalMs: optionalNumber(params.pollIntervalMs),
+        throwOnFailure: optionalBoolean(params.throwOnFailure),
+    });
+}
+function threadStartParamsFromAutomation(turn) {
+    return compactUndefined({
+        cwd: turn.cwd,
+        model: turn.model,
+        serviceTier: turn.serviceTier,
+        sandbox: turn.sandbox,
+        approvalPolicy: turn.approvalPolicy,
+        permissions: turn.permissions,
+        experimentalRawEvents: false,
+        persistExtendedHistory: false,
+    });
+}
+function turnStartParamsFromAutomation(threadId, turn, flags = {}) {
+    return compactUndefined({
+        threadId,
+        input: [
+            {
+                type: "text",
+                text: turn.prompt,
+                text_elements: [],
+            },
+        ],
+        cwd: turn.cwd,
+        model: turn.model,
+        serviceTier: turn.serviceTier,
+        approvalPolicy: turn.approvalPolicy,
+        sandboxPolicy: flags.includeSandboxPolicy
+            ? sandboxPolicyFromMode(turn.sandbox)
+            : undefined,
+        permissions: turn.permissions,
+        responsesapiClientMetadata: turn.responsesapiClientMetadata,
+        outputSchema: turn.outputSchema,
+    });
+}
+function validateTurnPermissionOptions(turn) {
+    if (turn.sandbox && turn.permissions) {
+        throw new Error("ctx.turn.start cannot combine sandbox and permissions");
+    }
+}
+function sandboxModeValue(value) {
+    if (value === "danger-full-access" ||
+        value === "read-only" ||
+        value === "workspace-write") {
+        return value;
+    }
+    if (value !== undefined) {
+        throw new Error("ctx.turn.start sandbox must be danger-full-access, workspace-write, or read-only");
+    }
+    return undefined;
+}
+function approvalPolicyValue(value) {
+    if (value === "never" ||
+        value === "on-failure" ||
+        value === "on-request" ||
+        value === "untrusted") {
+        return value;
+    }
+    if (value !== undefined) {
+        throw new Error("ctx.turn.start approvalPolicy must be never, on-failure, on-request, or untrusted");
+    }
+    return undefined;
+}
+function sandboxPolicyFromMode(mode) {
+    if (mode === "danger-full-access") {
+        return { type: "dangerFullAccess" };
+    }
+    if (mode === "read-only") {
+        return { type: "readOnly", networkAccess: false };
+    }
+    if (mode === "workspace-write") {
+        return {
+            type: "workspaceWrite",
+            writableRoots: [],
+            networkAccess: false,
+            excludeTmpdirEnvVar: false,
+            excludeSlashTmp: false,
+        };
+    }
+    return undefined;
+}
+function nestedId(response, key, label) {
+    const id = optionalString(record(record(response)[key]).id);
+    if (!id) {
+        throw new Error(`${label} did not return ${key}.id`);
+    }
+    return id;
+}
+function finalTextFromTurn(turn) {
+    const items = array(turn.items);
+    const agentMessages = items
+        .map(record)
+        .filter((item) => item.type === "agentMessage");
+    const finalMessages = agentMessages.filter((item) => item.phase === "final_answer");
+    const selected = finalMessages.length > 0 ? finalMessages : agentMessages;
+    return selected
+        .map((item) => optionalString(item.text) ?? "")
+        .filter(Boolean)
+        .join("\n\n");
+}
+async function handleHostMessage(subprocess, host, message) {
+    if (!isHostRequestMessage(message)) {
+        return;
+    }
+    try {
+        if (!host) {
+            throw new Error("Turn automation host API is not available");
+        }
+        const result = await host({
+            method: message.method,
+            params: message.params,
+        });
+        await sendChildMessage(subprocess, {
+            type: "turnAutomation.hostResponse",
+            id: message.id,
+            result,
+        }).catch(() => undefined);
+    }
+    catch (error) {
+        await sendChildMessage(subprocess, {
+            type: "turnAutomation.hostResponse",
+            id: message.id,
+            error: {
+                message: errorMessage(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            },
+        }).catch(() => undefined);
+    }
+}
+function isHostRequestMessage(value) {
+    const message = record(value);
+    return message.type === "turnAutomation.hostRequest" &&
+        typeof message.id === "number" &&
+        typeof message.method === "string";
+}
+function sendChildMessage(subprocess, message) {
+    return new Promise((resolve, reject) => {
+        if (!subprocess.connected || typeof subprocess.send !== "function") {
+            reject(new Error("Turn automation runner IPC channel is closed"));
+            return;
+        }
+        subprocess.send(message, (error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+}
+function nodeCommandPath(scriptPath) {
+    const tsxLoader = import.meta.resolve("tsx");
+    return [
+        nodeRuntimeCommand(),
+        "--import",
+        tsxLoader,
+        siblingRuntimePath("turn-automation-module-runner"),
+        scriptPath,
+    ];
+}
+function nodeRuntimeCommand() {
+    return isBunRuntime() ? "node" : process.execPath;
+}
+function isBunRuntime() {
+    return typeof process.versions.bun === "string";
+}
+function siblingRuntimePath(basename) {
+    const currentPath = fileURLToPath(import.meta.url);
+    const extension = path.extname(currentPath) || ".ts";
+    return path.join(path.dirname(currentPath), `${basename}${extension}`);
+}
+async function collectText(stream) {
+    let output = "";
+    if (!stream) {
+        return output;
+    }
+    for await (const chunk of stream) {
+        output += Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
+    }
+    return output;
+}
+function exitCodeFor(subprocess) {
+    return new Promise((resolve, reject) => {
+        subprocess.once("error", reject);
+        subprocess.once("exit", (code) => resolve(code));
+    });
+}
+function optionalString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function requiredString(value, label) {
+    const result = optionalString(value);
+    if (!result) {
+        throw new Error(`${label} must be a non-empty string`);
+    }
+    return result;
+}
+function optionalNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function optionalBoolean(value) {
+    return typeof value === "boolean" ? value : undefined;
+}
+function stringRecord(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const entries = Object.entries(value).filter((entry) => typeof entry[1] === "string");
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+function stringArray(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const entries = value.filter((entry) => typeof entry === "string" && entry.length > 0);
+    return entries.length > 0 ? entries : undefined;
+}
+function recordOrUndefined(value) {
+    return isRecord(value) ? value : undefined;
+}
+function array(value) {
+    return Array.isArray(value) ? value : [];
+}
+function record(value) {
+    return isRecord(value) ? value : {};
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function compactUndefined(value) {
+    const result = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (entry !== undefined) {
+            result[key] = entry;
+        }
+    }
+    return result;
+}
+function preview(value) {
+    return value.length > 80 ? `${value.slice(0, 77)}...` : value;
+}
+function previewJson(value) {
+    const json = JSON.stringify(value);
+    return preview(json ?? "null");
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=turn-automation.js.map