@poetic-ai/poetic 1.42.0

package/dist/chunk-WDUORIHF.js

@@ -0,0 +1,877 @@
+import {
+  execGit
+} from "./chunk-KNDYMVWN.js";
+import {
+  quotePosixShellArg
+} from "./chunk-N5DX4JAK.js";
+
+// src/cli/commands/setup-temp-cleanup.ts
+import { randomUUID } from "crypto";
+import { existsSync } from "fs";
+import { chmod, mkdir, readFile, rename, unlink, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { execa as execa2 } from "execa";
+
+// src/cli/commands/upgrade-support.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { fileURLToPath } from "url";
+import { execa, execaSync } from "execa";
+var DEFAULT_PACKAGE = "@poetic-ai/poetic";
+var LEGACY_PACKAGE = "@poetic/cli";
+var INSTALL_LOCK_DIR_NAME = "install.lock.d";
+var INSTALL_LOCK_OWNER_FILE = "owner.json";
+var DEFAULT_LOCK_TIMEOUT_MS = 3e4;
+var DEFAULT_LOCK_STALE_MS = 36 * 6e4;
+var DEFAULT_LOCK_RETRY_MS = 250;
+var FULL_SHA_RE = /^[0-9a-f]{40}$/i;
+var PARTIAL_SHA_RE = /^[0-9a-f]{7,39}$/i;
+function defaultSleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isPidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code = error.code;
+    return code === "EPERM";
+  }
+}
+function poeticHomeDir(homeDir) {
+  return path.join(homeDir ?? os.homedir(), ".poetic");
+}
+function installManifestPath(homeDir) {
+  return path.join(poeticHomeDir(homeDir), "install.json");
+}
+function installLockDir(homeDir) {
+  return path.join(poeticHomeDir(homeDir), INSTALL_LOCK_DIR_NAME);
+}
+function readInstallLockOwner(lockDir) {
+  try {
+    const ownerPath = path.join(lockDir, INSTALL_LOCK_OWNER_FILE);
+    if (!fs.existsSync(ownerPath)) return void 0;
+    const raw = fs.readFileSync(ownerPath, "utf8");
+    const data = JSON.parse(raw);
+    if (typeof data.pid !== "number" || typeof data.hostname !== "string" || typeof data.startedAt !== "string" || typeof data.token !== "string") {
+      return void 0;
+    }
+    return {
+      pid: data.pid,
+      hostname: data.hostname,
+      startedAt: data.startedAt,
+      command: typeof data.command === "string" ? data.command : "unknown",
+      token: data.token
+    };
+  } catch {
+    return void 0;
+  }
+}
+function formatLockDiagnostics(lockDir, owner, alive, stale) {
+  const lines = [`Install lock is held at ${lockDir}.`];
+  if (!owner) {
+    lines.push("Owner metadata is missing or unreadable.");
+  } else {
+    lines.push(
+      `Owner: pid=${owner.pid} host=${owner.hostname} startedAt=${owner.startedAt} command=${owner.command}`
+    );
+    if (alive === false) lines.push("Owner process is not running (stale lock).");
+    if (alive === true) lines.push("Owner process appears to be running.");
+  }
+  if (stale) lines.push("Lock is considered stale and can be reclaimed.");
+  lines.push("Wait for the other upgrade/install to finish, or remove the stale lock directory.");
+  return lines.join(" ");
+}
+function writeLockOwner(lockDir, owner) {
+  const ownerPath = path.join(lockDir, INSTALL_LOCK_OWNER_FILE);
+  const tmp = path.join(lockDir, `.owner.${owner.pid}.${Date.now()}.tmp`);
+  fs.writeFileSync(tmp, `${JSON.stringify(owner, null, 2)}
+`, "utf8");
+  fs.renameSync(tmp, ownerPath);
+}
+function releaseLockDir(lockDir, token) {
+  try {
+    const owner = readInstallLockOwner(lockDir);
+    if (owner && owner.token !== token) {
+      return;
+    }
+    const ownerPath = path.join(lockDir, INSTALL_LOCK_OWNER_FILE);
+    try {
+      fs.unlinkSync(ownerPath);
+    } catch {
+    }
+    try {
+      for (const entry of fs.readdirSync(lockDir)) {
+        if (entry.startsWith(".owner.")) {
+          try {
+            fs.unlinkSync(path.join(lockDir, entry));
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+    fs.rmdirSync(lockDir);
+  } catch {
+  }
+}
+function isLockStale(lockDir, owner, staleMs, nowMs, pidAlive, localHostname) {
+  if (!owner) {
+    try {
+      const stat = fs.statSync(lockDir);
+      return { stale: nowMs - stat.mtimeMs > staleMs, alive: void 0 };
+    } catch {
+      return { stale: true, alive: void 0 };
+    }
+  }
+  if (owner.hostname !== localHostname) {
+    const started2 = Date.parse(owner.startedAt);
+    return {
+      stale: Number.isFinite(started2) && nowMs - started2 > staleMs,
+      alive: void 0
+    };
+  }
+  const alive = pidAlive(owner.pid);
+  if (!alive) return { stale: true, alive: false };
+  const started = Date.parse(owner.startedAt);
+  if (Number.isFinite(started) && nowMs - started > staleMs) {
+    return { stale: false, alive: true };
+  }
+  return { stale: false, alive: true };
+}
+async function acquireInstallLock(options = {}) {
+  const homeDir = options.homeDir;
+  const lockDir = installLockDir(homeDir);
+  const timeoutMs = options.timeoutMs ?? DEFAULT_LOCK_TIMEOUT_MS;
+  const staleMs = options.staleMs ?? DEFAULT_LOCK_STALE_MS;
+  const retryMs = options.retryMs ?? DEFAULT_LOCK_RETRY_MS;
+  const nowFn = options.now ?? Date.now;
+  const sleepFn = options.sleep ?? defaultSleep;
+  const pidAlive = options.isPidAlive ?? isPidAlive;
+  const hostname = options.hostname ?? os.hostname();
+  const pid = options.pid ?? process.pid;
+  const command = options.command ?? "poetic upgrade";
+  const parent = poeticHomeDir(homeDir);
+  fs.mkdirSync(parent, { recursive: true });
+  const deadline = nowFn() + timeoutMs;
+  let lastDiagnostics = `Install lock is held at ${lockDir}.`;
+  while (true) {
+    const token = `${pid}:${nowFn()}:${Math.random().toString(16).slice(2)}`;
+    const owner = {
+      pid,
+      hostname,
+      startedAt: new Date(nowFn()).toISOString(),
+      command,
+      token
+    };
+    try {
+      fs.mkdirSync(lockDir);
+      try {
+        writeLockOwner(lockDir, owner);
+      } catch (error) {
+        try {
+          fs.rmdirSync(lockDir);
+        } catch {
+        }
+        throw error;
+      }
+      return {
+        lockDir,
+        owner,
+        release: () => releaseLockDir(lockDir, token)
+      };
+    } catch (error) {
+      const code = error.code;
+      if (code !== "EEXIST") throw error;
+      const existing = readInstallLockOwner(lockDir);
+      const { stale, alive } = isLockStale(lockDir, existing, staleMs, nowFn(), pidAlive, hostname);
+      lastDiagnostics = formatLockDiagnostics(lockDir, existing, alive, stale);
+      if (stale) {
+        try {
+          releaseLockDir(lockDir, existing?.token ?? "");
+        } catch {
+        }
+        if (!fs.existsSync(lockDir)) continue;
+      }
+      if (nowFn() >= deadline) {
+        throw new Error(
+          `Error: could not acquire install lock within ${timeoutMs}ms. ${lastDiagnostics}`
+        );
+      }
+      await sleepFn(retryMs);
+    }
+  }
+}
+function parseLsRemoteLines(stdout) {
+  const lines = stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const out = [];
+  for (const line of lines) {
+    const [sha, ref] = line.split(/\s+/, 2);
+    if (sha && ref && FULL_SHA_RE.test(sha)) {
+      out.push({ sha: sha.toLowerCase(), ref });
+    }
+  }
+  return out;
+}
+async function resolveGitCommitSha(repoUrl, ref, runLsRemote) {
+  const trimmed = ref.trim();
+  if (!trimmed) {
+    throw new Error("Error: git ref is empty");
+  }
+  if (FULL_SHA_RE.test(trimmed)) {
+    const result = await runLsRemote(repoUrl);
+    if (result.exitCode !== 0) {
+      throw new Error(
+        `Error: could not query advertised git identities from ${repoUrl}${result.stderr.trim() ? `: ${result.stderr.trim()}` : ` (exit ${result.exitCode})`}`
+      );
+    }
+    const rows = parseLsRemoteLines(result.stdout);
+    const peeledTags = new Set(
+      rows.filter((row) => row.ref.endsWith("^{}")).map((row) => row.ref.slice(0, -3))
+    );
+    const advertised = rows.some((row) => {
+      if (row.sha !== trimmed.toLowerCase()) return false;
+      const annotatedTagObject = row.ref.startsWith("refs/tags/") && !row.ref.endsWith("^{}") && peeledTags.has(row.ref);
+      return !annotatedTagObject;
+    });
+    if (advertised) return trimmed.toLowerCase();
+    throw new Error(`Error: full git SHA "${trimmed}" is not an advertised identity on ${repoUrl}`);
+  }
+  if (PARTIAL_SHA_RE.test(trimmed)) {
+    const result = await runLsRemote(repoUrl, trimmed);
+    const matches = parseLsRemoteLines(result.stdout).filter(
+      (row) => row.sha.startsWith(trimmed.toLowerCase())
+    );
+    const unique = [...new Set(matches.map((m) => m.sha))];
+    if (unique.length === 1) {
+      return unique[0];
+    }
+    if (unique.length > 1) {
+      throw new Error(
+        `Error: partial git SHA "${trimmed}" is ambiguous (${unique.length} matches). Use a full 40-character commit SHA.`
+      );
+    }
+    throw new Error(
+      `Error: partial git SHA "${trimmed}" could not be verified against ${repoUrl}. Use a full 40-character commit SHA.`
+    );
+  }
+  const exactTag = await runLsRemote(repoUrl, `refs/tags/${trimmed}`);
+  const peeledTag = await runLsRemote(repoUrl, `refs/tags/${trimmed}^{}`);
+  const tagRows = [...parseLsRemoteLines(exactTag.stdout), ...parseLsRemoteLines(peeledTag.stdout)];
+  const peeled = tagRows.find((row) => row.ref === `refs/tags/${trimmed}^{}`);
+  if (peeled?.sha) {
+    return peeled.sha;
+  }
+  if (peeledTag.exitCode !== 0) {
+    throw new Error(
+      peeledTag.stderr.trim() || `Error: could not verify whether git tag "${trimmed}" is annotated on ${repoUrl}`
+    );
+  }
+  const lightweight = tagRows.find((row) => row.ref === `refs/tags/${trimmed}`);
+  if (lightweight?.sha) {
+    return lightweight.sha;
+  }
+  const headResult = await runLsRemote(repoUrl, `refs/heads/${trimmed}`);
+  if (headResult.exitCode === 0) {
+    const head = parseLsRemoteLines(headResult.stdout).find(
+      (row) => row.ref === `refs/heads/${trimmed}`
+    );
+    if (head?.sha) return head.sha;
+  }
+  throw new Error(
+    `Error: could not resolve git ref "${trimmed}" on ${repoUrl}. Named refs must resolve before install.`
+  );
+}
+async function resolvePackageVersionString(packageName, ref, runNpmView) {
+  const result = await runNpmView(packageName, ref);
+  if (result.exitCode !== 0) {
+    throw new Error(result.stderr.trim() || `Error: npm could not resolve ${packageName}@${ref}`);
+  }
+  const version = result.stdout.trim().split(/\r?\n/).at(-1)?.trim() ?? "";
+  if (!version) {
+    throw new Error(`Error: npm returned no version for ${packageName}@${ref}`);
+  }
+  if (!/^v?\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(version)) {
+    throw new Error(`Error: npm returned an invalid version for ${packageName}@${ref}`);
+  }
+  return version;
+}
+function packageInstallTarget(packageName, resolvedVersion) {
+  return `${packageName}@${resolvedVersion}`;
+}
+function gitInstallTarget(repository, resolvedFullCommit) {
+  if (!FULL_SHA_RE.test(resolvedFullCommit)) {
+    throw new Error(
+      `Error: git install target requires a full 40-character commit SHA, got "${resolvedFullCommit}"`
+    );
+  }
+  return `git+${repository}#${resolvedFullCommit.toLowerCase()}`;
+}
+function writeInstallManifestAtomic(manifest, options = {}) {
+  const manifestPath = options.manifestPath ?? installManifestPath(options.homeDir);
+  const dir = path.dirname(manifestPath);
+  fs.mkdirSync(dir, { recursive: true });
+  const payload = `${JSON.stringify(manifest, null, 2)}
+`;
+  const tmp = path.join(
+    dir,
+    `.install.json.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`
+  );
+  try {
+    fs.writeFileSync(tmp, payload, "utf8");
+    fs.renameSync(tmp, manifestPath);
+  } catch (error) {
+    try {
+      fs.unlinkSync(tmp);
+    } catch {
+    }
+    throw error;
+  }
+}
+function readInstallManifestFromDisk(options = {}) {
+  try {
+    const manifestPath = options.manifestPath ?? installManifestPath(options.homeDir);
+    if (!fs.existsSync(manifestPath)) return void 0;
+    const data = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+    if (!data || typeof data !== "object") return void 0;
+    if (data.source === "package" || data.source === "git") {
+      return data;
+    }
+    if (typeof data.commit === "string" && data.commit.length > 0) {
+      return { ...data, source: "git", schema: 2 };
+    }
+    if (typeof data.version === "string" || typeof data.package === "string") {
+      return { ...data, source: "package", schema: 2 };
+    }
+  } catch {
+  }
+  return void 0;
+}
+function findPackageJson(startDir) {
+  let current = startDir;
+  while (true) {
+    const candidate = path.join(current, "package.json");
+    if (fs.existsSync(candidate)) return candidate;
+    const parent = path.dirname(current);
+    if (parent === current) return void 0;
+    current = parent;
+  }
+}
+function resolveNpmPrefix(installDir) {
+  if (installDir) return installDir;
+  try {
+    const result = execaSync("npm", ["config", "get", "prefix"]);
+    const prefix = result.stdout.trim();
+    return prefix || "";
+  } catch {
+    return "";
+  }
+}
+function detectLegacyPackageOnDisk(installDir) {
+  const prefix = resolveNpmPrefix(installDir);
+  if (!prefix) return false;
+  return fs.existsSync(path.join(prefix, "lib", "node_modules", LEGACY_PACKAGE, "package.json"));
+}
+function detectPackageOnDisk(packageName, installDir) {
+  const prefix = resolveNpmPrefix(installDir);
+  if (!prefix) return false;
+  return fs.existsSync(path.join(prefix, "lib", "node_modules", packageName, "package.json"));
+}
+function readInstalledPackageVersion(packageName, installDir) {
+  const prefix = resolveNpmPrefix(installDir);
+  if (!prefix) return void 0;
+  try {
+    const packageJsonPath = path.join(prefix, "lib", "node_modules", packageName, "package.json");
+    const parsed = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+    return typeof parsed.version === "string" && parsed.version.trim() ? parsed.version.trim() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function snapshotInstallState(options) {
+  const packageName = options.packageName ?? DEFAULT_PACKAGE;
+  const manifestPath = installManifestPath(options.homeDir);
+  let manifestBytes = null;
+  try {
+    if (fs.existsSync(manifestPath)) {
+      manifestBytes = fs.readFileSync(manifestPath, "utf8");
+    }
+  } catch {
+    manifestBytes = null;
+  }
+  return {
+    manifestPath,
+    manifestBytes,
+    legacyPackagePresent: detectLegacyPackageOnDisk(options.installDir),
+    legacyPackageVersion: readInstalledPackageVersion(LEGACY_PACKAGE, options.installDir),
+    packagePresent: detectPackageOnDisk(packageName, options.installDir),
+    packageVersion: readInstalledPackageVersion(packageName, options.installDir),
+    prefix: resolveNpmPrefix(options.installDir),
+    capturedAt: (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString()
+  };
+}
+function preserveManifestBackup(snapshot, writeStderr) {
+  if (!snapshot.manifestBytes) return;
+  try {
+    const bakPath = `${snapshot.manifestPath}.bak`;
+    fs.writeFileSync(bakPath, snapshot.manifestBytes, "utf8");
+    writeStderr?.(`Previous manifest preserved at ${bakPath}.
+`);
+  } catch {
+  }
+}
+function restoreManifestFromSnapshot(snapshot) {
+  if (snapshot.manifestBytes === null) {
+    try {
+      if (fs.existsSync(snapshot.manifestPath)) {
+        fs.unlinkSync(snapshot.manifestPath);
+      }
+    } catch {
+    }
+    return;
+  }
+  const dir = path.dirname(snapshot.manifestPath);
+  fs.mkdirSync(dir, { recursive: true });
+  const tmp = `${snapshot.manifestPath}.restore.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, snapshot.manifestBytes, "utf8");
+  fs.renameSync(tmp, snapshot.manifestPath);
+}
+function detectSourceCheckout(options = {}) {
+  let entryPath = options.entryPath;
+  if (!entryPath) {
+    try {
+      entryPath = fileURLToPath(import.meta.url);
+    } catch {
+      entryPath = process.argv[1] ?? "";
+    }
+  }
+  const normalized = entryPath.replace(/\\/g, "/");
+  const packageName = options.packageName ?? DEFAULT_PACKAGE;
+  const packageRoot = findPackageJson(path.dirname(entryPath));
+  const hasTsx = process.argv.some((arg) => arg.includes("tsx")) || process.execArgv.some((arg) => arg.includes("tsx"));
+  let kind = "unknown";
+  if (hasTsx && !normalized.includes("/node_modules/")) {
+    kind = "development";
+  } else if (normalized.includes(`/node_modules/${packageName}/`)) {
+    try {
+      const real = fs.realpathSync(entryPath).replace(/\\/g, "/");
+      if (real !== normalized && !real.includes("/node_modules/")) {
+        kind = "npm-link";
+      } else if (normalized.includes("/lib/node_modules/") || normalized.includes("/.nvm/") || normalized.includes("/volta/")) {
+        kind = "global";
+      } else {
+        kind = "package";
+      }
+    } catch {
+      kind = "package";
+    }
+  } else if (normalized.includes("/dist/") && !normalized.includes("/node_modules/")) {
+    kind = "repo-dist";
+  } else if (["/lib/node_modules/", "/.npm/", "/nvm/", "/volta/"].some((p) => normalized.includes(p))) {
+    kind = "global";
+  } else if (packageRoot) {
+    const rootDir = path.dirname(packageRoot);
+    const hasSrc = fs.existsSync(path.join(rootDir, "src"));
+    const hasGit = fs.existsSync(path.join(rootDir, ".git"));
+    if (hasSrc && (hasGit || fs.existsSync(path.join(rootDir, "install.sh")))) {
+      kind = "source-checkout";
+    }
+  }
+  const isSourceLike = kind === "source-checkout" || kind === "npm-link" || kind === "repo-dist" || kind === "development";
+  const guidance = isSourceLike ? [
+    `This Poetic binary looks like a ${kind} (not a published package install).`,
+    "Refusing to default to the unpublished package channel from a source/link checkout.",
+    "Update from source instead:",
+    "  git pull",
+    "  ./scripts/build-poetic.sh",
+    "Do not run package-channel upgrade against a dirty source checkout.",
+    "If you intentionally want the published package, pass --source package --force after installing from npm."
+  ] : [];
+  return {
+    kind,
+    isSourceLike,
+    entryPath,
+    packageRoot: packageRoot ? path.dirname(packageRoot) : void 0,
+    guidance
+  };
+}
+function defaultRunGitLsRemote(repoUrl, refspec) {
+  return execGit(["ls-remote", repoUrl, ...refspec ? [refspec] : []], { cwd: os.tmpdir() });
+}
+function defaultRunNpmViewVersion(packageName, ref) {
+  return execa("npm", ["view", `${packageName}@${ref}`, "version"], { reject: false }).then(
+    (result) => ({
+      exitCode: result.exitCode ?? 1,
+      stdout: result.stdout ?? "",
+      stderr: result.stderr ?? ""
+    })
+  );
+}
+
+// src/cli/commands/setup-temp-cleanup.ts
+var LABEL = "com.poetic.temp-cleanup";
+var WRAPPER_DIR = join(homedir(), ".poetic", "bin");
+var WRAPPER_PATH = join(WRAPPER_DIR, "poetic-cleanup");
+var PLIST_DIR = join(homedir(), "Library", "LaunchAgents");
+var PLIST_PATH = join(PLIST_DIR, `${LABEL}.plist`);
+var LOG_DIR = join(homedir(), ".poetic", "logs");
+var LOG_OUT = join(LOG_DIR, "temp-cleanup.log");
+var LOG_ERR = join(LOG_DIR, "temp-cleanup-error.log");
+async function resolvePoeticBinary() {
+  const prefix = readInstallManifestFromDisk()?.prefix;
+  if (prefix) {
+    const selectedBinary = join(prefix, "bin", "poetic");
+    if (existsSync(selectedBinary)) return selectedBinary;
+  }
+  try {
+    const { execFileSync } = await import("child_process");
+    const which = execFileSync("which", ["poetic"], { encoding: "utf8" }).trim();
+    if (which && existsSync(which)) {
+      return which;
+    }
+  } catch {
+  }
+  return null;
+}
+function shellUnescapeSingleQuoted(value) {
+  return value.replace(/'\\''/g, "'");
+}
+function buildCleanupArgs(config) {
+  const args = ["cleanup", "provider-temp", "--execute", "--silent"];
+  if (config.roots.length > 0) {
+    for (const root of config.roots) {
+      args.push("--root", root);
+    }
+  } else if (config.useDefaultRoots) {
+    args.push("--use-default-roots");
+  }
+  return args;
+}
+async function loadConfiguredRoots() {
+  try {
+    const { loadAllConfigSources } = await import("./config-loader-VPFPFO4B.js");
+    const sources = await loadAllConfigSources(process.cwd(), {});
+    let roots = [];
+    for (const source of sources) {
+      const cleanup = source.data?.cleanup;
+      if (cleanup?.providerTemp?.roots?.length) {
+        roots = cleanup.providerTemp.roots;
+      }
+    }
+    return roots;
+  } catch {
+    return [];
+  }
+}
+async function resolveTargetConfig(options) {
+  if (options?.roots && options.roots.length > 0) {
+    return { roots: options.roots, useDefaultRoots: false };
+  }
+  if (options?.useDefaultRoots) {
+    return { roots: [], useDefaultRoots: true };
+  }
+  const configuredRoots = await loadConfiguredRoots();
+  if (configuredRoots.length > 0) {
+    return { roots: configuredRoots, useDefaultRoots: false };
+  }
+  return {
+    error: "No provider temp roots configured. Set cleanup.providerTemp.roots, or re-run with --use-default-roots or --root <path>."
+  };
+}
+function generateWrapper(poeticBinary, targetConfig) {
+  const cleanupArgs = buildCleanupArgs(targetConfig).map((arg) => quotePosixShellArg(arg)).join(" ");
+  const invokeCmd = `exec "$POETIC_BIN" ${cleanupArgs}`;
+  const home = homedir();
+  return `#!/bin/bash
+# Poetic temp cleanup wrapper \u2014 managed by \`poetic cleanup temp-agent\`
+# Do not edit manually; re-run \`poetic cleanup temp-agent --install-launchagent\` to update.
+
+set -euo pipefail
+
+# LaunchAgents run with minimal environment \u2014 set HOME explicitly
+export HOME=${quotePosixShellArg(home)}
+
+# Verify the target binary exists; exit 0 (not 1) to avoid launchd backoff
+POETIC_BIN=${quotePosixShellArg(poeticBinary)}
+if [ ! -x "$POETIC_BIN" ]; then
+  echo "$(date -Iseconds) poetic-cleanup: binary not found at $POETIC_BIN \u2014 skipping" >> ${quotePosixShellArg(LOG_ERR)} 2>/dev/null || true
+  exit 0
+fi
+
+${invokeCmd}
+`;
+}
+function generatePlist(intervalSeconds) {
+  const home = homedir();
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LABEL}</string>
+
+  <key>ProgramArguments</key>
+  <array>
+    <string>${WRAPPER_PATH}</string>
+  </array>
+
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>HOME</key>
+    <string>${home}</string>
+  </dict>
+
+  <key>StartInterval</key>
+  <integer>${intervalSeconds}</integer>
+
+  <key>RunAtLoad</key>
+  <true/>
+
+  <key>StandardOutPath</key>
+  <string>${LOG_OUT}</string>
+
+  <key>StandardErrorPath</key>
+  <string>${LOG_ERR}</string>
+
+  <key>Nice</key>
+  <integer>10</integer>
+
+  <key>ProcessType</key>
+  <string>Background</string>
+</dict>
+</plist>
+`;
+}
+async function writeFileAtomic(filePath, content, mode) {
+  const tempPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(tempPath, content, "utf8");
+    if (mode !== void 0) await chmod(tempPath, mode);
+    await rename(tempPath, filePath);
+  } catch (error) {
+    await unlink(tempPath).catch(() => void 0);
+    throw error;
+  }
+}
+async function restoreFile(filePath, prior, mode) {
+  if (prior === null) {
+    await unlink(filePath).catch(() => void 0);
+    return;
+  }
+  await writeFileAtomic(filePath, prior, mode);
+}
+async function unloadJob() {
+  const uid = process.getuid?.() ?? 501;
+  try {
+    await execa2("launchctl", ["bootout", `gui/${uid}`, PLIST_PATH], {
+      reject: false,
+      timeout: 1e4
+    });
+  } catch {
+  }
+}
+async function loadJob() {
+  const uid = process.getuid?.() ?? 501;
+  await execa2("launchctl", ["bootstrap", `gui/${uid}`, PLIST_PATH], {
+    timeout: 1e4
+  });
+}
+async function installTempCleanup(options) {
+  const effectiveIntervalMinutes = options?.intervalMinutes ?? 1440;
+  const intervalSeconds = effectiveIntervalMinutes * 60;
+  const poeticBinary = await resolvePoeticBinary();
+  if (!poeticBinary) {
+    return {
+      installed: false,
+      updated: false,
+      message: "Could not resolve poetic binary. Run from a built Poetic repo or ensure `poetic` is in PATH."
+    };
+  }
+  const targetConfig = await resolveTargetConfig(options);
+  if ("error" in targetConfig) {
+    return {
+      installed: false,
+      updated: false,
+      message: targetConfig.error
+    };
+  }
+  await mkdir(WRAPPER_DIR, { recursive: true });
+  await mkdir(PLIST_DIR, { recursive: true });
+  await mkdir(LOG_DIR, { recursive: true });
+  const wrapperContent = generateWrapper(poeticBinary, targetConfig);
+  let wrapperChanged = true;
+  if (existsSync(WRAPPER_PATH)) {
+    const existing = await readFile(WRAPPER_PATH, "utf8");
+    wrapperChanged = existing !== wrapperContent;
+  }
+  const priorWrapper = existsSync(WRAPPER_PATH) ? await readFile(WRAPPER_PATH, "utf8") : null;
+  const plistContent = generatePlist(intervalSeconds);
+  let plistChanged = true;
+  if (existsSync(PLIST_PATH)) {
+    const existing = await readFile(PLIST_PATH, "utf8");
+    plistChanged = existing !== plistContent;
+  }
+  const priorPlist = existsSync(PLIST_PATH) ? await readFile(PLIST_PATH, "utf8") : null;
+  try {
+    if (wrapperChanged) await writeFileAtomic(WRAPPER_PATH, wrapperContent, 493);
+    if (plistChanged) await writeFileAtomic(PLIST_PATH, plistContent);
+    await unloadJob();
+    await loadJob();
+  } catch (err) {
+    await restoreFile(WRAPPER_PATH, priorWrapper, 493);
+    await restoreFile(PLIST_PATH, priorPlist);
+    if (priorPlist !== null) await loadJob().catch(() => void 0);
+    return {
+      installed: false,
+      updated: false,
+      message: `Failed to load LaunchAgent: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  const updated = existsSync(PLIST_PATH) && (wrapperChanged || plistChanged);
+  return {
+    installed: true,
+    updated,
+    message: updated ? `LaunchAgent updated and loaded (interval: ${effectiveIntervalMinutes}m)` : `LaunchAgent installed and loaded (interval: ${effectiveIntervalMinutes}m)`
+  };
+}
+async function readInstalledTempCleanupOptions() {
+  if (!existsSync(WRAPPER_PATH) || !existsSync(PLIST_PATH)) return null;
+  try {
+    const [wrapper, plist] = await Promise.all([
+      readFile(WRAPPER_PATH, "utf8"),
+      readFile(PLIST_PATH, "utf8")
+    ]);
+    const execLine = wrapper.match(/^exec "\$POETIC_BIN" (.+)$/m)?.[1] ?? "";
+    const args = [...execLine.matchAll(/'((?:'\\''|[^'])*)'/g)].map(
+      (match) => shellUnescapeSingleQuoted(match[1] ?? "")
+    );
+    const roots = [];
+    for (let index = 0; index < args.length; index += 1) {
+      const root = args[index + 1];
+      if (args[index] === "--root" && root) roots.push(root);
+    }
+    const intervalSeconds = Number(
+      plist.match(/<key>StartInterval<\/key>\s*<integer>(\d+)<\/integer>/)?.[1]
+    );
+    if (!Number.isFinite(intervalSeconds) || intervalSeconds <= 0) return null;
+    return {
+      intervalMinutes: intervalSeconds / 60,
+      roots,
+      useDefaultRoots: args.includes("--use-default-roots")
+    };
+  } catch {
+    return null;
+  }
+}
+async function uninstallTempCleanup() {
+  let removed = false;
+  await unloadJob();
+  if (existsSync(PLIST_PATH)) {
+    await unlink(PLIST_PATH);
+    removed = true;
+  }
+  if (existsSync(WRAPPER_PATH)) {
+    await unlink(WRAPPER_PATH);
+    removed = true;
+  }
+  return {
+    removed,
+    message: removed ? "LaunchAgent and wrapper removed." : "LaunchAgent was not installed."
+  };
+}
+function parseWrapperPaths(content) {
+  const singleQuoted = "'((?:'\\\\''|[^'])*)'";
+  const binMatch = new RegExp(`^POETIC_BIN=${singleQuoted}$`, "m").exec(content) ?? /^POETIC_BIN="(.+)"$/m.exec(content);
+  const execMatch = new RegExp(`^exec ${singleQuoted} "\\$POETIC_BIN"(?:\\s|$)`, "m").exec(content) ?? /^exec "(.+)" "(.+)" /m.exec(content);
+  const binaryPath = binMatch?.[1] ? shellUnescapeSingleQuoted(binMatch[1]) : execMatch?.[2] ?? null;
+  const nodePath = execMatch?.[1] ? shellUnescapeSingleQuoted(execMatch[1]) : null;
+  return {
+    binaryPath,
+    nodePath
+  };
+}
+async function checkTempCleanupStatus() {
+  const wrapperExists = existsSync(WRAPPER_PATH);
+  const plistExists = existsSync(PLIST_PATH);
+  let jobLoaded = false;
+  try {
+    const result = await execa2("launchctl", ["list"], { timeout: 5e3 });
+    jobLoaded = result.stdout.includes(LABEL);
+  } catch {
+  }
+  let embeddedBinaryPath = null;
+  let embeddedBinaryExists = null;
+  let embeddedNodePath = null;
+  let embeddedNodeExists = null;
+  if (wrapperExists) {
+    try {
+      const wrapperContent = await readFile(WRAPPER_PATH, "utf8");
+      const { binaryPath, nodePath } = parseWrapperPaths(wrapperContent);
+      embeddedBinaryPath = binaryPath;
+      embeddedBinaryExists = binaryPath !== null ? existsSync(binaryPath) : null;
+      embeddedNodePath = nodePath;
+      embeddedNodeExists = nodePath !== null ? existsSync(nodePath) : null;
+    } catch {
+    }
+  }
+  const stale = (
+    // Partial install: one artifact is present without the other
+    wrapperExists !== plistExists || // Wrapper installed but unreadable or unparseable — can't validate its launcher
+    wrapperExists && embeddedBinaryPath === null || // Wrapper installed and parseable but one or both embedded paths are gone
+    embeddedBinaryExists === false || // Legacy wrappers pinned Node separately; retain that stale-path check.
+    embeddedNodeExists === false
+  );
+  return {
+    wrapperExists,
+    plistExists,
+    jobLoaded,
+    wrapperPath: WRAPPER_PATH,
+    plistPath: PLIST_PATH,
+    embeddedBinaryPath,
+    embeddedBinaryExists,
+    embeddedNodePath,
+    embeddedNodeExists,
+    stale
+  };
+}
+var __testOnly = {
+  buildCleanupArgs,
+  generateWrapper,
+  parseWrapperPaths,
+  resolvePoeticBinary,
+  resolveTargetConfig,
+  generatePlist,
+  writeFileAtomic,
+  WRAPPER_PATH,
+  PLIST_PATH
+};
+
+export {
+  DEFAULT_PACKAGE,
+  LEGACY_PACKAGE,
+  acquireInstallLock,
+  resolveGitCommitSha,
+  resolvePackageVersionString,
+  packageInstallTarget,
+  gitInstallTarget,
+  writeInstallManifestAtomic,
+  readInstallManifestFromDisk,
+  findPackageJson,
+  resolveNpmPrefix,
+  detectLegacyPackageOnDisk,
+  snapshotInstallState,
+  preserveManifestBackup,
+  restoreManifestFromSnapshot,
+  detectSourceCheckout,
+  defaultRunGitLsRemote,
+  defaultRunNpmViewVersion,
+  installTempCleanup,
+  readInstalledTempCleanupOptions,
+  uninstallTempCleanup,
+  checkTempCleanupStatus,
+  __testOnly
+};
+//# sourceMappingURL=chunk-WDUORIHF.js.map