rootr-cli 0.2.0 → 0.4.0

package/lib/mcp-tools/recordings.js

@@ -0,0 +1,426 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { basename, extname, join, isAbsolute } from 'node:path';
+
+import { z } from 'zod';
+
+import { jsonResult, errorResult, makeClient, requireWorkspace } from './shared.js';
+import { RootrApiError } from '../client.js';
+
+/** 100MB — the backend's hard limit on a single audio upload. */
+const MAX_AUDIO_BYTES = 100 * 1024 * 1024;
+
+/** 확장자 → 오디오 MIME 추론 (filePath만 주면 filename/mimeType을 알아서 채운다). */
+const AUDIO_MIME_BY_EXT = {
+  '.webm': 'audio/webm',
+  '.m4a': 'audio/mp4',
+  '.mp4': 'audio/mp4',
+  '.mp3': 'audio/mpeg',
+  '.wav': 'audio/wav',
+  '.ogg': 'audio/ogg',
+  '.oga': 'audio/ogg',
+  '.flac': 'audio/flac',
+  '.aac': 'audio/aac',
+};
+
+/** Reads file bytes from a local path or a base64 string; exactly one must be given. */
+function readAudioBytes({ filePath, base64Data }) {
+  if (filePath) return readFileSync(filePath);
+  if (base64Data) return Buffer.from(base64Data, 'base64');
+  throw new RootrApiError('filePath 또는 base64Data 중 하나가 필요합니다.');
+}
+
+function pad2(n) {
+  return String(n).padStart(2, '0');
+}
+
+function clock(totalSec) {
+  const sec = Math.max(0, Math.floor(totalSec || 0));
+  const h = Math.floor(sec / 3600);
+  const m = Math.floor((sec % 3600) / 60);
+  const s = sec % 60;
+  return h > 0 ? `${h}:${pad2(m)}:${pad2(s)}` : `${pad2(m)}:${pad2(s)}`;
+}
+
+function speakerLabel(key, names) {
+  const custom = (names?.[key] || '').trim();
+  if (custom) return custom;
+  const m = /^S(\d+)$/i.exec(String(key).trim());
+  return m ? `Speaker ${m[1]}` : String(key);
+}
+
+/**
+ * REC-001 — RECORDING node (audio recording → diarized transcript → minutes).
+ * The read tool is the seam that lets a user's OWN agent do the summarization
+ * (no Rootr AI credits): read the transcript here, write the minutes with
+ * rootr_write. Audio bytes cannot be uploaded through MCP — recording happens
+ * in the Rootr web app.
+ */
+export function registerRecordingTools(server) {
+  server.registerTool(
+    'rootr_create_recording',
+    {
+      title: 'Create a Rootr recording node',
+      description:
+        'Create a new RECORDING node (audio + diarized transcript + minutes) in a Rootr (루터) workspace. ' +
+        'The node starts EMPTY. Typical flow: rootr_create_recording → rootr_upload_recording_audio (stores the ' +
+        'audio, status becomes UPLOADED) → rootr_transcribe_recording (explicitly starts speaker-labeled ' +
+        'speech-to-text; nothing is transcribed until you call it) → poll rootr_read_recording until status is ' +
+        'READY → read the transcript (and optionally name the speakers with rootr_rename_recording_speakers) → ' +
+        'write the minutes yourself with rootr_write, or call rootr_summarize_recording to use Rootr\'s built-in ' +
+        'summarizer.',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        name: z.string().optional().describe('Recording name/title, e.g. "2026-07-21 주간회의"'),
+        parentId: z.string().optional().describe('Parent folder/node id to create the recording under'),
+        path: z
+          .string()
+          .optional()
+          .describe('Tree path to create at, e.g. "/회의록/2026-07-21 주간회의" (alternative to parentId)'),
+        createParents: z
+          .boolean()
+          .optional()
+          .describe('When using `path`, create any missing parent folders (default false)'),
+        icon: z.string().optional().describe('Emoji icon for the recording node'),
+        expectedSpeakers: z
+          .array(z.string())
+          .optional()
+          .describe(
+            'Known attendees, e.g. ["김대표","이팀장"]. A naming HINT for transcription: a voice that ' +
+              'introduces itself or is addressed by name gets that name as its speaker label instead of S1. ' +
+              'Voices the model cannot identify stay anonymous — set the mapping afterwards with ' +
+              'rootr_rename_recording_speakers.',
+          ),
+        workspace: z
+          .string()
+          .optional()
+          .describe('Workspace id; defaults to ROOTR_WORKSPACE/config if omitted'),
+      },
+    },
+    async ({ name, parentId, path, createParents, icon, expectedSpeakers, workspace }) => {
+      try {
+        const ws = requireWorkspace(workspace);
+        const client = makeClient(ws);
+        const result = await client.createRecording(ws, {
+          name,
+          parentId,
+          path,
+          createParents,
+          icon,
+          expectedSpeakers,
+        });
+        return jsonResult(result);
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_upload_recording_audio',
+    {
+      title: 'Upload audio to a Rootr recording (starts transcription)',
+      description:
+        'Upload an audio file (meeting/interview/call recording — .webm .m4a .mp4 .mp3 .wav .ogg .flac .aac, ' +
+        'max 100MB) into an existing Rootr (루터) RECORDING node. This is how audio gets into Rootr from an agent: ' +
+        'give exactly one of filePath (the MCP server reads the file from the local filesystem itself) or ' +
+        'base64Data (bytes already in memory). filename and mimeType are inferred from filePath when omitted. ' +
+        'This ONLY stores the audio (status becomes UPLOADED) and REPLACES any previous audio — it does NOT ' +
+        'transcribe anything and spends no AI credits. To get a transcript you must then explicitly call ' +
+        'rootr_transcribe_recording.',
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      inputSchema: {
+        recordingId: z.string().describe('RECORDING node id (create one with rootr_create_recording)'),
+        filePath: z
+          .string()
+          .optional()
+          .describe('Local filesystem path to the audio file (the MCP server reads this itself, e.g. "/tmp/meeting.m4a")'),
+        base64Data: z
+          .string()
+          .optional()
+          .describe('Base64-encoded audio bytes; use this when the caller has the audio in memory instead of on disk'),
+        filename: z
+          .string()
+          .optional()
+          .describe('File name to store, e.g. "meeting.m4a". Inferred from filePath when omitted.'),
+        mimeType: z
+          .string()
+          .optional()
+          .describe('Audio MIME type, e.g. "audio/mp4". Inferred from the file extension when omitted.'),
+        durationSec: z
+          .number()
+          .optional()
+          .describe('Audio length in seconds, if known (shown in the UI; the server may also detect it)'),
+      },
+    },
+    async ({ recordingId, filePath, base64Data, filename, mimeType, durationSec }) => {
+      try {
+        const client = makeClient();
+        const data = readAudioBytes({ filePath, base64Data });
+        if (data.length > MAX_AUDIO_BYTES) {
+          throw new RootrApiError(
+            `오디오가 너무 큽니다: ${(data.length / 1024 / 1024).toFixed(1)}MB (최대 100MB).`,
+            { hint: '더 낮은 비트레이트로 다시 인코딩하거나(예: 64kbps mono m4a) 파일을 나눠서 올리세요.' },
+          );
+        }
+        const name = filename || (filePath ? basename(filePath) : null);
+        if (!name) {
+          throw new RootrApiError('base64Data를 쓸 때는 filename이 필요합니다.');
+        }
+        const ext = extname(name).toLowerCase();
+        const type = mimeType || AUDIO_MIME_BY_EXT[ext];
+        if (!type) {
+          throw new RootrApiError(
+            `오디오 MIME 타입을 알 수 없습니다 (확장자: ${ext || '없음'}). mimeType을 직접 지정하세요.`,
+          );
+        }
+        const result = await client.uploadRecordingAudio(recordingId, {
+          filename: name,
+          mimeType: type,
+          durationSec,
+          data,
+        });
+        return jsonResult({
+          ...result,
+          uploadedBytes: data.length,
+          next:
+            'Audio stored (status UPLOADED). No transcript exists yet — call rootr_transcribe_recording to ' +
+            'produce the diarized transcript (this is the step that spends AI credits).',
+        });
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_read_recording',
+    {
+      title: 'Read a Rootr recording transcript',
+      description:
+        'Read a Rootr (루터) RECORDING node — status, speaker names and the full diarized transcript ' +
+        '(segments + a ready-to-use "[mm:ss] Speaker: text" rendering). Use this to summarize a meeting with ' +
+        'YOUR own reasoning instead of Rootr\'s built-in summarize (which spends the workspace\'s AI credits): ' +
+        'read the transcript, then create the minutes document with rootr_write. ' +
+        'status EMPTY = no audio yet (upload with rootr_upload_recording_audio); ' +
+        'UPLOADED = audio stored but no transcript yet — call rootr_transcribe_recording to create one; ' +
+        'TRANSCRIBING = speech-to-text still running (poll again later); ' +
+        'READY = transcript available; FAILED = last transcription errored (see `error`).',
+      inputSchema: {
+        recordingId: z.string().describe('RECORDING node id'),
+      },
+    },
+    async ({ recordingId }) => {
+      try {
+        const client = makeClient();
+        const result = await client.getRecording(recordingId);
+        const segments = result?.transcript?.segments ?? [];
+        const names = result?.speakerNames ?? {};
+        const transcriptText = segments
+          .map((s) => `[${clock(s.start)}] ${speakerLabel(s.speaker, names)}: ${s.text}`)
+          .join('\n');
+        // audioUrl lets an agent fetch the audio itself (e.g. to run its own
+        // speech-to-text) instead of spending Rootr credits on transcription.
+        const audioUrl = result?.audio?.attachmentId
+          ? client.attachmentRawUrl(result.audio.attachmentId)
+          : null;
+        return jsonResult({ ...result, audioUrl, transcriptText });
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_rename_recording_speakers',
+    {
+      title: 'Rename diarized speakers in a Rootr recording',
+      description:
+        'Assign display names to the diarized speaker labels of a Rootr (루터) RECORDING node, e.g. ' +
+        '{"S1":"김대표","S2":"이팀장"}. Merge-patch: only the keys you send change. The names apply to the ' +
+        'transcript everywhere (web UI, rootr_read_recording, knowledge graph).',
+      inputSchema: {
+        recordingId: z.string().describe('RECORDING node id'),
+        speakerNames: z
+          .record(z.string())
+          .optional()
+          .describe('Map of speaker key ("S1", "S2", …) to display name, e.g. {"S1":"김개똥","S2":"홍길동"}'),
+        expectedSpeakers: z
+          .array(z.string())
+          .optional()
+          .describe(
+            'Replace the known-attendee list used as a naming hint on the NEXT transcription run. ' +
+              'Does not relabel the current transcript — use speakerNames for that.',
+          ),
+      },
+    },
+    async ({ recordingId, speakerNames, expectedSpeakers }) => {
+      try {
+        if (!speakerNames && !expectedSpeakers) {
+          throw new RootrApiError('speakerNames 또는 expectedSpeakers 중 하나는 필요합니다.');
+        }
+        const client = makeClient();
+        const current = await client.getRecording(recordingId);
+        const merged = speakerNames
+          ? { ...(current?.speakerNames ?? {}), ...speakerNames }
+          : undefined;
+        const result = await client.updateRecording(recordingId, {
+          speakerNames: merged,
+          expectedSpeakers,
+        });
+        return jsonResult({
+          speakerNames: result.speakerNames,
+          expectedSpeakers: result.expectedSpeakers,
+        });
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_transcribe_recording',
+    {
+      title: 'Transcribe a Rootr recording (speech-to-text)',
+      description:
+        'Turn the audio of a Rootr (루터) RECORDING node into a diarized (speaker-labeled) transcript. This is THE ' +
+        'tool that creates a transcript — uploading audio does not transcribe by itself, so call this after ' +
+        'rootr_upload_recording_audio (status UPLOADED), and call it again to redo a transcript that FAILED or that ' +
+        'you want regenerated (it REPLACES the existing transcript; speaker names you set are kept). ' +
+        'This spends the workspace\'s Rootr AI credits — only run it when the user actually wants the transcript. ' +
+        'Returns the recording with status TRANSCRIBING; poll rootr_read_recording until READY (a long meeting can ' +
+        'take a few minutes).',
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      inputSchema: {
+        recordingId: z.string().describe('RECORDING node id'),
+      },
+    },
+    async ({ recordingId }) => {
+      try {
+        const client = makeClient();
+        const result = await client.transcribeRecording(recordingId);
+        return jsonResult({
+          ...result,
+          next: 'Poll rootr_read_recording until status is READY (or FAILED — see `error`).',
+        });
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_summarize_recording',
+    {
+      title: 'Summarize a Rootr recording with Rootr\'s built-in AI',
+      description:
+        'Run Rootr\'s BUILT-IN summarizer over a RECORDING node\'s transcript and create a markdown DOCUMENT node ' +
+        'from it. Two formats: "summary" (default) = short minutes — one-line outcome, participants, key points, ' +
+        'decisions, action items; "onepager" = a detailed hand-off briefing for someone who was NOT in the meeting — ' +
+        'background, per-topic prose with quotes, decisions with rationale, an owner/due table, risks and a timeline. ' +
+        'Each format has its own document, so creating one does not replace the other. Returns { docId, format } — ' +
+        'read or edit it afterwards with rootr_read / rootr_edit. Requires status READY.\n' +
+        'IMPORTANT — this spends the workspace\'s Rootr AI credits (a one-pager costs more than a summary). To save ' +
+        'credits, do it yourself instead: call rootr_read_recording to get the full transcript, write the document ' +
+        'with your own reasoning, and create it with rootr_write. Prefer that path unless the user explicitly asks ' +
+        'for Rootr\'s built-in summary.',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        recordingId: z.string().describe('RECORDING node id (status must be READY)'),
+        format: z
+          .enum(['summary', 'onepager'])
+          .optional()
+          .describe(
+            'What to write: "summary" (default) = short minutes to skim; "onepager" = the long, detailed briefing ' +
+              'for someone who missed the meeting.',
+          ),
+        locale: z
+          .enum(['ko', 'en'])
+          .optional()
+          .describe('Language of the generated document: "ko" (Korean) or "en" (English). Defaults to the workspace locale.'),
+      },
+    },
+    async ({ recordingId, locale, format }) => {
+      try {
+        const client = makeClient();
+        const result = await client.summarizeRecording(recordingId, { locale, format });
+        return jsonResult(result);
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_download_recording_audio',
+    {
+      title: 'Download a Rootr recording\'s audio file',
+      description:
+        'Fetch the audio of a Rootr (루터) RECORDING node so YOU can process it — most usefully, run your own ' +
+        'speech-to-text on it instead of rootr_transcribe_recording (which spends the workspace\'s AI credits). ' +
+        'Note that most chat models cannot listen to audio at all (Claude cannot); this is for agents that can ' +
+        'reach a speech-to-text model or CLI. Two ways to get the bytes: ' +
+        '(a) pass `filePath` (or omit it for a temp file) to save the audio on the machine running this MCP ' +
+        'server — right for the local `rootr` CLI, useless over the hosted connector, where the file would land ' +
+        'on Rootr\'s server; or (b) pass `urlOnly: true` to get just a direct download URL you can fetch yourself. ' +
+        'The URL is also returned by rootr_read_recording as `audioUrl`. ' +
+        'Audio is never returned inline as base64 — a meeting recording is tens of megabytes and would blow up ' +
+        'the conversation. ' +
+        'Rootr has no endpoint for writing an externally-produced transcript back yet, so a transcript you make ' +
+        'this way lives wherever you put it (e.g. a document via rootr_write), not in the recording node.',
+      annotations: { readOnlyHint: true },
+      inputSchema: {
+        recordingId: z.string().describe('RECORDING node id'),
+        filePath: z
+          .string()
+          .optional()
+          .describe(
+            'Where to save the audio ON THE MACHINE RUNNING THIS MCP SERVER. A directory saves under the ' +
+              'original filename. Omit to use a temp file. Ignored when urlOnly is true.',
+          ),
+        urlOnly: z
+          .boolean()
+          .optional()
+          .describe('Return only the download URL, without writing any file (default false).'),
+      },
+    },
+    async ({ recordingId, filePath, urlOnly }) => {
+      try {
+        const client = makeClient();
+        const rec = await client.getRecording(recordingId);
+        if (!rec?.audio?.attachmentId) {
+          throw new RootrApiError('이 녹음에는 아직 오디오가 없습니다. rootr_upload_recording_audio로 먼저 올리세요.');
+        }
+        const { attachmentId, filename, mimeType, size } = rec.audio;
+        const url = client.attachmentRawUrl(attachmentId);
+        if (urlOnly) {
+          return jsonResult({ audioUrl: url, filename, mimeType, size, durationSec: rec.durationSec ?? null });
+        }
+        const data = await client.downloadAttachmentBytes(attachmentId);
+        // A directory (existing path ending in a separator, or no extension) →
+        // keep the original filename; otherwise treat it as the target file.
+        let target = filePath?.trim();
+        if (!target) {
+          target = join(tmpdir(), `rootr-${recordingId}-${filename}`);
+        } else {
+          if (!isAbsolute(target)) target = join(process.cwd(), target);
+          if (target.endsWith('/') || !extname(target)) target = join(target, filename);
+        }
+        writeFileSync(target, data);
+        return jsonResult({
+          filePath: target,
+          bytes: data.length,
+          filename,
+          mimeType,
+          durationSec: rec.durationSec ?? null,
+          audioUrl: url,
+          note:
+            'Saved on the machine running the MCP server. Run your own speech-to-text on this file if you want ' +
+            'to avoid spending Rootr AI credits.',
+        });
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+}

package/lib/mcp-tools/shared.js

@@ -1,5 +1,6 @@
-import { loadConfig } from '../config.js';
+import { loadConfig, keyForWorkspace } from '../config.js';
 import { RootrClient, RootrApiError } from '../client.js';
+import { currentClientOverride } from '../context.js';
 
 export function textResult(text) {
   return { content: [{ type: 'text', text }] };
@@ -23,9 +24,22 @@ export function jsonResult(value) {
  * that every workspace-scoped MCP tool accepts.
  */
 export function makeClient(workspaceOverride) {
+  const hosted = currentClientOverride();
+  if (hosted) {
+    // Hosted MCP requests are locked to the workspace granted at OAuth
+    // consent time — silently ignoring a caller-supplied workspace here
+    // would be a scoping bug, so only honor an override that matches.
+    if (workspaceOverride && workspaceOverride !== hosted.workspace) {
+      throw new RootrApiError('이 연결은 하나의 워크스페이스에만 연결되어 있습니다.', {
+        hint: '다른 워크스페이스가 필요하면 설정>연동에서 새 원격 커넥터를 발급하세요.',
+      });
+    }
+    return hosted;
+  }
   const cfg = loadConfig();
   const workspace = workspaceOverride || cfg.workspace;
-  return new RootrClient({ ...cfg, workspace });
+  // Each workspace may need a different key (see config.js keys[]).
+  return new RootrClient({ ...cfg, workspace, apiKey: keyForWorkspace(cfg, workspace) });
 }
 
 /**
@@ -33,7 +47,8 @@ export function makeClient(workspaceOverride) {
  * then ROOTR_WORKSPACE/config. Throws a clear RootrApiError otherwise.
  */
 export function requireWorkspace(workspaceOverride) {
-  const cfg = loadConfig();
+  const hosted = currentClientOverride();
+  const cfg = hosted ? { workspace: hosted.workspace } : loadConfig();
   const workspace = workspaceOverride || cfg.workspace;
   if (!workspace) {
     throw new RootrApiError('워크스페이스가 설정되지 않았습니다.', {