Keysat
cbd9748a79
saveMeeting/loadMeeting/deleteMeeting built path.join(meetingsDir, id + '.json') straight from req.params.id, so an admin-authed :id like '../../etc/passwd' could read/write/delete outside internal-meetings/. Centralize a meetingPath() helper that strips anything outside [A-Za-z0-9_-] (mirrors output-store.js) and throws on an empty result; load/delete catch it as 404/no-op. Add a regression test.
2238 lines
83 KiB
JavaScript
2238 lines
83 KiB
JavaScript
// Internal team meeting processing — Path 2A Phase 1.
|
|
//
|
|
// Operator-only endpoint family. Accepts an uploaded audio file
|
|
// (mp3 / m4a / wav / etc), runs the SAME hardware pipeline that
|
|
// /relay/v1/summarize-url uses for YouTube/podcast content
|
|
// (transcribe → diarize → cluster → analyze → post-cluster polish),
|
|
// and saves the result to /data/internal-meetings/<id>.json.
|
|
//
|
|
// Differences from summarize-url:
|
|
// - No download step (caller already has the file)
|
|
// - No license / credit accounting (operator-owned compute)
|
|
// - No Recaps-app envelope (results live on the relay, not in a
|
|
// user library — Path 2B will migrate them into per-user
|
|
// libraries once multi-tenant Recaps lands)
|
|
// - Saved JSON is downloadable + markdown-renderable so the
|
|
// operator can feed transcripts to other tools without
|
|
// re-running the pipeline
|
|
//
|
|
// All routes mount under /admin/internal-meetings/* and inherit
|
|
// the admin-session-cookie auth gate from the parent admin router.
|
|
// No public exposure.
|
|
|
|
import express from "express";
|
|
import multer from "multer";
|
|
import fs from "fs/promises";
|
|
import path from "path";
|
|
import os from "os";
|
|
import { randomUUID } from "crypto";
|
|
|
|
import { getConfigSnapshot } from "../config.js";
|
|
import { resolveHardwareConfig } from "../hardware-config.js";
|
|
import { createHardwareBackend } from "../backends/hardware.js";
|
|
import {
|
|
runPipelinedAnalysis,
|
|
parseBracketedTranscript,
|
|
firstEntryAtOrAfter,
|
|
lastEntryBefore,
|
|
canonicalIndexForOffset,
|
|
stitchAnalysisResults,
|
|
planWindowsByDuration,
|
|
} from "../chunked-analyze.js";
|
|
import { createChunkBuffer } from "../chunk-buffer.js";
|
|
import {
|
|
runNameInference,
|
|
runSummaryPolish,
|
|
} from "../post-cluster-polish.js";
|
|
import { runMeetingExtras } from "../meeting-extras.js";
|
|
import {
|
|
backfillEntrySpeakers,
|
|
mergeSpeakersInRecord,
|
|
reclusterMeetingRecord,
|
|
applyPolishedSummaries,
|
|
} from "../meeting-speaker-edits.js";
|
|
import { acquireHardwareSlot } from "../hardware-queue.js";
|
|
import { getAudioDurationSeconds } from "../audio-meta.js";
|
|
import {
|
|
createJob,
|
|
appendEvent,
|
|
subscribeToJob,
|
|
getJob,
|
|
markRunning,
|
|
setProgress,
|
|
markComplete,
|
|
markFailed,
|
|
} from "../jobs.js";
|
|
|
|
// Upload size cap — generous enough for a 4-hour meeting at 192kbps
|
|
// mp3 (~340MB) but rejects bigger uploads to avoid disk-fill DoS.
|
|
const MAX_UPLOAD_BYTES = 500 * 1024 * 1024; // 500MB
|
|
|
|
// Storage dir for completed meetings.
|
|
function meetingsDir(dataDir) {
|
|
return path.join(dataDir, "internal-meetings");
|
|
}
|
|
|
|
async function ensureMeetingsDir(dataDir) {
|
|
await fs.mkdir(meetingsDir(dataDir), { recursive: true }).catch(() => {});
|
|
}
|
|
|
|
// Build the on-disk path for a meeting record, sanitizing the id so a
|
|
// caller-supplied :id can't traverse out of internal-meetings/. Real
|
|
// ids are UUIDs; anything outside [A-Za-z0-9_-] is stripped (mirrors
|
|
// output-store.js's pathFor). Throws when the id sanitizes to empty —
|
|
// load/delete catch it (→ 404 / no-op); save only ever gets a freshly
|
|
// minted id.
|
|
export function meetingPath(dataDir, id) {
|
|
const safe = String(id || "").replace(/[^A-Za-z0-9_-]/g, "");
|
|
if (!safe) throw new Error("invalid meeting id");
|
|
return path.join(meetingsDir(dataDir), `${safe}.json`);
|
|
}
|
|
|
|
// ─── Storage layer ──────────────────────────────────────────────────
|
|
|
|
async function saveMeeting(dataDir, id, record) {
|
|
await ensureMeetingsDir(dataDir);
|
|
const filePath = meetingPath(dataDir, id);
|
|
await fs.writeFile(filePath, JSON.stringify(record, null, 2), {
|
|
mode: 0o600,
|
|
});
|
|
}
|
|
|
|
async function loadMeeting(dataDir, id) {
|
|
try {
|
|
const filePath = meetingPath(dataDir, id);
|
|
const raw = await fs.readFile(filePath, "utf8");
|
|
const rec = JSON.parse(raw);
|
|
// Retroactive chunk-contiguity backfill must run BEFORE the
|
|
// speaker backfill, because contiguity adds entries that the
|
|
// speaker backfill then needs to label. Both are no-ops when
|
|
// the saved record was already produced by the post-v0.2.107
|
|
// pipeline (entries are contiguous + speaker fields populated).
|
|
backfillChunkContiguity(rec);
|
|
backfillEntrySpeakers(rec);
|
|
return rec;
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// Reslice each chunk's entries to fill gaps the LLM analyze pass
|
|
// left between section boundaries. The original v0.2.103-v0.2.106
|
|
// pipeline saved chunks with strict LLM startIndex/endIndex slices,
|
|
// which dropped entries the model classified as "between topics"
|
|
// (filler, brief transitions). On a 3-min meeting that meant
|
|
// users saw topic 2 with one statement and 46-second timestamp
|
|
// gaps between consecutive topics.
|
|
//
|
|
// Fix on read: re-derive canonical entries from rec.transcript,
|
|
// match each saved chunk's first/last entry by (offset, text-prefix)
|
|
// to find its canonical index range, then extend ranges to be
|
|
// contiguous (chunk 0 → entry 0, chunk N's end → chunk N+1's start
|
|
// minus 1, last chunk → end of transcript) and rewrite entries
|
|
// from the extended slice. Section titles and summaries stay
|
|
// untouched — only the entries[] gets refilled.
|
|
function backfillChunkContiguity(rec) {
|
|
if (!rec || !Array.isArray(rec.chunks) || rec.chunks.length === 0) return;
|
|
if (typeof rec.transcript !== "string" || !rec.transcript) return;
|
|
|
|
const allEntries = parseBracketedTranscript(rec.transcript);
|
|
if (allEntries.length === 0) return;
|
|
|
|
// Quick exit: if the current saved chunks already cover every
|
|
// entry contiguously, do nothing. Heuristic — sum of entries
|
|
// across chunks equals total entries AND each chunk's last
|
|
// entry's offset equals the next chunk's first entry's offset
|
|
// minus the gap. Simpler check: total saved entries vs canonical.
|
|
const savedEntryCount = rec.chunks.reduce(
|
|
(n, c) => n + (Array.isArray(c.entries) ? c.entries.length : 0),
|
|
0
|
|
);
|
|
if (savedEntryCount >= allEntries.length) return;
|
|
|
|
const matchEntry = (saved) => {
|
|
if (!saved) return -1;
|
|
const t = saved.offset || 0;
|
|
const txt = (saved.text || "").slice(0, 24);
|
|
let fallback = -1;
|
|
for (let i = 0; i < allEntries.length; i++) {
|
|
const off = allEntries[i].offset || 0;
|
|
if (off !== t) {
|
|
if (off > t + 2) break;
|
|
continue;
|
|
}
|
|
const a = (allEntries[i].text || "").slice(0, 24);
|
|
if (a === txt) return i;
|
|
if (fallback < 0) fallback = i;
|
|
}
|
|
return fallback;
|
|
};
|
|
|
|
const ranges = [];
|
|
for (const chunk of rec.chunks) {
|
|
const entries = Array.isArray(chunk.entries) ? chunk.entries : [];
|
|
if (entries.length === 0) continue;
|
|
const firstIdx = matchEntry(entries[0]);
|
|
const lastIdx = matchEntry(entries[entries.length - 1]);
|
|
if (firstIdx < 0 || lastIdx < 0 || lastIdx < firstIdx) continue;
|
|
ranges.push({ chunk, firstIdx, lastIdx });
|
|
}
|
|
if (ranges.length === 0) return;
|
|
ranges.sort((a, b) => a.firstIdx - b.firstIdx);
|
|
|
|
// Extend ranges so they collectively cover every canonical entry.
|
|
ranges[0].firstIdx = 0;
|
|
for (let i = 0; i + 1 < ranges.length; i++) {
|
|
ranges[i].lastIdx = Math.max(
|
|
ranges[i].lastIdx,
|
|
ranges[i + 1].firstIdx - 1
|
|
);
|
|
}
|
|
ranges[ranges.length - 1].lastIdx = allEntries.length - 1;
|
|
|
|
// Rewrite each chunk's entries from its extended slice. We carry
|
|
// over the existing chunk's per-entry speaker/confidence/uncertain
|
|
// fields keyed by offset+text-prefix so any prior speaker
|
|
// attribution survives the rewrite.
|
|
for (const r of ranges) {
|
|
const priorByKey = new Map();
|
|
for (const e of r.chunk.entries || []) {
|
|
const k = `${e.offset || 0}|${(e.text || "").slice(0, 16)}`;
|
|
priorByKey.set(k, e);
|
|
}
|
|
const slice = allEntries.slice(r.firstIdx, r.lastIdx + 1).map((e) => {
|
|
const k = `${e.offset || 0}|${(e.text || "").slice(0, 16)}`;
|
|
const prior = priorByKey.get(k);
|
|
if (prior && prior.speaker) {
|
|
return {
|
|
...e,
|
|
speaker: prior.speaker,
|
|
speaker_confidence: prior.speaker_confidence ?? null,
|
|
speaker_uncertain: !!prior.speaker_uncertain,
|
|
};
|
|
}
|
|
return { ...e };
|
|
});
|
|
r.chunk.entries = slice;
|
|
r.chunk.startTime = slice[0]?.offset || 0;
|
|
}
|
|
}
|
|
|
|
async function listMeetings(dataDir) {
|
|
await ensureMeetingsDir(dataDir);
|
|
const dir = meetingsDir(dataDir);
|
|
let files = [];
|
|
try {
|
|
files = await fs.readdir(dir);
|
|
} catch {
|
|
return [];
|
|
}
|
|
const out = [];
|
|
for (const f of files) {
|
|
if (!f.endsWith(".json")) continue;
|
|
try {
|
|
const raw = await fs.readFile(path.join(dir, f), "utf8");
|
|
const rec = JSON.parse(raw);
|
|
out.push({
|
|
id: rec.id,
|
|
title: rec.title || "(untitled)",
|
|
created_at: rec.created_at,
|
|
audio_seconds: rec.audio_seconds || 0,
|
|
topic_count: Array.isArray(rec.chunks) ? rec.chunks.length : 0,
|
|
speaker_count: rec.speakers ? Object.keys(rec.speakers).length : 0,
|
|
});
|
|
} catch {
|
|
// skip malformed files
|
|
}
|
|
}
|
|
// Most-recent first
|
|
out.sort((a, b) => (b.created_at || 0) - (a.created_at || 0));
|
|
return out;
|
|
}
|
|
|
|
async function deleteMeeting(dataDir, id) {
|
|
try {
|
|
const filePath = meetingPath(dataDir, id);
|
|
await fs.unlink(filePath);
|
|
return true;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// ─── Markdown formatter ─────────────────────────────────────────────
|
|
// Converts a saved meeting record into a human-readable markdown doc
|
|
// suitable for downloading + feeding to other LLMs / sharing.
|
|
|
|
function formatTimestamp(secs) {
|
|
const s = Math.max(0, Math.floor(secs || 0));
|
|
const h = Math.floor(s / 3600);
|
|
const m = Math.floor((s % 3600) / 60);
|
|
const sec = s % 60;
|
|
const pad = (n) => n.toString().padStart(2, "0");
|
|
return h > 0 ? `${h}:${pad(m)}:${pad(sec)}` : `${m}:${pad(sec)}`;
|
|
}
|
|
|
|
function speakerDisplayName(speakerId, speakerNames) {
|
|
if (!speakerId) return "Unknown";
|
|
if (speakerId === "Speaker_Unknown") return "Unknown";
|
|
const inferred = speakerNames && speakerNames[speakerId];
|
|
if (typeof inferred === "string" && inferred.trim()) return inferred.trim();
|
|
const m = String(speakerId).match(/^Speaker_([A-Z]+)$/);
|
|
return m ? `Speaker ${m[1]}` : speakerId;
|
|
}
|
|
|
|
export function meetingToMarkdown(rec) {
|
|
if (!rec) return "";
|
|
const lines = [];
|
|
lines.push(`# ${rec.title || "Untitled meeting"}`);
|
|
lines.push("");
|
|
|
|
const dateStr = rec.created_at
|
|
? new Date(rec.created_at).toLocaleString("en-US", {
|
|
dateStyle: "long",
|
|
timeStyle: "short",
|
|
})
|
|
: "(unknown)";
|
|
lines.push(`**Processed:** ${dateStr}`);
|
|
if (rec.audio_seconds) {
|
|
lines.push(`**Duration:** ${formatTimestamp(rec.audio_seconds)}`);
|
|
}
|
|
if (Array.isArray(rec.participants) && rec.participants.length) {
|
|
lines.push(`**Participant hints:** ${rec.participants.join(", ")}`);
|
|
}
|
|
|
|
// Speaker roster
|
|
if (rec.speakers && Object.keys(rec.speakers).length) {
|
|
lines.push("");
|
|
lines.push("## Speakers");
|
|
lines.push("");
|
|
const entries = Object.entries(rec.speakers).sort((a, b) => {
|
|
if (a[0] === "Speaker_Unknown") return 1;
|
|
if (b[0] === "Speaker_Unknown") return -1;
|
|
return a[0].localeCompare(b[0]);
|
|
});
|
|
for (const [id, stats] of entries) {
|
|
const display = speakerDisplayName(id, rec.speaker_names);
|
|
const secs = Math.round(stats.total_speaking_seconds || 0);
|
|
const turns = stats.turns || 0;
|
|
lines.push(`- **${display}** — ${formatTimestamp(secs)} speaking, ${turns} turn${turns !== 1 ? "s" : ""}`);
|
|
}
|
|
}
|
|
|
|
// Phase 2 extras (decisions / action items / open questions /
|
|
// key quotes). Rendered ABOVE the topics so the reader sees the
|
|
// most actionable content first. Empty categories collapse;
|
|
// entire block hides when no extras exist.
|
|
if (rec.extras) {
|
|
const x = rec.extras;
|
|
const tldr = x.tldr && typeof x.tldr === "object" ? x.tldr : null;
|
|
const decs = Array.isArray(x.decisions) ? x.decisions : [];
|
|
const acts = Array.isArray(x.action_items) ? x.action_items : [];
|
|
const qs = Array.isArray(x.open_questions) ? x.open_questions : [];
|
|
const quotes = Array.isArray(x.key_quotes) ? x.key_quotes : [];
|
|
const speakerNamesMd = rec.speaker_names || {};
|
|
const renderSpeakerMd = (sid) =>
|
|
sid ? speakerDisplayName(sid, speakerNamesMd) : "";
|
|
if (tldr && typeof tldr.summary === "string" && tldr.summary.trim()) {
|
|
lines.push("");
|
|
lines.push("## TL;DR");
|
|
lines.push("");
|
|
lines.push(tldr.summary.trim());
|
|
if (Array.isArray(tldr.primary_speakers) && tldr.primary_speakers.length) {
|
|
const names = tldr.primary_speakers.map(renderSpeakerMd).filter(Boolean);
|
|
if (names.length) {
|
|
lines.push("");
|
|
lines.push(`_Primary speakers: ${names.join(", ")}_`);
|
|
}
|
|
}
|
|
}
|
|
if (decs.length) {
|
|
lines.push("");
|
|
lines.push("## Decisions");
|
|
lines.push("");
|
|
for (const d of decs) {
|
|
const ts = d.supporting_offset != null ? ` [${formatTimestamp(d.supporting_offset)}]` : "";
|
|
const agreed = (d.agreed_by || []).map(renderSpeakerMd).filter(Boolean);
|
|
const agreedStr = agreed.length ? ` — agreed by ${agreed.join(", ")}` : "";
|
|
lines.push(`- ${d.statement}${ts}${agreedStr}`);
|
|
}
|
|
}
|
|
if (acts.length) {
|
|
lines.push("");
|
|
lines.push("## Action items");
|
|
lines.push("");
|
|
for (const a of acts) {
|
|
const ts = a.supporting_offset != null ? ` [${formatTimestamp(a.supporting_offset)}]` : "";
|
|
const owner = a.owner ? ` — ${renderSpeakerMd(a.owner)}` : "";
|
|
const due = a.due_hint ? ` (due: ${a.due_hint})` : "";
|
|
lines.push(`- ${a.description}${ts}${owner}${due}`);
|
|
}
|
|
}
|
|
if (qs.length) {
|
|
lines.push("");
|
|
lines.push("## Open questions");
|
|
lines.push("");
|
|
for (const q of qs) {
|
|
const by = q.raised_by ? ` — raised by ${renderSpeakerMd(q.raised_by)}` : "";
|
|
lines.push(`- ${q.question}${by}`);
|
|
}
|
|
}
|
|
if (quotes.length) {
|
|
lines.push("");
|
|
lines.push("## Key quotes");
|
|
lines.push("");
|
|
for (const q of quotes) {
|
|
const ts = q.offset != null ? ` [${formatTimestamp(q.offset)}]` : "";
|
|
const sp = q.speaker ? ` — ${renderSpeakerMd(q.speaker)}` : "";
|
|
const why = q.why_notable ? ` _(${q.why_notable})_` : "";
|
|
lines.push(`- "${q.quote}"${ts}${sp}${why}`);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Topics + per-topic transcript chunks
|
|
if (Array.isArray(rec.chunks) && rec.chunks.length) {
|
|
lines.push("");
|
|
lines.push("## Topics");
|
|
lines.push("");
|
|
rec.chunks.forEach((chunk, i) => {
|
|
const start = formatTimestamp(chunk.startTime || 0);
|
|
// Adjacent display: end = next chunk's start so consecutive
|
|
// topics appear contiguous; last chunk extends to full audio.
|
|
let endSec;
|
|
if (i + 1 < rec.chunks.length) {
|
|
endSec = rec.chunks[i + 1].startTime || 0;
|
|
} else if (rec.audio_seconds) {
|
|
endSec = rec.audio_seconds;
|
|
} else if (chunk.entries && chunk.entries.length > 0) {
|
|
endSec = chunk.entries[chunk.entries.length - 1].offset || 0;
|
|
} else {
|
|
endSec = chunk.startTime || 0;
|
|
}
|
|
const end = formatTimestamp(endSec);
|
|
lines.push(`### ${i + 1}. ${chunk.title || "(untitled topic)"} (${start} — ${end})`);
|
|
lines.push("");
|
|
lines.push(chunk.summary || "");
|
|
if (Array.isArray(chunk.entries) && chunk.entries.length) {
|
|
lines.push("");
|
|
lines.push("<details><summary>Transcript</summary>");
|
|
lines.push("");
|
|
for (const entry of chunk.entries) {
|
|
const t = formatTimestamp(entry.offset || 0);
|
|
// Operator override wins (same convention as the .html
|
|
// and dashboard renderers).
|
|
const effSpeaker = entry.speaker_override || entry.speaker;
|
|
const who = effSpeaker
|
|
? speakerDisplayName(effSpeaker, rec.speaker_names)
|
|
: null;
|
|
if (who) {
|
|
lines.push(`- **[${t}] ${who}:** ${entry.text || ""}`);
|
|
} else {
|
|
lines.push(`- **[${t}]** ${entry.text || ""}`);
|
|
}
|
|
}
|
|
lines.push("");
|
|
lines.push("</details>");
|
|
}
|
|
lines.push("");
|
|
});
|
|
}
|
|
|
|
// Full unattributed transcript at the bottom — useful for grep'ing
|
|
// and as a clean LLM-input form. Always emitted so downloads are
|
|
// self-contained.
|
|
if (rec.transcript) {
|
|
lines.push("");
|
|
lines.push("## Full transcript (bracketed)");
|
|
lines.push("");
|
|
lines.push("```");
|
|
lines.push(rec.transcript);
|
|
lines.push("```");
|
|
}
|
|
|
|
return lines.join("\n");
|
|
}
|
|
|
|
// ─── HTML formatter ─────────────────────────────────────────────────
|
|
// Produces a fully self-contained HTML page that renders the meeting
|
|
// in the same Recaps-style layout as the dashboard's detail view —
|
|
// title, summary stats, speaker legend, topic cards with native
|
|
// <details>-driven expandable transcript lines, and the full bracketed
|
|
// transcript at the bottom. Includes inlined CSS so it's shareable as
|
|
// a single file (email attachment, drag-into-browser, link from a
|
|
// shared drive, etc.) and a print-friendly fallback.
|
|
//
|
|
// Phase-2 reserve: when `rec.extras` lands (Decisions / Action Items /
|
|
// Open Questions / Key Quotes), this function will render those above
|
|
// the topics. For now it just skips that section gracefully.
|
|
|
|
function htmlEsc(s) {
|
|
return String(s == null ? "" : s)
|
|
.replace(/&/g, "&")
|
|
.replace(/</g, "<")
|
|
.replace(/>/g, ">")
|
|
.replace(/"/g, """)
|
|
.replace(/'/g, "'");
|
|
}
|
|
|
|
// Mirror dashboard.html's meetingsSpeakerChipColor — same palette so a
|
|
// speaker has the same color across the dashboard, .md, and .html.
|
|
function speakerChipColor(id) {
|
|
if (id === "Speaker_Unknown") {
|
|
return { bg: "rgba(100,116,139,0.18)", fg: "#cbd5e1", bd: "rgba(100,116,139,0.35)" };
|
|
}
|
|
const m = String(id || "").match(/^Speaker_([A-Z]+)$/);
|
|
const letters = m ? m[1] : "A";
|
|
let n = 0;
|
|
for (const c of letters) n = n * 26 + (c.charCodeAt(0) - 64);
|
|
n -= 1;
|
|
const palette = [
|
|
{ bg: "rgba(239,68,68,0.18)", fg: "#fca5a5", bd: "rgba(239,68,68,0.35)" },
|
|
{ bg: "rgba(59,130,246,0.18)", fg: "#93c5fd", bd: "rgba(59,130,246,0.35)" },
|
|
{ bg: "rgba(34,197,94,0.18)", fg: "#86efac", bd: "rgba(34,197,94,0.35)" },
|
|
{ bg: "rgba(245,158,11,0.18)", fg: "#fcd34d", bd: "rgba(245,158,11,0.35)" },
|
|
{ bg: "rgba(168,85,247,0.18)", fg: "#d8b4fe", bd: "rgba(168,85,247,0.35)" },
|
|
{ bg: "rgba(14,165,233,0.18)", fg: "#7dd3fc", bd: "rgba(14,165,233,0.35)" },
|
|
{ bg: "rgba(236,72,153,0.18)", fg: "#f9a8d4", bd: "rgba(236,72,153,0.35)" },
|
|
{ bg: "rgba(100,116,139,0.18)",fg: "#cbd5e1", bd: "rgba(100,116,139,0.35)" },
|
|
];
|
|
return palette[((n % 8) + 8) % 8];
|
|
}
|
|
|
|
function speakerChipLabel(id, speakerNames) {
|
|
if (id === "Speaker_Unknown") return "?";
|
|
const inferred = speakerNames && typeof speakerNames[id] === "string" && speakerNames[id].trim();
|
|
if (inferred) {
|
|
const parts = inferred.split(/\s+/).filter(Boolean);
|
|
if (parts.length === 1) return parts[0][0].toUpperCase();
|
|
return (parts[0][0] + parts[parts.length - 1][0]).toUpperCase();
|
|
}
|
|
const m = String(id).match(/^Speaker_([A-Z]+)$/);
|
|
return m ? m[1] : "?";
|
|
}
|
|
|
|
function renderChipHtml(speakerId, confidence, uncertain, speakerNames) {
|
|
if (!speakerId) return "";
|
|
const c = speakerChipColor(speakerId);
|
|
const label = speakerChipLabel(speakerId, speakerNames);
|
|
const showQ = uncertain || (typeof confidence === "number" && confidence < 0.5);
|
|
const text = label + (showQ ? "?" : "");
|
|
const full = speakerDisplayName(speakerId, speakerNames);
|
|
const tooltip = speakerId === "Speaker_Unknown"
|
|
? "Unknown speaker (brief utterance, no anchor match)"
|
|
: (showQ ? full + " — best-guess attribution" : full);
|
|
return (
|
|
`<span class="chip" style="background:${c.bg};color:${c.fg};border-color:${c.bd};" ` +
|
|
`title="${htmlEsc(tooltip)}">${htmlEsc(text)}</span>`
|
|
);
|
|
}
|
|
|
|
// Renders the Phase 2 extras block for the self-contained .html
|
|
// download. Mirrors the dashboard's renderMeetingExtras layout —
|
|
// four collapsible sections (Decisions / Action items / Open
|
|
// questions / Key quotes), each item with inline speaker chips +
|
|
// timestamp links. Timestamps in the downloaded file are NOT
|
|
// clickable (static HTML); they're shown as styled tags for visual
|
|
// parity with the dashboard. Returns "" when extras is empty/null.
|
|
function renderExtrasHtml(extras, speakerNames) {
|
|
if (!extras) return "";
|
|
const tldr = extras.tldr && typeof extras.tldr === "object" ? extras.tldr : null;
|
|
const decs = Array.isArray(extras.decisions) ? extras.decisions : [];
|
|
const acts = Array.isArray(extras.action_items) ? extras.action_items : [];
|
|
const qs = Array.isArray(extras.open_questions) ? extras.open_questions : [];
|
|
const quotes = Array.isArray(extras.key_quotes) ? extras.key_quotes : [];
|
|
if (!tldr && !decs.length && !acts.length && !qs.length && !quotes.length) return "";
|
|
|
|
const tsTag = (sec) => {
|
|
if (sec == null || !Number.isFinite(sec)) return "";
|
|
return `<span class="ts-tag">${htmlEsc(formatTimestamp(sec))}</span>`;
|
|
};
|
|
const inlineChip = (sid) => {
|
|
if (!sid) return "";
|
|
const c = speakerChipColor(sid);
|
|
const label = speakerChipLabel(sid, speakerNames);
|
|
const full = sid === "Speaker_Unknown" ? "Unknown" : speakerDisplayName(sid, speakerNames);
|
|
return (
|
|
`<span class="inline-chip">` +
|
|
`<span class="chip" style="background:${c.bg};color:${c.fg};border-color:${c.bd};">${htmlEsc(label)}</span>` +
|
|
`<span class="inline-name">${htmlEsc(full)}</span>` +
|
|
`</span>`
|
|
);
|
|
};
|
|
|
|
const section = (label, items, render, emoji) => {
|
|
if (!items.length) return "";
|
|
return (
|
|
`<details class="extras-section" open>` +
|
|
`<summary>` +
|
|
`<span class="extras-title">${emoji} ${htmlEsc(label)}</span>` +
|
|
`<span class="extras-count">· ${items.length}</span>` +
|
|
`</summary>` +
|
|
`<div class="extras-body">` + items.map(render).join("") + `</div>` +
|
|
`</details>`
|
|
);
|
|
};
|
|
|
|
const renderDecision = (d) => {
|
|
const agreed = (d.agreed_by || []).map(inlineChip).join('<span class="sep"> · </span>');
|
|
return (
|
|
`<div class="extras-item">` +
|
|
`<div class="extras-text">${htmlEsc(d.statement || "")}</div>` +
|
|
`<div class="extras-meta">` +
|
|
(d.supporting_offset != null ? tsTag(d.supporting_offset) : "") +
|
|
(agreed ? `<span class="meta-label">agreed by:</span>${agreed}` : "") +
|
|
`</div>` +
|
|
`</div>`
|
|
);
|
|
};
|
|
const renderAction = (a) => (
|
|
`<div class="extras-item">` +
|
|
`<div class="extras-text">${htmlEsc(a.description || "")}</div>` +
|
|
`<div class="extras-meta">` +
|
|
(a.supporting_offset != null ? tsTag(a.supporting_offset) : "") +
|
|
(a.owner ? `<span class="meta-label">owner:</span>${inlineChip(a.owner)}` : "") +
|
|
(a.due_hint ? `<span class="meta-due">due: ${htmlEsc(a.due_hint)}</span>` : "") +
|
|
`</div>` +
|
|
`</div>`
|
|
);
|
|
const renderQuestion = (q) => (
|
|
`<div class="extras-item">` +
|
|
`<div class="extras-text">${htmlEsc(q.question || "")}</div>` +
|
|
(q.raised_by ? `<div class="extras-meta"><span class="meta-label">raised by:</span>${inlineChip(q.raised_by)}</div>` : "") +
|
|
`</div>`
|
|
);
|
|
const renderQuote = (q) => (
|
|
`<div class="extras-item">` +
|
|
`<div class="extras-quote">"${htmlEsc(q.quote || "")}"</div>` +
|
|
`<div class="extras-meta">` +
|
|
(q.offset != null ? tsTag(q.offset) : "") +
|
|
(q.speaker ? inlineChip(q.speaker) : "") +
|
|
(q.why_notable ? `<span class="meta-due">— ${htmlEsc(q.why_notable)}</span>` : "") +
|
|
`</div>` +
|
|
`</div>`
|
|
);
|
|
|
|
// TLDR — highlighted callout above the four collapsibles. Always
|
|
// visible (not in a <details>) because it's meant as the first
|
|
// read. Mirrors the dashboard's styling pattern.
|
|
let tldrHtml = "";
|
|
if (tldr && typeof tldr.summary === "string" && tldr.summary.trim()) {
|
|
const primary = Array.isArray(tldr.primary_speakers) ? tldr.primary_speakers : [];
|
|
const primaryHtml = primary.length
|
|
? `<div class="tldr-meta"><span>primary speakers:</span>` +
|
|
primary.map(inlineChip).join(`<span class="sep"> · </span>`) +
|
|
`</div>`
|
|
: "";
|
|
tldrHtml = (
|
|
`<div class="tldr">` +
|
|
`<div class="tldr-label">TL;DR</div>` +
|
|
`<div class="tldr-summary">${htmlEsc(tldr.summary)}</div>` +
|
|
primaryHtml +
|
|
`</div>`
|
|
);
|
|
}
|
|
|
|
return (
|
|
`<section class="extras">` +
|
|
tldrHtml +
|
|
section("Decisions", decs, renderDecision, "✓") +
|
|
section("Action items", acts, renderAction, "→") +
|
|
section("Open questions", qs, renderQuestion, "?") +
|
|
section("Key quotes", quotes, renderQuote, "❝") +
|
|
`</section>`
|
|
);
|
|
}
|
|
|
|
export function meetingToHtml(rec) {
|
|
if (!rec) return "<!doctype html><html><body><p>Meeting not found.</p></body></html>";
|
|
|
|
const title = rec.title || "Untitled meeting";
|
|
const speakerNames = rec.speaker_names || {};
|
|
const speakerEntries = rec.speakers
|
|
? Object.entries(rec.speakers).sort((a, b) => {
|
|
if (a[0] === "Speaker_Unknown") return 1;
|
|
if (b[0] === "Speaker_Unknown") return -1;
|
|
return a[0].localeCompare(b[0]);
|
|
})
|
|
: [];
|
|
|
|
const dateStr = rec.created_at
|
|
? new Date(rec.created_at).toLocaleString("en-US", {
|
|
dateStyle: "medium",
|
|
timeStyle: "short",
|
|
})
|
|
: null;
|
|
|
|
const chunks = Array.isArray(rec.chunks) ? rec.chunks : [];
|
|
const metaParts = [];
|
|
if (rec.audio_seconds) metaParts.push(formatTimestamp(rec.audio_seconds));
|
|
metaParts.push(`${chunks.length} topic${chunks.length === 1 ? "" : "s"}`);
|
|
metaParts.push(`${speakerEntries.length} speaker${speakerEntries.length === 1 ? "" : "s"}`);
|
|
if (dateStr) metaParts.push(dateStr);
|
|
|
|
// ── Embed .md + .json as inline data URLs ──
|
|
// The shareable .html artifact carries the markdown and JSON
|
|
// serializations inside itself as base64 data URLs, so a recipient
|
|
// who downloads the .html (email attachment, shared drive, etc.)
|
|
// can grab either format without going back to the relay — the
|
|
// relay endpoints are admin-auth-gated anyway, so external
|
|
// recipients couldn't reach them. Self-contained = truly portable.
|
|
//
|
|
// Size overhead: base64 inflates ~33%, but the resulting blobs
|
|
// are still in the tens-of-KB range even for hour-long meetings.
|
|
// Done at HTML-build time so we don't recompute on every download
|
|
// click in the browser.
|
|
const safeFilenameBase = (title || "meeting")
|
|
.replace(/[^a-zA-Z0-9-_.]+/g, "-")
|
|
.slice(0, 80) || "meeting";
|
|
const mdContent = meetingToMarkdown(rec);
|
|
const jsonContent = JSON.stringify(rec, null, 2);
|
|
const mdDataUrl =
|
|
"data:text/markdown;charset=utf-8;base64," +
|
|
Buffer.from(mdContent, "utf8").toString("base64");
|
|
const jsonDataUrl =
|
|
"data:application/json;charset=utf-8;base64," +
|
|
Buffer.from(jsonContent, "utf8").toString("base64");
|
|
|
|
const legendHtml = speakerEntries.length
|
|
? (
|
|
`<section class="legend"><div class="legend-label">Speakers</div><div class="legend-chips">` +
|
|
speakerEntries.map(([id, stats]) => {
|
|
const c = speakerChipColor(id);
|
|
const label = speakerChipLabel(id, speakerNames);
|
|
const full = speakerDisplayName(id, speakerNames);
|
|
const secs = Math.round(stats.total_speaking_seconds || 0);
|
|
return (
|
|
`<span class="legend-chip">` +
|
|
`<span class="chip" style="background:${c.bg};color:${c.fg};border-color:${c.bd};">${htmlEsc(label)}</span>` +
|
|
`<span class="legend-name">${htmlEsc(full)}</span>` +
|
|
`<span class="legend-secs">· ${formatTimestamp(secs)}</span>` +
|
|
`</span>`
|
|
);
|
|
}).join("") +
|
|
`</div></section>`
|
|
)
|
|
: "";
|
|
|
|
const topicsHtml = chunks.length
|
|
? chunks.map((chunk, i) => {
|
|
const start = formatTimestamp(chunk.startTime || 0);
|
|
// Adjacent display: end = next chunk's start so topic ranges
|
|
// appear visually contiguous. Last chunk extends to the full
|
|
// audio duration. Fallback to last entry's offset.
|
|
let endSec;
|
|
if (i + 1 < chunks.length) {
|
|
endSec = chunks[i + 1].startTime || 0;
|
|
} else if (rec.audio_seconds) {
|
|
endSec = rec.audio_seconds;
|
|
} else {
|
|
const lastEntry = chunk.entries && chunk.entries[chunk.entries.length - 1];
|
|
endSec = lastEntry ? (lastEntry.offset || 0) : (chunk.startTime || 0);
|
|
}
|
|
const end = formatTimestamp(endSec);
|
|
const lines = (chunk.entries || []).map((entry) => {
|
|
const t = formatTimestamp(entry.offset || 0);
|
|
// Effective speaker: operator override (set via the
|
|
// dashboard's click-to-reassign UI) wins over the original
|
|
// diarization attribution. Override-source not shown in
|
|
// the static HTML download.
|
|
const effectiveSpeaker = entry.speaker_override || entry.speaker;
|
|
const chip = renderChipHtml(
|
|
effectiveSpeaker,
|
|
entry.speaker_confidence,
|
|
entry.speaker_uncertain,
|
|
speakerNames
|
|
);
|
|
return (
|
|
`<div class="line">` +
|
|
`<span class="ts">${htmlEsc(t)}</span>` +
|
|
(chip || `<span class="chip chip-empty"></span>`) +
|
|
`<span class="text">${htmlEsc(entry.text || "")}</span>` +
|
|
`</div>`
|
|
);
|
|
}).join("");
|
|
return (
|
|
`<details class="topic">` +
|
|
`<summary>` +
|
|
`<div class="topic-head">` +
|
|
`<span class="topic-title">${i + 1}. ${htmlEsc(chunk.title || "(untitled)")}</span>` +
|
|
`<span class="topic-range">${htmlEsc(start)} — ${htmlEsc(end)}</span>` +
|
|
`</div>` +
|
|
`<div class="topic-summary">${htmlEsc(chunk.summary || "")}</div>` +
|
|
`</summary>` +
|
|
`<div class="topic-body">` +
|
|
(lines || `<div class="empty-lines">No transcript entries for this topic.</div>`) +
|
|
`</div>` +
|
|
`</details>`
|
|
);
|
|
}).join("")
|
|
: `<div class="empty">No topic data — analyze may have failed.</div>`;
|
|
|
|
const transcriptHtml = rec.transcript
|
|
? (
|
|
`<details class="full-transcript">` +
|
|
`<summary>Full transcript (bracketed)</summary>` +
|
|
`<pre>${htmlEsc(rec.transcript)}</pre>` +
|
|
`</details>`
|
|
)
|
|
: "";
|
|
|
|
// Phase 2 extras (decisions / action items / open questions /
|
|
// key quotes). Renders above the topics block when present.
|
|
// Empty categories collapse; if all four are empty the block hides.
|
|
const extrasHtml = renderExtrasHtml(rec.extras, speakerNames);
|
|
|
|
const css = `
|
|
:root {
|
|
--bg: #0b1220;
|
|
--panel: #111827;
|
|
--line: rgba(148,163,184,0.18);
|
|
--fg: #e2e8f0;
|
|
--fg-dim: #cbd5e1;
|
|
--fg-faint: #94a3b8;
|
|
--accent: #60a5fa;
|
|
}
|
|
* { box-sizing: border-box; }
|
|
html, body {
|
|
margin: 0;
|
|
padding: 0;
|
|
background: var(--bg);
|
|
color: var(--fg);
|
|
font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
|
|
font-size: 14px;
|
|
line-height: 1.5;
|
|
}
|
|
main {
|
|
max-width: 920px;
|
|
margin: 0 auto;
|
|
padding: 32px 24px 64px;
|
|
}
|
|
header { margin-bottom: 18px; }
|
|
h1 {
|
|
font-size: 22px;
|
|
font-weight: 600;
|
|
margin: 0 0 6px;
|
|
color: var(--fg);
|
|
}
|
|
.meta {
|
|
font-size: 12px;
|
|
color: var(--fg-dim);
|
|
}
|
|
.header-actions {
|
|
margin-top: 12px;
|
|
display: flex;
|
|
flex-wrap: wrap;
|
|
gap: 8px;
|
|
}
|
|
.dl-btn {
|
|
display: inline-block;
|
|
padding: 6px 12px;
|
|
background: transparent;
|
|
border: 1px solid var(--line);
|
|
border-radius: 5px;
|
|
color: var(--fg);
|
|
font-size: 12px;
|
|
font-weight: 500;
|
|
text-decoration: none;
|
|
cursor: pointer;
|
|
transition: border-color 0.15s, background 0.15s;
|
|
}
|
|
.dl-btn:hover {
|
|
border-color: var(--accent);
|
|
background: rgba(96,165,250,0.08);
|
|
}
|
|
@media print {
|
|
.header-actions { display: none; }
|
|
}
|
|
.legend {
|
|
background: rgba(15,23,42,0.5);
|
|
border: 1px solid var(--line);
|
|
border-radius: 8px;
|
|
padding: 10px 14px;
|
|
margin-bottom: 16px;
|
|
}
|
|
.legend-label {
|
|
font-size: 10px;
|
|
font-weight: 600;
|
|
color: var(--fg-faint);
|
|
text-transform: uppercase;
|
|
letter-spacing: 0.06em;
|
|
margin-bottom: 8px;
|
|
}
|
|
.legend-chips { display: flex; flex-wrap: wrap; gap: 8px; }
|
|
.legend-chip {
|
|
display: inline-flex;
|
|
align-items: center;
|
|
gap: 6px;
|
|
padding: 3px 10px;
|
|
background: rgba(255,255,255,0.03);
|
|
border: 1px solid var(--line);
|
|
border-radius: 16px;
|
|
font-size: 11px;
|
|
}
|
|
.legend-name { color: var(--fg); }
|
|
.legend-secs { color: var(--fg-faint); }
|
|
.chip {
|
|
display: inline-flex;
|
|
align-items: center;
|
|
justify-content: center;
|
|
min-width: 26px;
|
|
height: 18px;
|
|
padding: 0 6px;
|
|
font-size: 10px;
|
|
font-weight: 700;
|
|
border-radius: 4px;
|
|
flex-shrink: 0;
|
|
letter-spacing: 0.02em;
|
|
line-height: 1;
|
|
font-family: ui-monospace, Menlo, Consolas, monospace;
|
|
border: 1px solid;
|
|
}
|
|
.chip-empty { background: transparent; border-color: transparent; }
|
|
/* Phase 2 extras block — TLDR + decisions / action items /
|
|
open questions / key quotes. Sits above the topics list. */
|
|
.extras { display: flex; flex-direction: column; gap: 8px; margin-bottom: 16px; }
|
|
.tldr {
|
|
background: linear-gradient(135deg, rgba(96,165,250,0.08), rgba(15,23,42,0.5));
|
|
border: 1px solid var(--line);
|
|
border-left: 3px solid var(--accent);
|
|
border-radius: 8px;
|
|
padding: 12px 16px;
|
|
}
|
|
.tldr-label {
|
|
font-size: 10px;
|
|
font-weight: 600;
|
|
color: var(--accent);
|
|
text-transform: uppercase;
|
|
letter-spacing: 0.08em;
|
|
margin-bottom: 6px;
|
|
}
|
|
.tldr-summary { font-size: 13px; line-height: 1.6; color: var(--fg); }
|
|
.tldr-meta {
|
|
margin-top: 8px;
|
|
display: flex;
|
|
flex-wrap: wrap;
|
|
gap: 8px;
|
|
align-items: center;
|
|
font-size: 11px;
|
|
color: var(--fg-faint);
|
|
}
|
|
@media print {
|
|
.tldr { background: #f5f9ff; border-color: #cbd5e1; border-left-color: #2563eb; }
|
|
.tldr-label { color: #2563eb; }
|
|
}
|
|
details.extras-section {
|
|
background: var(--panel);
|
|
border: 1px solid var(--line);
|
|
border-radius: 8px;
|
|
overflow: hidden;
|
|
}
|
|
details.extras-section > summary {
|
|
padding: 10px 14px;
|
|
cursor: pointer;
|
|
list-style: none;
|
|
display: flex;
|
|
align-items: baseline;
|
|
gap: 8px;
|
|
}
|
|
details.extras-section > summary::-webkit-details-marker { display: none; }
|
|
.extras-title { font-size: 13px; font-weight: 600; color: var(--fg); }
|
|
.extras-count { font-size: 11px; color: var(--fg-faint); }
|
|
.extras-body {
|
|
border-top: 1px solid var(--line);
|
|
padding: 8px 14px 12px;
|
|
background: rgba(15,23,42,0.3);
|
|
display: flex;
|
|
flex-direction: column;
|
|
gap: 10px;
|
|
}
|
|
.extras-item { font-size: 12px; line-height: 1.55; color: var(--fg); }
|
|
.extras-text {}
|
|
.extras-quote {
|
|
font-style: italic;
|
|
border-left: 3px solid var(--line);
|
|
padding-left: 10px;
|
|
}
|
|
.extras-meta {
|
|
margin-top: 4px;
|
|
display: flex;
|
|
flex-wrap: wrap;
|
|
gap: 8px;
|
|
align-items: center;
|
|
font-size: 11px;
|
|
color: var(--fg-faint);
|
|
}
|
|
.meta-label { color: var(--fg-faint); }
|
|
.meta-due { color: var(--fg-dim); }
|
|
.sep { color: var(--fg-faint); }
|
|
.ts-tag {
|
|
display: inline-block;
|
|
padding: 1px 6px;
|
|
border: 1px solid var(--line);
|
|
border-radius: 4px;
|
|
color: var(--accent);
|
|
font-family: ui-monospace, Menlo, Consolas, monospace;
|
|
font-size: 10.5px;
|
|
}
|
|
.inline-chip { display: inline-flex; align-items: center; gap: 4px; }
|
|
.inline-chip .chip {
|
|
min-width: 22px;
|
|
height: 16px;
|
|
padding: 0 5px;
|
|
font-size: 9px;
|
|
}
|
|
.inline-name { font-size: 11px; color: var(--fg-dim); }
|
|
.topics { display: flex; flex-direction: column; gap: 10px; }
|
|
details.topic {
|
|
background: var(--panel);
|
|
border: 1px solid var(--line);
|
|
border-radius: 8px;
|
|
padding: 0;
|
|
overflow: hidden;
|
|
}
|
|
details.topic > summary {
|
|
padding: 12px 16px;
|
|
cursor: pointer;
|
|
list-style: none;
|
|
}
|
|
details.topic > summary::-webkit-details-marker { display: none; }
|
|
.topic-head {
|
|
display: flex;
|
|
align-items: baseline;
|
|
gap: 10px;
|
|
}
|
|
.topic-title { font-size: 13px; font-weight: 600; color: var(--fg); }
|
|
.topic-range {
|
|
font-size: 10.5px;
|
|
color: var(--fg-faint);
|
|
font-family: ui-monospace, Menlo, Consolas, monospace;
|
|
}
|
|
.topic-summary {
|
|
font-size: 12px;
|
|
color: var(--fg-dim);
|
|
line-height: 1.55;
|
|
margin-top: 6px;
|
|
}
|
|
.topic-body {
|
|
border-top: 1px solid var(--line);
|
|
padding: 8px 8px 12px;
|
|
background: rgba(15,23,42,0.3);
|
|
}
|
|
.line {
|
|
display: flex;
|
|
gap: 10px;
|
|
align-items: flex-start;
|
|
padding: 4px 8px;
|
|
font-size: 12px;
|
|
line-height: 1.55;
|
|
color: var(--fg);
|
|
}
|
|
.line .ts {
|
|
font-size: 11px;
|
|
color: var(--accent);
|
|
min-width: 54px;
|
|
padding-top: 2px;
|
|
font-family: ui-monospace, Menlo, Consolas, monospace;
|
|
}
|
|
.line .text { flex: 1; }
|
|
.empty-lines, .empty {
|
|
padding: 10px 14px;
|
|
font-size: 11px;
|
|
color: var(--fg-faint);
|
|
}
|
|
details.full-transcript {
|
|
margin-top: 24px;
|
|
background: var(--panel);
|
|
border: 1px solid var(--line);
|
|
border-radius: 8px;
|
|
padding: 12px 16px;
|
|
}
|
|
details.full-transcript > summary {
|
|
cursor: pointer;
|
|
font-size: 12px;
|
|
font-weight: 600;
|
|
color: var(--fg-dim);
|
|
}
|
|
details.full-transcript pre {
|
|
margin: 12px 0 0;
|
|
padding: 12px;
|
|
background: rgba(15,23,42,0.5);
|
|
border: 1px solid var(--line);
|
|
border-radius: 6px;
|
|
font-family: ui-monospace, Menlo, Consolas, monospace;
|
|
font-size: 11px;
|
|
line-height: 1.55;
|
|
color: var(--fg-dim);
|
|
white-space: pre-wrap;
|
|
word-break: break-word;
|
|
max-height: 60vh;
|
|
overflow: auto;
|
|
}
|
|
footer {
|
|
margin-top: 32px;
|
|
padding-top: 16px;
|
|
border-top: 1px solid var(--line);
|
|
font-size: 11px;
|
|
color: var(--fg-faint);
|
|
text-align: center;
|
|
}
|
|
/* Print styles — flatten dark theme for paper. */
|
|
@media print {
|
|
html, body { background: #fff; color: #111; }
|
|
.topic, .legend, details.full-transcript { background: #fff; border-color: #ddd; }
|
|
.topic-summary, .legend-name, .meta { color: #444; }
|
|
.legend-secs, .topic-range, .empty-lines, .empty { color: #888; }
|
|
.line .ts { color: #2563eb; }
|
|
details { break-inside: avoid; }
|
|
details > summary { list-style: none; }
|
|
details, details > summary { display: block !important; }
|
|
details > summary + * { display: block !important; }
|
|
}
|
|
`;
|
|
|
|
return (
|
|
`<!doctype html>\n<html lang="en">\n<head>\n` +
|
|
`<meta charset="utf-8">\n` +
|
|
`<meta name="viewport" content="width=device-width, initial-scale=1">\n` +
|
|
`<title>${htmlEsc(title)}</title>\n` +
|
|
`<style>${css}</style>\n` +
|
|
`</head>\n<body>\n<main>\n` +
|
|
`<header>\n` +
|
|
`<h1>${htmlEsc(title)}</h1>\n` +
|
|
`<div class="meta">${htmlEsc(metaParts.join(" · "))}</div>\n` +
|
|
// Download buttons for the .md + .json siblings — embedded in
|
|
// the .html itself as base64 data URLs so they work entirely
|
|
// offline (no relay round-trip, no auth needed). Lets a
|
|
// recipient who got the .html grab any of the three formats
|
|
// without operator access.
|
|
`<div class="header-actions">\n` +
|
|
`<a class="dl-btn" href="${mdDataUrl}" download="${htmlEsc(safeFilenameBase)}.md">Download .md</a>\n` +
|
|
`<a class="dl-btn" href="${jsonDataUrl}" download="${htmlEsc(safeFilenameBase)}.json">Download .json</a>\n` +
|
|
`</div>\n` +
|
|
`</header>\n` +
|
|
legendHtml +
|
|
extrasHtml +
|
|
`<section class="topics">${topicsHtml}</section>\n` +
|
|
transcriptHtml +
|
|
`<footer>Generated by Recap Relay · Internal Meetings</footer>\n` +
|
|
`</main>\n</body>\n</html>\n`
|
|
);
|
|
}
|
|
|
|
// ─── Pipeline orchestrator ──────────────────────────────────────────
|
|
// Runs the full hardware pipeline on an uploaded audio file. Mirrors
|
|
// the relevant portion of summarize-url.js but without the URL
|
|
// download / credit accounting / Recaps-app envelope layers.
|
|
|
|
async function runMeetingPipeline({
|
|
dataDir,
|
|
jobId,
|
|
audioPath,
|
|
mimeType,
|
|
audioSec,
|
|
title,
|
|
participants,
|
|
notes = "",
|
|
}) {
|
|
const cfg = await getConfigSnapshot();
|
|
const hw = await resolveHardwareConfig(cfg);
|
|
if (!hw.transcribe.url) {
|
|
throw new Error(
|
|
"hardware transcribe not available — Spark Control discovery isn't reporting a ready endpoint"
|
|
);
|
|
}
|
|
|
|
// ── Acquire hardware FIFO slot ──
|
|
const release = await acquireHardwareSlot({
|
|
jobId,
|
|
onWait: ({ position, activeJobId }) => {
|
|
appendEvent(jobId, "queued", {
|
|
position,
|
|
activeJobId: activeJobId || null,
|
|
});
|
|
setProgress(
|
|
jobId,
|
|
`queued — ${position} job(s) ahead on operator hardware`
|
|
);
|
|
},
|
|
});
|
|
|
|
try {
|
|
markRunning(jobId);
|
|
appendEvent(jobId, "progress", { message: "reading audio…" });
|
|
|
|
const audioBuf = await fs.readFile(audioPath);
|
|
|
|
// Build analyze backend up-front so the pipelined-analyze worker
|
|
// can fire windows as soon as their chunks arrive.
|
|
const analyzeBackend = createHardwareBackend({
|
|
parakeetBaseURL: hw.transcribe.url || "",
|
|
gemmaBaseURL: hw.analyze.url,
|
|
sparkControlBaseURL: hw.sparkBase || "",
|
|
parakeetModel: hw.transcribe.model || "",
|
|
gemmaModel: hw.analyze.model || "",
|
|
anMaxTokens: cfg.relay_hardware_an_max_tokens || 16000,
|
|
});
|
|
|
|
const bodyMin = cfg.relay_hardware_analyze_window_minutes || 18;
|
|
const overlapMin = cfg.relay_hardware_analyze_overlap_minutes || 2;
|
|
const anConcurrency = cfg.relay_hardware_analyze_concurrency || 8;
|
|
const cutoffMin = cfg.relay_analyze_cutoff_minutes || 25;
|
|
const targetTotalsByBucket = {
|
|
under_30: cfg.relay_analyze_total_sections_under_30,
|
|
"30_60": cfg.relay_analyze_total_sections_30_60,
|
|
"60_90": cfg.relay_analyze_total_sections_60_90,
|
|
"90_120": cfg.relay_analyze_total_sections_90_120,
|
|
"120_150": cfg.relay_analyze_total_sections_120_150,
|
|
"150_180": cfg.relay_analyze_total_sections_150_180,
|
|
over_180: cfg.relay_analyze_total_sections_over_180,
|
|
};
|
|
const analyzePromptOverride =
|
|
cfg.relay_analyze_prompt || cfg.relay_analyze_prompt_default || "";
|
|
const computeCostDetails = () => ({
|
|
input_tokens: 0,
|
|
output_tokens: 0,
|
|
thinking_tokens: 0,
|
|
cost_usd: 0,
|
|
});
|
|
|
|
const chunkBuffer = createChunkBuffer();
|
|
const pipelinedAnalyzePromise = runPipelinedAnalysis({
|
|
audioDurationSec: audioSec || 0,
|
|
waitForTime: (sec) => chunkBuffer.waitForTime(sec),
|
|
getReadySegments: (s, e) => chunkBuffer.getSegments(s, e),
|
|
bodySeconds: bodyMin * 60,
|
|
overlapSeconds: overlapMin * 60,
|
|
cutoffSeconds: cutoffMin * 60,
|
|
concurrency: anConcurrency,
|
|
backend: analyzeBackend,
|
|
pipelineBackend: "hardware",
|
|
jobId,
|
|
batchId: null,
|
|
mediaUrl: null,
|
|
title: title || null,
|
|
installId: "internal-meetings",
|
|
licenseFingerprint: null,
|
|
source: "internal-meetings",
|
|
computeCostDetails,
|
|
analyzePromptOverride,
|
|
targetTotalsByBucket,
|
|
onWindowComplete: (cb) => {
|
|
appendEvent(jobId, "window_complete", {
|
|
windowIdx: cb.windowIdx,
|
|
totalWindows: cb.totalWindows,
|
|
ownedSections: cb.ownedSections,
|
|
windowEntries: cb.windowEntries || undefined,
|
|
windowBodySeconds: cb.windowBodySeconds,
|
|
model: cb.model,
|
|
durationMs: cb.durationMs,
|
|
});
|
|
setProgress(
|
|
jobId,
|
|
`analyze window ${cb.windowIdx + 1}/${cb.totalWindows} done`
|
|
);
|
|
},
|
|
}).catch((err) => ({ __error: err }));
|
|
|
|
const transcribeBackend = createHardwareBackend({
|
|
parakeetBaseURL: hw.transcribe.url || "",
|
|
gemmaBaseURL: hw.analyze.url || "",
|
|
sparkControlBaseURL: hw.sparkBase || "",
|
|
parakeetModel: hw.transcribe.model || "",
|
|
gemmaModel: hw.analyze.model || "",
|
|
txChunkSeconds: (cfg.relay_hardware_tx_chunk_minutes || 5) * 60,
|
|
txChunkOverlapSeconds:
|
|
cfg.relay_hardware_tx_chunk_overlap_seconds ?? 30,
|
|
diarizationEnabled: !!cfg.relay_hardware_diarization_enabled,
|
|
clusterThresholdPct:
|
|
cfg.relay_hardware_voice_clustering_threshold ?? 70,
|
|
anchorMinSpeakingSec:
|
|
cfg.relay_hardware_anchor_min_speaking_sec ?? 30,
|
|
smallClusterMaxSpeakingSec:
|
|
cfg.relay_hardware_small_cluster_max_speaking_sec ?? 15,
|
|
uncertainMarginPct: cfg.relay_hardware_uncertain_margin_pct ?? 10,
|
|
txConcurrency: cfg.relay_hardware_tx_concurrency || 4,
|
|
anMaxTokens: cfg.relay_hardware_an_max_tokens || 16000,
|
|
onChunkComplete: (cd) => chunkBuffer.add(cd),
|
|
});
|
|
|
|
const txResult = await transcribeBackend.transcribeAudio({
|
|
audio: audioBuf,
|
|
mimeType,
|
|
offsetSeconds: 0,
|
|
});
|
|
|
|
appendEvent(jobId, "transcribe_complete", {
|
|
transcript: txResult.text || "",
|
|
model: txResult.model || null,
|
|
chunk_count: txResult.chunk_count ?? null,
|
|
audio_seconds: audioSec || null,
|
|
});
|
|
|
|
// Await the pipelined analyze.
|
|
const pipelinedRaw = await pipelinedAnalyzePromise;
|
|
if (pipelinedRaw && pipelinedRaw.__error) {
|
|
throw pipelinedRaw.__error;
|
|
}
|
|
|
|
// Remap window-local section indices to global canonical indices,
|
|
// mirroring summarize-url.js's post-pipeline stitch.
|
|
const canonicalEntries = parseBracketedTranscript(txResult.text || "");
|
|
const syntheticResults = (pipelinedRaw.windowResults || []).map((wr) => {
|
|
if (!wr || !wr.ok) return wr;
|
|
const w = wr.window;
|
|
const globalStartIdx = firstEntryAtOrAfter(canonicalEntries, w.startSec);
|
|
const globalBodyStartIdx = firstEntryAtOrAfter(
|
|
canonicalEntries,
|
|
w.bodyStartSec
|
|
);
|
|
const globalEndIdx = lastEntryBefore(
|
|
canonicalEntries,
|
|
w.windowEndSec + 0.5
|
|
);
|
|
if (
|
|
globalStartIdx >= canonicalEntries.length ||
|
|
globalEndIdx < globalStartIdx
|
|
) {
|
|
return {
|
|
window: { startIdx: 0, endIdx: -1, bodyStartIdx: 0 },
|
|
ok: false,
|
|
error: new Error("pipelined window had no canonical entries"),
|
|
};
|
|
}
|
|
const remapped = [];
|
|
for (const s of wr.sections || []) {
|
|
const localStartEntry = wr.windowEntries?.[s.startIndex];
|
|
const localEndEntry = wr.windowEntries?.[s.endIndex];
|
|
if (!localStartEntry || !localEndEntry) continue;
|
|
const globalStart = canonicalIndexForOffset(
|
|
canonicalEntries,
|
|
localStartEntry.offset || 0
|
|
);
|
|
const globalEnd = canonicalIndexForOffset(
|
|
canonicalEntries,
|
|
localEndEntry.offset || 0
|
|
);
|
|
if (globalStart < 0 || globalEnd < 0) continue;
|
|
remapped.push({
|
|
startIndex: globalStart - globalStartIdx,
|
|
endIndex: globalEnd - globalStartIdx,
|
|
title: s.title,
|
|
summary: s.summary,
|
|
});
|
|
}
|
|
return {
|
|
window: {
|
|
startIdx: globalStartIdx,
|
|
endIdx: globalEndIdx,
|
|
bodyStartIdx: globalBodyStartIdx,
|
|
},
|
|
ok: true,
|
|
sections: remapped,
|
|
model: wr.model,
|
|
};
|
|
});
|
|
const stitched = stitchAnalysisResults(syntheticResults);
|
|
let analyzeResult = {
|
|
text: JSON.stringify({ sections: stitched }),
|
|
model: pipelinedRaw.dominantModel,
|
|
attempts: pipelinedRaw.attempts,
|
|
};
|
|
|
|
// ── Polish pass ──
|
|
let speakerNames = null;
|
|
const polishEnabled = cfg.relay_post_cluster_polish_enabled !== false;
|
|
const detectedSpeakerCount = Object.keys(txResult?.speakers || {}).length;
|
|
const parsedAnalysis = JSON.parse(analyzeResult.text);
|
|
const polishableSections = Array.isArray(parsedAnalysis.sections)
|
|
? parsedAnalysis.sections
|
|
: null;
|
|
if (
|
|
polishEnabled &&
|
|
detectedSpeakerCount >= 2 &&
|
|
Array.isArray(txResult?.segments) &&
|
|
polishableSections &&
|
|
polishableSections.length > 0
|
|
) {
|
|
appendEvent(jobId, "progress", { message: "polishing summaries…" });
|
|
try {
|
|
speakerNames = await runNameInference({
|
|
speakers: txResult.speakers,
|
|
transcriptSegments: txResult.segments,
|
|
channelHint: "",
|
|
titleHint: title || "",
|
|
// descriptionHint stays empty for internal meetings —
|
|
// we don't want to stuff participants into the "Description"
|
|
// metadata field where the LLM might read them as factual
|
|
// metadata about the meeting. They go through the explicit
|
|
// OPERATOR HINTS pathway instead, which the prompt warns
|
|
// the model to treat as suggestion-not-truth.
|
|
descriptionHint: "",
|
|
participantHints: Array.isArray(participants) && participants.length
|
|
? participants.join(", ")
|
|
: "",
|
|
operatorNotes: notes || "",
|
|
backend: analyzeBackend,
|
|
pipelineBackend: "hardware",
|
|
jobId,
|
|
batchId: null,
|
|
mediaUrl: null,
|
|
installId: "internal-meetings",
|
|
licenseFingerprint: null,
|
|
source: "internal-meetings",
|
|
computeCostDetails,
|
|
});
|
|
|
|
const canonicalForPolish = parseBracketedTranscript(
|
|
txResult.text || ""
|
|
);
|
|
const { planWindowsByDuration } = await import("../chunked-analyze.js");
|
|
const windowsForPolish = planWindowsByDuration({
|
|
totalAudioSec: audioSec || 0,
|
|
bodySeconds: bodyMin * 60,
|
|
overlapSeconds: overlapMin * 60,
|
|
cutoffSeconds: cutoffMin * 60,
|
|
});
|
|
const polishedSections = await runSummaryPolish({
|
|
sections: polishableSections,
|
|
canonicalEntries: canonicalForPolish,
|
|
windows: windowsForPolish,
|
|
transcriptSegments: txResult.segments,
|
|
speakerNames,
|
|
speakerStats: txResult.speakers,
|
|
backend: analyzeBackend,
|
|
concurrency: anConcurrency,
|
|
pipelineBackend: "hardware",
|
|
jobId,
|
|
batchId: null,
|
|
mediaUrl: null,
|
|
installId: "internal-meetings",
|
|
licenseFingerprint: null,
|
|
source: "internal-meetings",
|
|
computeCostDetails,
|
|
});
|
|
analyzeResult = {
|
|
...analyzeResult,
|
|
text: JSON.stringify({ sections: polishedSections }),
|
|
};
|
|
} catch (err) {
|
|
console.warn(
|
|
`[internal-meetings ${jobId.slice(0, 8)}] polish failed (keeping unpolished output): ${err?.message || err}`
|
|
);
|
|
speakerNames = null;
|
|
}
|
|
}
|
|
|
|
// Build the chunks shape Recaps-style rendering expects:
|
|
// chunks[i] = { title, summary, startTime, entries: [...] }
|
|
//
|
|
// Gap-absorbing slice: the LLM's analyze pass returns section
|
|
// ranges (startIndex/endIndex) that don't always cover every
|
|
// entry — short audio especially produces gaps where the model
|
|
// skipped over filler ("uh", "yeah, OK") between coherent
|
|
// topics. The naive slice(start, end+1) drops those orphaned
|
|
// entries entirely, so the user sees topic cards with one
|
|
// statement under a summary that clearly references more
|
|
// dialogue, and big un-rendered gaps between consecutive topic
|
|
// timestamps (e.g. 2:10 → 2:56 with nothing shown in between).
|
|
//
|
|
// We extend each chunk's end to one before the NEXT chunk's
|
|
// start (so consecutive topics are exactly adjacent), and the
|
|
// final chunk extends to the end of the transcript. Chunk 0
|
|
// backfills to entry 0 to absorb any opening preamble the LLM
|
|
// skipped. Result: every canonical entry lives in exactly one
|
|
// chunk's entries[], no transcript line is hidden, and topic
|
|
// ranges in the UI become contiguous.
|
|
//
|
|
// The LLM's original (uncovered) ranges stay in
|
|
// `analysis.sections` (saved with the record) for forensics —
|
|
// we only adjust the rendered `chunks`.
|
|
const finalAnalysis = JSON.parse(analyzeResult.text);
|
|
const sortedSections = (finalAnalysis.sections || [])
|
|
.slice()
|
|
.sort((a, b) => (a.startIndex ?? 0) - (b.startIndex ?? 0));
|
|
const lastEntryIdx = canonicalEntries.length - 1;
|
|
const chunks = sortedSections
|
|
.map((s, idx, arr) => {
|
|
let start = Math.max(0, s.startIndex ?? 0);
|
|
let end = Math.min(lastEntryIdx, s.endIndex ?? start);
|
|
// First chunk absorbs any pre-topic preamble.
|
|
if (idx === 0) start = 0;
|
|
// Non-final chunks extend to one before the next chunk's
|
|
// start. We take the MAX of (LLM-provided end, next-1) so
|
|
// we don't shrink a section the LLM intentionally made
|
|
// wider than the gap suggests.
|
|
if (idx + 1 < arr.length) {
|
|
const nextStart = arr[idx + 1].startIndex ?? canonicalEntries.length;
|
|
end = Math.max(end, Math.min(lastEntryIdx, nextStart - 1));
|
|
} else {
|
|
// Last section absorbs any trailing entries.
|
|
end = lastEntryIdx;
|
|
}
|
|
// Defensive clamps in case the LLM emitted backwards ranges.
|
|
if (end < start) end = start;
|
|
const slice = canonicalEntries.slice(start, end + 1);
|
|
return {
|
|
title: s.title,
|
|
summary: s.summary,
|
|
entries: slice,
|
|
startTime: slice[0]?.offset || 0,
|
|
};
|
|
})
|
|
.filter((c) => c.entries.length > 0);
|
|
|
|
// Attach speakers to each entry by timestamp match.
|
|
//
|
|
// Tricky bit: `entry.offset` came from parseBracketedTranscript,
|
|
// which extracted an INTEGER seconds value from a [m:ss] / [h:mm:ss]
|
|
// bracket. That bracket was originally emitted by formatMmSs in
|
|
// hardware.js using Math.floor(seg.start). So `entry.offset` is
|
|
// exactly Math.floor(sourceSegment.start). The segments' own
|
|
// `start` field still carries float precision.
|
|
//
|
|
// The earlier strict containment check (`seg.start <= t <= seg.end`)
|
|
// misses every entry where seg.start has a fractional part — e.g.
|
|
// seg.start=0.32 and t=0 fails because 0 < 0.32. That's why the
|
|
// detail view rendered no chips at all even though the speakers
|
|
// legend showed the diarized roster.
|
|
//
|
|
// Build a floored-start index for O(1) lookup, with a tolerant
|
|
// fallback for the rare cases where mergeShortEntries dropped a
|
|
// line.
|
|
if (Array.isArray(txResult.segments) && txResult.segments.length) {
|
|
const sortedSegs = txResult.segments
|
|
.slice()
|
|
.sort((a, b) => (a.start || 0) - (b.start || 0));
|
|
const segByFlooredStart = new Map();
|
|
for (const seg of sortedSegs) {
|
|
const k = Math.floor(seg.start || 0);
|
|
if (!segByFlooredStart.has(k)) segByFlooredStart.set(k, seg);
|
|
}
|
|
const pickSpeaker = (t) => {
|
|
// Primary: exact floored-start match — this is the segment
|
|
// that produced the bracket the entry was parsed from.
|
|
let found = segByFlooredStart.get(t);
|
|
if (found && found.speaker) return found;
|
|
// Secondary: containing segment (covers gaps where the
|
|
// bracket-source segment had no speaker but a neighboring
|
|
// diar segment does cover this timestamp).
|
|
for (const seg of sortedSegs) {
|
|
if ((seg.start || 0) > t + 5) break;
|
|
if ((seg.start || 0) - 0.5 <= t && t <= (seg.end || 0) + 0.5) {
|
|
if (seg.speaker) return seg;
|
|
}
|
|
}
|
|
// Tertiary: nearest preceding segment within 5s window.
|
|
let bestPrev = null;
|
|
let bestDist = Infinity;
|
|
for (const seg of sortedSegs) {
|
|
if ((seg.start || 0) > t) break;
|
|
const dist = t - (seg.start || 0);
|
|
if (dist < bestDist && seg.speaker) {
|
|
bestDist = dist;
|
|
bestPrev = seg;
|
|
}
|
|
}
|
|
if (bestPrev && bestDist <= 5) return bestPrev;
|
|
return null;
|
|
};
|
|
for (const chunk of chunks) {
|
|
for (const entry of chunk.entries) {
|
|
const t = entry.offset || 0;
|
|
const found = pickSpeaker(t);
|
|
if (found && found.speaker) {
|
|
entry.speaker = found.speaker;
|
|
entry.speaker_confidence = found.speaker_confidence ?? null;
|
|
entry.speaker_uncertain = !!found.speaker_uncertain;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
const transcriptSegments = Array.isArray(txResult?.segments)
|
|
? txResult.segments.map((s) => ({
|
|
start: s.start || 0,
|
|
end: s.end || 0,
|
|
text: s.text || "",
|
|
speaker: s.speaker || null,
|
|
speaker_confidence: s.speaker_confidence ?? null,
|
|
speaker_uncertain: !!s.speaker_uncertain,
|
|
}))
|
|
: null;
|
|
|
|
// ── Phase 2: Meeting extras ──
|
|
// Single LLM pass to pull out structured information operators
|
|
// want at the top of a meeting recap: decisions, action items,
|
|
// open questions, key quotes. Each item carries speaker IDs +
|
|
// offsets so the dashboard can render speaker chips and
|
|
// clickable timestamps that jump to the supporting transcript
|
|
// line. Failure is non-fatal — rec.extras stays null and the
|
|
// UI just hides the section.
|
|
const extrasEnabled = cfg.relay_meeting_extras_enabled !== false;
|
|
let extras = null;
|
|
if (extrasEnabled && Array.isArray(transcriptSegments) && transcriptSegments.length) {
|
|
appendEvent(jobId, "progress", { message: "extracting decisions + action items…" });
|
|
try {
|
|
extras = await runMeetingExtras({
|
|
title,
|
|
audioSec: audioSec || 0,
|
|
speakers: txResult.speakers || {},
|
|
speakerNames: speakerNames || {},
|
|
transcriptSegments,
|
|
topics: chunks.map((c) => ({
|
|
title: c.title,
|
|
summary: c.summary,
|
|
startTime: c.startTime,
|
|
})),
|
|
// Operator hints passed through to the extras prompt the
|
|
// same way they're passed to name-inference — explicit
|
|
// hints, framed in the prompt as suggestions, not truth.
|
|
participantHints: Array.isArray(participants) && participants.length
|
|
? participants.join(", ")
|
|
: "",
|
|
operatorNotes: notes || "",
|
|
promptOverride: cfg.relay_meeting_extras_prompt || "",
|
|
backend: analyzeBackend,
|
|
pipelineBackend: "hardware",
|
|
jobId,
|
|
installId: "internal-meetings",
|
|
licenseFingerprint: null,
|
|
source: "internal-meetings",
|
|
computeCostDetails,
|
|
});
|
|
} catch (err) {
|
|
console.warn(
|
|
`[internal-meetings ${jobId.slice(0, 8)}] extras extraction failed (non-fatal): ${err?.message || err}`
|
|
);
|
|
extras = null;
|
|
}
|
|
}
|
|
|
|
// ── Save the record ──
|
|
// Note: `notes` from the upload form is intentionally NOT
|
|
// persisted here. Notes are LLM hints only — used by name-
|
|
// inference + extras at pipeline time, then dropped. They
|
|
// never appear in the dashboard detail view, the .md/.html/.json
|
|
// downloads, or any operator-readable artifact. The operator
|
|
// can write candid context ("Steve is the new guy still
|
|
// figuring stuff out", "John was angry about Q3") without
|
|
// worrying about it becoming part of a shareable meeting recap.
|
|
const record = {
|
|
id: jobId,
|
|
type: "internal-meeting",
|
|
title: title || "Untitled meeting",
|
|
participants: Array.isArray(participants) ? participants : [],
|
|
created_at: Date.now(),
|
|
audio_seconds: audioSec || 0,
|
|
transcript: txResult.text || "",
|
|
transcript_segments: transcriptSegments,
|
|
speakers: txResult.speakers || null,
|
|
speaker_names: speakerNames || null,
|
|
diarization: txResult.diarization || null,
|
|
chunks,
|
|
analysis: finalAnalysis,
|
|
extras,
|
|
meta: {
|
|
transcribe_model: txResult.model || null,
|
|
analyze_model: analyzeResult.model || null,
|
|
polish_done: !!speakerNames,
|
|
extras_done: !!extras,
|
|
},
|
|
};
|
|
await saveMeeting(dataDir, jobId, record);
|
|
|
|
markComplete(jobId, {
|
|
result: {
|
|
id: jobId,
|
|
title: record.title,
|
|
audio_seconds: record.audio_seconds,
|
|
topic_count: chunks.length,
|
|
speaker_count: Object.keys(record.speakers || {}).length,
|
|
named_speaker_count: speakerNames
|
|
? Object.values(speakerNames).filter(Boolean).length
|
|
: 0,
|
|
},
|
|
credit_charged: 0,
|
|
tier: "operator",
|
|
});
|
|
console.log(
|
|
`[internal-meetings ${jobId.slice(0, 8)}] complete — ${chunks.length} topics, ${Object.keys(record.speakers || {}).length} speakers`
|
|
);
|
|
} finally {
|
|
release();
|
|
// ALWAYS delete the uploaded audio file after processing (success
|
|
// or failure). The relay never retains audio for internal
|
|
// meetings — same policy as the YouTube/podcast download path.
|
|
try {
|
|
await fs.unlink(audioPath);
|
|
} catch {}
|
|
}
|
|
}
|
|
|
|
// ─── Router ─────────────────────────────────────────────────────────
|
|
|
|
export function internalMeetingsRouter({ dataDir }) {
|
|
const router = express.Router();
|
|
|
|
// Multer config: write uploads to OS tmp dir; we move/process and
|
|
// delete in the pipeline. memoryStorage would buffer the whole
|
|
// file in RAM — fine for short meetings, risky for 4-hour ones.
|
|
const upload = multer({
|
|
storage: multer.diskStorage({
|
|
destination: (_req, _file, cb) => {
|
|
fs.mkdtemp(path.join(os.tmpdir(), "relay-meeting-"))
|
|
.then((dir) => cb(null, dir))
|
|
.catch((err) => cb(err));
|
|
},
|
|
filename: (_req, file, cb) => {
|
|
// Preserve extension for mimeType detection downstream
|
|
const ext = path.extname(file.originalname || "") || ".bin";
|
|
cb(null, `upload${ext}`);
|
|
},
|
|
}),
|
|
limits: { fileSize: MAX_UPLOAD_BYTES },
|
|
});
|
|
|
|
// POST /admin/internal-meetings/upload
|
|
// multipart fields:
|
|
// file — audio (required)
|
|
// title — string (optional)
|
|
// participants — CSV string of attendee names (optional, treated
|
|
// as HINTS only by the LLM)
|
|
// notes — free-form prose context for the LLM. Used by
|
|
// the name-inference + extras prompts as a soft
|
|
// signal for who-said-what attribution.
|
|
router.post("/upload", upload.single("file"), async (req, res) => {
|
|
const file = req.file;
|
|
if (!file) {
|
|
return res.status(400).json({ error: "no file uploaded" });
|
|
}
|
|
const title = (req.body?.title || "").toString().slice(0, 200);
|
|
const participantsCsv = (req.body?.participants || "").toString();
|
|
const participants = participantsCsv
|
|
.split(",")
|
|
.map((s) => s.trim())
|
|
.filter(Boolean)
|
|
.slice(0, 30); // soft cap
|
|
// Notes — free-form context the operator wants the LLM to factor
|
|
// in. Trimmed + clamped to 4000 chars (matches the cap in
|
|
// post-cluster-polish.js / meeting-extras.js so we don't store
|
|
// more than we'll ever send to the model). Empty string when
|
|
// not provided.
|
|
const notes = (req.body?.notes || "").toString().trim().slice(0, 4000);
|
|
|
|
// Probe audio duration up-front so the pipeline knows the
|
|
// window plan size. Falls back to 0 if probe fails (pipeline
|
|
// will single-shot in that case).
|
|
let audioSec = 0;
|
|
try {
|
|
audioSec = await getAudioDurationSeconds(file.path);
|
|
} catch (err) {
|
|
console.warn(
|
|
`[internal-meetings] duration probe failed for ${file.path}: ${err?.message || err}`
|
|
);
|
|
}
|
|
|
|
const job = createJob({
|
|
kind: "internal-meeting",
|
|
installId: "internal-meetings",
|
|
metadata: {
|
|
title,
|
|
participants,
|
|
notes,
|
|
audio_seconds: audioSec,
|
|
original_filename: file.originalname || null,
|
|
size_bytes: file.size,
|
|
},
|
|
});
|
|
|
|
console.log(
|
|
`[internal-meetings ${job.id.slice(0, 8)}] upload received — ${file.originalname || "(no name)"} ${Math.round((file.size || 0) / (1024 * 1024))}MB, ${Math.round(audioSec / 60)} min audio, title="${title}"${notes ? `, notes=${notes.length} chars` : ""}`
|
|
);
|
|
|
|
// Kick off pipeline in the background. Don't await — we return
|
|
// the job ID immediately so the client can subscribe via SSE.
|
|
(async () => {
|
|
try {
|
|
await runMeetingPipeline({
|
|
dataDir,
|
|
jobId: job.id,
|
|
audioPath: file.path,
|
|
mimeType: file.mimetype || "audio/mpeg",
|
|
audioSec,
|
|
title,
|
|
participants,
|
|
notes,
|
|
});
|
|
} catch (err) {
|
|
const msg = (err?.message || String(err)).slice(0, 400);
|
|
markFailed(job.id, "meeting_failed: " + msg);
|
|
console.error(
|
|
`[internal-meetings ${job.id.slice(0, 8)}] worker crashed:`,
|
|
err
|
|
);
|
|
// Best-effort cleanup of the temp file + dir
|
|
try {
|
|
await fs.unlink(file.path);
|
|
} catch {}
|
|
try {
|
|
await fs.rmdir(path.dirname(file.path));
|
|
} catch {}
|
|
}
|
|
})();
|
|
|
|
res.json({
|
|
job_id: job.id,
|
|
title,
|
|
audio_seconds: audioSec,
|
|
participants,
|
|
notes,
|
|
});
|
|
});
|
|
|
|
// GET /admin/internal-meetings/jobs/:id/stream
|
|
// SSE stream of live progress events. Same event types
|
|
// summarize-url emits: progress, queued, transcribe_complete,
|
|
// window_complete, done, error.
|
|
router.get("/jobs/:id/stream", (req, res) => {
|
|
const job = getJob(req.params.id);
|
|
if (!job) {
|
|
res.status(404).json({ error: "no such job" });
|
|
return;
|
|
}
|
|
res.setHeader("Content-Type", "text/event-stream");
|
|
res.setHeader("Cache-Control", "no-cache, no-transform");
|
|
res.setHeader("Connection", "keep-alive");
|
|
res.flushHeaders?.();
|
|
|
|
const send = (ev) => {
|
|
try {
|
|
res.write(`event: ${ev.type}\ndata: ${JSON.stringify(ev.data || {})}\n\n`);
|
|
} catch {}
|
|
};
|
|
|
|
// Replay any events that already happened before this connection
|
|
// opened — clients that subscribe after the job has progressed
|
|
// would otherwise miss them.
|
|
for (const ev of job.events) send(ev);
|
|
if (job.status === "complete" || job.status === "failed") {
|
|
// Already terminal; close the stream after replay.
|
|
res.end();
|
|
return;
|
|
}
|
|
|
|
const unsubscribe = subscribeToJob(job.id, (ev) => {
|
|
send(ev);
|
|
if (ev.type === "done" || ev.type === "error") {
|
|
try {
|
|
res.end();
|
|
} catch {}
|
|
}
|
|
});
|
|
req.on("close", () => {
|
|
try {
|
|
unsubscribe();
|
|
} catch {}
|
|
});
|
|
});
|
|
|
|
// GET /admin/internal-meetings/jobs/:id
|
|
router.get("/jobs/:id", (req, res) => {
|
|
const job = getJob(req.params.id);
|
|
if (!job) return res.status(404).json({ error: "no such job" });
|
|
res.json({
|
|
id: job.id,
|
|
kind: job.kind,
|
|
status: job.status,
|
|
progress: job.progress,
|
|
started_at: job.started_at,
|
|
completed_at: job.completed_at,
|
|
error: job.error,
|
|
result: job.result,
|
|
});
|
|
});
|
|
|
|
// GET /admin/internal-meetings — list saved meetings
|
|
router.get("/", async (_req, res) => {
|
|
res.json({ meetings: await listMeetings(dataDir) });
|
|
});
|
|
|
|
// GET /admin/internal-meetings/:id — get full record JSON
|
|
router.get("/:id", async (req, res) => {
|
|
const rec = await loadMeeting(dataDir, req.params.id);
|
|
if (!rec) return res.status(404).json({ error: "not found" });
|
|
res.json(rec);
|
|
});
|
|
|
|
// GET /admin/internal-meetings/:id/markdown — markdown download
|
|
router.get("/:id/markdown", async (req, res) => {
|
|
const rec = await loadMeeting(dataDir, req.params.id);
|
|
if (!rec) return res.status(404).send("not found");
|
|
const md = meetingToMarkdown(rec);
|
|
const safeTitle = (rec.title || "meeting")
|
|
.replace(/[^a-zA-Z0-9-_.]+/g, "-")
|
|
.slice(0, 80);
|
|
res.setHeader("Content-Type", "text/markdown; charset=utf-8");
|
|
res.setHeader(
|
|
"Content-Disposition",
|
|
`attachment; filename="${safeTitle}.md"`
|
|
);
|
|
res.send(md);
|
|
});
|
|
|
|
// PATCH /admin/internal-meetings/:id/entries — per-line operator
|
|
// speaker re-assignment. Body shape:
|
|
// { overrides: [{ chunk_idx, entry_idx, speaker_id }] }
|
|
// - speaker_id = a known cluster id ("Speaker_A", "Speaker_Unknown")
|
|
// sets entry.speaker_override
|
|
// - speaker_id = "" CLEARS the override (reverts the line to its
|
|
// original diarization-assigned speaker, if any)
|
|
//
|
|
// We persist the override as a separate field (entry.speaker_override)
|
|
// rather than overwriting entry.speaker so provenance is never
|
|
// destroyed — the original Sortformer attribution stays for
|
|
// debugging and so the operator can always revert. All downstream
|
|
// rendering (dashboard chips, .html / .md downloads) uses
|
|
// (entry.speaker_override || entry.speaker) so corrections show
|
|
// up everywhere.
|
|
//
|
|
// Why per-line and not just per-cluster: diarization on 4+
|
|
// speakers gets noisy in real meetings — similar voices get
|
|
// merged, mid-sentence speaker swaps get assigned to the wrong
|
|
// person, and the LLM name-inference compounds the issue when it
|
|
// confidently guesses the wrong person from limited context.
|
|
// Per-line override is the only knob that lets the operator
|
|
// perfectly correct the transcript without re-running anything
|
|
// upstream.
|
|
router.patch("/:id/entries", express.json(), async (req, res) => {
|
|
const rec = await loadMeeting(dataDir, req.params.id);
|
|
if (!rec) return res.status(404).json({ error: "not found" });
|
|
const overrides = Array.isArray(req.body?.overrides) ? req.body.overrides : null;
|
|
if (!overrides) {
|
|
return res.status(400).json({ error: "overrides array required" });
|
|
}
|
|
const knownIds = new Set(Object.keys(rec.speakers || {}));
|
|
if (!knownIds.has("Speaker_Unknown")) knownIds.add("Speaker_Unknown");
|
|
let changed = 0;
|
|
for (const op of overrides) {
|
|
if (!op || typeof op !== "object") continue;
|
|
const ci = Number.isInteger(op.chunk_idx) ? op.chunk_idx : -1;
|
|
const ei = Number.isInteger(op.entry_idx) ? op.entry_idx : -1;
|
|
if (ci < 0 || ei < 0) continue;
|
|
const chunk = rec.chunks?.[ci];
|
|
if (!chunk) continue;
|
|
const entry = chunk.entries?.[ei];
|
|
if (!entry) continue;
|
|
const sid = typeof op.speaker_id === "string" ? op.speaker_id.trim() : "";
|
|
if (sid === "") {
|
|
if (entry.speaker_override) {
|
|
delete entry.speaker_override;
|
|
changed += 1;
|
|
}
|
|
continue;
|
|
}
|
|
if (!knownIds.has(sid)) continue; // ignore unknown ids silently
|
|
if (entry.speaker_override !== sid) {
|
|
entry.speaker_override = sid;
|
|
changed += 1;
|
|
}
|
|
}
|
|
if (changed > 0) {
|
|
rec.meta = rec.meta || {};
|
|
rec.meta.entries_edited_at = Date.now();
|
|
await saveMeeting(dataDir, req.params.id, rec);
|
|
}
|
|
res.json({ ok: true, changed });
|
|
});
|
|
|
|
// PATCH /admin/internal-meetings/:id/speakers — operator-driven
|
|
// speaker rename. Body: { speaker_names: { Speaker_A: "Matt", ... } }
|
|
// Persists into rec.speaker_names (the same field the polish-pass
|
|
// name inference writes). Markdown/HTML downloads and the
|
|
// dashboard speaker chips/legend pick this up immediately.
|
|
//
|
|
// Rationale: the LLM name inference is a best-guess from the first
|
|
// ~6 minutes of transcript context. On internal calls where
|
|
// participants speak each other's names rarely (or where the same
|
|
// first name is shared by two people), it gets things wrong. This
|
|
// endpoint lets the operator correct them after the fact. The
|
|
// change is a single field rewrite — no entry-rewriting, no
|
|
// re-clustering — because Speaker_X cluster IDs are stable; we
|
|
// just relabel the display name.
|
|
//
|
|
// Speaker MERGES (Speaker_A and Speaker_C are actually the same
|
|
// person) are a separate, harder change — they require rewriting
|
|
// every entry's .speaker and recomputing stats. Tracked as a
|
|
// follow-up; for now, two clusters with the same display name
|
|
// render with the same name on the legend but stay as distinct
|
|
// chips on the per-line attribution.
|
|
router.patch("/:id/speakers", express.json(), async (req, res) => {
|
|
const rec = await loadMeeting(dataDir, req.params.id);
|
|
if (!rec) return res.status(404).json({ error: "not found" });
|
|
const incoming = req.body?.speaker_names;
|
|
if (!incoming || typeof incoming !== "object") {
|
|
return res.status(400).json({ error: "speaker_names object required" });
|
|
}
|
|
const current = rec.speaker_names && typeof rec.speaker_names === "object"
|
|
? { ...rec.speaker_names }
|
|
: {};
|
|
// Only allow updating keys that look like cluster IDs to avoid
|
|
// junk-write attacks. Empty string clears the name (falls back
|
|
// to "Speaker X" display).
|
|
const knownIds = new Set(Object.keys(rec.speakers || {}));
|
|
let changed = 0;
|
|
for (const [id, name] of Object.entries(incoming)) {
|
|
if (!/^Speaker_[A-Z]+$/.test(id)) continue;
|
|
if (!knownIds.has(id)) continue;
|
|
const trimmed = typeof name === "string" ? name.trim().slice(0, 60) : "";
|
|
if (trimmed) {
|
|
if (current[id] !== trimmed) {
|
|
current[id] = trimmed;
|
|
changed += 1;
|
|
}
|
|
} else if (current[id]) {
|
|
delete current[id];
|
|
changed += 1;
|
|
}
|
|
}
|
|
if (changed > 0) {
|
|
rec.speaker_names = current;
|
|
// Mark that this was operator-edited so we can preserve the
|
|
// edit if/when the pipeline ever re-runs name inference.
|
|
rec.meta = rec.meta || {};
|
|
rec.meta.speaker_names_edited_at = Date.now();
|
|
await saveMeeting(dataDir, req.params.id, rec);
|
|
}
|
|
res.json({
|
|
ok: true,
|
|
changed,
|
|
speaker_names: current,
|
|
});
|
|
});
|
|
|
|
// PATCH /admin/internal-meetings/:id/merge-speakers — fold one or
|
|
// more clusters that diarization mistakenly split apart into a single
|
|
// speaker. Body: { survivor: "Speaker_A", absorbed: ["Speaker_C"] }.
|
|
// Rewrites every label reference (segments, entries, overrides),
|
|
// sums the per-cluster stats, and rewrites extras attributions. The
|
|
// survivor keeps its own display name (inheriting the absorbed name
|
|
// only if it had none). This is the inverse of a re-cluster: use it
|
|
// when ONE person was diarized as two; use re-cluster when TWO people
|
|
// were diarized as one.
|
|
router.patch("/:id/merge-speakers", express.json(), async (req, res) => {
|
|
const rec = await loadMeeting(dataDir, req.params.id);
|
|
if (!rec) return res.status(404).json({ error: "not found" });
|
|
const survivor = req.body?.survivor;
|
|
const absorbed = req.body?.absorbed;
|
|
try {
|
|
const result = mergeSpeakersInRecord(rec, survivor, absorbed);
|
|
await saveMeeting(dataDir, req.params.id, rec);
|
|
res.json({ ok: true, ...result });
|
|
} catch (err) {
|
|
if (err?.code === "BAD_REQUEST") {
|
|
return res.status(400).json({ error: err.message });
|
|
}
|
|
console.error(
|
|
`[internal-meetings] merge-speakers failed for ${req.params.id}: ${err?.message || err}`
|
|
);
|
|
res.status(500).json({ error: "merge failed" });
|
|
}
|
|
});
|
|
|
|
// POST /admin/internal-meetings/:id/recluster — re-run the cross-chunk
|
|
// voice clustering on the persisted per-chunk fingerprints at a new
|
|
// strictness threshold, to separate speakers that were over-merged
|
|
// into one cluster. Fully offline (no audio, no Spark Control). Body:
|
|
// { threshold, anchorMinSpeakingSec?, smallClusterMaxSpeakingSec?,
|
|
// uncertainMarginPct? }
|
|
// Unspecified suppression knobs fall back to the operator's global
|
|
// hardware defaults. Re-clustering changes cluster identity, so the
|
|
// inferred names, per-line overrides, and extras speaker tags are
|
|
// RESET — the operator re-labels via the legend afterward. Returns
|
|
// 400 when the meeting has no saved fingerprints (diarization was off
|
|
// or it predates fingerprint capture).
|
|
router.post("/:id/recluster", express.json(), async (req, res) => {
|
|
const rec = await loadMeeting(dataDir, req.params.id);
|
|
if (!rec) return res.status(404).json({ error: "not found" });
|
|
const cfg = await getConfigSnapshot();
|
|
const numOr = (v, fallback) => (Number.isFinite(Number(v)) ? Number(v) : fallback);
|
|
try {
|
|
const result = reclusterMeetingRecord(rec, {
|
|
threshold: numOr(
|
|
req.body?.threshold,
|
|
cfg.relay_hardware_voice_clustering_threshold ?? 70
|
|
),
|
|
anchorMinSpeakingSec: numOr(
|
|
req.body?.anchorMinSpeakingSec,
|
|
cfg.relay_hardware_anchor_min_speaking_sec ?? 30
|
|
),
|
|
smallClusterMaxSpeakingSec: numOr(
|
|
req.body?.smallClusterMaxSpeakingSec,
|
|
cfg.relay_hardware_small_cluster_max_speaking_sec ?? 15
|
|
),
|
|
uncertainMarginPct: numOr(
|
|
req.body?.uncertainMarginPct,
|
|
cfg.relay_hardware_uncertain_margin_pct ?? 10
|
|
),
|
|
});
|
|
await saveMeeting(dataDir, req.params.id, rec);
|
|
res.json({
|
|
ok: true,
|
|
speakers: result.speakers,
|
|
cluster_count: result.clusterCount,
|
|
threshold: result.threshold,
|
|
});
|
|
} catch (err) {
|
|
if (err?.code === "NO_FINGERPRINTS") {
|
|
return res.status(400).json({ error: err.message, code: "NO_FINGERPRINTS" });
|
|
}
|
|
if (err?.code === "BAD_REQUEST") {
|
|
return res.status(400).json({ error: err.message });
|
|
}
|
|
console.error(
|
|
`[internal-meetings] recluster failed for ${req.params.id}: ${err?.message || err}`
|
|
);
|
|
res.status(500).json({ error: "recluster failed" });
|
|
}
|
|
});
|
|
|
|
// POST /admin/internal-meetings/:id/repolish — re-run the Phase-2
|
|
// summary polish using the meeting's CURRENT speaker names. After the
|
|
// operator corrects names in the legend (or merges/re-runs detection),
|
|
// the topic summaries still attribute statements to the old names —
|
|
// this rewrites each topic summary against the corrected roster. It
|
|
// does NOT re-infer names (uses rec.speaker_names as-is) and does NOT
|
|
// touch transcripts, entries, or per-line overrides — only the topic
|
|
// summary text. Needs the operator's analyze hardware online (it's an
|
|
// LLM pass, one call per analysis window).
|
|
router.post("/:id/repolish", express.json(), async (req, res) => {
|
|
const rec = await loadMeeting(dataDir, req.params.id);
|
|
if (!rec) return res.status(404).json({ error: "not found" });
|
|
if (!rec.analysis || !Array.isArray(rec.analysis.sections) || rec.analysis.sections.length === 0) {
|
|
return res.status(400).json({ error: "this meeting has no analysis sections to re-polish" });
|
|
}
|
|
if (typeof rec.transcript !== "string" || !rec.transcript.trim()) {
|
|
return res.status(400).json({ error: "this meeting has no transcript to polish against" });
|
|
}
|
|
const namedCount = Object.values(rec.speaker_names || {}).filter(
|
|
(v) => typeof v === "string" && v.trim()
|
|
).length;
|
|
if (namedCount === 0) {
|
|
return res.status(400).json({
|
|
error: "no named speakers yet — rename speakers in the legend first, then re-polish",
|
|
});
|
|
}
|
|
try {
|
|
const cfg = await getConfigSnapshot();
|
|
const hw = await resolveHardwareConfig(cfg);
|
|
if (!hw.analyze || !hw.analyze.url) {
|
|
return res.status(503).json({
|
|
error: "analyze hardware not available — Spark Control isn't reporting a ready analyze endpoint",
|
|
});
|
|
}
|
|
const analyzeBackend = createHardwareBackend({
|
|
parakeetBaseURL: hw.transcribe.url || "",
|
|
gemmaBaseURL: hw.analyze.url,
|
|
sparkControlBaseURL: hw.sparkBase || "",
|
|
parakeetModel: hw.transcribe.model || "",
|
|
gemmaModel: hw.analyze.model || "",
|
|
anMaxTokens: cfg.relay_hardware_an_max_tokens || 16000,
|
|
});
|
|
const bodyMin = cfg.relay_hardware_analyze_window_minutes || 18;
|
|
const overlapMin = cfg.relay_hardware_analyze_overlap_minutes || 2;
|
|
const cutoffMin = cfg.relay_analyze_cutoff_minutes || 25;
|
|
const anConcurrency = cfg.relay_hardware_analyze_concurrency || 8;
|
|
const windows = planWindowsByDuration({
|
|
totalAudioSec: rec.audio_seconds || 0,
|
|
bodySeconds: bodyMin * 60,
|
|
overlapSeconds: overlapMin * 60,
|
|
cutoffSeconds: cutoffMin * 60,
|
|
});
|
|
const canonicalEntries = parseBracketedTranscript(rec.transcript);
|
|
const polished = await runSummaryPolish({
|
|
sections: rec.analysis.sections,
|
|
canonicalEntries,
|
|
windows,
|
|
transcriptSegments: rec.transcript_segments || [],
|
|
speakerNames: rec.speaker_names || {},
|
|
speakerStats: rec.speakers || {},
|
|
backend: analyzeBackend,
|
|
concurrency: anConcurrency,
|
|
pipelineBackend: "hardware",
|
|
jobId: "repolish-" + req.params.id,
|
|
batchId: null,
|
|
mediaUrl: null,
|
|
installId: "internal-meetings",
|
|
licenseFingerprint: null,
|
|
source: "internal-meetings",
|
|
computeCostDetails: () => ({
|
|
input_tokens: 0,
|
|
output_tokens: 0,
|
|
thinking_tokens: 0,
|
|
cost_usd: 0,
|
|
}),
|
|
});
|
|
const changed = applyPolishedSummaries(rec, polished);
|
|
rec.meta = rec.meta || {};
|
|
rec.meta.repolished_at = Date.now();
|
|
rec.meta.polish_done = true;
|
|
await saveMeeting(dataDir, req.params.id, rec);
|
|
res.json({ ok: true, polished_count: changed });
|
|
} catch (err) {
|
|
console.error(
|
|
`[internal-meetings] repolish failed for ${req.params.id}: ${err?.message || err}`
|
|
);
|
|
res.status(500).json({ error: "re-polish failed: " + (err?.message || "unknown error") });
|
|
}
|
|
});
|
|
|
|
// GET /admin/internal-meetings/:id/html — self-contained HTML
|
|
// download. Renders the same Recaps-style layout the dashboard uses,
|
|
// with inlined CSS so the file is a single shareable artifact.
|
|
router.get("/:id/html", async (req, res) => {
|
|
const rec = await loadMeeting(dataDir, req.params.id);
|
|
if (!rec) return res.status(404).send("not found");
|
|
const html = meetingToHtml(rec);
|
|
const safeTitle = (rec.title || "meeting")
|
|
.replace(/[^a-zA-Z0-9-_.]+/g, "-")
|
|
.slice(0, 80);
|
|
// ?inline=1 → render in-place (useful for clicking a saved link
|
|
// and reading it without forcing a download). Default = download.
|
|
if (req.query.inline === "1") {
|
|
res.setHeader("Content-Type", "text/html; charset=utf-8");
|
|
} else {
|
|
res.setHeader("Content-Type", "text/html; charset=utf-8");
|
|
res.setHeader(
|
|
"Content-Disposition",
|
|
`attachment; filename="${safeTitle}.html"`
|
|
);
|
|
}
|
|
res.send(html);
|
|
});
|
|
|
|
// GET /admin/internal-meetings/:id/download — raw JSON download
|
|
router.get("/:id/download", async (req, res) => {
|
|
const rec = await loadMeeting(dataDir, req.params.id);
|
|
if (!rec) return res.status(404).send("not found");
|
|
const safeTitle = (rec.title || "meeting")
|
|
.replace(/[^a-zA-Z0-9-_.]+/g, "-")
|
|
.slice(0, 80);
|
|
res.setHeader("Content-Type", "application/json; charset=utf-8");
|
|
res.setHeader(
|
|
"Content-Disposition",
|
|
`attachment; filename="${safeTitle}.json"`
|
|
);
|
|
res.send(JSON.stringify(rec, null, 2));
|
|
});
|
|
|
|
// DELETE /admin/internal-meetings/:id
|
|
router.delete("/:id", async (req, res) => {
|
|
const ok = await deleteMeeting(dataDir, req.params.id);
|
|
if (!ok) return res.status(404).json({ error: "not found" });
|
|
res.json({ deleted: true });
|
|
});
|
|
|
|
return router;
|
|
}
|