@makerbi/remodex 2.0.1 → 2.3.1

package/src/thread-runtime-settings-store.js

@@ -0,0 +1,247 @@
+// FILE: thread-runtime-settings-store.js
+// Purpose: Persists the last accepted model, reasoning effort, and service tier for each local thread.
+// Layer: CLI helper
+// Exports: createThreadRuntimeSettingsStore, runtimeSettingsFromTurnParams
+// Depends on: fs, os, path
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const STORE_VERSION = 1;
+const DEFAULT_MAX_THREADS = 500;
+const DEFAULT_MAX_AGE_MS = 180 * 24 * 60 * 60 * 1_000;
+const DEFAULT_STORE_DIR = path.join(os.homedir(), ".remodex");
+
+function createThreadRuntimeSettingsStore({
+  storeFile = process.env.REMODEX_THREAD_RUNTIME_STATE_FILE
+    || path.join(process.env.REMODEX_DEVICE_STATE_DIR || DEFAULT_STORE_DIR, "thread-runtime-settings.json"),
+  fsImpl = fs,
+  now = () => Date.now(),
+  maxThreads = DEFAULT_MAX_THREADS,
+  maxAgeMs = DEFAULT_MAX_AGE_MS,
+} = {}) {
+  let state = readState({ storeFile, fsImpl });
+
+  function get(threadId) {
+    const normalizedThreadId = normalizeString(threadId);
+    if (!normalizedThreadId) {
+      return null;
+    }
+    return cloneSettings(state.threads[normalizedThreadId]);
+  }
+
+  function commit(threadId, turnParams, { source = "unknown", turnId = "" } = {}) {
+    const normalizedThreadId = normalizeString(threadId);
+    const nextSource = normalizeString(source) || "unknown";
+    // Runtime choices are intentionally one-way: the phone may configure the
+    // runtime that executes its turn, while Desktop choices stay local.
+    if (!normalizedThreadId || nextSource !== "phone") {
+      return null;
+    }
+    const previous = state.threads[normalizedThreadId] || null;
+    const nextValues = runtimeSettingsFromTurnParams(turnParams, previous);
+    if (!nextValues.model && !nextValues.reasoningEffort && !previous) {
+      return null;
+    }
+
+    const normalizedTurnId = normalizeString(turnId);
+    if (previous
+      && previous.turnId === normalizedTurnId
+      && previous.model === nextValues.model
+      && previous.reasoningEffort === nextValues.reasoningEffort
+      && previous.serviceTier === nextValues.serviceTier) {
+      return cloneSettings(previous);
+    }
+
+    const next = {
+      model: nextValues.model || null,
+      reasoningEffort: nextValues.reasoningEffort || null,
+      serviceTier: nextValues.serviceTier,
+      revision: Math.max(0, Number(previous?.revision) || 0) + 1,
+      updatedAt: now(),
+      source: nextSource,
+      turnId: normalizedTurnId || null,
+    };
+    state.threads[normalizedThreadId] = next;
+    pruneState(state, { now: now(), maxThreads, maxAgeMs });
+    writeState(state, { storeFile, fsImpl });
+    return cloneSettings(next);
+  }
+
+  function attachToConversation(threadId, conversation) {
+    if (!conversation || typeof conversation !== "object") {
+      return conversation;
+    }
+    const settings = get(threadId);
+    if (!settings) {
+      return conversation;
+    }
+    conversation.remodexRuntimeSettings = settings;
+    if (settings.model) {
+      conversation.latestModel = settings.model;
+    }
+    if (settings.reasoningEffort) {
+      conversation.latestReasoningEffort = settings.reasoningEffort;
+    }
+    conversation.latestServiceTier = settings.serviceTier;
+    conversation.latestThreadSettings = {
+      ...(conversation.latestThreadSettings && typeof conversation.latestThreadSettings === "object"
+        ? conversation.latestThreadSettings
+        : {}),
+      model: settings.model,
+      effort: settings.reasoningEffort,
+      serviceTier: settings.serviceTier,
+    };
+    const collaborationSettings = conversation.latestCollaborationMode?.settings;
+    conversation.latestCollaborationMode = {
+      mode: conversation.latestCollaborationMode?.mode || "default",
+      settings: {
+        ...(collaborationSettings && typeof collaborationSettings === "object"
+          ? collaborationSettings
+          : { developer_instructions: null }),
+        model: settings.model || collaborationSettings?.model || "",
+        reasoning_effort: settings.reasoningEffort
+          || collaborationSettings?.reasoning_effort
+          || null,
+      },
+    };
+    return conversation;
+  }
+
+  function enrichResponse(method, envelope) {
+    if (!envelope || typeof envelope !== "object" || envelope.error) {
+      return envelope;
+    }
+    const result = envelope.result;
+    if (!result || typeof result !== "object") {
+      return envelope;
+    }
+    if (method === "thread/read" || method === "thread/resume") {
+      if (result.thread && typeof result.thread === "object") {
+        attachToThread(result.thread);
+      }
+      return envelope;
+    }
+    if (method === "thread/list") {
+      const key = ["data", "items", "threads"].find((candidate) => Array.isArray(result[candidate]));
+      for (const thread of key ? result[key] : []) {
+        attachToThread(thread);
+      }
+    }
+    return envelope;
+  }
+
+  function attachToThread(thread) {
+    const threadId = normalizeString(thread?.id) || normalizeString(thread?.threadId);
+    const settings = get(threadId);
+    if (!settings || !thread || typeof thread !== "object") {
+      return thread;
+    }
+    thread.model = settings.model || thread.model || null;
+    thread.reasoningEffort = settings.reasoningEffort;
+    thread.serviceTier = settings.serviceTier;
+    thread.runtimeSettingsRevision = settings.revision;
+    thread.runtimeSettingsUpdatedAt = settings.updatedAt;
+    thread.runtimeSettingsSource = settings.source;
+    return thread;
+  }
+
+  return {
+    get,
+    commit,
+    attachToConversation,
+    attachToThread,
+    enrichResponse,
+  };
+}
+
+function runtimeSettingsFromTurnParams(turnParams, previous = null) {
+  const params = turnParams && typeof turnParams === "object" ? turnParams : {};
+  const collaborationSettings = params.collaborationMode?.settings
+    || params.collaboration_mode?.settings
+    || {};
+  const model = normalizeString(params.model)
+    || normalizeString(collaborationSettings.model)
+    || normalizeString(previous?.model)
+    || null;
+  const reasoningEffort = normalizeString(params.effort)
+    || normalizeString(params.reasoningEffort)
+    || normalizeString(collaborationSettings.reasoning_effort)
+    || normalizeString(collaborationSettings.reasoningEffort)
+    || normalizeString(previous?.reasoningEffort)
+    || null;
+  const serviceTier = normalizeString(params.serviceTier)
+    || normalizeString(params.service_tier)
+    || null;
+  return { model, reasoningEffort, serviceTier };
+}
+
+function readState({ storeFile, fsImpl }) {
+  try {
+    const parsed = JSON.parse(fsImpl.readFileSync(storeFile, "utf8"));
+    return normalizeState(parsed);
+  } catch {
+    return { version: STORE_VERSION, threads: {} };
+  }
+}
+
+function normalizeState(rawState) {
+  const rawThreads = rawState?.threads && typeof rawState.threads === "object"
+    ? rawState.threads
+    : {};
+  const threads = {};
+  for (const [threadId, rawSettings] of Object.entries(rawThreads)) {
+    const normalizedThreadId = normalizeString(threadId);
+    const source = normalizeString(rawSettings?.source) || "unknown";
+    // Drop records written by older bidirectional builds so a Desktop choice
+    // cannot be replayed to the phone after upgrading.
+    if (!normalizedThreadId || !rawSettings || typeof rawSettings !== "object" || source !== "phone") {
+      continue;
+    }
+    threads[normalizedThreadId] = {
+      model: normalizeString(rawSettings.model) || null,
+      reasoningEffort: normalizeString(rawSettings.reasoningEffort) || null,
+      serviceTier: normalizeString(rawSettings.serviceTier) || null,
+      revision: Math.max(0, Number(rawSettings.revision) || 0),
+      updatedAt: Math.max(0, Number(rawSettings.updatedAt) || 0),
+      source,
+      turnId: normalizeString(rawSettings.turnId) || null,
+    };
+  }
+  return { version: STORE_VERSION, threads };
+}
+
+function pruneState(storeState, { now, maxThreads, maxAgeMs }) {
+  const entries = Object.entries(storeState.threads)
+    .filter(([, settings]) => !maxAgeMs || now - settings.updatedAt <= maxAgeMs)
+    .sort((left, right) => right[1].updatedAt - left[1].updatedAt)
+    .slice(0, Math.max(1, maxThreads));
+  storeState.threads = Object.fromEntries(entries);
+}
+
+function writeState(storeState, { storeFile, fsImpl }) {
+  const directory = path.dirname(storeFile);
+  const temporaryFile = `${storeFile}.tmp`;
+  fsImpl.mkdirSync(directory, { recursive: true });
+  fsImpl.writeFileSync(temporaryFile, JSON.stringify(storeState, null, 2), { mode: 0o600 });
+  fsImpl.renameSync(temporaryFile, storeFile);
+  try {
+    fsImpl.chmodSync(storeFile, 0o600);
+  } catch {
+    // Best-effort only on filesystems without POSIX permissions.
+  }
+}
+
+function cloneSettings(settings) {
+  return settings ? { ...settings } : null;
+}
+
+function normalizeString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+module.exports = {
+  createThreadRuntimeSettingsStore,
+  runtimeSettingsFromTurnParams,
+};

package/src/voice-audio.js

@@ -0,0 +1,344 @@
+// FILE: voice-audio.js
+// Purpose: Pure WAV and M4A container parsing plus format checks for Remodex voice clips.
+// Layer: Bridge helper
+// Exports: hasConsistentVoiceWavLayout, isSupportedVoiceWavFormat, readM4AInfo, readWavInfo, wavDurationMs
+// Depends on: Buffer
+
+// ─── WAV parsing ─────────────────────────────────────────────────
+
+function hasRiffWaveHeader(buffer) {
+  return buffer.length >= 44
+    && buffer.toString("ascii", 0, 4) === "RIFF"
+    && buffer.toString("ascii", 8, 12) === "WAVE";
+}
+
+// Parses chunked WAV metadata so extra chunks before fmt/data do not break valid clips.
+function readWavInfo(buffer) {
+  if (!hasRiffWaveHeader(buffer)) {
+    return null;
+  }
+
+  let offset = 12;
+  let info = null;
+  let hasData = false;
+  let dataByteCount = 0;
+  while (offset + 8 <= buffer.length) {
+    const chunkId = buffer.toString("ascii", offset, offset + 4);
+    const chunkSize = buffer.readUInt32LE(offset + 4);
+    const payloadStart = offset + 8;
+    const payloadEnd = payloadStart + chunkSize;
+    if (payloadEnd > buffer.length) {
+      return null;
+    }
+
+    if (chunkId === "fmt ") {
+      if (chunkSize < 16) {
+        return null;
+      }
+      info = {
+        audioFormat: buffer.readUInt16LE(payloadStart),
+        channelCount: buffer.readUInt16LE(payloadStart + 2),
+        sampleRateHz: buffer.readUInt32LE(payloadStart + 4),
+        byteRate: buffer.readUInt32LE(payloadStart + 8),
+        blockAlign: buffer.readUInt16LE(payloadStart + 12),
+        bitsPerSample: buffer.readUInt16LE(payloadStart + 14),
+      };
+    } else if (chunkId === "data") {
+      hasData = chunkSize > 0;
+      dataByteCount = chunkSize;
+    }
+
+    offset = payloadEnd + (chunkSize % 2);
+  }
+
+  if (info && hasData) {
+    info.dataByteCount = dataByteCount;
+    return info;
+  }
+  return null;
+}
+
+function isSupportedVoiceWavFormat(wavInfo) {
+  return wavInfo.audioFormat === 1
+    && wavInfo.channelCount === 1
+    && wavInfo.sampleRateHz === 24_000
+    && wavInfo.bitsPerSample === 16;
+}
+
+// Rejects forged WAV layout fields before using data length for duration checks.
+function hasConsistentVoiceWavLayout(wavInfo) {
+  return wavInfo.blockAlign === expectedVoiceWavBlockAlign(wavInfo)
+    && wavInfo.byteRate === expectedVoiceWavByteRate(wavInfo);
+}
+
+function expectedVoiceWavBlockAlign(wavInfo) {
+  return wavInfo.channelCount * (wavInfo.bitsPerSample / 8);
+}
+
+function expectedVoiceWavByteRate(wavInfo) {
+  return wavInfo.sampleRateHz * expectedVoiceWavBlockAlign(wavInfo);
+}
+
+function wavDurationMs(wavInfo) {
+  const byteRate = expectedVoiceWavByteRate(wavInfo);
+  if (!Number.isFinite(byteRate) || byteRate <= 0) {
+    return NaN;
+  }
+
+  return (Number(wavInfo.dataByteCount || 0) / byteRate) * 1_000;
+}
+
+// ─── M4A parsing ─────────────────────────────────────────────────
+
+// Parses the MP4/M4A container enough to validate Remodex-generated AAC clips
+// before proxying them to ChatGPT.
+function readM4AInfo(buffer) {
+  if (!Buffer.isBuffer(buffer) || buffer.length < 16) {
+    return null;
+  }
+
+  let hasM4ABrand = false;
+  let hasMediaData = false;
+  let durationMs = NaN;
+  let audioTrackInfo = null;
+  for (const box of readMp4Boxes(buffer, 0, buffer.length)) {
+    if (box.type === "ftyp") {
+      hasM4ABrand = isM4AFileTypeBox(buffer, box);
+    } else if (box.type === "mdat") {
+      hasMediaData = box.payloadEnd > box.payloadStart;
+    } else if (box.type === "moov") {
+      durationMs = readMovieDurationMs(buffer, box.payloadStart, box.payloadEnd);
+      audioTrackInfo = readAudioTrackInfo(buffer, box.payloadStart, box.payloadEnd);
+    }
+  }
+
+  if (!hasM4ABrand
+    || !hasMediaData
+    || !Number.isFinite(durationMs)
+    || durationMs <= 0
+    || !isSupportedM4AAudioTrack(audioTrackInfo)) {
+    return null;
+  }
+  return { durationMs: Math.max(durationMs, audioTrackInfo.mdhdDurationMs) };
+}
+
+function* readMp4Boxes(buffer, start, end) {
+  let offset = start;
+  while (offset + 8 <= end) {
+    const size32 = buffer.readUInt32BE(offset);
+    const type = buffer.toString("ascii", offset + 4, offset + 8);
+    let headerSize = 8;
+    let size = size32;
+    if (size32 === 1) {
+      if (offset + 16 > end) {
+        return;
+      }
+      const size64 = buffer.readBigUInt64BE(offset + 8);
+      if (size64 > BigInt(Number.MAX_SAFE_INTEGER)) {
+        return;
+      }
+      size = Number(size64);
+      headerSize = 16;
+    } else if (size32 === 0) {
+      size = end - offset;
+    }
+
+    if (size < headerSize || offset + size > end) {
+      return;
+    }
+
+    yield {
+      type,
+      start: offset,
+      end: offset + size,
+      payloadStart: offset + headerSize,
+      payloadEnd: offset + size,
+    };
+    offset += size;
+  }
+}
+
+function isM4AFileTypeBox(buffer, box) {
+  if (box.payloadEnd - box.payloadStart < 8) {
+    return false;
+  }
+  const brands = [
+    buffer.toString("ascii", box.payloadStart, box.payloadStart + 4),
+  ];
+  for (let offset = box.payloadStart + 8; offset + 4 <= box.payloadEnd; offset += 4) {
+    brands.push(buffer.toString("ascii", offset, offset + 4));
+  }
+  return brands.includes("M4A ");
+}
+
+function readMovieDurationMs(buffer, start, end) {
+  for (const box of readMp4Boxes(buffer, start, end)) {
+    if (box.type !== "mvhd") {
+      continue;
+    }
+    return readMovieHeaderDurationMs(buffer, box.payloadStart, box.payloadEnd);
+  }
+  return NaN;
+}
+
+function readAudioTrackInfo(buffer, start, end) {
+  for (const box of readMp4Boxes(buffer, start, end)) {
+    if (box.type !== "trak") {
+      continue;
+    }
+    const trackInfo = readTrackInfo(buffer, box.payloadStart, box.payloadEnd);
+    if (trackInfo.handlerType === "soun") {
+      return trackInfo;
+    }
+  }
+  return null;
+}
+
+function readTrackInfo(buffer, start, end) {
+  let mdhdTimescale = NaN;
+  let mdhdDurationMs = NaN;
+  let handlerType = "";
+  let sampleEntryInfo = null;
+  for (const box of readMp4Boxes(buffer, start, end)) {
+    if (box.type !== "mdia") {
+      continue;
+    }
+    for (const mediaBox of readMp4Boxes(buffer, box.payloadStart, box.payloadEnd)) {
+      if (mediaBox.type === "mdhd") {
+        const mediaHeader = readMediaHeaderInfo(buffer, mediaBox.payloadStart, mediaBox.payloadEnd);
+        mdhdTimescale = mediaHeader.timescale;
+        mdhdDurationMs = mediaHeader.durationMs;
+      } else if (mediaBox.type === "hdlr") {
+        handlerType = readHandlerType(buffer, mediaBox.payloadStart, mediaBox.payloadEnd);
+      } else if (mediaBox.type === "minf") {
+        sampleEntryInfo = readAudioSampleEntryInfo(buffer, mediaBox.payloadStart, mediaBox.payloadEnd);
+      }
+    }
+  }
+  return { mdhdTimescale, mdhdDurationMs, handlerType, sampleEntryInfo };
+}
+
+function readMediaHeaderInfo(buffer, start, end) {
+  if (start + 4 > end) {
+    return { timescale: NaN, durationMs: NaN };
+  }
+  const version = buffer.readUInt8(start);
+  if (version === 0) {
+    if (start + 20 > end) {
+      return { timescale: NaN, durationMs: NaN };
+    }
+    const timescale = buffer.readUInt32BE(start + 12);
+    const duration = buffer.readUInt32BE(start + 16);
+    return { timescale, durationMs: movieDurationMs(timescale, duration) };
+  }
+  if (version === 1) {
+    if (start + 32 > end) {
+      return { timescale: NaN, durationMs: NaN };
+    }
+    const timescale = buffer.readUInt32BE(start + 20);
+    const duration = buffer.readBigUInt64BE(start + 24);
+    if (duration > BigInt(Number.MAX_SAFE_INTEGER)) {
+      return { timescale: NaN, durationMs: NaN };
+    }
+    return { timescale, durationMs: movieDurationMs(timescale, Number(duration)) };
+  }
+  return { timescale: NaN, durationMs: NaN };
+}
+
+function readHandlerType(buffer, start, end) {
+  if (start + 12 > end) {
+    return "";
+  }
+  return buffer.toString("ascii", start + 8, start + 12);
+}
+
+function readAudioSampleEntryInfo(buffer, start, end) {
+  for (const minfBox of readMp4Boxes(buffer, start, end)) {
+    if (minfBox.type !== "stbl") {
+      continue;
+    }
+    for (const stblBox of readMp4Boxes(buffer, minfBox.payloadStart, minfBox.payloadEnd)) {
+      if (stblBox.type !== "stsd") {
+        continue;
+      }
+      const sampleEntry = readFirstSampleEntry(buffer, stblBox.payloadStart, stblBox.payloadEnd);
+      if (sampleEntry) {
+        return sampleEntry;
+      }
+    }
+  }
+  return null;
+}
+
+function readFirstSampleEntry(buffer, start, end) {
+  if (start + 8 > end) {
+    return null;
+  }
+  const entryCount = buffer.readUInt32BE(start + 4);
+  if (entryCount < 1) {
+    return null;
+  }
+  const [sampleEntry] = readMp4Boxes(buffer, start + 8, end);
+  if (!sampleEntry || sampleEntry.type !== "mp4a" || sampleEntry.payloadStart + 28 > sampleEntry.payloadEnd) {
+    return null;
+  }
+  return {
+    codec: sampleEntry.type,
+    channelCount: buffer.readUInt16BE(sampleEntry.payloadStart + 16),
+    sampleRateHz: buffer.readUInt32BE(sampleEntry.payloadStart + 24) >>> 16,
+  };
+}
+
+function isSupportedM4AAudioTrack(trackInfo) {
+  return trackInfo?.handlerType === "soun"
+    && trackInfo.mdhdTimescale === 24_000
+    && Number.isFinite(trackInfo.mdhdDurationMs)
+    && trackInfo.mdhdDurationMs > 0
+    && trackInfo.sampleEntryInfo?.codec === "mp4a"
+    // CoreAudio writes channelCount=2 in the mp4a sample entry even for mono AAC
+    // (the real channel config lives in the esds), so accept both values here.
+    && (trackInfo.sampleEntryInfo?.channelCount === 1 || trackInfo.sampleEntryInfo?.channelCount === 2)
+    && trackInfo.sampleEntryInfo?.sampleRateHz === 24_000;
+}
+
+function readMovieHeaderDurationMs(buffer, start, end) {
+  if (start + 4 > end) {
+    return NaN;
+  }
+  const version = buffer.readUInt8(start);
+  if (version === 0) {
+    if (start + 20 > end) {
+      return NaN;
+    }
+    const timescale = buffer.readUInt32BE(start + 12);
+    const duration = buffer.readUInt32BE(start + 16);
+    return movieDurationMs(timescale, duration);
+  }
+  if (version === 1) {
+    if (start + 32 > end) {
+      return NaN;
+    }
+    const timescale = buffer.readUInt32BE(start + 20);
+    const duration = buffer.readBigUInt64BE(start + 24);
+    if (duration > BigInt(Number.MAX_SAFE_INTEGER)) {
+      return NaN;
+    }
+    return movieDurationMs(timescale, Number(duration));
+  }
+  return NaN;
+}
+
+function movieDurationMs(timescale, duration) {
+  if (!Number.isFinite(timescale) || timescale <= 0 || !Number.isFinite(duration) || duration <= 0) {
+    return NaN;
+  }
+  return (duration / timescale) * 1_000;
+}
+
+module.exports = {
+  hasConsistentVoiceWavLayout,
+  isSupportedVoiceWavFormat,
+  readM4AInfo,
+  readWavInfo,
+  wavDurationMs,
+};