codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/mobile-workstreams.js

@@ -0,0 +1,160 @@
+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 mobile_workstreams_exports = {};
+__export(mobile_workstreams_exports, {
+  PHONE_TURNS: () => PHONE_TURNS,
+  WORKSTREAM_METHODS: () => WORKSTREAM_METHODS,
+  handleWorkstreamMethod: () => handleWorkstreamMethod,
+  phoneTaskWorkstreams: () => phoneTaskWorkstreams,
+  phoneWorkstream: () => phoneWorkstream,
+  phoneWorkstreams: () => phoneWorkstreams
+});
+module.exports = __toCommonJS(mobile_workstreams_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_workstream_service = require("./workstream-service");
+var import_task_workstreams = require("./task-workstreams");
+var import_awareness_service = require("./awareness-service");
+var import_agent_event_log = require("./agent-event-log");
+var import_database = require("./database");
+var import_workstream_words = require("../../shared/lib/workstream-words");
+var import_agent_turns = require("../../shared/lib/agent-turns");
+const WORKSTREAM_METHODS = ["workstreams.list", "workstreams.detail"];
+const PHONE_TURNS = 10;
+async function handleWorkstreamMethod(method, params, _peer, ctx) {
+  switch (method) {
+    case "workstreams.list":
+      return { projectRoot: ctx.projectRoot, workstreams: await phoneWorkstreams(ctx.projectRoot), tasks: phoneTaskWorkstreams(ctx.projectRoot) };
+    case "workstreams.detail": {
+      const id = params.id;
+      if (typeof id !== "string" || !id) throw new Error("id is required");
+      return { workstream: await phoneWorkstream(ctx.projectRoot, id) };
+    }
+    default:
+      throw new Error(`Unknown workstream method: ${method}`);
+  }
+}
+async function phoneWorkstreams(projectRoot) {
+  if (!projectRoot) return [];
+  return (await (0, import_workstream_service.listWorkstreams)(projectRoot)).map((w) => toPhone(projectRoot, w));
+}
+function phoneTaskWorkstreams(projectRoot) {
+  if (!projectRoot) return [];
+  return (0, import_task_workstreams.listTaskWorkstreams)(projectRoot).map((t) => {
+    const signals = (0, import_awareness_service.listSignals)(projectRoot, { workstream: t.id });
+    return {
+      id: t.id,
+      itemUid: t.itemUid,
+      name: (0, import_task_workstreams.taskLabel)(t),
+      planUid: t.planUid,
+      planTitle: t.planTitle,
+      status: t.status,
+      agents: t.agents.map((a) => ({ agentType: a.agentType, model: a.model, lastSeen: a.lastSeen })),
+      materials: t.materials,
+      outputs: t.outputs,
+      signals: signals.filter((s) => s.state !== "intended" && s.state !== "dismissed").length,
+      needsYou: signals.filter((s) => s.state === "open" && s.severity !== "low").length
+    };
+  });
+}
+async function phoneWorkstream(projectRoot, id) {
+  if (!projectRoot) throw new Error("No project is open on the desktop");
+  const w = (await (0, import_workstream_service.listWorkstreams)(projectRoot, { includeIdle: true })).find((x) => x.root === id);
+  if (!w) throw new Error("No such workstream in this project");
+  return {
+    ...toPhone(projectRoot, w),
+    files: w.changes.files.map((f) => ({
+      path: f.path,
+      status: f.status,
+      ...typeof f.added === "number" ? { added: f.added } : {},
+      ...typeof f.removed === "number" ? { removed: f.removed } : {}
+    })),
+    truncated: w.changes.truncated,
+    ...typeof w.changes.ahead === "number" ? { ahead: w.changes.ahead } : {},
+    ...typeof w.changes.behind === "number" ? { behind: w.changes.behind } : {},
+    turns: turnsIn(w)
+  };
+}
+function toPhone(projectRoot, w) {
+  const signals = w.root.startsWith("branch:") ? [] : (0, import_awareness_service.listSignals)(projectRoot, { workstream: w.root });
+  return {
+    id: w.root,
+    name: (0, import_workstream_words.chipLabel)(w),
+    branch: w.branch,
+    shape: w.shape,
+    main: w.main,
+    agents: w.agents.map((a) => ({ agentType: a.agentType, model: a.model, source: a.source, lastSeen: a.lastSeen })),
+    tasks: tasksOf(w),
+    changedFiles: w.changes.files.length,
+    signals: signals.filter((s) => s.state !== "intended" && s.state !== "dismissed").length,
+    needsYou: signals.filter((s) => s.state === "open" && s.severity !== "low").length
+  };
+}
+function tasksOf(w) {
+  const sessions = w.agents.map((a) => a.sessionId);
+  if (sessions.length === 0) return [];
+  const res = (0, import_database.getDb)().exec(
+    `SELECT uid, title, plan_uid, status FROM plan_items
+      WHERE assignee_session IN (${sessions.map(() => "?").join(",")}) AND status IN ('assigned', 'in_progress')
+      ORDER BY updated_at DESC`,
+    sessions
+  );
+  return (res[0]?.values ?? []).map(([uid, title, planUid, status]) => ({ uid, title, planUid, status }));
+}
+function turnsIn(w) {
+  if (w.root.startsWith("branch:")) return [];
+  const roots = /* @__PURE__ */ new Set([w.root]);
+  try {
+    roots.add(import_node_fs.default.realpathSync.native(w.root));
+  } catch {
+  }
+  const events = [...roots].flatMap((r) => (0, import_agent_event_log.listAgentEvents)({ workstreamRoot: r, limit: 300 }));
+  const seen = /* @__PURE__ */ new Set();
+  const unique = events.filter((e) => seen.has(e.id) ? false : (seen.add(e.id), true));
+  const withSession = unique.map((e) => ({ ...e, payload: { ...e.payload, sessionId: e.sessionId ?? e.payload.sessionId, agentType: e.agentType ?? e.payload.agentType } }));
+  const named = new Map(w.agents.map((a) => [a.sessionId, a.agentType]));
+  return (0, import_agent_turns.groupIntoTurns)(withSession).slice(-PHONE_TURNS).reverse().map((t) => ({
+    sessionId: t.sessionId,
+    agentType: t.sessionId && named.get(t.sessionId) || t.agentType,
+    startedAt: t.startedAt,
+    endedAt: t.endedAt,
+    summary: t.summary,
+    calls: t.events.length,
+    files: t.files,
+    hasError: t.hasError,
+    mutating: t.mutating
+  }));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PHONE_TURNS,
+  WORKSTREAM_METHODS,
+  handleWorkstreamMethod,
+  phoneTaskWorkstreams,
+  phoneWorkstream,
+  phoneWorkstreams
+});

package/src/backend/services/monorepo-detector.js

@@ -0,0 +1,131 @@
+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 monorepo_detector_exports = {};
+__export(monorepo_detector_exports, {
+  detectMonorepo: () => detectMonorepo
+});
+module.exports = __toCommonJS(monorepo_detector_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+function detectMonorepo(rootPath) {
+  const type = detectType(rootPath);
+  const packages = discoverPackages(rootPath, type);
+  const dependencyGraph = buildDependencyGraph(packages);
+  return { type, root: rootPath, packages, dependencyGraph };
+}
+function detectType(rootPath) {
+  if (import_node_fs.default.existsSync(import_node_path.default.join(rootPath, "pnpm-workspace.yaml"))) {
+    return "pnpm-workspaces";
+  }
+  if (import_node_fs.default.existsSync(import_node_path.default.join(rootPath, "nx.json"))) {
+    return "nx";
+  }
+  if (import_node_fs.default.existsSync(import_node_path.default.join(rootPath, "turbo.json"))) {
+    return "turborepo";
+  }
+  const pkgPath = import_node_path.default.join(rootPath, "package.json");
+  if (import_node_fs.default.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(import_node_fs.default.readFileSync(pkgPath, "utf-8"));
+      if (pkg.workspaces) return "npm-workspaces";
+    } catch {
+    }
+  }
+  return "single";
+}
+function discoverPackages(rootPath, type) {
+  if (type === "single") {
+    return [readPackageInfo(rootPath)].filter(Boolean);
+  }
+  const patterns = getWorkspacePatterns(rootPath, type);
+  const packages = [];
+  for (const pattern of patterns) {
+    const basePath = pattern.replace(/\/?\*.*$/, "");
+    const fullBase = import_node_path.default.join(rootPath, basePath);
+    if (!import_node_fs.default.existsSync(fullBase)) continue;
+    const entries = import_node_fs.default.readdirSync(fullBase, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith(".")) continue;
+      const pkgDir = import_node_path.default.join(fullBase, entry.name);
+      const info = readPackageInfo(pkgDir);
+      if (info) packages.push(info);
+    }
+  }
+  return packages;
+}
+function getWorkspacePatterns(rootPath, type) {
+  if (type === "pnpm-workspaces") {
+    try {
+      const content = import_node_fs.default.readFileSync(import_node_path.default.join(rootPath, "pnpm-workspace.yaml"), "utf-8");
+      const matches = content.match(/- ['"]?([^'"]+)['"]?/g);
+      return matches?.map((m) => m.replace(/^- ['"]?/, "").replace(/['"]?$/, "")) || [];
+    } catch {
+      return [];
+    }
+  }
+  try {
+    const pkg = JSON.parse(import_node_fs.default.readFileSync(import_node_path.default.join(rootPath, "package.json"), "utf-8"));
+    const workspaces = Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces?.packages || [];
+    return workspaces;
+  } catch {
+    return [];
+  }
+}
+function readPackageInfo(pkgDir) {
+  const pkgPath = import_node_path.default.join(pkgDir, "package.json");
+  if (!import_node_fs.default.existsSync(pkgPath)) return null;
+  try {
+    const pkg = JSON.parse(import_node_fs.default.readFileSync(pkgPath, "utf-8"));
+    return {
+      name: pkg.name || import_node_path.default.basename(pkgDir),
+      path: pkgDir,
+      version: pkg.version || "0.0.0",
+      dependencies: pkg.dependencies || {},
+      devDependencies: pkg.devDependencies || {}
+    };
+  } catch {
+    return null;
+  }
+}
+function buildDependencyGraph(packages) {
+  const names = new Set(packages.map((p) => p.name));
+  const graph = /* @__PURE__ */ new Map();
+  for (const pkg of packages) {
+    const deps = [
+      ...Object.keys(pkg.dependencies),
+      ...Object.keys(pkg.devDependencies)
+    ].filter((d) => names.has(d));
+    graph.set(pkg.name, deps);
+  }
+  return graph;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  detectMonorepo
+});

package/src/backend/services/other-work.js

@@ -0,0 +1,45 @@
+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 other_work_exports = {};
+__export(other_work_exports, {
+  affectedByOtherWork: () => affectedByOtherWork
+});
+module.exports = __toCommonJS(other_work_exports);
+var import_awareness_service = require("./awareness-service");
+var import_task_workstreams = require("./task-workstreams");
+var import_signal_words = require("../../shared/lib/signal-words");
+async function affectedByOtherWork(itemUid, projectRoot, opts = {}) {
+  if (!projectRoot) return [];
+  if (opts.refresh) {
+    await (0, import_awareness_service.refreshSignals)(projectRoot).catch(() => {
+    });
+  }
+  const id = (0, import_task_workstreams.taskWorkstreamId)(itemUid);
+  return (0, import_awareness_service.listSignals)(projectRoot).filter((s) => s.subject.material && s.workstreams.includes(id) && s.state !== "dismissed").map((s) => ({
+    signal_id: s.id,
+    kind: (0, import_signal_words.kindWords)(s),
+    severity: s.severity,
+    state: s.state,
+    says: (0, import_signal_words.briefLine)(s, id),
+    other_tasks: s.workstreams.filter((w) => w !== id).map((w) => s.subject.labels?.[w] ?? w)
+  }));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  affectedByOtherWork
+});

package/src/backend/services/pack-seal.js

@@ -0,0 +1,129 @@
+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 pack_seal_exports = {};
+__export(pack_seal_exports, {
+  EVIDENCE_NAMESPACE: () => EVIDENCE_NAMESPACE,
+  PACK_NAMESPACE: () => PACK_NAMESPACE,
+  checkDocumentSeal: () => checkDocumentSeal,
+  checkSeal: () => checkSeal,
+  sealBytes: () => sealBytes,
+  sealDocument: () => sealDocument,
+  sealPack: () => sealPack
+});
+module.exports = __toCommonJS(pack_seal_exports);
+var import_database = require("./database");
+var import_signing = require("./task-records/signing");
+var import_trust = require("./task-records/trust");
+var import_record_chain = require("./record-chain");
+const PACK_NAMESPACE = "codetrellis-signoff-pack";
+const EVIDENCE_NAMESPACE = "codetrellis-evidence";
+function sealBytes(pack, namespace = PACK_NAMESPACE) {
+  const { seal: _seal, ...rest } = pack;
+  return `${namespace}
+${(0, import_signing.canonicalJson)(JSON.parse(JSON.stringify(rest)))}`;
+}
+function sealDocument(namespace, doc) {
+  const key = (0, import_trust.deviceKey)();
+  const { seal: _old, ...rest } = doc;
+  const body = { ...rest, sealedRecord: (0, import_record_chain.recordHead)() };
+  const value = (0, import_signing.signWithDevice)(key, sealBytes(body, namespace)).value;
+  return { ...body, seal: { how: "device", key: key.fingerprint, publicKey: key.publicKey, value } };
+}
+function sealPack(pack) {
+  return sealDocument(PACK_NAMESPACE, pack);
+}
+function parseSeal(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const s = raw;
+  if (s.how !== "device" || typeof s.key !== "string" || typeof s.publicKey !== "string" || typeof s.value !== "string") return null;
+  if (s.publicKey.length > 200 || s.value.length > 200) return null;
+  return { how: "device", key: s.key, publicKey: s.publicKey, value: s.value };
+}
+function parseRecord(raw) {
+  const r = raw;
+  return r && Number.isInteger(r.seq) && r.seq >= 0 && typeof r.hash === "string" && /^[0-9a-f]{64}$/.test(r.hash) ? { seq: r.seq, hash: r.hash } : null;
+}
+function recordState(seq, hash) {
+  const db = (0, import_database.getDb)();
+  const link = db.exec("SELECT hash FROM record_chain WHERE seq = ?", [seq])[0]?.values[0];
+  if (link) return String(link[0]) === hash ? "matches" : "differs";
+  const anchor = db.exec("SELECT through_seq, hash FROM record_anchor WHERE id = 1")[0]?.values[0];
+  if (anchor && Number(anchor[0]) === seq) return String(anchor[1]) === hash ? "matches" : "differs";
+  if (anchor && Number(anchor[0]) > seq) return "trimmed";
+  return seq === 0 ? "matches" : "differs";
+}
+const RECORD_WORDS = {
+  matches: "the record it names is still here and unchanged",
+  trimmed: "the record it names has since been removed by retention",
+  differs: "but the record it names has changed since",
+  "not-here": "the record it names is on that computer"
+};
+function checkSeal(pack) {
+  return checkDocumentSeal(PACK_NAMESPACE, "pack", pack);
+}
+function checkDocumentSeal(namespace, noun, doc) {
+  const p = doc && typeof doc === "object" ? doc : {};
+  const seal = parseSeal(p.seal);
+  if (!seal) {
+    return { state: "unsigned", fingerprint: null, signer: null, record: null, words: noun === "pack" ? "This pack is not signed: it was made before packs were signed, or its signature was removed." : "This export is not signed: its signature was removed." };
+  }
+  const short = `${(0, import_signing.shortFingerprint)(seal.key)}\u2026`;
+  const record = parseRecord(p.sealedRecord);
+  const intact = record !== null && (0, import_signing.fingerprintOf)(seal.publicKey) === seal.key && (0, import_signing.verifyWithDevice)(seal.publicKey, sealBytes(p, namespace), seal.value);
+  if (!intact) {
+    return { state: "changed", fingerprint: seal.key, signer: null, record: null, words: `Changed after it was signed: this ${noun} no longer matches its signature (key ${short}).` };
+  }
+  const mine = (0, import_trust.deviceKey)().fingerprint === seal.key;
+  if (mine) {
+    const state = recordState(record.seq, record.hash);
+    return {
+      state: "this-computer",
+      fingerprint: seal.key,
+      signer: null,
+      record: { ...record, state },
+      words: record.seq === 0 ? `Signed by this computer (${short}), and unchanged since; the record was empty when it was signed.` : `Signed by this computer (${short}), and unchanged since; ${RECORD_WORDS[state]} (entry #${record.seq}).`
+    };
+  }
+  const teammate = (0, import_database.getDb)().exec("SELECT name FROM task_record_keys WHERE fingerprint = ? AND state = 'trusted' LIMIT 1", [seal.key])[0]?.values[0];
+  if (teammate) {
+    return {
+      state: "teammate",
+      fingerprint: seal.key,
+      signer: String(teammate[0]),
+      record: { ...record, state: "not-here" },
+      words: `Signed by ${String(teammate[0])}'s computer (${short}), a key you trust, and unchanged since; ${RECORD_WORDS["not-here"]} (entry #${record.seq}).`
+    };
+  }
+  return {
+    state: "unknown-key",
+    fingerprint: seal.key,
+    signer: null,
+    record: { ...record, state: "not-here" },
+    words: `Signed by a key this computer does not know (${short}): unchanged since it was signed, but who signed it is not proven. Check the fingerprint with whoever sent it.`
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EVIDENCE_NAMESPACE,
+  PACK_NAMESPACE,
+  checkDocumentSeal,
+  checkSeal,
+  sealBytes,
+  sealDocument,
+  sealPack
+});

package/src/backend/services/paired-device-service.js

@@ -0,0 +1,192 @@
+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 paired_device_service_exports = {};
+__export(paired_device_service_exports, {
+  _resetCache: () => _resetCache,
+  getPairedDevice: () => getPairedDevice,
+  linkInstanceId: () => linkInstanceId,
+  listPairedDevices: () => listPairedDevices,
+  onDeviceGrantsChanged: () => onDeviceGrantsChanged,
+  refreshDeviceFingerprint: () => refreshDeviceFingerprint,
+  removePairedDevice: () => removePairedDevice,
+  renamePairedDevice: () => renamePairedDevice,
+  setDeviceCapabilities: () => setDeviceCapabilities,
+  touchPairedDevice: () => touchPairedDevice,
+  upsertPairedDevice: () => upsertPairedDevice
+});
+module.exports = __toCommonJS(paired_device_service_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_persistence = require("./persistence");
+var import_peer_capabilities = require("./peer-capabilities");
+var import_peer_audit_service = require("./peer-audit-service");
+function getPairedDevicesPath() {
+  return import_node_path.default.join((0, import_persistence.getSettingsDir)(), "paired-devices.json");
+}
+let devices = null;
+function ensureLoaded() {
+  if (devices) return devices;
+  const filePath = getPairedDevicesPath();
+  if (!import_node_fs.default.existsSync(filePath)) {
+    devices = [];
+    return devices;
+  }
+  try {
+    const raw = JSON.parse(import_node_fs.default.readFileSync(filePath, "utf-8"));
+    if (Array.isArray(raw)) {
+      devices = raw;
+    } else {
+      console.warn("[PairedDevices] Invalid format \u2014 starting fresh");
+      devices = [];
+    }
+  } catch (err) {
+    console.warn("[PairedDevices] Failed to read paired-devices.json:", err);
+    devices = [];
+  }
+  return devices;
+}
+function persist() {
+  const filePath = getPairedDevicesPath();
+  const dir = import_node_path.default.dirname(filePath);
+  if (!import_node_fs.default.existsSync(dir)) {
+    import_node_fs.default.mkdirSync(dir, { recursive: true });
+  }
+  try {
+    import_node_fs.default.writeFileSync(filePath, JSON.stringify(devices, null, 2), "utf-8");
+  } catch (err) {
+    console.error("[PairedDevices] Failed to write paired-devices.json:", err);
+  }
+}
+function listPairedDevices() {
+  return [...ensureLoaded()];
+}
+function getPairedDevice(fingerprint) {
+  return ensureLoaded().find((d) => d.fingerprint === fingerprint);
+}
+function upsertPairedDevice(device) {
+  const list = ensureLoaded();
+  const idx = list.findIndex((d) => d.fingerprint === device.fingerprint);
+  if (idx >= 0) {
+    list[idx] = device;
+  } else {
+    list.push(device);
+  }
+  persist();
+  console.log(`[PairedDevices] ${idx >= 0 ? "Updated" : "Added"} device: ${device.alias} (${device.fingerprint.slice(0, 12)}\u2026)`);
+}
+function removePairedDevice(fingerprint) {
+  const list = ensureLoaded();
+  const idx = list.findIndex((d) => d.fingerprint === fingerprint);
+  if (idx < 0) return false;
+  const removed = list.splice(idx, 1)[0];
+  persist();
+  console.log(`[PairedDevices] Removed device: ${removed.alias} (${fingerprint.slice(0, 12)}\u2026)`);
+  return true;
+}
+function touchPairedDevice(fingerprint) {
+  const device = ensureLoaded().find((d) => d.fingerprint === fingerprint);
+  if (device) {
+    device.lastConnected = (/* @__PURE__ */ new Date()).toISOString();
+    persist();
+  }
+}
+function renamePairedDevice(fingerprint, alias) {
+  const device = ensureLoaded().find((d) => d.fingerprint === fingerprint);
+  if (!device) return false;
+  device.alias = alias;
+  persist();
+  return true;
+}
+const grantsListeners = /* @__PURE__ */ new Set();
+function onDeviceGrantsChanged(cb) {
+  grantsListeners.add(cb);
+  return () => {
+    grantsListeners.delete(cb);
+  };
+}
+function setDeviceCapabilities(fingerprint, capabilities) {
+  const device = ensureLoaded().find((d) => d.fingerprint === fingerprint);
+  if (!device) return null;
+  const valid = [...new Set(capabilities)].filter(
+    (c) => import_peer_capabilities.ALL_CAPABILITIES.includes(c)
+  );
+  const before = device.capabilities ?? [...import_peer_capabilities.DEFAULT_GRANTS];
+  const added = valid.filter((c) => !before.includes(c));
+  const removed = before.filter((c) => !valid.includes(c));
+  device.capabilities = valid;
+  persist();
+  if (added.length || removed.length) {
+    (0, import_peer_audit_service.recordPeerAudit)({
+      kind: "capability-change",
+      fingerprint,
+      alias: device.alias,
+      method: "settings.deviceCapabilities",
+      detail: [
+        added.length ? `granted ${added.join(", ")}` : "",
+        removed.length ? `revoked ${removed.join(", ")}` : ""
+      ].filter(Boolean).join("; ")
+    });
+    for (const cb of grantsListeners) {
+      try {
+        cb(fingerprint, added, removed);
+      } catch {
+      }
+    }
+  }
+  return valid;
+}
+function refreshDeviceFingerprint(pairingId, fingerprint) {
+  const device = ensureLoaded().find((d) => d.pairingId === pairingId);
+  if (!device || !fingerprint || device.fingerprint === fingerprint) return;
+  device.fingerprint = fingerprint;
+  persist();
+}
+function linkInstanceId(fingerprint, instanceId) {
+  const device = ensureLoaded().find((d) => d.fingerprint === fingerprint);
+  if (device) {
+    device.instanceId = instanceId;
+    persist();
+  }
+}
+function _resetCache() {
+  devices = null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  _resetCache,
+  getPairedDevice,
+  linkInstanceId,
+  listPairedDevices,
+  onDeviceGrantsChanged,
+  refreshDeviceFingerprint,
+  removePairedDevice,
+  renamePairedDevice,
+  setDeviceCapabilities,
+  touchPairedDevice,
+  upsertPairedDevice
+});