@playdrop/playdrop-cli 0.16.5 → 0.16.12

package/dist/commands/worker/archive-staging.js

@@ -0,0 +1,257 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractZipArchive = extractZipArchive;
+exports.stageWorkspaceArchiveInChild = stageWorkspaceArchiveInChild;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_process_1 = __importDefault(require("node:process"));
+const node_util_1 = require("node:util");
+const fflate_1 = require("fflate");
+const WORKSPACE_ARCHIVE_MAX_ENTRIES = 1000;
+const WORKSPACE_ARCHIVE_MAX_DOWNLOAD_BYTES = 256 * 1024 * 1024;
+const WORKSPACE_ARCHIVE_MAX_UNCOMPRESSED_BYTES = 100 * 1024 * 1024;
+const WORKSPACE_ARCHIVE_STAGER_MAX_OLD_SPACE_MB = 256;
+const WORKSPACE_ARCHIVE_STAGER_EXIT_GRACE_MS = 60000;
+const ZIP_CENTRAL_DIRECTORY_SIGNATURE = 0x02014b50;
+const ZIP_END_OF_CENTRAL_DIRECTORY_SIGNATURE = 0x06054b50;
+const ZIP_END_OF_CENTRAL_DIRECTORY_MIN_BYTES = 22;
+const ZIP_MAX_COMMENT_BYTES = 0xffff;
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+function normalizeStageInput(value) {
+    const input = value && typeof value === "object" && !Array.isArray(value) ? value : null;
+    const downloadUrl = typeof input?.downloadUrl === "string" ? input.downloadUrl.trim() : "";
+    const expectedSize = Number(input?.expectedSize);
+    const targetDir = typeof input?.targetDir === "string" ? input.targetDir.trim() : "";
+    const timeoutMs = Number(input?.timeoutMs);
+    if (!downloadUrl || !Number.isInteger(expectedSize) || expectedSize <= 0 || !node_path_1.default.isAbsolute(targetDir)) {
+        throw new Error("agent_task_workspace_archive_stager_input_invalid");
+    }
+    if (expectedSize > WORKSPACE_ARCHIVE_MAX_DOWNLOAD_BYTES) {
+        throw new Error(`agent_task_workspace_archive_download_too_large:${expectedSize}>${WORKSPACE_ARCHIVE_MAX_DOWNLOAD_BYTES}`);
+    }
+    if (!Number.isInteger(timeoutMs) || timeoutMs <= 0) {
+        throw new Error("agent_task_workspace_archive_download_timeout_invalid");
+    }
+    return { downloadUrl, expectedSize, targetDir, timeoutMs };
+}
+function assertWorkspaceArchiveExtractionBounds(buffer) {
+    if (buffer.length < ZIP_END_OF_CENTRAL_DIRECTORY_MIN_BYTES) {
+        throw new Error("agent_task_workspace_archive_invalid_zip");
+    }
+    const earliestEndRecordOffset = Math.max(0, buffer.length - ZIP_END_OF_CENTRAL_DIRECTORY_MIN_BYTES - ZIP_MAX_COMMENT_BYTES);
+    let endRecordOffset = -1;
+    for (let offset = buffer.length - ZIP_END_OF_CENTRAL_DIRECTORY_MIN_BYTES; offset >= earliestEndRecordOffset; offset -= 1) {
+        if (buffer.readUInt32LE(offset) === ZIP_END_OF_CENTRAL_DIRECTORY_SIGNATURE &&
+            offset + ZIP_END_OF_CENTRAL_DIRECTORY_MIN_BYTES + buffer.readUInt16LE(offset + 20) === buffer.length) {
+            endRecordOffset = offset;
+            break;
+        }
+    }
+    if (endRecordOffset < 0) {
+        throw new Error("agent_task_workspace_archive_invalid_zip");
+    }
+    const diskNumber = buffer.readUInt16LE(endRecordOffset + 4);
+    const centralDirectoryDisk = buffer.readUInt16LE(endRecordOffset + 6);
+    const diskEntryCount = buffer.readUInt16LE(endRecordOffset + 8);
+    const entryCount = buffer.readUInt16LE(endRecordOffset + 10);
+    const centralDirectorySize = buffer.readUInt32LE(endRecordOffset + 12);
+    const centralDirectoryOffset = buffer.readUInt32LE(endRecordOffset + 16);
+    if (diskNumber !== 0 ||
+        centralDirectoryDisk !== 0 ||
+        diskEntryCount !== entryCount ||
+        entryCount === 0xffff ||
+        centralDirectorySize === 0xffffffff ||
+        centralDirectoryOffset === 0xffffffff) {
+        throw new Error("agent_task_workspace_archive_unsupported_zip");
+    }
+    if (entryCount === 0) {
+        throw new Error("agent_task_workspace_archive_empty");
+    }
+    if (entryCount > WORKSPACE_ARCHIVE_MAX_ENTRIES) {
+        throw new Error(`agent_task_workspace_archive_too_many_entries:${entryCount}>${WORKSPACE_ARCHIVE_MAX_ENTRIES}`);
+    }
+    if (centralDirectoryOffset + centralDirectorySize !== endRecordOffset) {
+        throw new Error("agent_task_workspace_archive_invalid_zip");
+    }
+    let cursor = centralDirectoryOffset;
+    let uncompressedBytes = 0;
+    for (let entryIndex = 0; entryIndex < entryCount; entryIndex += 1) {
+        if (cursor + 46 > endRecordOffset || buffer.readUInt32LE(cursor) !== ZIP_CENTRAL_DIRECTORY_SIGNATURE) {
+            throw new Error("agent_task_workspace_archive_invalid_zip");
+        }
+        const compressedSize = buffer.readUInt32LE(cursor + 20);
+        const uncompressedSize = buffer.readUInt32LE(cursor + 24);
+        const fileNameLength = buffer.readUInt16LE(cursor + 28);
+        const extraFieldLength = buffer.readUInt16LE(cursor + 30);
+        const fileCommentLength = buffer.readUInt16LE(cursor + 32);
+        if (compressedSize === 0xffffffff || uncompressedSize === 0xffffffff) {
+            throw new Error("agent_task_workspace_archive_unsupported_zip");
+        }
+        const nextCursor = cursor + 46 + fileNameLength + extraFieldLength + fileCommentLength;
+        if (nextCursor > endRecordOffset) {
+            throw new Error("agent_task_workspace_archive_invalid_zip");
+        }
+        uncompressedBytes += uncompressedSize;
+        if (uncompressedBytes > WORKSPACE_ARCHIVE_MAX_UNCOMPRESSED_BYTES) {
+            throw new Error(`agent_task_workspace_archive_too_large:${uncompressedBytes}>${WORKSPACE_ARCHIVE_MAX_UNCOMPRESSED_BYTES}`);
+        }
+        cursor = nextCursor;
+    }
+    if (cursor !== endRecordOffset) {
+        throw new Error("agent_task_workspace_archive_invalid_zip");
+    }
+}
+// This synchronous work is intentionally executed only by the disposable archive
+// child. A malformed ZIP can terminate that child without blocking or terminating
+// the long-lived worker process that owns presence and task heartbeats.
+function extractZipArchive(zipBuffer, targetDir) {
+    assertWorkspaceArchiveExtractionBounds(Buffer.from(zipBuffer.buffer, zipBuffer.byteOffset, zipBuffer.byteLength));
+    const files = (0, fflate_1.unzipSync)(zipBuffer);
+    const names = Object.keys(files);
+    if (names.length === 0) {
+        throw new Error("agent_task_workspace_archive_empty");
+    }
+    if (names.length > WORKSPACE_ARCHIVE_MAX_ENTRIES) {
+        throw new Error(`agent_task_workspace_archive_too_many_entries:${names.length}>${WORKSPACE_ARCHIVE_MAX_ENTRIES}`);
+    }
+    const resolvedTarget = node_path_1.default.resolve(targetDir);
+    const written = [];
+    let uncompressedBytes = 0;
+    for (const originalName of names) {
+        const name = originalName.replace(/\\/g, "/");
+        if (!name || name.startsWith("/") || name.split("/").includes("..")) {
+            throw new Error(`agent_task_workspace_archive_unsafe_entry:${originalName}`);
+        }
+        const destination = node_path_1.default.resolve(resolvedTarget, name);
+        if (destination !== resolvedTarget && !destination.startsWith(resolvedTarget + node_path_1.default.sep)) {
+            throw new Error(`agent_task_workspace_archive_unsafe_entry:${originalName}`);
+        }
+        if (name.endsWith("/")) {
+            (0, node_fs_1.mkdirSync)(destination, { recursive: true });
+            continue;
+        }
+        uncompressedBytes += files[originalName].byteLength;
+        if (uncompressedBytes > WORKSPACE_ARCHIVE_MAX_UNCOMPRESSED_BYTES) {
+            throw new Error(`agent_task_workspace_archive_too_large:${uncompressedBytes}>${WORKSPACE_ARCHIVE_MAX_UNCOMPRESSED_BYTES}`);
+        }
+        (0, node_fs_1.mkdirSync)(node_path_1.default.dirname(destination), { recursive: true });
+        (0, node_fs_1.writeFileSync)(destination, Buffer.from(files[originalName]));
+        written.push(name);
+    }
+    return written;
+}
+async function downloadAndExtractWorkspaceArchive(input) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), input.timeoutMs);
+    const stagingRoot = await (0, promises_1.mkdtemp)(node_path_1.default.join(node_os_1.default.tmpdir(), "playdrop-workspace-archive-"));
+    const archivePath = node_path_1.default.join(stagingRoot, "archive.zip");
+    const extractedDir = node_path_1.default.join(stagingRoot, "contents");
+    try {
+        const response = await fetch(input.downloadUrl, { signal: controller.signal });
+        if (!response.ok) {
+            throw new Error(`agent_task_workspace_archive_http_error:${response.status}`);
+        }
+        const contentLength = response.headers.get("content-length");
+        if (contentLength !== null && Number(contentLength) !== input.expectedSize) {
+            throw new Error(`agent_task_workspace_archive_size_mismatch:${contentLength}!=${input.expectedSize}`);
+        }
+        if (!response.body) {
+            throw new Error("agent_task_workspace_archive_body_missing");
+        }
+        const reader = response.body.getReader();
+        const file = await (0, promises_1.open)(archivePath, "wx");
+        let receivedBytes = 0;
+        try {
+            while (true) {
+                const chunk = await reader.read();
+                if (chunk.done) {
+                    break;
+                }
+                const buffer = Buffer.from(chunk.value);
+                if (receivedBytes + buffer.length > input.expectedSize) {
+                    throw new Error(`agent_task_workspace_archive_size_mismatch:${receivedBytes + buffer.length}>${input.expectedSize}`);
+                }
+                let chunkOffset = 0;
+                while (chunkOffset < buffer.length) {
+                    const result = await file.write(buffer, chunkOffset, buffer.length - chunkOffset, receivedBytes + chunkOffset);
+                    if (result.bytesWritten <= 0) {
+                        throw new Error("agent_task_workspace_archive_write_failed");
+                    }
+                    chunkOffset += result.bytesWritten;
+                }
+                receivedBytes += buffer.length;
+            }
+        }
+        finally {
+            await file.close();
+        }
+        if (receivedBytes !== input.expectedSize) {
+            throw new Error(`agent_task_workspace_archive_size_mismatch:${receivedBytes}!=${input.expectedSize}`);
+        }
+        const buffer = await (0, promises_1.readFile)(archivePath);
+        await (0, promises_1.mkdir)(extractedDir, { recursive: true });
+        extractZipArchive(new Uint8Array(buffer), extractedDir);
+        await (0, promises_1.mkdir)(node_path_1.default.dirname(input.targetDir), { recursive: true });
+        await (0, promises_1.rm)(input.targetDir, { recursive: true, force: true });
+        await (0, promises_1.rename)(extractedDir, input.targetDir);
+    }
+    catch (error) {
+        if (controller.signal.aborted) {
+            throw new Error("agent_task_workspace_archive_download_timeout");
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+        await (0, promises_1.rm)(stagingRoot, { recursive: true, force: true });
+    }
+}
+function childFailureDetail(error) {
+    if (!error || typeof error !== "object") {
+        return String(error);
+    }
+    const detail = error;
+    const stderr = typeof detail.stderr === "string" ? detail.stderr.trim() : "";
+    if (stderr) {
+        return stderr.slice(0, 500);
+    }
+    if (typeof detail.signal === "string" && detail.signal) {
+        return `child_signal:${detail.signal}`;
+    }
+    return typeof detail.message === "string" ? detail.message : "archive_stager_failed";
+}
+async function stageWorkspaceArchiveInChild(input) {
+    const normalized = normalizeStageInput(input);
+    try {
+        await execFileAsync(node_process_1.default.execPath, [
+            `--max-old-space-size=${WORKSPACE_ARCHIVE_STAGER_MAX_OLD_SPACE_MB}`,
+            __filename,
+            JSON.stringify(normalized),
+        ], {
+            timeout: normalized.timeoutMs + WORKSPACE_ARCHIVE_STAGER_EXIT_GRACE_MS,
+            maxBuffer: 64 * 1024,
+        });
+    }
+    catch (error) {
+        throw new Error(`agent_task_workspace_archive_stager_failed:${childFailureDetail(error)}`);
+    }
+}
+async function runArchiveStagerChild() {
+    const rawInput = node_process_1.default.argv[2];
+    if (!rawInput) {
+        throw new Error("agent_task_workspace_archive_stager_input_missing");
+    }
+    await downloadAndExtractWorkspaceArchive(normalizeStageInput(JSON.parse(rawInput)));
+}
+if (require.main === module) {
+    void runArchiveStagerChild().catch((error) => {
+        node_process_1.default.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        node_process_1.default.exitCode = 1;
+    });
+}

package/dist/commands/worker/instrument-evidence.d.ts

@@ -1,4 +1,4 @@
-import { type InstrumentEvidenceCapture, type InstrumentEvidenceManifest } from '@playdrop/types';
+import { type InstrumentEvidenceCapture, type InstrumentEvidenceManifest } from "@playdrop/types";
 export declare const INSTRUMENT_EVIDENCE_MANIFEST_FILE = "instrument-evidence.json";
 export declare function createWorkerInstrumentScreenshotCollector(workspaceDir: string): {
     push: (chunk: string) => number;

package/dist/commands/worker/instrument-evidence.js

@@ -12,33 +12,33 @@ const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
 const sharp_1 = __importDefault(require("sharp"));
-const SCREENSHOT_STORE_DIR = '.playdrop-instrument-screenshots';
-const SCREENSHOT_INDEX_FILE = 'index.json';
-exports.INSTRUMENT_EVIDENCE_MANIFEST_FILE = 'instrument-evidence.json';
+const SCREENSHOT_STORE_DIR = ".playdrop-instrument-screenshots";
+const SCREENSHOT_INDEX_FILE = "index.json";
+exports.INSTRUMENT_EVIDENCE_MANIFEST_FILE = "instrument-evidence.json";
 const GROUP_ID_PATTERN = /^[a-z0-9][a-z0-9_-]{0,63}$/;
 const SHA256_PATTERN = /^[a-f0-9]{64}$/;
 function sha256(buffer) {
-    return (0, node_crypto_1.createHash)('sha256').update(buffer).digest('hex');
+    return (0, node_crypto_1.createHash)("sha256").update(buffer).digest("hex");
 }
 function isPathInside(parent, child) {
     const relative = node_path_1.default.relative(parent, child);
-    return relative === '' || (!!relative && !relative.startsWith('..') && !node_path_1.default.isAbsolute(relative));
+    return relative === "" || (!!relative && !relative.startsWith("..") && !node_path_1.default.isAbsolute(relative));
 }
 function writeJsonAtomic(filePath, value) {
     (0, node_fs_1.mkdirSync)(node_path_1.default.dirname(filePath), { recursive: true });
     const tempPath = `${filePath}.${process.pid}.tmp`;
-    (0, node_fs_1.writeFileSync)(tempPath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+    (0, node_fs_1.writeFileSync)(tempPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
     (0, node_fs_1.renameSync)(tempPath, filePath);
 }
 function readJsonRecord(filePath, code) {
     let parsed;
     try {
-        parsed = JSON.parse((0, node_fs_1.readFileSync)(filePath, 'utf8'));
+        parsed = JSON.parse((0, node_fs_1.readFileSync)(filePath, "utf8"));
     }
     catch (error) {
         throw new Error(`${code}:${error instanceof Error ? error.message : String(error)}`);
     }
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
         throw new Error(code);
     }
     return parsed;
@@ -54,20 +54,20 @@ function readScreenshotIndex(workspaceDir) {
     if (!(0, node_fs_1.existsSync)(filePath)) {
         return { version: 1, screenshots: {} };
     }
-    const parsed = readJsonRecord(filePath, 'invalid_instrument_screenshot_index');
-    const screenshots = parsed['screenshots'];
-    if (parsed['version'] !== 1 || !screenshots || typeof screenshots !== 'object' || Array.isArray(screenshots)) {
-        throw new Error('invalid_instrument_screenshot_index');
+    const parsed = readJsonRecord(filePath, "invalid_instrument_screenshot_index");
+    const screenshots = parsed["screenshots"];
+    if (parsed["version"] !== 1 || !screenshots || typeof screenshots !== "object" || Array.isArray(screenshots)) {
+        throw new Error("invalid_instrument_screenshot_index");
     }
     return parsed;
 }
 function extensionForMediaType(mediaType) {
-    return mediaType === 'image/jpeg' ? 'jpg' : 'png';
+    return mediaType === "image/jpeg" ? "jpg" : "png";
 }
 function createWorkerInstrumentScreenshotCollector(workspaceDir) {
     const resolvedWorkspace = node_path_1.default.resolve(workspaceDir);
     const store = (screenshot) => {
-        const buffer = Buffer.from(screenshot.dataBase64, 'base64');
+        const buffer = Buffer.from(screenshot.dataBase64, "base64");
         if (buffer.length <= 0) {
             throw new Error(`invalid_claude_screenshot_payload:${screenshot.screenshotId}`);
         }
@@ -109,7 +109,7 @@ function resolveLatestUnusedScreenshotId(workspaceDir, index) {
                 walk(entryPath);
             }
             else if (entry.name === exports.INSTRUMENT_EVIDENCE_MANIFEST_FILE) {
-                const manifest = readJsonRecord(entryPath, 'invalid_instrument_evidence_manifest');
+                const manifest = readJsonRecord(entryPath, "invalid_instrument_evidence_manifest");
                 for (const capture of Object.values(manifest.captures ?? {})) {
                     if (capture?.screenshotId) {
                         used.add(capture.screenshotId);
@@ -124,7 +124,7 @@ function resolveLatestUnusedScreenshotId(workspaceDir, index) {
         .sort((a, b) => a.capturedAt.localeCompare(b.capturedAt));
     const latest = candidates.at(-1);
     if (!latest) {
-        throw new Error('instrument_screenshot_none_available');
+        throw new Error("instrument_screenshot_none_available");
     }
     return latest.screenshotId;
 }
@@ -146,7 +146,7 @@ function resolveEvidenceDir(workspaceDir, evidenceDir) {
     const resolvedWorkspace = node_path_1.default.resolve(workspaceDir);
     const resolvedEvidenceDir = node_path_1.default.resolve(evidenceDir);
     if (!isPathInside(resolvedWorkspace, resolvedEvidenceDir)) {
-        throw new Error('instrument_evidence_dir_outside_workspace');
+        throw new Error("instrument_evidence_dir_outside_workspace");
     }
     return resolvedEvidenceDir;
 }
@@ -155,13 +155,13 @@ function readManifestIfPresent(evidenceDir) {
     if (!(0, node_fs_1.existsSync)(filePath)) {
         return null;
     }
-    return readJsonRecord(filePath, 'invalid_instrument_evidence_manifest');
+    return readJsonRecord(filePath, "invalid_instrument_evidence_manifest");
 }
 async function saveInstrumentEvidenceCapture(input) {
     const evidenceName = normalizeEvidenceName(input.name);
     const groupId = normalizeGroupId(input.groupId);
     const index = readScreenshotIndex(input.workspaceDir);
-    const requestedId = input.screenshotId?.trim() ?? '';
+    const requestedId = input.screenshotId?.trim() ?? "";
     // With no id, persist the capture the judge just took: the most recent one not already used as
     // evidence. The judge never has to track ids, and a failed capture simply is not there to pick.
     const screenshotId = requestedId || resolveLatestUnusedScreenshotId(input.workspaceDir, index);
@@ -207,28 +207,26 @@ async function saveInstrumentEvidenceCapture(input) {
     return capture;
 }
 function normalizeCapture(value, name) {
-    const capture = value && typeof value === 'object' && !Array.isArray(value)
-        ? value
-        : null;
-    const screenshotId = typeof capture?.['screenshotId'] === 'string' ? capture['screenshotId'].trim() : '';
-    const tabId = Number(capture?.['tabId']);
-    const toolUseId = typeof capture?.['toolUseId'] === 'string' ? capture['toolUseId'].trim() : '';
-    const mediaType = capture?.['mediaType'];
-    const fileName = typeof capture?.['fileName'] === 'string' ? capture['fileName'].trim() : '';
-    const hash = typeof capture?.['sha256'] === 'string' ? capture['sha256'].trim().toLowerCase() : '';
-    const sourceHash = typeof capture?.['sourceSha256'] === 'string' ? capture['sourceSha256'].trim().toLowerCase() : '';
-    const capturedAt = typeof capture?.['capturedAt'] === 'string' ? capture['capturedAt'].trim() : '';
-    if (capture?.['name'] !== name
-        || !screenshotId
-        || !Number.isInteger(tabId)
-        || tabId <= 0
-        || !toolUseId
-        || (mediaType !== 'image/jpeg' && mediaType !== 'image/png')
-        || node_path_1.default.basename(fileName) !== fileName
-        || !fileName
-        || !SHA256_PATTERN.test(sourceHash)
-        || !SHA256_PATTERN.test(hash)
-        || !capturedAt) {
+    const capture = value && typeof value === "object" && !Array.isArray(value) ? value : null;
+    const screenshotId = typeof capture?.["screenshotId"] === "string" ? capture["screenshotId"].trim() : "";
+    const tabId = Number(capture?.["tabId"]);
+    const toolUseId = typeof capture?.["toolUseId"] === "string" ? capture["toolUseId"].trim() : "";
+    const mediaType = capture?.["mediaType"];
+    const fileName = typeof capture?.["fileName"] === "string" ? capture["fileName"].trim() : "";
+    const hash = typeof capture?.["sha256"] === "string" ? capture["sha256"].trim().toLowerCase() : "";
+    const sourceHash = typeof capture?.["sourceSha256"] === "string" ? capture["sourceSha256"].trim().toLowerCase() : "";
+    const capturedAt = typeof capture?.["capturedAt"] === "string" ? capture["capturedAt"].trim() : "";
+    if (capture?.["name"] !== name ||
+        !screenshotId ||
+        !Number.isInteger(tabId) ||
+        tabId <= 0 ||
+        !toolUseId ||
+        (mediaType !== "image/jpeg" && mediaType !== "image/png") ||
+        node_path_1.default.basename(fileName) !== fileName ||
+        !fileName ||
+        !SHA256_PATTERN.test(sourceHash) ||
+        !SHA256_PATTERN.test(hash) ||
+        !capturedAt) {
         throw new Error(`invalid_instrument_evidence_capture:${name}`);
     }
     return {
@@ -247,12 +245,12 @@ function readAndValidateInstrumentEvidenceManifest(input) {
     const evidenceDir = resolveEvidenceDir(input.workspaceDir, input.evidenceDir);
     const parsed = readManifestIfPresent(evidenceDir);
     if (!parsed || parsed.version !== 1) {
-        throw new Error('missing_instrument_evidence_manifest');
+        throw new Error("missing_instrument_evidence_manifest");
     }
     const groupId = normalizeGroupId(parsed.groupId);
     const controlledTabId = Number(parsed.controlledTabId);
     if (!Number.isInteger(controlledTabId) || controlledTabId <= 0) {
-        throw new Error('invalid_instrument_evidence_tab');
+        throw new Error("invalid_instrument_evidence_tab");
     }
     const captures = {};
     const screenshotIds = new Set();

package/dist/commands/worker/provider-telemetry.d.ts

@@ -1,4 +1,4 @@
-import type { AgentRuntime, AgentWorkerCapabilities, AgentWorkerWeeklyUsage, AgentWorkerWeeklyUsageStatus } from '@playdrop/types';
+import type { AgentRuntime, AgentWorkerCapabilities, AgentWorkerWeeklyUsage, AgentWorkerWeeklyUsageStatus } from "@playdrop/types";
 export interface WorkerAgentProviderTelemetry {
     account: string | null;
     plan: string | null;
@@ -12,6 +12,7 @@ export declare function calculateWeeklyUsageRouting(remainingPercent: number, re
 } | null;
 export declare function buildCodexProviderTelemetry(accountResult: unknown, rateLimitsResult: unknown, checkedAt: string): WorkerAgentProviderTelemetry;
 export declare function buildClaudeProviderTelemetry(authStatus: unknown, credentialMetadata: unknown, usageResult: unknown, checkedAt: string): WorkerAgentProviderTelemetry;
+export declare function buildGrokProviderTelemetry(authEntryValue: unknown, billingResult: unknown, checkedAt: string): WorkerAgentProviderTelemetry;
 export declare function probeWorkerProviderTelemetry(capabilities: AgentWorkerCapabilities): Promise<Partial<Record<AgentRuntime, WorkerAgentProviderTelemetry>>>;
 export declare function mergeWorkerProviderTelemetry(capabilities: AgentWorkerCapabilities, telemetry: Partial<Record<AgentRuntime, WorkerAgentProviderTelemetry>>): AgentWorkerCapabilities;
 export declare function preserveWorkerProviderTelemetry(capabilities: AgentWorkerCapabilities, previous: AgentWorkerCapabilities): AgentWorkerCapabilities;