@renderinc/sdk 0.1.0

package/dist/workflows/client/schema.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/workflows/client/sse.d.ts

@@ -0,0 +1,14 @@
+import type { TaskRunDetails } from "./types.js";
+export declare enum TaskEventType {
+    COMPLETED = "task.completed",
+    FAILED = "task.failed",
+    RUNNING = "task.running",
+    PENDING = "task.pending"
+}
+export declare class SSEClient {
+    private baseUrl;
+    private token;
+    constructor(baseUrl: string, token: string);
+    waitOnTaskRun(taskRunId: string, signal?: AbortSignal): Promise<TaskRunDetails>;
+}
+//# sourceMappingURL=sse.d.ts.map

package/dist/workflows/client/sse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../../../src/workflows/client/sse.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAKjD,oBAAY,aAAa;IACvB,SAAS,mBAAmB;IAC5B,MAAM,gBAAgB;IACtB,OAAO,iBAAiB;IACxB,OAAO,iBAAiB;CACzB;AAKD,qBAAa,SAAS;IAElB,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,KAAK;gBADL,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM;IAGjB,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,cAAc,CAAC;CAqEtF"}

package/dist/workflows/client/sse.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SSEClient = exports.TaskEventType = void 0;
+const eventsource_1 = require("eventsource");
+const errors_js_1 = require("../../errors.js");
+var TaskEventType;
+(function (TaskEventType) {
+    TaskEventType["COMPLETED"] = "task.completed";
+    TaskEventType["FAILED"] = "task.failed";
+    TaskEventType["RUNNING"] = "task.running";
+    TaskEventType["PENDING"] = "task.pending";
+})(TaskEventType || (exports.TaskEventType = TaskEventType = {}));
+class SSEClient {
+    constructor(baseUrl, token) {
+        this.baseUrl = baseUrl;
+        this.token = token;
+    }
+    async waitOnTaskRun(taskRunId, signal) {
+        return new Promise((resolve, reject) => {
+            let eventSource = null;
+            const abortHandler = () => {
+                cleanup();
+                reject(new errors_js_1.AbortError());
+            };
+            const cleanup = () => {
+                if (eventSource) {
+                    eventSource.removeEventListener(TaskEventType.COMPLETED, eventHandler);
+                    eventSource.removeEventListener(TaskEventType.FAILED, eventHandler);
+                    eventSource.removeEventListener("error", errorHandler);
+                    eventSource.close();
+                    eventSource = null;
+                }
+                signal?.removeEventListener("abort", abortHandler);
+            };
+            const eventHandler = (event) => {
+                try {
+                    const details = JSON.parse(event.data);
+                    cleanup();
+                    resolve(details);
+                }
+                catch (e) {
+                    cleanup();
+                    reject(new Error(`Failed to parse task run details: ${e}`));
+                }
+            };
+            const errorHandler = (error) => {
+                cleanup();
+                reject(new Error(`SSE connection error: ${error.message || "Unknown error"}`));
+            };
+            if (signal?.aborted) {
+                reject(new errors_js_1.AbortError());
+                return;
+            }
+            signal?.addEventListener("abort", abortHandler);
+            try {
+                const url = new URL("/v1/task-runs/events", this.baseUrl);
+                url.searchParams.append("taskRunIds", taskRunId);
+                eventSource = new eventsource_1.EventSource(url.toString(), {
+                    fetch: (input, init) => fetch(input, {
+                        ...init,
+                        headers: {
+                            ...init?.headers,
+                            Authorization: `Bearer ${this.token}`,
+                        },
+                    }),
+                });
+                eventSource.addEventListener(TaskEventType.COMPLETED, eventHandler);
+                eventSource.addEventListener(TaskEventType.FAILED, eventHandler);
+                eventSource.addEventListener("error", errorHandler);
+            }
+            catch (e) {
+                cleanup();
+                reject(e);
+            }
+        });
+    }
+}
+exports.SSEClient = SSEClient;

package/dist/workflows/client/types.d.ts

@@ -0,0 +1,23 @@
+import type { components, paths } from "../../utils/schema";
+export type TaskIdentifier = string;
+export type TaskData = Array<any>;
+export declare enum TaskRunStatus {
+    PENDING = "pending",
+    RUNNING = "running",
+    COMPLETED = "completed",
+    FAILED = "failed"
+}
+export type TaskRun = components["schemas"]["TaskRun"];
+export type TaskRunDetails = components["schemas"]["TaskRunDetails"];
+export type ListTaskRunsParams = paths["/task-runs"]["get"]["parameters"]["query"];
+export interface RunTaskRequest {
+    task: TaskIdentifier;
+    input: TaskData;
+}
+export interface ClientOptions {
+    token?: string;
+    baseUrl?: string;
+    useLocalDev?: boolean;
+    localDevUrl?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/workflows/client/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/workflows/client/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAK5D,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC;AAKpC,MAAM,MAAM,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;AAKlC,oBAAY,aAAa;IACvB,OAAO,YAAY;IACnB,OAAO,YAAY;IACnB,SAAS,cAAc;IACvB,MAAM,WAAW;CAClB;AAMD,MAAM,MAAM,OAAO,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,SAAS,CAAC,CAAC;AAMvD,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,gBAAgB,CAAC,CAAC;AAKrE,MAAM,MAAM,kBAAkB,GAAG,KAAK,CAAC,YAAY,CAAC,CAAC,KAAK,CAAC,CAAC,YAAY,CAAC,CAAC,OAAO,CAAC,CAAC;AAKnF,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,cAAc,CAAC;IACrB,KAAK,EAAE,QAAQ,CAAC;CACjB;AAKD,MAAM,WAAW,aAAa;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB"}

package/dist/workflows/client/types.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskRunStatus = void 0;
+var TaskRunStatus;
+(function (TaskRunStatus) {
+    TaskRunStatus["PENDING"] = "pending";
+    TaskRunStatus["RUNNING"] = "running";
+    TaskRunStatus["COMPLETED"] = "completed";
+    TaskRunStatus["FAILED"] = "failed";
+})(TaskRunStatus || (exports.TaskRunStatus = TaskRunStatus = {}));

package/dist/workflows/client/workflows.d.ts

@@ -0,0 +1,15 @@
+import type { Client } from 'openapi-fetch';
+import type { paths } from './schema.js';
+import type { SSEClient } from './sse.js';
+import type { ListTaskRunsParams, TaskData, TaskIdentifier, TaskRun, TaskRunDetails } from './types.js';
+export declare class WorkflowsService {
+    private sseClient;
+    private apiClient;
+    constructor(sseClient: SSEClient, apiClient: Client<paths>);
+    runTask(taskIdentifier: TaskIdentifier, inputData: TaskData): Promise<TaskRun>;
+    waitForTask(taskRunId: string): Promise<TaskRunDetails>;
+    getTaskRun(taskRunId: string): Promise<TaskRunDetails>;
+    cancelTaskRun(taskRunId: string): Promise<void>;
+    listTaskRuns(params: ListTaskRunsParams): Promise<TaskRun[]>;
+}
+//# sourceMappingURL=workflows.d.ts.map

package/dist/workflows/client/workflows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflows.d.ts","sourceRoot":"","sources":["../../../src/workflows/client/workflows.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAE5C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,KAAK,EACV,kBAAkB,EAClB,QAAQ,EACR,cAAc,EACd,OAAO,EACP,cAAc,EACf,MAAM,YAAY,CAAC;AAoBpB,qBAAa,gBAAgB;IAEzB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,SAAS;gBADT,SAAS,EAAE,SAAS,EACpB,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC;IAS5B,OAAO,CAAC,cAAc,EAAE,cAAc,EAAE,SAAS,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC;IAe9E,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IAUvD,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IAetD,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAe/C,YAAY,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;CASnE"}

package/dist/workflows/client/workflows.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowsService = void 0;
+const errors_js_1 = require("./errors.js");
+function handleApiError(error, response, context) {
+    const statusCode = response.status;
+    const errorMessage = `${context}: ${error}`;
+    if (statusCode >= 500) {
+        throw new errors_js_1.ServerError(errorMessage, statusCode, error);
+    }
+    else if (statusCode >= 400) {
+        throw new errors_js_1.ClientError(errorMessage, statusCode, error);
+    }
+    throw new errors_js_1.ClientError(errorMessage, statusCode, error);
+}
+class WorkflowsService {
+    constructor(sseClient, apiClient) {
+        this.sseClient = sseClient;
+        this.apiClient = apiClient;
+    }
+    async runTask(taskIdentifier, inputData) {
+        const { data, error, response } = await this.apiClient.POST('/task-runs', {
+            body: {
+                task: taskIdentifier,
+                input: inputData,
+            },
+        });
+        if (error) {
+            handleApiError(error, response, 'Failed to run task');
+        }
+        return data;
+    }
+    async waitForTask(taskRunId) {
+        return this.sseClient.waitOnTaskRun(taskRunId);
+    }
+    async getTaskRun(taskRunId) {
+        const { data, error, response } = await this.apiClient.GET('/task-runs/{taskRunId}', {
+            params: { path: { taskRunId } },
+        });
+        if (error) {
+            handleApiError(error, response, 'Failed to get task run');
+        }
+        return data;
+    }
+    async cancelTaskRun(taskRunId) {
+        const { error, response } = await this.apiClient.DELETE('/task-runs/{taskRunId}', {
+            params: { path: { taskRunId } },
+        });
+        if (error) {
+            handleApiError(error, response, 'Failed to cancel task run');
+        }
+    }
+    async listTaskRuns(params) {
+        const { data, error, response } = await this.apiClient.GET('/task-runs', {
+            params: { query: params },
+        });
+        if (error) {
+            handleApiError(error, response, 'Failed to list task runs');
+        }
+        return data;
+    }
+}
+exports.WorkflowsService = WorkflowsService;

package/dist/workflows/executor.d.ts

@@ -0,0 +1,8 @@
+export declare class TaskExecutor {
+    private udsClient;
+    private context;
+    constructor(socketPath: string);
+    executeTask(): Promise<void>;
+    registerTasks(): Promise<void>;
+}
+//# sourceMappingURL=executor.d.ts.map

package/dist/workflows/executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../src/workflows/executor.ts"],"names":[],"mappings":"AAyEA,qBAAa,YAAY;IACvB,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,OAAO,CAAc;gBAEjB,UAAU,EAAE,MAAM;IAQxB,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAiC5B,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;CAKrC"}

package/dist/workflows/executor.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskExecutor = void 0;
+const errors_js_1 = require("../errors.js");
+const registry_js_1 = require("./registry.js");
+const task_js_1 = require("./task.js");
+const uds_js_1 = require("./uds.js");
+class TaskResultImpl {
+    constructor(subtaskId, udsClient) {
+        this.subtaskId = subtaskId;
+        this.udsClient = udsClient;
+    }
+    async get() {
+        const pollInterval = 500;
+        while (true) {
+            const result = await this.udsClient.getSubtaskResult(this.subtaskId);
+            if (!result.still_running && result.complete) {
+                if (result.complete.output) {
+                    const json = Buffer.from(result.complete.output, "base64").toString();
+                    const decoded = JSON.parse(json);
+                    return decoded[0];
+                }
+                return undefined;
+            }
+            else if (!result.still_running && result.error) {
+                throw new errors_js_1.RenderError(`Subtask failed: ${result.error}`);
+            }
+            await new Promise((resolve) => setTimeout(resolve, pollInterval));
+        }
+    }
+}
+class TaskContextImpl {
+    constructor(udsClient) {
+        this.udsClient = udsClient;
+    }
+    executeTask(_task, taskName, ...args) {
+        const registry = registry_js_1.TaskRegistry.getInstance();
+        if (!registry.has(taskName)) {
+            throw new errors_js_1.RenderError(`Task '${taskName}' is not registered`);
+        }
+        const subtaskIdPromise = this.udsClient.runSubtask(taskName, args);
+        return {
+            get: async () => {
+                const subtaskId = await subtaskIdPromise;
+                const result = new TaskResultImpl(subtaskId, this.udsClient);
+                return result.get();
+            },
+        };
+    }
+}
+class TaskExecutor {
+    constructor(socketPath) {
+        this.udsClient = new uds_js_1.UDSClient(socketPath);
+        this.context = new TaskContextImpl(this.udsClient);
+    }
+    async executeTask() {
+        const registry = registry_js_1.TaskRegistry.getInstance();
+        try {
+            const input = await this.udsClient.getInput();
+            const taskName = input.task_name;
+            const inputData = JSON.parse(Buffer.from(input.input, "base64").toString());
+            const taskMetadata = registry.get(taskName);
+            if (!taskMetadata) {
+                throw new errors_js_1.RenderError(`Task '${taskName}' not found in registry`);
+            }
+            const result = await (0, task_js_1.setCurrentContext)(this.context, async () => {
+                return await taskMetadata.func(...inputData);
+            });
+            await this.udsClient.sendCallback(result);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            await this.udsClient.sendCallback(undefined, errorMessage);
+            throw error;
+        }
+    }
+    async registerTasks() {
+        const registry = registry_js_1.TaskRegistry.getInstance();
+        const tasks = registry.getAllTasks();
+        await this.udsClient.registerTasks(tasks);
+    }
+}
+exports.TaskExecutor = TaskExecutor;

package/dist/workflows/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./client/index.js";
+export { TaskExecutor } from "./executor.js";
+export { TaskRegistry } from "./registry.js";
+export { run, startTaskServer } from "./runner.js";
+export { getCurrentContext, setCurrentContext, task } from "./task.js";
+export * from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/workflows/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/workflows/index.ts"],"names":[],"mappings":"AACA,cAAc,mBAAmB,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAE,GAAG,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACvE,cAAc,YAAY,CAAC"}

package/dist/workflows/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.task = exports.setCurrentContext = exports.getCurrentContext = exports.startTaskServer = exports.run = exports.TaskRegistry = exports.TaskExecutor = void 0;
+__exportStar(require("./client/index.js"), exports);
+var executor_js_1 = require("./executor.js");
+Object.defineProperty(exports, "TaskExecutor", { enumerable: true, get: function () { return executor_js_1.TaskExecutor; } });
+var registry_js_1 = require("./registry.js");
+Object.defineProperty(exports, "TaskRegistry", { enumerable: true, get: function () { return registry_js_1.TaskRegistry; } });
+var runner_js_1 = require("./runner.js");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return runner_js_1.run; } });
+Object.defineProperty(exports, "startTaskServer", { enumerable: true, get: function () { return runner_js_1.startTaskServer; } });
+var task_js_1 = require("./task.js");
+Object.defineProperty(exports, "getCurrentContext", { enumerable: true, get: function () { return task_js_1.getCurrentContext; } });
+Object.defineProperty(exports, "setCurrentContext", { enumerable: true, get: function () { return task_js_1.setCurrentContext; } });
+Object.defineProperty(exports, "task", { enumerable: true, get: function () { return task_js_1.task; } });
+__exportStar(require("./types.js"), exports);

package/dist/workflows/registry.d.ts

@@ -0,0 +1,14 @@
+import type { RegisterTaskOptions, TaskFunction, TaskMetadata } from "./types.js";
+export declare class TaskRegistry {
+    private static instance;
+    private tasks;
+    private constructor();
+    static getInstance(): TaskRegistry;
+    register(func: TaskFunction, options: RegisterTaskOptions): void;
+    get(name: string): TaskMetadata | undefined;
+    getAllTaskNames(): string[];
+    getAllTasks(): TaskMetadata[];
+    has(name: string): boolean;
+    clear(): void;
+}
+//# sourceMappingURL=registry.d.ts.map

package/dist/workflows/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/workflows/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,YAAY,EAAE,YAAY,EAAe,MAAM,YAAY,CAAC;AAK/F,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAe;IACtC,OAAO,CAAC,KAAK,CAAwC;IAErD,OAAO;IAEP,MAAM,CAAC,WAAW,IAAI,YAAY;IAUlC,QAAQ,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE,mBAAmB,GAAG,IAAI;IA4BhE,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAO3C,eAAe,IAAI,MAAM,EAAE;IAI3B,WAAW,IAAI,YAAY,EAAE;IAO7B,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAO1B,KAAK,IAAI,IAAI;CAGd"}

package/dist/workflows/registry.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskRegistry = void 0;
+class TaskRegistry {
+    constructor() {
+        this.tasks = new Map();
+    }
+    static getInstance() {
+        if (!TaskRegistry.instance) {
+            TaskRegistry.instance = new TaskRegistry();
+        }
+        return TaskRegistry.instance;
+    }
+    register(func, options) {
+        const taskName = options.name;
+        if (!taskName) {
+            throw new Error("Task function must have a name or name must be provided");
+        }
+        let taskOptions;
+        if (options.retry) {
+            taskOptions = {
+                retry: {
+                    max_retries: options.retry.maxRetries,
+                    wait_duration_ms: options.retry.waitDuration,
+                    factor: options.retry.backoffScaling,
+                },
+            };
+        }
+        this.tasks.set(taskName, {
+            name: taskName,
+            func,
+            options: taskOptions,
+        });
+    }
+    get(name) {
+        return this.tasks.get(name);
+    }
+    getAllTaskNames() {
+        return Array.from(this.tasks.keys());
+    }
+    getAllTasks() {
+        return Array.from(this.tasks.values());
+    }
+    has(name) {
+        return this.tasks.has(name);
+    }
+    clear() {
+        this.tasks.clear();
+    }
+}
+exports.TaskRegistry = TaskRegistry;

package/dist/workflows/runner.d.ts

@@ -0,0 +1,3 @@
+export declare function startTaskServer(): Promise<void>;
+export declare function run(socketPath: string): Promise<void>;
+//# sourceMappingURL=runner.d.ts.map

package/dist/workflows/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/workflows/runner.ts"],"names":[],"mappings":"AAMA,wBAAsB,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC,CAmBrD;AAKD,wBAAsB,GAAG,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAG3D"}

package/dist/workflows/runner.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startTaskServer = startTaskServer;
+exports.run = run;
+const errors_js_1 = require("../errors.js");
+const executor_js_1 = require("./executor.js");
+async function startTaskServer() {
+    const mode = process.env.RENDER_SDK_MODE || "run";
+    const socketPath = process.env.RENDER_SDK_SOCKET_PATH;
+    if (!socketPath) {
+        throw new errors_js_1.RenderError("RENDER_SDK_SOCKET_PATH environment variable is required");
+    }
+    const executor = new executor_js_1.TaskExecutor(socketPath);
+    if (mode === "register") {
+        await executor.registerTasks();
+    }
+    else if (mode === "run") {
+        await executor.executeTask();
+    }
+    else {
+        throw new errors_js_1.RenderError(`Unknown SDK mode: ${mode}`);
+    }
+}
+async function run(socketPath) {
+    const executor = new executor_js_1.TaskExecutor(socketPath);
+    await executor.executeTask();
+}