patchrelay 0.36.6 → 0.36.8

package/dist/db/issue-session-store.js

@@ -0,0 +1,292 @@
+import { deriveSessionWakePlan } from "../issue-session-events.js";
+import { isoNow } from "./shared.js";
+export class IssueSessionStore {
+    connection;
+    mapIssueSessionRow;
+    mapIssueSessionEventRow;
+    getIssue;
+    deriveImplicitReactiveWake;
+    transaction;
+    upsertIssue;
+    finishRun;
+    updateRunThread;
+    setBranchOwner;
+    constructor(connection, mapIssueSessionRow, mapIssueSessionEventRow, getIssue, deriveImplicitReactiveWake, transaction, upsertIssue, finishRun, updateRunThread, setBranchOwner) {
+        this.connection = connection;
+        this.mapIssueSessionRow = mapIssueSessionRow;
+        this.mapIssueSessionEventRow = mapIssueSessionEventRow;
+        this.getIssue = getIssue;
+        this.deriveImplicitReactiveWake = deriveImplicitReactiveWake;
+        this.transaction = transaction;
+        this.upsertIssue = upsertIssue;
+        this.finishRun = finishRun;
+        this.updateRunThread = updateRunThread;
+        this.setBranchOwner = setBranchOwner;
+    }
+    getIssueSession(projectId, linearIssueId) {
+        const row = this.connection
+            .prepare("SELECT * FROM issue_sessions WHERE project_id = ? AND linear_issue_id = ?")
+            .get(projectId, linearIssueId);
+        return row ? this.mapIssueSessionRow(row) : undefined;
+    }
+    getIssueSessionByKey(issueKey) {
+        const row = this.connection.prepare("SELECT * FROM issue_sessions WHERE issue_key = ?").get(issueKey);
+        return row ? this.mapIssueSessionRow(row) : undefined;
+    }
+    appendIssueSessionEvent(params) {
+        if (params.dedupeKey) {
+            const existing = this.connection.prepare(`
+        SELECT * FROM issue_session_events
+        WHERE project_id = ? AND linear_issue_id = ? AND dedupe_key = ? AND processed_at IS NULL
+        ORDER BY id DESC LIMIT 1
+      `).get(params.projectId, params.linearIssueId, params.dedupeKey);
+            if (existing)
+                return this.mapIssueSessionEventRow(existing);
+        }
+        const now = isoNow();
+        const result = this.connection.prepare(`
+      INSERT INTO issue_session_events (
+        project_id, linear_issue_id, event_type, event_json, dedupe_key, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?)
+    `).run(params.projectId, params.linearIssueId, params.eventType, params.eventJson ?? null, params.dedupeKey ?? null, now);
+        return this.getIssueSessionEvent(Number(result.lastInsertRowid));
+    }
+    appendIssueSessionEventWithLease(lease, params) {
+        return this.withIssueSessionLease(lease.projectId, lease.linearIssueId, lease.leaseId, () => this.appendIssueSessionEvent(params));
+    }
+    appendIssueSessionEventRespectingActiveLease(projectId, linearIssueId, params) {
+        const lease = this.getActiveIssueSessionLease(projectId, linearIssueId);
+        if (!lease) {
+            return this.appendIssueSessionEvent(params);
+        }
+        return this.appendIssueSessionEventWithLease(lease, params);
+    }
+    getIssueSessionEvent(id) {
+        const row = this.connection.prepare("SELECT * FROM issue_session_events WHERE id = ?").get(id);
+        return row ? this.mapIssueSessionEventRow(row) : undefined;
+    }
+    listIssueSessionEvents(projectId, linearIssueId, options) {
+        const conditions = ["project_id = ?", "linear_issue_id = ?"];
+        const values = [projectId, linearIssueId];
+        if (options?.pendingOnly) {
+            conditions.push("processed_at IS NULL");
+        }
+        let query = `SELECT * FROM issue_session_events WHERE ${conditions.join(" AND ")} ORDER BY id`;
+        if (options?.limit !== undefined) {
+            query += " LIMIT ?";
+            values.push(options.limit);
+        }
+        const rows = this.connection.prepare(query).all(...values);
+        return rows.map(this.mapIssueSessionEventRow);
+    }
+    consumeIssueSessionEvents(projectId, linearIssueId, eventIds, runId) {
+        if (eventIds.length === 0)
+            return;
+        const now = isoNow();
+        const placeholders = eventIds.map(() => "?").join(", ");
+        this.connection.prepare(`
+      UPDATE issue_session_events
+      SET processed_at = ?, consumed_by_run_id = ?
+      WHERE project_id = ? AND linear_issue_id = ? AND id IN (${placeholders}) AND processed_at IS NULL
+    `).run(now, runId, projectId, linearIssueId, ...eventIds);
+    }
+    clearPendingIssueSessionEvents(projectId, linearIssueId) {
+        this.connection.prepare(`
+      UPDATE issue_session_events
+      SET processed_at = ?, consumed_by_run_id = NULL
+      WHERE project_id = ? AND linear_issue_id = ? AND processed_at IS NULL
+    `).run(isoNow(), projectId, linearIssueId);
+    }
+    hasPendingIssueSessionEvents(projectId, linearIssueId) {
+        const row = this.connection.prepare(`
+      SELECT 1
+      FROM issue_session_events
+      WHERE project_id = ? AND linear_issue_id = ? AND processed_at IS NULL
+      LIMIT 1
+    `).get(projectId, linearIssueId);
+        return row !== undefined;
+    }
+    peekIssueSessionWake(projectId, linearIssueId) {
+        const issue = this.getIssue(projectId, linearIssueId);
+        if (!issue)
+            return undefined;
+        const events = this.listIssueSessionEvents(projectId, linearIssueId, { pendingOnly: true });
+        const plan = deriveSessionWakePlan(issue, events);
+        if (plan?.runType) {
+            return {
+                eventIds: events.map((event) => event.id),
+                runType: plan.runType,
+                context: plan.context,
+                ...(plan.wakeReason ? { wakeReason: plan.wakeReason } : {}),
+                resumeThread: plan.resumeThread,
+            };
+        }
+        const implicitWake = this.deriveImplicitReactiveWake(issue);
+        if (!implicitWake)
+            return undefined;
+        return {
+            eventIds: [],
+            runType: implicitWake.runType,
+            context: implicitWake.context,
+            wakeReason: implicitWake.wakeReason,
+            resumeThread: false,
+        };
+    }
+    acquireIssueSessionLease(params) {
+        const now = params.now ?? isoNow();
+        const result = this.connection.prepare(`
+      UPDATE issue_sessions
+      SET lease_id = ?, worker_id = ?, leased_until = ?, updated_at = ?
+      WHERE project_id = ? AND linear_issue_id = ?
+        AND (leased_until IS NULL OR leased_until <= ? OR lease_id = ?)
+    `).run(params.leaseId, params.workerId, params.leasedUntil, now, params.projectId, params.linearIssueId, now, params.leaseId);
+        return Number(result.changes ?? 0) > 0;
+    }
+    forceAcquireIssueSessionLease(params) {
+        const now = params.now ?? isoNow();
+        const result = this.connection.prepare(`
+      UPDATE issue_sessions
+      SET lease_id = ?, worker_id = ?, leased_until = ?, updated_at = ?
+      WHERE project_id = ? AND linear_issue_id = ?
+    `).run(params.leaseId, params.workerId, params.leasedUntil, now, params.projectId, params.linearIssueId);
+        return Number(result.changes ?? 0) > 0;
+    }
+    renewIssueSessionLease(params) {
+        const now = params.now ?? isoNow();
+        const result = this.connection.prepare(`
+      UPDATE issue_sessions
+      SET leased_until = ?, updated_at = ?
+      WHERE project_id = ? AND linear_issue_id = ? AND lease_id = ?
+    `).run(params.leasedUntil, now, params.projectId, params.linearIssueId, params.leaseId);
+        return Number(result.changes ?? 0) > 0;
+    }
+    releaseIssueSessionLease(projectId, linearIssueId, leaseId) {
+        this.connection.prepare(`
+      UPDATE issue_sessions
+      SET lease_id = NULL, worker_id = NULL, leased_until = NULL, updated_at = ?
+      WHERE project_id = ? AND linear_issue_id = ? AND (? IS NULL OR lease_id = ?)
+    `).run(isoNow(), projectId, linearIssueId, leaseId ?? null, leaseId ?? null);
+    }
+    releaseExpiredIssueSessionLeases(now = isoNow()) {
+        this.connection.prepare(`
+      UPDATE issue_sessions
+      SET lease_id = NULL, worker_id = NULL, leased_until = NULL, updated_at = ?
+      WHERE leased_until IS NOT NULL AND leased_until <= ?
+    `).run(now, now);
+    }
+    hasActiveIssueSessionLease(projectId, linearIssueId, leaseId, now = isoNow()) {
+        const row = this.connection.prepare(`
+      SELECT 1
+      FROM issue_sessions
+      WHERE project_id = ? AND linear_issue_id = ? AND lease_id = ?
+        AND leased_until IS NOT NULL
+        AND leased_until > ?
+      LIMIT 1
+    `).get(projectId, linearIssueId, leaseId, now);
+        return row !== undefined;
+    }
+    getActiveIssueSessionLease(projectId, linearIssueId, now = isoNow()) {
+        const row = this.connection.prepare(`
+      SELECT lease_id
+      FROM issue_sessions
+      WHERE project_id = ? AND linear_issue_id = ?
+        AND lease_id IS NOT NULL
+        AND leased_until IS NOT NULL
+        AND leased_until > ?
+      LIMIT 1
+    `).get(projectId, linearIssueId, now);
+        const leaseId = typeof row?.lease_id === "string" ? row.lease_id : undefined;
+        if (!leaseId)
+            return undefined;
+        return { projectId, linearIssueId, leaseId };
+    }
+    withIssueSessionLease(projectId, linearIssueId, leaseId, fn) {
+        return this.transaction(() => {
+            if (!this.hasActiveIssueSessionLease(projectId, linearIssueId, leaseId)) {
+                return undefined;
+            }
+            return fn();
+        });
+    }
+    upsertIssueWithLease(lease, params) {
+        return this.withIssueSessionLease(lease.projectId, lease.linearIssueId, lease.leaseId, () => this.upsertIssue(params));
+    }
+    upsertIssueRespectingActiveLease(projectId, linearIssueId, params) {
+        const lease = this.getActiveIssueSessionLease(projectId, linearIssueId);
+        if (!lease) {
+            return this.upsertIssue(params);
+        }
+        return this.upsertIssueWithLease(lease, params);
+    }
+    finishRunWithLease(lease, runId, params) {
+        return this.withIssueSessionLease(lease.projectId, lease.linearIssueId, lease.leaseId, () => {
+            this.finishRun(runId, params);
+            return true;
+        }) ?? false;
+    }
+    finishRunRespectingActiveLease(projectId, linearIssueId, runId, params) {
+        const lease = this.getActiveIssueSessionLease(projectId, linearIssueId);
+        if (!lease) {
+            this.finishRun(runId, params);
+            return true;
+        }
+        return this.finishRunWithLease(lease, runId, params);
+    }
+    updateRunThreadWithLease(lease, runId, params) {
+        return this.withIssueSessionLease(lease.projectId, lease.linearIssueId, lease.leaseId, () => {
+            this.updateRunThread(runId, params);
+            return true;
+        }) ?? false;
+    }
+    consumeIssueSessionEventsWithLease(lease, eventIds, runId) {
+        return this.withIssueSessionLease(lease.projectId, lease.linearIssueId, lease.leaseId, () => {
+            this.consumeIssueSessionEvents(lease.projectId, lease.linearIssueId, eventIds, runId);
+            return true;
+        }) ?? false;
+    }
+    clearPendingIssueSessionEventsWithLease(lease) {
+        return this.withIssueSessionLease(lease.projectId, lease.linearIssueId, lease.leaseId, () => {
+            this.clearPendingIssueSessionEvents(lease.projectId, lease.linearIssueId);
+            return true;
+        }) ?? false;
+    }
+    clearPendingIssueSessionEventsRespectingActiveLease(projectId, linearIssueId) {
+        const lease = this.getActiveIssueSessionLease(projectId, linearIssueId);
+        if (!lease) {
+            this.clearPendingIssueSessionEvents(projectId, linearIssueId);
+            return true;
+        }
+        return this.clearPendingIssueSessionEventsWithLease(lease);
+    }
+    setIssueSessionLastWakeReasonWithLease(lease, lastWakeReason) {
+        return this.withIssueSessionLease(lease.projectId, lease.linearIssueId, lease.leaseId, () => {
+            this.setIssueSessionLastWakeReason(lease.projectId, lease.linearIssueId, lastWakeReason);
+            return true;
+        }) ?? false;
+    }
+    setIssueSessionLastWakeReason(projectId, linearIssueId, lastWakeReason) {
+        this.connection.prepare(`
+      UPDATE issue_sessions
+      SET last_wake_reason = ?, updated_at = ?
+      WHERE project_id = ? AND linear_issue_id = ?
+    `).run(lastWakeReason ?? null, isoNow(), projectId, linearIssueId);
+    }
+    setBranchOwnerWithLease(lease, owner) {
+        return this.withIssueSessionLease(lease.projectId, lease.linearIssueId, lease.leaseId, () => {
+            this.setBranchOwner(lease.projectId, lease.linearIssueId, owner);
+            return true;
+        }) ?? false;
+    }
+    setBranchOwnerRespectingActiveLease(projectId, linearIssueId, owner) {
+        const lease = this.getActiveIssueSessionLease(projectId, linearIssueId);
+        if (!lease) {
+            this.setBranchOwner(projectId, linearIssueId, owner);
+            return true;
+        }
+        return this.setBranchOwnerWithLease(lease, owner);
+    }
+    releaseIssueSessionLeaseRespectingActiveLease(projectId, linearIssueId) {
+        const lease = this.getActiveIssueSessionLease(projectId, linearIssueId);
+        this.releaseIssueSessionLease(projectId, linearIssueId, lease?.leaseId);
+    }
+}

package/dist/db/run-store.js

@@ -0,0 +1,127 @@
+import { extractLatestAssistantSummary } from "../issue-session-events.js";
+import { isoNow } from "./shared.js";
+export class RunStore {
+    connection;
+    mapRunRow;
+    getRun;
+    getIssue;
+    syncIssueSessionFromIssue;
+    constructor(connection, mapRunRow, getRun, getIssue, syncIssueSessionFromIssue) {
+        this.connection = connection;
+        this.mapRunRow = mapRunRow;
+        this.getRun = getRun;
+        this.getIssue = getIssue;
+        this.syncIssueSessionFromIssue = syncIssueSessionFromIssue;
+    }
+    createRun(params) {
+        const now = isoNow();
+        const result = this.connection.prepare(`
+      INSERT INTO runs (issue_id, project_id, linear_issue_id, run_type, status, source_head_sha, prompt_text, started_at)
+      VALUES (?, ?, ?, ?, 'queued', ?, ?, ?)
+    `).run(params.issueId, params.projectId, params.linearIssueId, params.runType, params.sourceHeadSha ?? null, params.promptText ?? null, now);
+        const run = this.getRun(Number(result.lastInsertRowid));
+        const issue = this.getIssue(params.projectId, params.linearIssueId);
+        if (issue) {
+            this.syncIssueSessionFromIssue(issue, { lastRunType: run.runType });
+        }
+        return run;
+    }
+    getRunById(id) {
+        const row = this.connection.prepare("SELECT * FROM runs WHERE id = ?").get(id);
+        return row ? this.mapRunRow(row) : undefined;
+    }
+    getRunByThreadId(threadId) {
+        const row = this.connection.prepare("SELECT * FROM runs WHERE thread_id = ?").get(threadId);
+        return row ? this.mapRunRow(row) : undefined;
+    }
+    listRunsForIssue(projectId, linearIssueId) {
+        const rows = this.connection
+            .prepare("SELECT * FROM runs WHERE project_id = ? AND linear_issue_id = ? ORDER BY id")
+            .all(projectId, linearIssueId);
+        return rows.map(this.mapRunRow);
+    }
+    getLatestRunForIssue(projectId, linearIssueId) {
+        const row = this.connection
+            .prepare("SELECT * FROM runs WHERE project_id = ? AND linear_issue_id = ? ORDER BY id DESC LIMIT 1")
+            .get(projectId, linearIssueId);
+        return row ? this.mapRunRow(row) : undefined;
+    }
+    listActiveRuns() {
+        const rows = this.connection
+            .prepare("SELECT * FROM runs WHERE status IN ('queued', 'running')")
+            .all();
+        return rows.map(this.mapRunRow);
+    }
+    listRunningRuns() {
+        const rows = this.connection
+            .prepare("SELECT * FROM runs WHERE status IN ('running', 'queued')")
+            .all();
+        return rows.map(this.mapRunRow);
+    }
+    updateRunThread(runId, params) {
+        this.connection.prepare(`
+      UPDATE runs SET
+        thread_id = ?,
+        parent_thread_id = COALESCE(?, parent_thread_id),
+        turn_id = COALESCE(?, turn_id),
+        status = 'running'
+      WHERE id = ?
+        AND ended_at IS NULL
+        AND status IN ('queued', 'running')
+    `).run(params.threadId, params.parentThreadId ?? null, params.turnId ?? null, runId);
+        const run = this.getRun(runId);
+        if (!run)
+            return;
+        const issue = this.getIssue(run.projectId, run.linearIssueId);
+        if (issue) {
+            this.syncIssueSessionFromIssue(issue);
+        }
+    }
+    updateRunTurnId(runId, turnId) {
+        this.connection.prepare("UPDATE runs SET turn_id = ? WHERE id = ?").run(turnId, runId);
+    }
+    finishRun(runId, params) {
+        const now = isoNow();
+        this.connection.prepare(`
+      UPDATE runs SET
+        status = ?,
+        thread_id = COALESCE(?, thread_id),
+        turn_id = COALESCE(?, turn_id),
+        failure_reason = COALESCE(?, failure_reason),
+        summary_json = COALESCE(?, summary_json),
+        report_json = COALESCE(?, report_json),
+        ended_at = ?
+      WHERE id = ?
+    `).run(params.status, params.threadId ?? null, params.turnId ?? null, params.failureReason ?? null, params.summaryJson ?? null, params.reportJson ?? null, now, runId);
+        const run = this.getRun(runId);
+        if (!run)
+            return;
+        const issue = this.getIssue(run.projectId, run.linearIssueId);
+        if (issue) {
+            this.syncIssueSessionFromIssue(issue, {
+                summaryText: extractLatestAssistantSummary(this.getRun(runId) ?? run),
+                lastRunType: run.runType,
+            });
+        }
+    }
+    saveThreadEvent(params) {
+        this.connection.prepare(`
+      INSERT INTO run_thread_events (run_id, thread_id, turn_id, method, event_json, created_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(params.runId, params.threadId, params.turnId ?? null, params.method, params.eventJson, isoNow());
+    }
+    listThreadEvents(runId) {
+        const rows = this.connection
+            .prepare("SELECT * FROM run_thread_events WHERE run_id = ? ORDER BY id")
+            .all(runId);
+        return rows.map((row) => ({
+            id: Number(row.id),
+            runId: Number(row.run_id),
+            threadId: String(row.thread_id),
+            ...(row.turn_id !== null ? { turnId: String(row.turn_id) } : {}),
+            method: String(row.method),
+            eventJson: String(row.event_json),
+            createdAt: String(row.created_at),
+        }));
+    }
+}

package/dist/db/webhook-event-store.js

@@ -0,0 +1,71 @@
+export class WebhookEventStore {
+    connection;
+    constructor(connection) {
+        this.connection = connection;
+    }
+    insertWebhookEvent(webhookId, receivedAt) {
+        const existing = this.connection
+            .prepare("SELECT id FROM webhook_events WHERE webhook_id = ?")
+            .get(webhookId);
+        if (existing) {
+            return { id: existing.id, duplicate: true };
+        }
+        const result = this.connection
+            .prepare("INSERT INTO webhook_events (webhook_id, received_at, processing_status) VALUES (?, ?, 'processed')")
+            .run(webhookId, receivedAt);
+        return { id: Number(result.lastInsertRowid), duplicate: false };
+    }
+    insertFullWebhookEvent(params) {
+        const existing = this.connection
+            .prepare("SELECT id FROM webhook_events WHERE webhook_id = ?")
+            .get(params.webhookId);
+        if (existing) {
+            return { id: existing.id, dedupeStatus: "duplicate" };
+        }
+        const result = this.connection
+            .prepare("INSERT INTO webhook_events (webhook_id, received_at, payload_json) VALUES (?, ?, ?)")
+            .run(params.webhookId, params.receivedAt, params.payloadJson);
+        return { id: Number(result.lastInsertRowid), dedupeStatus: "accepted" };
+    }
+    getWebhookPayload(id) {
+        const row = this.connection.prepare("SELECT webhook_id, payload_json FROM webhook_events WHERE id = ?").get(id);
+        if (!row || !row.payload_json)
+            return undefined;
+        return { webhookId: String(row.webhook_id), payloadJson: String(row.payload_json) };
+    }
+    isWebhookDuplicate(webhookId) {
+        return this.connection.prepare("SELECT 1 FROM webhook_events WHERE webhook_id = ?").get(webhookId) !== undefined;
+    }
+    markWebhookProcessed(id, status) {
+        this.connection.prepare("UPDATE webhook_events SET processing_status = ? WHERE id = ?").run(status, id);
+    }
+    assignWebhookProject(id, projectId) {
+        this.connection.prepare("UPDATE webhook_events SET project_id = ? WHERE id = ?").run(projectId, id);
+    }
+    findLatestAgentSessionIdForIssue(linearIssueId) {
+        const row = this.connection.prepare(`
+      SELECT COALESCE(
+        json_extract(payload_json, '$.agentSession.id'),
+        json_extract(payload_json, '$.data.agentSession.id'),
+        json_extract(payload_json, '$.agentSessionId'),
+        json_extract(payload_json, '$.data.agentSessionId')
+      ) AS agent_session_id
+      FROM webhook_events
+      WHERE COALESCE(
+        json_extract(payload_json, '$.agentSession.issueId'),
+        json_extract(payload_json, '$.data.agentSession.issueId'),
+        json_extract(payload_json, '$.agentSession.issue.id'),
+        json_extract(payload_json, '$.data.agentSession.issue.id')
+      ) = ?
+        AND COALESCE(
+          json_extract(payload_json, '$.agentSession.id'),
+          json_extract(payload_json, '$.data.agentSession.id'),
+          json_extract(payload_json, '$.agentSessionId'),
+          json_extract(payload_json, '$.data.agentSessionId')
+        ) IS NOT NULL
+      ORDER BY id DESC
+      LIMIT 1
+    `).get(linearIssueId);
+        return row?.agent_session_id != null ? String(row.agent_session_id) : undefined;
+    }
+}