@playdrop/playdrop-cli 0.9.6 → 0.10.0

package/dist/commands/validate.js

@@ -10,6 +10,7 @@ const uploadLog_1 = require("../uploadLog");
 const apps_1 = require("../apps");
 const assetSpecs_1 = require("../assetSpecs");
 const externalAssetPackValidation_1 = require("../externalAssetPackValidation");
+const dev_1 = require("./dev");
 const upload_content_1 = require("./upload-content");
 function buildLocalAssetSpecLookups(tasks) {
     const exactByRef = new Map();
@@ -114,6 +115,8 @@ async function loadHostedLaunchValidationContext(workspacePath, envOverride) {
         apiBase: ctx.envConfig.apiBase,
         webBase: ctx.envConfig.webBase ?? null,
         token: ctx.token,
+        devRouterPort: (0, dev_1.resolveDevRouterPort)(process.env.PLAYDROP_DEV_ROUTER_PORT),
+        taskScoped: Boolean(ctx.workspaceAuth?.config.taskToken),
     };
 }
 function printResolvedValidationAccount(ctx) {
@@ -250,6 +253,8 @@ async function validate(pathOrName, options = {}) {
                         task,
                         token: launchContext.token,
                         currentUser: launchContext.currentUser,
+                        devRouterPort: launchContext.devRouterPort,
+                        allowUnregisteredViewerLaunch: launchContext.taskScoped,
                     });
                     if (launchCheck.status !== 'PASSED') {
                         throw new Error((0, apps_1.formatHostedLaunchCheckFailure)(task.name, launchCheck, 'local'));

package/dist/commands/worker/runtime.d.ts

@@ -0,0 +1,69 @@
+export declare const DEFAULT_CODEX_TIMEOUT_MS: number;
+export declare const DEFAULT_WORKER_TOKEN_CAP = 20000000;
+export declare const DEFAULT_CODEX_LOG_TAIL_CHARS = 12000;
+export declare const DEFAULT_TRANSCRIPT_FLUSH_INTERVAL_MS = 10000;
+export type LoggedProcessResult = {
+    exitCode: number | null;
+    signal: NodeJS.Signals | null;
+    stdout: string;
+    stderr: string;
+    outputTail: string;
+    timedOut: boolean;
+    tokensUsed: number | null;
+};
+export type LoggedProcessTranscriptChunk = {
+    stream: 'stdout' | 'stderr';
+    content: string;
+};
+export declare function readPositiveEnvInt(name: string, fallback: number): number;
+export declare function readEnvBoolean(name: string, fallback: boolean): boolean;
+export declare function extractCodexTokensUsed(output: string): number | null;
+export declare function assertWorkerTokenUsageWithinCap(input: {
+    tokensUsed: number | null;
+    tokenCap: number;
+}): boolean;
+export declare function runLoggedProcess(input: {
+    command: string;
+    args: string[];
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    stdin?: string;
+    timeoutMs: number;
+    maxOutputChars: number;
+    transcriptFlushIntervalMs?: number;
+    onTranscriptChunks?: (chunks: LoggedProcessTranscriptChunk[]) => Promise<void> | void;
+    onChild?: (controls: {
+        terminate: () => void;
+    }) => void;
+}): Promise<LoggedProcessResult>;
+export declare function buildCodexExecArgs(input: {
+    workspaceDir: string;
+    model: string;
+    reasoningEffort: string;
+    networkAccess: boolean;
+    sandboxMode?: CodexSandboxMode;
+}): string[];
+export type CodexSandboxMode = 'danger-full-access' | 'workspace-write' | 'read-only';
+export declare function readCodexSandboxMode(env?: NodeJS.ProcessEnv): CodexSandboxMode;
+export declare function buildClaudeExecArgs(input: {
+    model: string;
+    effort?: string | null;
+    workspaceDir?: string | null;
+    denyReadRoots?: string[] | null;
+    pluginDir?: string | null;
+}): string[];
+export declare function buildClaudePermissionSettings(denyReadRoots?: string[]): {
+    permissions: {
+        allow: string[];
+        deny: string[];
+    };
+};
+export declare function buildClaudeDeniedPermissionRules(denyReadRoots?: string[]): string[];
+export declare function buildWorkerChildEnv(input: {
+    binDir: string;
+    taskId: number;
+    envName: string;
+    eventDir?: string;
+    devPort?: number;
+    baseEnv?: NodeJS.ProcessEnv;
+}): NodeJS.ProcessEnv;

package/dist/commands/worker/runtime.js

@@ -0,0 +1,414 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_TRANSCRIPT_FLUSH_INTERVAL_MS = exports.DEFAULT_CODEX_LOG_TAIL_CHARS = exports.DEFAULT_WORKER_TOKEN_CAP = exports.DEFAULT_CODEX_TIMEOUT_MS = void 0;
+exports.readPositiveEnvInt = readPositiveEnvInt;
+exports.readEnvBoolean = readEnvBoolean;
+exports.extractCodexTokensUsed = extractCodexTokensUsed;
+exports.assertWorkerTokenUsageWithinCap = assertWorkerTokenUsageWithinCap;
+exports.runLoggedProcess = runLoggedProcess;
+exports.buildCodexExecArgs = buildCodexExecArgs;
+exports.readCodexSandboxMode = readCodexSandboxMode;
+exports.buildClaudeExecArgs = buildClaudeExecArgs;
+exports.buildClaudePermissionSettings = buildClaudePermissionSettings;
+exports.buildClaudeDeniedPermissionRules = buildClaudeDeniedPermissionRules;
+exports.buildWorkerChildEnv = buildWorkerChildEnv;
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = __importDefault(require("node:path"));
+const CHILD_KILL_GRACE_MS = 10000;
+exports.DEFAULT_CODEX_TIMEOUT_MS = 2 * 60 * 60 * 1000;
+exports.DEFAULT_WORKER_TOKEN_CAP = 20000000;
+exports.DEFAULT_CODEX_LOG_TAIL_CHARS = 12000;
+exports.DEFAULT_TRANSCRIPT_FLUSH_INTERVAL_MS = 10000;
+function tailText(value, maxChars) {
+    if (value.length <= maxChars) {
+        return value;
+    }
+    return value.slice(value.length - maxChars);
+}
+function readPositiveEnvInt(name, fallback) {
+    const raw = process.env[name]?.trim();
+    if (!raw) {
+        return fallback;
+    }
+    const parsed = Number.parseInt(raw, 10);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw new Error(`invalid_${name.toLowerCase()}`);
+    }
+    return parsed;
+}
+function readEnvBoolean(name, fallback) {
+    const raw = process.env[name]?.trim().toLowerCase();
+    if (!raw) {
+        return fallback;
+    }
+    if (raw === '1' || raw === 'true' || raw === 'yes' || raw === 'on') {
+        return true;
+    }
+    if (raw === '0' || raw === 'false' || raw === 'no' || raw === 'off') {
+        return false;
+    }
+    throw new Error(`invalid_${name.toLowerCase()}`);
+}
+function extractCodexTokensUsed(output) {
+    for (const line of output.split(/\r?\n/).reverse()) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(trimmed);
+            const usage = parsed.usage;
+            if (!usage) {
+                continue;
+            }
+            const tokenKeys = [
+                'input_tokens',
+                'output_tokens',
+                'cache_creation_input_tokens',
+                'cache_read_input_tokens',
+            ];
+            let total = 0;
+            let sawTokenValue = false;
+            for (const key of tokenKeys) {
+                const value = usage[key];
+                if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
+                    continue;
+                }
+                total += value;
+                sawTokenValue = true;
+            }
+            if (sawTokenValue) {
+                return Math.ceil(total);
+            }
+        }
+        catch {
+            // Fall through to the plain-text patterns below.
+        }
+    }
+    const patterns = [
+        /total\s+tokens\s*:?\s*([\d,]+)/i,
+        /tokens\s+used\s*:?\s*([\d,]+)/i,
+        /"total_tokens"\s*:\s*([\d,]+)/i,
+    ];
+    for (const pattern of patterns) {
+        const match = pattern.exec(output);
+        if (!match?.[1]) {
+            continue;
+        }
+        const parsed = Number.parseInt(match[1].replace(/,/g, ''), 10);
+        if (Number.isInteger(parsed) && parsed >= 0) {
+            return parsed;
+        }
+    }
+    return null;
+}
+function assertWorkerTokenUsageWithinCap(input) {
+    if (input.tokensUsed === null) {
+        return false;
+    }
+    if (input.tokensUsed > input.tokenCap) {
+        throw new Error(`token_cap_exceeded:${input.tokensUsed}:${input.tokenCap}`);
+    }
+    return true;
+}
+async function runLoggedProcess(input) {
+    if (!input.command.trim()) {
+        throw new Error('invalid_process_command');
+    }
+    if (!Number.isInteger(input.timeoutMs) || input.timeoutMs <= 0) {
+        throw new Error('invalid_process_timeout');
+    }
+    if (!Number.isInteger(input.maxOutputChars) || input.maxOutputChars <= 0) {
+        throw new Error('invalid_process_log_tail');
+    }
+    const transcriptFlushIntervalMs = input.transcriptFlushIntervalMs ?? exports.DEFAULT_TRANSCRIPT_FLUSH_INTERVAL_MS;
+    if (input.onTranscriptChunks && (!Number.isInteger(transcriptFlushIntervalMs) || transcriptFlushIntervalMs <= 0)) {
+        throw new Error('invalid_process_transcript_flush_interval');
+    }
+    return await new Promise((resolve, reject) => {
+        let stdout = '';
+        let stderr = '';
+        let combined = '';
+        let timedOut = false;
+        let closed = false;
+        let killTimer = null;
+        let terminateKillTimer = null;
+        let transcriptFlushTimer = null;
+        let transcriptFlushError = null;
+        let transcriptFlushPromise = Promise.resolve();
+        const pendingTranscriptChunks = [];
+        const child = (0, node_child_process_1.spawn)(input.command, input.args, {
+            cwd: input.cwd,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: input.env,
+        });
+        child.stdin?.end(input.stdin ?? '');
+        if (input.onChild) {
+            input.onChild({
+                terminate: () => {
+                    if (closed) {
+                        return;
+                    }
+                    child.kill('SIGTERM');
+                    terminateKillTimer = setTimeout(() => {
+                        if (!closed) {
+                            child.kill('SIGKILL');
+                        }
+                    }, CHILD_KILL_GRACE_MS);
+                },
+            });
+        }
+        const flushTranscriptChunks = async () => {
+            if (!input.onTranscriptChunks || pendingTranscriptChunks.length <= 0) {
+                return;
+            }
+            const chunks = pendingTranscriptChunks.splice(0, pendingTranscriptChunks.length);
+            await input.onTranscriptChunks(chunks);
+        };
+        const queueTranscriptFlush = () => {
+            transcriptFlushPromise = transcriptFlushPromise.then(flushTranscriptChunks, flushTranscriptChunks);
+            return transcriptFlushPromise;
+        };
+        const handleTranscriptFlushError = (error) => {
+            transcriptFlushError = transcriptFlushError ?? error;
+            if (!closed) {
+                child.kill('SIGTERM');
+            }
+        };
+        if (input.onTranscriptChunks) {
+            transcriptFlushTimer = setInterval(() => {
+                queueTranscriptFlush().catch(handleTranscriptFlushError);
+            }, transcriptFlushIntervalMs);
+        }
+        const append = (stream, chunk) => {
+            const text = chunk.toString('utf8');
+            if (stream === 'stdout') {
+                process.stdout.write(text);
+                stdout = tailText(stdout + text, input.maxOutputChars);
+            }
+            else {
+                process.stderr.write(text);
+                stderr = tailText(stderr + text, input.maxOutputChars);
+            }
+            if (input.onTranscriptChunks) {
+                pendingTranscriptChunks.push({ stream, content: text });
+            }
+            combined = tailText(combined + text, input.maxOutputChars);
+        };
+        const timeout = setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGTERM');
+            killTimer = setTimeout(() => {
+                if (!closed) {
+                    child.kill('SIGKILL');
+                }
+            }, 5000);
+        }, input.timeoutMs);
+        child.stdout?.on('data', (chunk) => append('stdout', chunk));
+        child.stderr?.on('data', (chunk) => append('stderr', chunk));
+        child.on('error', reject);
+        child.on('close', (code, signal) => {
+            closed = true;
+            clearTimeout(timeout);
+            if (killTimer) {
+                clearTimeout(killTimer);
+            }
+            if (terminateKillTimer) {
+                clearTimeout(terminateKillTimer);
+            }
+            if (transcriptFlushTimer) {
+                clearInterval(transcriptFlushTimer);
+            }
+            void (async () => {
+                await queueTranscriptFlush();
+                if (transcriptFlushError) {
+                    throw transcriptFlushError;
+                }
+                const outputTail = tailText(combined, input.maxOutputChars);
+                resolve({
+                    exitCode: code,
+                    signal,
+                    stdout,
+                    stderr,
+                    outputTail,
+                    timedOut,
+                    tokensUsed: extractCodexTokensUsed(`${stdout}\n${stderr}\n${outputTail}`),
+                });
+            })().catch(reject);
+        });
+    });
+}
+function buildCodexExecArgs(input) {
+    const sandboxMode = input.sandboxMode ?? 'danger-full-access';
+    const args = [
+        'exec',
+        '--sandbox',
+        sandboxMode,
+        '--cd',
+        input.workspaceDir,
+        '--skip-git-repo-check',
+        '--ephemeral',
+        '--model',
+        input.model,
+        '-c',
+        `model_reasoning_effort="${input.reasoningEffort}"`,
+        '-',
+    ];
+    if (sandboxMode === 'workspace-write') {
+        args.splice(args.length - 3, 0, '-c', `sandbox_workspace_write.network_access=${input.networkAccess ? 'true' : 'false'}`);
+    }
+    return args;
+}
+function readCodexSandboxMode(env = process.env) {
+    const raw = env.PLAYDROP_WORKER_CODEX_SANDBOX?.trim();
+    if (!raw) {
+        return 'danger-full-access';
+    }
+    if (raw === 'danger-full-access' || raw === 'workspace-write' || raw === 'read-only') {
+        return raw;
+    }
+    throw new Error(`invalid_playdrop_worker_codex_sandbox:${raw}`);
+}
+function buildClaudeExecArgs(input) {
+    const model = input.model.trim();
+    if (!model) {
+        throw new Error('agent_task_assignment_model_missing');
+    }
+    const permissionSettings = buildClaudePermissionSettings(input.denyReadRoots ?? []);
+    const tools = 'Bash,Edit,Write,Read,Glob,Grep';
+    const args = [
+        '-p',
+        '--model',
+        model,
+        '--output-format',
+        'stream-json',
+        '--verbose',
+        '--include-partial-messages',
+        '--no-session-persistence',
+        '--permission-mode',
+        'acceptEdits',
+        '--tools',
+        tools,
+        '--allowedTools',
+        ...CLAUDE_ALLOWED_PERMISSION_RULES,
+        '--disallowedTools',
+        ...buildClaudeDeniedPermissionRules(input.denyReadRoots ?? []),
+        '--settings',
+        JSON.stringify(permissionSettings),
+    ];
+    const pluginDir = typeof input.pluginDir === 'string' ? input.pluginDir.trim() : '';
+    if (pluginDir) {
+        args.push('--plugin-dir', pluginDir);
+    }
+    const effort = typeof input.effort === 'string' ? input.effort.trim() : '';
+    if (effort) {
+        args.push('--effort', effort);
+    }
+    return args;
+}
+const CLAUDE_ALLOWED_PERMISSION_RULES = [
+    'Read',
+    'Edit',
+    'Write',
+    'Glob',
+    'Grep',
+    'Bash',
+    'Bash(playdrop *)',
+    'Bash(./bin/playdrop *)',
+    'Bash(bin/playdrop *)',
+    'Bash(/Users/*/PlayDropWorker/tasks/*/bin/playdrop *)',
+    'Bash(node *)',
+    'Bash(npm *)',
+    'Bash(mkdir *)',
+    'Bash(cp *)',
+    'Bash(mv *)',
+    'Bash(file *)',
+    'Bash(sips *)',
+    'Bash(ls *)',
+    'Bash(pwd)',
+    'Bash(cat *)',
+    'Bash(head *)',
+    'Bash(tail *)',
+    'Bash(rg *)',
+    'Bash(grep *)',
+    'Bash(find *)',
+    'Bash(which *)',
+    'Bash(wc *)',
+    'Bash(stat *)',
+    'Bash(du *)',
+];
+function normalizeClaudePermissionPath(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return null;
+    }
+    return node_path_1.default.resolve(trimmed).replace(/\\/g, '/').replace(/\/+$/, '');
+}
+function buildClaudePermissionSettings(denyReadRoots = []) {
+    return {
+        permissions: {
+            allow: [...CLAUDE_ALLOWED_PERMISSION_RULES],
+            deny: buildClaudeDeniedPermissionRules(denyReadRoots),
+        },
+    };
+}
+function buildClaudeDeniedPermissionRules(denyReadRoots = []) {
+    const deny = new Set([
+        'Bash(rm *)',
+        'Bash(git *)',
+    ]);
+    for (const rawRoot of denyReadRoots) {
+        const root = normalizeClaudePermissionPath(rawRoot);
+        if (!root) {
+            continue;
+        }
+        deny.add(`Read(//${root.replace(/^\/+/, '')}/**)`);
+        deny.add(`Bash(* ${root}*)`);
+    }
+    return [...deny];
+}
+function buildWorkerChildEnv(input) {
+    const base = input.baseEnv ?? process.env;
+    const child = {};
+    for (const key of ['HOME', 'USER', 'SHELL', 'TMPDIR', 'LANG', 'TERM']) {
+        const value = base[key];
+        if (typeof value === 'string') {
+            child[key] = value;
+        }
+    }
+    for (const [key, value] of Object.entries(base)) {
+        if (key.startsWith('LC_') && typeof value === 'string') {
+            child[key] = value;
+        }
+    }
+    child.PATH = typeof base.PATH === 'string' && base.PATH
+        ? `${input.binDir}${node_path_1.default.delimiter}${base.PATH}`
+        : input.binDir;
+    for (const key of [
+        'PLAYDROP_API_BASE',
+        `PLAYDROP_API_BASE_${input.envName.toUpperCase()}`,
+        'PLAYDROP_AI_BASE',
+        `PLAYDROP_AI_BASE_${input.envName.toUpperCase()}`,
+    ]) {
+        const value = base[key];
+        if (typeof value === 'string') {
+            child[key] = value;
+        }
+    }
+    child.PLAYDROP_WORKER_CONTEXT = '1';
+    child.PLAYDROP_WORKER_TASK_ID = String(input.taskId);
+    if (input.devPort !== undefined) {
+        if (!Number.isInteger(input.devPort) || input.devPort <= 0 || input.devPort > 65535) {
+            throw new Error('invalid_worker_task_dev_port');
+        }
+        child.PLAYDROP_WORKER_TASK_DEV_PORT = String(input.devPort);
+        child.PLAYDROP_DEV_ROUTER_PORT = String(input.devPort);
+    }
+    if (input.eventDir?.trim()) {
+        child.PLAYDROP_WORKER_EVENT_DIR = input.eventDir.trim();
+    }
+    return child;
+}

package/dist/commands/worker.d.ts

@@ -0,0 +1,144 @@
+import type { ApiClient } from '@playdrop/api-client';
+import { type AgentExecutionTarget, type AgentRuntime, type AgentTaskResponse, type AgentWorkerCapabilities, type WorkerAgentTaskAssignmentResponse, type WorkerAgentTaskBaseSourceResponse, type WorkerAgentTaskWorkspaceFileResponse, type WorkerClaimAgentTaskResponse } from '@playdrop/types';
+import { type WorkerPlaydropAssetRequirement } from './upload';
+import { type LoggedProcessResult, type LoggedProcessTranscriptChunk } from './worker/runtime';
+export { DEFAULT_CODEX_TIMEOUT_MS, DEFAULT_WORKER_TOKEN_CAP, assertWorkerTokenUsageWithinCap, buildCodexExecArgs, buildClaudeExecArgs, buildClaudePermissionSettings, buildWorkerChildEnv, extractCodexTokensUsed, readEnvBoolean, readCodexSandboxMode, runLoggedProcess, } from './worker/runtime';
+export type { LoggedProcessResult, LoggedProcessTranscriptChunk, } from './worker/runtime';
+export declare const WORKER_SESSION_EXPIRED_MESSAGE = "worker session expired: run \"playdrop auth login\" and start the worker again";
+export declare const WORKER_CONTEXT_COMMAND_NOT_ALLOWED_MESSAGE = "worker_context_command_not_allowed: inside a PlayDrop worker task only task progress, task upload/done/fail, project validation/build/dev/capture, read-only catalogue/documentation lookup, and PlayDrop AI generation are permitted.";
+type WorkerStartOptions = {
+    env?: string;
+    once?: boolean;
+    name?: string;
+};
+type TaskReportOptions = {
+    env?: string;
+    phase?: string;
+    pct?: string | number;
+    message?: string;
+    kind?: string;
+};
+type TaskCatalogueReportOptions = {
+    env?: string;
+    file?: string;
+    message?: string;
+};
+type TaskCompleteOptions = {
+    env?: string;
+};
+type TaskUploadOptions = {
+    env?: string;
+};
+type TaskFailOptions = {
+    env?: string;
+    message?: string;
+};
+export type WorkerHealthAlertInput = {
+    state: 'started' | 'stopped' | 'crashed';
+    env: string;
+    workerName: string;
+    taskId?: number | null;
+    detail?: string | null;
+};
+type WorkerTaskState = {
+    taskId: number;
+    env: string;
+    target: AgentExecutionTarget;
+    leaseExpiresAt: string | null;
+    claimedAt: string;
+};
+export declare function allocateWorkerDevPort(input: {
+    activePorts: ReadonlySet<number>;
+    basePort?: number;
+    maxParallelTasks?: number;
+}): number;
+export declare function isWorkerContextCommandAllowed(argv: string[]): boolean;
+export declare function resolveWorkerExecutionTargetFromRole(role: unknown): AgentExecutionTarget;
+export declare function resolveWorkerClaimTaskAssignment(claim: WorkerClaimAgentTaskResponse): WorkerAgentTaskAssignmentResponse | null;
+export declare function nextClaimBackoffMs(currentMs: number): number;
+export declare function claimBackoffDelayMs(currentMs: number, random?: () => number): number;
+export declare function resolveWorkerHomeDir(): string;
+export declare function hasAgentTaskUploadedArtifact(task: Pick<AgentTaskResponse, 'appId' | 'appVersionId'>): boolean;
+export declare function appendWorkerTranscriptChunks(input: {
+    client: Pick<ApiClient, 'workerAppendAgentTaskTranscriptChunks'>;
+    taskId: number;
+    workerKey: string;
+    leaseToken: string;
+    chunks: LoggedProcessTranscriptChunk[];
+    batchSize?: number;
+}): Promise<void>;
+export declare function assertTaskUploadResultMatchesContext(input: {
+    taskContext: {
+        taskId: number;
+        creatorUsername: string;
+        outputAppName?: string | null;
+        outputVersion: string;
+    };
+    uploadResult: {
+        taskId: number;
+        appName: string;
+        version: string;
+        creatorUsername: string;
+    };
+}): void;
+export declare function stageAssignmentWorkspaceFiles(workspaceDir: string, files: readonly WorkerAgentTaskWorkspaceFileResponse[]): Promise<void>;
+export declare function resolvePlaydropPluginRoot(input?: {
+    homeDir?: string;
+    env?: NodeJS.ProcessEnv;
+}): string;
+export declare function stagePlaydropPluginReferences(input: {
+    workspaceDir: string;
+    pluginRoot: string;
+}): Promise<string[]>;
+export declare function discoverWorkerProjectRoot(workspaceDir: string): string;
+export declare function readWorkerTaskState(): WorkerTaskState | null;
+export declare function buildWorkerHealthAlertText(input: WorkerHealthAlertInput): string;
+export declare function isWorkerAuthFailureError(error: unknown): boolean;
+export declare function classifyWorkerEventDrainError(error: unknown): 'session_expired' | 'lease_invalid' | null;
+export declare function assertWorkerClaimErrorRetryable(error: unknown): void;
+export declare function resolvePlaydropAssetRequirementFromText(value: unknown): WorkerPlaydropAssetRequirement | null;
+export declare function loadWorkerEnvFile(envName: string | undefined, cwd?: string): string | null;
+export declare function buildWorkerCapabilities(input: string | {
+    codexVersion?: string | null;
+    codexAuthenticated?: boolean | null;
+    claudeVersion?: string | null;
+    claudeAuthenticated?: boolean | null;
+    npmVersion?: string | null;
+    playwright?: {
+        version?: string;
+        chromiumInstalled?: boolean;
+    } | null;
+    maxParallelTasks?: number | null;
+    runningTaskCount?: number | null;
+}): AgentWorkerCapabilities;
+export declare function buildWorkerClaimBody(input: {
+    workerKey: string;
+    capabilities: AgentWorkerCapabilities;
+    runningTaskCount?: number;
+}): {
+    workerKey: string;
+    capabilities: AgentWorkerCapabilities;
+};
+export type WorkerBaseApp = {
+    appName: string;
+    version: string;
+    appId: number;
+    appVersionId: number;
+};
+export declare function resolveWorkerBaseSource(value: WorkerAgentTaskBaseSourceResponse | null | undefined): WorkerBaseApp;
+export declare function extractZipArchive(zipBuffer: Uint8Array, targetDir: string): string[];
+export declare function readWorkerProjectVersion(projectDir: string, appName: string): string;
+export declare function buildCataloguePreviewPayload(cataloguePath: string, workspaceDir?: string): Record<string, unknown>;
+export declare function assertWorkerProjectVersionBumped(input: {
+    baseVersion: string;
+    projectVersion: string;
+    appName: string;
+}): void;
+export declare function buildAgentFailureCode(agent: AgentRuntime, result: LoggedProcessResult): string;
+export declare function describeAgentFailureForEvent(errorCode: string): string;
+export declare function startWorker(options?: WorkerStartOptions): Promise<void>;
+export declare function reportTask(options: TaskReportOptions): Promise<void>;
+export declare function reportCatalogueTask(options: TaskCatalogueReportOptions): Promise<void>;
+export declare function uploadTask(options?: TaskUploadOptions): Promise<void>;
+export declare function completeTask(options: TaskCompleteOptions): Promise<void>;
+export declare function failTask(options: TaskFailOptions): Promise<void>;