codetrellis 0.0.0-stage → 0.3.0

package/src/backend/services/peer-connection-service.js

@@ -0,0 +1,450 @@
+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 peer_connection_service_exports = {};
+__export(peer_connection_service_exports, {
+  broadcastAgentSessions: () => import_remote_interaction_service2.broadcastAgentSessions,
+  broadcastAudioStatus: () => import_remote_audio_service2.broadcastAudioStatus,
+  broadcastAudioStopped: () => import_remote_audio_service2.broadcastAudioStopped,
+  broadcastChannelEvent: () => import_remote_interaction_service2.broadcastChannelEvent,
+  broadcastChannelResolved: () => import_remote_interaction_service2.broadcastChannelResolved,
+  broadcastInputRequest: () => import_remote_interaction_service2.broadcastInputRequest,
+  broadcastToAllPeers: () => import_webrtc_service.broadcastToAllPeers,
+  cancelActivePairing: () => cancelActivePairing,
+  collectSnapshot: () => import_state_sync_service2.collectSnapshot,
+  completePairing: () => completePairing,
+  completeReconnection: () => completeReconnection,
+  disconnect: () => disconnect,
+  forwardAudioChunk: () => import_remote_audio_service2.forwardAudioChunk,
+  getAllRemoteStates: () => import_state_sync_service2.getAllRemoteStates,
+  getConnectedCount: () => getConnectedCount,
+  getConnection: () => getConnection,
+  getConnections: () => getConnections,
+  getDevice: () => getDevice,
+  getDevices: () => getDevices,
+  getDiscoveredDevices: () => getDiscoveredDevices,
+  getPairingConfirmCode: () => getPairingConfirmCode,
+  getPeerManagerStatus: () => getPeerManagerStatus,
+  getPendingInputRequest: () => import_remote_interaction_service2.getPendingInputRequest,
+  getPendingInputRequests: () => import_remote_interaction_service2.getPendingInputRequests,
+  getRemoteAudioStatus: () => import_remote_audio_service2.getRemoteAudioStatus,
+  getRemoteAudioStatuses: () => import_remote_audio_service2.getRemoteAudioStatuses,
+  getRemoteState: () => import_state_sync_service2.getRemoteState,
+  getRemoteTerminals: () => import_remote_terminal_service2.getRemoteTerminals,
+  getRemoteTerminalsForPeer: () => import_remote_terminal_service2.getRemoteTerminalsForPeer,
+  getThisInstanceId: () => getThisInstanceId,
+  isDiscoveryActive: () => isDiscoveryActive,
+  isPairingActive: () => import_pairing_service2.isPairingActive,
+  isPushNotificationsRunning: () => import_push_notification_service2.isPushNotificationsRunning,
+  isRemoteAudioRunning: () => import_remote_audio_service2.isRemoteAudioRunning,
+  isRemoteInteractionRunning: () => import_remote_interaction_service2.isRemoteInteractionRunning,
+  isRemoteTerminalRunning: () => import_remote_terminal_service2.isRemoteTerminalRunning,
+  isStateSyncRunning: () => import_state_sync_service2.isStateSyncRunning,
+  issueReconnectChallenge: () => issueReconnectChallenge,
+  listPushTokens: () => import_push_notification_service2.listPushTokens,
+  onChannelMessage: () => import_webrtc_service.onChannelMessage,
+  onConnectionStateChange: () => import_webrtc_service.onConnectionStateChange,
+  onRemoteAudioEvent: () => import_remote_audio_service2.onRemoteAudioEvent,
+  onRemoteChannelEvent: () => import_remote_interaction_service2.onRemoteChannelEvent,
+  onRemoteInteractionEvent: () => import_remote_interaction_service2.onRemoteInteractionEvent,
+  onRemoteStateChange: () => import_state_sync_service2.onRemoteStateChange,
+  onRemoteTerminalEvent: () => import_remote_terminal_service2.onRemoteTerminalEvent,
+  pushForChannelEvent: () => import_push_notification_service2.pushForChannelEvent,
+  pushForInputRequest: () => import_push_notification_service2.pushForInputRequest,
+  registerPushToken: () => import_push_notification_service2.registerPushToken,
+  renameDevice: () => renameDevice,
+  resizeRemoteTerminal: () => import_remote_terminal_service2.resizeRemoteTerminal,
+  respondToInputRequest: () => import_remote_interaction_service2.respondToInputRequest,
+  sendToPeer: () => import_webrtc_service.sendToPeer,
+  startPairing: () => startPairing,
+  startPeerManager: () => startPeerManager,
+  startReconnection: () => startReconnection,
+  stopPeerManager: () => stopPeerManager,
+  unpairDevice: () => unpairDevice,
+  unregisterPushToken: () => import_push_notification_service2.unregisterPushToken,
+  writeRemoteTerminal: () => import_remote_terminal_service2.writeRemoteTerminal
+});
+module.exports = __toCommonJS(peer_connection_service_exports);
+var import_mdns_service = require("./mdns-service");
+var import_paired_device_service = require("./paired-device-service");
+var import_pairing_service = require("./pairing-service");
+var import_webrtc_service = require("./webrtc-service");
+var import_settings_service = require("./settings-service");
+var import_sdp_fingerprint = require("../../shared/lib/sdp-fingerprint");
+var import_peer_auth = require("./peer-auth");
+var import_node_crypto = require("node:crypto");
+var import_state_sync_service = require("./state-sync-service");
+var import_remote_terminal_service = require("./remote-terminal-service");
+var import_remote_audio_service = require("./remote-audio-service");
+var import_remote_interaction_service = require("./remote-interaction-service");
+var import_push_notification_service = require("./push-notification-service");
+var import_mobile_rpc_service = require("./mobile-rpc-service");
+var import_mobile_api_server = require("./mobile-api-server");
+var import_pairing_service2 = require("./pairing-service");
+var import_state_sync_service2 = require("./state-sync-service");
+var import_remote_terminal_service2 = require("./remote-terminal-service");
+var import_remote_audio_service2 = require("./remote-audio-service");
+var import_remote_interaction_service2 = require("./remote-interaction-service");
+var import_push_notification_service2 = require("./push-notification-service");
+let started = false;
+async function startPeerManager() {
+  if (started) return;
+  started = true;
+  const settings = (0, import_settings_service.getSettings)();
+  const deviceName = settings.device.deviceName || void 0;
+  let mobilePort = 0;
+  if (settings.device.exposeMobileApi) {
+    try {
+      mobilePort = await (0, import_mobile_api_server.startMobileApiServer)();
+      console.log("[PeerManager] Mobile API exposed on the local network (user-enabled)");
+    } catch (err) {
+      console.warn("[PeerManager] Mobile API server failed to start:", err);
+    }
+  } else {
+    console.log("[PeerManager] Mobile API NOT exposed \u2014 enable it in Settings \u2192 Devices to pair a phone");
+  }
+  if (settings.device.advertise) {
+    (0, import_mdns_service.startMdns)(deviceName, void 0, mobilePort);
+  }
+  (0, import_mdns_service.onPeerDiscovered)((peer) => {
+    const paired = (0, import_paired_device_service.listPairedDevices)().find(
+      (d) => d.fingerprint === peer.fingerprint
+    );
+    if (paired) {
+      console.log(`[PeerManager] Discovered known device "${peer.name}" \u2014 will attempt auto-reconnect`);
+      (0, import_paired_device_service.linkInstanceId)(paired.fingerprint, peer.instanceId);
+    }
+  });
+  (0, import_webrtc_service.onConnectionStateChange)((fingerprint, state) => {
+    if (state === "connected") {
+      (0, import_paired_device_service.touchPairedDevice)(fingerprint);
+    }
+    console.log(`[PeerManager] Peer ${fingerprint.slice(0, 12)}\u2026 \u2192 ${state}`);
+  });
+  const myInstanceId = (0, import_mdns_service.getInstanceId)();
+  (0, import_state_sync_service.startStateSync)(myInstanceId);
+  (0, import_remote_terminal_service.startRemoteTerminals)();
+  (0, import_remote_audio_service.startRemoteAudio)();
+  (0, import_remote_interaction_service.startRemoteInteraction)(myInstanceId);
+  (0, import_push_notification_service.startPushNotifications)();
+  (0, import_mobile_rpc_service.startMobileRpc)();
+  console.log(`[PeerManager] Started (mobileApiPort=${mobilePort || "none"})`);
+}
+async function stopPeerManager() {
+  if (!started) return;
+  started = false;
+  (0, import_mobile_rpc_service.stopMobileRpc)();
+  (0, import_push_notification_service.stopPushNotifications)();
+  (0, import_remote_interaction_service.stopRemoteInteraction)();
+  (0, import_remote_audio_service.stopRemoteAudio)();
+  (0, import_remote_terminal_service.stopRemoteTerminals)();
+  (0, import_state_sync_service.stopStateSync)();
+  (0, import_mobile_api_server.stopMobileApiServer)();
+  (0, import_pairing_service.cancelPairing)();
+  await (0, import_webrtc_service.discardPendingOffer)();
+  await (0, import_webrtc_service.disconnectAllPeers)();
+  (0, import_mdns_service.stopMdns)();
+  console.log("[PeerManager] Stopped");
+}
+function getDiscoveredDevices() {
+  return (0, import_mdns_service.getDiscoveredPeers)();
+}
+function getThisInstanceId() {
+  return (0, import_mdns_service.getInstanceId)();
+}
+function isDiscoveryActive() {
+  return (0, import_mdns_service.isMdnsRunning)();
+}
+async function startPairing() {
+  const { offer, iceCandidates, fingerprint } = await (0, import_webrtc_service.createOffer)();
+  const { qrPayload, waitForAnswer: waitRaw } = await (0, import_pairing_service.initiatePairing)(
+    offer,
+    iceCandidates,
+    fingerprint
+  );
+  const waitForAnswer = async () => {
+    const answer = await waitRaw();
+    const offerSdp = (0, import_pairing_service.getStoredOfferSdp)();
+    if (!offerSdp) throw new Error("Offer SDP lost");
+    await (0, import_webrtc_service.connectWithAnswer)(
+      offerSdp,
+      answer.answerSdp,
+      answer.iceCandidates,
+      answer.fingerprint,
+      "Pending\u2026",
+      // alias set on confirm
+      "mobile"
+    );
+  };
+  return { qrPayload, waitForAnswer };
+}
+function getPairingConfirmCode() {
+  return (0, import_pairing_service.getConfirmationCode)();
+}
+function completePairing(userEnteredCode, deviceAlias, deviceType = "mobile") {
+  const device = (0, import_pairing_service.confirmPairing)(userEnteredCode, deviceAlias, deviceType);
+  if (!device) {
+    return { success: false, error: "Confirmation code mismatch or no active session" };
+  }
+  if (!(0, import_settings_service.getSettings)().device.exposeMobileApi) {
+    (0, import_settings_service.updateSettings)({ device: { exposeMobileApi: true } });
+    console.log(
+      `[PeerManager] Enabled the mobile API for "${deviceAlias}" \u2014 a paired phone needs it to reconnect. Turn it off in Settings \u2192 Devices to stop accepting connections.`
+    );
+    (0, import_mobile_api_server.startMobileApiServer)().then((port) => console.log(`[PeerManager] Mobile API now listening on 0.0.0.0:${port}`)).catch((err) => console.warn("[PeerManager] Mobile API failed to start after pairing:", err));
+  }
+  return { success: true, device };
+}
+function cancelActivePairing() {
+  (0, import_pairing_service.cancelPairing)();
+  (0, import_webrtc_service.discardPendingOffer)().catch(() => {
+  });
+}
+function getDevices() {
+  return (0, import_paired_device_service.listPairedDevices)().map(redactSecret);
+}
+function redactSecret(device) {
+  const { sharedSecret, ...rest } = device;
+  return { ...rest, hasSecret: (0, import_peer_auth.isUsableSecret)(sharedSecret) };
+}
+function getDevice(fingerprint) {
+  const device = (0, import_paired_device_service.getPairedDevice)(fingerprint);
+  return device ? redactSecret(device) : void 0;
+}
+async function unpairDevice(fingerprint) {
+  await (0, import_webrtc_service.disconnectPeer)(fingerprint);
+  return (0, import_paired_device_service.removePairedDevice)(fingerprint);
+}
+function renameDevice(fingerprint, alias) {
+  return (0, import_paired_device_service.renamePairedDevice)(fingerprint, alias);
+}
+function getConnections() {
+  return (0, import_webrtc_service.getPeerConnections)().map(withDeviceName);
+}
+function getConnection(fingerprint) {
+  const c = (0, import_webrtc_service.getPeerConnection)(fingerprint);
+  return c ? withDeviceName(c) : void 0;
+}
+function withDeviceName(c) {
+  const device = (0, import_paired_device_service.getPairedDevice)(c.fingerprint);
+  return device ? { ...c, alias: device.alias, deviceType: device.deviceType } : c;
+}
+async function disconnect(fingerprint) {
+  await (0, import_webrtc_service.disconnectPeer)(fingerprint);
+}
+function getConnectedCount() {
+  return (0, import_webrtc_service.connectedPeerCount)();
+}
+const reconnectOffers = /* @__PURE__ */ new Map();
+function purgeStaleOffers() {
+  const now = Date.now();
+  for (const [fp, entry] of reconnectOffers) {
+    if (now - entry.createdAt > 6e4) {
+      reconnectOffers.delete(fp);
+    }
+  }
+}
+function findByPairingId(pairingId) {
+  return (0, import_paired_device_service.listPairedDevices)().find((d) => d.pairingId === pairingId);
+}
+function issueReconnectChallenge(pairingId) {
+  return (0, import_peer_auth.issueChallenge)(pairingId);
+}
+async function startReconnection(pairingId, proof) {
+  purgeStaleOffers();
+  const paired = pairingId ? findByPairingId(pairingId) : void 0;
+  if (!paired) {
+    console.warn(`[PeerManager] Reconnect rejected \u2014 no device for pairingId=${pairingId?.slice(0, 8) ?? "none"}`);
+    return null;
+  }
+  if (!(0, import_peer_auth.isUsableSecret)(paired.sharedSecret)) {
+    console.warn(
+      `[PeerManager] Reconnect rejected \u2014 "${paired.alias}" was paired before reconnect authentication existed and has no secret. It must be paired again.`
+    );
+    return null;
+  }
+  const verdict = (0, import_peer_auth.verifyChallengeResponse)({
+    pairingId,
+    nonce: proof.nonce,
+    expiresAt: proof.expiresAt,
+    mac: proof.mac,
+    secret: paired.sharedSecret
+  });
+  if (!verdict.ok) {
+    console.warn(`[PeerManager] Reconnect REFUSED for "${paired.alias}" \u2014 ${verdict.reason}`);
+    return null;
+  }
+  const devicePairingId = paired.pairingId;
+  console.log(`[PeerManager] Creating reconnect offer for "${paired.alias}" (pairingId=${devicePairingId.slice(0, 8)}\u2026)`);
+  const { offer, iceCandidates, fingerprint: desktopFp } = await (0, import_webrtc_service.createOffer)();
+  const answerNonce = (0, import_node_crypto.randomBytes)(16).toString("hex");
+  reconnectOffers.set(devicePairingId, {
+    offerSdp: offer,
+    iceCandidates,
+    desktopFingerprint: desktopFp,
+    createdAt: Date.now(),
+    answerNonce
+  });
+  return {
+    offer,
+    iceCandidates,
+    fingerprint: desktopFp,
+    pairingId: devicePairingId,
+    answerNonce,
+    // Prove this certificate is ours. The phone cannot recognise us by the
+    // fingerprint it stored at pairing — werift mints a fresh one on every
+    // process start, so restarting the desktop would otherwise make every
+    // paired device refuse it.
+    offerMac: (0, import_peer_auth.computeReconnectOfferMac)(paired.sharedSecret, devicePairingId, proof.nonce, desktopFp)
+  };
+}
+async function completeReconnection(pairingId, answerSdp, answerIceCandidates, mobileFingerprint, answerMac = "") {
+  const stored = reconnectOffers.get(pairingId);
+  if (!stored) {
+    console.warn(`[PeerManager] No pending reconnect offer for pairingId=${pairingId.slice(0, 8)}\u2026`);
+    return false;
+  }
+  reconnectOffers.delete(pairingId);
+  const paired = findByPairingId(pairingId);
+  if (!paired) return false;
+  let assertedFingerprint;
+  try {
+    assertedFingerprint = (0, import_sdp_fingerprint.extractSingleFingerprint)(answerSdp);
+  } catch (err) {
+    console.warn(
+      `[PeerManager] Reconnect refused \u2014 unusable answer SDP for pairingId=${pairingId.slice(0, 8)}\u2026: ${err.message}`
+    );
+    return false;
+  }
+  if (mobileFingerprint && !(0, import_sdp_fingerprint.fingerprintsEqual)(mobileFingerprint, assertedFingerprint)) {
+    console.warn("[PeerManager] Reconnect refused \u2014 claimed fingerprint disagrees with the certificate presented");
+    return false;
+  }
+  if (!(0, import_peer_auth.isUsableSecret)(paired.sharedSecret)) {
+    console.warn(`[PeerManager] Reconnect refused \u2014 "${paired.alias}" has no pairing secret`);
+    return false;
+  }
+  const expectedMac = (0, import_peer_auth.computeReconnectAnswerMac)(
+    paired.sharedSecret,
+    pairingId,
+    stored.answerNonce,
+    assertedFingerprint
+  );
+  if (!(0, import_peer_auth.macsEqual)(expectedMac, answerMac)) {
+    console.warn(
+      `[PeerManager] Reconnect REFUSED \u2014 the answer for "${paired.alias}" is not signed by the paired device`
+    );
+    return false;
+  }
+  (0, import_paired_device_service.refreshDeviceFingerprint)(pairingId, assertedFingerprint);
+  try {
+    await (0, import_webrtc_service.connectWithAnswer)(
+      stored.offerSdp,
+      answerSdp,
+      answerIceCandidates,
+      assertedFingerprint,
+      paired.alias,
+      paired.deviceType
+    );
+    console.log(`[PeerManager] Reconnection established with "${paired.alias}"`);
+    return true;
+  } catch (err) {
+    console.error(`[PeerManager] Reconnection failed:`, err);
+    return false;
+  }
+}
+function getPeerManagerStatus() {
+  return {
+    running: started,
+    instanceId: (0, import_mdns_service.getInstanceId)(),
+    discoveryActive: isDiscoveryActive(),
+    discoveredPeers: (0, import_mdns_service.getDiscoveredPeers)().length,
+    pairedDevices: (0, import_paired_device_service.listPairedDevices)().length,
+    connectedPeers: (0, import_webrtc_service.connectedPeerCount)(),
+    pairingActive: (0, import_pairing_service.isPairingActive)(),
+    mobileApi: (0, import_mobile_api_server.isMobileApiRunning)(),
+    mobileApiPort: (0, import_mobile_api_server.getMobileApiPort)(),
+    stateSync: (0, import_state_sync_service.isStateSyncRunning)(),
+    remoteTerminals: (0, import_remote_terminal_service.isRemoteTerminalRunning)(),
+    remoteAudio: (0, import_remote_audio_service.isRemoteAudioRunning)(),
+    remoteInteraction: (0, import_remote_interaction_service.isRemoteInteractionRunning)(),
+    pushNotifications: (0, import_push_notification_service.isPushNotificationsRunning)()
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  broadcastAgentSessions,
+  broadcastAudioStatus,
+  broadcastAudioStopped,
+  broadcastChannelEvent,
+  broadcastChannelResolved,
+  broadcastInputRequest,
+  broadcastToAllPeers,
+  cancelActivePairing,
+  collectSnapshot,
+  completePairing,
+  completeReconnection,
+  disconnect,
+  forwardAudioChunk,
+  getAllRemoteStates,
+  getConnectedCount,
+  getConnection,
+  getConnections,
+  getDevice,
+  getDevices,
+  getDiscoveredDevices,
+  getPairingConfirmCode,
+  getPeerManagerStatus,
+  getPendingInputRequest,
+  getPendingInputRequests,
+  getRemoteAudioStatus,
+  getRemoteAudioStatuses,
+  getRemoteState,
+  getRemoteTerminals,
+  getRemoteTerminalsForPeer,
+  getThisInstanceId,
+  isDiscoveryActive,
+  isPairingActive,
+  isPushNotificationsRunning,
+  isRemoteAudioRunning,
+  isRemoteInteractionRunning,
+  isRemoteTerminalRunning,
+  isStateSyncRunning,
+  issueReconnectChallenge,
+  listPushTokens,
+  onChannelMessage,
+  onConnectionStateChange,
+  onRemoteAudioEvent,
+  onRemoteChannelEvent,
+  onRemoteInteractionEvent,
+  onRemoteStateChange,
+  onRemoteTerminalEvent,
+  pushForChannelEvent,
+  pushForInputRequest,
+  registerPushToken,
+  renameDevice,
+  resizeRemoteTerminal,
+  respondToInputRequest,
+  sendToPeer,
+  startPairing,
+  startPeerManager,
+  startReconnection,
+  stopPeerManager,
+  unpairDevice,
+  unregisterPushToken,
+  writeRemoteTerminal
+});

package/src/backend/services/peer-grants.js

@@ -0,0 +1,33 @@
+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 peer_grants_exports = {};
+__export(peer_grants_exports, {
+  peerHolds: () => peerHolds
+});
+module.exports = __toCommonJS(peer_grants_exports);
+var import_paired_device_service = require("./paired-device-service");
+var import_peer_capabilities = require("./peer-capabilities");
+function peerHolds(fingerprint, capability) {
+  const device = (0, import_paired_device_service.getPairedDevice)(fingerprint);
+  if (!device?.confirmedAt) return false;
+  return (device.capabilities ?? import_peer_capabilities.DEFAULT_GRANTS).includes(capability);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  peerHolds
+});

package/src/backend/services/persistence.js

@@ -0,0 +1,116 @@
+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 persistence_exports = {};
+__export(persistence_exports, {
+  ensureDataDir: () => ensureDataDir,
+  getDataDir: () => getDataDir,
+  getSettingsDir: () => getSettingsDir,
+  loadFromDisk: () => loadFromDisk,
+  markDirty: () => markDirty,
+  saveNow: () => saveNow,
+  saveToDisk: () => saveToDisk,
+  startAutoSave: () => startAutoSave,
+  stopAutoSave: () => stopAutoSave
+});
+module.exports = __toCommonJS(persistence_exports);
+var _lazy___settings_service = __toESM(require("./settings-service"));
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_os = __toESM(require("node:os"));
+const DEFAULT_DATA_DIR = import_node_path.default.join(import_node_os.default.homedir(), ".codetrellis");
+function getSettingsDir() {
+  const fromEnv = process.env.CODETRELLIS_DATA_DIR;
+  if (fromEnv && fromEnv.trim()) return fromEnv;
+  return DEFAULT_DATA_DIR;
+}
+function resolveDataDir() {
+  const fromEnv = process.env.CODETRELLIS_DATA_DIR;
+  if (fromEnv && fromEnv.trim()) return fromEnv;
+  try {
+    const { getSettings } = _lazy___settings_service;
+    const override = getSettings().data.dataDirOverride;
+    if (override && typeof override === "string" && override.trim()) return override;
+  } catch {
+  }
+  return DEFAULT_DATA_DIR;
+}
+function getDbPath() {
+  return import_node_path.default.join(resolveDataDir(), "data.db");
+}
+let autoSaveInterval = null;
+function ensureDataDir() {
+  const dir = resolveDataDir();
+  if (!import_node_fs.default.existsSync(dir)) {
+    import_node_fs.default.mkdirSync(dir, { recursive: true });
+    console.log(`[Persistence] Created data directory: ${dir}`);
+  }
+}
+function loadFromDisk() {
+  ensureDataDir();
+  if (!import_node_fs.default.existsSync(getDbPath())) {
+    console.log("[Persistence] No saved database found, starting fresh");
+    return null;
+  }
+  try {
+    const buffer = import_node_fs.default.readFileSync(getDbPath());
+    console.log(`[Persistence] Loaded database from ${getDbPath()} (${(buffer.length / 1024).toFixed(1)} KB)`);
+    return new Uint8Array(buffer);
+  } catch (err) {
+    console.error("[Persistence] Failed to load database:", err);
+    return null;
+  }
+}
+function saveToDisk(_data) {
+}
+function markDirty() {
+}
+function startAutoSave(_exportFn, _intervalMs = 3e4) {
+}
+function saveNow(_exportFn) {
+}
+function stopAutoSave() {
+  if (autoSaveInterval) {
+    clearInterval(autoSaveInterval);
+    autoSaveInterval = null;
+  }
+}
+function getDataDir() {
+  return resolveDataDir();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ensureDataDir,
+  getDataDir,
+  getSettingsDir,
+  loadFromDisk,
+  markDirty,
+  saveNow,
+  saveToDisk,
+  startAutoSave,
+  stopAutoSave
+});