trigger.dev 3.0.0-beta.9 → 3.0.0

package/dist/esm/entryPoints/dev-run-worker.js

@@ -0,0 +1,254 @@
+import { clock, logger, runtime, taskCatalog, TaskRunErrorCodes, WorkerToExecutorMessageCatalog, TriggerTracer, WorkerManifest, ExecutorToWorkerMessageCatalog, } from "@trigger.dev/core/v3";
+import { DevRuntimeManager } from "@trigger.dev/core/v3/dev";
+import { ConsoleInterceptor, DevUsageManager, DurableClock, getEnvVar, logLevels, OtelTaskLogger, StandardTaskCatalog, TaskExecutor, TracingSDK, usage, } from "@trigger.dev/core/v3/workers";
+import { ZodIpcConnection } from "@trigger.dev/core/v3/zodIpc";
+import { readFile } from "node:fs/promises";
+import sourceMapSupport from "source-map-support";
+import { VERSION } from "../version.js";
+import { env } from "std-env";
+import { normalizeImportPath } from "../utilities/normalizeImportPath.js";
+sourceMapSupport.install({
+    handleUncaughtExceptions: false,
+    environment: "node",
+    hookRequire: false,
+});
+process.on("uncaughtException", function (error, origin) {
+    if (error instanceof Error) {
+        process.send &&
+            process.send({
+                type: "UNCAUGHT_EXCEPTION",
+                payload: {
+                    error: { name: error.name, message: error.message, stack: error.stack },
+                    origin,
+                },
+                version: "v1",
+            });
+    }
+    else {
+        process.send &&
+            process.send({
+                type: "UNCAUGHT_EXCEPTION",
+                payload: {
+                    error: {
+                        name: "Error",
+                        message: typeof error === "string" ? error : JSON.stringify(error),
+                    },
+                    origin,
+                },
+                version: "v1",
+            });
+    }
+});
+taskCatalog.setGlobalTaskCatalog(new StandardTaskCatalog());
+const durableClock = new DurableClock();
+clock.setGlobalClock(durableClock);
+usage.setGlobalUsageManager(new DevUsageManager());
+const devRuntimeManager = new DevRuntimeManager();
+runtime.setGlobalRuntimeManager(devRuntimeManager);
+const triggerLogLevel = getEnvVar("TRIGGER_LOG_LEVEL");
+async function importConfig(configPath) {
+    const configModule = await import(normalizeImportPath(configPath));
+    const config = configModule?.default ?? configModule?.config;
+    return {
+        config,
+        handleError: configModule?.handleError,
+    };
+}
+async function loadWorkerManifest() {
+    const manifestContents = await readFile(env.TRIGGER_WORKER_MANIFEST_PATH, "utf-8");
+    const raw = JSON.parse(manifestContents);
+    return WorkerManifest.parse(raw);
+}
+async function bootstrap() {
+    const workerManifest = await loadWorkerManifest();
+    const { config, handleError } = await importConfig(workerManifest.configPath);
+    const tracingSDK = new TracingSDK({
+        url: env.OTEL_EXPORTER_OTLP_ENDPOINT ?? "http://0.0.0.0:4318",
+        instrumentations: config.instrumentations ?? [],
+        diagLogLevel: env.OTEL_LOG_LEVEL ?? "none",
+        forceFlushTimeoutMillis: 30_000,
+    });
+    const otelTracer = tracingSDK.getTracer("trigger-dev-worker", VERSION);
+    const otelLogger = tracingSDK.getLogger("trigger-dev-worker", VERSION);
+    const tracer = new TriggerTracer({ tracer: otelTracer, logger: otelLogger });
+    const consoleInterceptor = new ConsoleInterceptor(otelLogger, typeof config.enableConsoleLogging === "boolean" ? config.enableConsoleLogging : true);
+    const configLogLevel = triggerLogLevel ?? config.logLevel ?? "info";
+    const otelTaskLogger = new OtelTaskLogger({
+        logger: otelLogger,
+        tracer: tracer,
+        level: logLevels.includes(configLogLevel) ? configLogLevel : "info",
+    });
+    logger.setGlobalTaskLogger(otelTaskLogger);
+    for (const task of workerManifest.tasks) {
+        taskCatalog.registerTaskFileMetadata(task.id, {
+            exportName: task.exportName,
+            filePath: task.filePath,
+            entryPoint: task.entryPoint,
+        });
+    }
+    return {
+        tracer,
+        tracingSDK,
+        consoleInterceptor,
+        config,
+        handleErrorFn: handleError,
+        workerManifest,
+    };
+}
+let _execution;
+let _isRunning = false;
+let _tracingSDK;
+const zodIpc = new ZodIpcConnection({
+    listenSchema: WorkerToExecutorMessageCatalog,
+    emitSchema: ExecutorToWorkerMessageCatalog,
+    process,
+    handlers: {
+        EXECUTE_TASK_RUN: async ({ execution, traceContext, metadata }, sender) => {
+            if (_isRunning) {
+                console.error("Worker is already running a task");
+                await sender.send("TASK_RUN_COMPLETED", {
+                    execution,
+                    result: {
+                        ok: false,
+                        id: execution.run.id,
+                        error: {
+                            type: "INTERNAL_ERROR",
+                            code: TaskRunErrorCodes.TASK_ALREADY_RUNNING,
+                        },
+                        usage: {
+                            durationMs: 0,
+                        },
+                    },
+                });
+                return;
+            }
+            const { tracer, tracingSDK, consoleInterceptor, config, handleErrorFn, workerManifest } = await bootstrap();
+            _tracingSDK = tracingSDK;
+            const taskManifest = workerManifest.tasks.find((t) => t.id === execution.task.id);
+            if (!taskManifest) {
+                console.error(`Could not find task ${execution.task.id}`);
+                await sender.send("TASK_RUN_COMPLETED", {
+                    execution,
+                    result: {
+                        ok: false,
+                        id: execution.run.id,
+                        error: {
+                            type: "INTERNAL_ERROR",
+                            code: TaskRunErrorCodes.COULD_NOT_FIND_TASK,
+                        },
+                        usage: {
+                            durationMs: 0,
+                        },
+                    },
+                });
+                return;
+            }
+            try {
+                await import(normalizeImportPath(taskManifest.entryPoint));
+            }
+            catch (err) {
+                console.error(`Failed to import task ${execution.task.id}`, err);
+                await sender.send("TASK_RUN_COMPLETED", {
+                    execution,
+                    result: {
+                        ok: false,
+                        id: execution.run.id,
+                        error: {
+                            type: "INTERNAL_ERROR",
+                            code: TaskRunErrorCodes.COULD_NOT_IMPORT_TASK,
+                        },
+                        usage: {
+                            durationMs: 0,
+                        },
+                    },
+                });
+                return;
+            }
+            process.title = `trigger-dev-worker: ${execution.task.id} ${execution.run.id}`;
+            // Import the task module
+            const task = taskCatalog.getTask(execution.task.id);
+            if (!task) {
+                console.error(`Could not find task ${execution.task.id}`);
+                await sender.send("TASK_RUN_COMPLETED", {
+                    execution,
+                    result: {
+                        ok: false,
+                        id: execution.run.id,
+                        error: {
+                            type: "INTERNAL_ERROR",
+                            code: TaskRunErrorCodes.COULD_NOT_FIND_EXECUTOR,
+                        },
+                        usage: {
+                            durationMs: 0,
+                        },
+                    },
+                });
+                return;
+            }
+            const executor = new TaskExecutor(task, {
+                tracer,
+                tracingSDK,
+                consoleInterceptor,
+                config,
+                handleErrorFn,
+            });
+            try {
+                _execution = execution;
+                _isRunning = true;
+                const measurement = usage.start();
+                const { result } = await executor.execute(execution, metadata, traceContext, measurement);
+                const usageSample = usage.stop(measurement);
+                return sender.send("TASK_RUN_COMPLETED", {
+                    execution,
+                    result: {
+                        ...result,
+                        usage: {
+                            durationMs: usageSample.cpuTime,
+                        },
+                    },
+                });
+            }
+            finally {
+                _execution = undefined;
+                _isRunning = false;
+            }
+        },
+        TASK_RUN_COMPLETED_NOTIFICATION: async (payload) => {
+            switch (payload.version) {
+                case "v1": {
+                    devRuntimeManager.resumeTask(payload.completion, payload.execution.run.id);
+                    break;
+                }
+                case "v2": {
+                    devRuntimeManager.resumeTask(payload.completion, payload.completion.id);
+                    break;
+                }
+            }
+        },
+        FLUSH: async ({ timeoutInMs }, sender) => {
+            await _tracingSDK?.flush();
+        },
+    },
+});
+process.title = "trigger-dev-worker";
+async function asyncHeartbeat(initialDelayInSeconds = 30, intervalInSeconds = 30) {
+    async function _doHeartbeat() {
+        while (true) {
+            if (_isRunning && _execution) {
+                try {
+                    await zodIpc.send("TASK_HEARTBEAT", { id: _execution.attempt.id });
+                }
+                catch (err) {
+                    console.error("Failed to send HEARTBEAT message", err);
+                }
+            }
+            await new Promise((resolve) => setTimeout(resolve, 1000 * intervalInSeconds));
+        }
+    }
+    // Wait for the initial delay
+    await new Promise((resolve) => setTimeout(resolve, 1000 * initialDelayInSeconds));
+    // Wait for 5 seconds before the next execution
+    return _doHeartbeat();
+}
+await asyncHeartbeat();
+//# sourceMappingURL=dev-run-worker.js.map

package/dist/esm/entryPoints/dev-run-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev-run-worker.js","sourceRoot":"","sources":["../../../src/entryPoints/dev-run-worker.ts"],"names":[],"mappings":"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"}

package/dist/esm/entryPoints/loader.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/entryPoints/loader.js

@@ -0,0 +1,16 @@
+import { register } from "node:module";
+import { createAddHookMessageChannel } from "import-in-the-middle";
+const { registerOptions, waitForAllMessagesAcknowledged } = createAddHookMessageChannel();
+const data = {};
+if (typeof process.env.OTEL_IMPORT_HOOK_INCLUDES === "string") {
+    data.include = process.env.OTEL_IMPORT_HOOK_INCLUDES.split(",");
+}
+if (typeof process.env.OTEL_IMPORT_HOOK_EXCLUDES === "string") {
+    data.exclude = process.env.OTEL_IMPORT_HOOK_EXCLUDES.split(",");
+}
+// @ts-ignore
+register("import-in-the-middle/hook.mjs", import.meta.url, registerOptions);
+// Ensure that the loader has acknowledged all the modules
+// before we allow execution to continue
+await waitForAllMessagesAcknowledged;
+//# sourceMappingURL=loader.js.map

package/dist/esm/entryPoints/loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.js","sourceRoot":"","sources":["../../../src/entryPoints/loader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAC;AAEnE,MAAM,EAAE,eAAe,EAAE,8BAA8B,EAAE,GAAG,2BAA2B,EAAE,CAAC;AAO1F,MAAM,IAAI,GAAmB,EAAE,CAAC;AAEhC,IAAI,OAAO,OAAO,CAAC,GAAG,CAAC,yBAAyB,KAAK,QAAQ,EAAE,CAAC;IAC9D,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,yBAAyB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;AAClE,CAAC;AAED,IAAI,OAAO,OAAO,CAAC,GAAG,CAAC,yBAAyB,KAAK,QAAQ,EAAE,CAAC;IAC9D,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,yBAAyB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;AAClE,CAAC;AAED,aAAa;AACb,QAAQ,CAAC,+BAA+B,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,eAAe,CAAC,CAAC;AAE5E,0DAA0D;AAC1D,wCAAwC;AACxC,MAAM,8BAA8B,CAAC"}

package/dist/esm/executions/taskRunProcess.d.ts

@@ -0,0 +1,115 @@
+import { ExecutorToWorkerMessageCatalog, ServerBackgroundWorker, TaskRunExecutionPayload, TaskRunExecutionResult, WorkerManifest } from "@trigger.dev/core/v3";
+import { Evt } from "evt";
+import { InferSocketMessageSchema } from "@trigger.dev/core/v3/zodSocket";
+export type OnWaitForDurationMessage = InferSocketMessageSchema<typeof ExecutorToWorkerMessageCatalog, "WAIT_FOR_DURATION">;
+export type OnWaitForTaskMessage = InferSocketMessageSchema<typeof ExecutorToWorkerMessageCatalog, "WAIT_FOR_TASK">;
+export type OnWaitForBatchMessage = InferSocketMessageSchema<typeof ExecutorToWorkerMessageCatalog, "WAIT_FOR_BATCH">;
+export type TaskRunProcessOptions = {
+    workerManifest: WorkerManifest;
+    serverWorker: ServerBackgroundWorker;
+    env: Record<string, string>;
+    payload: TaskRunExecutionPayload;
+    messageId: string;
+    cwd?: string;
+};
+export declare class TaskRunProcess {
+    #private;
+    readonly options: TaskRunProcessOptions;
+    private _ipc?;
+    private _child;
+    private _childPid?;
+    private _attemptPromises;
+    private _attemptStatuses;
+    private _currentExecution;
+    private _gracefulExitTimeoutElapsed;
+    private _isBeingKilled;
+    private _isBeingCancelled;
+    private _stderr;
+    onTaskRunHeartbeat: Evt<string>;
+    onExit: Evt<{
+        code: number | null;
+        signal: NodeJS.Signals | null;
+        pid?: number;
+    }>;
+    onIsBeingKilled: Evt<TaskRunProcess>;
+    onReadyToDispose: Evt<TaskRunProcess>;
+    onWaitForDuration: Evt<OnWaitForDurationMessage>;
+    onWaitForTask: Evt<OnWaitForTaskMessage>;
+    onWaitForBatch: Evt<OnWaitForBatchMessage>;
+    constructor(options: TaskRunProcessOptions);
+    cancel(): Promise<void>;
+    cleanup(kill?: boolean): Promise<void>;
+    get runId(): string;
+    get isTest(): boolean;
+    get payload(): {
+        execution: {
+            task: {
+                id: string;
+                filePath: string;
+                exportName: string;
+            };
+            attempt: {
+                number: number;
+                status: string;
+                id: string;
+                startedAt: Date;
+                backgroundWorkerId: string;
+                backgroundWorkerTaskId: string;
+            };
+            run: {
+                id: string;
+                startedAt: Date;
+                payload: string;
+                payloadType: string;
+                tags: string[];
+                isTest: boolean;
+                createdAt: Date;
+                durationMs: number;
+                costInCents: number;
+                baseCostInCents: number;
+                context?: any;
+                idempotencyKey?: string | undefined;
+                maxAttempts?: number | undefined;
+                version?: string | undefined;
+            };
+            queue: {
+                id: string;
+                name: string;
+            };
+            environment: {
+                type: "PRODUCTION" | "STAGING" | "DEVELOPMENT" | "PREVIEW";
+                id: string;
+                slug: string;
+            };
+            organization: {
+                id: string;
+                name: string;
+                slug: string;
+            };
+            project: {
+                id: string;
+                name: string;
+                slug: string;
+                ref: string;
+            };
+            batch?: {
+                id: string;
+            } | undefined;
+            machine?: {
+                name: "micro" | "small-1x" | "small-2x" | "medium-1x" | "medium-2x" | "large-1x" | "large-2x";
+                cpu: number;
+                memory: number;
+                centsPerMs: number;
+            } | undefined;
+        };
+        traceContext: Record<string, unknown>;
+        environment?: Record<string, string> | undefined;
+    };
+    initialize(): Promise<void>;
+    execute(): Promise<TaskRunExecutionResult>;
+    taskRunCompletedNotification(completion: TaskRunExecutionResult): void;
+    waitCompletedNotification(): void;
+    kill(signal?: number | NodeJS.Signals, timeoutInMs?: number): Promise<void>;
+    get isBeingKilled(): boolean | undefined;
+    get pid(): number | undefined;
+}

package/dist/esm/executions/taskRunProcess.js

@@ -0,0 +1,254 @@
+import { ExecutorToWorkerMessageCatalog, WorkerToExecutorMessageCatalog, } from "@trigger.dev/core/v3";
+import { ZodIpcConnection, } from "@trigger.dev/core/v3/zodIpc";
+import { Evt } from "evt";
+import { fork } from "node:child_process";
+import { chalkError, chalkGrey, chalkRun, prettyPrintDate } from "../utilities/cliOutput.js";
+import { execOptionsForRuntime, execPathForRuntime } from "@trigger.dev/core/v3/build";
+import { logger } from "../utilities/logger.js";
+import { CancelledProcessError, CleanupProcessError, GracefulExitTimeoutError, UnexpectedExitError, } from "@trigger.dev/core/v3/errors";
+export class TaskRunProcess {
+    options;
+    _ipc;
+    _child;
+    _childPid;
+    _attemptPromises = new Map();
+    _attemptStatuses = new Map();
+    _currentExecution;
+    _gracefulExitTimeoutElapsed = false;
+    _isBeingKilled = false;
+    _isBeingCancelled = false;
+    _stderr = [];
+    onTaskRunHeartbeat = new Evt();
+    onExit = new Evt();
+    onIsBeingKilled = new Evt();
+    onReadyToDispose = new Evt();
+    onWaitForDuration = new Evt();
+    onWaitForTask = new Evt();
+    onWaitForBatch = new Evt();
+    constructor(options) {
+        this.options = options;
+    }
+    async cancel() {
+        this._isBeingCancelled = true;
+        try {
+            await this.#flush();
+        }
+        catch (err) {
+            logger.error("Error flushing task run process", { err });
+        }
+        await this.kill();
+    }
+    async cleanup(kill = true) {
+        try {
+            await this.#flush();
+        }
+        catch (err) {
+            logger.error("Error flushing task run process", { err });
+        }
+        if (kill) {
+            await this.kill("SIGKILL");
+        }
+    }
+    get runId() {
+        return this.options.payload.execution.run.id;
+    }
+    get isTest() {
+        return this.options.payload.execution.run.isTest;
+    }
+    get payload() {
+        return this.options.payload;
+    }
+    async initialize() {
+        const { env: $env, workerManifest, cwd, messageId } = this.options;
+        const fullEnv = {
+            ...(this.isTest ? { TRIGGER_LOG_LEVEL: "debug" } : {}),
+            ...$env,
+            OTEL_IMPORT_HOOK_INCLUDES: workerManifest.otelImportHook?.include?.join(","),
+            // TODO: this will probably need to use something different for bun (maybe --preload?)
+            NODE_OPTIONS: execOptionsForRuntime(workerManifest.runtime, workerManifest),
+        };
+        logger.debug(`[${this.runId}] initializing task run process`, {
+            env: fullEnv,
+            path: workerManifest.workerEntryPoint,
+            cwd,
+        });
+        this._child = fork(workerManifest.workerEntryPoint, executorArgs(workerManifest), {
+            stdio: [/*stdin*/ "ignore", /*stdout*/ "pipe", /*stderr*/ "pipe", "ipc"],
+            cwd,
+            env: fullEnv,
+            execArgv: ["--trace-uncaught", "--no-warnings=ExperimentalWarning"],
+            execPath: execPathForRuntime(workerManifest.runtime),
+            serialization: "json",
+        });
+        this._childPid = this._child?.pid;
+        this._ipc = new ZodIpcConnection({
+            listenSchema: ExecutorToWorkerMessageCatalog,
+            emitSchema: WorkerToExecutorMessageCatalog,
+            process: this._child,
+            handlers: {
+                TASK_RUN_COMPLETED: async (message) => {
+                    const { result, execution } = message;
+                    const promiseStatus = this._attemptStatuses.get(execution.attempt.id);
+                    if (promiseStatus !== "PENDING") {
+                        return;
+                    }
+                    this._attemptStatuses.set(execution.attempt.id, "RESOLVED");
+                    const attemptPromise = this._attemptPromises.get(execution.attempt.id);
+                    if (!attemptPromise) {
+                        return;
+                    }
+                    const { resolver } = attemptPromise;
+                    resolver(result);
+                },
+                READY_TO_DISPOSE: async (message) => {
+                    logger.debug(`[${this.runId}] task run process is ready to dispose`);
+                    this.onReadyToDispose.post(this);
+                },
+                TASK_HEARTBEAT: async (message) => {
+                    this.onTaskRunHeartbeat.post(messageId);
+                },
+                WAIT_FOR_TASK: async (message) => {
+                    this.onWaitForTask.post(message);
+                },
+                WAIT_FOR_BATCH: async (message) => {
+                    this.onWaitForBatch.post(message);
+                },
+                WAIT_FOR_DURATION: async (message) => {
+                    this.onWaitForDuration.post(message);
+                },
+            },
+        });
+        this._child.on("exit", this.#handleExit.bind(this));
+        this._child.stdout?.on("data", this.#handleLog.bind(this));
+        this._child.stderr?.on("data", this.#handleStdErr.bind(this));
+    }
+    async #flush(timeoutInMs = 5_000) {
+        logger.debug("flushing task run process", { pid: this.pid });
+        await this._ipc?.sendWithAck("FLUSH", { timeoutInMs }, timeoutInMs + 1_000);
+    }
+    async execute() {
+        let resolver;
+        let rejecter;
+        const promise = new Promise((resolve, reject) => {
+            resolver = resolve;
+            rejecter = reject;
+        });
+        this._attemptStatuses.set(this.payload.execution.attempt.id, "PENDING");
+        // @ts-expect-error - We know that the resolver and rejecter are defined
+        this._attemptPromises.set(this.payload.execution.attempt.id, { resolver, rejecter });
+        const { execution, traceContext } = this.payload;
+        this._currentExecution = execution;
+        if (this._child?.connected && !this._isBeingKilled && !this._child.killed) {
+            logger.debug(`[${new Date().toISOString()}][${this.runId}] sending EXECUTE_TASK_RUN message to task run process`, {
+                pid: this.pid,
+            });
+            await this._ipc?.send("EXECUTE_TASK_RUN", {
+                execution,
+                traceContext,
+                metadata: this.options.serverWorker,
+            });
+        }
+        const result = await promise;
+        this._currentExecution = undefined;
+        return result;
+    }
+    taskRunCompletedNotification(completion) {
+        if (!completion.ok && typeof completion.retry !== "undefined") {
+            logger.debug("Task run completed with error and wants to retry, won't send task run completed notification");
+            return;
+        }
+        if (!this._child?.connected || this._isBeingKilled || this._child.killed) {
+            logger.debug("Child process not connected or being killed, can't send task run completed notification");
+            return;
+        }
+        this._ipc?.send("TASK_RUN_COMPLETED_NOTIFICATION", {
+            version: "v2",
+            completion,
+        });
+    }
+    waitCompletedNotification() {
+        if (!this._child?.connected || this._isBeingKilled || this._child.killed) {
+            console.error("Child process not connected or being killed, can't send wait completed notification");
+            return;
+        }
+        this._ipc?.send("WAIT_COMPLETED_NOTIFICATION", {});
+    }
+    async #handleExit(code, signal) {
+        logger.debug("handling child exit", { code, signal });
+        // Go through all the attempts currently pending and reject them
+        for (const [id, status] of this._attemptStatuses.entries()) {
+            if (status === "PENDING") {
+                logger.debug("found pending attempt", { id });
+                this._attemptStatuses.set(id, "REJECTED");
+                const attemptPromise = this._attemptPromises.get(id);
+                if (!attemptPromise) {
+                    continue;
+                }
+                const { rejecter } = attemptPromise;
+                if (this._isBeingCancelled) {
+                    rejecter(new CancelledProcessError());
+                }
+                else if (this._gracefulExitTimeoutElapsed) {
+                    // Order matters, this has to be before the graceful exit timeout
+                    rejecter(new GracefulExitTimeoutError());
+                }
+                else if (this._isBeingKilled) {
+                    rejecter(new CleanupProcessError());
+                }
+                else {
+                    rejecter(new UnexpectedExitError(code ?? -1, signal, this._stderr.length ? this._stderr.join("\n") : undefined));
+                }
+            }
+        }
+        logger.debug("Task run process exited, posting onExit", { code, signal, pid: this.pid });
+        this.onExit.post({ code, signal, pid: this.pid });
+    }
+    #handleLog(data) {
+        if (!this._currentExecution) {
+            logger.log(`${chalkGrey("○")} ${chalkGrey(prettyPrintDate(new Date()))} ${data.toString()}`);
+            return;
+        }
+        const runId = chalkRun(`${this._currentExecution.run.id}.${this._currentExecution.attempt.number}`);
+        logger.log(`${chalkGrey("○")} ${chalkGrey(prettyPrintDate(new Date()))} ${runId} ${data.toString()}`);
+    }
+    #handleStdErr(data) {
+        if (this._isBeingKilled) {
+            return;
+        }
+        if (!this._currentExecution) {
+            logger.log(`${chalkError("○")} ${chalkGrey(prettyPrintDate(new Date()))} ${data.toString()}`);
+            return;
+        }
+        const runId = chalkRun(`${this._currentExecution.run.id}.${this._currentExecution.attempt.number}`);
+        const errorLine = data.toString();
+        logger.log(`${chalkError("○")} ${chalkGrey(prettyPrintDate(new Date()))} ${runId} ${errorLine}`);
+        if (this._stderr.length > 100) {
+            this._stderr.shift();
+        }
+        this._stderr.push(errorLine);
+    }
+    async kill(signal, timeoutInMs) {
+        logger.debug(`[${this.runId}] killing task run process`, {
+            signal,
+            timeoutInMs,
+            pid: this.pid,
+        });
+        this._isBeingKilled = true;
+        const killTimeout = this.onExit.waitFor(timeoutInMs);
+        this.onIsBeingKilled.post(this);
+        this._child?.kill(signal);
+        if (timeoutInMs) {
+            await killTimeout;
+        }
+    }
+    get isBeingKilled() {
+        return this._isBeingKilled || this._child?.killed;
+    }
+    get pid() {
+        return this._childPid;
+    }
+}
+function executorArgs(workerManifest) {
+    return [];
+}
+//# sourceMappingURL=taskRunProcess.js.map