@playdrop/playdrop-cli 0.16.5 → 0.16.11

package/dist/commands/worker/provider-telemetry.js

@@ -6,10 +6,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.calculateWeeklyUsageRouting = calculateWeeklyUsageRouting;
 exports.buildCodexProviderTelemetry = buildCodexProviderTelemetry;
 exports.buildClaudeProviderTelemetry = buildClaudeProviderTelemetry;
+exports.buildGrokProviderTelemetry = buildGrokProviderTelemetry;
 exports.probeWorkerProviderTelemetry = probeWorkerProviderTelemetry;
 exports.mergeWorkerProviderTelemetry = mergeWorkerProviderTelemetry;
 exports.preserveWorkerProviderTelemetry = preserveWorkerProviderTelemetry;
 const node_child_process_1 = require("node:child_process");
+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 clientInfo_1 = require("../../clientInfo");
@@ -19,15 +23,13 @@ const WEEKLY_WINDOW_MINUTES = 7 * 24 * 60;
 const WEEKLY_WINDOW_MS = 7 * 24 * 60 * 60 * 1000;
 const WEEKLY_USAGE_RESERVE_PERCENT = 10;
 function asObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value)
-        ? value
-        : null;
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
 }
 function optionalString(value) {
-    return typeof value === 'string' && value.trim() ? value.trim() : null;
+    return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 function normalizePercent(value, field) {
-    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0 || value > 100) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 100) {
         throw new Error(`${field}_invalid`);
     }
     return Math.round(value * 10) / 10;
@@ -41,11 +43,10 @@ function calculateWeeklyUsageRouting(remainingPercent, resetsAt, checkedAt) {
     const resetMs = new Date(resetsAt).getTime();
     const checkedMs = new Date(checkedAt).getTime();
     if (!Number.isFinite(resetMs) || !Number.isFinite(checkedMs)) {
-        throw new Error('worker_weekly_usage_routing_time_invalid');
+        throw new Error("worker_weekly_usage_routing_time_invalid");
     }
     const remainingWindowRatio = Math.max(0, Math.min(1, (resetMs - checkedMs) / WEEKLY_WINDOW_MS));
-    const targetRemainingPercent = roundPercent(WEEKLY_USAGE_RESERVE_PERCENT
-        + (100 - WEEKLY_USAGE_RESERVE_PERCENT) * remainingWindowRatio);
+    const targetRemainingPercent = roundPercent(WEEKLY_USAGE_RESERVE_PERCENT + (100 - WEEKLY_USAGE_RESERVE_PERCENT) * remainingWindowRatio);
     return {
         targetRemainingPercent,
         surplusPercent: roundPercent(remainingPercent - targetRemainingPercent),
@@ -56,15 +57,15 @@ function unavailableTelemetry(checkedAt) {
         account: null,
         plan: null,
         weeklyUsage: null,
-        weeklyUsageStatus: 'UNAVAILABLE',
+        weeklyUsageStatus: "UNAVAILABLE",
         telemetryCheckedAt: checkedAt,
     };
 }
 function accountTypeLabel(type) {
-    if (type === 'apiKey')
-        return 'API key';
-    if (type === 'amazonBedrock')
-        return 'Amazon Bedrock';
+    if (type === "apiKey")
+        return "API key";
+    if (type === "amazonBedrock")
+        return "Amazon Bedrock";
     return type;
 }
 function readCodexWeeklyWindow(rateLimitsResult) {
@@ -89,12 +90,12 @@ function buildCodexProviderTelemetry(accountResult, rateLimitsResult, checkedAt)
     const accountType = optionalString(account.type);
     const accountLabel = optionalString(account.email) ?? accountTypeLabel(accountType);
     const plan = optionalString(account.planType);
-    if (accountType !== 'chatgpt') {
+    if (accountType !== "chatgpt") {
         return {
             account: accountLabel,
             plan,
             weeklyUsage: null,
-            weeklyUsageStatus: 'NOT_APPLICABLE',
+            weeklyUsageStatus: "NOT_APPLICABLE",
             telemetryCheckedAt: checkedAt,
         };
     }
@@ -104,15 +105,15 @@ function buildCodexProviderTelemetry(accountResult, rateLimitsResult, checkedAt)
             account: accountLabel,
             plan,
             weeklyUsage: null,
-            weeklyUsageStatus: 'UNAVAILABLE',
+            weeklyUsageStatus: "UNAVAILABLE",
             telemetryCheckedAt: checkedAt,
         };
     }
-    const usedPercent = normalizePercent(weeklyWindow.usedPercent, 'codex_weekly_usage');
+    const usedPercent = normalizePercent(weeklyWindow.usedPercent, "codex_weekly_usage");
     const remainingPercent = roundPercent(100 - usedPercent);
     const resetsAtSeconds = weeklyWindow.resetsAt;
-    if (typeof resetsAtSeconds !== 'number' || !Number.isFinite(resetsAtSeconds) || resetsAtSeconds <= 0) {
-        throw new Error('codex_weekly_reset_invalid');
+    if (typeof resetsAtSeconds !== "number" || !Number.isFinite(resetsAtSeconds) || resetsAtSeconds <= 0) {
+        throw new Error("codex_weekly_reset_invalid");
     }
     const resetsAt = new Date(resetsAtSeconds * 1000).toISOString();
     return {
@@ -124,14 +125,14 @@ function buildCodexProviderTelemetry(accountResult, rateLimitsResult, checkedAt)
             resetsAt,
             ...calculateWeeklyUsageRouting(remainingPercent, resetsAt, checkedAt),
         },
-        weeklyUsageStatus: 'AVAILABLE',
+        weeklyUsageStatus: "AVAILABLE",
         telemetryCheckedAt: checkedAt,
     };
 }
 function claudePlanLabel(subscriptionType, rateLimitTier) {
     const tierMatch = rateLimitTier?.match(/^default_claude_(pro|max)(?:_(\d+)x)?$/i);
     if (tierMatch) {
-        const name = tierMatch[1]?.toLowerCase() === 'max' ? 'Max' : 'Pro';
+        const name = tierMatch[1]?.toLowerCase() === "max" ? "Max" : "Pro";
         return tierMatch[2] ? `${name} ${tierMatch[2]}x` : name;
     }
     if (!subscriptionType)
@@ -148,7 +149,7 @@ function buildClaudeProviderTelemetry(authStatus, credentialMetadata, usageResul
             account,
             plan,
             weeklyUsage: null,
-            weeklyUsageStatus: 'UNAVAILABLE',
+            weeklyUsageStatus: "UNAVAILABLE",
             telemetryCheckedAt: checkedAt,
         };
     }
@@ -158,21 +159,19 @@ function buildClaudeProviderTelemetry(authStatus, credentialMetadata, usageResul
             account,
             plan,
             weeklyUsage: null,
-            weeklyUsageStatus: 'UNAVAILABLE',
+            weeklyUsageStatus: "UNAVAILABLE",
             telemetryCheckedAt: checkedAt,
         };
     }
-    const usedPercent = normalizePercent(sevenDay.utilization, 'claude_weekly_usage');
+    const usedPercent = normalizePercent(sevenDay.utilization, "claude_weekly_usage");
     const remainingPercent = roundPercent(100 - usedPercent);
     const rawReset = sevenDay.resets_at;
-    const resetsAt = rawReset === null
-        ? null
-        : optionalString(rawReset);
+    const resetsAt = rawReset === null ? null : optionalString(rawReset);
     if (rawReset !== null && !resetsAt) {
-        throw new Error('claude_weekly_reset_invalid');
+        throw new Error("claude_weekly_reset_invalid");
     }
     if (resetsAt && Number.isNaN(new Date(resetsAt).getTime())) {
-        throw new Error('claude_weekly_reset_invalid');
+        throw new Error("claude_weekly_reset_invalid");
     }
     return {
         account,
@@ -183,15 +182,72 @@ function buildClaudeProviderTelemetry(authStatus, credentialMetadata, usageResul
             resetsAt: resetsAt ? new Date(resetsAt).toISOString() : null,
             ...calculateWeeklyUsageRouting(remainingPercent, resetsAt ? new Date(resetsAt).toISOString() : null, checkedAt),
         },
-        weeklyUsageStatus: 'AVAILABLE',
+        weeklyUsageStatus: "AVAILABLE",
+        telemetryCheckedAt: checkedAt,
+    };
+}
+function readGrokTier(authEntry) {
+    const token = optionalString(authEntry?.key);
+    const payload = token?.split(".")[1];
+    if (!payload)
+        return null;
+    try {
+        const claims = asObject(JSON.parse(Buffer.from(payload, "base64url").toString("utf8")));
+        return typeof claims?.tier === "number" && Number.isFinite(claims.tier) ? claims.tier : null;
+    }
+    catch {
+        return null;
+    }
+}
+function grokPlanLabel(authEntry, billingConfig) {
+    const configured = optionalString(billingConfig?.subscriptionTier) ?? optionalString(billingConfig?.plan);
+    if (configured)
+        return configured;
+    const tier = readGrokTier(authEntry);
+    if (tier === 4)
+        return "X Premium+";
+    return tier === null ? null : `Tier ${tier}`;
+}
+function buildGrokProviderTelemetry(authEntryValue, billingResult, checkedAt) {
+    const authEntry = asObject(authEntryValue);
+    const billingConfig = asObject(asObject(billingResult)?.config);
+    const account = optionalString(authEntry?.email);
+    const plan = grokPlanLabel(authEntry, billingConfig);
+    if (!authEntry || !optionalString(authEntry.key) || !billingConfig) {
+        return {
+            account,
+            plan,
+            weeklyUsage: null,
+            weeklyUsageStatus: "UNAVAILABLE",
+            telemetryCheckedAt: checkedAt,
+        };
+    }
+    const currentPeriod = asObject(billingConfig.currentPeriod);
+    const usedPercent = normalizePercent(billingConfig.creditUsagePercent, "grok_weekly_usage");
+    const rawReset = optionalString(currentPeriod?.end);
+    if (!rawReset || Number.isNaN(new Date(rawReset).getTime())) {
+        throw new Error("grok_weekly_reset_invalid");
+    }
+    const resetsAt = new Date(rawReset).toISOString();
+    const remainingPercent = roundPercent(100 - usedPercent);
+    return {
+        account,
+        plan,
+        weeklyUsage: {
+            usedPercent,
+            remainingPercent,
+            resetsAt,
+            ...calculateWeeklyUsageRouting(remainingPercent, resetsAt, checkedAt),
+        },
+        weeklyUsageStatus: "AVAILABLE",
         telemetryCheckedAt: checkedAt,
     };
 }
 function runCodexAccountRequests() {
     return new Promise((resolve, reject) => {
-        const child = (0, node_child_process_1.spawn)('codex', ['app-server'], { stdio: ['pipe', 'pipe', 'pipe'] });
+        const child = (0, node_child_process_1.spawn)("codex", ["app-server"], { stdio: ["pipe", "pipe", "pipe"] });
         let settled = false;
-        let stdoutBuffer = '';
+        let stdoutBuffer = "";
         let accountReceived = false;
         let rateLimitsReceived = false;
         let accountResult;
@@ -210,17 +266,17 @@ function runCodexAccountRequests() {
             }
         };
         const timeout = setTimeout(() => {
-            finish(new Error('codex_telemetry_timeout'));
+            finish(new Error("codex_telemetry_timeout"));
         }, PROVIDER_TELEMETRY_TIMEOUT_MS);
-        child.once('error', () => finish(new Error('codex_app_server_unavailable')));
-        child.once('close', () => {
+        child.once("error", () => finish(new Error("codex_app_server_unavailable")));
+        child.once("close", () => {
             if (!settled)
-                finish(new Error('codex_app_server_closed'));
+                finish(new Error("codex_app_server_closed"));
         });
-        child.stdout.on('data', (chunk) => {
+        child.stdout.on("data", (chunk) => {
             stdoutBuffer += chunk.toString();
-            while (stdoutBuffer.includes('\n')) {
-                const newline = stdoutBuffer.indexOf('\n');
+            while (stdoutBuffer.includes("\n")) {
+                const newline = stdoutBuffer.indexOf("\n");
                 const line = stdoutBuffer.slice(0, newline).trim();
                 stdoutBuffer = stdoutBuffer.slice(newline + 1);
                 if (!line)
@@ -229,18 +285,18 @@ function runCodexAccountRequests() {
                 try {
                     const parsed = asObject(JSON.parse(line));
                     if (!parsed)
-                        throw new Error('invalid_message');
+                        throw new Error("invalid_message");
                     message = parsed;
                 }
                 catch {
-                    finish(new Error('codex_app_server_response_invalid'));
+                    finish(new Error("codex_app_server_response_invalid"));
                     return;
                 }
                 if (message.id !== 1 && message.id !== 2)
                     continue;
                 if (message.error) {
                     if (message.id === 1) {
-                        finish(new Error('codex_account_request_failed'));
+                        finish(new Error("codex_account_request_failed"));
                         return;
                     }
                     rateLimitsReceived = true;
@@ -261,22 +317,22 @@ function runCodexAccountRequests() {
                     finish();
             }
         });
-        child.once('spawn', () => {
+        child.once("spawn", () => {
             const messages = [
                 {
-                    method: 'initialize',
+                    method: "initialize",
                     id: 0,
                     params: {
                         clientInfo: {
-                            name: 'playdrop_worker',
-                            title: 'PlayDrop Worker',
+                            name: "playdrop_worker",
+                            title: "PlayDrop Worker",
                             version: (0, clientInfo_1.getCliVersion)(),
                         },
                     },
                 },
-                { method: 'initialized', params: {} },
-                { method: 'account/read', id: 1, params: { refreshToken: false } },
-                { method: 'account/rateLimits/read', id: 2 },
+                { method: "initialized", params: {} },
+                { method: "account/read", id: 1, params: { refreshToken: false } },
+                { method: "account/rateLimits/read", id: 2 },
             ];
             for (const message of messages) {
                 child.stdin.write(`${JSON.stringify(message)}\n`);
@@ -285,25 +341,28 @@ function runCodexAccountRequests() {
     });
 }
 async function readClaudeAuthStatus() {
-    const { stdout } = await execFileAsync('claude', ['auth', 'status', '--json'], {
+    const { stdout } = await execFileAsync("claude", ["auth", "status", "--json"], {
         timeout: PROVIDER_TELEMETRY_TIMEOUT_MS,
         maxBuffer: 1024 * 1024,
     });
     const parsed = asObject(JSON.parse(stdout));
     if (!parsed)
-        throw new Error('claude_auth_status_invalid');
+        throw new Error("claude_auth_status_invalid");
     return parsed;
 }
 async function readClaudeCredentialState() {
-    if (node_process_1.default.platform !== 'darwin') {
-        throw new Error('claude_usage_requires_macos_keychain');
+    if (node_process_1.default.platform !== "darwin") {
+        throw new Error("claude_usage_requires_macos_keychain");
     }
-    const { stdout } = await execFileAsync('security', ['find-generic-password', '-s', 'Claude Code-credentials', '-w'], { timeout: PROVIDER_TELEMETRY_TIMEOUT_MS, maxBuffer: 1024 * 1024 });
+    const { stdout } = await execFileAsync("security", ["find-generic-password", "-s", "Claude Code-credentials", "-w"], {
+        timeout: PROVIDER_TELEMETRY_TIMEOUT_MS,
+        maxBuffer: 1024 * 1024,
+    });
     const oauth = asObject(asObject(JSON.parse(stdout))?.claudeAiOauth);
     const accessToken = optionalString(oauth?.accessToken);
     const expiresAt = oauth?.expiresAt;
-    if (!accessToken || typeof expiresAt !== 'number' || !Number.isFinite(expiresAt)) {
-        throw new Error('claude_oauth_credentials_invalid');
+    if (!accessToken || typeof expiresAt !== "number" || !Number.isFinite(expiresAt)) {
+        throw new Error("claude_oauth_credentials_invalid");
     }
     return {
         accessToken,
@@ -312,7 +371,10 @@ async function readClaudeCredentialState() {
     };
 }
 async function refreshClaudeAccessToken() {
-    await execFileAsync('claude', ['--print', '--output-format', 'json', '--max-turns', '1', '/model'], { timeout: PROVIDER_TELEMETRY_TIMEOUT_MS, maxBuffer: 1024 * 1024 });
+    await execFileAsync("claude", ["--print", "--output-format", "json", "--max-turns", "1", "/model"], {
+        timeout: PROVIDER_TELEMETRY_TIMEOUT_MS,
+        maxBuffer: 1024 * 1024,
+    });
 }
 async function probeCodexProviderTelemetry(checkedAt) {
     const result = await runCodexAccountRequests();
@@ -332,11 +394,11 @@ async function probeClaudeProviderTelemetry(checkedAt, claudeVersion) {
     const timeout = setTimeout(() => controller.abort(), PROVIDER_TELEMETRY_TIMEOUT_MS);
     try {
         try {
-            const response = await fetch('https://api.anthropic.com/api/oauth/usage', {
+            const response = await fetch("https://api.anthropic.com/api/oauth/usage", {
                 headers: {
                     authorization: `Bearer ${credentials.accessToken}`,
-                    'anthropic-beta': 'oauth-2025-04-20',
-                    'user-agent': `claude-code/${claudeVersion ?? 'unknown'}`,
+                    "anthropic-beta": "oauth-2025-04-20",
+                    "user-agent": `claude-code/${claudeVersion ?? "unknown"}`,
                 },
                 signal: controller.signal,
             });
@@ -353,10 +415,52 @@ async function probeClaudeProviderTelemetry(checkedAt, claudeVersion) {
         clearTimeout(timeout);
     }
 }
+async function readGrokAuthEntry() {
+    const grokHome = node_process_1.default.env.GROK_HOME?.trim() || node_path_1.default.join(node_os_1.default.homedir(), ".grok");
+    const authPath = node_process_1.default.env.GROK_AUTH_PATH?.trim() || node_path_1.default.join(grokHome, "auth.json");
+    if (!node_path_1.default.isAbsolute(authPath))
+        throw new Error("invalid_grok_auth_path");
+    const parsed = asObject(JSON.parse(await (0, promises_1.readFile)(authPath, "utf8")));
+    const entry = parsed
+        ? Object.values(parsed)
+            .map(asObject)
+            .find((candidate) => {
+            const authMode = optionalString(candidate?.auth_mode)?.toLowerCase();
+            return (authMode === "oidc" || authMode === "oauth") && Boolean(optionalString(candidate?.key));
+        })
+        : null;
+    if (!entry)
+        throw new Error("grok_oauth_credentials_invalid");
+    return entry;
+}
+async function probeGrokProviderTelemetry(checkedAt) {
+    const authEntry = await readGrokAuthEntry();
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), PROVIDER_TELEMETRY_TIMEOUT_MS);
+    try {
+        const response = await fetch("https://cli-chat-proxy.grok.com/v1/billing?format=credits", {
+            headers: {
+                authorization: `Bearer ${optionalString(authEntry.key)}`,
+                "x-grok-client-mode": "headless",
+            },
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`grok_billing_http_${response.status}`);
+        }
+        return buildGrokProviderTelemetry(authEntry, await response.json(), checkedAt);
+    }
+    catch {
+        return buildGrokProviderTelemetry(authEntry, null, checkedAt);
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
 async function probeWorkerProviderTelemetry(capabilities) {
     const checkedAt = new Date().toISOString();
     const results = await Promise.all(capabilities.agents.map(async (agent) => {
-        if (agent.agent === 'CODEX') {
+        if (agent.agent === "CODEX") {
             try {
                 return [agent.agent, await probeCodexProviderTelemetry(checkedAt)];
             }
@@ -364,7 +468,7 @@ async function probeWorkerProviderTelemetry(capabilities) {
                 return [agent.agent, unavailableTelemetry(checkedAt)];
             }
         }
-        if (agent.agent === 'CLAUDE_CODE') {
+        if (agent.agent === "CLAUDE_CODE") {
             try {
                 return [agent.agent, await probeClaudeProviderTelemetry(checkedAt, agent.cliVersion ?? null)];
             }
@@ -378,6 +482,14 @@ async function probeWorkerProviderTelemetry(capabilities) {
                 ];
             }
         }
+        if (agent.agent === "GROK_BUILD") {
+            try {
+                return [agent.agent, await probeGrokProviderTelemetry(checkedAt)];
+            }
+            catch {
+                return [agent.agent, unavailableTelemetry(checkedAt)];
+            }
+        }
         return null;
     }));
     return Object.fromEntries(results.filter((entry) => entry !== null));
@@ -403,13 +515,18 @@ function preserveWorkerProviderTelemetry(capabilities, previous) {
     const telemetry = Object.fromEntries(previous.agents.flatMap((agent) => {
         if (!agent.weeklyUsageStatus || !agent.telemetryCheckedAt)
             return [];
-        return [[agent.agent, {
+        return [
+            [
+                agent.agent,
+                {
                     account: agent.account ?? null,
                     plan: agent.plan ?? null,
                     weeklyUsage: agent.weeklyUsage ?? null,
                     weeklyUsageStatus: agent.weeklyUsageStatus,
                     telemetryCheckedAt: agent.telemetryCheckedAt,
-                }]];
+                },
+            ],
+        ];
     }));
     return mergeWorkerProviderTelemetry(capabilities, telemetry);
 }

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

@@ -14,6 +14,7 @@ export type LoggedProcessResult = {
     tokenUsage: AgentTokenUsage;
     tokensUsed: number | null;
     providerSessionId?: string | null;
+    providerResolvedModel?: string | null;
 };
 export type AgentTokenUsage = {
     inputTokens: number | null;
@@ -25,7 +26,7 @@ export type AgentTokenUsage = {
     usageParseError: string | null;
 };
 export type LoggedProcessTranscriptChunk = {
-    stream: 'stdout' | 'stderr';
+    stream: "stdout" | "stderr";
     content: string;
 };
 export declare function resolveDescendantProcessIds(processTable: string, rootPid: number): number[];
@@ -35,6 +36,12 @@ export declare function extractAgentTokenUsage(output: string): AgentTokenUsage;
 export declare function extractCodexRolloutTokenUsage(output: string): AgentTokenUsage;
 export declare function extractCodexThreadId(output: string): string | null;
 export declare function extractClaudeSessionId(output: string): string | null;
+export type GrokRunMetadata = {
+    sessionId: string | null;
+    resolvedRuntimeModel: string | null;
+    tokenUsage: AgentTokenUsage;
+};
+export declare function extractGrokRunMetadata(output: string): GrokRunMetadata;
 export type CodexRolloutTokenUsageReadOptions = {
     sessionsRoot?: string;
     deleteAfterRead?: boolean;
@@ -69,7 +76,15 @@ export declare function buildCodexExecArgs(input: {
     imagePaths?: string[];
     resumeSessionId?: string | null;
 }): string[];
-export type CodexSandboxMode = 'danger-full-access' | 'workspace-write' | 'read-only';
+export declare function buildGrokExecArgs(input: {
+    workspaceDir: string;
+    promptFile?: string | null;
+    promptJson?: string | null;
+    model: string;
+    reasoningEffort: string;
+    resumeSessionId?: string | null;
+}): 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;
@@ -84,7 +99,7 @@ export declare function buildClaudeExecArgs(input: {
     resumeSessionId?: string | null;
 }): string[];
 export declare const PLAYWRIGHT_MCP_VERSION = "0.0.78";
-export type WorkerInstrumentSurface = 'DESKTOP' | 'MOBILE_LANDSCAPE' | 'MOBILE_PORTRAIT';
+export type WorkerInstrumentSurface = "DESKTOP" | "MOBILE_LANDSCAPE" | "MOBILE_PORTRAIT";
 export declare function resolvePlaywrightMcpCliPath(): string;
 export declare function buildPlaywrightMcpCommand(surface?: WorkerInstrumentSurface | null): {
     command: string;