@miraland-labs/conduit-bridge 0.16.119 → 0.16.120

package/dist/cli.js

@@ -339,6 +339,7 @@ async function installService() {
     const { values } = parseArgs({ args: process.argv.slice(3), options: {
             workspace: { type: "string" }, interval: { type: "string" }, "agent-timeout-minutes": { type: "string" },
             "ensure-checkout": { type: "string" }, "bootstrap-result": { type: "string" },
+            service: { type: "string" },
         } });
     if (!values.workspace) {
         throw new Error(`Usage: ${bridgeUsage("install-service", "--workspace", "<repository-path>", "[--ensure-checkout <repository-url>]")} (workspace required; uses online driver lanes)`);
@@ -363,6 +364,7 @@ async function installService() {
         agentTimeoutMinutes: values["agent-timeout-minutes"],
         ensureCheckout: values["ensure-checkout"],
         bootstrapResult,
+        ...(values.service ? { serviceName: values.service } : {}),
     });
     console.log(`Installed Conduit Bridge v${bridgeVersion()} (protocol ${BRIDGE_PROTOCOL_VERSION}) runner service (${result.platform}): ${result.path}`);
     console.log(`Online lanes: ${onlineDriverIds(config).join(", ")}. Toggle with \`${bridgeUsage("drivers", "online|offline", "…")}\`.`);

package/dist/config.js

@@ -18,6 +18,11 @@ export function clampLeaseCapacity(value) {
 const directory = process.env.CONDUIT_BRIDGE_CONFIG_DIR?.trim()
     ? resolve(process.env.CONDUIT_BRIDGE_CONFIG_DIR)
     : join(homedir(), ".config", "conduit");
+/** The installation this process belongs to. Service state follows it, or a second installation on
+ *  one computer writes its service record over the first one's. */
+export function bridgeConfigDirectory() {
+    return directory;
+}
 const path = join(directory, "config.json");
 /** Runtime attempt/session state — separate so drivers CLI cannot clobber live claims. */
 const runtimePath = join(directory, "runtime.json");

package/dist/ops.js

@@ -15,7 +15,7 @@ import { ensureCheckout } from "./checkout.js";
 import { detectInstalledClients, probeAgentHealth } from "./detect.js";
 import { driverIdsFromDetectedLabels, formatLaneTiers, laneDispatchBlock, laneStatuses } from "./drivers.js";
 import { BRIDGE_PROTOCOL_VERSION, describePreflightIssue, runBridgePreflight } from "./preflight.js";
-import { applyRunnerToolPath, readActiveRunnerServiceWorkspace, readStoredRunnerServiceOptions, runnerServiceWorkspaceWarnings } from "./service.js";
+import { applyRunnerToolPath, readActiveRunnerServiceWorkspace, readStoredRunnerServiceOptions, readStoredServiceName, runnerServiceWorkspaceWarnings } from "./service.js";
 import { bridgeVersion } from "./version.js";
 import { bootstrapManagedWorkspace } from "./workspace-bootstrap.js";
 import { managedWorkspacePath } from "./managed-workspace-path.js";
@@ -351,7 +351,7 @@ export async function runOps(verb, argv = [], deps = {}) {
         const config = await (deps.loadBridgeConfig ?? loadConfig)();
         const workspace = resolve(expandOpsValue(workspaceRaw));
         if (!values["skip-service-alignment"]) {
-            for (const warning of runnerServiceWorkspaceWarnings(workspace)) {
+            for (const warning of runnerServiceWorkspaceWarnings(workspace, homedir(), await readStoredServiceName())) {
                 console.warn(`WARNING: ${warning}`);
             }
         }
@@ -379,7 +379,7 @@ export async function runOps(verb, argv = [], deps = {}) {
             console.log("");
         }
         if (report.ready) {
-            const serviceWarnings = values["skip-service-alignment"] ? [] : runnerServiceWorkspaceWarnings(workspace);
+            const serviceWarnings = values["skip-service-alignment"] ? [] : runnerServiceWorkspaceWarnings(workspace, homedir(), await readStoredServiceName());
             if (serviceWarnings.length > 0) {
                 for (const warning of serviceWarnings)
                     console.warn(`WARNING: ${warning}`);
@@ -408,16 +408,20 @@ export async function runOps(verb, argv = [], deps = {}) {
     // seed ops.env once; later project changes must not mutate it.
     let installEnv = env;
     let installArgv = argv;
+    let installServiceName = null;
     if (verb === "install") {
         const { values, positionals } = parseArgs({
             args: argv,
             options: {
                 workspace: { type: "string" },
                 repo: { type: "string" },
+                // The supervisor name this installation's service carries; one computer may hold two.
+                service: { type: "string" },
             },
             allowPositionals: true,
         });
         installArgv = positionals;
+        installServiceName = values.service?.trim() || null;
         const declaredWorkspace = values.workspace?.trim();
         const declaredRepo = values.repo?.trim();
         if (declaredWorkspace || declaredRepo) {
@@ -670,6 +674,8 @@ export async function runOps(verb, argv = [], deps = {}) {
             ]);
         }
         const installArgs = ["install-service", "--workspace", workspace];
+        if (installServiceName)
+            installArgs.push("--service", installServiceName);
         if (installEnv.CONDUIT_REPO)
             installArgs.push("--ensure-checkout", installEnv.CONDUIT_REPO);
         if (bootstrapResult)

package/dist/service.js

@@ -3,15 +3,38 @@ import { homedir, platform } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 import { existsSync, realpathSync } from "node:fs";
 import { spawn, spawnSync } from "node:child_process";
-export const SERVICE_LABEL = "io.miraland.conduit-runner";
+import { bridgeConfigDirectory } from "./config.js";
+/** The name an installation's service carries when its operator named none. */
+export const DEFAULT_SERVICE_NAME = "conduit-runner";
+/** Backwards-compatible label for the default installation (macOS). */
+export const SERVICE_LABEL = `io.miraland.${DEFAULT_SERVICE_NAME}`;
+/**
+ * One computer may hold more than one installation — this host runs the Conduit lane and the forge
+ * lane — and a service named after the product cannot say which work it serves. The name is a
+ * property of the installation: given once at install time, stored beside its program arguments, and
+ * read back by every path that looks the service up.
+ */
+const SERVICE_NAME_PATTERN = /^[a-z][a-z0-9-]{1,30}$/;
+export function assertServiceName(name) {
+    if (!SERVICE_NAME_PATTERN.test(name)) {
+        throw new Error(`Service name must match ${SERVICE_NAME_PATTERN} (got "${name}") — no .service suffix, no spaces.`);
+    }
+    return name;
+}
+export function serviceLabelFor(name) {
+    return `io.miraland.${name}`;
+}
+export function windowsTaskNameFor(name) {
+    return name.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
 function configDir() {
-    return join(homedir(), ".config", "conduit");
+    return bridgeConfigDirectory();
 }
 function serviceStatePath() {
     return join(configDir(), "service.json");
 }
-function logPath() {
-    return join(homedir(), "Library", "Logs", "conduit-runner.log");
+function logPath(name = DEFAULT_SERVICE_NAME) {
+    return join(homedir(), "Library", "Logs", `${name}.log`);
 }
 function linuxLogDir() {
     return join(homedir(), ".local", "state", "conduit");
@@ -130,14 +153,14 @@ function escapeSystemdExecArgument(value) {
     // Exec*= additionally expands $ environment references; $$ passes one literal dollar.
     return escapeSystemdUnitValue(value.replaceAll("$", () => "$$"));
 }
-function launchAgentsPath() {
-    return join(homedir(), "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`);
+function launchAgentsPath(name = DEFAULT_SERVICE_NAME) {
+    return join(homedir(), "Library", "LaunchAgents", `${serviceLabelFor(name)}.plist`);
 }
-export function systemdUnitPath(home = homedir()) {
-    return join(home, ".config", "systemd", "user", "conduit-runner.service");
+export function systemdUnitPath(home = homedir(), name = DEFAULT_SERVICE_NAME) {
+    return join(home, ".config", "systemd", "user", `${name}.service`);
 }
-export function systemdDropInDir(home = homedir()) {
-    return join(home, ".config", "systemd", "user", "conduit-runner.service.d");
+export function systemdDropInDir(home = homedir(), name = DEFAULT_SERVICE_NAME) {
+    return join(home, ".config", "systemd", "user", `${name}.service.d`);
 }
 /** Parse `--workspace` from a runner argv list or systemd ExecStart line. */
 export function parseRunnerWorkspaceFromProgramArguments(args) {
@@ -154,9 +177,9 @@ export function parseSystemdDropInPaths(value) {
     return value.trim().split(/\s+/).filter((path) => path.endsWith(".conf"));
 }
 /** Any effective drop-in can change workspace, identity, fuel, PATH, or restart behaviour. */
-export async function systemdDropInConflicts(home = homedir()) {
+export async function systemdDropInConflicts(home = homedir(), name = DEFAULT_SERVICE_NAME) {
     const conflicts = new Set();
-    const dir = systemdDropInDir(home);
+    const dir = systemdDropInDir(home, name);
     if (existsSync(dir)) {
         for (const name of await readdir(dir)) {
             if (name.endsWith(".conf"))
@@ -164,7 +187,7 @@ export async function systemdDropInConflicts(home = homedir()) {
         }
     }
     if (platform() === "linux") {
-        const effective = spawnSync("systemctl", ["--user", "show", "conduit-runner.service", "--property=DropInPaths", "--value"], { encoding: "utf8" });
+        const effective = spawnSync("systemctl", ["--user", "show", `${name}.service`, "--property=DropInPaths", "--value"], { encoding: "utf8" });
         if (effective.status === 0) {
             for (const path of parseSystemdDropInPaths(effective.stdout))
                 conflicts.add(basename(path));
@@ -172,6 +195,16 @@ export async function systemdDropInConflicts(home = homedir()) {
     }
     return [...conflicts].sort();
 }
+/** The name this installation's service carries, from its own record. */
+export async function readStoredServiceName() {
+    try {
+        const stored = JSON.parse(await readFile(serviceStatePath(), "utf8"));
+        return stored.serviceName && SERVICE_NAME_PATTERN.test(stored.serviceName) ? stored.serviceName : DEFAULT_SERVICE_NAME;
+    }
+    catch {
+        return DEFAULT_SERVICE_NAME;
+    }
+}
 export async function readStoredRunnerServiceOptions() {
     try {
         const stored = JSON.parse(await readFile(serviceStatePath(), "utf8"));
@@ -191,13 +224,13 @@ export async function readStoredRunnerServiceWorkspace() {
 }
 /** Installed supervisor command is the active workspace authority; service.json is fallback. */
 export async function readActiveRunnerServiceWorkspace(home = homedir()) {
-    return readEffectiveLinuxRunnerWorkspace(home) ?? await readStoredRunnerServiceWorkspace();
+    return readEffectiveLinuxRunnerWorkspace(home, await readStoredServiceName()) ?? await readStoredRunnerServiceWorkspace();
 }
 /** Effective workspace from the installed supervisor (systemd user unit on Linux). */
-export function readEffectiveLinuxRunnerWorkspace(home = homedir()) {
+export function readEffectiveLinuxRunnerWorkspace(home = homedir(), name = DEFAULT_SERVICE_NAME) {
     if (platform() !== "linux")
         return null;
-    const result = spawnSync("systemctl", ["--user", "cat", "conduit-runner.service"], { encoding: "utf8" });
+    const result = spawnSync("systemctl", ["--user", "cat", `${name}.service`], { encoding: "utf8" });
     if (result.status !== 0)
         return null;
     let execStart = null;
@@ -207,13 +240,13 @@ export function readEffectiveLinuxRunnerWorkspace(home = homedir()) {
     }
     return execStart ? parseRunnerWorkspaceFromExecStart(execStart) : null;
 }
-export function runnerServiceWorkspaceWarnings(declaredWorkspace, home = homedir()) {
+export function runnerServiceWorkspaceWarnings(declaredWorkspace, home = homedir(), name = DEFAULT_SERVICE_NAME) {
     const declared = resolve(declaredWorkspace);
     const warnings = [];
-    const stored = platform() === "linux" ? readEffectiveLinuxRunnerWorkspace(home) : null;
+    const stored = platform() === "linux" ? readEffectiveLinuxRunnerWorkspace(home, name) : null;
     if (stored && resolve(stored) !== declared) {
         warnings.push(`Background runner service uses workspace ${stored}, but ops.env declares ${declaredWorkspace}. ` +
-            "Run ops install to realign the service, or remove stale systemd drop-ins under conduit-runner.service.d/.");
+            `Run ops install to realign the service, or remove stale systemd drop-ins under ${name}.service.d/.`);
     }
     return warnings;
 }
@@ -287,10 +320,10 @@ export function runningInsideRunnerContainer(env = process.env) {
  * explicitly; the resident runner must return to its caller and exit normally, after which
  * Restart=always starts the rewritten unit.
  */
-export function systemdActivationCommands(insideRunner) {
+export function systemdActivationCommands(insideRunner, name = DEFAULT_SERVICE_NAME) {
     return [
-        ["--user", "enable", "conduit-runner.service"],
-        ...(!insideRunner ? [["--user", "restart", "conduit-runner.service"]] : []),
+        ["--user", "enable", `${name}.service`],
+        ...(!insideRunner ? [["--user", "restart", `${name}.service`]] : []),
     ];
 }
 /**
@@ -315,6 +348,18 @@ export function reloadLaunchdRunnerSync(domain, plistPath) {
     spawnSync("launchctl", ["kickstart", "-k", label], { encoding: "utf8" });
     return launchdServiceLoaded(domain);
 }
+/**
+ * A unit already written by another installation must not be taken over: that is how one lane's
+ * service silently started serving another lane's workspace. The unit records the installation it
+ * belongs to in its WorkingDirectory.
+ */
+export function unitBelongsToAnotherInstallation(unitText, installation) {
+    const line = unitText.split(/\r?\n/).find((entry) => entry.startsWith("WorkingDirectory="));
+    if (!line)
+        return null;
+    const owner = line.slice("WorkingDirectory=".length).trim().replace(/^"|"$/g, "");
+    return owner && resolve(owner) !== resolve(installation) ? owner : null;
+}
 export async function installRunnerService(options = {}) {
     if (runningInsideRunnerContainer()) {
         return { path: "container entrypoint", platform: "container" };
@@ -323,30 +368,34 @@ export async function installRunnerService(options = {}) {
     if (host !== "darwin" && host !== "linux" && host !== "win32") {
         throw new Error(`install-service is supported on macOS, Linux, and Windows only (got ${host})`);
     }
+    const serviceName = assertServiceName(options.serviceName ?? await readStoredServiceName());
+    const stored = { ...options, serviceName };
     const programArguments = runnerProgramArguments(options);
     if (host === "win32") {
         const tr = windowsTaskCommandLine(programArguments);
-        run("schtasks", ["/Create", "/TN", WINDOWS_TASK_NAME, "/TR", tr, "/SC", "ONLOGON", "/RL", "LIMITED", "/F"]);
+        const taskName = windowsTaskNameFor(serviceName);
+        run("schtasks", ["/Create", "/TN", taskName, "/TR", tr, "/SC", "ONLOGON", "/RL", "LIMITED", "/F"]);
         try {
-            run("schtasks", ["/Run", "/TN", WINDOWS_TASK_NAME]);
+            run("schtasks", ["/Run", "/TN", taskName]);
         }
         catch {
             // Task is registered for next logon. /Run needs an interactive session; enroll already succeeded.
         }
         await mkdir(configDir(), { recursive: true });
-        await writeFile(serviceStatePath(), `${JSON.stringify({ platform: "win32", programArguments, options, installed_at: new Date().toISOString() }, null, 2)}\n`, { mode: 0o600 });
-        return { path: WINDOWS_TASK_NAME, platform: "win32" };
+        await writeFile(serviceStatePath(), `${JSON.stringify({ platform: "win32", serviceName, programArguments, options: stored, installed_at: new Date().toISOString() }, null, 2)}\n`, { mode: 0o600 });
+        return { path: taskName, platform: "win32" };
     }
     if (host === "darwin") {
-        const plistPath = launchAgentsPath();
+        const plistPath = launchAgentsPath(serviceName);
+        const log = logPath(serviceName);
         await mkdir(dirname(plistPath), { recursive: true });
-        await mkdir(dirname(logPath()), { recursive: true });
-        await writeFile(plistPath, launchdPlist(programArguments, logPath()), { mode: 0o644 });
+        await mkdir(dirname(log), { recursive: true });
+        await writeFile(plistPath, launchdPlist(programArguments, log), { mode: 0o644 });
         const domain = `gui/${process.getuid?.() ?? 501}`;
         let loaded = false;
         if (runningInsideRunnerLaunchAgent()) {
             // Detached helper must survive bootout of this process.
-            spawn("/bin/sh", ["-c", launchdSwapCommand(domain, plistPath, logPath())], { detached: true, stdio: "ignore" }).unref();
+            spawn("/bin/sh", ["-c", launchdSwapCommand(domain, plistPath, log)], { detached: true, stdio: "ignore" }).unref();
             for (let attempt = 0; attempt < 20 && !loaded; attempt++) {
                 await sleepMs(attempt === 0 ? 2000 : 500);
                 loaded = launchdServiceLoaded(domain);
@@ -363,24 +412,30 @@ export async function installRunnerService(options = {}) {
             }
         }
         if (!loaded)
-            throw new Error(`launchd did not load ${SERVICE_LABEL}; see ${logPath()}`);
-        await writeFile(serviceStatePath(), `${JSON.stringify({ platform: "darwin", programArguments, options, installed_at: new Date().toISOString() }, null, 2)}\n`, { mode: 0o600 });
+            throw new Error(`launchd did not load ${serviceLabelFor(serviceName)}; see ${log}`);
+        await writeFile(serviceStatePath(), `${JSON.stringify({ platform: "darwin", serviceName, programArguments, options: stored, installed_at: new Date().toISOString() }, null, 2)}\n`, { mode: 0o600 });
         return { path: plistPath, platform: "darwin" };
     }
-    const unitPath = systemdUnitPath();
-    const dropIns = await systemdDropInConflicts();
+    const unitPath = systemdUnitPath(homedir(), serviceName);
+    const dropIns = await systemdDropInConflicts(homedir(), serviceName);
     if (dropIns.length) {
-        throw new Error(`Refusing to install with conduit-runner.service drop-in(s): ${dropIns.join(", ")}. ` +
+        throw new Error(`Refusing to install with ${serviceName}.service drop-in(s): ${dropIns.join(", ")}. ` +
             "Review and migrate or remove them, then run ops install again.");
     }
+    const existing = existsSync(unitPath) ? await readFile(unitPath, "utf8") : "";
+    const otherOwner = existing ? unitBelongsToAnotherInstallation(existing, configDir()) : null;
+    if (otherOwner) {
+        throw new Error(`${serviceName}.service already belongs to the installation at ${otherOwner}. ` +
+            `Install this one under another name: ops install --service <name>.`);
+    }
     await mkdir(dirname(unitPath), { recursive: true });
     await mkdir(linuxLogDir(), { recursive: true });
     await writeFile(unitPath, systemdUserUnit(programArguments, configDir()), { mode: 0o644 });
     run("systemctl", ["--user", "daemon-reload"]);
-    for (const args of systemdActivationCommands(runningInsideRunnerSystemd())) {
+    for (const args of systemdActivationCommands(runningInsideRunnerSystemd(), serviceName)) {
         run("systemctl", args);
     }
-    await writeFile(serviceStatePath(), `${JSON.stringify({ platform: "linux", programArguments, options, installed_at: new Date().toISOString() }, null, 2)}\n`, { mode: 0o600 });
+    await writeFile(serviceStatePath(), `${JSON.stringify({ platform: "linux", serviceName, programArguments, options: stored, installed_at: new Date().toISOString() }, null, 2)}\n`, { mode: 0o600 });
     return { path: unitPath, platform: "linux" };
 }
 export async function uninstallRunnerService() {
@@ -395,21 +450,23 @@ export async function uninstallRunnerService() {
     catch {
         stored = null;
     }
+    const serviceName = await readStoredServiceName();
     if (host === "win32") {
-        spawnSync("schtasks", ["/Delete", "/TN", WINDOWS_TASK_NAME, "/F"], { encoding: "utf8" });
+        const taskName = windowsTaskNameFor(serviceName);
+        spawnSync("schtasks", ["/Delete", "/TN", taskName, "/F"], { encoding: "utf8" });
         await unlink(serviceStatePath()).catch(() => undefined);
-        return { path: WINDOWS_TASK_NAME, platform: "win32" };
+        return { path: taskName, platform: "win32" };
     }
     if (host === "darwin") {
-        const plistPath = launchAgentsPath();
-        spawnSync("launchctl", ["bootout", `gui/${process.getuid?.() ?? 501}/${SERVICE_LABEL}`], { encoding: "utf8" });
+        const plistPath = launchAgentsPath(serviceName);
+        spawnSync("launchctl", ["bootout", `gui/${process.getuid?.() ?? 501}/${serviceLabelFor(serviceName)}`], { encoding: "utf8" });
         spawnSync("launchctl", ["unload", "-w", plistPath], { encoding: "utf8" });
         await unlink(plistPath).catch(() => undefined);
         await unlink(serviceStatePath()).catch(() => undefined);
         return { path: plistPath, platform: stored?.platform ?? "darwin" };
     }
-    const unitPath = systemdUnitPath();
-    spawnSync("systemctl", ["--user", "disable", "--now", "conduit-runner.service"], { encoding: "utf8" });
+    const unitPath = systemdUnitPath(homedir(), serviceName);
+    spawnSync("systemctl", ["--user", "disable", "--now", `${serviceName}.service`], { encoding: "utf8" });
     await unlink(unitPath).catch(() => undefined);
     spawnSync("systemctl", ["--user", "daemon-reload"], { encoding: "utf8" });
     await unlink(serviceStatePath()).catch(() => undefined);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miraland-labs/conduit-bridge",
-  "version": "0.16.119",
+  "version": "0.16.120",
   "description": "Conduit Bridge CLI \u2014 join, connect, disconnect, multi-driver lanes, and run Claude Code / Codex / Cursor / OpenCode / Pi / Kiro / Antigravity / Grok Build agents for a Conduit organization",
   "type": "module",
   "bin": {