codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/claude-code-parallel.js

@@ -0,0 +1,221 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var claude_code_parallel_exports = {};
+__export(claude_code_parallel_exports, {
+  HOOK_TIMEOUT: () => HOOK_TIMEOUT,
+  SETTINGS_FILE: () => SETTINGS_FILE,
+  SKILL_FILE: () => SKILL_FILE,
+  SKILL_NAME: () => SKILL_NAME,
+  applyClaudeCode: () => applyClaudeCode,
+  claudeCodeDir: () => claudeCodeDir,
+  hookCommand: () => hookCommand,
+  planHook: () => planHook,
+  planSkill: () => planSkill,
+  previewClaudeCode: () => previewClaudeCode,
+  skillText: () => skillText,
+  thisMachine: () => thisMachine
+});
+module.exports = __toCommonJS(claude_code_parallel_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_os = __toESM(require("node:os"));
+var import_node_path = __toESM(require("node:path"));
+var import_skill_guide = require("../mcp/skill-guide");
+var import_command = require("../mcp/connector/command");
+var import_hook = require("../mcp/connector/hook");
+var import_claude_desktop_config = require("./claude-desktop-config");
+var import_confined_fs = require("./confined-fs");
+const SKILL_NAME = "codetrellis-parallel";
+const SKILL_FILE = `skills/${SKILL_NAME}/SKILL.md`;
+const SETTINGS_FILE = "settings.json";
+const HOOK_TIMEOUT = 10;
+function claudeCodeDir(w) {
+  const dir = w.env.CLAUDE_CONFIG_DIR?.trim() || import_node_path.default.join(w.home, ".claude");
+  return w.exists(dir) ? dir : null;
+}
+function skillText() {
+  const guide = (0, import_skill_guide.buildSkillGuide)("parallel").replace(/^# .*\n+/, "");
+  return [
+    "---",
+    `name: ${SKILL_NAME}`,
+    "description: Working alongside other AI agents in the same repository (other git worktrees, clones or branches), with CodeTrellis running. Use when starting work in a repository where other agents may be working, when planning changes to shared or exported code, or when CodeTrellis reports an overlap with other work.",
+    "---",
+    "",
+    "# Working in parallel, with CodeTrellis",
+    "",
+    "The tools below are the CodeTrellis MCP server's. In Claude Code they are named",
+    "`mcp__codetrellis__<tool>` (for example `mcp__codetrellis__get_awareness`). If they",
+    "are not available, CodeTrellis is not connected: say so rather than guessing.",
+    "",
+    "This skill is written by the CodeTrellis app (Settings \u2192 Connect an agent). The same",
+    "guide is served by the app as `codetrellis://skill/parallel`.",
+    "",
+    guide.trimEnd(),
+    ""
+  ].join("\n");
+}
+function hookCommand(connector) {
+  const env = Object.entries(connector.env).map(([k, v]) => `${k}=${(0, import_command.shellQuote)(v, "linux")}`);
+  return [...env, (0, import_command.shellQuote)(connector.command, "linux"), ...connector.args.map((a) => (0, import_command.shellQuote)(a, "linux")), import_hook.HOOK_FLAG, import_hook.HOOK_PRE_TOOL_USE].join(" ");
+}
+const isOurHook = (h) => !!h && typeof h === "object" && typeof h.command === "string" && /mcp-connector\.cjs/.test(h.command) && h.command.includes(`${import_hook.HOOK_FLAG} ${import_hook.HOOK_PRE_TOOL_USE}`);
+const planned = (before, after, existed) => {
+  const status = before === after ? "unchanged" : existed ? "update" : "add";
+  return { ok: true, status, before, after, diff: status === "unchanged" ? [] : (0, import_claude_desktop_config.lineDiff)(before, after) };
+};
+function planSkill(current) {
+  return planned(current ?? "", skillText(), current !== null);
+}
+function planHook(current, command) {
+  let doc = {};
+  if (current !== null && current.trim() !== "") {
+    let parsed;
+    try {
+      parsed = JSON.parse(current);
+    } catch {
+      return { ok: false, reason: "Claude Code's settings.json is not valid JSON, so it was left alone. Fix it, then try again." };
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return { ok: false, reason: "Claude Code's settings.json is not a JSON object, so it was left alone." };
+    }
+    doc = parsed;
+  }
+  const hooks = doc.hooks ?? {};
+  if (!hooks || typeof hooks !== "object" || Array.isArray(hooks)) {
+    return { ok: false, reason: `Claude Code's settings have a "hooks" that is not an object, so they were left alone.` };
+  }
+  const pre = hooks.PreToolUse ?? [];
+  if (!Array.isArray(pre)) {
+    return { ok: false, reason: `Claude Code's settings have a "PreToolUse" that is not a list, so they were left alone.` };
+  }
+  const ours = { type: "command", command, timeout: HOOK_TIMEOUT };
+  let placed = false;
+  const kept = pre.flatMap((group) => {
+    const g = group;
+    if (!g || typeof g !== "object" || !Array.isArray(g.hooks) || !g.hooks.some(isOurHook)) return [group];
+    const others = g.hooks.filter((h) => !isOurHook(h));
+    const mine = placed ? [] : [{ matcher: import_hook.HOOK_MATCHER, hooks: [ours] }];
+    placed = true;
+    return [...mine, ...others.length ? [{ ...g, hooks: others }] : []];
+  });
+  const next = placed ? kept : [...kept, { matcher: import_hook.HOOK_MATCHER, hooks: [ours] }];
+  const merged = { ...doc, hooks: { ...hooks, PreToolUse: next } };
+  const before = current ?? "";
+  const unchanged = current !== null && JSON.stringify(JSON.parse(current || "{}")) === JSON.stringify(merged);
+  return planned(before, unchanged ? before : `${JSON.stringify(merged, null, 2)}
+`, current !== null);
+}
+function readCurrent(dir, rel, label) {
+  if (!import_node_fs.default.existsSync(import_node_path.default.join(dir, rel))) return { text: null };
+  try {
+    return { text: (0, import_confined_fs.readTextWithin)(dir, rel, label) };
+  } catch {
+    return { error: `Claude Code's ${label} could not be read (it may be a link, which is not followed), so it was left alone.` };
+  }
+}
+const NO_DIR = "Claude Code's settings folder (~/.claude) was not found on this computer. Install Claude Code and run it once, then try again.";
+const NO_CONNECTOR = "The connector is not built in this checkout, so there is no hook to add yet (npm run build:connector).";
+function previewItem(dir, rel, label, plan) {
+  const current = readCurrent(dir, rel, label);
+  if ("error" in current) return current;
+  const p = plan(current.text);
+  if (!p.ok) return { error: p.reason };
+  return { path: import_node_path.default.join(dir, rel), status: p.status, diff: p.diff, beforeHash: (0, import_claude_desktop_config.hashOf)(current.text), exists: current.text !== null };
+}
+function previewClaudeCode(where, connector) {
+  const dir = claudeCodeDir(where);
+  if (!dir) return { ok: false, reason: NO_DIR };
+  const skill = previewItem(dir, SKILL_FILE, "skill file", planSkill);
+  if ("error" in skill) return { ok: false, reason: skill.error };
+  let hook;
+  if (!connector) hook = { unavailable: NO_CONNECTOR };
+  else {
+    const h = previewItem(dir, SETTINGS_FILE, "settings.json", (t) => planHook(t, hookCommand(connector)));
+    hook = "error" in h ? { unavailable: h.error } : { ...h, ...connector.caveat ? { caveat: connector.caveat } : {} };
+  }
+  return { ok: true, dir, skill, hook };
+}
+const stampOf = (now) => now.toISOString().replace(/[:.]/g, "-");
+function applyClaudeCode(where, connector, choice, now = /* @__PURE__ */ new Date()) {
+  const dir = claudeCodeDir(where);
+  if (!dir) return { ok: false, reason: NO_DIR };
+  if (!choice.skill && !choice.hook) return { ok: false, reason: "Choose the skill, the hook, or both." };
+  if (choice.hook && !connector) return { ok: false, reason: NO_CONNECTOR };
+  const items = [];
+  if (choice.skill) items.push({ key: "skill", rel: SKILL_FILE, label: "skill file", shown: choice.skill, plan: planSkill });
+  if (choice.hook) items.push({ key: "hook", rel: SETTINGS_FILE, label: "settings.json", shown: choice.hook, plan: (t) => planHook(t, hookCommand(connector)) });
+  const ready = [];
+  for (const it of items) {
+    const current = readCurrent(dir, it.rel, it.label);
+    if ("error" in current) return { ok: false, reason: current.error };
+    if ((0, import_claude_desktop_config.hashOf)(current.text) !== it.shown) {
+      return { ok: false, changed: true, reason: `Claude Code's ${it.label} changed after you looked at it. Here is the change again, against the file as it is now.` };
+    }
+    const plan = it.plan(current.text);
+    if (!plan.ok) return plan;
+    ready.push({ key: it.key, rel: it.rel, label: it.label, current: current.text, plan });
+  }
+  const out = {};
+  try {
+    for (const r of ready) {
+      const target = import_node_path.default.join(dir, r.rel);
+      if (r.plan.status === "unchanged") {
+        out[r.key] = { path: target, backupPath: null, status: "unchanged" };
+        continue;
+      }
+      let backupPath = null;
+      if (r.current !== null) {
+        const ext = import_node_path.default.extname(r.rel);
+        const backupRel = `${r.rel.slice(0, -ext.length)}.before-codetrellis-${stampOf(now)}${ext}`;
+        backupPath = (0, import_confined_fs.writeFileWithin)(dir, backupRel, r.current, `Claude Code ${r.label} backup`);
+      }
+      (0, import_confined_fs.writeFileWithin)(dir, r.rel, r.plan.after, `Claude Code ${r.label}`);
+      out[r.key] = { path: target, backupPath, status: r.plan.status };
+    }
+  } catch {
+    return { ok: false, reason: "Claude Code's files could not be written (a link at their place is not written through). Anything already written is listed by a fresh preview." };
+  }
+  return { ok: true, ...out };
+}
+function thisMachine() {
+  return { home: import_node_os.default.homedir(), env: process.env, exists: (p) => import_node_fs.default.existsSync(p) };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HOOK_TIMEOUT,
+  SETTINGS_FILE,
+  SKILL_FILE,
+  SKILL_NAME,
+  applyClaudeCode,
+  claudeCodeDir,
+  hookCommand,
+  planHook,
+  planSkill,
+  previewClaudeCode,
+  skillText,
+  thisMachine
+});

package/src/backend/services/claude-desktop-config.js

@@ -0,0 +1,186 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var claude_desktop_config_exports = {};
+__export(claude_desktop_config_exports, {
+  CONFIG_NAME: () => CONFIG_NAME,
+  applyClaudeDesktop: () => applyClaudeDesktop,
+  claudeDesktopConfigDir: () => claudeDesktopConfigDir,
+  hashOf: () => hashOf,
+  lineDiff: () => lineDiff,
+  planMerge: () => planMerge,
+  previewClaudeDesktop: () => previewClaudeDesktop,
+  thisMachine: () => thisMachine
+});
+module.exports = __toCommonJS(claude_desktop_config_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_os = __toESM(require("node:os"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_crypto = require("node:crypto");
+var import_confined_fs = require("./confined-fs");
+const CONFIG_NAME = "claude_desktop_config.json";
+function claudeDesktopConfigDir(w) {
+  const candidates = [];
+  if (w.platform === "darwin") {
+    candidates.push(import_node_path.default.join(w.home, "Library", "Application Support", "Claude"));
+  } else if (w.platform === "win32") {
+    const appData = w.env.APPDATA ?? import_node_path.default.join(w.home, "AppData", "Roaming");
+    candidates.push(import_node_path.default.join(appData, "Claude"));
+    const local = w.env.LOCALAPPDATA ?? import_node_path.default.join(w.home, "AppData", "Local");
+    const packages = import_node_path.default.join(local, "Packages");
+    if (w.exists(packages)) {
+      for (const name of w.list(packages).filter((n) => /^Claude_/i.test(n)).sort()) {
+        candidates.push(import_node_path.default.join(packages, name, "LocalCache", "Roaming", "Claude"));
+      }
+    }
+  } else {
+    candidates.push(import_node_path.default.join(w.env.XDG_CONFIG_HOME || import_node_path.default.join(w.home, ".config"), "Claude"));
+  }
+  return candidates.find((d) => w.exists(d)) ?? null;
+}
+function lineDiff(before, after) {
+  const a = before === "" ? [] : before.replace(/\n$/, "").split("\n");
+  const b = after.replace(/\n$/, "").split("\n");
+  const n = a.length;
+  const m = b.length;
+  const lcs = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+  for (let i2 = n - 1; i2 >= 0; i2--) {
+    for (let j2 = m - 1; j2 >= 0; j2--) {
+      lcs[i2][j2] = a[i2] === b[j2] ? lcs[i2 + 1][j2 + 1] + 1 : Math.max(lcs[i2 + 1][j2], lcs[i2][j2 + 1]);
+    }
+  }
+  const out = [];
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (a[i] === b[j]) {
+      out.push({ op: " ", text: a[i] });
+      i++;
+      j++;
+    } else if (lcs[i + 1][j] >= lcs[i][j + 1]) out.push({ op: "-", text: a[i++] });
+    else out.push({ op: "+", text: b[j++] });
+  }
+  while (i < n) out.push({ op: "-", text: a[i++] });
+  while (j < m) out.push({ op: "+", text: b[j++] });
+  return out;
+}
+function planMerge(current, entry) {
+  let doc = {};
+  if (current !== null && current.trim() !== "") {
+    let parsed;
+    try {
+      parsed = JSON.parse(current);
+    } catch {
+      return { ok: false, reason: "Claude Desktop's config file is not valid JSON, so it was left alone. Fix or remove it, then try again." };
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return { ok: false, reason: "Claude Desktop's config file is not a JSON object, so it was left alone." };
+    }
+    doc = parsed;
+  }
+  const servers = doc.mcpServers ?? {};
+  if (!servers || typeof servers !== "object" || Array.isArray(servers)) {
+    return { ok: false, reason: `Claude Desktop's config has an "mcpServers" that is not an object, so it was left alone.` };
+  }
+  const existing = servers.codetrellis;
+  const status = existing === void 0 ? "add" : JSON.stringify(existing) === JSON.stringify(entry) ? "unchanged" : "update";
+  const merged = { ...doc, mcpServers: { ...servers, codetrellis: entry } };
+  const before = current ?? "";
+  const after = status === "unchanged" ? before : `${JSON.stringify(merged, null, 2)}
+`;
+  return { ok: true, status, before, after, diff: status === "unchanged" ? [] : lineDiff(before, after) };
+}
+const hashOf = (text) => (0, import_node_crypto.createHash)("sha256").update(text ?? "\0absent").digest("hex");
+function readCurrent(dir) {
+  if (!import_node_fs.default.existsSync(import_node_path.default.join(dir, CONFIG_NAME))) return { text: null };
+  try {
+    return { text: (0, import_confined_fs.readTextWithin)(dir, CONFIG_NAME, "Claude Desktop config") };
+  } catch {
+    return { error: "Claude Desktop's config file could not be read (it may be a link, which is not followed), so it was left alone." };
+  }
+}
+function previewClaudeDesktop(where, entry) {
+  if (!entry) return { ok: false, reason: "The connector is not built in this checkout, so there is nothing to add yet (npm run build:connector)." };
+  const dir = claudeDesktopConfigDir(where);
+  if (!dir) return { ok: false, reason: "Claude Desktop's settings folder was not found on this computer. Install Claude Desktop and open it once, then try again." };
+  const current = readCurrent(dir);
+  if ("error" in current) return { ok: false, reason: current.error };
+  const plan = planMerge(current.text, entry);
+  if (!plan.ok) return plan;
+  return { ok: true, path: import_node_path.default.join(dir, CONFIG_NAME), status: plan.status, diff: plan.diff, beforeHash: hashOf(current.text), exists: current.text !== null };
+}
+function applyClaudeDesktop(where, entry, shownHash, now = /* @__PURE__ */ new Date()) {
+  if (!entry) return { ok: false, reason: "The connector is not built in this checkout." };
+  const dir = claudeDesktopConfigDir(where);
+  if (!dir) return { ok: false, reason: "Claude Desktop's settings folder was not found on this computer." };
+  const current = readCurrent(dir);
+  if ("error" in current) return { ok: false, reason: current.error };
+  if (hashOf(current.text) !== shownHash) {
+    return { ok: false, changed: true, reason: "Claude Desktop's config changed after you looked at it. Here is the change again, against the file as it is now." };
+  }
+  const plan = planMerge(current.text, entry);
+  if (!plan.ok) return plan;
+  const target = import_node_path.default.join(dir, CONFIG_NAME);
+  if (plan.status === "unchanged") return { ok: true, path: target, backupPath: null, status: "unchanged" };
+  try {
+    let backupPath = null;
+    if (current.text !== null) {
+      const stamp = now.toISOString().replace(/[:.]/g, "-");
+      backupPath = (0, import_confined_fs.writeFileWithin)(dir, `claude_desktop_config.before-codetrellis-${stamp}.json`, current.text, "Claude Desktop config backup");
+    }
+    (0, import_confined_fs.writeFileWithin)(dir, CONFIG_NAME, plan.after, "Claude Desktop config");
+    return { ok: true, path: target, backupPath, status: plan.status };
+  } catch {
+    return { ok: false, reason: "Claude Desktop's config could not be written (a link at its place is not written through). Nothing was changed." };
+  }
+}
+function thisMachine() {
+  return {
+    platform: process.platform,
+    env: process.env,
+    home: import_node_os.default.homedir(),
+    exists: (p) => import_node_fs.default.existsSync(p),
+    list: (d) => {
+      try {
+        return import_node_fs.default.readdirSync(d);
+      } catch {
+        return [];
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CONFIG_NAME,
+  applyClaudeDesktop,
+  claudeDesktopConfigDir,
+  hashOf,
+  lineDiff,
+  planMerge,
+  previewClaudeDesktop,
+  thisMachine
+});

package/src/backend/services/clock.js

@@ -0,0 +1,57 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var clock_exports = {};
+__export(clock_exports, {
+  _setClockForTesting: () => _setClockForTesting,
+  createControllableClock: () => createControllableClock,
+  now: () => now,
+  nowIso: () => nowIso
+});
+module.exports = __toCommonJS(clock_exports);
+let _now = () => Date.now();
+function now() {
+  return _now();
+}
+function nowIso() {
+  return new Date(_now()).toISOString();
+}
+function _setClockForTesting(fn) {
+  _now = fn ?? (() => Date.now());
+}
+function createControllableClock(start = Date.UTC(2026, 0, 1)) {
+  let value = start;
+  return {
+    tick(ms = 1e3) {
+      value += ms;
+      return value;
+    },
+    set(epochMs) {
+      value = epochMs;
+    },
+    read() {
+      return value;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  _setClockForTesting,
+  createControllableClock,
+  now,
+  nowIso
+});

package/src/backend/services/cloud-files.js

@@ -0,0 +1,191 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cloud_files_exports = {};
+__export(cloud_files_exports, {
+  NotOnDeviceError: () => NotOnDeviceError,
+  attribSaysOffline: () => attribSaysOffline,
+  cloudRoots: () => cloudRoots,
+  findPlace: () => findPlace,
+  forgetCloudRoots: () => forgetCloudRoots,
+  isPlaceholder: () => isPlaceholder,
+  isPosixPlaceholder: () => isPosixPlaceholder,
+  macRoots: () => macRoots,
+  underCloudRoot: () => underCloudRoot,
+  windowsRoots: () => windowsRoots
+});
+module.exports = __toCommonJS(cloud_files_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_os = __toESM(require("node:os"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_child_process = require("node:child_process");
+class NotOnDeviceError extends Error {
+  constructor(what) {
+    super(`${what} is not on this device: it is still only in the cloud`);
+  }
+}
+const isDir = (p) => {
+  try {
+    return import_node_fs.default.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+};
+function macRoots(home, list = safeList) {
+  const out = [];
+  const cloud = import_node_path.default.join(home, "Library", "CloudStorage");
+  for (const name of list(cloud)) {
+    const shared = /^OneDrive-SharedLibraries-(.+)$/.exec(name);
+    if (shared) {
+      out.push({ provider: "sharepoint", path: import_node_path.default.join(cloud, name), account: shared[1] });
+      continue;
+    }
+    const one = /^OneDrive-(.+)$/.exec(name);
+    if (one) out.push({ provider: "onedrive", path: import_node_path.default.join(cloud, name), account: one[1] });
+  }
+  for (const name of list(home)) {
+    const legacy = /^OneDrive(?: - (.+))?$/.exec(name);
+    if (legacy) out.push({ provider: "onedrive", path: import_node_path.default.join(home, name), account: legacy[1] ?? null });
+  }
+  return out;
+}
+function windowsRoots(env, regOutput) {
+  const out = [];
+  const accountOf = (p) => /OneDrive - (.+)$/.exec(import_node_path.default.win32.basename(p))?.[1] ?? null;
+  for (const key of ["OneDriveCommercial", "OneDriveConsumer", "OneDrive"]) {
+    const p = env[key];
+    if (p) out.push({ provider: "onedrive", path: p, account: key === "OneDriveConsumer" ? "Personal" : accountOf(p) });
+  }
+  for (const m of regOutput.matchAll(/^\s*MountPoint\s+REG_\w+\s+(.+?)\s*$/gm)) {
+    const p = m[1];
+    const isOneDrive = /[\\/]OneDrive(?: - [^\\/]+)?$/i.test(p);
+    out.push({ provider: isOneDrive ? "onedrive" : "sharepoint", path: p, account: isOneDrive ? accountOf(p) : import_node_path.default.win32.basename(import_node_path.default.win32.dirname(p)) || null });
+  }
+  return out;
+}
+function safeList(dir) {
+  try {
+    return import_node_fs.default.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+function cloudRoots() {
+  const forced = process.env.CODETRELLIS_CLOUD_ROOTS;
+  let roots;
+  if (forced !== void 0) {
+    try {
+      roots = JSON.parse(forced).filter((r) => r && (r.provider === "onedrive" || r.provider === "sharepoint") && typeof r.path === "string");
+    } catch {
+      roots = [];
+    }
+  } else if (process.platform === "darwin") {
+    roots = macRoots(import_node_os.default.homedir());
+  } else if (process.platform === "win32") {
+    let reg = "";
+    try {
+      reg = (0, import_node_child_process.execFileSync)("reg", ["query", "HKCU\\Software\\SyncEngines\\Providers\\OneDrive", "/s", "/v", "MountPoint"], {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 5e3,
+        windowsHide: true
+      });
+    } catch {
+    }
+    roots = windowsRoots(process.env, reg);
+  } else {
+    const p = import_node_path.default.join(import_node_os.default.homedir(), "OneDrive");
+    roots = isDir(p) ? [{ provider: "onedrive", path: p, account: null }] : [];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return roots.filter((r) => isDir(r.path)).filter((r) => {
+    const k = import_node_path.default.resolve(r.path).toLowerCase();
+    if (seen.has(k)) return false;
+    seen.add(k);
+    return true;
+  }).sort((a, b) => a.provider === b.provider ? a.path.localeCompare(b.path) : a.provider === "onedrive" ? -1 : 1);
+}
+function findPlace(provider, place, roots = cloudRoots()) {
+  const parts = place.split("/").filter(Boolean);
+  for (const r of roots) {
+    if (r.provider !== provider) continue;
+    const candidate = import_node_path.default.join(r.path, ...parts);
+    if (isDir(candidate)) return candidate;
+  }
+  return null;
+}
+function isPosixPlaceholder(st) {
+  return st.isFile() && st.size > 0 && st.blocks === 0;
+}
+function attribSaysOffline(attribLine) {
+  const m = /^(.*?)\s+(?:[A-Za-z]:\\|\\\\)/.exec(attribLine);
+  return /\bO\b/.test(m?.[1] ?? "");
+}
+let rootsCache = null;
+function cachedRoots() {
+  if (!rootsCache || Date.now() - rootsCache.at > 3e4) rootsCache = { at: Date.now(), roots: cloudRoots() };
+  return rootsCache.roots;
+}
+function forgetCloudRoots() {
+  rootsCache = null;
+}
+function underCloudRoot(file, roots = cachedRoots()) {
+  const f = import_node_path.default.resolve(file);
+  return roots.some((r) => {
+    const rel = import_node_path.default.relative(import_node_path.default.resolve(r.path), f);
+    return rel !== "" && !rel.startsWith("..") && !import_node_path.default.isAbsolute(rel);
+  });
+}
+function isPlaceholder(file) {
+  let st;
+  try {
+    st = import_node_fs.default.statSync(file);
+  } catch {
+    return false;
+  }
+  if (process.platform !== "win32") return isPosixPlaceholder(st) && underCloudRoot(file);
+  if (!st.isFile()) return false;
+  try {
+    const out = (0, import_node_child_process.execFileSync)("attrib", [file], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"], timeout: 5e3, windowsHide: true });
+    return attribSaysOffline(out.split(/\r?\n/)[0] ?? "");
+  } catch {
+    return false;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NotOnDeviceError,
+  attribSaysOffline,
+  cloudRoots,
+  findPlace,
+  forgetCloudRoots,
+  isPlaceholder,
+  isPosixPlaceholder,
+  macRoots,
+  underCloudRoot,
+  windowsRoots
+});