rootr-cli 0.23.3 → 0.24.0

package/README.ko.md

@@ -305,6 +305,22 @@ rootr sign ledger          # 워크스페이스 원장 전체 재계산
 원본은 `SUPERSEDED`로 남습니다 — 지침이 "고친 흔적과 원본이 모두 보여야 한다"를
 요구하기 때문입니다.
 
+### 문서 보내기 · 문서함 (send · mail)
+
+폴더만 빼고 어떤 노드든 이메일 1~20명에게 **보낼 때의 복사본**으로 보낼 수 있습니다. 담기는 내용은
+공개 페이지와 같아서 사람·첨부·관계 칸은 나가지 않습니다. 받는 사람은 메일 링크로 **루터 계정 없이**
+열고, 그 이메일에 루터 계정이 있거나 나중에 가입하면 받은 문서함에도 그대로 있습니다. 보낸 뒤 원본을
+고치거나 지워도 받은 문서는 그대로입니다. 보내려면 그 노드에 쓰기(WRITE) 권한이 있어야 합니다(공유와 같은 문턱).
+
+```bash
+rootr send "/보고서/3분기 실적" --to partner@example.com,cfo@example.com --message "말씀드린 자료입니다"
+rootr mail                 # 받은 문서 (안 읽은 수 함께)
+rootr mail sent            # 보낸 문서 — 읽었는지, 메일 실패
+rootr mail show <id>       # 열기 (문서는 마크다운 본문, 그 밖은 --json 으로 전부)
+rootr mail revoke <id>     # 회수 — 받는 쪽에서 본문이 안 보이고 링크는 410
+rootr mail hide <id>       # 내 문서함에서만 지우기
+```
+
 ### 제보 보내기 (feedback)
 
 ```bash
@@ -352,7 +368,7 @@ rootr memory forget <id>                         # 폐기(--hard면 행 삭제)
 
 ## MCP 서버로 사용하기
 
-`rootr mcp`는 stdio로 MCP(Model Context Protocol) 서버를 구동합니다. 제공 도구 186종:
+`rootr mcp`는 stdio로 MCP(Model Context Protocol) 서버를 구동합니다. 제공 도구 197종:
 
 노드를 가리키는 인자(`target`, `databaseId`, `spreadsheetId`, `formId`, `crmId`, `trackerId`,
 `recordingId`, `presentationId`, `whiteboardId`, `logId`, `parentId` 등)는 **노드 id와 경로를 모두**
@@ -799,6 +815,18 @@ rootr db view <표> <뷰> --scale year       # 달력 보기를 주·달·해
 주세요 — 그 표는 행을 열 때마다 서명문서(연구노트)가 만들어집니다(실험 기록 대장,
 점검 대장).
 
+#### 문서 보내기 · 문서함 (docs:read/docs:write)
+
+| 도구 | 설명 |
+|---|---|
+| `rootr_send_document` | 노드 하나를 이메일 1~20명에게 보낼 때의 복사본으로 보내기 (계정 없어도 메일 링크로 열림) |
+| `rootr_list_doc_mail` | 내 문서함 — `box`: inbox(받은, 기본) / sent(보낸), 안 읽은 수 함께 |
+| `rootr_read_doc_mail` | 한 통 열기 — 본문(`payload`), 받은 것은 읽음 처리, 회수된 것은 본문 없음 |
+| `rootr_revoke_doc_mail` | 보낸 문서 회수 (보낸 사람만) |
+
+문서함은 워크스페이스가 아니라 **사람(이메일)**에 붙습니다. 사람 없는 워크스페이스 키(원격 커넥터)는
+그 키를 만든 구성원으로 동작합니다.
+
 #### 문서 버전 / 삭제
 
 | 도구 | 설명 |

package/README.md

@@ -11,7 +11,7 @@ citations back to the exact paragraph.
 *(한국어 문서: [README.ko.md](https://github.com/gwmage/rootr-cli/blob/main/README.ko.md))*
 
 - `rootr` CLI — documents, databases, forms, signed documents, publishing, permissions, memory
-- `rootr mcp` — stdio MCP server, **193 tools** (see [MCP tools](#mcp-tools))
+- `rootr mcp` — stdio MCP server, **197 tools** (see [MCP tools](#mcp-tools))
 
 Plain Node.js ESM, no build step. Node 18+ (uses the built-in `fetch`).
 
@@ -327,6 +327,23 @@ A signed document is never edited in place. You issue a **revision**
 (`rootr sign revise <id> --note "…"`) and the original stays as `SUPERSEDED`, because the
 regulations require both the original and the trace of the change to remain visible.
 
+### Sending a document to someone (mailbox)
+
+Any node except a folder can be emailed to 1–20 addresses as a **copy taken at send time** — the
+same content a public page shows, so person / attachment / relation columns never go out. The
+recipient opens it from the email link **without a Rootr account**; if that address has (or later
+gets) a Rootr account, it is also in their inbox. Editing or deleting the original afterwards does
+not change what they received. Sending needs WRITE on the node, the same bar as sharing.
+
+```bash
+rootr send "/reports/Q3 numbers" --to partner@example.com,cfo@example.com --message "As discussed"
+rootr mail                 # received (with the unread count)
+rootr mail sent            # what you sent — read or not, email failures
+rootr mail show <id>       # open it (a document prints its markdown; --json for any type)
+rootr mail revoke <id>     # withdraw: the recipient no longer sees the content, the link answers 410
+rootr mail hide <id>       # remove from your own mailbox only
+```
+
 ### Team memory
 
 ```bash
@@ -408,7 +425,7 @@ is refused and says when the grace was used.
 
 ## MCP tools
 
-`rootr mcp` speaks MCP over stdio. 193 tools:
+`rootr mcp` speaks MCP over stdio. 197 tools:
 
 | Group | Count | Tools |
 |---|---|---|
@@ -416,6 +433,7 @@ is refused and says when the grace was used.
 | Databases | 32 | create, columns, views, rows (single & bulk), row pages, permissions, notifications, buttons, duplicates (find / merge / keep & link), history & point-in-time restore (row / whole table) |
 | CRM | 18 | companies, contacts, deals (incl. pipeline moves), activities, tasks, CSV import |
 | Signed documents & research notes | 14 | create, sign, revise, reject, reopen, approval lines, signing codes, ledger verification, research-note preset |
+| Sending documents (mailbox) | 4 | send any node as a frozen copy to email addresses (no account needed to open), list received / sent, read, withdraw |
 | Forms | 10 | create, read, update, responses, share links, collectors |
 | Presentations & images | 10 | decks, slides, diagram slides, image generation and background removal |
 | Workspaces & scaffolding | 10 | list, create, delete, switch, set the emblem (sidebar logo), plan / review / apply a document tree, health check |

package/bin/rootr.js

@@ -95,6 +95,11 @@ const USAGE_KO = `Rootr CLI v${pkg.version}
   rootr sign list [--pending] [--status <S>] [--mode <M>] [--json]  서명문서 목록 (--pending: 내 차례)
   rootr sign bulk <id…> --code <6자리>              여러 건 한 번에 올리기+서명 (코드 하나로, 초안 포함)
   rootr sign ledger [--json]                       워크스페이스 원장(해시 체인) 전체 검증
+  rootr send <path|id> --to a@x.com[,b@y.com] [--message "..."]  문서(어떤 타입이든)를 이메일로 보내기 — 보낼 때의 복사본, 계정 없어도 열림
+  rootr mail [inbox|sent] [--limit N] [--q <찾기>] [--json]  문서함 — 받은 문서(기본)·보낸 문서
+  rootr mail show <id> [--json]                    받은/보낸 문서 열기(문서면 본문, 그 밖은 요약) — 받은 것은 읽음 처리
+  rootr mail revoke <id>                           보낸 문서 회수 — 받는 쪽에서 본문이 안 보임
+  rootr mail hide <id> [--box inbox|sent]          내 문서함에서만 지우기(상대 화면은 그대로)
   rootr config [--api-key <k>] [--workspace <w>] [--base-url <u>]  설정 조회/저장
   rootr config --add-key <k> [--label <name>] [--workspace <w>]     워크스페이스별 키 추가 등록
   rootr feedback "<무엇이 안 되는지>" [--kind bug|friction|idea|praise] [--email <주소>]
@@ -108,7 +113,7 @@ const USAGE_KO = `Rootr CLI v${pkg.version}
   rootr memory add "<내용>" [--kind 지시|사람|프로젝트|참고] [--source <경로|id>] [--related a,b]  기억 저장
   rootr memory edit <id> [--content "<내용>"] [--kind …] [--source …] [--related a,b]  기억 고치기(준 칸만)
   rootr memory forget <id> [--hard]                 기억 폐기(--hard면 행 삭제)
-  rootr mcp                                        MCP stdio 서버 구동 (도구 178종 — README 참고)
+  rootr mcp                                        MCP stdio 서버 구동 (도구 197종 — README 참고)
   rootr --help                                     도움말
   rootr --version                                  버전 출력
 
@@ -201,6 +206,11 @@ usage:
   rootr sign list [--pending] [--status <S>] [--mode <M>] [--json]  list signed documents (--pending: waiting on you)
   rootr sign bulk <id…> --code <6 digits>           submit+sign many at once (one code, drafts included)
   rootr sign ledger [--json]                       verify the whole workspace ledger (hash chain)
+  rootr send <path|id> --to a@x.com[,b@y.com] [--message "..."]  email any node as a frozen copy — opens without an account
+  rootr mail [inbox|sent] [--limit N] [--q <text>] [--json]  your document mailbox — received (default) or sent
+  rootr mail show <id> [--json]                    open a received/sent document (body for docs, a summary otherwise); marks received ones read
+  rootr mail revoke <id>                           withdraw a document you sent — the recipient no longer sees the content
+  rootr mail hide <id> [--box inbox|sent]          remove from your own mailbox only (the other side keeps it)
   rootr config [--api-key <k>] [--workspace <w>] [--base-url <u>]  read/save configuration
   rootr config --add-key <k> [--label <name>] [--workspace <w>]     register an extra per-workspace key
   rootr feedback "<what is not working>" [--kind bug|friction|idea|praise] [--email <address>]
@@ -214,7 +224,7 @@ usage:
   rootr memory add "<content>" [--kind instruction|person|project|reference] [--source <path|id>] [--related a,b]  save a memory
   rootr memory edit <id> [--content "<content>"] [--kind …] [--source …] [--related a,b]  edit a memory (only the fields you pass)
   rootr memory forget <id> [--hard]                 retire a memory (--hard deletes the row)
-  rootr mcp                                        run the MCP stdio server (178 tools — see the README)
+  rootr mcp                                        run the MCP stdio server (197 tools — see the README)
   rootr --help                                     this help
   rootr --version                                  print the version
 
@@ -3061,6 +3071,128 @@ async function cmdSign(args) {
   }
 }
 
+// ---- doc mail (DOC-MAIL — 문서 송수신) ------------------------------------
+
+const MAIL_USAGE =
+  usage(`rootr mail [inbox|sent] | show <id> | revoke <id> | hide <id>\n`) +
+  tr('       (자세한 건 rootr --help)', `       (see rootr --help)`);
+
+const NODE_TYPE_KO = {
+  DOCUMENT: tr('문서', 'document'),
+  DATABASE: tr('표', 'table'),
+  SPREADSHEET: tr('스프레드시트', 'spreadsheet'),
+  WHITEBOARD: tr('화이트보드', 'whiteboard'),
+  PRESENTATION: tr('발표자료', 'deck'),
+  FORM: tr('폼', 'form'),
+  ISSUE_TRACKER: tr('이슈', 'issues'),
+  LOG: tr('로그', 'log'),
+  CRM: 'CRM',
+  RECORDING: tr('녹음', 'recording'),
+  PAGE: tr('페이지', 'page'),
+  SIGNED: tr('서명문서', 'signed document'),
+};
+
+async function cmdSend(args) {
+  const target = args._[0];
+  const toArg = typeof args.to === 'string' ? args.to : '';
+  const to = toArg.split(/[,;\s]+/).map((s) => s.trim()).filter(Boolean);
+  if (!target || !to.length) {
+    throw new Error(usage(tr(`rootr send <path|id> --to a@x.com[,b@y.com] [--message "..."]`, `rootr send <path|id> --to a@x.com[,b@y.com] [--message "..."]`)));
+  }
+  const client = makeClient();
+  const nodeId = requireResolved(await resolveTarget(client, target));
+  const out = await client.sendNode(nodeId, { to, message: typeof args.message === 'string' ? args.message : undefined });
+  if (args.json) return console.log(JSON.stringify(out, null, 2));
+  const items = out.items ?? [];
+  console.log(tr(`${items.length}명에게 보냈습니다 (묶음 ${out.batchId})`, `Sent to ${items.length} ${items.length === 1 ? 'person' : 'people'} (batch ${out.batchId})`));
+  for (const it of items) {
+    console.log(
+      `  ${it.to}\t${it.id}\t` +
+        (it.emailed ? tr('메일 보냄', 'emailed') : tr(`메일 실패${it.error ? `: ${it.error}` : ''} — 문서는 받은 문서함에 있습니다`, `email failed${it.error ? `: ${it.error}` : ''} — the copy is still in their inbox`)),
+    );
+  }
+}
+
+function mailWhen(iso) {
+  return iso ? String(iso).replace('T', ' ').slice(0, 16) : '';
+}
+
+async function cmdMail(args) {
+  const sub = args._[0];
+  const client = makeClient();
+  if (!sub || sub === 'inbox' || sub === 'sent' || sub === 'list') {
+    const box = sub === 'sent' || args.box === 'sent' ? 'sent' : 'inbox';
+    const limit = args.limit ? Number(args.limit) : undefined;
+    const out = await client.listDocMail({ box, limit, q: typeof args.q === 'string' ? args.q : undefined, cursor: typeof args.cursor === 'string' ? args.cursor : undefined });
+    if (args.json) return console.log(JSON.stringify(out, null, 2));
+    if (box === 'inbox') console.log(tr(`받은 문서 — 안 읽은 것 ${out.unread}개`, `Received — ${out.unread} unread`));
+    else console.log(tr('보낸 문서', 'Sent'));
+    if (!out.items?.length) return console.log(tr('  (없음)', '  (none)'));
+    for (const m of out.items) {
+      const type = NODE_TYPE_KO[m.nodeType] ?? m.nodeType;
+      const state = m.revoked
+        ? tr('[회수됨]', '[withdrawn]')
+        : box === 'inbox'
+          ? m.readAt ? '' : tr('[새 문서]', '[new]')
+          : m.readAt ? tr(`[읽음 ${mailWhen(m.readAt)}]`, `[read ${mailWhen(m.readAt)}]`) : tr('[안 읽음]', '[unread]');
+      const who = box === 'inbox' ? `${m.senderName} <${m.senderEmail}>` : `→ ${m.recipientEmail}`;
+      const mailFail = box === 'sent' && m.emailed === false ? tr('  [메일 실패]', '  [email failed]') : '';
+      console.log(`${m.id}\t${mailWhen(m.createdAt)}\t${type}\t${m.title}\t${who}${state ? `  ${state}` : ''}${mailFail}`);
+      if (m.message) console.log(`    ${String(m.message).split('\n')[0].slice(0, 100)}`);
+    }
+    if (out.nextCursor) console.log(tr(`\n다음 쪽: rootr mail ${box} --cursor ${out.nextCursor}`, `\nNext page: rootr mail ${box} --cursor ${out.nextCursor}`));
+    return;
+  }
+  const id = args._[1];
+  if (!id) throw new Error(MAIL_USAGE);
+  switch (sub) {
+    case 'show':
+    case 'read': {
+      const m = await client.getDocMail(id);
+      if (args.json) return console.log(JSON.stringify(m, null, 2));
+      console.log(`${m.title}  (${NODE_TYPE_KO[m.nodeType] ?? m.nodeType})`);
+      console.log(tr(`보낸 사람: ${m.senderName} <${m.senderEmail}> · ${m.workspaceName}`, `From: ${m.senderName} <${m.senderEmail}> · ${m.workspaceName}`));
+      console.log(tr(`받는 사람: ${m.recipientEmail} · 보낸 때 ${mailWhen(m.createdAt)}${m.readAt ? ` · 읽음 ${mailWhen(m.readAt)}` : ''}`, `To: ${m.recipientEmail} · sent ${mailWhen(m.createdAt)}${m.readAt ? ` · read ${mailWhen(m.readAt)}` : ''}`));
+      if (m.message) console.log(tr(`메시지: ${m.message}`, `Message: ${m.message}`));
+      if (m.revoked && !m.payload) return console.log(tr('\n보낸 사람이 이 문서를 회수했습니다.', '\nThe sender withdrew this document.'));
+      if (m.revoked) console.log(tr('(회수함 — 받는 쪽에서는 본문이 안 보입니다)', '(withdrawn — the recipient no longer sees the content)'));
+      const p = m.payload ?? {};
+      console.log('');
+      if (p.kind === 'doc') return console.log(p.content ?? '');
+      if (p.kind === 'database') {
+        const props = p.properties ?? [];
+        const rows = p.rows ?? [];
+        console.log(props.map((c) => c.name).join('\t'));
+        for (const r of rows) {
+          console.log(props.map((c) => {
+            const v = r.values?.[c.id];
+            return v === null || v === undefined ? '' : typeof v === 'object' ? JSON.stringify(v) : String(v);
+          }).join('\t'));
+        }
+        if (p.truncated) console.log(tr(`… ${p.truncated.total}행 중 ${p.truncated.shown}행만 담겼습니다`, `… ${p.truncated.shown} of ${p.truncated.total} rows were included`));
+        return;
+      }
+      const keys = Object.keys(p).filter((k) => k !== 'kind');
+      console.log(tr(`[${p.kind}] 담긴 것: ${keys.join(', ')} — 전부 보려면 --json`, `[${p.kind}] contains: ${keys.join(', ')} — use --json for everything`));
+      return;
+    }
+    case 'revoke': {
+      const out = await client.revokeDocMail(id);
+      if (args.json) return console.log(JSON.stringify(out, null, 2));
+      return console.log(tr(`회수했습니다 (${mailWhen(out.revokedAt)}) — 받는 쪽에서 본문이 안 보입니다.`, `Withdrawn (${mailWhen(out.revokedAt)}) — the recipient no longer sees the content.`));
+    }
+    case 'hide':
+    case 'rm': {
+      const box = args.box === 'inbox' || args.box === 'sent' ? args.box : undefined;
+      const out = await client.hideDocMail(id, { box });
+      if (args.json) return console.log(JSON.stringify(out, null, 2));
+      return console.log(tr(`내 문서함에서 지웠습니다 (${out.hidden}). 상대 화면은 그대로입니다.`, `Removed from your mailbox (${out.hidden}). The other side still has it.`));
+    }
+    default:
+      throw new Error(MAIL_USAGE);
+  }
+}
+
 async function main() {
   const argv = process.argv.slice(2);
   const args = parseArgs(argv);
@@ -3126,6 +3258,10 @@ async function main() {
       return cmdAccess(args);
     case 'sign':
       return cmdSign(args);
+    case 'send':
+      return cmdSend(args);
+    case 'mail':
+      return cmdMail(args);
     case 'feedback':
       return cmdFeedback(args);
     case 'scaffold':

package/lib/client.js

@@ -2049,6 +2049,48 @@ export class RootrClient {
     return this.request(`/workspaces/${encodeURIComponent(workspaceId)}/ledger/verify`);
   }
 
+  // ---- Doc mail (DOC-MAIL — 문서 송수신) ---------------------------------
+  //
+  // 노드 하나를 **보낼 때의 복사본**으로 이메일 1~20명에게 보낸다. 받은 문서는 받는 사람의
+  // 이메일에 붙는다 — 계정이 없어도 메일 링크로 열리고, 나중에 그 이메일로 가입하면 문서함에
+  // 그대로 있다. 문서함은 사람(이메일)에 붙으므로 워크스페이스 주소 밑이 아니다.
+
+  /** 보내기 — WRITE 이상. 응답 `{batchId, items:[{id,to,emailed}]}`. */
+  async sendNode(nodeId, { to, message } = {}) {
+    return this.request(`/nodes/${encodeURIComponent(nodeId)}/send`, {
+      method: 'POST',
+      body: { to, ...(message ? { message } : {}) },
+    });
+  }
+
+  /** 문서함 목록 — box: inbox(받은, 기본) | sent(보낸). 본문 없이 요약 + 안 읽은 수(unread). */
+  async listDocMail({ box, limit, cursor, q } = {}) {
+    const qs = new URLSearchParams();
+    if (box) qs.set('box', box);
+    if (limit) qs.set('limit', String(limit));
+    if (cursor) qs.set('cursor', cursor);
+    if (q) qs.set('q', q);
+    const s = qs.toString();
+    return this.request(`/doc-mail${s ? `?${s}` : ''}`);
+  }
+
+  /** 한 통 열기(본문 payload 포함). 받는 사람이 열면 읽음으로 바뀐다. */
+  async getDocMail(id) {
+    return this.request(`/doc-mail/${encodeURIComponent(id)}`);
+  }
+
+  /** 회수 — 보낸 사람만. 이후 받는 쪽에서 본문이 안 보인다. */
+  async revokeDocMail(id) {
+    return this.request(`/doc-mail/${encodeURIComponent(id)}/revoke`, { method: 'POST', body: {} });
+  }
+
+  /** 내 문서함에서만 지우기(상대 화면은 그대로). box 로 나에게 보낸 것의 한쪽만 고를 수 있다. */
+  async hideDocMail(id, { box } = {}) {
+    return this.request(`/doc-mail/${encodeURIComponent(id)}${box ? `?box=${encodeURIComponent(box)}` : ''}`, {
+      method: 'DELETE',
+    });
+  }
+
   /**
    * FEEDBACK — 제보를 보낸다. 다른 메서드와 달리 `request()`를 쓰지 않고 직접
    * fetch 한다: **API 키가 없어도, 키가 틀렸어도 보낼 수 있어야** 하기 때문이다.

package/lib/mcp-tools/doc-mail.js

@@ -0,0 +1,116 @@
+import { z } from 'zod';
+
+import { jsonResult, errorResult, makeClient, resolveNodeId, NODE_TARGET_HINT } from './shared.js';
+
+/**
+ * DOC-MAIL — 문서 송수신(창업자 지시 2026-10-20).
+ *
+ * 어떤 타입이든(문서·표·시트·화이트보드·덱·폼·이슈·로그·CRM·녹음·페이지·서명문서) 노드 하나를
+ * **보낼 때의 복사본**으로 특정 이메일에게 보낸다. 받은 문서는 받는 사람의 **이메일 주소**에 붙는다 —
+ * 계정이 없어도 메일 링크로 열리고, 나중에 그 이메일로 가입하면 받은 문서함에 그대로 있다.
+ * 보낸 뒤 원본을 고치거나 지워도 받은 문서는 그대로다(살아 있는 공유가 필요하면 권한/공개를 쓴다).
+ */
+export function registerDocMailTools(server) {
+  server.registerTool(
+    'rootr_send_document',
+    {
+      title: 'Send a Rootr node to email addresses',
+      description:
+        'Send a SNAPSHOT of any Rootr node (document, table, spreadsheet, whiteboard, deck, form, issues, log, CRM, ' +
+        'recording, page, signed document — anything but a folder) to 1–20 email addresses. Each recipient gets an ' +
+        'email with a link that opens the copy WITHOUT a Rootr account; if they have (or later create) a Rootr account ' +
+        'with that email, it also sits in their inbox (rootr_list_doc_mail). The copy is frozen at send time — later ' +
+        'edits or deletion of the original do not change it; use permissions/publishing for a live share instead. ' +
+        'Needs WRITE on the node (the same bar as sharing). What never goes out: the same things a public page hides ' +
+        '(person/attachment/relation columns, row documents, form responses, signer emails). ' +
+        'The result lists each recipient with `emailed` (false = the notification email failed; the copy still exists). ' +
+        'Only send to addresses the user asked for — this emails real people.',
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      inputSchema: {
+        node: z.string().describe(`보낼 노드 id${NODE_TARGET_HINT}`),
+        to: z.array(z.string()).min(1).max(20).describe('받는 사람 이메일 주소들(1~20개). 대소문자만 다른 주소는 같은 사람'),
+        message: z.string().max(2000).optional().describe('보내며 함께 적을 말(메일과 문서함에 보인다, 2000자까지)'),
+        workspace: z.string().optional().describe('경로로 줄 때 찾을 워크스페이스 id (생략하면 설정값)'),
+      },
+    },
+    async ({ node, to, message, workspace }) => {
+      try {
+        const client = makeClient(workspace);
+        return jsonResult(await client.sendNode(await resolveNodeId(client, node), { to, message }));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_list_doc_mail',
+    {
+      title: 'List my received or sent Rootr documents',
+      description:
+        "List the caller's document mailbox: box=inbox (documents sent TO the caller's account email — default) or " +
+        'box=sent (documents the caller sent). Summaries only (title, type, sender, recipient, message, sentAt, ' +
+        'readAt, revoked); open one with rootr_read_doc_mail. `unread` is the number of unread received documents. ' +
+        'Page with `cursor` = the previous `nextCursor`. Belongs to the person (their email), not to a workspace.',
+      annotations: { readOnlyHint: true },
+      inputSchema: {
+        box: z.enum(['inbox', 'sent']).optional().describe('inbox=받은 문서(기본), sent=보낸 문서'),
+        limit: z.number().int().min(1).max(100).optional().describe('한 번에 몇 개(기본 30)'),
+        cursor: z.string().optional().describe('다음 쪽 — 앞 응답의 nextCursor'),
+        q: z.string().optional().describe('제목·보낸 사람·받는 사람으로 찾기'),
+      },
+    },
+    async ({ box, limit, cursor, q }) => {
+      try {
+        return jsonResult(await makeClient().listDocMail({ box, limit, cursor, q }));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_read_doc_mail',
+    {
+      title: 'Read a received or sent Rootr document',
+      description:
+        'Open one document from the mailbox (id from rootr_list_doc_mail). Returns the summary plus `payload` — the ' +
+        'snapshot taken at send time, in the same shape a public page uses: `kind` says what it is (doc → `content` ' +
+        'markdown; database → `properties` + `rows`; spreadsheet → `data`; …). Opening a received one marks it read. ' +
+        'If the sender withdrew it, `revoked` is true and `payload` is null.',
+      annotations: { readOnlyHint: false },
+      inputSchema: {
+        id: z.string().describe('문서함 항목 id (rootr_list_doc_mail 의 items[].id)'),
+      },
+    },
+    async ({ id }) => {
+      try {
+        return jsonResult(await makeClient().getDocMail(id));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_revoke_doc_mail',
+    {
+      title: 'Withdraw a sent Rootr document',
+      description:
+        'Withdraw a document the caller sent (id from rootr_list_doc_mail box=sent). From then on the recipient sees ' +
+        'only the title and "withdrawn" — no content — and the email link answers 410. Only the sender can do this; ' +
+        'it cannot be undone (send it again instead). Copies the recipient already saved elsewhere are out of reach.',
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      inputSchema: {
+        id: z.string().describe('보낸 문서함 항목 id'),
+      },
+    },
+    async ({ id }) => {
+      try {
+        return jsonResult(await makeClient().revokeDocMail(id));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+}

package/lib/mcp.js

@@ -24,6 +24,7 @@ import { registerAttachmentTools } from './mcp-tools/attachments.js';
 import { registerSignedDocTools } from './mcp-tools/signed.js';
 import { registerFeedbackTools } from './mcp-tools/feedback.js';
 import { registerMemoryTools } from './mcp-tools/memory.js';
+import { registerDocMailTools } from './mcp-tools/doc-mail.js';
 import { withRateLimitSink } from './context.js';
 import { makeClient } from './mcp-tools/shared.js';
 import { t as tr } from './i18n.js';
@@ -224,6 +225,10 @@ export function buildMcpServer({ name, version }) {
         'rootr_request_signing_code first and ASK THE HUMAN for the 6 digits that arrive in their mail — ' +
         'that code is the only evidence a person (not an agent) pressed sign; ' +
         'FOLDER = grouping; LOG store = typed event table whose relation fields auto-build a lineage graph (metrics, incidents, pipeline events — use the rootr_*_log_* tools).\n\n' +
+        'Sending a document to someone by email (문서 보내기 · 문서함): rootr_send_document mails a frozen COPY of any ' +
+        'node (not a folder) to 1-20 addresses — no Rootr account needed to open it, and it lands in their inbox if ' +
+        'that email has an account; rootr_list_doc_mail (box inbox|sent) / rootr_read_doc_mail / rootr_revoke_doc_mail ' +
+        'cover the mailbox. Only send to addresses the user gave you.\n\n' +
         'Scaffolding discipline — treat "set up a workspace for X" exactly like "build me this app": you ask a ' +
         'few clarifying questions, write it, compile it, run the tests, leave a README, and report. The user ' +
         'should only have to type that one sentence; everything else finishes inside the conversation. Never ask ' +
@@ -286,6 +291,7 @@ export function buildMcpServer({ name, version }) {
   registerSignedDocTools(server);
   registerFeedbackTools(server);
   registerMemoryTools(server);
+  registerDocMailTools(server);
 
   return server;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rootr-cli",
-  "version": "0.23.3",
+  "version": "0.24.0",
   "description": "Official Rootr CLI + MCP server — read, write, edit and search Rootr documents from the shell or from an AI agent.",
   "type": "module",
   "bin": {