ghostrail 0.20.1 → 0.22.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,10 +28,14 @@ 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 { 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";
@@ -68,6 +72,27 @@ function makeLogger(streams, secrets) {
         warn: (message) => streams.err(`${redactSecrets(message, secrets)}\n`),
     };
 }
+/**
+ * `watch`'s logger: everything `makeLogger` does, plus a redacted copy of
+ * every line appended to this repo's rolling watch log (`src/loop/tick-log.ts`),
+ * so the dashboard has something to show for a daemon it has no live
+ * connection to. `ghostrail run` and a standalone respond/triage pass keep
+ * using the plain logger: only the watch loop is what the dashboard's log
+ * section is about.
+ */
+function watchLogger(streams, secrets, dir) {
+    const base = makeLogger(streams, secrets);
+    return {
+        info: (message) => {
+            base.info(message);
+            void appendLog(dir, redactSecrets(message, secrets));
+        },
+        warn: (message) => {
+            base.warn(message);
+            void appendLog(dir, `WARN ${redactSecrets(message, secrets)}`);
+        },
+    };
+}
 /**
  * The effective `ghostrail.toml` path for a repo: the repo's own file if it
  * has one, else wherever its `.ghostrail-config` pointer file names, else
@@ -164,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)
@@ -189,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 }),
@@ -204,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()) {
@@ -270,6 +303,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. */
@@ -281,11 +318,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()) {
@@ -295,14 +335,26 @@ 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 = makeLogger(streams, setup.secrets);
+    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`);
     try {
@@ -317,6 +369,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),
@@ -328,7 +389,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
@@ -337,9 +402,19 @@ 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
+                // dashboard's countdown reads this back, but nothing here depends on
+                // it, so a write failure must not touch the loop.
+                try {
+                    await writeNextTickAt(setup.stateDir, Date.now() + watch.intervalMs);
+                }
+                catch {
+                    // the countdown is a convenience, not something the loop depends on
+                }
             },
         });
         streams.err(`stopped after ${ticks} tick(s)\n`);
@@ -439,6 +514,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 };
@@ -514,6 +626,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 } : {}),
         });
@@ -604,12 +720,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,
@@ -696,6 +823,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);
@@ -1192,6 +1338,12 @@ async function ghostrailName(repo) {
  * as it is, because re-running `init --update` must not switch `watch` back on
  * for a ghostrail the operator deliberately turned off.
  *
+ * `options.repoint` gates the one case that is an act, not an add: an entry
+ * that already has an identity, pointing at a checkout other than this one.
+ * Off by default, an existing entry is reported and left alone rather than
+ * rewritten, so a second clone of a registered repo cannot silently steal the
+ * entry that governs what `start` runs unattended (TJ-1652).
+ *
  * Never fails the command. Scaffolding the repo is the job; registering it is a
  * convenience, and aborting a good scaffold over an unwritable config dir would
  * be the worse trade.
@@ -1241,11 +1393,11 @@ async function prepareState(repo, config, env, streams) {
         streams.err(`${note}\n`);
     return { dir: state.dir, repoId: state.repoId };
 }
-async function registerGhostrail(repo, env, streams, forceRegister = false) {
+async function registerGhostrail(repo, env, streams, options = {}) {
     const store = globalStoreFor(env);
     const path = resolve(repo);
     try {
-        if (!forceRegister && (await isTempPath(path, env))) {
+        if (options.forceRegister !== true && (await isTempPath(path, env))) {
             // `watch` defaults to true and, for a repo with no remote, `path` is the
             // identity: registering here would switch on a service unit pointed at a
             // directory that is going to vanish. Scaffolding still happened; only the
@@ -1261,12 +1413,27 @@ async function registerGhostrail(repo, env, streams, forceRegister = false) {
         const repoId = await resolveRepoId(path);
         const existing = await findForRepoResolving(entries, repoId, path, resolveRepoId);
         if (existing !== undefined) {
+            if (existing.repo === repoId && existing.path === path)
+                return;
+            // An entry that already has an identity, at a *different* path than this
+            // checkout, is a deliberate repoint, not a migration. `--update` promises
+            // to write only what it can prove is safe everywhere else, and moving the
+            // entry that governs what `start` runs unattended is a far bigger act
+            // than anything else it does, so it never happens as a side effect of
+            // asking for template changes. Report it and leave the registry alone,
+            // the way a stale entry is already reported rather than pruned.
+            if (existing.repo !== undefined && options.repoint !== true) {
+                streams.out(`this repo already has the ghostrail "${existing.name}", registered at a different checkout
+  registered: ${existing.path}
+  this one:   ${path}
+  \`ghostrail ls\` lists it; re-run with --repoint to point it here instead
+`);
+                return;
+            }
             // Everything the entry already carries survives, `watch` above all:
             // re-registering must never switch a ghostrail back on that the operator
             // deliberately turned off.
             const adopted = { ...existing, repo: repoId, path };
-            if (existing.repo === repoId && existing.path === path)
-                return;
             // By the entry's *old* key: adopting an identity re-keys it, so an
             // ordinary upsert would append beside it rather than replace it.
             await store.writeRegistry(replaceEntry(entries, entryKey(existing), adopted));
@@ -1333,7 +1500,7 @@ async function promptPathsAt(configPath) {
  * the template gained, which is what every hand port consisted of before
  * regions existed, and the skill places them in the repo's own wording.
  */
-async function applyTemplateUpdate(template, srcDir, repo, streams, env, register) {
+async function applyTemplateUpdate(template, srcDir, repo, streams, env, options) {
     const manifest = await readManifest(repo);
     const rels = await scaffoldFiles(srcDir);
     const templatePrompts = (await promptPathsAt(join(srcDir, "ghostrail.toml"))) ?? {};
@@ -1458,7 +1625,10 @@ async function applyTemplateUpdate(template, srcDir, repo, streams, env, registe
     if (Object.keys(written).length > 0 || Object.keys(writtenRegions).length > 0) {
         await writeManifest(repo, mergeManifest(manifest, template, VERSION, written, writtenRegions));
     }
-    await registerGhostrail(repo, env, streams, register);
+    await registerGhostrail(repo, env, streams, {
+        repoint: options.repoint,
+        forceRegister: options.register,
+    });
     streams.out("\n");
     if (took > 0)
         streams.out(`took ${took} file(s) you had not edited\n`);
@@ -1502,7 +1672,8 @@ async function removeLocalScaffold(repo, rels) {
     }
 }
 /**
- * `ghostrail init <template> [--repo <path>] [--force|--diff|--update|--greenroom [<path>]] [--register]`:
+ * `ghostrail init <template> [--repo <path>] [--force|--diff|--update|--greenroom
+ * [<path>]] [--register] [--repoint]`:
  * scaffold `ghostrail.toml` and `prompts/` from a quickstart template. Safe for
  * a fresh OR an existing repo: existing files are left untouched (skipped)
  * unless `--force` is given. `--diff` reports drift instead of writing
@@ -1514,6 +1685,11 @@ async function removeLocalScaffold(repo, rels) {
  *
  * Registration is skipped, not just the write, when the target looks like a
  * temp directory (TJ-1654); `--register` registers it anyway.
+ *
+ * `--repoint` opts into the one registry write that is an act rather than an
+ * add: moving an already-registered ghostrail's entry to this checkout when it
+ * is currently pointing somewhere else. Without it, that mismatch is reported
+ * and the registry is left alone (TJ-1652).
  */
 export async function cmdInit(argv, streams, cwd = process.cwd(), env = process.env) {
     let template;
@@ -1521,6 +1697,7 @@ export async function cmdInit(argv, streams, cwd = process.cwd(), env = process.
     let force = false;
     let diff = false;
     let update = false;
+    let repoint = false;
     let register = false;
     let greenroom = false;
     let greenroomPath;
@@ -1540,6 +1717,9 @@ export async function cmdInit(argv, streams, cwd = process.cwd(), env = process.
         else if (arg === "--update") {
             update = true;
         }
+        else if (arg === "--repoint") {
+            repoint = true;
+        }
         else if (arg === "--register") {
             register = true;
         }
@@ -1555,7 +1735,7 @@ export async function cmdInit(argv, streams, cwd = process.cwd(), env = process.
         }
     }
     if (template === undefined || !TEMPLATES.includes(template)) {
-        streams.err(`usage: ghostrail init <template> [--repo <path>] [--force|--diff|--update|--greenroom [<path>]] [--register]\ntemplates: ${TEMPLATES.join(", ")}\n`);
+        streams.err(`usage: ghostrail init <template> [--repo <path>] [--force|--diff|--update|--greenroom [<path>]] [--register] [--repoint]\ntemplates: ${TEMPLATES.join(", ")}\n`);
         return 1;
     }
     if (diff && force) {
@@ -1578,7 +1758,10 @@ export async function cmdInit(argv, streams, cwd = process.cwd(), env = process.
     const srcDir = join(templatesDir(), template);
     if (update) {
         try {
-            return await applyTemplateUpdate(template, srcDir, repo, streams, env, register);
+            return await applyTemplateUpdate(template, srcDir, repo, streams, env, {
+                repoint,
+                register,
+            });
         }
         catch (error) {
             streams.err(`init --update failed: ${error instanceof Error ? error.message : String(error)}\n`);
@@ -1669,7 +1852,7 @@ export async function cmdInit(argv, streams, cwd = process.cwd(), env = process.
         streams.out("this repo's config and prompts now live outside it; keep that pointer file out of\n" +
             "version control (it is host-specific), the same as .ghostrail.env\n");
     }
-    await registerGhostrail(repo, env, streams, register);
+    await registerGhostrail(repo, env, streams, { repoint, forceRegister: register });
     streams.out(await initNextStepsHint(env, cwd));
     return 0;
 }