codetrellis 0.0.0-stage → 0.3.0

package/src/backend/services/reference-service.js

@@ -0,0 +1,169 @@
+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 reference_service_exports = {};
+__export(reference_service_exports, {
+  AmbiguousReferenceError: () => AmbiguousReferenceError,
+  describeReference: () => describeReference,
+  findReferenceMatches: () => findReferenceMatches,
+  resolveReferenceArgs: () => resolveReferenceArgs
+});
+module.exports = __toCommonJS(reference_service_exports);
+var import_database = require("./database");
+var import_references = require("../../shared/lib/references");
+const LOOKUPS = [
+  {
+    kinds: ["plan"],
+    sql: `SELECT uid, title FROM plans WHERE REPLACE(uid, '-', '') LIKE ? LIMIT 6`,
+    toMatch: (r) => ({ kind: "plan", uid: String(r[0]), title: String(r[1] ?? "") })
+  },
+  {
+    kinds: ["task", "page"],
+    sql: `SELECT uid, title, kind FROM plan_items WHERE REPLACE(uid, '-', '') LIKE ? LIMIT 6`,
+    toMatch: (r) => ({ kind: r[2] === "object" ? "page" : "task", uid: String(r[0]), title: String(r[1] ?? "") })
+  },
+  {
+    kinds: ["comment"],
+    sql: `SELECT uid, body FROM comments WHERE REPLACE(uid, '-', '') LIKE ? LIMIT 6`,
+    toMatch: (r) => ({ kind: "comment", uid: String(r[0]), title: String(r[1] ?? "").slice(0, 80) })
+  },
+  {
+    kinds: ["attachment"],
+    sql: `SELECT uid, COALESCE(label, value) FROM attachments WHERE REPLACE(uid, '-', '') LIKE ? LIMIT 6`,
+    toMatch: (r) => ({ kind: "attachment", uid: String(r[0]), title: String(r[1] ?? "") })
+  }
+];
+function findReferenceMatches(ref) {
+  const db = (0, import_database.getDb)();
+  const out = [];
+  for (const lookup of LOOKUPS) {
+    if (ref.kind && !lookup.kinds.includes(ref.kind)) continue;
+    const rows = db.exec(lookup.sql, [`${ref.prefix}%`])[0]?.values ?? [];
+    for (const row of rows) {
+      const match = lookup.toMatch(row);
+      if (!ref.kind || match.kind === ref.kind) out.push(match);
+    }
+  }
+  return out;
+}
+class AmbiguousReferenceError extends Error {
+  constructor(raw, candidates) {
+    super(
+      `"${raw}" matches ${candidates.length} things: ` + candidates.slice(0, 5).map((c) => `${(0, import_references.formatReference)(c.kind, c.uid)} (${c.uid})${c.title ? ` "${c.title}"` : ""}`).join("; ") + ". Pass the full uid, or a longer prefix."
+    );
+    this.raw = raw;
+    this.candidates = candidates;
+    this.name = "AmbiguousReferenceError";
+  }
+  raw;
+  candidates;
+}
+const NOTE_LIMIT = 5;
+function notesOn(uid, by = "target_uid") {
+  const rows = (0, import_database.getDb)().exec(
+    `SELECT uid, author, author_type, body, created_at FROM comments
+      WHERE ${by} = ? ORDER BY created_at DESC LIMIT ${NOTE_LIMIT}`,
+    [uid]
+  )[0]?.values ?? [];
+  return rows.map((r) => ({
+    reference: (0, import_references.formatReference)("comment", String(r[0])),
+    author: String(r[1]),
+    authorType: String(r[2]),
+    body: String(r[3]),
+    createdAt: Number(r[4])
+  }));
+}
+function planSummary(planUid) {
+  const row = (0, import_database.getDb)().exec(`SELECT uid, title FROM plans WHERE uid = ?`, [planUid])[0]?.values?.[0];
+  if (!row) return void 0;
+  return { reference: (0, import_references.formatReference)("plan", String(row[0])), uid: String(row[0]), title: String(row[1] ?? "") };
+}
+function targetSummary(uid) {
+  const matches = findReferenceMatches({ kind: null, prefix: uid.replace(/-/g, "").toLowerCase() }).filter((m2) => m2.uid === uid);
+  const m = matches[0];
+  return m ? { reference: (0, import_references.formatReference)(m.kind, m.uid), uid: m.uid, title: m.title } : null;
+}
+function describeReference(m) {
+  const db = (0, import_database.getDb)();
+  const base = {
+    reference: (0, import_references.formatReference)(m.kind, m.uid),
+    kind: m.kind,
+    uid: m.uid,
+    title: m.title,
+    notes: []
+  };
+  if (m.kind === "plan") {
+    const row2 = db.exec(`SELECT status FROM plans WHERE uid = ?`, [m.uid])[0]?.values?.[0];
+    return { ...base, status: row2 ? String(row2[0]) : void 0, notes: notesOn(m.uid) };
+  }
+  if (m.kind === "task" || m.kind === "page") {
+    const row2 = db.exec(`SELECT plan_uid, status FROM plan_items WHERE uid = ?`, [m.uid])[0]?.values?.[0];
+    return {
+      ...base,
+      status: row2 ? String(row2[1]) : void 0,
+      plan: row2 ? planSummary(String(row2[0])) : void 0,
+      notes: notesOn(m.uid)
+    };
+  }
+  if (m.kind === "comment") {
+    const row2 = db.exec(`SELECT target_uid, body FROM comments WHERE uid = ?`, [m.uid])[0]?.values?.[0];
+    return {
+      ...base,
+      body: row2 ? String(row2[1]) : void 0,
+      on: row2 ? targetSummary(String(row2[0])) : null,
+      notes: notesOn(m.uid, "parent_uid")
+      // replies
+    };
+  }
+  const row = db.exec(`SELECT target_uid FROM attachments WHERE uid = ?`, [m.uid])[0]?.values?.[0];
+  return { ...base, on: row ? targetSummary(String(row[0])) : null };
+}
+function kindsForArg(key) {
+  if (/(^|_)plan_uids?$/.test(key)) return ["plan"];
+  if (/comment_uid$/.test(key)) return ["comment"];
+  if (/attachment_uid$/.test(key)) return ["attachment"];
+  if (/(^|_)(item|parent|new_parent)_uid$/.test(key)) return ["task", "page"];
+  return null;
+}
+const UID_ARG = /^(?!_)(?:[a-z_]*_)?uids?$/;
+function resolveReferenceArgs(args) {
+  if (!args || typeof args !== "object" || Array.isArray(args)) return args;
+  let changed = false;
+  const out = { ...args };
+  const one = (key, value) => {
+    const ref = (0, import_references.parseReference)(value);
+    if (!ref) return value;
+    const kinds = ref.kind ? [ref.kind] : kindsForArg(key);
+    const matches = findReferenceMatches({ ...ref, kind: null }).filter((m) => !kinds || kinds.includes(m.kind));
+    if (matches.length > 1) throw new AmbiguousReferenceError(String(value), matches);
+    if (matches.length === 0) return value;
+    changed = true;
+    return matches[0].uid;
+  };
+  for (const [key, value] of Object.entries(out)) {
+    if (!UID_ARG.test(key)) continue;
+    out[key] = Array.isArray(value) ? value.map((v) => one(key, v)) : one(key, value);
+  }
+  return changed ? out : args;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AmbiguousReferenceError,
+  describeReference,
+  findReferenceMatches,
+  resolveReferenceArgs
+});

package/src/backend/services/release-public-key.js

@@ -0,0 +1,30 @@
+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 release_public_key_exports = {};
+__export(release_public_key_exports, {
+  RELEASE_PUBLIC_KEY_PEM: () => RELEASE_PUBLIC_KEY_PEM
+});
+module.exports = __toCommonJS(release_public_key_exports);
+const RELEASE_PUBLIC_KEY_PEM = `-----BEGIN PUBLIC KEY-----
+MCowBQYDK2VwAyEAUtfyemenyMhyJbIIuJDrc3NX8Ck8YtYKkn31XTzhZSY=
+-----END PUBLIC KEY-----
+`;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RELEASE_PUBLIC_KEY_PEM
+});

package/src/backend/services/release-signature.js

@@ -0,0 +1,64 @@
+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 release_signature_exports = {};
+__export(release_signature_exports, {
+  _publicKeyPem: () => _publicKeyPem,
+  digestFor: () => digestFor,
+  parseManifest: () => parseManifest,
+  verifyManifestSignature: () => verifyManifestSignature
+});
+module.exports = __toCommonJS(release_signature_exports);
+var import_node_crypto = require("node:crypto");
+var import_release_public_key = require("./release-public-key");
+function parseManifest(text) {
+  const out = [];
+  for (const raw of String(text ?? "").split("\n")) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    const m = /^([0-9a-fA-F]{64})\s+\*?(.+)$/.exec(line);
+    if (!m) continue;
+    out.push({ sha256: m[1].toLowerCase(), filename: m[2].trim() });
+  }
+  return out;
+}
+function verifyManifestSignature(manifest, signatureBase64) {
+  try {
+    if (!signatureBase64 || typeof signatureBase64 !== "string") return false;
+    const signature = Buffer.from(signatureBase64.trim(), "base64");
+    if (signature.length !== 64) return false;
+    const key = (0, import_node_crypto.createPublicKey)(import_release_public_key.RELEASE_PUBLIC_KEY_PEM);
+    const data = Buffer.isBuffer(manifest) ? manifest : Buffer.from(manifest, "utf-8");
+    return (0, import_node_crypto.verify)(null, data, key, signature);
+  } catch {
+    return false;
+  }
+}
+function digestFor(entries, filename) {
+  const wanted = String(filename ?? "").trim();
+  if (!wanted) return null;
+  const hit = entries.find((e) => e.filename === wanted);
+  return hit ? hit.sha256 : null;
+}
+const _publicKeyPem = import_release_public_key.RELEASE_PUBLIC_KEY_PEM;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  _publicKeyPem,
+  digestFor,
+  parseManifest,
+  verifyManifestSignature
+});

package/src/backend/services/remote-audio-service.js

@@ -0,0 +1,224 @@
+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 remote_audio_service_exports = {};
+__export(remote_audio_service_exports, {
+  broadcastAudioStatus: () => broadcastAudioStatus,
+  broadcastAudioStopped: () => broadcastAudioStopped,
+  forwardAudioChunk: () => forwardAudioChunk,
+  getRemoteAudioStatus: () => getRemoteAudioStatus,
+  getRemoteAudioStatuses: () => getRemoteAudioStatuses,
+  isRemoteAudioRunning: () => isRemoteAudioRunning,
+  onRemoteAudioEvent: () => onRemoteAudioEvent,
+  startRemoteAudio: () => startRemoteAudio,
+  stopRemoteAudio: () => stopRemoteAudio
+});
+module.exports = __toCommonJS(remote_audio_service_exports);
+var _lazy___audio_buffer_service = __toESM(require("./audio-buffer-service"));
+var import_types = require("../../shared/types");
+var import_webrtc_service = require("./webrtc-service");
+var import_paired_device_service = require("./paired-device-service");
+var import_peer_grants = require("./peer-grants");
+var import_settings_service = require("./settings-service");
+function sendToCapturePeers(payload) {
+  for (const peer of (0, import_webrtc_service.getPeerConnections)()) {
+    if (peer.state === "connected" && (0, import_peer_grants.peerHolds)(peer.fingerprint, "capture")) {
+      (0, import_webrtc_service.sendToPeer)(peer.fingerprint, import_types.DATA_CHANNELS.AUDIO, payload);
+    }
+  }
+}
+const MSG = {
+  AUDIO_STATUS: 1,
+  AUDIO_CHUNK: 2,
+  AUDIO_STOPPED: 3
+};
+let running = false;
+let unsubMessage = null;
+let unsubConnection = null;
+let unsubGrants = null;
+const remoteAudioStatus = /* @__PURE__ */ new Map();
+const listeners = /* @__PURE__ */ new Set();
+function startRemoteAudio() {
+  if (running) return;
+  running = true;
+  unsubMessage = (0, import_webrtc_service.onChannelMessage)(import_types.DATA_CHANNELS.AUDIO, handleAudioMessage);
+  unsubConnection = (0, import_webrtc_service.onConnectionStateChange)((fingerprint, state) => {
+    if (state === "connected") {
+      sendAudioStatus(fingerprint);
+    } else if (state === "disconnected" || state === "failed") {
+      remoteAudioStatus.delete(fingerprint);
+      emitEvent("remote-audio-changed", { fingerprint, capturing: false });
+    }
+  });
+  unsubGrants = (0, import_paired_device_service.onDeviceGrantsChanged)((fingerprint, added) => {
+    if (added.includes("capture")) sendAudioStatus(fingerprint);
+  });
+  console.log("[RemoteAudio] Started");
+}
+function stopRemoteAudio() {
+  if (!running) return;
+  running = false;
+  if (unsubMessage) {
+    unsubMessage();
+    unsubMessage = null;
+  }
+  if (unsubConnection) {
+    unsubConnection();
+    unsubConnection = null;
+  }
+  if (unsubGrants) {
+    unsubGrants();
+    unsubGrants = null;
+  }
+  remoteAudioStatus.clear();
+  console.log("[RemoteAudio] Stopped");
+}
+function forwardAudioChunk(chunkData) {
+  if (!running) return;
+  const settings = (0, import_settings_service.getSettings)();
+  if (!settings.device.shareAudio) return;
+  const payload = Buffer.alloc(1 + chunkData.length);
+  payload[0] = MSG.AUDIO_CHUNK;
+  chunkData.copy(payload, 1);
+  sendToCapturePeers(payload);
+}
+function broadcastAudioStatus(capturing, bufferedSeconds) {
+  if (!running) return;
+  const settings = (0, import_settings_service.getSettings)();
+  if (!settings.device.shareAudio) return;
+  const status = JSON.stringify({ capturing, bufferedSeconds });
+  const msg = Buffer.from(String.fromCharCode(MSG.AUDIO_STATUS) + status);
+  sendToCapturePeers(msg);
+}
+function broadcastAudioStopped() {
+  if (!running) return;
+  const msg = Buffer.from([MSG.AUDIO_STOPPED]);
+  sendToCapturePeers(msg);
+}
+function getRemoteAudioStatuses() {
+  return Array.from(remoteAudioStatus.values());
+}
+function getRemoteAudioStatus(fingerprint) {
+  return remoteAudioStatus.get(fingerprint) ?? null;
+}
+function onRemoteAudioEvent(cb) {
+  listeners.add(cb);
+  return () => {
+    listeners.delete(cb);
+  };
+}
+function isRemoteAudioRunning() {
+  return running;
+}
+function sendAudioStatus(fingerprint) {
+  const settings = (0, import_settings_service.getSettings)();
+  if (!settings.device.shareAudio) return;
+  if (!(0, import_peer_grants.peerHolds)(fingerprint, "capture")) return;
+  let capturing = false;
+  let bufferedSeconds = 0;
+  try {
+    const instance = _lazy___audio_buffer_service.audioBuffer;
+    if (instance) {
+      capturing = instance.isCapturing?.() ?? false;
+      const status2 = instance.getStatus?.();
+      if (status2) bufferedSeconds = status2.bufferedSeconds ?? 0;
+    }
+  } catch {
+  }
+  const status = JSON.stringify({ capturing, bufferedSeconds });
+  const msg = Buffer.from(String.fromCharCode(MSG.AUDIO_STATUS) + status);
+  (0, import_webrtc_service.sendToPeer)(fingerprint, import_types.DATA_CHANNELS.AUDIO, msg);
+}
+function handleAudioMessage(fingerprint, data) {
+  try {
+    const buf = typeof data === "string" ? Buffer.from(data, "utf-8") : data;
+    if (buf.length < 1) return;
+    const msgType = buf[0];
+    switch (msgType) {
+      case MSG.AUDIO_STATUS: {
+        const json = buf.slice(1).toString("utf-8");
+        const { capturing, bufferedSeconds } = JSON.parse(json);
+        remoteAudioStatus.set(fingerprint, {
+          peerFingerprint: fingerprint,
+          capturing: !!capturing,
+          bufferedSeconds: bufferedSeconds ?? 0
+        });
+        emitEvent("remote-audio-changed", {
+          fingerprint,
+          capturing: !!capturing,
+          bufferedSeconds
+        });
+        break;
+      }
+      case MSG.AUDIO_CHUNK: {
+        const chunkData = buf.slice(1);
+        if (chunkData.length > 0) {
+          try {
+            const instance = _lazy___audio_buffer_service.audioBuffer;
+            if (instance && typeof instance.addChunk === "function") {
+              const estimatedDurationMs = Math.min(6e4, Math.max(1, Math.round(chunkData.length / 4e3 * 1e3)));
+              instance.addChunk(chunkData, estimatedDurationMs);
+            }
+          } catch {
+          }
+          emitEvent("remote-audio-chunk", { fingerprint, size: chunkData.length });
+        }
+        break;
+      }
+      case MSG.AUDIO_STOPPED: {
+        const status = remoteAudioStatus.get(fingerprint);
+        if (status) {
+          status.capturing = false;
+          emitEvent("remote-audio-changed", { fingerprint, capturing: false });
+        }
+        break;
+      }
+    }
+  } catch (err) {
+    console.warn("[RemoteAudio] Invalid message:", err);
+  }
+}
+function emitEvent(event, data) {
+  for (const cb of listeners) {
+    try {
+      cb(event, data);
+    } catch {
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  broadcastAudioStatus,
+  broadcastAudioStopped,
+  forwardAudioChunk,
+  getRemoteAudioStatus,
+  getRemoteAudioStatuses,
+  isRemoteAudioRunning,
+  onRemoteAudioEvent,
+  startRemoteAudio,
+  stopRemoteAudio
+});