@yuandc/aica 0.1.0

package/dist/core/job-worker.js

@@ -0,0 +1,749 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { compactAgentContext, sendAgentPrompt } from "../acp/agent.js";
+import { acaServerRequest } from "./aca-server-client.js";
+import { loadAcaConfig } from "./aca-config.js";
+import { prepareLocalWorktree } from "./worktree.js";
+import { getAcaHome } from "./paths.js";
+import { collectAffectedFiles, extractAffectedFilePathsFromAcpRaw } from "./affected-files.js";
+import { resolveJobPermissionPolicy } from "./job-permission-policy.js";
+import { appendCoalescedAcpEvent } from "./acp-event-coalescer.js";
+import { shouldUploadAcpEvent } from "./acp-event-upload-filter.js";
+const CLAIM_INTERVAL_MS = 1_500;
+const JOB_HEARTBEAT_INTERVAL_MS = 5_000;
+const PERMISSION_POLL_INTERVAL_MS = 1_000;
+const DEFAULT_ACP_EVENT_BATCH_INTERVAL_MS = 320;
+const ACP_EVENT_BATCH_MAX_SIZE = 64;
+const ACP_PRESENCE_MIN_INTERVAL_MS = 900;
+const ACP_PRESENCE_KEEPALIVE_MS = 10_000;
+const DEFAULT_MAX_CONCURRENT_JOBS = 0;
+const WORKER_STOP_TIMEOUT_MS = 12_000;
+function expandProjectRoot(value) {
+    if (!value)
+        return "";
+    if (value === "~")
+        return path.dirname(getAcaHome());
+    if (value.startsWith("~/"))
+        return path.join(path.dirname(getAcaHome()), value.slice(2));
+    return value;
+}
+function isChatProjectJob(job) {
+    const metadata = job.project_metadata;
+    if (metadata && typeof metadata === "object" && !Array.isArray(metadata) && metadata.kind === "chat")
+        return true;
+    return typeof job.project_root_path === "string" && (job.project_root_path.startsWith("~/.aca/chats/") ||
+        /(^|\/)\.aca\/chats\//.test(job.project_root_path));
+}
+export function startJobWorkerLoop(logger, dependencies = {}) {
+    let stopping = false;
+    let tickPromise = null;
+    let stopPromise = null;
+    const activeJobs = new Set();
+    const activeSessions = new Set();
+    const activeRuns = new Map();
+    const tick = async () => {
+        if (stopping)
+            return;
+        const maxConcurrentJobs = getMaxConcurrentJobs();
+        if (!hasJobCapacity(activeJobs.size, maxConcurrentJobs))
+            return;
+        try {
+            const config = dependencies.loadConfig?.() ?? loadAcaConfig();
+            if (!config.token)
+                return;
+            while (!stopping && hasJobCapacity(activeJobs.size, maxConcurrentJobs)) {
+                const response = dependencies.claimNextJob
+                    ? await dependencies.claimNextJob(config)
+                    : await acaServerRequest("POST", "/api/client/jobs/claim", {
+                        machineId: config.machineId,
+                        workspaceId: config.defaultWorkspaceId
+                    });
+                if (!response.item)
+                    break;
+                const job = response.item;
+                if (stopping) {
+                    await (dependencies.cancelClaimedJob
+                        ? dependencies.cancelClaimedJob(job, config)
+                        : failJob(job.job_id, config.machineId, "cancelled")).catch(() => void 0);
+                    break;
+                }
+                const sessionKey = job.session_id;
+                if (activeSessions.has(sessionKey)) {
+                    logger.warn(`claimed job=${job.job_id} for already active session=${sessionKey}; running anyway to avoid leaving it stuck`);
+                }
+                activeJobs.add(job.job_id);
+                activeSessions.add(sessionKey);
+                const controller = new AbortController();
+                const promise = (dependencies.runJob ?? runClientJob)(job, config, logger, controller)
+                    .catch((error) => {
+                    logger.warn(`job ${job.job_id} failed outside handler: ${error instanceof Error ? error.message : String(error)}`);
+                })
+                    .finally(() => {
+                    activeJobs.delete(job.job_id);
+                    activeSessions.delete(sessionKey);
+                    activeRuns.delete(job.job_id);
+                });
+                activeRuns.set(job.job_id, { controller, promise });
+            }
+        }
+        catch (error) {
+            if (!stopping)
+                logger.warn(`job worker failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    };
+    const scheduleTick = () => {
+        if (stopping || tickPromise)
+            return;
+        const promise = tick();
+        tickPromise = promise;
+        void promise.finally(() => {
+            if (tickPromise === promise)
+                tickPromise = null;
+        });
+    };
+    scheduleTick();
+    const timer = setInterval(() => {
+        scheduleTick();
+    }, dependencies.claimIntervalMs ?? CLAIM_INTERVAL_MS);
+    return {
+        timer,
+        stop: () => {
+            if (stopPromise)
+                return stopPromise;
+            stopPromise = (async () => {
+                if (stopping)
+                    return;
+                stopping = true;
+                clearInterval(timer);
+                for (const run of activeRuns.values())
+                    run.controller.abort();
+                await tickPromise?.catch(() => void 0);
+                for (const run of activeRuns.values())
+                    run.controller.abort();
+                const pending = [...activeRuns.values()].map((run) => run.promise);
+                if (pending.length === 0)
+                    return;
+                await Promise.race([
+                    Promise.allSettled(pending).then(() => void 0),
+                    delay(WORKER_STOP_TIMEOUT_MS)
+                ]);
+            })();
+            return stopPromise;
+        }
+    };
+}
+function getMaxConcurrentJobs() {
+    const raw = process.env.ACA_MAX_CONCURRENT_JOBS || process.env.ACA_MAX_CONCURRENT_PROJECT_JOBS || "";
+    const parsed = Number.parseInt(raw, 10);
+    if (!raw.trim() || !Number.isFinite(parsed) || parsed < 0)
+        return DEFAULT_MAX_CONCURRENT_JOBS;
+    if (parsed === 0)
+        return 0;
+    return Math.max(1, Math.min(parsed, 8));
+}
+function hasJobCapacity(activeCount, maxConcurrentJobs) {
+    return maxConcurrentJobs === 0 || activeCount < maxConcurrentJobs;
+}
+function getAcpEventBatchIntervalMs() {
+    const value = Number.parseInt(process.env.ACA_ACP_EVENT_BATCH_INTERVAL_MS || "", 10);
+    if (!Number.isFinite(value))
+        return DEFAULT_ACP_EVENT_BATCH_INTERVAL_MS;
+    return Math.max(40, Math.min(value, 2_000));
+}
+async function runClientJob(job, config, logger, controller) {
+    const jobId = job.job_id;
+    const sessionId = job.session_id;
+    const workspaceId = job.workspace_id;
+    const projectId = job.project_id ?? null;
+    const input = job.input ?? {};
+    const controlType = String(input.control?.type || "").toLowerCase();
+    if (!controlType && !input.message?.trim() && (input.attachments ?? []).length === 0) {
+        await failJob(jobId, config.machineId, "job input missing message");
+        return;
+    }
+    const project = config.projects.find((item) => item.projectId === projectId);
+    const projectRoot = expandProjectRoot(project?.rootPath || job.project_root_path || "");
+    if (!projectRoot) {
+        await failJob(jobId, config.machineId, "job project root is unknown");
+        return;
+    }
+    if (isChatProjectJob(job))
+        fs.mkdirSync(projectRoot, { recursive: true });
+    logger.info(`claimed job=${jobId} session=${sessionId} project=${project?.name ?? projectId ?? "unknown"}`);
+    const heartbeatTimer = setInterval(() => {
+        void acaServerRequest("POST", `/api/client/jobs/${encodeURIComponent(jobId)}/heartbeat`, {
+            machineId: config.machineId
+        }).catch(() => void 0);
+        void checkCancel(jobId, controller).catch(() => void 0);
+    }, JOB_HEARTBEAT_INTERVAL_MS);
+    let acpUpdateSequence = 0;
+    const eventBatcher = createAcpEventBatcher(jobId, config.machineId);
+    const presenceReporter = createPresenceReporter(jobId, config.machineId);
+    const affectedPathEvidence = new Set();
+    let preparedForResult = null;
+    try {
+        await presenceReporter.sendNow({
+            phase: "initializing",
+            label: "准备工作区",
+            detail: job.worktree_id ? "worktree" : "project root"
+        }).catch(() => void 0);
+        const prepared = prepareLocalWorktree({
+            projectId,
+            sessionId,
+            projectRoot,
+            worktree: job
+        });
+        preparedForResult = prepared;
+        await updateWorktree(jobId, config.machineId, prepared);
+        const acpRun = normalizeAcpRun(input.acpRun);
+        if (controlType === "compact") {
+            if (!job.acp_session_id)
+                throw new Error("Current session does not have an ACP context to compact");
+            const compacted = await compactAgentContext({
+                agentType: firstNonEmptyString(acpRun.agentType, "codex"),
+                cliType: firstNonEmptyString(acpRun.cliType, "builtin"),
+                acpSessionId: job.acp_session_id,
+                cwd: prepared.cwd,
+                model: input.model,
+                mode: input.mode,
+                configOptionValues: input.configOptionValues,
+                timeoutMs: input.timeoutMs,
+                allowRollover: input.control?.allowRollover === true,
+                signal: controller.signal,
+                onStatus: (status) => {
+                    presenceReporter.report({
+                        phase: status.phase,
+                        label: status.label,
+                        detail: status.detail,
+                        updateType: status.updateType,
+                        raw: status
+                    });
+                }
+            });
+            await presenceReporter.flush();
+            await acaServerRequest("POST", `/api/client/jobs/${encodeURIComponent(jobId)}/complete`, {
+                machineId: config.machineId,
+                acpSessionId: compacted.acpSessionId,
+                suppressTurn: true,
+                result: {
+                    ok: true,
+                    control: { type: "compact", allowRollover: input.control?.allowRollover === true },
+                    acpSessionId: compacted.acpSessionId,
+                    durationMs: compacted.durationMs,
+                    usage: compacted.contextUsage,
+                    maintenance: compacted.maintenance,
+                    worktree: summarizePreparedWorktree(prepared)
+                }
+            });
+            logger.info(`completed context compact job=${jobId}`);
+            return;
+        }
+        const materializedAttachments = materializeJobAttachments({
+            cwd: prepared.cwd,
+            sessionId,
+            jobId,
+            attachments: input.attachments ?? []
+        });
+        if (materializedAttachments.length > 0) {
+            logger.info(`materialized ${materializedAttachments.length} attachment(s) for job=${jobId}`);
+            await presenceReporter.sendNow({
+                phase: "initializing",
+                label: "附件已写入本机",
+                detail: materializedAttachments.map((item) => item.relativePath).join(", "),
+                raw: { attachments: summarizeMaterializedAttachments(materializedAttachments) }
+            }).catch(() => void 0);
+        }
+        const prompt = buildPromptWithAttachments(input, materializedAttachments);
+        const promptBlocks = buildPromptBlocks(prompt, materializedAttachments);
+        const agent = await sendAgentPrompt({
+            agentType: firstNonEmptyString(acpRun.agentType, "codex"),
+            cliType: firstNonEmptyString(acpRun.cliType, "builtin"),
+            acpSessionId: job.acp_session_id ?? null,
+            prompt,
+            promptBlocks,
+            cwd: prepared.cwd,
+            model: input.model,
+            mode: input.mode,
+            configOptionValues: input.configOptionValues,
+            canExecuteTools: input.canExecuteTools,
+            timeoutMs: input.timeoutMs,
+            contextWindow: positiveNumber(acpRun.contextWindow),
+            signal: controller.signal,
+            onStatus: (status) => {
+                presenceReporter.report({
+                    phase: status.phase,
+                    label: status.label,
+                    detail: status.detail,
+                    updateType: status.updateType,
+                    raw: status
+                });
+            },
+            onUpdate: (event) => {
+                acpUpdateSequence += 1;
+                for (const filePath of extractAffectedFilePathsFromAcpRaw(event.raw)) {
+                    affectedPathEvidence.add(filePath);
+                }
+                const outgoingEvent = {
+                    turnId: job.user_turn_id ?? null,
+                    eventType: event.type,
+                    label: event.label,
+                    text: event.text,
+                    status: event.status,
+                    toolCallId: event.toolCallId,
+                    raw: withAcaSequence(event.raw, acpUpdateSequence)
+                };
+                if (shouldUploadAcpEvent(outgoingEvent))
+                    eventBatcher.push(outgoingEvent);
+            },
+            onPermissionRequest: (request) => {
+                const policyResponse = resolveJobPermissionPolicy(input, request);
+                return policyResponse
+                    ? Promise.resolve(policyResponse)
+                    : waitForPermission(jobId, config.machineId, request, controller.signal);
+            },
+            onUserInputRequest: (request) => waitForUserInput(jobId, config.machineId, request, controller.signal)
+        });
+        await eventBatcher.flush();
+        await presenceReporter.flush();
+        const affectedFiles = collectAffectedFiles({
+            cwd: prepared.cwd,
+            evidencePaths: affectedPathEvidence
+        });
+        const stopReason = agentStopReason(agent.promptResponse);
+        const ok = isAgentRunSuccessful(stopReason) || Boolean(agent.content);
+        if (!ok) {
+            await failJob(jobId, config.machineId, `${agent.agentType} stopped: ${stopReason ?? "unknown"}`, {
+                acpSessionId: agent.acpSessionId,
+                stopReason,
+                exitCode: agent.exitCode,
+                stderr: truncate(agent.stderr, 4_000),
+                worktree: summarizePreparedWorktree(prepared)
+            });
+            return;
+        }
+        await acaServerRequest("POST", `/api/client/jobs/${encodeURIComponent(jobId)}/complete`, {
+            machineId: config.machineId,
+            acpSessionId: agent.acpSessionId,
+            assistantText: agent.content,
+            result: {
+                ok: true,
+                acpSessionId: agent.acpSessionId,
+                stopReason,
+                durationMs: agent.durationMs,
+                acpRun: input.acpRun ?? null,
+                effectiveConfig: agent.effectiveConfig ?? null,
+                performance: agent.performance ?? null,
+                usage: agent.contextUsage ?? null,
+                updateCount: agent.updates.length,
+                statusTimeline: agent.statusTimeline,
+                worktree: summarizePreparedWorktree(prepared),
+                attachments: summarizeMaterializedAttachments(materializedAttachments),
+                files: affectedFiles
+            }
+        });
+        logger.info(`completed job=${jobId}`);
+    }
+    catch (error) {
+        await eventBatcher.flush();
+        await presenceReporter.flush();
+        const rawMessage = controller.signal.aborted ? "cancelled" : error instanceof Error ? error.message : String(error);
+        const affectedFiles = preparedForResult ? collectAffectedFiles({
+            cwd: preparedForResult.cwd,
+            evidencePaths: affectedPathEvidence
+        }) : [];
+        await failJob(jobId, config.machineId, userFacingAcpError(rawMessage), { rawError: rawMessage, files: affectedFiles });
+    }
+    finally {
+        await eventBatcher.flush();
+        await presenceReporter.flush();
+        clearInterval(heartbeatTimer);
+    }
+}
+function userFacingAcpError(message) {
+    if (/ACP request timed out/i.test(message))
+        return "ACP 长时间没有完成，请稍后重试，或点击停止后重新发送。";
+    if (/MimoCode request timed out/i.test(message))
+        return "MimoCode 长时间没有完成，请稍后重试，或点击停止后重新发送。";
+    return message.replace(/\bsession\/prompt\b/g, "ACP 请求");
+}
+function normalizeAcpRun(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return {};
+    return value;
+}
+function positiveNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
+}
+function firstNonEmptyString(...values) {
+    for (const value of values) {
+        if (typeof value === "string" && value.trim())
+            return value.trim();
+    }
+    return "";
+}
+function agentStopReason(promptResponse) {
+    if (!promptResponse || typeof promptResponse !== "object" || Array.isArray(promptResponse))
+        return undefined;
+    const record = promptResponse;
+    if (typeof record.stopReason === "string")
+        return record.stopReason;
+    if (typeof record.reason === "string")
+        return record.reason;
+    const part = record.part;
+    if (part && typeof part === "object" && !Array.isArray(part) && typeof part.reason === "string") {
+        return part.reason;
+    }
+    return undefined;
+}
+function isAgentRunSuccessful(stopReason) {
+    if (!stopReason)
+        return false;
+    return ["end_turn", "stop", "completed", "complete"].includes(stopReason);
+}
+function createAcpEventBatcher(jobId, machineId) {
+    let buffer = [];
+    let timer = null;
+    let chain = Promise.resolve();
+    const send = async (events) => {
+        if (events.length === 0)
+            return;
+        await acaServerRequest("POST", `/api/client/jobs/${encodeURIComponent(jobId)}/events/batch`, {
+            machineId,
+            events
+        });
+    };
+    const flushNow = () => {
+        if (timer) {
+            clearTimeout(timer);
+            timer = null;
+        }
+        const events = buffer;
+        buffer = [];
+        chain = chain.then(() => send(events)).catch(() => void 0);
+        return chain;
+    };
+    const schedule = () => {
+        if (timer)
+            return;
+        timer = setTimeout(() => {
+            void flushNow();
+        }, getAcpEventBatchIntervalMs());
+        timer.unref();
+    };
+    return {
+        push(event) {
+            appendCoalescedAcpEvent(buffer, event);
+            if (buffer.length >= ACP_EVENT_BATCH_MAX_SIZE) {
+                void flushNow();
+                return;
+            }
+            schedule();
+        },
+        flush: flushNow
+    };
+}
+function createPresenceReporter(jobId, machineId) {
+    let pending = null;
+    let lastSentAt = 0;
+    let lastSignature = "";
+    let timer = null;
+    let chain = Promise.resolve();
+    const signatureOf = (payload) => {
+        return JSON.stringify({
+            phase: payload.phase ?? "",
+            label: payload.label ?? "",
+            detail: payload.detail ?? "",
+            updateType: payload.updateType ?? ""
+        });
+    };
+    const post = async (payload) => {
+        await acaServerRequest("POST", `/api/client/jobs/${encodeURIComponent(jobId)}/presence`, {
+            machineId,
+            phase: payload.phase,
+            label: payload.label,
+            detail: payload.detail,
+            updateType: payload.updateType,
+            raw: payload.raw
+        });
+        lastSentAt = Date.now();
+        lastSignature = signatureOf(payload);
+    };
+    const flushPending = () => {
+        if (timer) {
+            clearTimeout(timer);
+            timer = null;
+        }
+        if (!pending)
+            return chain;
+        const payload = pending;
+        pending = null;
+        chain = chain.then(() => post(payload)).catch(() => void 0);
+        return chain;
+    };
+    const schedule = (delay) => {
+        if (timer)
+            return;
+        timer = setTimeout(() => {
+            void flushPending();
+        }, delay);
+        timer.unref();
+    };
+    return {
+        report(payload) {
+            const now = Date.now();
+            const signature = signatureOf(payload);
+            const changed = signature !== lastSignature;
+            const stale = now - lastSentAt >= ACP_PRESENCE_KEEPALIVE_MS;
+            if (!changed && !stale)
+                return;
+            pending = payload;
+            const elapsed = now - lastSentAt;
+            if (elapsed >= ACP_PRESENCE_MIN_INTERVAL_MS || lastSentAt === 0) {
+                void flushPending();
+                return;
+            }
+            schedule(ACP_PRESENCE_MIN_INTERVAL_MS - elapsed);
+        },
+        sendNow(payload) {
+            pending = payload;
+            return flushPending();
+        },
+        flush: flushPending
+    };
+}
+function withAcaSequence(raw, sequence) {
+    if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+        return { ...raw, acaSequence: sequence };
+    }
+    return { value: raw, acaSequence: sequence };
+}
+function buildPromptWithAttachments(input, materializedAttachments = []) {
+    const message = input?.message?.trim() ?? "";
+    if (materializedAttachments.length === 0)
+        return message;
+    const lines = materializedAttachments.map((attachment, index) => {
+        return `${index + 1}. ${attachment.name} (${attachment.kind}, ${attachment.mimeType}, ${formatByteSize(attachment.size)})\n   localPath: ${attachment.path}\n   workspacePath: ${attachment.relativePath}`;
+    });
+    const attachmentText = [
+        "用户随消息上传了以下附件，aca 已将附件写入本机工作区。需要读取附件时请直接使用下面的 localPath；图片附件也已作为 ACP image block 随本轮请求传入。",
+        ...lines
+    ].join("\n");
+    return message ? `${message}\n\n${attachmentText}` : attachmentText;
+}
+function buildPromptBlocks(prompt, attachments) {
+    const blocks = [{ type: "text", text: prompt }];
+    for (const attachment of attachments) {
+        if (attachment.kind !== "image" || !attachment.mimeType.startsWith("image/"))
+            continue;
+        blocks.push({
+            type: "image",
+            data: attachment.base64,
+            mimeType: attachment.mimeType,
+            uri: attachment.path
+        });
+    }
+    return blocks;
+}
+function materializeJobAttachments(input) {
+    if (input.attachments.length === 0)
+        return [];
+    const root = path.join(input.cwd, ".aca", "attachments", sanitizePathSegment(input.sessionId), sanitizePathSegment(input.jobId));
+    fs.mkdirSync(root, { recursive: true });
+    return input.attachments.map((attachment, index) => {
+        const parsed = parseDataUrl(attachment.dataUrl ?? "");
+        const mimeType = attachment.mimeType || parsed.mimeType || "application/octet-stream";
+        const kind = attachment.kind === "image" || mimeType.startsWith("image/") ? "image" : "file";
+        const safeName = safeAttachmentFileName(attachment.name || `attachment-${index + 1}`, mimeType);
+        const filePath = path.join(root, `${String(index + 1).padStart(2, "0")}-${safeName}`);
+        fs.writeFileSync(filePath, parsed.bytes);
+        return {
+            name: attachment.name || safeName,
+            mimeType,
+            size: parsed.bytes.byteLength,
+            kind,
+            path: filePath,
+            relativePath: path.relative(input.cwd, filePath),
+            base64: parsed.bytes.toString("base64"),
+            sha256: crypto.createHash("sha256").update(parsed.bytes).digest("hex")
+        };
+    });
+}
+function parseDataUrl(dataUrl) {
+    const commaIndex = dataUrl.indexOf(",");
+    if (!dataUrl.startsWith("data:") || commaIndex < 0) {
+        throw new Error("attachment dataUrl is not a data URL");
+    }
+    const header = dataUrl.slice(5, commaIndex);
+    const body = dataUrl.slice(commaIndex + 1);
+    const parts = header.split(";").filter(Boolean);
+    const mimeType = parts[0]?.includes("/") ? parts[0] : "application/octet-stream";
+    if (!parts.includes("base64")) {
+        throw new Error("attachment dataUrl is not base64 encoded");
+    }
+    return {
+        mimeType,
+        bytes: Buffer.from(body, "base64")
+    };
+}
+function safeAttachmentFileName(name, mimeType) {
+    const cleaned = path.basename(name).replace(/[<>:"/\\|?*\x00-\x1F]/g, "_").trim();
+    const fallback = `attachment${extensionForMimeType(mimeType)}`;
+    const safe = !cleaned || cleaned === "." || cleaned === ".." ? fallback : cleaned;
+    return safe.slice(0, 180);
+}
+function extensionForMimeType(mimeType) {
+    switch (mimeType.toLowerCase()) {
+        case "image/png":
+            return ".png";
+        case "image/jpeg":
+            return ".jpg";
+        case "image/webp":
+            return ".webp";
+        case "image/gif":
+            return ".gif";
+        case "text/plain":
+            return ".txt";
+        case "application/json":
+            return ".json";
+        case "text/markdown":
+        case "text/x-markdown":
+            return ".md";
+        case "application/pdf":
+            return ".pdf";
+        case "application/msword":
+            return ".doc";
+        case "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
+            return ".docx";
+        case "application/vnd.ms-excel":
+            return ".xls";
+        case "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet":
+            return ".xlsx";
+        case "application/vnd.ms-powerpoint":
+            return ".ppt";
+        case "application/vnd.openxmlformats-officedocument.presentationml.presentation":
+            return ".pptx";
+        case "application/zip":
+            return ".zip";
+        case "application/x-7z-compressed":
+            return ".7z";
+        case "application/x-rar-compressed":
+        case "application/vnd.rar":
+            return ".rar";
+        case "application/gzip":
+            return ".gz";
+        case "application/x-tar":
+            return ".tar";
+        default:
+            return "";
+    }
+}
+function sanitizePathSegment(value) {
+    return value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "item";
+}
+function summarizeMaterializedAttachments(attachments) {
+    return attachments.map((attachment) => ({
+        name: attachment.name,
+        kind: attachment.kind,
+        mimeType: attachment.mimeType,
+        size: attachment.size,
+        path: attachment.path,
+        relativePath: attachment.relativePath,
+        sha256: attachment.sha256
+    }));
+}
+function formatByteSize(size) {
+    if (!Number.isFinite(size) || size <= 0)
+        return "0 B";
+    const units = ["B", "KB", "MB", "GB"];
+    let value = size;
+    let unitIndex = 0;
+    while (value >= 1024 && unitIndex < units.length - 1) {
+        value /= 1024;
+        unitIndex += 1;
+    }
+    return `${value >= 10 || unitIndex === 0 ? value.toFixed(0) : value.toFixed(1)} ${units[unitIndex]}`;
+}
+async function updateWorktree(jobId, machineId, prepared) {
+    if (!prepared.usedWorktree || !prepared.worktreeId)
+        return;
+    await acaServerRequest("POST", `/api/client/jobs/${encodeURIComponent(jobId)}/worktree`, {
+        machineId,
+        baseCommit: prepared.baseCommit ?? null,
+        worktreePath: prepared.cwd,
+        status: prepared.status ?? "active",
+        raw: prepared.raw ?? summarizePreparedWorktree(prepared)
+    });
+}
+function summarizePreparedWorktree(prepared) {
+    return {
+        usedWorktree: prepared.usedWorktree,
+        worktreeId: prepared.worktreeId ?? null,
+        cwd: prepared.cwd,
+        status: prepared.status ?? null,
+        baseCommit: prepared.baseCommit ?? null,
+        branchName: prepared.branchName ?? null,
+        baseBranch: prepared.baseBranch ?? null
+    };
+}
+async function waitForPermission(jobId, machineId, request, signal) {
+    const created = await acaServerRequest("POST", `/api/client/jobs/${encodeURIComponent(jobId)}/permissions`, {
+        machineId,
+        request
+    });
+    const permissionId = created.item.permission_id;
+    while (!signal.aborted) {
+        await delay(PERMISSION_POLL_INTERVAL_MS);
+        const response = await acaServerRequest("GET", `/api/client/permissions/${encodeURIComponent(permissionId)}`);
+        if (response.item.status === "resolved" && response.item.response) {
+            const outcome = response.item.response.outcome;
+            if (outcome.outcome === "selected")
+                return { outcome };
+            return { outcome: { outcome: "cancelled" } };
+        }
+    }
+    return { outcome: { outcome: "cancelled" } };
+}
+async function waitForUserInput(jobId, machineId, request, signal) {
+    const created = await acaServerRequest("POST", `/api/client/jobs/${encodeURIComponent(jobId)}/permissions`, {
+        machineId,
+        request: {
+            kind: "elicitation",
+            ...request
+        }
+    });
+    const permissionId = created.item.permission_id;
+    while (!signal.aborted) {
+        await delay(PERMISSION_POLL_INTERVAL_MS);
+        const response = await acaServerRequest("GET", `/api/client/permissions/${encodeURIComponent(permissionId)}`);
+        if (response.item.status === "resolved" && response.item.response) {
+            const outcome = response.item.response.outcome;
+            if (outcome.outcome === "submitted")
+                return { outcome };
+            return { outcome: { outcome: "cancelled" } };
+        }
+    }
+    return { outcome: { outcome: "cancelled" } };
+}
+async function checkCancel(jobId, controller) {
+    if (controller.signal.aborted)
+        return;
+    const response = await acaServerRequest("GET", `/api/client/jobs/${encodeURIComponent(jobId)}`);
+    if (Number(response.item.cancel_requested ?? 0) === 1)
+        controller.abort();
+}
+async function failJob(jobId, machineId, error, result) {
+    await acaServerRequest("POST", `/api/client/jobs/${encodeURIComponent(jobId)}/fail`, {
+        machineId,
+        error,
+        result
+    });
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function truncate(value, maxChars) {
+    if (value.length <= maxChars)
+        return value;
+    return `${value.slice(0, maxChars)}...`;
+}