@playdrop/playdrop-cli 0.15.29 → 0.15.30

package/config/client-meta.json

@@ -1,8 +1,8 @@
 {
-  "version": "0.15.29",
-  "build": 12,
-  "runtimeSdkVersion": "0.15.29",
-  "runtimeSdkBuild": 12,
+  "version": "0.15.30",
+  "build": 13,
+  "runtimeSdkVersion": "0.15.30",
+  "runtimeSdkBuild": 13,
   "clients": {
     "all": {
       "minimumVersion": "0.7.4"

package/dist/commands/chat.d.ts

@@ -0,0 +1,27 @@
+export type ChatCommonOptions = {
+    env?: string;
+    json?: boolean;
+};
+export type ChatWriteCommandOptions = ChatCommonOptions & {
+    text?: string;
+    textFile?: string;
+    file?: string[];
+    link?: string[];
+    clientKey?: string;
+    eventType?: string;
+    eventDataFile?: string;
+    asSystem?: boolean;
+};
+export declare function listChatChannels(options?: ChatCommonOptions): Promise<void>;
+export declare function readChatChannel(channel: string, options?: ChatCommonOptions): Promise<void>;
+export declare function readChatThread(rawMessageId: string, options?: ChatCommonOptions): Promise<void>;
+export declare function sendChatMessage(channel: string, options: ChatWriteCommandOptions): Promise<void>;
+export declare function replyChatMessage(rawMessageId: string, options: ChatWriteCommandOptions): Promise<void>;
+export declare function editChatMessage(rawMessageId: string, options: ChatWriteCommandOptions): Promise<void>;
+export declare function reactChatMessage(rawMessageId: string, emoji: string, options?: ChatCommonOptions): Promise<void>;
+export declare function unreactChatMessage(rawMessageId: string, emoji: string, options?: ChatCommonOptions): Promise<void>;
+export declare function grantChatAccess(channel: string, username: string, options?: ChatCommonOptions & {
+    readOnly?: boolean;
+}): Promise<void>;
+export declare function revokeChatAccess(channel: string, username: string, options?: ChatCommonOptions): Promise<void>;
+export declare function setChatVisibility(channel: string, visibility: string, options?: ChatCommonOptions): Promise<void>;

package/dist/commands/chat.js

@@ -0,0 +1,224 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listChatChannels = listChatChannels;
+exports.readChatChannel = readChatChannel;
+exports.readChatThread = readChatThread;
+exports.sendChatMessage = sendChatMessage;
+exports.replyChatMessage = replyChatMessage;
+exports.editChatMessage = editChatMessage;
+exports.reactChatMessage = reactChatMessage;
+exports.unreactChatMessage = unreactChatMessage;
+exports.grantChatAccess = grantChatAccess;
+exports.revokeChatAccess = revokeChatAccess;
+exports.setChatVisibility = setChatVisibility;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const commandContext_1 = require("../commandContext");
+const errors_1 = require("../errors");
+const messages_1 = require("../messages");
+const output_1 = require("../output");
+function positiveId(raw, command) {
+    const value = Number(raw);
+    if (!Number.isInteger(value) || value <= 0) {
+        (0, messages_1.printErrorWithHelp)('Message id must be a positive integer.', [], { command });
+        process.exitCode = 1;
+        return null;
+    }
+    return value;
+}
+function contentTypeForFile(filePath) {
+    const extension = node_path_1.default.extname(filePath).toLowerCase();
+    if (extension === '.gif')
+        return 'image/gif';
+    if (extension === '.jpg' || extension === '.jpeg')
+        return 'image/jpeg';
+    if (extension === '.png')
+        return 'image/png';
+    if (extension === '.webp')
+        return 'image/webp';
+    if (extension === '.mp4')
+        return 'video/mp4';
+    if (extension === '.mov')
+        return 'video/quicktime';
+    if (extension === '.webm')
+        return 'video/webm';
+    if (extension === '.txt')
+        return 'text/plain';
+    if (extension === '.md' || extension === '.markdown')
+        return 'text/markdown';
+    if (extension === '.json')
+        return 'application/json';
+    throw new Error(`unsupported_chat_file:${filePath}`);
+}
+async function readWriteOptions(options) {
+    if (options.text !== undefined && options.textFile !== undefined) {
+        throw new Error('chat_text_and_text_file_conflict');
+    }
+    const body = options.textFile !== undefined
+        ? await node_fs_1.promises.readFile(node_path_1.default.resolve(options.textFile), 'utf8')
+        : options.text;
+    const eventData = options.eventDataFile !== undefined
+        ? JSON.parse(await node_fs_1.promises.readFile(node_path_1.default.resolve(options.eventDataFile), 'utf8'))
+        : undefined;
+    const files = await Promise.all((options.file ?? []).map(async (filePath) => {
+        const absolutePath = node_path_1.default.resolve(filePath);
+        const buffer = await node_fs_1.promises.readFile(absolutePath);
+        return {
+            file: new Blob([new Uint8Array(buffer)], { type: contentTypeForFile(absolutePath) }),
+            fileName: node_path_1.default.basename(absolutePath),
+        };
+    }));
+    return {
+        ...(body !== undefined ? { body } : {}),
+        ...(files.length > 0 ? { files } : {}),
+        ...(options.link?.length ? { links: options.link } : {}),
+        ...(options.clientKey !== undefined ? { clientKey: options.clientKey } : {}),
+        ...(options.eventType !== undefined ? { eventType: options.eventType } : {}),
+        ...(eventData !== undefined ? { eventData } : {}),
+        ...(options.asSystem !== undefined ? { asSystem: options.asSystem } : {}),
+    };
+}
+function printMessage(message, indent = '') {
+    const edited = message.editedAt ? ' edited' : '';
+    console.log(`${indent}#${message.id} ${message.author.displayName} [${message.author.kind}] | ${(0, output_1.formatTimestamp)(message.createdAt)}${edited}`);
+    if (message.body)
+        console.log(`${indent}${message.body.replace(/\n/g, `\n${indent}`)}`);
+    for (const attachment of message.attachments) {
+        console.log(`${indent}[${attachment.kind}] ${attachment.fileName ?? attachment.url} ${attachment.url}`);
+    }
+    if (message.reactions.length > 0) {
+        console.log(`${indent}${message.reactions.map((reaction) => `${reaction.emoji} ${reaction.count}`).join('  ')}`);
+    }
+    if (message.replyCount > 0)
+        console.log(`${indent}${message.replyCount} ${message.replyCount === 1 ? 'reply' : 'replies'}`);
+}
+async function runChatCommand(command, options, operation) {
+    await (0, commandContext_1.withEnvironment)(command, 'PlayDrop Chat', async ({ client }) => {
+        try {
+            await operation(client);
+        }
+        catch (error) {
+            if (!(0, errors_1.handleCommandFailure)(error, command, 'PlayDrop Chat'))
+                throw error;
+        }
+    }, { env: options.env });
+}
+async function listChatChannels(options = {}) {
+    await runChatCommand('chat channels', options, async (client) => {
+        const response = await client.fetchChatChannels();
+        if (options.json)
+            return (0, output_1.printJson)(response);
+        for (const channel of response.channels) {
+            console.log(`${channel.slug}\t${channel.displayName}\t${channel.readPolicy}\t${channel.canWrite ? 'write' : 'read'}`);
+        }
+    });
+}
+async function readChatChannel(channel, options = {}) {
+    await runChatCommand('chat read', options, async (client) => {
+        const response = await client.fetchChatMessages(channel);
+        if (options.json)
+            return (0, output_1.printJson)(response);
+        if (response.messages.length === 0)
+            return console.log(`No messages in ${channel}.`);
+        response.messages.forEach((message) => printMessage(message));
+    });
+}
+async function readChatThread(rawMessageId, options = {}) {
+    const messageId = positiveId(rawMessageId, 'chat thread');
+    if (!messageId)
+        return;
+    await runChatCommand('chat thread', options, async (client) => {
+        const response = await client.fetchChatThread(messageId);
+        if (options.json)
+            return (0, output_1.printJson)(response);
+        if (response.messages.length === 0)
+            return console.log(`No replies to message #${messageId}.`);
+        response.messages.forEach((message) => printMessage(message, '  '));
+    });
+}
+async function sendChatMessage(channel, options) {
+    await runChatCommand('chat send', options, async (client) => {
+        const response = await client.sendChatMessage(channel, await readWriteOptions(options));
+        if (options.json)
+            return (0, output_1.printJson)(response);
+        (0, output_1.printSuccess)(`Message #${response.message.id} sent to ${channel}.`);
+    });
+}
+async function replyChatMessage(rawMessageId, options) {
+    const messageId = positiveId(rawMessageId, 'chat reply');
+    if (!messageId)
+        return;
+    await runChatCommand('chat reply', options, async (client) => {
+        const response = await client.replyChatMessage(messageId, await readWriteOptions(options));
+        if (options.json)
+            return (0, output_1.printJson)(response);
+        (0, output_1.printSuccess)(`Reply #${response.message.id} sent.`);
+    });
+}
+async function editChatMessage(rawMessageId, options) {
+    const messageId = positiveId(rawMessageId, 'chat edit');
+    if (!messageId)
+        return;
+    await runChatCommand('chat edit', options, async (client) => {
+        const write = await readWriteOptions(options);
+        const response = await client.editChatMessage(messageId, write);
+        if (options.json)
+            return (0, output_1.printJson)(response);
+        (0, output_1.printSuccess)(`Message #${messageId} edited.`);
+    });
+}
+async function reactChatMessage(rawMessageId, emoji, options = {}) {
+    const messageId = positiveId(rawMessageId, 'chat react');
+    if (!messageId)
+        return;
+    await runChatCommand('chat react', options, async (client) => {
+        const response = await client.reactChatMessage(messageId, emoji);
+        if (options.json)
+            return (0, output_1.printJson)(response);
+        (0, output_1.printSuccess)(`${emoji} added to message #${messageId}.`);
+    });
+}
+async function unreactChatMessage(rawMessageId, emoji, options = {}) {
+    const messageId = positiveId(rawMessageId, 'chat unreact');
+    if (!messageId)
+        return;
+    await runChatCommand('chat unreact', options, async (client) => {
+        const response = await client.unreactChatMessage(messageId, emoji);
+        if (options.json)
+            return (0, output_1.printJson)(response);
+        (0, output_1.printSuccess)(`${emoji} removed from message #${messageId}.`);
+    });
+}
+async function grantChatAccess(channel, username, options = {}) {
+    await runChatCommand('chat access grant', options, async (client) => {
+        const response = await client.grantChatAccess(channel, username, !options.readOnly);
+        if (options.json)
+            return (0, output_1.printJson)(response);
+        (0, output_1.printSuccess)(`${username} now has ${response.canWrite ? 'write' : 'read'} access to ${channel}.`);
+    });
+}
+async function revokeChatAccess(channel, username, options = {}) {
+    await runChatCommand('chat access revoke', options, async (client) => {
+        await client.revokeChatAccess(channel, username);
+        if (options.json)
+            return (0, output_1.printJson)({ success: true, channel, username });
+        (0, output_1.printSuccess)(`${username} no longer has access to ${channel}.`);
+    });
+}
+async function setChatVisibility(channel, visibility, options = {}) {
+    const readPolicy = visibility === 'public' ? 'PUBLIC' : visibility === 'admin-only' ? 'ADMIN_ONLY' : null;
+    if (!readPolicy) {
+        (0, messages_1.printErrorWithHelp)('Visibility must be public or admin-only.', [], { command: 'chat visibility' });
+        process.exitCode = 1;
+        return;
+    }
+    await runChatCommand('chat visibility', options, async (client) => {
+        const response = await client.setChatVisibility(channel, readPolicy);
+        if (options.json)
+            return (0, output_1.printJson)(response);
+        (0, output_1.printSuccess)(`${channel} visibility is now ${visibility}.`);
+    });
+}

package/dist/commands/upgrade.js

@@ -84,7 +84,7 @@ async function observeManagedWorkerUpdate(input) {
         }
         await sleep(pollMs);
     }
-    throw new Error(`playdrop_update_worker_timeout: worker ${input.workerKey} did not complete update intent ${input.intentId} within ${timeoutMs}ms. Next action: check Slack worker alerts, launchctl status, and the wrapper failure marker on the worker host.`);
+    throw new Error(`playdrop_update_worker_timeout: worker ${input.workerKey} did not complete update intent ${input.intentId} within ${timeoutMs}ms. Next action: check PlayDrop Chat, launchctl status, and the wrapper failure marker on the worker host.`);
 }
 async function upgrade(options = {}) {
     if (options.worker) {

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

@@ -6,6 +6,10 @@ export interface WorkerAgentProviderTelemetry {
     weeklyUsageStatus: AgentWorkerWeeklyUsageStatus;
     telemetryCheckedAt: string;
 }
+export declare function calculateWeeklyUsageRouting(remainingPercent: number, resetsAt: string | null, checkedAt: string): {
+    targetRemainingPercent: number;
+    surplusPercent: number;
+} | 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 probeWorkerProviderTelemetry(capabilities: AgentWorkerCapabilities): Promise<Partial<Record<AgentRuntime, WorkerAgentProviderTelemetry>>>;

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

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateWeeklyUsageRouting = calculateWeeklyUsageRouting;
 exports.buildCodexProviderTelemetry = buildCodexProviderTelemetry;
 exports.buildClaudeProviderTelemetry = buildClaudeProviderTelemetry;
 exports.probeWorkerProviderTelemetry = probeWorkerProviderTelemetry;
@@ -15,6 +16,8 @@ const clientInfo_1 = require("../../clientInfo");
 const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
 const PROVIDER_TELEMETRY_TIMEOUT_MS = 10000;
 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
@@ -29,6 +32,25 @@ function normalizePercent(value, field) {
     }
     return Math.round(value * 10) / 10;
 }
+function roundPercent(value) {
+    return Math.round(value * 10) / 10;
+}
+function calculateWeeklyUsageRouting(remainingPercent, resetsAt, checkedAt) {
+    if (!resetsAt)
+        return null;
+    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');
+    }
+    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);
+    return {
+        targetRemainingPercent,
+        surplusPercent: roundPercent(remainingPercent - targetRemainingPercent),
+    };
+}
 function unavailableTelemetry(checkedAt) {
     return {
         account: null,
@@ -87,17 +109,20 @@ function buildCodexProviderTelemetry(accountResult, rateLimitsResult, checkedAt)
         };
     }
     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');
     }
+    const resetsAt = new Date(resetsAtSeconds * 1000).toISOString();
     return {
         account: accountLabel,
         plan,
         weeklyUsage: {
             usedPercent,
-            remainingPercent: Math.round((100 - usedPercent) * 10) / 10,
-            resetsAt: new Date(resetsAtSeconds * 1000).toISOString(),
+            remainingPercent,
+            resetsAt,
+            ...calculateWeeklyUsageRouting(remainingPercent, resetsAt, checkedAt),
         },
         weeklyUsageStatus: 'AVAILABLE',
         telemetryCheckedAt: checkedAt,
@@ -138,6 +163,7 @@ function buildClaudeProviderTelemetry(authStatus, credentialMetadata, usageResul
         };
     }
     const usedPercent = normalizePercent(sevenDay.utilization, 'claude_weekly_usage');
+    const remainingPercent = roundPercent(100 - usedPercent);
     const rawReset = sevenDay.resets_at;
     const resetsAt = rawReset === null
         ? null
@@ -153,8 +179,9 @@ function buildClaudeProviderTelemetry(authStatus, credentialMetadata, usageResul
         plan,
         weeklyUsage: {
             usedPercent,
-            remainingPercent: Math.round((100 - usedPercent) * 10) / 10,
+            remainingPercent,
             resetsAt: resetsAt ? new Date(resetsAt).toISOString() : null,
+            ...calculateWeeklyUsageRouting(remainingPercent, resetsAt ? new Date(resetsAt).toISOString() : null, checkedAt),
         },
         weeklyUsageStatus: 'AVAILABLE',
         telemetryCheckedAt: checkedAt,

package/dist/commands/worker.d.ts

@@ -139,13 +139,6 @@ type TaskSubmitEvalOptions = {
     evidenceDir?: string[];
     resultFile?: string;
 };
-export type WorkerHealthAlertInput = {
-    state: 'started' | 'stopped' | 'crashed';
-    env: string;
-    workerName: string;
-    taskId?: number | null;
-    detail?: string | null;
-};
 type WorkerTaskState = {
     taskId: number;
     env: string;
@@ -258,7 +251,6 @@ export declare function resolveDevPluginWorkingTree(input: {
 }): string | null;
 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 isWorkerTransientNetworkError(error: unknown): boolean;

package/dist/commands/worker.js

@@ -32,7 +32,6 @@ exports.stageAssignmentPluginBundle = stageAssignmentPluginBundle;
 exports.resolveDevPluginWorkingTree = resolveDevPluginWorkingTree;
 exports.discoverWorkerProjectRoot = discoverWorkerProjectRoot;
 exports.readWorkerTaskState = readWorkerTaskState;
-exports.buildWorkerHealthAlertText = buildWorkerHealthAlertText;
 exports.isWorkerAuthFailureError = isWorkerAuthFailureError;
 exports.classifyWorkerEventDrainError = classifyWorkerEventDrainError;
 exports.isWorkerTransientNetworkError = isWorkerTransientNetworkError;
@@ -153,7 +152,6 @@ const CLAIM_BACKOFF_MAX_MS = 60000;
 const CLAIM_BACKOFF_JITTER_MS = 500;
 const FAIL_REPORT_RETRY_DELAY_MS = 2000;
 const WORKER_TRANSCRIPT_CHUNK_BATCH_SIZE = 100;
-const SLACK_API_BASE_URL = 'https://slack.com/api';
 const WORKER_WRAPPER_CONTRACT_VERSION = 3;
 const WORKER_SUPPORTED_KINDS = ['NEW_GAME', 'STATIC_GAME', 'REMIX_GAME', 'GAME_UPDATE', 'GAME_REVIEW', 'GAME_EVAL', 'RELEASE_SMOKE'];
 const GAME_CREATION_TASK_KINDS = new Set(['NEW_GAME', 'STATIC_GAME', 'REMIX_GAME', 'GAME_UPDATE']);
@@ -1472,59 +1470,6 @@ function readWorkerTaskState() {
     }
     return parsed;
 }
-function isWorkerSlackAlertEnabled() {
-    const normalized = node_process_1.default.env.PLAYDROP_WORKER_SLACK_ALERTS?.trim().toLowerCase();
-    return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on';
-}
-function buildWorkerHealthAlertText(input) {
-    return [
-        `PlayDrop Worker ${input.state}`,
-        `env=${input.env}`,
-        `worker=${input.workerName}`,
-        input.taskId ? `task=${input.taskId}` : null,
-        input.detail ? `detail=${input.detail}` : null,
-    ].filter(Boolean).join(' ');
-}
-async function sendWorkerHealthAlert(input) {
-    if (!isWorkerSlackAlertEnabled()) {
-        return;
-    }
-    const token = node_process_1.default.env.PLAYDROP_SLACK_BOT_TOKEN?.trim();
-    if (!token) {
-        throw new Error('missing_playdrop_slack_bot_token');
-    }
-    const channelId = node_process_1.default.env.PLAYDROP_WORKER_SLACK_CHANNEL_ID?.trim();
-    if (!channelId) {
-        throw new Error('missing_playdrop_worker_slack_channel_id');
-    }
-    const response = await fetch(`${SLACK_API_BASE_URL}/chat.postMessage`, {
-        method: 'POST',
-        headers: {
-            authorization: `Bearer ${token}`,
-            'content-type': 'application/json; charset=utf-8',
-        },
-        body: JSON.stringify({
-            channel: channelId,
-            text: buildWorkerHealthAlertText(input),
-        }),
-    });
-    const raw = await response.text();
-    const payload = raw ? JSON.parse(raw) : {};
-    if (!response.ok) {
-        throw new Error(`slack_http_error:${response.status}`);
-    }
-    if (payload.ok !== true) {
-        throw new Error(`slack_api_error:${String(payload.error || 'unknown')}`);
-    }
-}
-async function sendWorkerHealthAlertSafely(input) {
-    try {
-        await sendWorkerHealthAlert(input);
-    }
-    catch (error) {
-        console.error(`Worker health alert failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
 function parsePositiveInteger(value, code) {
     const parsed = typeof value === 'number' ? value : Number.parseInt(String(value ?? ''), 10);
     if (!Number.isInteger(parsed) || parsed <= 0) {
@@ -4229,7 +4174,6 @@ async function startWorker(options = {}) {
             let shuttingDown = false;
             let quiescingForUpdate = false;
             let shutdownSignal = null;
-            let crashed = false;
             let fatalTaskError = null;
             let presenceTimer = null;
             let currentWorkerPolicy = initialWorkerPolicy;
@@ -4328,7 +4272,6 @@ async function startWorker(options = {}) {
                 node_process_1.default.stdin.resume();
             }
             console.log(`PlayDrop Worker started as "${workerName}" (${target}).`);
-            await sendWorkerHealthAlertSafely({ state: 'started', env, workerName });
             beginProviderTelemetryRefresh();
             // Marks the session expired, kills any in-flight agent child, and lets the
             // run loop finish the task lifecycle before the worker stops non-zero.
@@ -5302,26 +5245,11 @@ async function startWorker(options = {}) {
                     return;
                 }
                 if (shuttingDown) {
-                    await sendWorkerHealthAlertSafely({
-                        state: 'stopped',
-                        env,
-                        workerName,
-                        taskId: firstActiveTaskId(),
-                        detail: shutdownSignal,
-                    });
                     node_process_1.default.exitCode = shutdownSignal === 'SIGINT' ? 130 : 143;
                     return;
                 }
             }
             catch (error) {
-                crashed = true;
-                await sendWorkerHealthAlertSafely({
-                    state: 'crashed',
-                    env,
-                    workerName,
-                    taskId: firstActiveTaskId(),
-                    detail: error instanceof Error ? error.message : String(error),
-                });
                 throw error;
             }
             finally {
@@ -5334,14 +5262,6 @@ async function startWorker(options = {}) {
                     node_process_1.default.stdin.off('end', stdinShutdownHandler);
                     node_process_1.default.stdin.off('close', stdinShutdownHandler);
                 }
-                if (!crashed) {
-                    await sendWorkerHealthAlertSafely({
-                        state: 'stopped',
-                        env,
-                        workerName,
-                        taskId: firstActiveTaskId(),
-                    });
-                }
                 clearWorkerRuntimeState(target);
             }
         }

package/dist/index.js

@@ -45,6 +45,7 @@ const changelog_1 = require("./commands/changelog");
 const publicPages_1 = require("./commands/publicPages");
 const upgrade_1 = require("./commands/upgrade");
 const tweaks_1 = require("./commands/tweaks");
+const chat_1 = require("./commands/chat");
 const notes_1 = require("./commands/notes");
 const worker_1 = require("./commands/worker");
 const messages_1 = require("./messages");
@@ -378,6 +379,48 @@ registerLogoutCommand(auth);
 registerWhoamiCommand(auth);
 registerAccountsCommand(auth);
 registerUseAccountCommand(auth);
+function addChatReadOptions(command) {
+    return command
+        .option('--env <env>', 'Resolve this command against one logged-in environment')
+        .option('--json', 'Output JSON');
+}
+function addChatWriteOptions(command, allowClientKey = true) {
+    command
+        .option('--text <text>', 'Message text')
+        .option('--text-file <path>', 'Read message text from a file')
+        .option('--file <path>', 'Attach a file', collectRepeatedOption, [])
+        .option('--link <url>', 'Attach an HTTPS link', collectRepeatedOption, [])
+        .option('--event-type <type>', 'Structured event type')
+        .option('--event-data-file <path>', 'Read structured event JSON from a file')
+        .option('--as-system', 'Publish as playdrop-system (admin only)');
+    if (allowClientKey)
+        command.option('--client-key <key>', 'Idempotency key within the channel');
+    return addChatReadOptions(command);
+}
+const chat = program.command('chat').description('Read and write PlayDrop Chat');
+addChatReadOptions(chat.command('channels').description('List accessible channels'))
+    .action(chat_1.listChatChannels);
+addChatReadOptions(chat.command('read <channel>').description('Read channel messages'))
+    .action(chat_1.readChatChannel);
+addChatReadOptions(chat.command('thread <message-id>').description('Read a message thread'))
+    .action(chat_1.readChatThread);
+addChatWriteOptions(chat.command('send <channel>').description('Send a channel message'))
+    .action(chat_1.sendChatMessage);
+addChatWriteOptions(chat.command('reply <message-id>').description('Reply to a root message'))
+    .action(chat_1.replyChatMessage);
+addChatWriteOptions(chat.command('edit <message-id>').description('Edit a message'), false)
+    .action(chat_1.editChatMessage);
+addChatReadOptions(chat.command('react <message-id> <emoji>').description('Add a reaction'))
+    .action(chat_1.reactChatMessage);
+addChatReadOptions(chat.command('unreact <message-id> <emoji>').description('Remove a reaction'))
+    .action(chat_1.unreactChatMessage);
+const chatAccess = chat.command('access').description('Manage channel access');
+addChatReadOptions(chatAccess.command('grant <channel> <username>').description('Grant channel access').option('--read-only', 'Grant read access without write access'))
+    .action(chat_1.grantChatAccess);
+addChatReadOptions(chatAccess.command('revoke <channel> <username>').description('Revoke channel access'))
+    .action(chat_1.revokeChatAccess);
+addChatReadOptions(chat.command('visibility <channel> <visibility>').description('Set public or admin-only visibility'))
+    .action(chat_1.setChatVisibility);
 program
     .command('doctor')
     .description('Check PlayDrop setup health')