rootr-cli 0.8.1 → 0.9.0

package/README.md

@@ -304,6 +304,39 @@ rootr ask "왜 결제 실패가 늘었지?" --workspace ws_123
 | `rootr_add_column` | **열 추가** — 기존 열·행은 그대로 |
 | `rootr_update_column` | 열 이름 변경 / select 선택지 교체 |
 | `rootr_delete_column` | 열 삭제(파괴적) |
+| `rootr_read_database_permissions` | 표에 걸린 자물쇠 보기 |
+| `rootr_set_database_permissions` | 표 잠그기 — 칸·뷰 잠금 / 본인 행만 / 관리자만 고칠 칸 |
+| `rootr_read_database_notifications` | 표 알림 규칙 보기 |
+| `rootr_set_database_notifications` | 표 알림 규칙 저장 — 누구에게·언제·어떤 것만 |
+| `rootr_list_document_commits` | 공개 문서에 온 변경 제안 목록 |
+| `rootr_merge_document_commit` | 변경 제안 반영(세 벌 병합 — 덮어쓰기 아님) |
+| `rootr_reject_document_commit` | 변경 제안 거절(사유는 제안자에게 전달) |
+| `rootr_read_node_access` | 이 문서·폴더를 누가 볼 수 있는지(공개범위 + 따로 준 권한) |
+| `rootr_set_node_visibility` | 비공개로 잠그기 / 상위 설정 따르기 |
+| `rootr_grant_node_permission` | 한 사람(또는 그룹)에게 READ·WRITE·MANAGE 주기 |
+| `rootr_revoke_node_permission` | 준 권한 거두기 |
+| `rootr_update_form_response` | 이미 들어온 폼 응답 고치기(폼 검사 규칙 다시 통과) |
+| `rootr_delete_form_response` | 폼 응답 한 건 삭제 |
+| `rootr_create_form_collector` | 응답 모을 표·스프레드시트를 **만들어서** 연결(표는 질문 그대로 칸 생성) |
+
+**사람 칸은 여러 명을 담습니다.** 회의 참석자·공동 담당처럼 여럿이 들어가는 자리가
+흔해서, 값은 이름 목록(`["김대표","이팀장"]`)입니다. 이름 하나만 보내도 받아 주고
+목록으로 맞춰 돌려줍니다. 새로 들어온 사람에게만 알림이 갑니다.
+
+**"만들면서 같이 잠그기".** 공개범위는 스캐폴드 트리에서도 노드마다 지정할 수 있습니다 —
+`{ name: "채용", visibility: "PRIVATE", access: [{ subjectId: "<userId>", level: "READ" }] }`.
+폴더는 만들어 주면서 잠그는 건 사람이 따로 해야 하는 상태가 되지 않도록, 한 번에 갑니다.
+명령줄에서는 `rootr access <경로|id> --private`, `--grant <userId> --level READ`,
+`--revoke <userId>` 입니다. (웹에 공개하는 것과는 다릅니다 — 그건 `rootr_set_document_public`.)
+
+응답 모을 곳은 `rootr form collect <폼> --to db|sheet`로 **만들면서** 연결합니다 —
+표로 만들면 폼 질문 그대로 칸이 생기므로, 표를 미리 만들고 칸 이름을 맞출 필요가 없습니다
+(이름이 하나라도 어긋나면 그 칸은 영영 빈 칸으로 남습니다). 스캐폴드 트리에서는 폼 노드에
+`form.collectInto: "database" | "spreadsheet"`로 같은 일을 합니다.
+
+폼 응답은 `rootr form responses <폼> [--latest]`로 보고, `rootr form response-edit <응답id>
+--values '{"필드id":"값"}'`로 고치고, `rootr form response-rm <응답id> --yes`로 지웁니다.
+`--latest`는 같은 사람이 여러 번 낸 것 중 마지막 한 건만 남깁니다(익명 제출은 합치지 않습니다).
 
 행의 **상세 내용(본문 메모)** — 화면에서 칸반 카드를 열면 속성 아래에 적는 그 글 — 은
 `body`로 오갑니다. 실체는 표 밑에 달리는 문서 한 장이고, 없으면 쓸 때 만들어집니다.

package/bin/rootr.js

@@ -19,6 +19,7 @@ const USAGE = `Rootr CLI v${pkg.version}
   rootr write <path|id> [--file <f>] [--if-match <etag>]   문서 전체 교체(파일 없으면 생성)
   rootr append <path|id> [<text>] [--heading "## X"] [--file <f>]  문서 끝(또는 헤딩 아래)에 안전하게 추가
   rootr edit <path|id> --find <text> --replace <text> [--all]      본문 내 텍스트 치환
+  rootr comments <path|id> [--block <id>] [--json]  문서에 달린 댓글 읽기 (공개 페이지 댓글 포함)
   rootr search <query>                             워크스페이스 검색
   rootr mv <path|id> <새 경로|폴더 id>              문서/폴더 이동 및/또는 이름 변경
   rootr rm <path|id> [--yes]                       문서/폴더를 휴지통으로 이동 (복구 가능)
@@ -28,8 +29,18 @@ const USAGE = `Rootr CLI v${pkg.version}
   rootr ask <question> [--workspace <w>]           GraphRAG 질의응답 (RCA), 인용 포함 출력
   rootr db create [--file <spec.json>] [--parent <path|id>]  표(DATABASE) 생성 — 컬럼 순서 그대로, 행까지 한 번에
   rootr db rows <path|id> [--body] [--json]        표의 행 목록 (--body: 상세 내용까지)
+  rootr db lock <path|id> [--schema managers] [--rows own] [--locked "승인,점수"]  표 자물쇠 보기·걸기
+  rootr db notify <path|id> [--file rules.json] [--clear]  표 알림 규칙 보기·저장
   rootr db row-add <path|id> --values '<json>' [--body <md>|--body-file <f>]  행 추가(상세 내용 포함)
   rootr db row-body <path|id> <rowId> [--file <f>] 행의 상세 내용(본문 메모) 쓰기 — 없으면 표준입력
+  rootr access <path|id> [--json]                  공개범위·권한 보기 (관리 권한 필요)
+  rootr access <path|id> --private|--public|--inherit   공개범위 바꾸기
+  rootr access <path|id> --grant <userId> --level READ|WRITE|MANAGE   사람에게 권한 주기
+  rootr access <path|id> --revoke <userId>          준 권한 거두기
+  rootr form collect <path|id> --to db|sheet             응답 모을 곳을 새로 만들어 연결 (표는 질문 그대로 칸 생성)
+  rootr form responses <path|id> [--latest] [--json]  폼에 들어온 응답 보기 (--latest: 사람마다 최신 1건만)
+  rootr form response-edit <응답id> --values '<json>'  이미 낸 응답 고치기 (폼 검사 규칙 다시 통과)
+  rootr form response-rm <응답id> [--yes]           응답 한 건 삭제 (되돌릴 수 없음)
   rootr config [--api-key <k>] [--workspace <w>] [--base-url <u>]  설정 조회/저장
   rootr config --add-key <k> [--label <name>] [--workspace <w>]     워크스페이스별 키 추가 등록
   rootr mcp                                        MCP stdio 서버 구동 (도구 90종+ — README 참고)
@@ -115,6 +126,41 @@ async function cmdLs(args) {
   }
 }
 
+/**
+ * `rootr comments <path|id>` — 그 문서에 달린 댓글을 읽는다.
+ *
+ * 2026-08-23 창업자 확인 요청: "댓글 써진 거 mcp/api/cli로 읽어올 수 있는 거 맞는지."
+ * API와 MCP에는 있었고 CLI에만 없었다. 공개 페이지에 달린 댓글도 같은 곳에 쌓이므로
+ * 여기서 함께 나온다.
+ */
+async function cmdComments(args) {
+  const target = args._[0];
+  if (!target) throw new Error('사용법: rootr comments <path|id> [--block <blockId>] [--json]');
+
+  const client = makeClient();
+  const id = requireResolved(await resolveTarget(client, target));
+  const threads = await client.listComments(id, { blockId: args.block });
+
+  if (args.json) {
+    console.log(JSON.stringify(threads, null, 2));
+    return;
+  }
+  if (!threads.length) {
+    console.log('댓글이 없습니다.');
+    return;
+  }
+  for (const t of threads) {
+    const when = String(t.createdAt ?? '').slice(0, 16).replace('T', ' ');
+    console.log(`- ${t.author?.name ?? '(알 수 없음)'} · ${when}`);
+    console.log(`  ${String(t.body ?? '').replace(/\n/g, '\n  ')}`);
+    for (const r of t.replies ?? []) {
+      const rWhen = String(r.createdAt ?? '').slice(0, 16).replace('T', ' ');
+      console.log(`    ↳ ${r.author?.name ?? '(알 수 없음)'} · ${rWhen}`);
+      console.log(`      ${String(r.body ?? '').replace(/\n/g, '\n      ')}`);
+    }
+  }
+}
+
 async function cmdRead(args) {
   const target = args._[0];
   if (!target) throw new Error('사용법: rootr read <path|id> [--json]');
@@ -445,14 +491,166 @@ async function cmdMcp() {
  * 컬럼을 하나씩 붙이는 방식은 호출 순서가 곧 컬럼 순서가 되어 옮겨온 표가 뒤죽박죽이
  * 됐다 — 그래서 CLI도 "한 번에" 쪽만 제공한다.
  */
+/**
+ * `rootr access <path|id> [--private|--public|--inherit] [--grant <id> --level …] [--revoke <id>]`
+ *
+ * 화면의 "공개범위"·"권한" 창을 터미널에서. 인자 없이 부르면 지금 상태를 보여 준다.
+ * 관리 권한이 없으면 서버가 막는다(보기도 안 된다).
+ */
+async function cmdAccess(args) {
+  const target = args._[0];
+  if (!target) {
+    throw new Error(
+      '사용법: rootr access <path|id> [--private|--public|--inherit] [--grant <userId> --level READ|WRITE|MANAGE] [--revoke <userId>]',
+    );
+  }
+  const client = makeClient();
+  const id = requireResolved(await resolveTarget(client, target));
+  const group = args.group ? 'GROUP' : 'USER';
+
+  let changed = false;
+  if (args.private || args.public || args.inherit) {
+    const visibility = args.private ? 'PRIVATE' : args.public ? 'PUBLIC' : null;
+    await client.setNodeVisibility(id, visibility);
+    console.log(
+      `공개범위: ${visibility === 'PRIVATE' ? '비공개(만든 사람·관리자·따로 준 사람만)' : visibility === 'PUBLIC' ? '워크스페이스 전체' : '상위 폴더/워크스페이스 기본값을 따름'}`,
+    );
+    changed = true;
+  }
+  if (typeof args.grant === 'string') {
+    const level = String(args.level || '').toUpperCase();
+    if (!['READ', 'WRITE', 'MANAGE'].includes(level)) {
+      throw new Error('--grant 에는 --level READ|WRITE|MANAGE 를 함께 주세요.');
+    }
+    await client.grantNodePermission(id, { subjectType: group, subjectId: args.grant, level });
+    console.log(`권한 부여: ${args.grant} → ${level}`);
+    changed = true;
+  }
+  if (typeof args.revoke === 'string') {
+    await client.revokeNodePermission(id, { subjectType: group, subjectId: args.revoke });
+    console.log(`권한 회수: ${args.revoke}`);
+    changed = true;
+  }
+
+  const info = await client.getNodeAccess(id);
+  if (args.json) {
+    console.log(JSON.stringify(info, null, 2));
+    return;
+  }
+  if (!changed) {
+    const eff = info.effectiveVisibility ?? info.visibility;
+    console.log(`공개범위: ${eff === 'PRIVATE' ? '비공개' : '워크스페이스 전체'}${info.visibility === null ? ' (상속받음)' : ''}`);
+  }
+  const direct = info.direct ?? [];
+  console.log(`따로 준 권한: ${direct.length ? '' : '없음'}`);
+  for (const p of direct) console.log(`  - ${p.subjectType} ${p.subjectId} → ${p.level}`);
+}
+
+/**
+ * `rootr form responses|response-edit|response-rm`
+ *
+ * 폼에 들어온 응답을 터미널에서 보고 고치고 지운다. 화면에서만 되면
+ * 에이전트에게는 없는 기능이라 여기까지 열어 둔다.
+ */
+async function cmdForm(args) {
+  const sub = args._[0];
+  if (sub === 'collect') return cmdFormCollect(args);
+  if (sub === 'responses') return cmdFormResponses(args);
+  if (sub === 'response-edit') return cmdFormResponseEdit(args);
+  if (sub === 'response-rm') return cmdFormResponseRm(args);
+  throw new Error('사용법: rootr form collect|responses|response-edit|response-rm … (자세한 건 rootr --help)');
+}
+
+/**
+ * `rootr form collect <path|id> --to db|sheet`
+ *
+ * 응답 모을 곳을 새로 만들어 연결한다. 표로 만들면 폼 질문 그대로 칸이 생기므로,
+ * 표를 미리 만들고 칸 이름을 하나하나 맞출 필요가 없다.
+ */
+async function cmdFormCollect(args) {
+  const target = args._[1];
+  if (!target) throw new Error('사용법: rootr form collect <path|id> --to db|sheet');
+  const to = String(args.to || '').toLowerCase();
+  const map = { db: 'database', database: 'database', sheet: 'spreadsheet', spreadsheet: 'spreadsheet' };
+  if (!map[to]) throw new Error('--to 에 db 또는 sheet 를 주세요.');
+
+  const client = makeClient();
+  const id = requireResolved(await resolveTarget(client, target));
+  const made = await client.createFormCollector(id, map[to]);
+  if (args.json) {
+    console.log(JSON.stringify(made, null, 2));
+    return;
+  }
+  console.log(
+    made.kind === 'database'
+      ? `표를 만들어 연결했습니다: ${made.nodeId}  (폼 질문 그대로 칸이 생겼습니다)`
+      : `스프레드시트를 만들어 연결했습니다: ${made.nodeId}`,
+  );
+}
+
+async function cmdFormResponses(args) {
+  const target = args._[1];
+  if (!target) throw new Error('사용법: rootr form responses <path|id> [--latest] [--json]');
+  const client = makeClient();
+  const id = requireResolved(await resolveTarget(client, target));
+  const rows = await client.listFormResponses(id, { latestPerRespondent: Boolean(args.latest) });
+
+  if (args.json) {
+    console.log(JSON.stringify(rows, null, 2));
+    return;
+  }
+  if (!rows.length) {
+    console.log('아직 들어온 응답이 없습니다.');
+    return;
+  }
+  console.log(`응답 ${rows.length}건${args.latest ? ' (사람마다 최신 1건만)' : ''}`);
+  for (const r of rows) {
+    const who = r.submitterUserId ? r.submitterUserId : '익명';
+    console.log(`- ${r.id}  ${new Date(r.createdAt).toISOString()}  제출자:${who}`);
+    console.log(`  ${JSON.stringify(r.values)}`);
+  }
+}
+
+async function cmdFormResponseEdit(args) {
+  const responseId = args._[1];
+  if (!responseId) throw new Error("사용법: rootr form response-edit <응답id> --values '<json>'");
+  const raw = typeof args.values === 'string' ? args.values : await readStdin();
+  let values;
+  try {
+    values = JSON.parse(raw);
+  } catch {
+    throw new Error('--values 를 JSON으로 읽을 수 없습니다. {"필드id":"값"} 형태여야 합니다.');
+  }
+  // 통째로 바뀐다 — 남기고 싶은 답도 같이 보내야 한다.
+  const result = await makeClient().updateFormResponse(responseId, values);
+  if (args.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(`응답 수정됨: ${result.id ?? responseId}`);
+  console.log(`  ${JSON.stringify(result.values ?? values)}`);
+}
+
+async function cmdFormResponseRm(args) {
+  const responseId = args._[1];
+  if (!responseId) throw new Error('사용법: rootr form response-rm <응답id> [--yes]');
+  if (!args.yes) {
+    throw new Error('응답 삭제는 되돌릴 수 없습니다. 정말 지우려면 --yes 를 붙이세요.');
+  }
+  await makeClient().deleteFormResponse(responseId);
+  console.log(`응답 삭제됨: ${responseId}`);
+}
+
 async function cmdDb(args) {
   const sub = args._[0];
   if (sub === 'rows') return cmdDbRows(args);
   if (sub === 'row-add') return cmdDbRowAdd(args);
   if (sub === 'row-body') return cmdDbRowBody(args);
+  if (sub === 'lock') return cmdDbLock(args);
+  if (sub === 'notify') return cmdDbNotify(args);
   if (sub !== 'create') {
     throw new Error(
-      '사용법: rootr db create|rows|row-add|row-body … (자세한 건 rootr --help)',
+      '사용법: rootr db create|rows|row-add|row-body|lock|notify … (자세한 건 rootr --help)',
     );
   }
   const raw = typeof args.file === 'string' ? readFileSync(args.file, 'utf8') : await readStdin();
@@ -482,6 +680,90 @@ async function cmdDb(args) {
 }
 
 /** 표의 행 목록. --body 를 주면 행마다 상세 내용(본문 메모)까지 가져온다. */
+/**
+ * `rootr db lock <path|id> [--schema managers|open] [--rows own|all] [--locked <칸,칸>]`
+ *
+ * 표에 거는 자물쇠 — 노션에 없는 것이다. 인자 없이 부르면 지금 상태를 보여 준다.
+ */
+async function cmdDbLock(args) {
+  const target = args._[1];
+  if (!target) throw new Error('사용법: rootr db lock <path|id> [--schema managers|open] [--rows own|all] [--locked "승인,점수"]');
+
+  const client = makeClient();
+  const id = requireResolved(await resolveTarget(client, target));
+
+  const patch = {};
+  if (args.schema !== undefined) patch.schemaLock = args.schema;
+  if (args.rows !== undefined) patch.rowScope = args.rows;
+  if (args.locked !== undefined) {
+    patch.lockedProps = String(args.locked)
+      .split(',')
+      .map((x) => x.trim())
+      .filter(Boolean);
+  }
+
+  const result = Object.keys(patch).length
+    ? await client.setDatabasePermissions(id, patch)
+    : await client.getDatabasePermissions(id);
+
+  if (args.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(`칸·뷰 잠금: ${result.schemaLock === 'managers' ? '관리자만' : '누구나'}`);
+  console.log(`행 보기   : ${result.rowScope === 'own' ? '본인이 만든 행만' : '전부'}`);
+  console.log(`잠긴 칸   : ${(result.lockedProps ?? []).length ? result.lockedProps.join(', ') : '없음'}`);
+}
+
+/**
+ * `rootr db notify <path|id> [--file rules.json]`
+ *
+ * 표에 무슨 일이 생기면 누구에게 알릴지. 파일 없이 부르면 지금 규칙을 보여 준다.
+ * 규칙 모양: [{ "userIds": ["…"], "events": ["created"], "filter": {"propId":"p1","op":"is","value":"긴급"} }]
+ */
+async function cmdDbNotify(args) {
+  const target = args._[1];
+  if (!target) throw new Error('사용법: rootr db notify <path|id> [--file rules.json] [--clear] [--json]');
+
+  const client = makeClient();
+  const id = requireResolved(await resolveTarget(client, target));
+
+  if (args.clear) {
+    const cleared = await client.setDatabaseNotifications(id, []);
+    console.log('알림 규칙을 모두 지웠습니다.');
+    if (args.json) console.log(JSON.stringify(cleared, null, 2));
+    return;
+  }
+  if (args.file) {
+    const raw = readFileSync(args.file, 'utf8');
+    const saved = await client.setDatabaseNotifications(id, JSON.parse(raw));
+    console.log(`알림 규칙 ${saved.watchers.length}개를 저장했습니다.`);
+    if (args.json) console.log(JSON.stringify(saved, null, 2));
+    return;
+  }
+
+  const { watchers } = await client.getDatabaseNotifications(id);
+  if (args.json) {
+    console.log(JSON.stringify(watchers, null, 2));
+    return;
+  }
+  if (!watchers.length) {
+    console.log('알림 규칙이 없습니다.');
+    return;
+  }
+  const WHEN = { created: '행 추가', updated: '행 수정', deleted: '행 삭제' };
+  for (const w of watchers) {
+    const when = (w.events ?? []).map((e) => WHEN[e] ?? e).join(' · ');
+    const f = w.filter;
+    const only = f
+      ? f.op === 'changed'
+        ? ` (${f.propId} 칸이 바뀌었을 때만)`
+        : ` (${f.propId} ${f.op === 'is' ? '=' : '⊃'} ${f.value})`
+      : '';
+    console.log(`- ${when}${only} → ${(w.userIds ?? []).length}명`);
+  }
+}
+
 async function cmdDbRows(args) {
   const target = args._[1];
   if (!target) throw new Error('사용법: rootr db rows <path|id> [--body] [--json]');
@@ -575,6 +857,8 @@ async function main() {
   switch (cmd) {
     case 'ls':
       return cmdLs(args);
+    case 'comments':
+      return cmdComments(args);
     case 'read':
       return cmdRead(args);
     case 'write':
@@ -601,6 +885,10 @@ async function main() {
       return cmdUse(args);
     case 'db':
       return cmdDb(args);
+    case 'form':
+      return cmdForm(args);
+    case 'access':
+      return cmdAccess(args);
     case 'mcp':
       return cmdMcp(args);
     default:

package/lib/client.js

@@ -348,6 +348,55 @@ export class RootrClient {
     });
   }
 
+  // ── DB-PERM-001 / DB-WATCH — 표에 거는 자물쇠와 알림 규칙 ──────────────
+  //
+  // 노션에 없는 것들이라, 에이전트가 표를 만들어 놓고도 "지원서는 서로 못 보게" 같은
+  // 요구를 못 들어주는 일이 있었다. 만들 수 있으면 잠글 수도 있어야 한다.
+
+  async getDatabasePermissions(databaseId) {
+    return this.request(`/databases/${encodeURIComponent(databaseId)}/permissions`);
+  }
+
+  async setDatabasePermissions(databaseId, permissions) {
+    return this.request(`/databases/${encodeURIComponent(databaseId)}/permissions`, {
+      method: 'PATCH',
+      body: permissions,
+    });
+  }
+
+  async getDatabaseNotifications(databaseId) {
+    return this.request(`/databases/${encodeURIComponent(databaseId)}/notifications`);
+  }
+
+  async setDatabaseNotifications(databaseId, watchers) {
+    return this.request(`/databases/${encodeURIComponent(databaseId)}/notifications`, {
+      method: 'PUT',
+      body: { watchers },
+    });
+  }
+
+  // ── PUBLIC-DOCS — 발행한 문서에 올라온 변경 제안 ────────────────────────
+
+  async listDocumentCommits(documentId, status = 'OPEN') {
+    return this.request(
+      `/documents/${encodeURIComponent(documentId)}/commits?status=${encodeURIComponent(status)}`,
+    );
+  }
+
+  async mergeDocumentCommit(documentId, commitId, force = false) {
+    return this.request(
+      `/documents/${encodeURIComponent(documentId)}/commits/${encodeURIComponent(commitId)}/merge`,
+      { method: 'POST', body: force ? { force: true } : {} },
+    );
+  }
+
+  async rejectDocumentCommit(documentId, commitId, reason) {
+    return this.request(
+      `/documents/${encodeURIComponent(documentId)}/commits/${encodeURIComponent(commitId)}/reject`,
+      { method: 'POST', body: reason ? { reason } : {} },
+    );
+  }
+
   async getDocumentPublicStatus(documentId) {
     return this.request(`/documents/${encodeURIComponent(documentId)}/public-status`);
   }
@@ -602,6 +651,25 @@ export class RootrClient {
     });
   }
 
+  /**
+   * 뷰를 하나 **덧붙인다**(기존 뷰는 그대로). 표를 만들 때만 뷰를 정할 수 있어서,
+   * 노션에서 뷰가 넷인 표를 옮기면 하나밖에 못 두던 문제를 푼다.
+   */
+  async createDatabaseView(databaseId, { name, type, groupBy, dateProp, endDateProp } = {}) {
+    return this.request(`/databases/${encodeURIComponent(databaseId)}/views`, {
+      method: 'POST',
+      body: { name, type, groupBy, dateProp, endDateProp },
+    });
+  }
+
+  /** 뷰 하나를 지운다. 마지막 하나는 못 지운다. 행 값은 안 지워진다. */
+  async deleteDatabaseView(databaseId, viewId) {
+    return this.request(
+      `/databases/${encodeURIComponent(databaseId)}/views/${encodeURIComponent(viewId)}`,
+      { method: 'DELETE' },
+    );
+  }
+
   /**
    * 뷰 하나만 고친다(이름·감출 컬럼·그룹 기준). PATCH /databases/:id 는 views 배열을
    * 통째로 갈아끼워서 빠뜨린 뷰가 사라지는데, 여기서는 서버가 그 뷰만 병합한다.
@@ -655,10 +723,11 @@ export class RootrClient {
   // PATCH /databases/:id replaces the whole properties array, so rebuilding it
   // client-side drops any column left out. These merge server-side instead.
 
-  async addColumn(databaseId, { name, type, options } = {}) {
+  async addColumn(databaseId, { name, type, options, relationDatabaseId, formula, rollup, prefix } = {}) {
     return this.request(`/databases/${encodeURIComponent(databaseId)}/columns`, {
       method: 'POST',
-      body: { name, type, options },
+      // 계산 칸(수식·롤업·번호)은 설정이 곧 그 칸이라 같이 보내야 한다.
+      body: { name, type, options, relationDatabaseId, formula, rollup, prefix },
     });
   }
 
@@ -1136,13 +1205,75 @@ export class RootrClient {
     });
   }
 
-  /** Submitted responses, most recent first. */
-  async listFormResponses(formId) {
-    const data = await this.request(`/forms/${encodeURIComponent(formId)}/responses`);
+  // ── 문서·폴더 접근 권한(공개범위) ────────────────────────────────
+  // 화면의 "공개범위"·"권한" 창이 하는 일을 그대로 연다. 관리 권한이 있는
+  // 사람만 부를 수 있고, 없으면 서버가 403으로 막는다.
+
+  /** 이 노드의 공개범위와 직접·상속 권한을 함께 읽는다. */
+  async getNodeAccess(nodeId) {
+    return this.request(`/nodes/${encodeURIComponent(nodeId)}/permissions`);
+  }
+
+  /** 공개범위를 정한다. null이면 상위 폴더/워크스페이스 기본값을 따른다. */
+  async setNodeVisibility(nodeId, visibility) {
+    return this.request(`/nodes/${encodeURIComponent(nodeId)}/visibility`, {
+      method: 'POST',
+      body: { visibility: visibility ?? null },
+    });
+  }
+
+  /** 특정 사람/그룹에게 이 노드의 권한을 준다(이미 있으면 등급만 바뀐다). */
+  async grantNodePermission(nodeId, { subjectType = 'USER', subjectId, level }) {
+    return this.request(`/nodes/${encodeURIComponent(nodeId)}/permissions`, {
+      method: 'POST',
+      body: { subjectType, subjectId, level },
+    });
+  }
+
+  /** 준 권한을 거둔다. */
+  async revokeNodePermission(nodeId, { subjectType = 'USER', subjectId }) {
+    return this.request(`/nodes/${encodeURIComponent(nodeId)}/permissions`, {
+      method: 'DELETE',
+      body: { subjectType, subjectId },
+    });
+  }
+
+  /**
+   * Submitted responses, most recent first.
+   * `latestPerRespondent`이면 같은 사람이 여러 번 낸 것 중 마지막 것만 남긴다
+   * (누가 냈는지 모르는 익명 제출은 합치지 않는다 — 합칠 근거가 없다).
+   */
+  async listFormResponses(formId, { latestPerRespondent } = {}) {
+    const qs = latestPerRespondent ? '?latestPerRespondent=true' : '';
+    const data = await this.request(`/forms/${encodeURIComponent(formId)}/responses${qs}`);
     if (data && Array.isArray(data.responses)) return data.responses;
     return [];
   }
 
+  /**
+   * 응답 모을 곳을 새로 만들어 연결한다. 'database'면 폼 질문 그대로 칸이 생기고,
+   * 'spreadsheet'면 응답이 깔리는 시트가 한 장 생긴다. 미리 만들어 둘 필요가 없다.
+   */
+  async createFormCollector(formId, target) {
+    return this.request(`/forms/${encodeURIComponent(formId)}/collect`, {
+      method: 'POST',
+      body: { target },
+    });
+  }
+
+  /** 이미 낸 응답의 내용을 고친다(폼의 검사 규칙을 그대로 다시 통과해야 한다). */
+  async updateFormResponse(responseId, values) {
+    return this.request(`/form-responses/${encodeURIComponent(responseId)}`, {
+      method: 'PATCH',
+      body: { values },
+    });
+  }
+
+  /** 응답 한 건을 지운다. */
+  async deleteFormResponse(responseId) {
+    return this.request(`/form-responses/${encodeURIComponent(responseId)}`, { method: 'DELETE' });
+  }
+
   async createFormResponse(formId, values) {
     return this.request(`/forms/${encodeURIComponent(formId)}/responses`, {
       method: 'POST',