@exaudeus/workrail 3.43.0 → 3.45.0

package/dist/daemon/workflow-runner.js

@@ -1081,6 +1081,16 @@ function makeSpawnAgentTool(sessionId, ctx, apiKey, thisWorkrailSessionId, curre
                     notes: childResult.message,
                 };
             }
+            else if (childResult._tag === 'stuck') {
+                resultObj = {
+                    childSessionId,
+                    outcome: 'stuck',
+                    notes: childResult.message,
+                    ...(childResult.issueSummaries !== undefined
+                        ? { issueSummaries: childResult.issueSummaries }
+                        : {}),
+                };
+            }
             else {
                 (0, assert_never_js_1.assertNever)(childResult);
             }
@@ -1093,6 +1103,31 @@ function makeSpawnAgentTool(sessionId, ctx, apiKey, thisWorkrailSessionId, curre
         },
     };
 }
+async function writeStuckOutboxEntry(opts) {
+    try {
+        const outboxPath = path.join(os.homedir(), '.workrail', 'outbox.jsonl');
+        await fs.mkdir(path.dirname(outboxPath), { recursive: true });
+        const entry = JSON.stringify({
+            id: (0, node_crypto_1.randomUUID)(),
+            kind: 'stuck',
+            message: `Session stuck (${opts.reason}): workflowId=${opts.workflowId}` +
+                (opts.issueSummaries && opts.issueSummaries.length > 0
+                    ? ` -- issues: ${opts.issueSummaries.join('; ')}`
+                    : ''),
+            timestamp: new Date().toISOString(),
+            workflowId: opts.workflowId,
+            reason: opts.reason,
+            ...(opts.issueSummaries && opts.issueSummaries.length > 0
+                ? { issueSummaries: opts.issueSummaries }
+                : {}),
+        });
+        await fs.appendFile(outboxPath, entry + '\n');
+    }
+    catch (err) {
+        console.warn(`[WorkflowRunner] Could not write stuck outbox entry: ` +
+            `${err instanceof Error ? err.message : String(err)}`);
+    }
+}
 async function appendIssueAsync(issuesDir, sessionId, record) {
     await fs.mkdir(issuesDir, { recursive: true });
     const filePath = path.join(issuesDir, `${sessionId}.jsonl`);
@@ -1484,6 +1519,19 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
             };
         }
     }
+    if (trigger.botIdentity) {
+        try {
+            await execFileAsync('git', ['-C', sessionWorkspacePath, 'config', 'user.name', trigger.botIdentity.name]);
+            await execFileAsync('git', ['-C', sessionWorkspacePath, 'config', 'user.email', trigger.botIdentity.email]);
+            console.log(`[WorkflowRunner] Bot identity set: sessionId=${sessionId} ` +
+                `name=${trigger.botIdentity.name} email=${trigger.botIdentity.email}`);
+        }
+        catch (identityErr) {
+            console.warn(`[WorkflowRunner] WARNING: Failed to set bot identity for sessionId=${sessionId}: ` +
+                `${identityErr instanceof Error ? identityErr.message : String(identityErr)}. ` +
+                `Commits will use default git config.`);
+        }
+    }
     if (firstStep.isComplete) {
         await fs.unlink(path.join(exports.DAEMON_SESSIONS_DIR, `${sessionId}.json`)).catch(() => { });
         emitter?.emit({ kind: 'session_completed', sessionId, workflowId: trigger.workflowId, outcome: 'success', detail: 'stop', ...withWorkrailSession(workrailSessionId) });
@@ -1575,7 +1623,10 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
     });
     const sessionTimeoutMs = (trigger.agentConfig?.maxSessionMinutes ?? DEFAULT_SESSION_TIMEOUT_MINUTES) * 60 * 1000;
     const maxTurns = trigger.agentConfig?.maxTurns ?? DEFAULT_MAX_TURNS;
+    const sessionStartMs = Date.now();
+    void sessionStartMs;
     let timeoutReason = null;
+    let stuckReason = null;
     let turnCount = 0;
     const unsubscribe = agent.subscribe(async (event) => {
         if (event.type !== 'turn_end')
@@ -1610,6 +1661,17 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
                 argsSummary: lastNToolCalls[0]?.argsSummary,
                 ...withWorkrailSession(workrailSessionId),
             });
+            void writeStuckOutboxEntry({
+                workflowId: trigger.workflowId,
+                reason: 'repeated_tool_call',
+                ...(issueSummaries.length > 0 ? { issueSummaries: [...issueSummaries] } : {}),
+            });
+            const stuckPolicy = trigger.agentConfig?.stuckAbortPolicy ?? 'abort';
+            if (stuckPolicy !== 'notify_only' && stuckReason === null && timeoutReason === null) {
+                stuckReason = 'repeated_tool_call';
+                agent.abort();
+                return;
+            }
         }
         if (maxTurns > 0 &&
             turnCount >= Math.floor(maxTurns * 0.8) &&
@@ -1621,6 +1683,20 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
                 detail: `${turnCount} turns used, 0 step advances (${maxTurns} turn limit)`,
                 ...withWorkrailSession(workrailSessionId),
             });
+            const noProgressAbortEnabled = trigger.agentConfig?.noProgressAbortEnabled ?? false;
+            if (noProgressAbortEnabled) {
+                void writeStuckOutboxEntry({
+                    workflowId: trigger.workflowId,
+                    reason: 'no_progress',
+                    ...(issueSummaries.length > 0 ? { issueSummaries: [...issueSummaries] } : {}),
+                });
+                const noProgressPolicy = trigger.agentConfig?.stuckAbortPolicy ?? 'abort';
+                if (noProgressPolicy !== 'notify_only' && stuckReason === null && timeoutReason === null) {
+                    stuckReason = 'no_progress';
+                    agent.abort();
+                    return;
+                }
+            }
         }
         if (timeoutReason !== null) {
             emitter?.emit({
@@ -1680,6 +1756,26 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
         }
         console.log(`[WorkflowRunner] Agent loop ended: sessionId=${sessionId} stopReason=${stopReason}${errorMessage ? ` error=${errorMessage.slice(0, 120)}` : ''}`);
     }
+    if (stuckReason !== null) {
+        emitter?.emit({
+            kind: 'session_completed',
+            sessionId,
+            workflowId: trigger.workflowId,
+            outcome: 'timeout',
+            detail: stuckReason,
+            ...withWorkrailSession(workrailSessionId),
+        });
+        if (workrailSessionId !== null)
+            daemonRegistry?.unregister(workrailSessionId, 'failed');
+        return {
+            _tag: 'stuck',
+            workflowId: trigger.workflowId,
+            reason: stuckReason,
+            message: `Session aborted: stuck heuristic fired (${stuckReason})`,
+            stopReason: 'aborted',
+            ...(issueSummaries.length > 0 ? { issueSummaries: [...issueSummaries] } : {}),
+        };
+    }
     if (timeoutReason !== null) {
         emitter?.emit({ kind: 'session_completed', sessionId, workflowId: trigger.workflowId, outcome: 'timeout', detail: timeoutReason, ...withWorkrailSession(workrailSessionId) });
         if (workrailSessionId !== null)
@@ -1687,6 +1783,7 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
         const limitDescription = timeoutReason === 'wall_clock'
             ? `${trigger.agentConfig?.maxSessionMinutes ?? DEFAULT_SESSION_TIMEOUT_MINUTES} minutes`
             : `${trigger.agentConfig?.maxTurns ?? DEFAULT_MAX_TURNS} turns`;
+        await fs.unlink(path.join(exports.DAEMON_SESSIONS_DIR, `${sessionId}.json`)).catch(() => { });
         return {
             _tag: 'timeout',
             workflowId: trigger.workflowId,
@@ -1711,6 +1808,7 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry, emitter, steerR
             ...(lastToolCalled !== null && { lastToolCalled }),
             ...(issueSummaries.length > 0 && { issueSummaries }),
         })}`;
+        await fs.unlink(path.join(exports.DAEMON_SESSIONS_DIR, `${sessionId}.json`)).catch(() => { });
         return {
             _tag: 'error',
             workflowId: trigger.workflowId,

package/dist/manifest.json

@@ -449,16 +449,16 @@
       "sha256": "5fe866e54f796975dec5d8ba9983aefd86074db212d3fccd64eed04bc9f0b3da",
       "bytes": 8011
     },
+    "console-ui/assets/index-BpanIvmi.js": {
+      "sha256": "e5c3e897dbda3f810ce737422d3f84d06b8e146c7923041fbd96b276538435c6",
+      "bytes": 760528
+    },
     "console-ui/assets/index-DGj8EsFR.css": {
       "sha256": "3bdb55ec0957928e0ebbb86a7d6b36d28f7ba7d5c0f3e236fd8f2e2aacee2fa4",
       "bytes": 60631
     },
-    "console-ui/assets/index-Sb57DW4B.js": {
-      "sha256": "54d09def45773f707ebf2bc17d109411a36ae1098d97d1f81a7423c69686520a",
-      "bytes": 760528
-    },
     "console-ui/index.html": {
-      "sha256": "5f4e96c20ab0286c7be620fbaa3fd18728866e25b320ea8622fdda58f81b047a",
+      "sha256": "587aa7591502ca4dadbea5c7f5c56136d19f18d179c735abe693e9ee2c290e1e",
       "bytes": 417
     },
     "console/standalone-console.d.ts": {
@@ -550,12 +550,12 @@
       "bytes": 1512
     },
     "daemon/workflow-runner.d.ts": {
-      "sha256": "ba96e9b4437632c760a6da9b3d70e676a2ad0a0f0a6ae037ec83419d7ffaf7a8",
-      "bytes": 6529
+      "sha256": "4c67cc7a44c934469c190f11a71bd18bf0dfc31f59ab0c315b98315b96d59cce",
+      "bytes": 7048
     },
     "daemon/workflow-runner.js": {
-      "sha256": "24acc5dce22f6619a05d7a5268a82f801a25d99e1fd8d7c021d2b47ce01deba8",
-      "bytes": 88602
+      "sha256": "a5d74ec723ff0dce45d2335b811959ff0c6e6f8851edf399a70853f6bf127893",
+      "bytes": 93222
     },
     "di/container.d.ts": {
       "sha256": "003bb7fb7478d627524b9b1e76bd0a963a243794a687ff233b96dc0e33a06d9f",
@@ -1549,6 +1549,14 @@
       "sha256": "dd1a1bc20f1bf6da550960887c75fab4a794c19a1b79f3c89f4277145d009c2e",
       "bytes": 6723
     },
+    "trigger/adapters/github-queue-poller.d.ts": {
+      "sha256": "f36b01b118e6986e8f89701fc5d88fa7a1873fb38acaa67b1612895056bd5ef8",
+      "bytes": 1363
+    },
+    "trigger/adapters/github-queue-poller.js": {
+      "sha256": "73270636634fb8673c63b0c0347e6e5d7f676606d36b87a4c1aadc11f1939eb2",
+      "bytes": 7340
+    },
     "trigger/adapters/gitlab-poller.d.ts": {
       "sha256": "f685490fafad77194fdd0f0bbaf80dbc56730aeb344853da365199a120fbe399",
       "bytes": 911
@@ -1581,6 +1589,14 @@
       "sha256": "da358ced4e99c327493b6d3ca975a623aca21f72e68787a092b2760601801c99",
       "bytes": 1269
     },
+    "trigger/github-queue-config.d.ts": {
+      "sha256": "bff922c1b435da55e02b4b11d3fde9f06e999f13b8ac0494788cac4a4fc4c432",
+      "bytes": 766
+    },
+    "trigger/github-queue-config.js": {
+      "sha256": "a0ec09a7725ac1ee1adb9d41fdcb4c9545128f0b9515c6de4df9535d4bec1acc",
+      "bytes": 6857
+    },
     "trigger/index.d.ts": {
       "sha256": "a9cfd053714173e2a8cc5a282fd5b09a5c3f3001304d507facd0e12de9cc0733",
       "bytes": 735
@@ -1590,12 +1606,12 @@
       "bytes": 1222
     },
     "trigger/notification-service.d.ts": {
-      "sha256": "c78406d3748953548f7879df8ac60cecd5e42f2f3b283f777343168ce2470b8d",
-      "bytes": 1572
+      "sha256": "25509f290a11ac9a8aa03e5d7e44011950c841436e9458eb855b94d15d036d68",
+      "bytes": 1582
     },
     "trigger/notification-service.js": {
-      "sha256": "693f617adc30b3a4fcebeca6a78b0da1c58819001660c017a4d0901652d675b8",
-      "bytes": 6373
+      "sha256": "9d9a5951229f2c6ffaa413a7421efa6611d9ca0ed456edf5c297a4506e84a80e",
+      "bytes": 6521
     },
     "trigger/polled-event-store.d.ts": {
       "sha256": "2952a25804177b2389d4273bfc41192477d100bc26100683861dedf28520dec1",
@@ -1606,12 +1622,12 @@
       "bytes": 6968
     },
     "trigger/polling-scheduler.d.ts": {
-      "sha256": "c5f984df836dbc78ec51bfc78fa5a26973aff56e6f88e0cf11776057f940b2b6",
-      "bytes": 761
+      "sha256": "009b3340f5d46a3fc22b9cd087abcf484abe34c526a46dd4f958768fb8f61c9c",
+      "bytes": 792
     },
     "trigger/polling-scheduler.js": {
-      "sha256": "e77a5eb32a54d98e9f7178fc15d7c237809519c183eea716cd01b7b9a2aae62e",
-      "bytes": 10255
+      "sha256": "ec3c73739c9dfbbe3b2d7a55237fd35a290d6aab7bbc30ec5408bde69b2c95e0",
+      "bytes": 19769
     },
     "trigger/trigger-listener.d.ts": {
       "sha256": "92e971ab8f47c3c867860cffc01f54c4aae54fcc4ae199b9469210f4ce639423",
@@ -1626,20 +1642,20 @@
       "bytes": 2123
     },
     "trigger/trigger-router.js": {
-      "sha256": "605cdce397bd19e5b991fe7378faf17b4f25b4421749e1b5349413a208a4f3dd",
-      "bytes": 17250
+      "sha256": "8a4a4699df4210b5631211e7370ed6b70d972e82321cf8c66dcc9f60661e5d2c",
+      "bytes": 17750
     },
     "trigger/trigger-store.d.ts": {
       "sha256": "7afb05127d55bc3757a550dd15d4b797766b3fff29d1bfe76b303764b93322e7",
       "bytes": 1588
     },
     "trigger/trigger-store.js": {
-      "sha256": "f4e5c6d28db4c9c05df07b29eb627bc7a48f234a2c16ea4adfe57de24ca6bf38",
-      "bytes": 36591
+      "sha256": "8015b54da7ab5b1cec78e1ecea099d5b457eaa5de267bb1ed52cbb75eca207c4",
+      "bytes": 38148
     },
     "trigger/types.d.ts": {
-      "sha256": "f9ccdc2bea0bee7557362cc7b64d89ed3ab26f7cd954e05395ce4cabe536ab02",
-      "bytes": 2929
+      "sha256": "a1336ad769dbe4760e7acd3b2a92961251492aa29245b5d906ad89011ea934fa",
+      "bytes": 3587
     },
     "trigger/types.js": {
       "sha256": "45b4e4f23a6d1a2b07350196871b0c53840e5d8142b47f7acedd2f40ae7a6b73",
@@ -2954,8 +2970,8 @@
       "bytes": 798
     },
     "v2/usecases/console-routes.js": {
-      "sha256": "89749c3462728cd2a821af7e4cad61d2d42b8f580765f644c9f4e9d1e9187bd1",
-      "bytes": 29558
+      "sha256": "3e8bd3adfdc66926d91044506d2c77253b784b9e4356a8610c585e6a27153d4b",
+      "bytes": 29776
     },
     "v2/usecases/console-service.d.ts": {
       "sha256": "fc8fe65427fa9f4f3535344b385b36f66ca06b7e3bfaea708931817a3edcad2b",

package/dist/trigger/adapters/github-queue-poller.d.ts

@@ -0,0 +1,34 @@
+import type { GitHubQueuePollingSource } from '../types.js';
+import type { GitHubQueueConfig } from '../github-queue-config.js';
+import type { Result } from '../../runtime/result.js';
+export interface GitHubQueueLabel {
+    readonly name: string;
+}
+export interface GitHubQueueIssue {
+    readonly id: number;
+    readonly number: number;
+    readonly title: string;
+    readonly body: string;
+    readonly url: string;
+    readonly labels: readonly GitHubQueueLabel[];
+    readonly createdAt: string;
+}
+export type GitHubQueuePollError = {
+    readonly kind: 'http_error';
+    readonly status: number;
+    readonly message: string;
+} | {
+    readonly kind: 'network_error';
+    readonly message: string;
+} | {
+    readonly kind: 'parse_error';
+    readonly message: string;
+} | {
+    readonly kind: 'not_implemented';
+    readonly message: string;
+};
+export type FetchFn = (url: string, init: RequestInit) => Promise<Response>;
+export declare const DEFAULT_SESSIONS_DIR: string;
+export declare function pollGitHubQueueIssues(source: GitHubQueuePollingSource, config: GitHubQueueConfig, fetchFn?: FetchFn): Promise<Result<GitHubQueueIssue[], GitHubQueuePollError>>;
+export declare function inferMaturity(body: string): 'idea' | 'specced' | 'ready';
+export declare function checkIdempotency(issueNumber: number, sessionsDir?: string): Promise<'clear' | 'active'>;

package/dist/trigger/adapters/github-queue-poller.js

@@ -0,0 +1,200 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SESSIONS_DIR = void 0;
+exports.pollGitHubQueueIssues = pollGitHubQueueIssues;
+exports.inferMaturity = inferMaturity;
+exports.checkIdempotency = checkIdempotency;
+const result_js_1 = require("../../runtime/result.js");
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+exports.DEFAULT_SESSIONS_DIR = path.join(os.homedir(), '.workrail', 'daemon-sessions');
+function checkRateLimit(response) {
+    const remainingHeader = response.headers.get('X-RateLimit-Remaining');
+    const resetHeader = response.headers.get('X-RateLimit-Reset');
+    if (remainingHeader === null)
+        return true;
+    const remaining = parseInt(remainingHeader, 10);
+    if (isNaN(remaining) || remaining >= 100)
+        return true;
+    const resetTs = parseInt(resetHeader ?? '0', 10);
+    const resetAt = resetTs > 0 ? new Date(resetTs * 1000).toISOString() : 'unknown';
+    console.warn(`[GitHubQueuePoller] Rate limit low: remaining=${remaining}, resets at ${resetAt}. ` +
+        `Skipping poll cycle to avoid exhaustion.`);
+    return false;
+}
+async function pollGitHubQueueIssues(source, config, fetchFn = globalThis.fetch) {
+    if (config.type !== 'assignee') {
+        return (0, result_js_1.err)({
+            kind: 'not_implemented',
+            message: `Queue type '${config.type}' is not implemented. Only 'assignee' is supported.`,
+        });
+    }
+    const [owner, repo] = source.repo.split('/');
+    const url = new URL(`https://api.github.com/repos/${owner}/${repo}/issues`);
+    url.searchParams.set('state', 'open');
+    url.searchParams.set('per_page', '100');
+    if (config.user) {
+        url.searchParams.set('assignee', config.user);
+    }
+    let response;
+    try {
+        response = await fetchFn(url.toString(), {
+            headers: {
+                'Authorization': `Bearer ${source.token}`,
+                'Accept': 'application/vnd.github+json',
+                'X-GitHub-Api-Version': '2022-11-28',
+            },
+        });
+    }
+    catch (e) {
+        return (0, result_js_1.err)({
+            kind: 'network_error',
+            message: e instanceof Error ? e.message : String(e),
+        });
+    }
+    if (!response.ok) {
+        return (0, result_js_1.err)({
+            kind: 'http_error',
+            status: response.status,
+            message: `GitHub API returned HTTP ${response.status}: ${response.statusText}`,
+        });
+    }
+    if (!checkRateLimit(response)) {
+        return (0, result_js_1.ok)([]);
+    }
+    let raw;
+    try {
+        raw = await response.json();
+    }
+    catch (e) {
+        return (0, result_js_1.err)({
+            kind: 'parse_error',
+            message: `Failed to parse GitHub Issues API response: ${e instanceof Error ? e.message : String(e)}`,
+        });
+    }
+    if (!Array.isArray(raw)) {
+        return (0, result_js_1.err)({
+            kind: 'parse_error',
+            message: `Expected array from GitHub Issues API, got: ${typeof raw}`,
+        });
+    }
+    const issues = [];
+    for (const item of raw) {
+        const shaped = toGitHubQueueIssue(item);
+        if (shaped !== null) {
+            issues.push(shaped);
+        }
+    }
+    return (0, result_js_1.ok)(issues);
+}
+function inferMaturity(body) {
+    const specLineMatch = /upstream_spec:\s*(https?:\/\/\S+)/i.exec(body);
+    if (specLineMatch)
+        return 'ready';
+    const firstPara = body.split(/\n\s*\n/)[0] ?? '';
+    if (/https?:\/\/\S*\/(?:pitch|prd|spec|brd|rfc|design)\b/i.test(firstPara))
+        return 'ready';
+    if (/- \[ \]/.test(body))
+        return 'specced';
+    if (/^#{1,6}\s*(Acceptance Criteria|Implementation Plan)\s*$/im.test(body))
+        return 'specced';
+    return 'idea';
+}
+async function checkIdempotency(issueNumber, sessionsDir = exports.DEFAULT_SESSIONS_DIR) {
+    let files;
+    try {
+        files = await fs.readdir(sessionsDir);
+    }
+    catch {
+        return 'clear';
+    }
+    const jsonFiles = files.filter(f => f.endsWith('.json'));
+    for (const filename of jsonFiles) {
+        try {
+            const content = await fs.readFile(path.join(sessionsDir, filename), 'utf8');
+            const parsed = JSON.parse(content);
+            if (typeof parsed !== 'object' || parsed === null) {
+                return 'active';
+            }
+            const session = parsed;
+            const context = session['context'];
+            if (typeof context !== 'object' || context === null) {
+                continue;
+            }
+            const ctx = context;
+            const taskCandidate = ctx['taskCandidate'];
+            if (typeof taskCandidate !== 'object' || taskCandidate === null) {
+                continue;
+            }
+            const tc = taskCandidate;
+            if (tc['issueNumber'] === issueNumber) {
+                return 'active';
+            }
+        }
+        catch {
+            return 'active';
+        }
+    }
+    return 'clear';
+}
+function toGitHubQueueIssue(item) {
+    if (typeof item !== 'object' || item === null)
+        return null;
+    const obj = item;
+    if (typeof obj['id'] !== 'number' ||
+        typeof obj['number'] !== 'number' ||
+        typeof obj['title'] !== 'string' ||
+        typeof obj['html_url'] !== 'string') {
+        return null;
+    }
+    const body = typeof obj['body'] === 'string' ? obj['body'] : '';
+    const createdAt = typeof obj['created_at'] === 'string' ? obj['created_at'] : '';
+    const rawLabels = Array.isArray(obj['labels']) ? obj['labels'] : [];
+    const labels = rawLabels
+        .filter((l) => typeof l === 'object' && l !== null)
+        .filter((l) => typeof l['name'] === 'string')
+        .map((l) => ({ name: l['name'] }));
+    return {
+        id: obj['id'],
+        number: obj['number'],
+        title: obj['title'],
+        body,
+        url: obj['html_url'],
+        labels,
+        createdAt,
+    };
+}

package/dist/trigger/github-queue-config.d.ts

@@ -0,0 +1,18 @@
+import type { Result } from '../runtime/result.js';
+export interface GitHubQueueConfig {
+    readonly type: 'assignee' | 'label' | 'mention' | 'query';
+    readonly user?: string;
+    readonly name?: string;
+    readonly handle?: string;
+    readonly search?: string;
+    readonly workOnAll?: boolean;
+    readonly pollIntervalSeconds: number;
+    readonly maxTotalConcurrentSessions: number;
+    readonly excludeLabels: readonly string[];
+    readonly repo: string;
+    readonly token: string;
+    readonly botName?: string;
+    readonly botEmail?: string;
+}
+export declare const WORKRAIL_CONFIG_PATH: string;
+export declare function loadQueueConfig(configPath?: string, env?: Record<string, string | undefined>): Promise<Result<GitHubQueueConfig | null, string>>;