ghostrail 0.21.0 → 0.23.0

package/dist/cli/commands.js

@@ -12,7 +12,7 @@ import { parseDuration } from "../config/duration.js";
 import { parseConfig, parseMergedConfig } from "../config/load.js";
 import { MERGE_TRIGGER_COMMENT, createDashboardServer, defaultStateDir, } from "../dashboard/index.js";
 import { hasFailure, renderDoctorJson, renderDoctorText, runDoctor, } from "../doctor/index.js";
-import { buildLoopDeps, buildRespondDeps, buildTriageDeps, repoGhRunner, resolveRepoSlug, } from "../factory/build.js";
+import { buildLoopDeps, buildReleaseDeps, buildRespondDeps, buildTriageDeps, repoGhRunner, resolveRepoSlug, } from "../factory/build.js";
 import { describeMigration, migrateLegacyStore, resolveWorkRepo, stateDirFor, } from "../factory/state.js";
 import { entryKey, findByPath, findForRepoResolving, replaceEntry, upsert, } from "../global/registry.js";
 import { canonicalRepoId, localRepoId, repoKey } from "../global/repo-id.js";
@@ -28,19 +28,21 @@ import { concurrencyAdvice } from "../loop/advice.js";
 import { fileControl } from "../loop/control.js";
 import { readControl } from "../loop/control.js";
 import { runTick } from "../loop/engine.js";
-import { writeNextTickAt } from "../loop/next-tick.js";
+import { clearTickStarted, markTickStarted, writeNextTickAt } from "../loop/next-tick.js";
 import { duePasses, } from "../loop/schedule.js";
 import { appendLog } from "../loop/tick-log.js";
 import { watchLoop } from "../loop/watch.js";
 import { GhHost, parseRepoSlug } from "../publish/gh.js";
+import { releaseNow, releaseTick, requestRelease } from "../release/release.js";
 import { resolveIgnoredAuthors } from "../respond/authors.js";
+import { FileCiFixQueueStore } from "../respond/ci-fix-queue.js";
 import { respondTick } from "../respond/respond.js";
 import { GLOBAL_SECRETS_FILE, appendPlaceholders, applyOverrides, launchEditor as defaultLaunchEditor, loadEnvOverrides, missingSecrets, readSecretsFile, redactSecrets, renderFile, resolveEditor, secretValuesOf, writeSecretsFile, } from "../secrets/index.js";
 import { DASHBOARD_UNIT, renderDashboardUnit, servicePath, stopTimeoutSeconds, systemdManager, unitName, } from "../service/index.js";
 import { applySkillPlan, describePlan, pathCtx, planSkillInstall, uninstallSkill, } from "../skill/install.js";
 import { FileStore } from "../store/file-store.js";
 import { triageTick } from "../triage/engine.js";
-import { VERSION } from "../version.js";
+import { STABILITY_NOTICE, VERSION } from "../version.js";
 import { askOnTerminal, parseInstallOffers } from "./prompt.js";
 import { describeStalledUpdate } from "./update-diagnosis.js";
 /**
@@ -187,8 +189,13 @@ async function resolveClaudeProfile(env) {
  * Shared setup for the run/watch loops: apply secrets, load the merged config,
  * require the Linear key, and assemble the loop deps. Prints errors and returns
  * undefined on failure.
+ *
+ * `loggerFor` is the seam TJ-1682 turned on: the logger the deps are built with
+ * is decided here, because only here is the state directory known, and a caller
+ * that builds its own afterwards cannot reach the engine's narration. Exported
+ * so that invariant can be tested directly rather than inferred from a tick.
  */
-async function prepareLoop(flags, streams, env) {
+export async function prepareLoop(flags, streams, env, loggerFor = (_dir, secrets) => makeLogger(streams, secrets)) {
     const secrets = await applySecrets(flags, env);
     const loaded = await loadConfig(flags, streams, env);
     if (loaded === undefined)
@@ -212,6 +219,9 @@ async function prepareLoop(flags, streams, env) {
     // of one repo running overlapping ticks: while the store lived inside each
     // checkout they took different locks and nothing serialized them.
     const lock = new FileLock(join(state.dir, "lock"), config.guardrails.claimTtlMs);
+    // Keyed on the state dir because that is what a persisting logger needs and
+    // only `prepareLoop` knows it: the caller cannot build this itself (TJ-1682).
+    const logger = loggerFor(state.dir, secrets);
     const ctx = {
         repoPath: flags.repo,
         ...(work.path === undefined ? {} : { workRepoPath: work.path }),
@@ -227,10 +237,10 @@ async function prepareLoop(flags, streams, env) {
         ...(claudeProfileDir === undefined ? {} : { claudeProfileDir }),
         ...(promptSourceDir === undefined ? {} : { promptSourceDir }),
         ...(repoSlug === undefined ? {} : { repoSlug }),
-        logger: makeLogger(streams, secrets),
+        logger,
     };
     const deps = buildLoopDeps(config, ctx);
-    return { config, deps, secrets, stateDir: state.dir, ctx };
+    return { config, deps, secrets, stateDir: state.dir, ctx, logger };
 }
 /** `ghostrail run`: drain eligible work once. */
 export async function cmdRun(argv, streams, env = process.env, cwd = process.cwd()) {
@@ -243,12 +253,14 @@ export async function cmdRun(argv, streams, env = process.env, cwd = process.cwd
     return result.results.some((r) => r.state === "failed") ? 1 : 0;
 }
 /**
- * Parse `ghostrail watch` options: `--interval`/`-i <duration>` (default `60s`)
- * and an optional `--max-ticks <n>`. Returns undefined for a malformed interval.
+ * Parse `ghostrail watch` options: `--interval`/`-i <duration>` (default `60s`),
+ * an optional `--max-ticks <n>`, and `--self-update-restart`. Returns undefined
+ * for a malformed interval.
  */
 export function parseWatchFlags(argv) {
     let intervalLabel = "60s";
     let maxTicks;
+    let selfUpdateRestart = false;
     for (let i = 0; i < argv.length; i++) {
         const arg = argv[i];
         const next = argv[i + 1];
@@ -262,13 +274,51 @@ export function parseWatchFlags(argv) {
                 maxTicks = n;
             i++;
         }
+        else if (arg === "--self-update-restart") {
+            selfUpdateRestart = true;
+        }
     }
     const intervalMs = parseDuration(intervalLabel);
     if (intervalMs === null)
         return undefined;
-    return maxTicks === undefined
-        ? { intervalMs, intervalLabel }
-        : { intervalMs, intervalLabel, maxTicks };
+    return {
+        intervalMs,
+        intervalLabel,
+        ...(maxTicks === undefined ? {} : { maxTicks }),
+        ...(selfUpdateRestart ? { selfUpdateRestart: true } : {}),
+    };
+}
+/** Detached so the relaunch survives this process exiting right after. */
+function defaultRestart(watchArgv) {
+    spawn("ghostrail", ["watch", ...watchArgv], { stdio: "inherit", detached: true }).unref();
+}
+/**
+ * `--self-update-restart`'s whole behavior: called between ticks (never
+ * mid-tick, since `watchLoop` awaits `tick()` to completion first). Checks
+ * whether a newer ghostrail is published; if not, this is a no-op — refusing
+ * to start an update *is* the "pause ticks" the feature asks for, since the
+ * caller simply lets the loop continue. If a newer version exists, updates the
+ * same way `ghostrail self-update` does and, only on success, relaunches a
+ * detached process with the exact argv `watch` was given. A failed update is
+ * reported and left running on the current version rather than restarted.
+ */
+export async function maybeSelfUpdateAndRestart(watchArgv, streams, deps = {}) {
+    const current = deps.currentVersion ?? VERSION;
+    const latestVersion = deps.latestVersion ?? registryLatestVersion;
+    const selfUpdate = deps.selfUpdate ?? cmdSelfUpdate;
+    const restart = deps.restart ?? defaultRestart;
+    const latest = await latestVersion();
+    if (latest === undefined || latest === current)
+        return false;
+    streams.err(`self-update-restart: ${current} -> ${latest} available; updating\n`);
+    const code = await selfUpdate([], streams);
+    if (code !== 0) {
+        streams.err("self-update-restart: update failed; staying on the running version\n");
+        return false;
+    }
+    streams.err(`self-update-restart: restarting: ghostrail watch ${watchArgv.join(" ")}\n`);
+    restart(watchArgv);
+    return true;
 }
 /**
  * The passes this config can run under `watch`: the fix queue always, plus
@@ -293,6 +343,10 @@ function schedulablePasses(setup, streams) {
             streams.err(`not watching triage: ${error instanceof Error ? error.message : String(error)}\n`);
         }
     }
+    if (setup.config.release !== undefined) {
+        const { deps, config: releaseConfig } = buildReleaseDeps(setup.config, setup.ctx);
+        passes.release = () => releaseTick(deps, releaseConfig);
+    }
     return passes;
 }
 /** The intervals for the passes that are actually wired up. */
@@ -304,11 +358,14 @@ function intervalsOf(config, passes) {
     if (passes.triage !== undefined && config.triage?.everyMs !== undefined) {
         intervals.triage = config.triage.everyMs;
     }
+    if (passes.release !== undefined) {
+        intervals.release = true;
+    }
     return intervals;
 }
-/** The ", plus respond every 5m" tail of the watch banner. */
+/** The ", plus respond and triage" tail of the watch banner. */
 function describeSchedule(passes) {
-    const extra = ["respond", "triage"].filter((pass) => passes[pass] !== undefined);
+    const extra = ["respond", "triage", "release"].filter((pass) => passes[pass] !== undefined);
     return extra.length === 0 ? "" : `, plus ${extra.join(" and ")}`;
 }
 export async function cmdWatch(argv, streams, env = process.env, cwd = process.cwd()) {
@@ -318,16 +375,29 @@ export async function cmdWatch(argv, streams, env = process.env, cwd = process.c
         streams.err('invalid --interval (use e.g. "30s", "5m", "1h")\n');
         return 1;
     }
-    const setup = await prepareLoop(flags, streams, env);
+    // The persisting logger has to be the one the loop deps are built with, not a
+    // second one made afterwards: the engine narrates through `ctx.logger`, and a
+    // logger `watch` keeps to itself only ever sees pause, resume, and a thrown
+    // tick, which is why the log stayed empty (TJ-1682).
+    const setup = await prepareLoop(flags, streams, env, (dir, secrets) => watchLogger(streams, secrets, dir));
     if (setup === undefined)
         return 1;
     const controller = new AbortController();
     const onSignal = () => controller.abort();
     process.once("SIGINT", onSignal);
     process.once("SIGTERM", onSignal);
-    const logger = watchLogger(streams, setup.secrets, setup.stateDir);
+    const logger = setup.logger;
+    // A process killed mid-tick leaves its marker behind; starting up is the one
+    // moment we can be certain no tick of ours is running (TJ-1683).
+    try {
+        await clearTickStarted(setup.stateDir);
+    }
+    catch {
+        // Display state only. Never worth refusing to start over.
+    }
     const passes = schedulablePasses(setup, streams);
     streams.err(`watching every ${watch.intervalLabel}${describeSchedule(passes)}; press Ctrl-C to stop\n`);
+    let restarting = false;
     try {
         const controlDir = setup.stateDir;
         // In memory, for the life of this process: a restart re-runs every pass
@@ -340,6 +410,15 @@ export async function cmdWatch(argv, streams, env = process.env, cwd = process.c
             isEnabled: async () => (await readControl(controlDir)).enabled,
             ...(watch.maxTicks === undefined ? {} : { maxTicks: watch.maxTicks }),
             tick: async () => {
+                // Best-effort and for display only (specs/dashboard-log.spec.md): a
+                // tick that outlasts the interval is ordinary here, and without this
+                // the countdown reaches zero and has nothing left to say (TJ-1683).
+                try {
+                    await markTickStarted(setup.stateDir, Date.now());
+                }
+                catch {
+                    // the countdown is a convenience, not something the loop depends on
+                }
                 const due = duePasses({
                     now: Date.now(),
                     intervals: intervalsOf(setup.config, passes),
@@ -351,7 +430,11 @@ export async function cmdWatch(argv, streams, env = process.env, cwd = process.c
                         continue;
                     try {
                         const result = await run();
-                        streams.out(`${pass}: ${redactSecrets(JSON.stringify(result, null, 2), setup.secrets)}\n`);
+                        // Through the logger, not `streams.out`: this is the most useful
+                        // line a tick produces, and writing it straight to stdout kept it
+                        // out of the log the dashboard shows (TJ-1682). `watchLogger`
+                        // redacts, so this no longer redacts a second time.
+                        logger.info(`${pass}: ${JSON.stringify(result, null, 2)}`);
                     }
                     catch (error) {
                         // One broken pass must not disable the other two, and must not
@@ -360,7 +443,8 @@ export async function cmdWatch(argv, streams, env = process.env, cwd = process.c
                         // an agent-backed pass means spending money in a loop.
                         logger.warn(`${pass} pass failed: ${error instanceof Error ? error.message : String(error)}`);
                     }
-                    if (pass !== "fix")
+                    // `release` has no interval to stamp (see PassIntervals), same as `fix`.
+                    if (pass !== "fix" && pass !== "release")
                         lastRunAt[pass] = Date.now();
                 }
                 // Best-effort and for display only (specs/dashboard-log.spec.md): the
@@ -372,9 +456,17 @@ export async function cmdWatch(argv, streams, env = process.env, cwd = process.c
                 catch {
                     // the countdown is a convenience, not something the loop depends on
                 }
+                // Checked once per tick, never mid-tick: `watchLoop` awaits this whole
+                // callback before starting the next one, so this only ever runs
+                // between ticks (specs/self-update-restart.spec.md).
+                if (watch.selfUpdateRestart === true) {
+                    restarting = await maybeSelfUpdateAndRestart(argv, streams);
+                    if (restarting)
+                        controller.abort();
+                }
             },
         });
-        streams.err(`stopped after ${ticks} tick(s)\n`);
+        streams.err(restarting ? "stopped for self-update-restart\n" : `stopped after ${ticks} tick(s)\n`);
         return 0;
     }
     finally {
@@ -471,6 +563,43 @@ export async function cmdRespond(argv, streams, env = process.env, cwd = process
     streams.out(`${redactSecrets(JSON.stringify(results, null, 2), secrets)}\n`);
     return results.some((r) => r.state === "failed") ? 1 : 0;
 }
+/** `ghostrail release`: cut one release now. What "release" means is entirely [release].prompt's business. */
+export async function cmdRelease(argv, streams, env = process.env, cwd = process.cwd()) {
+    const flags = parseCommandFlags(argv, { config: "ghostrail.toml", repo: cwd });
+    const secrets = await applySecrets(flags, env);
+    const loaded = await loadConfig(flags, streams, env);
+    if (loaded === undefined)
+        return 1;
+    const { config, promptSourceDir } = loaded;
+    if (config.release === undefined) {
+        streams.err("no [release] section in the config; add one to use `ghostrail release`\n");
+        return 1;
+    }
+    const claudeProfileDir = await resolveClaudeProfile(env);
+    const releaseState = await prepareState(flags.repo, config, env, streams);
+    const releaseWork = await resolveWorkRepo({
+        repoPath: flags.repo,
+        stateDir: releaseState.dir,
+        config,
+        env,
+    });
+    if (releaseWork.note !== undefined)
+        streams.err(`${releaseWork.note}\n`);
+    // No LINEAR_API_KEY requirement: a release touches no tracker item.
+    const { deps, config: releaseConfig } = buildReleaseDeps(config, {
+        repoPath: flags.repo,
+        ...(releaseWork.path === undefined ? {} : { workRepoPath: releaseWork.path }),
+        stateDir: releaseState.dir,
+        linearApiKey: env.LINEAR_API_KEY ?? "",
+        lock: { acquire: async () => true, release: async () => { } },
+        ...(claudeProfileDir === undefined ? {} : { claudeProfileDir }),
+        ...(promptSourceDir === undefined ? {} : { promptSourceDir }),
+        logger: makeLogger(streams, secrets),
+    });
+    const result = await releaseNow(deps, releaseConfig);
+    streams.out(`${redactSecrets(JSON.stringify(result, null, 2), secrets)}\n`);
+    return result.state === "failed" ? 1 : 0;
+}
 /** Parse `board` flags: `--repo`, `--port`, `--bind`, `--token`. */
 export function parseBoardFlags(argv, defaults) {
     const flags = { ...defaults };
@@ -546,6 +675,10 @@ export async function cmdBoard(argv, streams, env = process.env, cwd = process.c
             bind: flags.bind,
             gitHost,
             control: fileControl(store.dir),
+            // Same directory `buildRespondDeps` resolves for this repo and config
+            // (`stateDirFor`), so a "Fix CI" click here is what the next
+            // `ghostrail respond` tick actually reads.
+            ciFixQueue: new FileCiFixQueueStore(join(store.dir, "ci-fix-queue.json")),
             ...(flags.token === undefined ? {} : { token: flags.token }),
             ...(unauthenticated ? { allowNoToken: true } : {}),
         });
@@ -636,12 +769,23 @@ function dashboardDeps(env, manager) {
         // subprocess. A machine with no `gh` and no credentials still serves the
         // whole dashboard, with PR status reported as unavailable.
         prStatus: async (entry, prNumber) => new GhHost(repoGhRunner(entry.path), await slugFor(entry)).getPrStatus(prNumber),
+        // The same directory `buildRespondDeps` resolves for this repo and
+        // config, so a "Fix CI" click here is what that ghostrail's next
+        // `ghostrail respond` tick actually reads.
+        ciFixQueue: async (entry) => new FileCiFixQueueStore(join(await defaultStateDir(entry), "ci-fix-queue.json")),
         // Posts the same trigger comment a human typing "resolve conflicts and
         // merge" by hand would; the next respond pass does the actual work (see
         // specs/dashboard-review-mode.spec.md). A machine with no `gh` and no
         // credentials still serves the whole dashboard; the route just answers
         // 503 rather than failing to start.
         mergeTrigger: async (entry, prNumber) => new GhHost(repoGhRunner(entry.path), await slugFor(entry)).postComment(prNumber, MERGE_TRIGGER_COMMENT),
+        releaseEnabled: (path) => releaseEnabledFor(path),
+        // Queuing a release is a local file write plus a store event, not a `gh`
+        // call, so this never needs the "no credentials" fallback mergeTrigger has.
+        releaseTrigger: async (entry) => {
+            const dir = await defaultStateDir(entry);
+            return requestRelease(dir, new FileStore(dir));
+        },
         readRegistry: () => store.readRegistry(),
         writeRegistry: (entries) => store.writeRegistry(entries),
         health: ghostrailHealth,
@@ -728,6 +872,25 @@ export async function ghostrailHealth(path) {
         return "missing";
     return (await resolveConfigPath(path)) !== undefined ? "ok" : "no config";
 }
+/**
+ * Whether a registered ghostrail has `[release]` configured — the dashboard's
+ * gate for showing the release button. False for anything that cannot be
+ * read or parsed, the same leniency `ghostrailHealth` already has: a config
+ * problem hides the button rather than erroring the whole listing.
+ */
+export async function releaseEnabledFor(path) {
+    const configPath = await resolveConfigPath(path);
+    if (configPath === undefined)
+        return false;
+    try {
+        const toml = await readFile(configPath, "utf8");
+        const parsed = parseConfig(toml);
+        return parsed.ok && parsed.value.release !== undefined;
+    }
+    catch {
+        return false;
+    }
+}
 /** `ghostrail ls`: the ghostrails this account knows about. */
 export async function cmdLs(_argv, streams, env = process.env) {
     const store = globalStoreFor(env);
@@ -1740,6 +1903,7 @@ export async function cmdInit(argv, streams, cwd = process.cwd(), env = process.
     }
     await registerGhostrail(repo, env, streams, { repoint, forceRegister: register });
     streams.out(await initNextStepsHint(env, cwd));
+    streams.out(`${STABILITY_NOTICE}\n`);
     return 0;
 }
 /**
@@ -1877,6 +2041,7 @@ async function npmInstallGlobalResult(version) {
  * install` gives you exactly x.y.z.
  */
 export async function cmdInstall(argv, streams, env = process.env, cwd = process.cwd(), deps = {}) {
+    streams.out(`${STABILITY_NOTICE}\n`);
     streams.out(`installing ghostrail@${VERSION} globally...\n`);
     const code = await npmInstallGlobal(VERSION);
     if (code !== 0) {