@playdrop/playdrop-cli 0.9.6 → 0.10.1

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,81 @@
+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;
+    tokenUsage: AgentTokenUsage;
+    tokensUsed: number | null;
+};
+export type AgentTokenUsage = {
+    inputTokens: number | null;
+    outputTokens: number | null;
+    cacheCreationInputTokens: number | null;
+    cacheReadInputTokens: number | null;
+    totalTokens: number | null;
+    rawProviderUsage: Record<string, unknown> | null;
+    usageParseError: string | 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 extractAgentTokenUsage(output: string): AgentTokenUsage;
+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;
+    attempt: number;
+    envName: string;
+    eventDir?: string;
+    devPort?: number;
+    baseEnv?: NodeJS.ProcessEnv;
+}): NodeJS.ProcessEnv;

package/dist/commands/worker/runtime.js

@@ -0,0 +1,458 @@
+"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.extractAgentTokenUsage = extractAgentTokenUsage;
+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 normalizeTokenCount(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
+        return null;
+    }
+    return Math.ceil(value);
+}
+function coerceRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+function readStructuredUsage(parsed) {
+    const root = coerceRecord(parsed);
+    if (!root) {
+        return null;
+    }
+    const directUsage = coerceRecord(root.usage);
+    if (directUsage) {
+        return directUsage;
+    }
+    const message = coerceRecord(root.message);
+    const messageUsage = coerceRecord(message?.usage);
+    if (messageUsage) {
+        return messageUsage;
+    }
+    const event = coerceRecord(root.event);
+    const eventUsage = coerceRecord(event?.usage);
+    if (eventUsage) {
+        return eventUsage;
+    }
+    const eventMessage = coerceRecord(event?.message);
+    const eventMessageUsage = coerceRecord(eventMessage?.usage);
+    if (eventMessageUsage) {
+        return eventMessageUsage;
+    }
+    return null;
+}
+function extractAgentTokenUsage(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 = readStructuredUsage(parsed);
+            if (!usage) {
+                continue;
+            }
+            const inputTokens = normalizeTokenCount(usage.input_tokens);
+            const outputTokens = normalizeTokenCount(usage.output_tokens);
+            const cacheCreationInputTokens = normalizeTokenCount(usage.cache_creation_input_tokens);
+            const cacheReadInputTokens = normalizeTokenCount(usage.cache_read_input_tokens);
+            const tokenParts = [
+                inputTokens,
+                outputTokens,
+                cacheCreationInputTokens,
+                cacheReadInputTokens,
+            ];
+            const sawTokenValue = tokenParts.some((value) => value !== null);
+            if (sawTokenValue) {
+                return {
+                    inputTokens,
+                    outputTokens,
+                    cacheCreationInputTokens,
+                    cacheReadInputTokens,
+                    totalTokens: tokenParts.reduce((sum, value) => sum + (value ?? 0), 0),
+                    rawProviderUsage: usage,
+                    usageParseError: null,
+                };
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return {
+        inputTokens: null,
+        outputTokens: null,
+        cacheCreationInputTokens: null,
+        cacheReadInputTokens: null,
+        totalTokens: null,
+        rawProviderUsage: null,
+        usageParseError: 'agent_usage_not_reported',
+    };
+}
+function extractCodexTokensUsed(output) {
+    return extractAgentTokenUsage(output).totalTokens;
+}
+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);
+                const tokenUsage = extractAgentTokenUsage(`${stdout}\n${stderr}\n${outputTail}`);
+                resolve({
+                    exitCode: code,
+                    signal,
+                    stdout,
+                    stderr,
+                    outputTail,
+                    timedOut,
+                    tokenUsage,
+                    tokensUsed: tokenUsage.totalTokens,
+                });
+            })().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';
+    if (!Number.isInteger(input.attempt) || input.attempt <= 0) {
+        throw new Error('invalid_worker_task_attempt');
+    }
+    child.PLAYDROP_WORKER_TASK_ID = String(input.taskId);
+    child.PLAYDROP_WORKER_TASK_ATTEMPT = String(input.attempt);
+    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;
+}