patchrelay 0.7.0 → 0.7.1

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.7.0",
-  "commit": "450840270db1",
-  "builtAt": "2026-03-13T18:08:50.316Z"
+  "version": "0.7.1",
+  "commit": "c70c0c3117a6",
+  "builtAt": "2026-03-13T18:54:01.444Z"
 }

package/dist/cli/commands/project.js

@@ -91,7 +91,7 @@ export async function handleProjectCommand(params) {
     if (!serviceState.ok) {
         throw new Error(`Project was saved, but PatchRelay could not be reloaded: ${serviceState.error}`);
     }
-    const cliData = params.options?.data ?? (await createCliDataAccess(fullConfig));
+    const cliData = params.options?.data ?? (await createCliOperatorDataAccess(fullConfig));
     try {
         if (params.json) {
             const connectResult = noConnect ? undefined : await cliData.connect(projectId);
@@ -140,7 +140,7 @@ export async function handleProjectCommand(params) {
         }
     }
 }
-async function createCliDataAccess(config) {
-    const { CliDataAccess } = await import("../data.js");
-    return new CliDataAccess(config);
+async function createCliOperatorDataAccess(config) {
+    const { CliOperatorApiClient } = await import("../operator-client.js");
+    return new CliOperatorApiClient(config);
 }

package/dist/cli/data.js

@@ -3,6 +3,7 @@ import pino from "pino";
 import { CodexAppServerClient } from "../codex-app-server.js";
 import { PatchRelayDatabase } from "../db.js";
 import { WorktreeManager } from "../worktree-manager.js";
+import { CliOperatorApiClient } from "./operator-client.js";
 import { resolveWorkflowStage } from "../workflow-policy.js";
 function safeJsonParse(value) {
     if (!value) {
@@ -40,12 +41,13 @@ function resolveStageFromState(config, projectId, stateName) {
     }
     return resolveWorkflowStage(project, stateName);
 }
-export class CliDataAccess {
+export class CliDataAccess extends CliOperatorApiClient {
     config;
     db;
     codex;
     codexStarted = false;
     constructor(config, options) {
+        super(config);
         this.config = config;
         this.db = options?.db ?? new PatchRelayDatabase(config.database.path, config.database.wal);
         this.codex = options?.codex;
@@ -448,138 +450,6 @@ export class CliDataAccess {
         const worktreeManager = new WorktreeManager(this.config);
         await worktreeManager.ensureIssueWorktree(project.repoPath, project.worktreeRoot, worktree.workspace.worktreePath, worktree.workspace.branchName);
     }
-    async connect(projectId) {
-        return await this.requestJson("/api/oauth/linear/start", {
-            ...(projectId ? { projectId } : {}),
-        });
-    }
-    async connectStatus(state) {
-        if (!state) {
-            throw new Error("OAuth state is required.");
-        }
-        return await this.requestJson(`/api/oauth/linear/state/${encodeURIComponent(state)}`);
-    }
-    async listInstallations() {
-        return await this.requestJson("/api/installations");
-    }
-    async listOperatorFeed(options) {
-        return await this.requestJson("/api/feed", {
-            ...(options?.limit && options.limit > 0 ? { limit: String(options.limit) } : {}),
-            ...(options?.issueKey ? { issue: options.issueKey } : {}),
-            ...(options?.projectId ? { project: options.projectId } : {}),
-        });
-    }
-    async followOperatorFeed(onEvent, options) {
-        const url = new URL("/api/feed", this.getOperatorBaseUrl());
-        url.searchParams.set("follow", "1");
-        if (options?.limit && options.limit > 0) {
-            url.searchParams.set("limit", String(options.limit));
-        }
-        if (options?.issueKey) {
-            url.searchParams.set("issue", options.issueKey);
-        }
-        if (options?.projectId) {
-            url.searchParams.set("project", options.projectId);
-        }
-        const response = await fetch(url, {
-            method: "GET",
-            headers: {
-                accept: "text/event-stream",
-                ...(this.config.operatorApi.bearerToken ? { authorization: `Bearer ${this.config.operatorApi.bearerToken}` } : {}),
-            },
-        });
-        if (!response.ok || !response.body) {
-            const body = await response.text().catch(() => "");
-            const message = this.readErrorMessage(body);
-            throw new Error(message ?? `Request failed: ${response.status}`);
-        }
-        const reader = response.body.getReader();
-        const decoder = new TextDecoder();
-        let buffer = "";
-        let dataLines = [];
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done) {
-                break;
-            }
-            buffer += decoder.decode(value, { stream: true });
-            let newlineIndex = buffer.indexOf("\n");
-            while (newlineIndex !== -1) {
-                const rawLine = buffer.slice(0, newlineIndex);
-                buffer = buffer.slice(newlineIndex + 1);
-                const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
-                if (!line) {
-                    if (dataLines.length > 0) {
-                        const parsed = JSON.parse(dataLines.join("\n"));
-                        onEvent(parsed);
-                        dataLines = [];
-                    }
-                    newlineIndex = buffer.indexOf("\n");
-                    continue;
-                }
-                if (line.startsWith(":")) {
-                    newlineIndex = buffer.indexOf("\n");
-                    continue;
-                }
-                if (line.startsWith("data:")) {
-                    dataLines.push(line.slice(5).trimStart());
-                }
-                newlineIndex = buffer.indexOf("\n");
-            }
-        }
-    }
-    getOperatorBaseUrl() {
-        const host = this.normalizeLocalHost(this.config.server.bind);
-        return `http://${host}:${this.config.server.port}/`;
-    }
-    normalizeLocalHost(bind) {
-        if (bind === "0.0.0.0") {
-            return "127.0.0.1";
-        }
-        if (bind === "::") {
-            return "[::1]";
-        }
-        if (bind.includes(":") && !bind.startsWith("[")) {
-            return `[${bind}]`;
-        }
-        return bind;
-    }
-    async requestJson(pathname, query, init) {
-        const url = new URL(pathname, this.getOperatorBaseUrl());
-        for (const [key, value] of Object.entries(query ?? {})) {
-            if (value) {
-                url.searchParams.set(key, value);
-            }
-        }
-        const response = await fetch(url, {
-            method: init?.method ?? "GET",
-            headers: {
-                accept: "application/json",
-                ...(init?.body !== undefined ? { "content-type": "application/json" } : {}),
-                ...(this.config.operatorApi.bearerToken ? { authorization: `Bearer ${this.config.operatorApi.bearerToken}` } : {}),
-            },
-            ...(init?.body !== undefined ? { body: JSON.stringify(init.body) } : {}),
-        });
-        const body = await response.text();
-        if (!response.ok) {
-            const message = this.readErrorMessage(body);
-            throw new Error(message ?? `Request failed: ${response.status}`);
-        }
-        const parsed = JSON.parse(body);
-        if (parsed.ok === false) {
-            throw new Error(this.readErrorMessage(body) ?? "Request failed.");
-        }
-        return parsed;
-    }
-    readErrorMessage(body) {
-        try {
-            const parsed = JSON.parse(body);
-            return parsed.message ?? parsed.reason;
-        }
-        catch {
-            return undefined;
-        }
-    }
     async readLiveSummary(threadId, latestTimestampSeen) {
         const codex = await this.getCodex();
         const thread = await codex.readThread(threadId, true);

package/dist/cli/index.js

@@ -202,6 +202,7 @@ export async function runCli(argv, options) {
             profile: getCommandConfigProfile(command),
         });
     let data = options?.data;
+    let ownsData = false;
     try {
         if (command === "doctor") {
             const { runPreflight } = await import("../preflight.js");
@@ -209,55 +210,111 @@ export async function runCli(argv, options) {
             writeOutput(stdout, json ? formatJson(report) : formatDoctor(report));
             return report.ok ? 0 : 1;
         }
-        data ??= await createCliDataAccess(config);
         if (command === "inspect") {
-            return await handleInspectCommand({ commandArgs, parsed, json, stdout, data, config, runInteractive });
+            const issueData = await ensureIssueDataAccess(data, config);
+            if (!data) {
+                data = issueData;
+                ownsData = true;
+            }
+            return await handleInspectCommand({ commandArgs, parsed, json, stdout, data: issueData, config, runInteractive });
         }
         if (command === "live") {
-            return await handleLiveCommand({ commandArgs, parsed, json, stdout, data, config, runInteractive });
+            const issueData = await ensureIssueDataAccess(data, config);
+            if (!data) {
+                data = issueData;
+                ownsData = true;
+            }
+            return await handleLiveCommand({ commandArgs, parsed, json, stdout, data: issueData, config, runInteractive });
         }
         if (command === "report") {
-            return await handleReportCommand({ commandArgs, parsed, json, stdout, data, config, runInteractive });
+            const issueData = await ensureIssueDataAccess(data, config);
+            if (!data) {
+                data = issueData;
+                ownsData = true;
+            }
+            return await handleReportCommand({ commandArgs, parsed, json, stdout, data: issueData, config, runInteractive });
         }
         if (command === "events") {
-            return await handleEventsCommand({ commandArgs, parsed, json, stdout, data, config, runInteractive });
+            const issueData = await ensureIssueDataAccess(data, config);
+            if (!data) {
+                data = issueData;
+                ownsData = true;
+            }
+            return await handleEventsCommand({ commandArgs, parsed, json, stdout, data: issueData, config, runInteractive });
         }
         if (command === "worktree") {
-            return await handleWorktreeCommand({ commandArgs, parsed, json, stdout, data, config, runInteractive });
+            const issueData = await ensureIssueDataAccess(data, config);
+            if (!data) {
+                data = issueData;
+                ownsData = true;
+            }
+            return await handleWorktreeCommand({ commandArgs, parsed, json, stdout, data: issueData, config, runInteractive });
         }
         if (command === "open") {
-            return await handleOpenCommand({ commandArgs, parsed, json, stdout, data, config, runInteractive });
+            const issueData = await ensureIssueDataAccess(data, config);
+            if (!data) {
+                data = issueData;
+                ownsData = true;
+            }
+            return await handleOpenCommand({ commandArgs, parsed, json, stdout, data: issueData, config, runInteractive });
         }
         if (command === "connect") {
+            const operatorData = await ensureConnectDataAccess(data, config);
+            if (!data) {
+                data = operatorData;
+                ownsData = true;
+            }
             return await handleConnectCommand({
                 parsed,
                 json,
                 stdout,
                 config,
-                data,
+                data: operatorData,
                 ...(options ? { options } : {}),
             });
         }
         if (command === "installations") {
+            const operatorData = await ensureInstallationsDataAccess(data, config);
+            if (!data) {
+                data = operatorData;
+                ownsData = true;
+            }
             return await handleInstallationsCommand({
                 json,
                 stdout,
-                data,
+                data: operatorData,
             });
         }
         if (command === "feed") {
+            const operatorData = parsed.flags.get("follow") === true
+                ? await ensureFeedFollowDataAccess(data, config)
+                : await ensureFeedListDataAccess(data, config);
+            if (!data) {
+                data = operatorData;
+                ownsData = true;
+            }
             return await handleFeedCommand({
                 parsed,
                 json,
                 stdout,
-                data,
+                data: operatorData,
             });
         }
         if (command === "retry") {
-            return await handleRetryCommand({ commandArgs, parsed, json, stdout, data, config, runInteractive });
+            const issueData = await ensureIssueDataAccess(data, config);
+            if (!data) {
+                data = issueData;
+                ownsData = true;
+            }
+            return await handleRetryCommand({ commandArgs, parsed, json, stdout, data: issueData, config, runInteractive });
         }
         if (command === "list") {
-            return await handleListCommand({ commandArgs, parsed, json, stdout, data, config, runInteractive });
+            const issueData = await ensureIssueDataAccess(data, config);
+            if (!data) {
+                data = issueData;
+                ownsData = true;
+            }
+            return await handleListCommand({ commandArgs, parsed, json, stdout, data: issueData, config, runInteractive });
         }
         throw new Error(`Unknown command: ${command}`);
     }
@@ -270,7 +327,7 @@ export async function runCli(argv, options) {
         return 1;
     }
     finally {
-        if (data && !options?.data) {
+        if (ownsData && data) {
             data.close();
         }
     }
@@ -279,3 +336,67 @@ async function createCliDataAccess(config) {
     const { CliDataAccess } = await import("./data.js");
     return new CliDataAccess(config);
 }
+async function createCliOperatorDataAccess(config) {
+    const { CliOperatorApiClient } = await import("./operator-client.js");
+    return new CliOperatorApiClient(config);
+}
+async function ensureIssueDataAccess(data, config) {
+    if (data) {
+        if (isIssueDataAccess(data)) {
+            return data;
+        }
+        throw new Error("Issue inspection commands require local SQLite-backed CLI data access.");
+    }
+    return await createCliDataAccess(config);
+}
+async function ensureConnectDataAccess(data, config) {
+    if (data) {
+        if (hasConnectDataAccess(data)) {
+            return data;
+        }
+        throw new Error("The connect command requires HTTP-backed OAuth CLI data access.");
+    }
+    return await createCliOperatorDataAccess(config);
+}
+function isIssueDataAccess(data) {
+    return !!data && typeof data === "object" && "inspect" in data && typeof data.inspect === "function";
+}
+async function ensureInstallationsDataAccess(data, config) {
+    if (data) {
+        if (hasInstallationsDataAccess(data)) {
+            return data;
+        }
+        throw new Error("The installations command requires HTTP-backed installation data access.");
+    }
+    return await createCliOperatorDataAccess(config);
+}
+async function ensureFeedListDataAccess(data, config) {
+    if (data) {
+        if (hasFeedListDataAccess(data)) {
+            return data;
+        }
+        throw new Error("The feed command requires listOperatorFeed() data access.");
+    }
+    return await createCliOperatorDataAccess(config);
+}
+function hasConnectDataAccess(data) {
+    return !!data && typeof data === "object" && "connect" in data && typeof data.connect === "function";
+}
+function hasInstallationsDataAccess(data) {
+    return !!data && typeof data === "object" && "listInstallations" in data && typeof data.listInstallations === "function";
+}
+async function ensureFeedFollowDataAccess(data, config) {
+    if (data) {
+        if (hasFeedFollowDataAccess(data)) {
+            return data;
+        }
+        throw new Error("The feed --follow command requires followOperatorFeed() data access.");
+    }
+    return await createCliOperatorDataAccess(config);
+}
+function hasFeedListDataAccess(data) {
+    return !!data && typeof data === "object" && "listOperatorFeed" in data && typeof data.listOperatorFeed === "function";
+}
+function hasFeedFollowDataAccess(data) {
+    return !!data && typeof data === "object" && "followOperatorFeed" in data && typeof data.followOperatorFeed === "function";
+}

package/dist/cli/operator-client.js

@@ -0,0 +1,140 @@
+export class CliOperatorApiClient {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    close() { }
+    async connect(projectId) {
+        return await this.requestJson("/api/oauth/linear/start", {
+            ...(projectId ? { projectId } : {}),
+        });
+    }
+    async connectStatus(state) {
+        if (!state) {
+            throw new Error("OAuth state is required.");
+        }
+        return await this.requestJson(`/api/oauth/linear/state/${encodeURIComponent(state)}`);
+    }
+    async listInstallations() {
+        return await this.requestJson("/api/installations");
+    }
+    async listOperatorFeed(options) {
+        return await this.requestJson("/api/feed", {
+            ...(options?.limit && options.limit > 0 ? { limit: String(options.limit) } : {}),
+            ...(options?.issueKey ? { issue: options.issueKey } : {}),
+            ...(options?.projectId ? { project: options.projectId } : {}),
+        });
+    }
+    async followOperatorFeed(onEvent, options) {
+        const url = new URL("/api/feed", this.getOperatorBaseUrl());
+        url.searchParams.set("follow", "1");
+        if (options?.limit && options.limit > 0) {
+            url.searchParams.set("limit", String(options.limit));
+        }
+        if (options?.issueKey) {
+            url.searchParams.set("issue", options.issueKey);
+        }
+        if (options?.projectId) {
+            url.searchParams.set("project", options.projectId);
+        }
+        const response = await fetch(url, {
+            method: "GET",
+            headers: {
+                accept: "text/event-stream",
+                ...(this.config.operatorApi.bearerToken ? { authorization: `Bearer ${this.config.operatorApi.bearerToken}` } : {}),
+            },
+        });
+        if (!response.ok || !response.body) {
+            const body = await response.text().catch(() => "");
+            const message = this.readErrorMessage(body);
+            throw new Error(message ?? `Request failed: ${response.status}`);
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        let dataLines = [];
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            let newlineIndex = buffer.indexOf("\n");
+            while (newlineIndex !== -1) {
+                const rawLine = buffer.slice(0, newlineIndex);
+                buffer = buffer.slice(newlineIndex + 1);
+                const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+                if (!line) {
+                    if (dataLines.length > 0) {
+                        const parsed = JSON.parse(dataLines.join("\n"));
+                        onEvent(parsed);
+                        dataLines = [];
+                    }
+                    newlineIndex = buffer.indexOf("\n");
+                    continue;
+                }
+                if (line.startsWith(":")) {
+                    newlineIndex = buffer.indexOf("\n");
+                    continue;
+                }
+                if (line.startsWith("data:")) {
+                    dataLines.push(line.slice(5).trimStart());
+                }
+                newlineIndex = buffer.indexOf("\n");
+            }
+        }
+    }
+    getOperatorBaseUrl() {
+        const host = this.normalizeLocalHost(this.config.server.bind);
+        return `http://${host}:${this.config.server.port}/`;
+    }
+    normalizeLocalHost(bind) {
+        if (bind === "0.0.0.0") {
+            return "127.0.0.1";
+        }
+        if (bind === "::") {
+            return "[::1]";
+        }
+        if (bind.includes(":") && !bind.startsWith("[")) {
+            return `[${bind}]`;
+        }
+        return bind;
+    }
+    async requestJson(pathname, query, init) {
+        const url = new URL(pathname, this.getOperatorBaseUrl());
+        for (const [key, value] of Object.entries(query ?? {})) {
+            if (value) {
+                url.searchParams.set(key, value);
+            }
+        }
+        const response = await fetch(url, {
+            method: init?.method ?? "GET",
+            headers: {
+                accept: "application/json",
+                connection: "close",
+                ...(init?.body !== undefined ? { "content-type": "application/json" } : {}),
+                ...(this.config.operatorApi.bearerToken ? { authorization: `Bearer ${this.config.operatorApi.bearerToken}` } : {}),
+            },
+            ...(init?.body !== undefined ? { body: JSON.stringify(init.body) } : {}),
+        });
+        const body = await response.text();
+        if (!response.ok) {
+            const message = this.readErrorMessage(body);
+            throw new Error(message ?? `Request failed: ${response.status}`);
+        }
+        const parsed = JSON.parse(body);
+        if (parsed.ok === false) {
+            throw new Error(this.readErrorMessage(body) ?? "Request failed.");
+        }
+        return parsed;
+    }
+    readErrorMessage(body) {
+        try {
+            const parsed = JSON.parse(body);
+            return parsed.message ?? parsed.reason;
+        }
+        catch {
+            return undefined;
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchrelay",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "license": "MIT",
   "type": "module",
   "repository": {