@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-7N3OLLSL.js

@@ -1,637 +0,0 @@
-import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  contents,
-  desktopEntry,
-  installLauncher,
-  launcherStatus,
-  uninstallLauncher
-} from "./chunk-BFPHMSK7.js";
-import {
-  Id
-} from "./chunk-KKRXONXG.js";
-import {
-  AppProblem
-} from "./chunk-MZDPF35R.js";
-import {
-  createStdioTransport
-} from "./chunk-XNZWWDC3.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-7N3OLLSL.js.map