@bridge4dev/runner 0.22.1 → 0.26.0

package/dist/index.js

@@ -10,13 +10,15 @@ import { CodexAdapter } from './adapters/codex.js';
 import { ensureCodexHome } from './adapters/codex-home.js';
 import { loadConfig, requireConfig, saveConfig } from './config.js';
 import { log } from './log.js';
-import { isSupervisedProcess, resolveInstalledPackageDir } from './self-update.js';
+import { installIsWritable, isSupervisedProcess, resolveInstalledPackageDir, } from './self-update.js';
 import { Supervisor } from './supervisor.js';
 import { readStatusFile, isPidAlive, writeStatusFile, STATUS_FRESH_MS } from './status-file.js';
 import { RunnerWsClient } from './ws-client.js';
 import { RUNNER_VERSION } from './version.js';
 import { buildUnit, cpuQuotaPercent, limitsOverrideIsOutdated, limitsOverridePath, unitExecTarget, unitPath, writeLimitsOverride, LIMITS_VERSION, } from './service-unit.js';
 import { readOomKills, recordCrash, takeLastExit } from './crash-note.js';
+import { agentAuthStatuses } from './auth-relay.js';
+import { addSafeDirectory, agentConfigContour, dockerCheck, ensureAgentPath, firstUnreachableAncestor, hasSafeDirectory, inspectPath, knownWorkspacePaths, lingerEnabled, nodeCheck, otherHomeWithAgents, runnerIdentity, safeDirectoryCommand, systemctlHint, systemdUserBusReachable, systemdUserEnv, } from './environment.js';
 import { mcpConfigDir } from './paths.js';
 const execFileAsync = promisify(execFile);
 /**
@@ -60,7 +62,8 @@ function installedAgents() {
  * instead of a button that would fail on tap.
  */
 function selfUpdatable() {
-    return resolveInstalledPackageDir() !== null && isSupervisedProcess();
+    const packageDir = resolveInstalledPackageDir();
+    return packageDir !== null && isSupervisedProcess() && installIsWritable(packageDir);
 }
 /**
  * Why this runner cannot replace itself — so the card can SAY it.
@@ -71,10 +74,15 @@ function selfUpdatable() {
  * only the runner knows how it was started.
  */
 function selfUpdateBlockedReason() {
-    if (resolveInstalledPackageDir() === null)
+    const packageDir = resolveInstalledPackageDir();
+    if (packageDir === null)
         return 'source-checkout';
     if (!isSupervisedProcess())
         return 'unsupervised';
+    // Installed by one user, run by another: npm would fail halfway through with
+    // EACCES. Reported so the card shows the command instead of a button.
+    if (!installIsWritable(packageDir))
+        return 'not-writable';
     return null;
 }
 function hasExecutable(name) {
@@ -119,6 +127,14 @@ function runnerCapabilities() {
         ...(selfUpdatable()
             ? { selfUpdate: true }
             : { selfUpdateBlocked: selfUpdateBlockedReason() ?? 'unsupervised' }),
+        /**
+         * Which OS user this daemon runs as (0.24.0).
+         *
+         * The card needs it to write a command that will actually work: an update
+         * installed by root has to be restarted as THIS user, and «run it as root»
+         * is only half the instruction without a name to restart under.
+         */
+        runnerUser: runnerIdentity().user,
         /**
          * A stricter ceiling set on the machine itself (layer 1). Reported so the
          * dashboard can explain why raising the number there changed nothing.
@@ -360,7 +376,10 @@ async function repairResourceLimits() {
             path: limitsOverridePath(),
             version: LIMITS_VERSION,
         });
-        await execFileAsync('systemctl', ['--user', 'daemon-reload'], { timeout: 15_000 });
+        await execFileAsync('systemctl', ['--user', 'daemon-reload'], {
+            timeout: 15_000,
+            env: systemdUserEnv(),
+        });
         // Deliberately no restart: `daemon-reload` alone is enough for these
         // directives (verified live — OOMPolicy went stop→continue and MemoryMax
         // 2G→infinity with the PID unchanged), and restarting here would park every
@@ -576,8 +595,10 @@ async function cmdInstallService() {
         print(`note: the service runs ${exec.execStart} directly — re-run install-service after reinstalling the package.`);
     }
     try {
-        await execFileAsync('systemctl', ['--user', 'daemon-reload']);
-        await execFileAsync('systemctl', ['--user', 'enable', '--now', 'devbridge-runner']);
+        await execFileAsync('systemctl', ['--user', 'daemon-reload'], { env: systemdUserEnv() });
+        await execFileAsync('systemctl', ['--user', 'enable', '--now', 'devbridge-runner'], {
+            env: systemdUserEnv(),
+        });
         print('Service enabled and started (systemctl --user).');
     }
     catch (error) {
@@ -593,21 +614,295 @@ async function cmdInstallService() {
     }
     print('Verify with: devbridge-runner status');
 }
-// ─── doctor ──────────────────────────────────────────────────────────
-/**
- * The one command that answers «is this machine set up to run the sessions it
- * says it can run».
- *
- * It exists because of what the 2026-07-30 incident cost to diagnose: the
- * runner's own systemd limits were the cause, they were invisible from
- * DevBridge, and the machine could not be reached. Everything printed here was
- * needed to reach that answer and none of it was available in one place.
- */
+function printCheck(check) {
+    print(`  ${check.ok ? '✔' : '✘'} ${check.name.padEnd(15)} ${check.detail}`);
+    if (check.fix)
+        print(`      → ${check.fix}`);
+    if (check.fixMore)
+        print(`        ${check.fixMore}`);
+}
+/** One property of the user service, or null when systemd cannot answer. */
+async function systemctlProperty(name) {
+    try {
+        const { stdout } = await execFileAsync('systemctl', ['--user', 'show', 'devbridge-runner', '-p', name, '--value'], { timeout: 10_000, env: systemdUserEnv() });
+        const value = stdout.trim();
+        return value.length > 0 ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function runnerChecks() {
+    const me = runnerIdentity();
+    const checks = [];
+    const busReachable = await systemdUserBusReachable();
+    const linger = await lingerEnabled();
+    if (!busReachable) {
+        checks.push({
+            ok: false,
+            name: 'service',
+            detail: 'systemd user session NOT reachable',
+            // `systemctl --user` prints «Failed to connect to bus» and exits 0, so a
+            // health check reads that as success. Give the form that works.
+            fix: systemctlHint('status devbridge-runner'),
+        });
+    }
+    else {
+        // The bus answering says nothing about the service. Reporting READY over a
+        // stopped daemon is worse than having no acceptance at all — an acceptance
+        // that lies is what sends somebody away from a server that does not work.
+        const state = await systemctlProperty('ActiveState');
+        const enabled = await systemctlProperty('UnitFileState');
+        const running = state === 'active';
+        checks.push({
+            ok: running,
+            name: 'service',
+            detail: running
+                ? `running${enabled === 'enabled' ? ', starts on boot' : ' — but NOT enabled: it will not come back after a reboot'}` +
+                    (linger === true
+                        ? ', survives logout'
+                        : linger === false
+                            ? ', but linger is OFF: it stops when this user logs out'
+                            : '')
+                : `NOT running (${state ?? 'unknown'})`,
+            ...(running
+                ? enabled !== 'enabled'
+                    ? { fix: systemctlHint('enable devbridge-runner') }
+                    : linger === false
+                        ? { fix: `loginctl enable-linger ${me.user}` }
+                        : {}
+                : {
+                    fix: systemctlHint('start devbridge-runner'),
+                    fixMore: systemctlHint('status devbridge-runner  # why it stopped'),
+                }),
+        });
+        // …and whether it actually reached DevBridge. The same file `status` reads.
+        const status = readStatusFile();
+        const live = status !== null &&
+            isPidAlive(status.pid) &&
+            Date.now() - new Date(status.updatedAt).getTime() < STATUS_FRESH_MS;
+        checks.push({
+            ok: Boolean(live && status?.connected),
+            name: 'connected',
+            detail: !live
+                ? 'the daemon has not reported in — it is not running, or it just started'
+                : status?.connected
+                    ? `talking to ${status.apiUrl ?? 'DevBridge'}`
+                    : 'running but NOT connected to DevBridge',
+            ...(live && status?.connected
+                ? {}
+                : {
+                    fix: systemctlHint('status devbridge-runner'),
+                    fixMore: 'and check the token: devbridge-runner status',
+                }),
+        });
+    }
+    const node = await nodeCheck();
+    checks.push({
+        ok: node.path !== null && !node.problem,
+        name: 'node',
+        detail: node.path
+            ? `${node.version ?? 'installed'}${node.problem ? ` — ${node.problem}` : ''}`
+            : 'not on this user’s PATH',
+        ...(node.path && !node.problem
+            ? {}
+            : {
+                fix: `install Node 22 for ${me.user} (a Node installed for another user is not inherited)`,
+            }),
+    });
+    const packageDir = resolveInstalledPackageDir();
+    const canUpdate = packageDir !== null && installIsWritable(packageDir);
+    checks.push({
+        // A source checkout is a legitimate setup with a different update channel,
+        // not a fault — calling it «not ready» would cry wolf on the dogfood box.
+        ok: canUpdate || packageDir === null,
+        name: 'updates',
+        detail: canUpdate
+            ? 'the «Update runner» button in the dashboard will work'
+            : packageDir === null
+                ? 'started from a source checkout — updated with git, not from the dashboard'
+                : `the package in ${packageDir} belongs to another user, so the dashboard button cannot update it`,
+        ...(canUpdate || packageDir === null
+            ? {}
+            : {
+                fix: `sudo -iu ${me.user} npm install -g --ignore-scripts --prefix ~/.local ${'@bridge4dev/runner'}`,
+                fixMore: `(reinstalling as ${me.user} is what makes the button work; until then every update is a root command)`,
+            }),
+    });
+    return checks;
+}
+async function agentChecks() {
+    const me = runnerIdentity();
+    // The probes log a verdict line each, which belongs in the journal, not in
+    // the middle of a sheet a person is reading.
+    const previousLogLevel = process.env['DEVBRIDGE_RUNNER_LOG'];
+    process.env['DEVBRIDGE_RUNNER_LOG'] = 'error';
+    const auth = await agentAuthStatuses().finally(() => {
+        if (previousLogLevel === undefined)
+            delete process.env['DEVBRIDGE_RUNNER_LOG'];
+        else
+            process.env['DEVBRIDGE_RUNNER_LOG'] = previousLogLevel;
+    });
+    const checks = [];
+    for (const [agent, info] of [
+        ['claude', auth.claude],
+        ['codex', auth.codex],
+    ]) {
+        const signedIn = info.status === 'ok';
+        const command = agent === 'claude' ? 'claude' : 'codex login';
+        checks.push({
+            ok: signedIn,
+            name: `${agent} login`,
+            detail: (info.detail ?? info.status) +
+                (info.expiresAt ? ` · until ${info.expiresAt.slice(0, 10)}` : ''),
+            ...(signedIn
+                ? {}
+                : {
+                    fix: `${me.isRoot ? command : `sudo -iu ${me.user} ${command}`}${agent === 'claude' ? '   then /login' : ''}`,
+                }),
+        });
+    }
+    const contour = agentConfigContour(me.home);
+    const elsewhere = otherHomeWithAgents(me);
+    checks.push({
+        ok: contour.claudeDir,
+        name: 'claude config',
+        detail: contour.claudeDir
+            ? `${contour.allowRules === null ? 'settings unreadable' : `${contour.allowRules} allow rules`} · ${contour.commands} commands · plugins: ${contour.plugins ? 'yes' : 'no'}`
+            : `nothing in ${me.home} — the agent starts with defaults and NO permission allowlist`,
+        ...(contour.claudeDir
+            ? {}
+            : {
+                fix: elsewhere
+                    ? `set it up as ${me.user}, or copy ${elsewhere}/.claude and ${elsewhere}/.codex into ${me.home}`
+                    : `run the agent once as ${me.user} and set its permissions there`,
+                ...(elsewhere
+                    ? {
+                        fixMore: '(a copied login means both accounts share ONE refresh token — a renewal in either signs the other out)',
+                    }
+                    : {}),
+            }),
+    });
+    return checks;
+}
+async function projectChecks(target, fix) {
+    const me = runnerIdentity();
+    const checks = [];
+    const access = inspectPath(target);
+    if (access.unreachable) {
+        const blocked = firstUnreachableAncestor(target) ?? target;
+        return [
+            {
+                ok: false,
+                name: 'access',
+                detail: `${me.user} is not allowed into ${blocked}`,
+                fix: `chmod o+x ${blocked}   (or setfacl -m u:${me.user}:x ${blocked})`,
+            },
+        ];
+    }
+    if (!access.exists) {
+        return [{ ok: false, name: 'access', detail: 'missing on this machine' }];
+    }
+    const usable = access.readable && access.writable;
+    checks.push({
+        ok: usable,
+        name: 'access',
+        detail: usable
+            ? `readable and writable${access.ownedByUs ? '' : ` (owner uid ${access.ownerUid})`}`
+            : `${access.readable ? 'read-only' : 'not readable'} for ${me.user}`,
+        ...(usable
+            ? {}
+            : { fix: `chown -R ${me.user} ${target}   (or setfacl -R -m u:${me.user}:rwX ${target})` }),
+    });
+    const excused = await hasSafeDirectory(target);
+    const gitRefuses = !access.ownedByUs && !excused;
+    if (gitRefuses && fix) {
+        try {
+            await addSafeDirectory(target);
+            checks.push({ ok: true, name: 'git', detail: `fixed: ${safeDirectoryCommand(target)}` });
+        }
+        catch (error) {
+            checks.push({
+                ok: false,
+                name: 'git',
+                detail: `could not fix: ${String(error instanceof Error ? error.message : error)}`,
+            });
+        }
+    }
+    else {
+        checks.push({
+            ok: !gitRefuses,
+            name: 'git',
+            detail: gitRefuses
+                ? `refuses this repository — it belongs to uid ${access.ownerUid}, not to ${me.user}`
+                : 'ok',
+            ...(gitRefuses
+                ? {
+                    fix: safeDirectoryCommand(target),
+                    fixMore: '(if you hand the directory over with chown instead, add the same line for its previous owner — otherwise THEY lose git here)',
+                }
+                : {}),
+        });
+    }
+    const docker = await dockerCheck();
+    if (docker.path) {
+        checks.push({
+            ok: !docker.problem,
+            name: 'docker',
+            detail: docker.problem ?? 'usable by this user',
+            ...(docker.problem
+                ? { fix: `usermod -aG docker ${me.user}   (then restart the runner)` }
+                : {}),
+        });
+    }
+    return checks;
+}
+async function reportAgentReadiness(paths, fix) {
+    const me = runnerIdentity();
+    print('');
+    print(`Runs as ${me.user} (uid ${me.uid}), home ${me.home}`);
+    if (me.isRoot) {
+        // Not a warning — the owner's call. But layer 1 is then the ONLY
+        // containment, and saying it once is cheaper than assuming they know.
+        print('  running as root: the layer-1 policy is the only containment');
+    }
+    const sections = [
+        ['Runner', await runnerChecks()],
+        ['Agent', await agentChecks()],
+    ];
+    for (const target of paths) {
+        sections.push([`Project ${target}`, await projectChecks(target, fix)]);
+    }
+    const failed = sections.flatMap(([, checks]) => checks).filter((check) => !check.ok);
+    print('');
+    print(failed.length === 0
+        ? 'READY — an agent will work on this machine'
+        : `NOT READY — ${failed.length} thing${failed.length === 1 ? '' : 's'} to fix (each one has its command below)`);
+    for (const [title, checks] of sections) {
+        print('');
+        print(title);
+        for (const check of checks)
+            printCheck(check);
+    }
+    if (paths.length === 0) {
+        print('');
+        print('Projects');
+        // Silence here would read as «all good» rather than «nothing to check yet».
+        print('  no project bound yet — this fills in when one is bound in the dashboard.');
+        print('  To check one now: devbridge-runner doctor /path/to/project');
+    }
+    return failed.length === 0;
+}
 async function cmdDoctor(args) {
     const fix = args.includes('--fix');
     const config = loadConfig();
     print(`devbridge-runner ${RUNNER_VERSION}`);
     print(config ? `Paired with: ${config.server.name} (${config.api.url})` : 'Not paired');
+    // Paths given on the command line win; otherwise check what this runner has
+    // actually been pointed at, because the person running doctor may not know.
+    const givenPaths = args.filter((arg) => arg.startsWith('/'));
+    const projectPaths = givenPaths.length > 0 ? givenPaths : knownWorkspacePaths();
+    const ready = await reportAgentReadiness(projectPaths, fix);
     const cpuCount = os.cpus().length;
     const quota = cpuQuotaPercent(cpuCount);
     print('');
@@ -641,7 +936,7 @@ async function cmdDoctor(args) {
             'OOMPolicy',
             '-p',
             'NRestarts',
-        ]);
+        ], { env: systemdUserEnv() });
         effective = stdout.trim().split('\n').filter(Boolean);
     }
     catch {
@@ -693,13 +988,18 @@ async function cmdDoctor(args) {
             print('Run `devbridge-runner doctor --fix` to write the drop-in, then restart the service.');
             process.exit(1);
         }
+        // A readiness problem is a real finding too: exiting 0 over «the agent has
+        // no login here» is how the installing agent reports success on a server
+        // where nothing will run.
+        if (!ready)
+            process.exit(1);
         return;
     }
     writeLimitsOverride(true);
     print('');
     print(`Wrote ${limitsOverridePath()}`);
     try {
-        await execFileAsync('systemctl', ['--user', 'daemon-reload']);
+        await execFileAsync('systemctl', ['--user', 'daemon-reload'], { env: systemdUserEnv() });
         print('systemctl --user daemon-reload — done.');
         print('Restart when sessions are idle: systemctl --user restart devbridge-runner');
     }
@@ -725,10 +1025,19 @@ Usage:
   devbridge-runner install-service                                 install + start systemd user service
   devbridge-runner status                                          connection status (exit 0 = connected)
   devbridge-runner set-token <dbr_token>                           store a rotated runner token
-  devbridge-runner doctor [--fix]                                  report (and repair) resource limits
+  devbridge-runner doctor [--fix] [path...]                        will an agent work here? logins, settings,
+                                                                   project permissions, resource limits
 `;
 async function main() {
+    // Before anything looks for an agent CLI. Append-only, so a service that can
+    // already find its tools keeps finding them (see ensureAgentPath).
+    const addedToPath = ensureAgentPath();
     const [command, ...args] = process.argv.slice(2);
+    // Said once, and only when it actually changed something: on a machine where
+    // the agent CLIs were already findable this is silent.
+    if (addedToPath.length > 0 && command === 'daemon') {
+        log.info('runner: extended PATH so the agent CLIs are findable', { added: addedToPath });
+    }
     switch (command) {
         case 'pair':
             return cmdPair(args);

package/dist/paths.d.ts

@@ -11,6 +11,15 @@ export declare function configFilePath(): string;
 export declare function statusFilePath(): string;
 export declare function journalDir(): string;
 export declare function worktreesDir(): string;
+/**
+ * Project directories this runner has been pointed at.
+ *
+ * Kept so `devbridge-runner doctor` can check the permissions that actually
+ * matter on this machine without being told the paths — the runner learns them
+ * from the API (binding a project, starting a session) and the person running
+ * doctor may have no idea which directories are bound.
+ */
+export declare function knownWorkspacesPath(): string;
 /** Session 14: the single preview checkout per repository. */
 export declare function previewsDir(): string;
 /**

package/dist/paths.js

@@ -39,6 +39,17 @@ export function journalDir() {
 export function worktreesDir() {
     return path.join(stateDir(), 'worktrees');
 }
+/**
+ * Project directories this runner has been pointed at.
+ *
+ * Kept so `devbridge-runner doctor` can check the permissions that actually
+ * matter on this machine without being told the paths — the runner learns them
+ * from the API (binding a project, starting a session) and the person running
+ * doctor may have no idea which directories are bound.
+ */
+export function knownWorkspacesPath() {
+    return path.join(stateDir(), 'workspaces.json');
+}
 /** Session 14: the single preview checkout per repository. */
 export function previewsDir() {
     return path.join(stateDir(), 'previews');

package/dist/protocol.d.ts

@@ -961,16 +961,16 @@ export declare const GatewayFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodO
     sessionId: z.ZodOptional<z.ZodString>;
     args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "strip", z.ZodTypeAny, {
+    name: string;
     type: "command";
     requestId: string;
-    name: string;
     sessionId?: string | undefined;
     workspaceId?: string | undefined;
     args?: Record<string, unknown> | undefined;
 }, {
+    name: string;
     type: "command";
     requestId: string;
-    name: string;
     sessionId?: string | undefined;
     workspaceId?: string | undefined;
     args?: Record<string, unknown> | undefined;

package/dist/self-update.d.ts

@@ -62,6 +62,20 @@ export interface SelfUpdateOptions {
  * has one above `packages/runner`.
  */
 export declare function resolveInstalledPackageDir(entry?: string): string | null;
+/**
+ * Can this user actually replace the installed package?
+ *
+ * The two legitimate installs part ways here. `npm install -g` run by root puts
+ * the package in `/usr/lib/node_modules` owned by root; the daemon then runs as
+ * a dedicated user, who cannot write there. The button was offered anyway and
+ * failed halfway through npm with «the permissions to access this file as the
+ * current user» — a dashboard button that cannot work, and an error in npm's
+ * words rather than ours.
+ *
+ * Both directories matter: npm rewrites the package AND the `bin` symlink, and
+ * either one being root-owned is enough to fail.
+ */
+export declare function installIsWritable(packageDir?: string | null): boolean;
 /**
  * Is something going to restart us?
  *

package/dist/self-update.js

@@ -1,5 +1,6 @@
 import { execFile } from 'node:child_process';
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { promisify } from 'node:util';
 import { log } from './log.js';
@@ -54,6 +55,35 @@ export function resolveInstalledPackageDir(entry = process.argv[1] ?? '') {
     }
     return null;
 }
+/**
+ * Can this user actually replace the installed package?
+ *
+ * The two legitimate installs part ways here. `npm install -g` run by root puts
+ * the package in `/usr/lib/node_modules` owned by root; the daemon then runs as
+ * a dedicated user, who cannot write there. The button was offered anyway and
+ * failed halfway through npm with «the permissions to access this file as the
+ * current user» — a dashboard button that cannot work, and an error in npm's
+ * words rather than ours.
+ *
+ * Both directories matter: npm rewrites the package AND the `bin` symlink, and
+ * either one being root-owned is enough to fail.
+ */
+export function installIsWritable(packageDir = resolveInstalledPackageDir()) {
+    if (!packageDir)
+        return false;
+    const writable = (target) => {
+        try {
+            fs.accessSync(target, fs.constants.W_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    // `<prefix>/lib/node_modules/@scope/pkg` → `<prefix>/lib/node_modules`
+    const nodeModules = path.dirname(packageDir.includes(`${path.sep}@`) ? path.dirname(packageDir) : packageDir);
+    return writable(packageDir) && writable(nodeModules);
+}
 /**
  * Is something going to restart us?
  *
@@ -218,6 +248,21 @@ export async function selfUpdate(options) {
     if (!packageDir) {
         return fail('This runner runs from a source checkout, not from an installed package — update it with git instead.');
     }
+    // Installed by one user, run by another — the usual shape being `npm install
+    // -g` as root with the daemon under a dedicated user. npm gets far enough to
+    // start rewriting the package and then stops with EACCES, so the check has to
+    // happen BEFORE anything is touched. Refused with the two commands that work,
+    // because «run it as root» alone leaves out the restart, which needs the
+    // runner's own user.
+    if (!installIsWritable(packageDir)) {
+        const user = os.userInfo().username;
+        const uid = typeof process.getuid === 'function' ? process.getuid() : -1;
+        return fail(`The runner package in ${packageDir} belongs to another user, and this daemon runs as ${user}, ` +
+            'so it cannot replace itself. Update it on the server in two steps — install as root:\n' +
+            `  npm install -g --ignore-scripts --loglevel=error ${options.tarballUrl}\n` +
+            'then restart the service as the runner’s own user:\n' +
+            `  sudo -iu ${user} env XDG_RUNTIME_DIR=/run/user/${uid >= 0 ? uid : '$(id -u ' + user + ')'} systemctl --user restart devbridge-runner`);
+    }
     // Pack the current version FIRST: without a rollback artefact there is no
     // honest way back if the new build turns out to be broken.
     const rollbackDir = path.join(stateDir(), 'rollback');

package/dist/service-unit.d.ts

@@ -15,12 +15,24 @@
  */
 export declare const SERVICE_NAME = "devbridge-runner";
 /** `<prefix>/bin/devbridge-runner` for an installed package, else the script. */
+/**
+ * A path that will not exist after a reboot.
+ *
+ * `fnm` (and `nvm`/`volta` in the same spirit) puts the active version's `bin`
+ * into a per-shell directory under `/run/user/<uid>/fnm_multishells/…` — tmpfs,
+ * created for one shell session. `command -v devbridge-runner` resolves there,
+ * so baking it into a unit produces a service that works until the shell that
+ * installed it goes away, and then fails with status=127 forever. Observed on a
+ * real install, 2026-07-31, on a ROOT install — this is not a dedicated-user
+ * problem, it is a per-user node manager problem.
+ */
+export declare function isEphemeralPath(target: string): boolean;
 export declare function unitExecTarget(argv1?: string): {
     execStart: string;
     viaCommand: boolean;
 };
 export declare function unitPath(home?: string): string;
-export declare function buildUnit(execStart?: string): string;
+export declare function buildUnit(execStart?: string, nodeBinary?: string): string;
 /**
  * Resource policy for the service, and why it does not live in the unit above.
  *