autonomous-sdlc-harness 0.1.0

package/dist/daemon/backend.js

@@ -0,0 +1,180 @@
+/**
+ * Which service manager this host can install the run daemon into, and where the run watcher is.
+ *
+ * **The rule this module exists to enforce: there is one detection, and `doctor` and `daemon` both
+ * import it.** The two commands must agree — `doctor` telling an operator the daemon is installable
+ * while `daemon install` refuses, or the reverse, is worse than either answer alone, because the
+ * operator has no way to tell which one is wrong. A second copy of the probe in the command that
+ * wanted a slightly different message is how that disagreement starts, so the messages live here
+ * too, as the `reason` string each result carries.
+ *
+ * Two invariants hold in every probe below:
+ *
+ * 1. **`execFileSync` with an argv array, never a shell string** — no `shell: true`, no `which`
+ *    pipeline, no interpolation. A pipeline would be a compound command, which an unattended run's
+ *    permission profile cannot allow-list as one literal, and which stalls rather than failing.
+ * 2. **Every probe is bounded and its output discarded.** A service manager that hangs must cost a
+ *    timeout rather than the run: `doctor` is the command an operator reaches for *because*
+ *    something is wrong with the host, and it has to answer.
+ *
+ * ## The watcher is the repository's, not this package's
+ *
+ * The daemon runs one script — the run watcher — and `init` writes it into the adopter's configured
+ * `scriptsDir` with the rest of the outer-loop set. {@link resolveWatcherPath} therefore joins the
+ * repository root to that configured directory, and {@link WATCHER_ABSENCE_MESSAGE} is the one
+ * sentence both commands use when nothing is there: `doctor` reports it as a warning, so a
+ * repository whose watcher was deleted still exits 0, and `daemon install` refuses, because
+ * installing a unit whose `ExecStart` points at nothing gives a service that restarts forever and
+ * logs nothing anyone reads.
+ *
+ * The path is **repo-relative and not a configuration key of its own**: `scriptsDir` already is one,
+ * and the file name comes from `generators/outerLoopScripts.ts`'s table — the single declaration of
+ * which outer-loop files ship and where each lands — so the writer and the daemon cannot disagree
+ * about what the daemon runs. Resolving against the repository is also what keeps the rendered
+ * unit's `ExecStart` inside the same repository its `WorkingDirectory` already names: a CLI invoked
+ * through `npx` lives in a cache directory that is deleted out from under a long-running service,
+ * and a package-relative program would have made that path a daemon's `ExecStart`. `--watcher`
+ * overrides it for developing against a watcher that is not the written one.
+ */
+import { execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { homeRoot } from '../core/paths.js';
+import { outerLoopScriptPath, WATCHER_SCRIPT_NAME } from '../generators/outerLoopScripts.js';
+/** `launchctl`'s `--version`-equivalent: it prints the running launchd's version and exits 0. */
+const LAUNCHCTL_PROBE = Object.freeze(['version']);
+/** `systemctl`'s version probe — resolution of the binary only, not of a user instance. */
+const SYSTEMCTL_PROBE = Object.freeze(['--version']);
+/**
+ * The per-user-instance probe.
+ *
+ * `--user show-environment` exits 0 exactly when the calling account's systemd manager is reachable
+ * over its bus, which is the condition a user unit needs and the binary's presence does not imply —
+ * a container image or an `ssh` session with no user bus has `systemctl` and no manager to talk to.
+ * `is-system-running` is the obvious alternative and is wrong here: it reports `degraded` with a
+ * non-zero status on a perfectly usable host, which would demote a working backend to `none`.
+ */
+const SYSTEMD_USER_PROBE = Object.freeze(['--user', 'show-environment']);
+/** Longest a probe may take before it is treated as "this tool did not answer". */
+const PROBE_TIMEOUT_MS = 5_000;
+/** The launchd user-agent directory, relative to the account home. */
+const LAUNCHD_UNIT_DIR = Object.freeze(['Library', 'LaunchAgents']);
+/** The systemd user-unit directory, relative to the account home. */
+const SYSTEMD_UNIT_DIR = Object.freeze(['.config', 'systemd', 'user']);
+/**
+ * The single sentence both commands use for the watcher's absence.
+ *
+ * Exported rather than written twice so a `doctor` warning and a `daemon install` refusal cannot
+ * describe the same condition differently — the second-worst outcome after describing it wrongly.
+ *
+ * It names the two ways a wired repository reaches this state, because they are the two the operator
+ * has to choose between: the file was removed, or `scriptsDir` was changed and `init` has not been
+ * run since. Both are repaired by the same command, which is why the remedy is one sentence.
+ */
+export const WATCHER_ABSENCE_MESSAGE = 'the run watcher is written into the configured scriptsDir by `init`, so nothing there means it was removed, or scriptsDir was changed without a re-run';
+/**
+ * Run a tool with a fixed argument vector and report whether it answered.
+ *
+ * Both failure modes collapse to `false` on purpose: a tool that is not on PATH and a tool that
+ * exited non-zero are the same answer to the only question asked — can this host's service manager
+ * be driven from here. The distinction that *does* matter, between "no systemctl" and "systemctl
+ * with no user instance", is drawn by which probe failed, not by how it failed.
+ */
+function toolResponds(command, args) {
+    try {
+        execFileSync(command, [...args], {
+            stdio: ['ignore', 'ignore', 'ignore'],
+            timeout: PROBE_TIMEOUT_MS,
+            windowsHide: true,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** `~/Library/LaunchAgents` — where a launchd user agent is installed. */
+export function launchdUnitDir() {
+    return join(homeRoot(), ...LAUNCHD_UNIT_DIR);
+}
+/** `~/.config/systemd/user` — where a systemd user unit is installed. */
+export function systemdUnitDir() {
+    return join(homeRoot(), ...SYSTEMD_UNIT_DIR);
+}
+/**
+ * Detect the service manager the run daemon can be installed into.
+ *
+ * The order is fixed and first-match-wins:
+ *
+ * 1. **launchd**, when this is macOS *and* `launchctl` answers. The platform check comes first
+ *    because launchd is not something a non-macOS host has a working `launchctl` for.
+ * 2. **systemd**, when `systemctl` answers *and* the calling account's user instance is reachable.
+ *    Both halves are required: a `systemctl` with no user manager behind it produces a unit file
+ *    that installs and never starts, which is the failure this second probe exists to turn into an
+ *    up-front `none` with a fixable reason.
+ * 3. **none** otherwise, always with a reason naming what was missing. `none` is a statement about
+ *    the host, not an error — the caller decides whether it is fatal (`daemon install`) or a
+ *    reported condition (`doctor`).
+ */
+export function detectBackend() {
+    const platform = process.platform;
+    const isMac = platform === 'darwin';
+    if (isMac && toolResponds('launchctl', LAUNCHCTL_PROBE)) {
+        return {
+            kind: 'launchd',
+            reason: 'macOS with a responding launchctl: the run daemon installs as a launchd user agent',
+            unitPath: launchdUnitDir(),
+        };
+    }
+    if (toolResponds('systemctl', SYSTEMCTL_PROBE)) {
+        if (toolResponds('systemctl', SYSTEMD_USER_PROBE)) {
+            return {
+                kind: 'systemd',
+                reason: 'systemd with a reachable per-user instance: the run daemon installs as a user unit',
+                unitPath: systemdUnitDir(),
+            };
+        }
+        return {
+            kind: 'none',
+            reason: 'systemctl responded but this account has no reachable systemd user instance (systemctl --user show-environment failed), so a user unit would install and never start: run the install from a logged-in session of the account that will own the run, or enable lingering for that account',
+        };
+    }
+    if (isMac) {
+        return {
+            kind: 'none',
+            reason: 'this host reports itself as macOS but launchctl did not answer, and there is no systemctl either: the run daemon has no service manager to install into here',
+        };
+    }
+    return {
+        kind: 'none',
+        reason: `no supported service manager on ${platform}: the run daemon needs launchd (macOS) or a systemd user instance`,
+    };
+}
+/**
+ * Where the run watcher is, and whether it is there.
+ *
+ * With no override the answer is `<repoRoot>/<scriptsDir>/<watcher>` — where `init` wrote it, taken
+ * from the writer's own {@link outerLoopScriptPath} so the daemon and the generator cannot resolve
+ * one configured `scriptsDir` differently. A `--watcher` value is resolved against the current
+ * directory instead, so a relative one behaves the way a path typed on a command line does.
+ *
+ * `present` is a plain existence check and is deliberately not upgraded to an executability or
+ * shebang check: the generated copy is the adopter's to edit, and a stricter probe here would start
+ * refusing to install a daemon over an edit that is none of this command's business.
+ */
+export function resolveWatcherPath({ repoRoot, config, override }) {
+    const trimmed = override?.trim();
+    const path = trimmed !== undefined && trimmed !== ''
+        ? resolve(trimmed)
+        : outerLoopScriptPath(repoRoot, config, WATCHER_SCRIPT_NAME);
+    return { path, present: existsSync(path) };
+}
+/**
+ * The full sentence for a missing watcher, built from {@link WATCHER_ABSENCE_MESSAGE} so the
+ * warning `doctor` prints and the refusal `daemon install` throws say the same thing about the same
+ * path.
+ */
+export function watcherMissingMessage(path) {
+    return `no run watcher at ${path}: ${WATCHER_ABSENCE_MESSAGE}. Re-run \`init\` to write it back, or point --watcher at a watcher script of your own`;
+}
+//# sourceMappingURL=backend.js.map

package/dist/daemon/backend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend.js","sourceRoot":"","sources":["../../src/daemon/backend.ts"],"names":[],"mappings":"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"}

package/dist/daemon/units.js

@@ -0,0 +1,380 @@
+/**
+ * Render the run daemon's unit file for the detected backend, and say where it is installed.
+ *
+ * **The rule this module exists to enforce: the unit's identifier, its install path and its text are
+ * produced together, from one call.** A caller that composed a label itself and read the target path
+ * from somewhere else would eventually install a file at one name and address the service by
+ * another — a daemon that cannot be stopped by the command that installed it, which is the worst
+ * shape of this failure because it survives a reinstall.
+ *
+ * ## Five non-obvious choices, and where each comes from
+ *
+ * 1. **The identity is per repository, not per project name.** The launchd label is
+ *    `com.autonomous-sdlc-harness.watcher.<slug>` and the systemd unit name
+ *    `harness-watcher@<slug>.service`, where `<slug>` is {@link repoSlug} of the repository the
+ *    daemon was installed from. Two repositories on one machine therefore install daemons that
+ *    cannot collide — which two checkouts sharing a `projectName` would have, under a label built
+ *    from that name. `docs/config.md` §4's `<launchd_label>` row is the register entry and
+ *    `docs/cli.md` §9 states the per-repository consequence; this module is where the form is
+ *    implemented, so nothing else in the CLI spells it out.
+ * 2. **The install directory comes from the detection result, not from a second table here.**
+ *    `DaemonBackend.unitPath` is the backend's user-unit directory; this module contributes only
+ *    the file *name*, which is the half that depends on the repository.
+ * 3. **Values are checked before they are substituted, and escaped for the format they land in.** A
+ *    plist is XML, so a `&` or a `<` in a checkout path would produce a unit no `launchctl` will
+ *    parse. A systemd unit is neither: `%` introduces a specifier in every directive rendered into
+ *    here, and `ExecStart=` splits its command line at whitespace, so an unescaped checkout path
+ *    holding a space runs `/bin/bash` on the first word of it — installed, started, failed and,
+ *    under `Restart=always`, restarted forever. Both are escaped, per format and per directive; see
+ *    {@link escapeSystemdValue} and {@link escapeSystemdArgument}. A newline is refused instead — it
+ *    is not something to render carefully, it is something to report.
+ * 4. **On systemd a *concrete* `harness-watcher@<slug>.service` file is written, not a template
+ *    unit plus an instance.** The `@` is what an operator reads as "one watcher per repository",
+ *    and it costs nothing to spell it that way: systemd resolves an instance name to a literal
+ *    file of that exact name *before* it falls back to the `harness-watcher@.service` template, so
+ *    the file installed here is the one `systemctl --user` acts on. A real template unit would have
+ *    to reach the repository path through `%i`, i.e. carry the checkout path in the instance name,
+ *    escaped into it. This design renders that path into `ExecStart` and `WorkingDirectory`
+ *    instead, quoted and specifier-escaped by choice 3, so a checkout holding a space or a `%` is
+ *    one the operator never has to encode by hand.
+ * 5. **The unit renders a `PATH`, captured from the shell that ran `daemon install`.** A user agent
+ *    or user unit inherits the *service manager's* environment, not a login shell's: on macOS that
+ *    is `/usr/bin:/bin:/usr/sbin:/sbin`, where neither a Homebrew package manager nor an agent CLI
+ *    under `~/.local/bin` resolves — the watcher launches both by name, so a unit without the key
+ *    fails at the first configured command and, with the failure repaired one binary at a time,
+ *    at the next. Three answers were weighed. Capturing the installing shell's `PATH` — this one —
+ *    needs no dependency (this package declares none, and that is a property worth keeping), is
+ *    deterministic Node with nothing to detect, and is exactly the hand edit that unblocked the
+ *    first unattended run. Pinning the individual binaries cannot work: the toolchain is the
+ *    adopter's `commands.*` configuration, which this CLI does not interpret. Sourcing the login
+ *    shell's profile from the watcher would run arbitrary shell configuration inside the daemon's
+ *    own process, on every dispatch. Its one weakness is that a captured value goes stale when the
+ *    toolchain moves; that is a `doctor` question — grading the *installed unit's* `PATH` against
+ *    the binaries the outer loop runs — rather than one the renderer can answer, and the remedy is
+ *    `daemon install --force`. An absent or empty `PATH` renders **no** key: `PATH=""` overrides
+ *    the service manager's own directories with nothing, which is strictly worse than the default
+ *    the caller then warns about. The value it does render is escaped for a **quoted** destination
+ *    on systemd — `Environment="PATH=…"` is quoted because an entry may hold a space, which makes a
+ *    `"` or a `\` in one the hazard choice 3's `ExecStart` escaping exists for.
+ *
+ * ## Scope
+ *
+ * This module renders and computes; it writes nothing. Installing the rendered text, reloading the
+ * service manager and starting or stopping the daemon are the `daemon` subcommand's, and keeping
+ * them apart is what lets the rendering be tested without a service manager present.
+ */
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { DEFAULTS } from '../config/model.js';
+import { EXIT, HarnessError } from '../core/errors.js';
+import { defaultProjectName, packageScriptsDir } from '../core/paths.js';
+import { normalizeRepoDir } from '../core/repoPaths.js';
+import { renderTemplate } from '../core/templating.js';
+/** The unit templates' subdirectory inside this package's `scripts/` directory. */
+const TEMPLATE_DIR = 'daemon';
+/** One template per installable backend. `none` has no row, because it has no unit. */
+const UNIT_TEMPLATES = {
+    launchd: 'launchd.plist.template',
+    systemd: 'systemd.service.template',
+};
+/** Reverse-DNS prefix of the launchd label; {@link repoSlug} completes it. */
+const LAUNCHD_LABEL_PREFIX = 'com.autonomous-sdlc-harness.watcher';
+/** The systemd unit name, either side of {@link repoSlug}. */
+const SYSTEMD_UNIT_PREFIX = 'harness-watcher@';
+const SYSTEMD_UNIT_SUFFIX = '.service';
+/** The longest a slug may be. Applied last, keeping the tail — see {@link repoSlug}. */
+const SLUG_MAX_LENGTH = 64;
+/**
+ * What a derived slug may be: non-empty, and lowercase letters, digits and `-` only.
+ *
+ * This is the check `projectName` used to carry, moved to the value that now names the service. It
+ * refuses a *derivation* rather than a configuration — {@link repoSlug} is total over any string,
+ * so nothing an adopter can write reaches it — which is why failing it exits {@link EXIT.INTERNAL}.
+ */
+const SLUG_PATTERN = /^[a-z0-9-]+$/;
+/**
+ * The repository's machine-unique identifier: its own absolute path, lowercased, with every
+ * character outside `[a-z0-9]` replaced by `-`, runs collapsed, leading and trailing `-` stripped,
+ * and the result cut to {@link SLUG_MAX_LENGTH} characters **keeping the tail** — the tail is the
+ * distinguishing part, since two checkouts on one machine usually share a long prefix.
+ *
+ * **This function has a twin, and a test that keeps them equal.** The generated
+ * `<scriptsDir>/lib/harness-run-lib.sh` defines `hr_repo_slug` doing the same transformation for
+ * the watcher, the notifier and the machine-level usage lane, so the daemon a repository installs
+ * and the run artifacts that repository writes are keyed alike. `test/daemon.test.mjs` runs both
+ * halves over one path and compares — the only thing stopping them drifting. **Change one, change
+ * the other in the same commit**, and keep these three properties, each of which the shell half
+ * also has:
+ *
+ * - **Truncation is last**, so a truncated slug may *begin* with `-`. Reordering it to strip after
+ *   cutting would be tidier and would silently disagree with the shell.
+ * - **Letters and digits are ASCII-only**, on both sides: the shell half runs under `LC_ALL=C` so
+ *   that its `[!a-z0-9]` cannot admit `é` through a locale's collation, and the fold here is
+ *   `[A-Z]` rather than `toLowerCase()` for the mirror-image reason — a locale-aware fold turns `İ`
+ *   into an ASCII `i` where the shell yields a `-`. An accented letter is a separator, never a
+ *   letter it resembles.
+ * - **No hash, no truncating digest.** Both halves have to be one readable transformation an
+ *   operator can reproduce by eye from the path they are looking at.
+ *
+ * The argument is the repository the daemon is being installed for — `daemon install` resolves it
+ * from its own working directory. The shell half additionally resolves the *main* checkout first,
+ * so every worktree of one repository answers the same slug; nothing here needs that step, because
+ * the unit's `WorkingDirectory` is this same root and a unit installed from a checkout is a unit
+ * for that checkout.
+ *
+ * Not to be confused with `parseRepoSlug` in `core/paths.ts`, which is `<owner>/<repository>` off a
+ * git remote URL and has nothing to do with a service identifier.
+ */
+export function repoSlug(repoRoot) {
+    const slug = repoRoot
+        .replace(/[A-Z]/g, (letter) => letter.toLowerCase())
+        .replace(/[^a-z0-9]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(-SLUG_MAX_LENGTH);
+    if (!SLUG_PATTERN.test(slug)) {
+        throw new HarnessError(`the daemon identifier derived from ${JSON.stringify(repoRoot)} is ${JSON.stringify(slug)}, which cannot name a service: the derivation admits only lowercase letters, digits and '-' and must produce at least one character, so this is a fault in this CLI rather than in the repository`, EXIT.INTERNAL);
+    }
+    return slug;
+}
+/**
+ * The project name the unit files *describe* themselves with: the configured `projectName`, or the
+ * repository directory name the schema says `init` defaults it to.
+ *
+ * Descriptive only, since decision 21 — it reaches a plist comment, through {@link commentSafe} for
+ * what that destination forbids, and a systemd `Description=`, and no longer the label or the file
+ * name. That is why it carries no pattern check any more: the check that used to live here is
+ * {@link SLUG_PATTERN}, on the value that names the service.
+ * `assertSingleLine` and the XML escaping still apply to it, as they do to every substituted value.
+ */
+function descriptiveProjectName(config, repoRoot) {
+    const configured = config.projectName?.trim();
+    return configured !== undefined && configured !== '' ? configured : defaultProjectName(repoRoot);
+}
+/** XML text-node escaping, for the values substituted into the plist's `<string>` elements. */
+function escapeXml(value) {
+    return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+/**
+ * Separate adjacent hyphens in a value whose plist destination is a **comment**, where XML 1.0 §2.5
+ * forbids `--` and {@link escapeXml} — which touches only `&`, `<` and `>` — leaves one standing.
+ *
+ * The guarantee is the property, not one substitution: no two hyphens survive adjacent, for a run of
+ * **any** length, since every hyphen followed by another takes a trailing space (`notes--app` →
+ * `notes- -app`, `notes---app` → `notes- - -app`).
+ *
+ * `projectName` is the plist's only comment-destined substitution; `label` appears in that block too
+ * but cannot carry an adjacent pair, because {@link repoSlug} collapses runs of `-`. The rewrite
+ * reaches descriptive comment text and never a value the service manager reads, which is why
+ * mangling it is acceptable where refusing a legal `projectName` would not be. The systemd arm is
+ * untouched: `Description=` is a directive, not a comment.
+ */
+function commentSafe(value) {
+    return value.replace(/-(?=-)/g, '- ');
+}
+/**
+ * systemd escaping for a value that is a whole directive argument — `WorkingDirectory=`,
+ * `Description=`, the `StandardOutput=append:` paths.
+ *
+ * Only `%` needs it: those directives take the rest of the line literally, but every one of them is
+ * specifier-expanded first, so a checkout under `/home/ada/100%-mine` would resolve `%-` and the
+ * service would run somewhere else. `%%` is systemd's own escape for a literal `%`.
+ */
+function escapeSystemdValue(value) {
+    return value.replace(/%/g, '%%');
+}
+/**
+ * systemd escaping for a value substituted **inside quotes** — `ExecStart=`'s program path, and the
+ * `PATH` inside `Environment="PATH=…"`, both of which the template quotes.
+ *
+ * `ExecStart=` splits at whitespace before anything runs and a `PATH` entry may hold a space, which
+ * is why each is quoted rather than trusted; a `"` or a `\` in one would end or eat that quoting, so
+ * both are backslash-escaped. Specifiers expand here too, so {@link escapeSystemdValue} still
+ * applies.
+ */
+function escapeSystemdArgument(value) {
+    return escapeSystemdValue(value.replace(/[\\"]/g, (character) => `\\${character}`));
+}
+/** The one token whose systemd destination is a command-line argument rather than a whole value. */
+const SYSTEMD_ARGUMENT_TOKENS = new Set(['watcherPath']);
+/**
+ * The `{{environment}}` stanza: the whole environment key for this backend, or nothing at all.
+ *
+ * The stanza is one token rather than a `{{envPath}}` inside a fixed key because the empty case has
+ * to remove the *key*, not leave it holding `""` (choice 5), and `renderTemplate` substitutes values
+ * and knows no conditional sections. `escaped` is the already-escaped value — {@link escapeXml} for
+ * the plist and {@link escapeSystemdArgument} for the quoted systemd directive below, applied by
+ * {@link renderUnit} — since this function's own output is markup that must not be escaped again.
+ *
+ * The trailing newline is what keeps both cases readable: each template puts `{{environment}}` on a
+ * line of its own, so a rendered stanza is followed by a blank line and an omitted one leaves the
+ * blank line that was already there.
+ */
+function environmentStanza(kind, escaped) {
+    if (escaped === undefined)
+        return '';
+    return kind === 'launchd'
+        ? `  <key>EnvironmentVariables</key>\n  <dict>\n    <key>PATH</key>\n    <string>${escaped}</string>\n  </dict>\n`
+        : `Environment="PATH=${escaped}"\n`;
+}
+/** The plist's environment dictionary — {@link environmentStanza} renders it — and one named entry inside it. */
+const PLIST_ENVIRONMENT = /<key>\s*EnvironmentVariables\s*<\/key>\s*<dict>([\s\S]*?)<\/dict>/;
+const plistEntry = (key) => new RegExp(`<key>\\s*${key}\\s*</key>\\s*<string>([\\s\\S]*?)</string>`);
+/**
+ * The systemd form, quoted as the renderer writes it and bare as a hand edit may leave it.
+ *
+ * The quoted alternative admits `\"` and `\\`, because that is what {@link escapeSystemdArgument}
+ * writes into it: a `[^"]*` value would stop at the first escaped quote and read back a truncated
+ * `PATH`.
+ */
+const systemdDirective = (key) => new RegExp(`^Environment=(?:"${key}=((?:[^"\\\\]|\\\\.)*)"|${key}=(.*))$`, 'gm');
+/**
+ * One environment value an installed unit gives the daemon, or `undefined` when the unit does not set
+ * it — `PATH`, and the agent CLI variable beside it.
+ *
+ * The two shapes are {@link environmentStanza}'s, read back: a plist dictionary whose value is
+ * XML-escaped, and a systemd `Environment=` line whose value is specifier-escaped and, inside the
+ * quoting the renderer writes, backslash-escaped as well. Each is un-escaped by the inverse of the
+ * escape that wrote it — and in that order — so a toolchain directory holding an `&`, a `%`, a `"` or
+ * a `\` is compared as the path it is rather than as the markup it was stored as. A *bare* directive
+ * is left as written, because nothing here escaped it: it can only be a hand edit.
+ *
+ * The key is interpolated into both patterns and is always one of the caller's own literals, so it
+ * carries nothing a regular expression reads.
+ *
+ * The parse is deliberately tolerant of hand edits — the unit is the operator's file once it is
+ * installed, and a key the renderer never writes (the agent CLI variable `doctor` reads) can only
+ * arrive that way — which is why the systemd side takes the **last** matching directive: that is what
+ * systemd itself does with a second one.
+ *
+ * Exported because two consumers read an installed unit back: `doctor`'s `daemon-path` check, and
+ * `daemon install`'s comparison of the `PATH` it is about to write against the one on disk. It lives
+ * beside the escaping it inverts so that a change to {@link environmentStanza} and a change to this
+ * parse are one edit in one file — and so the round trip against {@link renderUnit}'s escaping, the
+ * property the un-escaping claims and cannot show on its own, has both sides in one module.
+ */
+export function unitEnvValue(kind, text, key) {
+    if (kind === 'launchd') {
+        const dict = PLIST_ENVIRONMENT.exec(text)?.[1];
+        if (dict === undefined)
+            return undefined;
+        const value = plistEntry(key).exec(dict)?.[1];
+        return value === undefined ? undefined : value.replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&');
+    }
+    let last;
+    for (const match of text.matchAll(systemdDirective(key))) {
+        last = match[1] !== undefined ? { raw: match[1], quoted: true } : { raw: match[2] ?? '', quoted: false };
+    }
+    if (last === undefined)
+        return undefined;
+    // The escape's steps, undone in reverse: `%%` first, then the backslashes the quoting needed.
+    const withLiteralPercent = last.raw.replace(/%%/g, '%');
+    return last.quoted ? withLiteralPercent.replace(/\\(["\\])/g, '$1') : withLiteralPercent;
+}
+/**
+ * Refuse a value carrying a line break before it is substituted anywhere.
+ *
+ * A newline in a systemd unit's value ends the directive and starts another, and in a plist it
+ * survives into a string the service manager then acts on. Both are ways for a path to become a
+ * *setting*, so the check is applied to every value and to both backends rather than to the one
+ * format where the consequence is easiest to demonstrate.
+ */
+function assertSingleLine(token, value) {
+    if (/[\r\n]/.test(value)) {
+        throw new HarnessError(`the value for {{${token}}} contains a line break (${JSON.stringify(value)}), which would split the generated unit file into directives nobody wrote: move the checkout, or set the offending path in harness.config.json to one without a newline in it`);
+    }
+}
+/**
+ * Read a unit template from this package's `scripts/daemon/` directory.
+ *
+ * It is read from `scripts/` rather than through `readTemplate` because these two files are not
+ * adopter-facing generator templates: they are shipped assets of the daemon, which is why they sit
+ * beside the watcher the daemon runs. A missing one is a packaging fault the adopter cannot act on,
+ * so it exits {@link EXIT.INTERNAL} with the path named.
+ */
+function readUnitTemplate(file) {
+    const absolute = join(packageScriptsDir(), TEMPLATE_DIR, file);
+    try {
+        return readFileSync(absolute, 'utf8');
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT') {
+            throw new HarnessError(`daemon unit template missing from the installed package: ${absolute}`, EXIT.INTERNAL);
+        }
+        throw error;
+    }
+}
+/**
+ * Render a unit template through {@link renderTemplate}.
+ *
+ * **`assertNoneSurvive` is on**: the values are a service label, three absolute paths and an
+ * environment stanza built from a fourth, so one carrying `{{…}}` means a half-rendered unit
+ * installed into a service manager — the failure this module's header calls the worst shape,
+ * because it survives a reinstall.
+ */
+function render(file, values) {
+    return renderTemplate(readUnitTemplate(file), values, {
+        describe: `the daemon unit template ${file}`,
+        assertNoneSurvive: true,
+    });
+}
+/**
+ * Render the daemon's unit for the detected backend, and compute where it is installed and what it
+ * is then called.
+ *
+ * - **launchd** — `~/Library/LaunchAgents/com.autonomous-sdlc-harness.watcher.<slug>.plist`.
+ * - **systemd** — `~/.config/systemd/user/harness-watcher@<slug>.service`.
+ * - **`none`** — throws, naming the platform and carrying detection's own reason, because a caller
+ *   that reached this function with no backend has a question with no answer rather than a value to
+ *   fall back on.
+ *
+ * The install directory is the backend's `unitPath`; only the file name is computed here.
+ */
+export function renderUnit({ backend, config, repoRoot, watcherPath, envPath }) {
+    if (backend.kind === 'none') {
+        throw new HarnessError(`no service manager to install the run daemon into on ${process.platform}: ${backend.reason}`);
+    }
+    const unitDir = backend.unitPath;
+    if (unitDir === undefined) {
+        throw new HarnessError(`the ${backend.kind} backend was detected without a unit directory, so there is nowhere to install the daemon: detection and installation disagree, which is a fault in this CLI`, EXIT.INTERNAL);
+    }
+    const projectName = descriptiveProjectName(config, repoRoot);
+    const stateDirAbs = join(repoRoot, normalizeRepoDir(config.stateDir ?? DEFAULTS.stateDir));
+    const slug = repoSlug(repoRoot);
+    const label = backend.kind === 'launchd'
+        ? `${LAUNCHD_LABEL_PREFIX}.${slug}`
+        : `${SYSTEMD_UNIT_PREFIX}${slug}${SYSTEMD_UNIT_SUFFIX}`;
+    const fileName = backend.kind === 'launchd' ? `${label}.plist` : label;
+    // Undefined and empty are one answer — no environment key — so the distinction is collapsed here
+    // rather than in each of the two places that would otherwise have to test for both.
+    const resolvedEnvPath = envPath !== undefined && envPath.trim() !== '' ? envPath : undefined;
+    const values = { label, projectName, watcherPath, repoRoot, stateDirAbs };
+    for (const [token, value] of Object.entries(values))
+        assertSingleLine(token, value);
+    if (resolvedEnvPath !== undefined)
+        assertSingleLine('envPath', resolvedEnvPath);
+    // Escaped per format: XML for the plist, and for systemd per directive — the command-line
+    // argument quoted-and-escaped, every other value specifier-escaped. Escaping a value for the
+    // wrong format puts the escape text into the path the service actually runs.
+    const escape = backend.kind === 'launchd'
+        ? (token, value) => escapeXml(token === 'projectName' ? commentSafe(value) : value)
+        : (token, value) => SYSTEMD_ARGUMENT_TOKENS.has(token) ? escapeSystemdArgument(value) : escapeSystemdValue(value);
+    const substituted = Object.fromEntries(Object.entries(values).map(([token, value]) => [token, escape(token, value)]));
+    // Escaped for its own destination rather than through the map above: the systemd stanza renders a
+    // *quoted* `Environment="PATH=…"`, so a `"` or a `\` in a toolchain directory would end or eat that
+    // quoting — the same reason `ExecStart`'s path takes the argument escaper (choice 3), on the same
+    // kind of destination. The plist arm quotes nothing, so it stays on XML escaping.
+    const environment = environmentStanza(backend.kind, resolvedEnvPath === undefined
+        ? undefined
+        : backend.kind === 'launchd'
+            ? escapeXml(resolvedEnvPath)
+            : escapeSystemdArgument(resolvedEnvPath));
+    return {
+        text: render(UNIT_TEMPLATES[backend.kind], { ...substituted, environment }),
+        targetPath: join(unitDir, fileName),
+        label,
+        projectName,
+        envPath: resolvedEnvPath,
+    };
+}
+//# sourceMappingURL=units.js.map

package/dist/daemon/units.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"units.js","sourceRoot":"","sources":["../../src/daemon/units.ts"],"names":[],"mappings":"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"}