patchrelay 0.26.0 → 0.29.1

package/dist/cli/commands/repo.js

@@ -0,0 +1,213 @@
+import { existsSync } from "node:fs";
+import { dirname } from "node:path";
+import { loadConfig } from "../../config.js";
+import { ensureRepositoryProjectSettings, removeRepositoryFromConfig, upsertRepositoryInConfig } from "../../install.js";
+import { defaultLocalRepoPath, ensureLocalRepository, normalizeGitHubRepo } from "../../repository-linking.js";
+import { ensureDir, execCommand } from "../../utils.js";
+import { parseCsvFlag } from "../args.js";
+import { formatJson } from "../formatters/json.js";
+import { writeOutput } from "../output.js";
+import { restartServiceCommands, tryManageService } from "../service-commands.js";
+export async function handleRepoCommand(params) {
+    const subcommand = params.commandArgs[0] ?? "list";
+    switch (subcommand) {
+        case "list":
+            return await handleRepoList(params);
+        case "show":
+            return await handleRepoShow(params);
+        case "link":
+            return await handleRepoLink(params);
+        case "unlink":
+            return await handleRepoUnlink(params);
+        case "sync":
+            return await handleRepoSync(params);
+        default:
+            throw new Error(`Unknown repo subcommand: ${subcommand}`);
+    }
+}
+async function handleRepoList(params) {
+    const config = params.options?.config ?? loadConfig(undefined, { profile: "doctor" });
+    writeOutput(params.stdout, params.json
+        ? formatJson({ ok: true, repositories: config.repositories })
+        : config.repositories.length === 0
+            ? "No repositories linked.\n"
+            : `${config.repositories.map((repository) => `${repository.githubRepo}  ${repository.localPath}`).join("\n")}\n`);
+    return 0;
+}
+async function handleRepoShow(params) {
+    const githubRepo = params.commandArgs[1];
+    if (!githubRepo) {
+        throw new Error("patchrelay repo show requires <github-repo>.");
+    }
+    const normalized = normalizeGitHubRepo(githubRepo);
+    const config = params.options?.config ?? loadConfig(undefined, { profile: "doctor" });
+    const repository = config.repositories.find((entry) => entry.githubRepo === normalized);
+    if (!repository) {
+        throw new Error(`Repository not linked: ${normalized}`);
+    }
+    writeOutput(params.stdout, params.json
+        ? formatJson({ ok: true, repository })
+        : [
+            `Repository: ${repository.githubRepo}`,
+            `Path: ${repository.localPath}`,
+            `Workspace: ${repository.workspace ?? "-"}`,
+            `Linear teams: ${repository.linearTeamIds.join(", ") || "-"}`,
+            `Linear projects: ${repository.linearProjectIds.join(", ") || "-"}`,
+            `Issue key prefixes: ${repository.issueKeyPrefixes.join(", ") || "-"}`,
+        ].join("\n") + "\n");
+    return 0;
+}
+async function handleRepoLink(params) {
+    const githubRepoArg = params.commandArgs[1];
+    if (!githubRepoArg) {
+        throw new Error("patchrelay repo link requires <github-repo>.");
+    }
+    const githubRepo = normalizeGitHubRepo(githubRepoArg);
+    const workspaceArg = typeof params.parsed.flags.get("workspace") === "string" ? String(params.parsed.flags.get("workspace")) : undefined;
+    if (!workspaceArg) {
+        throw new Error("patchrelay repo link requires --workspace <workspace>.");
+    }
+    const teamQueries = parseCsvFlag(params.parsed.flags.get("team"));
+    if (teamQueries.length === 0) {
+        throw new Error("patchrelay repo link requires --team <key-or-id>[,...].");
+    }
+    const projectQueries = parseCsvFlag(params.parsed.flags.get("project"));
+    const explicitPrefixes = parseCsvFlag(params.parsed.flags.get("prefix"));
+    const config = params.options?.config ?? loadConfig(undefined, { profile: "operator_cli" });
+    const data = params.options?.data ?? (await createCliOperatorDataAccess(config));
+    try {
+        const syncResult = await data.syncLinearWorkspace(workspaceArg);
+        const installation = syncResult.installation;
+        const teams = resolveTeams(syncResult.teams, teamQueries);
+        const projects = resolveProjects(syncResult.projects, projectQueries);
+        const derivedPrefixes = explicitPrefixes.length > 0
+            ? explicitPrefixes
+            : teams.map((team) => team.key).filter((value) => Boolean(value));
+        const localPathFlag = typeof params.parsed.flags.get("path") === "string" ? String(params.parsed.flags.get("path")) : undefined;
+        const localPath = localPathFlag ? localPathFlag : defaultLocalRepoPath(config.repos.root, githubRepo);
+        const repoState = await ensureLocalRepository({ config, githubRepo, localPath });
+        await ensureRepositoryProjectSettings(repoState.localPath);
+        const saveResult = await upsertRepositoryInConfig({
+            githubRepo,
+            localPath: repoState.localPath,
+            workspace: installation.workspaceKey ?? installation.workspaceName ?? workspaceArg,
+            linearTeamIds: teams.map((team) => team.id),
+            linearProjectIds: projects.map((project) => project.id),
+            issueKeyPrefixes: derivedPrefixes,
+        });
+        const { PatchRelayDatabase } = await import("../../db.js");
+        await ensureDir(dirname(config.database.path));
+        const db = new PatchRelayDatabase(config.database.path, config.database.wal);
+        try {
+            db.runMigrations();
+            db.linearInstallations.setProjectInstallation(githubRepo, installation.id);
+        }
+        finally {
+            db.connection.close();
+        }
+        const serviceState = await tryManageService(params.runCommand, restartServiceCommands());
+        if (!serviceState.ok) {
+            throw new Error(`Repository was linked, but PatchRelay could not be reloaded: ${serviceState.error}`);
+        }
+        writeOutput(params.stdout, params.json
+            ? formatJson({
+                ok: true,
+                repository: saveResult.repository,
+                clone: repoState,
+                installation,
+                teams,
+                projects,
+            })
+            : [
+                `${saveResult.status === "created" ? "Linked" : saveResult.status === "updated" ? "Updated" : "Verified"} ${githubRepo}`,
+                `Path: ${repoState.localPath}${repoState.reused ? " (reused)" : " (cloned)"}`,
+                `Workspace: ${installation.workspaceKey ?? installation.workspaceName ?? installation.id}`,
+                `Linear teams: ${teams.map((team) => team.key ?? team.name ?? team.id).join(", ")}`,
+                `Linear projects: ${projects.map((project) => project.name ?? project.id).join(", ") || "-"}`,
+                `Issue key prefixes: ${derivedPrefixes.join(", ") || "-"}`,
+            ].join("\n") + "\n");
+        return 0;
+    }
+    finally {
+        if (!params.options?.data) {
+            data.close();
+        }
+    }
+}
+async function handleRepoUnlink(params) {
+    const githubRepoArg = params.commandArgs[1];
+    if (!githubRepoArg) {
+        throw new Error("patchrelay repo unlink requires <github-repo>.");
+    }
+    const githubRepo = normalizeGitHubRepo(githubRepoArg);
+    const config = params.options?.config ?? loadConfig(undefined, { profile: "doctor" });
+    const result = await removeRepositoryFromConfig({ githubRepo });
+    const { PatchRelayDatabase } = await import("../../db.js");
+    await ensureDir(dirname(config.database.path));
+    const db = new PatchRelayDatabase(config.database.path, config.database.wal);
+    try {
+        db.runMigrations();
+        db.linearInstallations.unlinkProjectInstallation(githubRepo);
+    }
+    finally {
+        db.connection.close();
+    }
+    const serviceState = await tryManageService(params.runCommand, restartServiceCommands());
+    if (!serviceState.ok) {
+        throw new Error(`Repository was unlinked, but PatchRelay could not be reloaded: ${serviceState.error}`);
+    }
+    writeOutput(params.stdout, params.json
+        ? formatJson({ ok: true, githubRepo, removed: result.removed })
+        : result.removed
+            ? `Unlinked ${githubRepo}.\n`
+            : `Repository was not linked: ${githubRepo}\n`);
+    return 0;
+}
+async function handleRepoSync(params) {
+    const githubRepoArg = params.commandArgs[1];
+    const config = params.options?.config ?? loadConfig(undefined, { profile: "doctor" });
+    const repositories = githubRepoArg
+        ? config.repositories.filter((repository) => repository.githubRepo === normalizeGitHubRepo(githubRepoArg))
+        : config.repositories;
+    const results = [];
+    for (const repository of repositories) {
+        if (!existsSync(repository.localPath)) {
+            await ensureLocalRepository({ config, githubRepo: repository.githubRepo, localPath: repository.localPath });
+            results.push({ githubRepo: repository.githubRepo, localPath: repository.localPath, fetched: false });
+            continue;
+        }
+        await execCommand(config.runner.gitBin, ["-C", repository.localPath, "fetch", "origin"], { timeoutMs: 300_000 });
+        results.push({ githubRepo: repository.githubRepo, localPath: repository.localPath, fetched: true });
+    }
+    writeOutput(params.stdout, params.json
+        ? formatJson({ ok: true, repositories: results })
+        : `${results.map((result) => `${result.githubRepo}  ${result.fetched ? "fetched" : "cloned"}  ${result.localPath}`).join("\n")}\n`);
+    return 0;
+}
+function resolveTeams(teams, queries) {
+    return queries.map((query) => {
+        const normalized = query.trim().toLowerCase();
+        const team = teams.find((entry) => entry.id.toLowerCase() === normalized
+            || entry.key?.trim().toLowerCase() === normalized
+            || entry.name?.trim().toLowerCase() === normalized);
+        if (!team) {
+            throw new Error(`Linear team not found: ${query}`);
+        }
+        return team;
+    });
+}
+function resolveProjects(projects, queries) {
+    return queries.map((query) => {
+        const normalized = query.trim().toLowerCase();
+        const project = projects.find((entry) => entry.id.toLowerCase() === normalized
+            || entry.name?.trim().toLowerCase() === normalized);
+        if (!project) {
+            throw new Error(`Linear project not found: ${query}`);
+        }
+        return project;
+    });
+}
+async function createCliOperatorDataAccess(config) {
+    const { CliOperatorApiClient } = await import("../operator-client.js");
+    return new CliOperatorApiClient(config);
+}

package/dist/cli/commands/setup.js

@@ -1,5 +1,8 @@
-import { getDefaultConfigPath, getDefaultRuntimeEnvPath, getDefaultServiceEnvPath, getSystemdPathUnitPath, getSystemdReloadUnitPath, getSystemdUnitPath, } from "../../runtime-paths.js";
+import { getDefaultConfigPath, getDefaultRuntimeEnvPath, getDefaultServiceEnvPath, getSystemdUnitPath, } from "../../runtime-paths.js";
 import { initializePatchRelayHome, installServiceUnits } from "../../install.js";
+import { loadConfig } from "../../config.js";
+import { parsePositiveIntegerFlag } from "../args.js";
+import { CliUsageError } from "../errors.js";
 import { formatJson } from "../formatters/json.js";
 import { writeOutput } from "../output.js";
 import { installServiceCommands, restartServiceCommands, runServiceCommands, tryManageService } from "../service-commands.js";
@@ -21,7 +24,7 @@ export async function handleInitCommand(params) {
             publicBaseUrl,
         });
         const serviceUnits = await installServiceUnits({ force: params.parsed.flags.get("force") === true });
-        const serviceState = await tryManageService(params.runInteractive, installServiceCommands());
+        const serviceState = await tryManageService(params.runCommand, installServiceCommands());
         writeOutput(params.stdout, params.json
             ? formatJson({ ...result, serviceUnits, serviceState })
             : [
@@ -32,8 +35,6 @@ export async function handleInitCommand(params) {
                 `State directory: ${result.stateDir}`,
                 `Data directory: ${result.dataDir}`,
                 `Service unit: ${serviceUnits.unitPath} (${serviceUnits.serviceStatus})`,
-                `Reload unit: ${serviceUnits.reloadUnitPath} (${serviceUnits.reloadStatus})`,
-                `Watcher unit: ${serviceUnits.pathUnitPath} (${serviceUnits.pathStatus})`,
                 "",
                 "PatchRelay public URLs:",
                 `- Public base URL: ${result.publicBaseUrl}`,
@@ -41,9 +42,9 @@ export async function handleInitCommand(params) {
                 `- OAuth callback: ${result.oauthCallbackUrl}`,
                 "",
                 "Created with defaults:",
-                `- Config file contains only machine-level essentials such as server.public_base_url`,
-                `- Database, logs, bind address, and worktree roots use built-in defaults`,
-                `- The system service and config watcher are installed for you`,
+                "- Config file contains only machine-level essentials such as server.public_base_url",
+                "- Database, logs, bind address, and worktree roots use built-in defaults",
+                "- The system service is installed for you",
                 "",
                 "Register the app in Linear:",
                 "- Open Linear Settings > API > Applications",
@@ -60,19 +61,21 @@ export async function handleInitCommand(params) {
                 "",
                 "Service status:",
                 serviceState.ok
-                    ? "PatchRelay service and config watcher are installed and reload-or-restart has been requested."
+                    ? "PatchRelay service is installed and reload-or-restart has been requested."
                     : `PatchRelay service units were installed, but the service could not be started yet: ${serviceState.error}`,
                 !serviceState.ok
-                    ? "This is expected until the required env vars and at least one valid project workflow are in place. The watcher will retry when config or env files change."
+                    ? "This is expected until the required env vars and at least one valid repo workflow are in place. Rerun `patchrelay service restart` after updating config or env files."
                     : undefined,
                 "",
                 "Next steps:",
                 `1. Edit ${result.serviceEnvPath}`,
                 "2. Paste your Linear OAuth client id and client secret into service.env and keep the generated webhook secret and token encryption key",
                 "3. Paste LINEAR_WEBHOOK_SECRET from service.env into the Linear OAuth app webhook signing secret",
-                "4. Run `patchrelay project apply <id> <repo-path>`",
-                "5. Edit the generated project workflows if you want custom state names or workflow files, then add those workflow files to the repo",
-                "6. Run `patchrelay doctor`",
+                "4. Run `patchrelay linear connect`",
+                "5. Run `patchrelay linear sync`",
+                "6. Run `patchrelay repo link <owner/repo> --workspace <workspace> --team <team>`",
+                "7. Add the workflow files your repo needs, then run `patchrelay doctor`",
+                "8. Run `patchrelay service status`",
             ]
                 .filter(Boolean)
                 .join("\n") + "\n");
@@ -88,21 +91,19 @@ export async function handleInstallServiceCommand(params) {
         const result = await installServiceUnits({ force: params.parsed.flags.get("force") === true });
         const writeOnly = params.parsed.flags.get("write-only") === true;
         if (!writeOnly) {
-            await runServiceCommands(params.runInteractive, installServiceCommands());
+            await runServiceCommands(params.runCommand, installServiceCommands());
         }
         writeOutput(params.stdout, params.json
             ? formatJson({ ...result, writeOnly })
             : [
                 `Service unit: ${result.unitPath} (${result.serviceStatus})`,
-                `Reload unit: ${result.reloadUnitPath} (${result.reloadStatus})`,
-                `Watcher unit: ${result.pathUnitPath} (${result.pathStatus})`,
                 `Runtime env: ${result.runtimeEnvPath}`,
                 `Service env: ${result.serviceEnvPath}`,
                 `Config file: ${result.configPath}`,
                 writeOnly
-                    ? "Service units written. Start them with: sudo systemctl daemon-reload && sudo systemctl enable --now patchrelay.path && sudo systemctl enable patchrelay.service && sudo systemctl reload-or-restart patchrelay.service"
-                    : "PatchRelay system service and config watcher are installed and running.",
-                "After package updates, run: patchrelay restart-service",
+                    ? "Service unit written. Start it with: sudo systemctl daemon-reload && sudo systemctl enable patchrelay.service && sudo systemctl reload-or-restart patchrelay.service"
+                    : "PatchRelay system service is installed and running.",
+                "After package updates, run: patchrelay service restart",
             ].join("\n") + "\n");
         return 0;
     }
@@ -113,13 +114,11 @@ export async function handleInstallServiceCommand(params) {
 }
 export async function handleRestartServiceCommand(params) {
     try {
-        await runServiceCommands(params.runInteractive, restartServiceCommands());
+        await runServiceCommands(params.runCommand, restartServiceCommands());
         writeOutput(params.stdout, params.json
             ? formatJson({
                 service: "patchrelay",
                 unitPath: getSystemdUnitPath(),
-                reloadUnitPath: getSystemdReloadUnitPath(),
-                pathUnitPath: getSystemdPathUnitPath(),
                 runtimeEnvPath: getDefaultRuntimeEnvPath(),
                 serviceEnvPath: getDefaultServiceEnvPath(),
                 configPath: getDefaultConfigPath(),
@@ -133,6 +132,126 @@ export async function handleRestartServiceCommand(params) {
         return 1;
     }
 }
+function parseSystemctlShowOutput(raw) {
+    const properties = {};
+    for (const line of raw.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        const separator = trimmed.indexOf("=");
+        if (separator <= 0)
+            continue;
+        properties[trimmed.slice(0, separator)] = trimmed.slice(separator + 1);
+    }
+    return properties;
+}
+async function readPatchRelayHealth() {
+    try {
+        const config = loadConfig(undefined, { profile: "doctor" });
+        const response = await fetch(`http://${config.server.bind}:${config.server.port}${config.server.healthPath}`, { signal: AbortSignal.timeout(2000) });
+        let body;
+        try {
+            body = await response.json();
+        }
+        catch {
+            body = undefined;
+        }
+        return {
+            reachable: true,
+            status: response.status,
+            ...(body ? { body } : {}),
+        };
+    }
+    catch (error) {
+        return {
+            reachable: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+export async function handleServiceCommand(params) {
+    if (params.commandArgs.length === 0) {
+        throw new CliUsageError("patchrelay service requires a subcommand.", "service");
+    }
+    const subcommand = params.commandArgs[0];
+    if (subcommand === "install") {
+        return await handleInstallServiceCommand({
+            ...params,
+            commandArgs: params.commandArgs.slice(1),
+        });
+    }
+    if (subcommand === "restart") {
+        return await handleRestartServiceCommand({
+            ...params,
+            commandArgs: params.commandArgs.slice(1),
+        });
+    }
+    if (subcommand === "status") {
+        const result = await params.runCommand("sudo", [
+            "systemctl",
+            "show",
+            "patchrelay.service",
+            "--property=Id,LoadState,UnitFileState,ActiveState,SubState,FragmentPath,ExecMainPID",
+        ]);
+        if (result.exitCode !== 0) {
+            throw new Error(result.stderr.trim() || result.stdout.trim() || "Unable to read patchrelay.service status.");
+        }
+        const properties = parseSystemctlShowOutput(result.stdout);
+        const health = await readPatchRelayHealth();
+        const payload = {
+            service: "patchrelay",
+            unit: "patchrelay.service",
+            unitPath: getSystemdUnitPath(),
+            systemd: properties,
+            health,
+        };
+        writeOutput(params.stdout, params.json
+            ? formatJson(payload)
+            : [
+                "PatchRelay service",
+                "",
+                `Unit: ${properties.Id ?? "patchrelay.service"}`,
+                `Load state: ${properties.LoadState ?? "unknown"}`,
+                `Enabled: ${properties.UnitFileState ?? "unknown"}`,
+                `Active: ${properties.ActiveState ?? "unknown"}${properties.SubState ? ` (${properties.SubState})` : ""}`,
+                `Unit path: ${properties.FragmentPath || getSystemdUnitPath()}`,
+                properties.ExecMainPID ? `Main PID: ${properties.ExecMainPID}` : undefined,
+                health.reachable
+                    ? `Health: reachable (HTTP ${health.status})${typeof health.body?.version === "string" ? ` version ${health.body.version}` : ""}`
+                    : `Health: not reachable (${health.error})`,
+            ]
+                .filter(Boolean)
+                .join("\n") + "\n");
+        return 0;
+    }
+    if (subcommand === "logs") {
+        const lines = parsePositiveIntegerFlag(params.parsed.flags.get("lines"), "--lines") ?? 50;
+        const result = await params.runCommand("sudo", [
+            "journalctl",
+            "-u",
+            "patchrelay.service",
+            "-n",
+            String(lines),
+            "--no-pager",
+            "-o",
+            "short-iso",
+        ]);
+        if (result.exitCode !== 0) {
+            throw new Error(result.stderr.trim() || result.stdout.trim() || "Unable to read PatchRelay logs.");
+        }
+        const logs = result.stdout.split(/\r?\n/).filter(Boolean);
+        writeOutput(params.stdout, params.json
+            ? formatJson({
+                service: "patchrelay",
+                unit: "patchrelay.service",
+                lines,
+                logs,
+            })
+            : `${result.stdout}${result.stdout.endsWith("\n") || result.stdout.length === 0 ? "" : "\n"}`);
+        return 0;
+    }
+    throw new CliUsageError(`Unknown service command: ${subcommand}`, "service");
+}
 function normalizePublicBaseUrl(value) {
     const candidate = /^[a-zA-Z][a-zA-Z\d+.-]*:\/\//.test(value) ? value : `https://${value}`;
     const url = new URL(candidate);

package/dist/cli/connect-flow.js

@@ -16,7 +16,9 @@ export async function runConnectFlow(params) {
     }
     if ("completed" in result && result.completed) {
         const label = result.installation.workspaceName ?? result.installation.actorName ?? `installation #${result.installation.id}`;
-        writeOutput(params.stdout, `Linked project ${result.projectId} to existing Linear installation ${result.installation.id} (${label}). No new OAuth approval was needed.\n`);
+        writeOutput(params.stdout, result.projectId
+            ? `Linked repo ${result.projectId} to existing Linear installation ${result.installation.id} (${label}). No new OAuth approval was needed.\n`
+            : `Reused existing Linear installation ${result.installation.id} (${label}). No new OAuth approval was needed.\n`);
         return 0;
     }
     if ("completed" in result) {
@@ -24,7 +26,7 @@ export async function runConnectFlow(params) {
     }
     const opener = params.openExternal;
     const opened = params.noOpen || !opener ? false : await opener(result.authorizeUrl);
-    writeOutput(params.stdout, `${result.projectId ? `Project: ${result.projectId}\n` : ""}${opened ? "Opened browser for Linear OAuth.\n" : "Open this URL in a browser:\n"}${opened ? result.authorizeUrl : `${result.authorizeUrl}\n`}Waiting for OAuth approval...\n`);
+    writeOutput(params.stdout, `${result.projectId ? `Repo: ${result.projectId}\n` : ""}${opened ? "Opened browser for Linear OAuth.\n" : "Open this URL in a browser:\n"}${opened ? result.authorizeUrl : `${result.authorizeUrl}\n`}Waiting for OAuth approval...\n`);
     const deadline = Date.now() + (params.timeoutSeconds ?? 180) * 1000;
     const pollIntervalMs = params.connectPollIntervalMs ?? 1000;
     do {
@@ -32,7 +34,7 @@ export async function runConnectFlow(params) {
         if (status.status === "completed") {
             const label = status.installation?.workspaceName ?? status.installation?.actorName ?? `installation #${status.installation?.id ?? "unknown"}`;
             writeOutput(params.stdout, [
-                `Connected ${label}${status.projectId ? ` for project ${status.projectId}` : ""}.${status.installation?.id ? ` Installation ${status.installation.id}.` : ""}`,
+                `Connected ${label}${status.projectId ? ` for repo ${status.projectId}` : ""}.${status.installation?.id ? ` Installation ${status.installation.id}.` : ""}`,
                 params.config.linear.oauth.actor === "app"
                     ? "If your Linear OAuth app webhook settings are configured, Linear has now provisioned the workspace webhook automatically."
                     : undefined,

package/dist/cli/formatters/text.js

@@ -88,7 +88,7 @@ export function formatOpen(result, command) {
         "git branch --show-current",
     ];
     if (result.needsNewSession) {
-        commands.push(`# No resumable thread found; \`patchrelay open ${result.issue.issueKey ?? result.issue.linearIssueId}\` will create a fresh session.`);
+        commands.push(`# No resumable thread found; \`patchrelay issue open ${result.issue.issueKey ?? result.issue.linearIssueId}\` will create a fresh session.`);
     }
     commands.push(command
         ? formatCommand(command.command, command.args)