@iowarp/clio-coder 0.4.7 → 0.4.8

package/dist/chunk-WFTSK7N3.js

@@ -0,0 +1,637 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  contents,
+  desktopEntry,
+  installLauncher,
+  launcherStatus,
+  uninstallLauncher
+} from "./chunk-BFPHMSK7.js";
+import {
+  createStdioTransport
+} from "./chunk-WS4FOGLY.js";
+import {
+  Id
+} from "./chunk-KKRXONXG.js";
+import {
+  AppProblem
+} from "./chunk-MZDPF35R.js";
+import {
+  value_exports
+} from "./chunk-SER7RRAE.js";
+import {
+  typebox_exports
+} from "./chunk-GH5ZR6JP.js";
+import {
+  processAlive,
+  processBirthToken
+} from "./chunk-TK2BMCBZ.js";
+import {
+  resolveClioDirs
+} from "./chunk-CTTI7G3T.js";
+import {
+  resolvePackageRoot
+} from "./chunk-E3LEPLQ2.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// apps/clio-coder-web/server/launcher/background.ts
+init_esm_shims();
+import { createHash as createHash2 } from "node:crypto";
+import { lstat, mkdir, mkdtemp, realpath as realpath3, rename, rm, rmdir, unlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, isAbsolute as isAbsolute3, join as join3, resolve } from "node:path";
+import { parseArgs } from "node:util";
+
+// apps/clio-coder-web/server/clio/http-shims.ts
+init_esm_shims();
+
+// apps/clio-coder-web/server/local-server.ts
+init_esm_shims();
+import { request } from "node:http";
+import { setTimeout as setTimeout2 } from "node:timers/promises";
+async function localServerReady(port, token) {
+  if (!Number.isInteger(port) || port < 1 || port > 65535 || !/^[\w-]{32,256}$/.test(token))
+    throw new Error("Invalid local server identity.");
+  return new Promise((resolve2) => {
+    const req = request(
+      { hostname: "127.0.0.1", port, path: "/api/meta", headers: { Authorization: `Bearer ${token}` } },
+      (response) => {
+        let body = "";
+        response.on("data", (chunk) => {
+          body += chunk.toString("utf8");
+          if (body.length > 8192) req.destroy();
+        });
+        response.on("error", () => resolve2(false));
+        response.on("end", () => {
+          try {
+            const value = JSON.parse(body);
+            resolve2(response.statusCode === 200 && value.apiVersion === 1 && value.pwa === true);
+          } catch {
+            resolve2(false);
+          }
+        });
+      }
+    );
+    req.on("error", () => resolve2(false));
+    req.setTimeout(1e3, () => {
+      req.destroy();
+      resolve2(false);
+    });
+    req.end();
+  });
+}
+async function waitForLocalServer(port, token) {
+  const deadline = performance.now() + 15e3;
+  while (performance.now() < deadline) {
+    if (await localServerReady(port, token)) return;
+    await setTimeout2(200);
+  }
+  throw new Error(
+    `Clio did not become ready on port ${port}. Check background status; another application may be using that port.`
+  );
+}
+
+// apps/clio-coder-web/server/process-policy.ts
+init_esm_shims();
+import { spawn } from "node:child_process";
+import { constants, existsSync } from "node:fs";
+import { access, readFile, realpath, stat } from "node:fs/promises";
+import { delimiter, isAbsolute, join } from "node:path";
+import { Worker } from "node:worker_threads";
+
+// apps/clio-coder-web/server/cli-commands.ts
+init_esm_shims();
+var closed = { additionalProperties: false };
+var CliCommand = typebox_exports.Union([
+  typebox_exports.Object({ kind: typebox_exports.Literal("library.agents") }, closed),
+  typebox_exports.Object({ kind: typebox_exports.Literal("library.verifiers") }, closed),
+  typebox_exports.Object({ kind: typebox_exports.Literal("usage.report") }, closed),
+  typebox_exports.Object({ kind: typebox_exports.Literal("evidence.build"), id: Id }, closed),
+  typebox_exports.Object({ kind: typebox_exports.Literal("receipt.verify"), id: Id }, closed),
+  typebox_exports.Object({ kind: typebox_exports.Literal("targets.list") }, closed),
+  typebox_exports.Object({ kind: typebox_exports.Literal("targets.probe"), id: Id }, closed),
+  typebox_exports.Object({ kind: typebox_exports.Literal("targets.use"), id: Id }, closed),
+  typebox_exports.Object({ kind: typebox_exports.Literal("targets.remove"), id: Id }, closed),
+  typebox_exports.Object({ kind: typebox_exports.Literal("routing.models") }, closed),
+  typebox_exports.Object({ kind: typebox_exports.Literal("routing.profiles") }, closed),
+  typebox_exports.Object({ kind: typebox_exports.Literal("routing.bindings") }, closed)
+]);
+function commandPlan(input, cwd) {
+  if (!value_exports.Check(CliCommand, input))
+    throw new AppProblem("validation", "CLI command is outside the supported command table.");
+  switch (input.kind) {
+    case "library.agents":
+      return { argv: ["agents", "--json"], output: "json" };
+    case "library.verifiers":
+      return { argv: ["verifiers", "inspect", "--json"], output: "json" };
+    case "usage.report":
+      if (!cwd) throw new AppProblem("validation", "A canonical workspace is required for usage.");
+      return { argv: ["usage", "report", "--repo", cwd, "--days", "30", "--json"], output: "jsonl" };
+    case "evidence.build":
+      return { argv: ["evidence", "build", "--run", input.id], output: "exit" };
+    case "receipt.verify":
+      return { argv: ["fleet", "verify", input.id, "--json"], output: "json" };
+    case "targets.list":
+      return { argv: ["targets", "--json"], output: "json" };
+    case "targets.probe":
+      return { argv: ["targets", "--json", "--probe", "--target", input.id], output: "json" };
+    case "targets.use":
+      return { argv: ["targets", "use", input.id], output: "exit" };
+    case "targets.remove":
+      return { argv: ["targets", "remove", input.id], output: "exit" };
+    case "routing.models":
+      return { argv: ["models", "--json", "--offline"], output: "json" };
+    case "routing.profiles":
+      return { argv: ["targets", "profile", "list", "--json"], output: "json" };
+    case "routing.bindings":
+      return { argv: ["targets", "profile", "bindings", "--json"], output: "json" };
+  }
+}
+
+// apps/clio-coder-web/server/process-policy.ts
+function startDomainWorker(kind, settings = {}, env = process.env, compiledDirectory) {
+  const entry = compiledDirectory ? new URL(kind === "reads" ? "reads-worker.js" : "ops-worker.js", compiledDirectory) : new URL("./worker/source-entry.mjs", import.meta.url);
+  return new Worker(entry, { workerData: { ...settings, kind }, env });
+}
+async function startAcpChild(cwd, env = process.env) {
+  const command = await resolveClioCommand(env);
+  return createStdioTransport(command.file, [...command.prefix, "acp", "--cwd", cwd, "--permission-timeout", "605000"], {
+    cwd,
+    env: Object.fromEntries(Object.entries(env).filter((entry) => entry[1] !== void 0))
+  });
+}
+async function resolveClioCommand(env = process.env) {
+  const override = env.CLIO_CODER_WEB_CLI;
+  if (override) {
+    if (!isAbsolute(override)) throw new AppProblem("validation", "CLIO_CODER_WEB_CLI must be an absolute path.");
+    const file = await realpath(override).catch(() => {
+      throw new AppProblem("unavailable", "The configured Clio CLI cannot be found.");
+    });
+    if (!(await stat(file)).isFile()) throw new AppProblem("validation", "The configured Clio CLI must be a file.");
+    return /\.[cm]?js$/.test(file) ? { file: process.execPath, prefix: [file] } : { file, prefix: [] };
+  }
+  const checkout = join(resolvePackageRoot(), "dist/cli/index.js");
+  if (existsSync(checkout)) return { file: process.execPath, prefix: [await realpath(checkout)] };
+  for (const directory of (env.PATH ?? "").split(delimiter).filter(Boolean)) {
+    const file = join(directory, process.platform === "win32" ? "clio-coder.cmd" : "clio-coder");
+    try {
+      await access(file, constants.X_OK);
+      if ((await stat(file)).isFile()) return { file: await realpath(file), prefix: [] };
+    } catch {
+    }
+  }
+  throw new AppProblem("unavailable", "Build the checkout CLI or set CLIO_CODER_WEB_CLI to its absolute path.");
+}
+function signalRecordedChild(pid, birthToken, signal) {
+  if (!Number.isSafeInteger(pid) || pid <= 0 || birthToken.startsWith("pid-") || processBirthToken(pid) !== birthToken || !processAlive(pid))
+    return false;
+  try {
+    process.kill(process.platform === "win32" ? pid : -pid, signal);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function childRunning(pid) {
+  if (!processAlive(pid)) return false;
+  if (process.platform !== "linux") return true;
+  try {
+    const value = await readFile(`/proc/${pid}/stat`, "utf8");
+    return !["Z", "X"].includes(value.slice(value.lastIndexOf(")") + 2).split(" ")[0] ?? "");
+  } catch {
+    return processAlive(pid);
+  }
+}
+async function runClioCommand(command, cwd, env = process.env) {
+  const plan = commandPlan(command, cwd);
+  if (!isAbsolute(cwd) || await realpath(cwd) !== cwd || !(await stat(cwd)).isDirectory())
+    throw new AppProblem("validation", "CLI workspace must be an existing canonical absolute directory.");
+  const executable = await resolveClioCommand(env);
+  const child = spawn(executable.file, [...executable.prefix, ...plan.argv], {
+    cwd,
+    env,
+    shell: false,
+    detached: process.platform !== "win32",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const birthToken = child.pid ? processBirthToken(child.pid) : "";
+  return { child, birthToken };
+}
+function stopClioCommand(child, birthToken, signal) {
+  if (!child.pid || child.exitCode !== null || child.signalCode !== null) return false;
+  if (birthToken && !birthToken.startsWith("pid-") && process.platform !== "win32")
+    return signalRecordedChild(child.pid, birthToken, signal);
+  return child.kill(signal);
+}
+function browserCommand(url, platform = process.platform) {
+  const parsed = new URL(url);
+  if (parsed.protocol !== "http:" || parsed.hostname !== "127.0.0.1" || !parsed.port || parsed.username || parsed.password)
+    throw new Error("The browser can only open this app's loopback HTTP URL.");
+  if (platform === "linux") return { file: "xdg-open", argv: [url] };
+  if (platform === "darwin") return { file: "open", argv: [url] };
+  throw new Error("Automatic browser opening is supported on Linux and macOS. Open the printed URL in your browser.");
+}
+async function openBrowser(url, env = process.env) {
+  const command = browserCommand(url);
+  const child = spawn(command.file, command.argv, { env, shell: false, stdio: "ignore" });
+  await new Promise((resolve2, reject) => {
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+    }, 1e4);
+    child.once("error", (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+    child.once("close", (code) => {
+      clearTimeout(timer);
+      if (code === 0) resolve2();
+      else reject(new Error("The desktop could not open a browser. Open the printed URL manually."));
+    });
+  });
+}
+function serviceCommand(action, unit, unitFile) {
+  if (!/^clio-coder-web-[a-f0-9]{12}\.service$/.test(unit) || !isAbsolute(unitFile) || !unitFile.endsWith(`/${unit}`))
+    throw new Error("Invalid Clio background service identity.");
+  if (action === "reload") return ["--user", "daemon-reload"];
+  if (action === "show")
+    return ["--user", "show", unit, "--property=FragmentPath,ActiveState,UnitFileState,MainPID,Result"];
+  if (action === "enable") return ["--user", "enable", "--now", "--", unitFile];
+  if (action === "disable") return ["--user", "disable", "--now", "--", unit];
+  return ["--user", action, "--", unit];
+}
+async function controlService(action, unit, unitFile, env = process.env) {
+  if (process.platform !== "linux")
+    throw new Error("Background setup currently requires Linux with a systemd user session.");
+  const child = spawn("systemctl", serviceCommand(action, unit, unitFile), {
+    env,
+    shell: false,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  return new Promise((resolve2, reject) => {
+    const output = [];
+    let bytes = 0, exceeded = false;
+    const timer = setTimeout(() => {
+      exceeded = true;
+      child.kill("SIGKILL");
+    }, 2e4);
+    const collect = (chunk, stdout) => {
+      bytes += chunk.length;
+      if (bytes > 65536) {
+        exceeded = true;
+        child.kill("SIGKILL");
+      } else if (stdout) output.push(chunk);
+    };
+    child.stdout.on("data", (chunk) => collect(chunk, true));
+    child.stderr.on("data", (chunk) => collect(chunk, false));
+    child.once("error", () => {
+      clearTimeout(timer);
+      reject(new Error("systemctl is unavailable. Background setup requires a running Linux systemd user session."));
+    });
+    child.once("close", (code) => {
+      clearTimeout(timer);
+      if (code === 0 && !exceeded) resolve2(Buffer.concat(output).toString("utf8"));
+      else
+        reject(new Error(`Background service ${action} failed. Check the user service manager and journal for ${unit}.`));
+    });
+  });
+}
+
+// apps/clio-coder-web/server/launcher/background-config.ts
+init_esm_shims();
+import { createHash, randomBytes } from "node:crypto";
+import { constants as constants2 } from "node:fs";
+import { open, realpath as realpath2 } from "node:fs/promises";
+import { isAbsolute as isAbsolute2, join as join2 } from "node:path";
+var path = typebox_exports.String({ minLength: 1, maxLength: 4096 });
+var BackgroundConfig = typebox_exports.Object(
+  {
+    v: typebox_exports.Literal(1),
+    port: typebox_exports.Integer({ minimum: 1, maximum: 65535 }),
+    token: typebox_exports.String({ pattern: "^[A-Za-z0-9_-]{43}$" }),
+    roots: typebox_exports.Object({ config: path, data: path, state: path, cache: path }, { additionalProperties: false }),
+    packageRoot: path,
+    path: typebox_exports.String({ maxLength: 8192 }),
+    launch: typebox_exports.Object(
+      { node: path, loader: typebox_exports.Optional(path), entry: path, icon: typebox_exports.Optional(path) },
+      { additionalProperties: false }
+    ),
+    desktopPrefix: path
+  },
+  { additionalProperties: false }
+);
+function backgroundPaths(directory) {
+  if (!isAbsolute2(directory)) throw new Error("The background directory must be absolute.");
+  const id = createHash("sha256").update(directory).digest("hex").slice(0, 12);
+  const unit = `clio-coder-web-${id}.service`;
+  return {
+    directory,
+    config: join2(directory, "server.json"),
+    unit,
+    unitFile: join2(directory, unit),
+    manifest: join2(directory, "owner.json")
+  };
+}
+async function readBackgroundConfig(file) {
+  const handle = await open(file, constants2.O_RDONLY | constants2.O_NOFOLLOW);
+  try {
+    const stat2 = await handle.stat();
+    if (!stat2.isFile() || stat2.nlink !== 1 || stat2.size > 16384 || (stat2.mode & 63) !== 0 || process.getuid && stat2.uid !== process.getuid())
+      throw new Error("Background credentials must be a private regular file owned by this user.");
+    const value = JSON.parse(await handle.readFile("utf8"));
+    if (!value_exports.Check(BackgroundConfig, value) || ![...Object.values(value.roots), value.packageRoot, value.desktopPrefix, ...Object.values(value.launch)].every(
+      isAbsolute2
+    ))
+      throw new Error("Background configuration is invalid. No settings were applied.");
+    return value;
+  } finally {
+    await handle.close();
+  }
+}
+async function newBackgroundConfig(port, launch, desktopPrefix, env = process.env) {
+  const config = {
+    v: 1,
+    port,
+    token: randomBytes(32).toString("base64url"),
+    roots: resolveClioDirs(),
+    packageRoot: resolvePackageRoot(),
+    path: env.PATH ?? "",
+    launch: {
+      node: await realpath2(launch.node),
+      ...launch.loader ? { loader: await realpath2(launch.loader) } : {},
+      ...launch.icon ? { icon: await realpath2(launch.icon) } : {},
+      entry: await realpath2(launch.entry)
+    },
+    desktopPrefix
+  };
+  if (!value_exports.Check(BackgroundConfig, config) || !isAbsolute2(desktopPrefix))
+    throw new Error("Invalid background setup options.");
+  return config;
+}
+function backgroundEnvironment(config) {
+  return {
+    PATH: config.path,
+    CLIO_CODER_PACKAGE_ROOT: config.packageRoot,
+    CLIO_CODER_CONFIG_DIR: config.roots.config,
+    CLIO_CODER_DATA_DIR: config.roots.data,
+    CLIO_CODER_STATE_DIR: config.roots.state,
+    CLIO_CODER_CACHE_DIR: config.roots.cache
+  };
+}
+function systemdArgument(value) {
+  if ([...value].some((char) => char.charCodeAt(0) < 32 || char.charCodeAt(0) === 127))
+    throw new Error("Service paths cannot contain control characters.");
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/%/g, "%%").replace(/\$/g, "$$$$")}"`;
+}
+function backgroundUnit(config, directory) {
+  const argv = [
+    config.launch.node,
+    ...config.launch.loader ? ["--import", config.launch.loader] : [],
+    config.launch.entry,
+    "--persistent",
+    backgroundPaths(directory).config
+  ];
+  return [
+    "[Unit]",
+    "Description=Clio Coder web application",
+    "StartLimitIntervalSec=30",
+    "StartLimitBurst=5",
+    "",
+    "[Service]",
+    "Type=simple",
+    `ExecStart=${argv.map(systemdArgument).join(" ")}`,
+    "Restart=on-failure",
+    "RestartSec=1",
+    "KillMode=control-group",
+    "TimeoutStopSec=15",
+    "UMask=0077",
+    "",
+    "[Install]",
+    "WantedBy=default.target",
+    ""
+  ].join("\n");
+}
+
+// apps/clio-coder-web/server/launcher/background.ts
+var hash = (value) => createHash2("sha256").update(value).digest("hex");
+async function owned(directory) {
+  const files = backgroundPaths(directory);
+  const manifest = await contents(files.manifest), configText = await contents(files.config), unit = await contents(files.unitFile);
+  if (manifest === null && configText === null && unit === null) return { status: "absent", files };
+  try {
+    const owner = JSON.parse(manifest ?? "null");
+    if (owner?.v !== 1 || owner?.owner !== "clio-coder-web-background" || !configText || !unit || owner.config !== hash(configText) || owner.unit !== hash(unit))
+      throw new Error("Ownership mismatch");
+    const config = await readBackgroundConfig(files.config);
+    if (unit !== backgroundUnit(config, directory)) throw new Error("Unit does not match configuration");
+    return { status: "installed", files, config };
+  } catch {
+    throw new Error(
+      "Background files are incomplete, modified or not private; ownership could not be verified. No files were changed."
+    );
+  }
+}
+async function serviceState(files, control) {
+  const text = await control("show", files.unit, files.unitFile);
+  const values = Object.fromEntries(
+    text.trim().split("\n").map((line) => {
+      const index = line.indexOf("=");
+      return [line.slice(0, index), line.slice(index + 1)];
+    })
+  );
+  if (values.FragmentPath && await realpath3(values.FragmentPath).catch(() => "") !== files.unitFile)
+    throw new Error("A different service uses this name; it will not be changed.");
+  return values;
+}
+async function desktopOwned(config, directory) {
+  const state = await launcherStatus(config.desktopPrefix);
+  if (state.status === "absent") return false;
+  if (state.status === "conflict" || await contents(state.entry) !== desktopEntry({ ...config.launch, background: directory }))
+    throw new Error(
+      "The desktop entry belongs to another launch mode or was changed; it will not be replaced or removed."
+    );
+  return true;
+}
+async function installBackground(directory, proposed, control = controlService, ready = waitForLocalServer) {
+  if (process.platform !== "linux")
+    throw new Error("Background setup currently requires Linux with a systemd user session.");
+  await mkdir(directory, { recursive: true, mode: 448 });
+  const info = await lstat(directory);
+  if (!info.isDirectory() || await realpath3(directory) !== directory || (info.mode & 63) !== 0 || process.getuid && info.uid !== process.getuid())
+    throw new Error("Background directory must be a private, canonical directory owned by this user.");
+  const state = await owned(directory), files = state.files;
+  await serviceState(files, control);
+  const config = state.status === "installed" ? state.config : proposed;
+  if (state.status === "installed" && (config.port !== proposed.port || config.desktopPrefix !== proposed.desktopPrefix))
+    throw new Error(
+      "Background setup already has a stable port and desktop location. Uninstall it before changing them."
+    );
+  if (state.status === "installed" && (config.packageRoot !== proposed.packageRoot || config.launch.node !== proposed.launch.node || config.launch.entry !== proposed.launch.entry || config.launch.loader !== proposed.launch.loader))
+    throw new Error(
+      "Background setup belongs to another installation. Run web background uninstall before installing this one."
+    );
+  const desktop = await launcherStatus(config.desktopPrefix);
+  if (desktop.status !== "absent") await desktopOwned(config, directory);
+  if (state.status === "absent") {
+    const configText = `${JSON.stringify(config, null, 2)}
+`, unit = backgroundUnit(config, directory);
+    const staging = await mkdtemp(join3(dirname(directory), ".clio-coder-background-"));
+    try {
+      await writeFile(join3(staging, "server.json"), configText, { flag: "wx", mode: 384 });
+      await readBackgroundConfig(join3(staging, "server.json"));
+      await writeFile(join3(staging, files.unit), unit, { flag: "wx", mode: 384 });
+      await writeFile(
+        join3(staging, "owner.json"),
+        `${JSON.stringify({ v: 1, owner: "clio-coder-web-background", config: hash(configText), unit: hash(unit) })}
+`,
+        { flag: "wx", mode: 384 }
+      );
+      await rename(staging, directory);
+    } finally {
+      await rm(staging, { recursive: true, force: true });
+    }
+  }
+  await control("enable", files.unit, files.unitFile);
+  await ready(config.port, config.token);
+  await installLauncher(config.desktopPrefix, { ...config.launch, background: directory });
+  return { status: "installed", unit: files.unit, origin: `http://127.0.0.1:${config.port}`, directory };
+}
+async function backgroundStatus(directory, control = controlService, ready = localServerReady) {
+  const state = await owned(directory);
+  if (state.status === "absent") return { status: "absent", directory };
+  const service = await serviceState(state.files, control);
+  return {
+    status: "installed",
+    directory,
+    unit: state.files.unit,
+    port: state.config.port,
+    origin: `http://127.0.0.1:${state.config.port}`,
+    active: service.ActiveState ?? "unknown",
+    enabled: service.UnitFileState ?? "unknown",
+    pid: Number(service.MainPID) || null,
+    ready: await ready(state.config.port, state.config.token),
+    desktop: await desktopOwned(state.config, directory) ? "installed" : "absent"
+  };
+}
+async function startBackground(directory, control = controlService, ready = waitForLocalServer) {
+  const state = await owned(directory);
+  if (state.status !== "installed")
+    throw new Error("Background service is not installed. Run background install first.");
+  await serviceState(state.files, control);
+  await control("start", state.files.unit, state.files.unitFile);
+  await ready(state.config.port, state.config.token);
+  return `http://127.0.0.1:${state.config.port}/#token=${state.config.token}`;
+}
+async function tryStartBackground(directory, packageRoot, control = controlService, ready = waitForLocalServer) {
+  const state = await owned(directory);
+  if (state.status === "absent") return void 0;
+  if (await realpath3(state.config.packageRoot) !== await realpath3(packageRoot))
+    throw new Error(
+      "Background setup belongs to another installation. Use that installation or run web without --reuse-background."
+    );
+  return startBackground(directory, control, ready);
+}
+async function stopBackground(directory, control = controlService) {
+  const state = await owned(directory);
+  if (state.status === "absent") return;
+  await serviceState(state.files, control);
+  await control("stop", state.files.unit, state.files.unitFile);
+}
+async function uninstallBackground(directory, control = controlService) {
+  const state = await owned(directory);
+  if (state.status === "absent") return { status: "absent", directory };
+  await serviceState(state.files, control);
+  const desktop = await desktopOwned(state.config, directory);
+  await control("disable", state.files.unit, state.files.unitFile);
+  if (desktop) await uninstallLauncher(state.config.desktopPrefix);
+  for (const file of [state.files.manifest, state.files.unitFile, state.files.config]) await unlink(file);
+  await control("reload", state.files.unit, state.files.unitFile);
+  await rmdir(directory).catch((error) => {
+    if (error.code !== "ENOTEMPTY") throw error;
+  });
+  return { status: "absent", directory };
+}
+async function backgroundRemoval(directory, packageRoot, control = controlService) {
+  const state = await owned(directory);
+  if (state.status === "absent") return null;
+  if (await realpath3(state.config.packageRoot) !== await realpath3(packageRoot))
+    throw new Error("Background service belongs to another installation; uninstall stopped before removing Clio state.");
+  await serviceState(state.files, control);
+  await desktopOwned(state.config, directory);
+  return { path: directory, remove: () => uninstallBackground(directory, control) };
+}
+async function background(args, launch) {
+  if (process.platform !== "linux")
+    throw new Error("Background setup currently requires Linux with a systemd user session.");
+  const { values, positionals } = parseArgs({
+    args,
+    allowPositionals: true,
+    options: {
+      directory: { type: "string" },
+      prefix: { type: "string" },
+      port: { type: "string" },
+      open: { type: "boolean" }
+    }
+  });
+  const command = positionals[0];
+  if (positionals.length !== 1 || !["install", "status", "start", "open", "stop", "uninstall"].includes(command ?? ""))
+    throw new Error(
+      "Usage: background install|status|start|open|stop|uninstall [--directory <absolute private directory>] [install: --port <port> --prefix <XDG data directory> --open]"
+    );
+  if (command !== "install" && (values.prefix !== void 0 || values.port !== void 0 || values.open !== void 0))
+    throw new Error("--port, --prefix and --open apply to background install only.");
+  const directory = values.directory ?? join3(resolveClioDirs().state, "web/background");
+  if (!isAbsolute3(directory) || resolve(directory) !== directory)
+    throw new Error("--directory must be an absolute normalized path.");
+  if (command === "status") {
+    console.log(JSON.stringify(await backgroundStatus(directory), null, 2));
+    return;
+  }
+  if (command === "uninstall") {
+    console.log(JSON.stringify(await uninstallBackground(directory), null, 2));
+    return;
+  }
+  if (command === "stop") {
+    await stopBackground(directory);
+    console.log("Clio background service stopped. It remains enabled for the next login.");
+    return;
+  }
+  if (command === "install") {
+    const port = Number(values.port ?? "4317");
+    if (!/^\d+$/.test(values.port ?? "4317") || !Number.isInteger(port) || port < 1 || port > 65535)
+      throw new Error("--port must be an integer from 1 to 65535.");
+    const prefix = values.prefix ?? (process.env.XDG_DATA_HOME && isAbsolute3(process.env.XDG_DATA_HOME) ? process.env.XDG_DATA_HOME : join3(homedir(), ".local/share"));
+    const config = await newBackgroundConfig(port, launch, prefix);
+    console.log(JSON.stringify(await installBackground(directory, config), null, 2));
+    console.log(
+      "Background sessions use Clio's saved credentials. If a target key exists only in your terminal environment, save it with clio-coder auth login <target> before starting a conversation."
+    );
+    if (!values.open) return;
+  }
+  const url = await startBackground(directory);
+  if (command === "start") console.log(`Clio background service is ready at ${new URL(url).origin}.`);
+  else await openBrowser(url);
+}
+
+export {
+  commandPlan,
+  startDomainWorker,
+  startAcpChild,
+  signalRecordedChild,
+  childRunning,
+  runClioCommand,
+  stopClioCommand,
+  openBrowser,
+  controlService,
+  readBackgroundConfig,
+  backgroundEnvironment,
+  installBackground,
+  backgroundStatus,
+  startBackground,
+  tryStartBackground,
+  stopBackground,
+  uninstallBackground,
+  backgroundRemoval,
+  background
+};
+//# sourceMappingURL=chunk-WFTSK7N3.js.map

package/dist/{chunk-YPRSNUTC.js → chunk-WJWNZXRM.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   isSessionEntry
-} from "./chunk-KAFMW7WM.js";
+} from "./chunk-6R5MBXBJ.js";
 import {
   init_esm_shims
 } from "./chunk-ECBHH7LU.js";
@@ -392,4 +392,4 @@ export {
   foldSessionTaskHistory,
   createTaskBoardStore
 };
-//# sourceMappingURL=chunk-YPRSNUTC.js.map
+//# sourceMappingURL=chunk-WJWNZXRM.js.map