rootr-cli 0.8.1 → 0.9.0

package/lib/mcp-tools/databases.js

@@ -60,11 +60,17 @@ export function registerDatabaseTools(server) {
         'board, a task/requirement/risk tracker, anything with trackable rows. Do NOT fake a table with a markdown ' +
         'document, and do NOT create an empty database and then add columns one by one — `properties` order IS the ' +
         'column order, so one call keeps the columns in exactly the order you list them. ' +
-        'The FIRST property must be type "title" (the row label). Other types: text | number | select | ' +
-        'multi_select | date | checkbox | url | person. select/multi_select take options:[{name,color}]. ' +
-        'Views default to a single table view; a "board" view needs config.groupBy = a select property id, a ' +
-        '"timeline" view needs config.dateProp. Row `values` are keyed by column NAME (or id); date values are ' +
-        '{ start: "YYYY-MM-DD", end? }, multi_select is string[].',
+        'The FIRST property must be type "title" (the row label). Other types: text | number | select | multi_select | ' +
+        'status | date | checkbox | url | email | phone | person | files | relation | formula | rollup | ' +
+        'created_time | last_edited_time | created_by | last_edited_by | unique_id. ' +
+        'select/multi_select/status take options:[{name,color,group?}] (group ∈ todo|in_progress|done, status only); ' +
+        'relation takes relationDatabaseId; formula takes formula ("{수량} * {단가}"); rollup takes ' +
+        'rollup:{relation,property?,function}; unique_id takes prefix ("TASK" → "TASK-42"). The last seven types are ' +
+        'filled in by the server and take no row value. ' +
+        'Views default to a single table view; view types are table | board | gallery | calendar | timeline | list — ' +
+        'a "board" view needs config.groupBy (a select/status property id), a "timeline"/"calendar" view needs ' +
+        'config.dateProp. Row `values` are keyed by column NAME (or id); date values are ' +
+        '{ start: "YYYY-MM-DDTHH:mm" or "YYYY-MM-DD", end? }, multi_select is string[], relation is an array of row ids.',
       annotations: { readOnlyHint: false, destructiveHint: false },
       inputSchema: {
         name: z.string().describe('Table name, e.g. "업무 목록"'),
@@ -77,12 +83,54 @@ export function registerDatabaseTools(server) {
             z.object({
               name: z.string().describe('Column header, e.g. "담당자"'),
               type: z
-                .enum(['title', 'text', 'number', 'select', 'multi_select', 'date', 'checkbox', 'url', 'person'])
+                .enum([
+                  'title',
+                  'text',
+                  'number',
+                  'select',
+                  'multi_select',
+                  'status',
+                  'date',
+                  'checkbox',
+                  'url',
+                  'email',
+                  'phone',
+                  'person',
+                  'files',
+                  'relation',
+                  'formula',
+                  'rollup',
+                  'created_time',
+                  'last_edited_time',
+                  'created_by',
+                  'last_edited_by',
+                  'unique_id',
+                ])
                 .describe('Column type; the FIRST property must be "title"'),
               options: z
-                .array(z.object({ name: z.string(), color: z.string() }))
+                .array(z.object({ name: z.string(), color: z.string(), group: z.string().optional() }))
                 .optional()
-                .describe('select/multi_select only: the choices'),
+                .describe('select/multi_select/status only: the choices'),
+              relationDatabaseId: z.string().optional().describe('relation only: the table this column points at'),
+              formula: z.string().optional().describe('formula only: e.g. "{수량} * {단가}"'),
+              rollup: z
+                .object({
+                  relation: z.string(),
+                  property: z.string().optional(),
+                  function: z.enum([
+                    'count',
+                    'count_values',
+                    'sum',
+                    'average',
+                    'min',
+                    'max',
+                    'show_original',
+                    'percent_checked',
+                  ]),
+                })
+                .optional()
+                .describe('rollup only: what to gather through which relation'),
+              prefix: z.string().optional().describe('unique_id only: e.g. "TASK" → "TASK-42"'),
             }),
           )
           .optional()
@@ -120,6 +168,66 @@ export function registerDatabaseTools(server) {
     },
   );
 
+  server.registerTool(
+    'rootr_create_view',
+    {
+      title: 'Add a view to an existing database',
+      description:
+        'Add ONE more view (table / board / gallery / calendar / timeline) to a Rootr (루터) DATABASE that ' +
+        'already exists. Until now views could only be set when the table was CREATED, so a Notion table with ' +
+        'four views could only be migrated with one. Existing views are untouched — the server merges, unlike ' +
+        'a full PATCH which replaces the whole views array and silently drops anything you leave out. ' +
+        'A board needs `groupBy` (a select column); calendar/timeline need `dateProp`. Columns may be given ' +
+        'by NAME or id.',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        databaseId: z.string().describe(DATABASE_TARGET_DESC),
+        name: z.string().describe('View name shown on the tab, e.g. "일정"'),
+        type: z
+          .enum(['table', 'board', 'gallery', 'calendar', 'timeline'])
+          .describe('View layout'),
+        groupBy: z.string().optional().describe('board view: the select column to group by (name or id)'),
+        dateProp: z.string().optional().describe('calendar/timeline view: the date column (name or id)'),
+        endDateProp: z.string().optional().describe('timeline view: the end-date column (name or id)'),
+      },
+    },
+    async ({ databaseId, name, type, groupBy, dateProp, endDateProp }) => {
+      try {
+        const client = makeClient();
+        const id = await resolveNodeId(client, databaseId);
+        const view = await client.createDatabaseView(id, { name, type, groupBy, dateProp, endDateProp });
+        return jsonResult(view);
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_delete_view',
+    {
+      title: 'Delete one view from a database',
+      description:
+        'Remove ONE view from a Rootr (루터) DATABASE. Rows and column values are NOT touched — only that ' +
+        'view\'s layout is removed. The last remaining view cannot be deleted (there would be nothing to look at).',
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      inputSchema: {
+        databaseId: z.string().describe(DATABASE_TARGET_DESC),
+        viewId: z.string().describe('View id or view NAME (from rootr_read_database)'),
+      },
+    },
+    async ({ databaseId, viewId }) => {
+      try {
+        const client = makeClient();
+        const id = await resolveNodeId(client, databaseId);
+        await client.deleteDatabaseView(id, viewId);
+        return jsonResult({ deleted: viewId });
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
   server.registerTool(
     'rootr_update_view',
     {
@@ -229,7 +337,8 @@ export function registerDatabaseTools(server) {
       title: 'Add a database row',
       description:
         'Append a row to a Rootr (루터) DATABASE. `values` maps property NAME (or id) → value. ' +
-        'Value shapes by type: title/text/url/select/person → string; number → number; multi_select → string[]; ' +
+        'Value shapes by type: title/text/url/select → string; number → number; multi_select → string[]; ' +
+        'person → string[] (a LIST of names — a meeting has several attendees; one bare name is also accepted); ' +
         'checkbox → boolean; date → { start: "YYYY-MM-DD", end? }. A select value is the OPTION NAME. ' +
         'Call rootr_read_database first to learn the columns. Optionally set `position` to insert at an index. ' +
         'Pass `body` to also write the row\'s DETAIL PAGE (the note shown under a kanban card\'s properties) — ' +
@@ -328,27 +437,91 @@ export function registerDatabaseTools(server) {
       description:
         'Add ONE column to a Rootr (루터) DATABASE. The existing columns and every row are left untouched — ' +
         'rows simply read empty for the new column until you fill them with rootr_update_row. ' +
-        'type ∈ text | number | select | multi_select | date | checkbox | url | person ' +
+        'type ∈ text | number | select | multi_select | status | date | checkbox | url | email | phone | person | files | ' +
+        'relation | formula | rollup | created_time | last_edited_time | created_by | last_edited_by | unique_id ' +
         '("title" is not allowed: a database already has exactly one title column). ' +
-        'For select/multi_select pass options: [{ name, color }]. Returns the created column WITH ITS id.',
+        'For select/multi_select/status pass options: [{ name, color, group? }] (group ∈ todo|in_progress|done, status only). ' +
+        'For relation pass relationDatabaseId (the node id of the table it points at). ' +
+        'For formula pass formula, e.g. "{수량} * {단가}" or "if({금액} >= 5000, \\"큰 건\\", \\"작은 건\\")" — ' +
+        'available functions: if, concat, length, upper, lower, contains, abs, round, floor, ceil, min, max, dateBetween, now, empty. ' +
+        'For rollup pass rollup: { relation, property?, function } (function ∈ count|count_values|sum|average|min|max|show_original|percent_checked). ' +
+        'For unique_id pass prefix to get "TASK-42" style ids. ' +
+        'created_time / last_edited_time / created_by / last_edited_by / unique_id / formula / rollup are filled in by the server — ' +
+        'they take no value and rootr_update_row will refuse to set them. ' +
+        'Returns the created column WITH ITS id.',
       annotations: { readOnlyHint: false, destructiveHint: false },
       inputSchema: {
         databaseId: z.string().describe(DATABASE_TARGET_DESC),
         name: z.string().describe('Column header, e.g. "담당자"'),
         type: z
-          .enum(['text', 'number', 'select', 'multi_select', 'date', 'checkbox', 'url', 'person'])
+          .enum([
+            'text',
+            'number',
+            'select',
+            'multi_select',
+            'status',
+            'date',
+            'checkbox',
+            'url',
+            'email',
+            'phone',
+            'person',
+            'files',
+            'relation',
+            'formula',
+            'rollup',
+            'created_time',
+            'last_edited_time',
+            'created_by',
+            'last_edited_by',
+            'unique_id',
+          ])
           .describe('Column type'),
         options: z
-          .array(z.object({ name: z.string(), color: z.string() }))
+          .array(z.object({ name: z.string(), color: z.string(), group: z.string().optional() }))
+          .optional()
+          .describe('select/multi_select/status only: the choices, e.g. [{ name: "진행중", color: "blue" }]'),
+        relationDatabaseId: z
+          .string()
+          .optional()
+          .describe('relation only: the node id of the database this column points at'),
+        formula: z
+          .string()
+          .optional()
+          .describe('formula only: the expression, e.g. "{수량} * {단가}"'),
+        rollup: z
+          .object({
+            relation: z.string().describe('the relation column (id or name) to follow'),
+            property: z.string().optional().describe('the column to read in the linked table'),
+            function: z.enum([
+              'count',
+              'count_values',
+              'sum',
+              'average',
+              'min',
+              'max',
+              'show_original',
+              'percent_checked',
+            ]),
+          })
           .optional()
-          .describe('select/multi_select only: the choices, e.g. [{ name: "진행중", color: "blue" }]'),
+          .describe('rollup only: what to gather through which relation'),
+        prefix: z.string().optional().describe('unique_id only: prefix for the number, e.g. "TASK" → "TASK-42"'),
       },
     },
-    async ({ databaseId, name, type, options }) => {
+    async ({ databaseId, name, type, options, relationDatabaseId, formula, rollup, prefix }) => {
       try {
         const client = makeClient();
         const id = await resolveNodeId(client, databaseId);
-        const property = await client.addColumn(id, { name, type, options });
+        const property = await client.addColumn(id, {
+          name,
+          type,
+          options,
+          relationDatabaseId,
+          formula,
+          rollup,
+          prefix,
+        });
         return jsonResult({ property });
       } catch (err) {
         return errorResult(err);
@@ -387,6 +560,131 @@ export function registerDatabaseTools(server) {
     },
   );
 
+  // ── DB-PERM-001 / DB-WATCH — 노션에 없는 두 가지: 자물쇠와 알림 ────────────
+  //
+  // 표를 만들 수 있으면 잠글 수도, 누구에게 알릴지 정할 수도 있어야 한다. 이게 없으면
+  // 에이전트가 "지원서 표 만들어 줘. 서로 못 보게 하고, 새 지원 들어오면 김승수한테
+  // 알려 줘" 같은 부탁의 절반만 해내고 만다.
+
+  server.registerTool(
+    'rootr_read_database_permissions',
+    {
+      title: 'Read a database\'s locks',
+      description:
+        'Read the three locks on a Rootr (루터) DATABASE — schema lock (only managers change columns/views), ' +
+        'own-rows-only (people see just what they submitted), and manager-only columns. Notion has none of these.',
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      inputSchema: { databaseId: z.string().describe(DATABASE_TARGET_DESC) },
+    },
+    async ({ databaseId }) => {
+      try {
+        const client = makeClient();
+        const id = await resolveNodeId(client, databaseId);
+        return jsonResult(await client.getDatabasePermissions(id));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_set_database_permissions',
+    {
+      title: 'Lock a database',
+      description:
+        'Set the locks on a Rootr (루터) DATABASE. `schemaLock: "managers"` stops editors from changing columns and ' +
+        'views; `rowScope: "own"` hides other people\'s rows (application forms, report boxes); `lockedProps` names ' +
+        'the columns only managers may edit (approval flags, final scores). Omitted fields keep their current value. ' +
+        'Requires MANAGE on the table.',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        databaseId: z.string().describe(DATABASE_TARGET_DESC),
+        schemaLock: z.enum(['open', 'managers']).optional().describe('Who may change columns and views'),
+        rowScope: z.enum(['all', 'own']).optional().describe('"own" = each person sees only the rows they created'),
+        lockedProps: z
+          .array(z.string())
+          .optional()
+          .describe('Column ids (or names) only managers may edit'),
+      },
+    },
+    async ({ databaseId, schemaLock, rowScope, lockedProps }) => {
+      try {
+        const client = makeClient();
+        const id = await resolveNodeId(client, databaseId);
+        const body = {};
+        if (schemaLock !== undefined) body.schemaLock = schemaLock;
+        if (rowScope !== undefined) body.rowScope = rowScope;
+        if (lockedProps !== undefined) body.lockedProps = lockedProps;
+        return jsonResult(await client.setDatabasePermissions(id, body));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_read_database_notifications',
+    {
+      title: 'Read a database\'s notification rules',
+      description:
+        'Read who gets notified when rows are added, changed or deleted in a Rootr (루터) DATABASE. ' +
+        'Notion cannot do this — there each person must turn on watching for themselves.',
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      inputSchema: { databaseId: z.string().describe(DATABASE_TARGET_DESC) },
+    },
+    async ({ databaseId }) => {
+      try {
+        const client = makeClient();
+        const id = await resolveNodeId(client, databaseId);
+        return jsonResult(await client.getDatabaseNotifications(id));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_set_database_notifications',
+    {
+      title: 'Set who gets notified about a database',
+      description:
+        'Replace the notification rules on a Rootr (루터) DATABASE. Each rule names the people to notify (`userIds`), ' +
+        'when (`events`: created / updated / deleted), and optionally a filter so only some rows ping — ' +
+        '`{propId, op: "is"|"contains"|"changed", value}` (e.g. status is 긴급, owner changed). ' +
+        'Rules replace the existing set; pass [] to clear. Requires MANAGE. A person is never notified about their own change.',
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      inputSchema: {
+        databaseId: z.string().describe(DATABASE_TARGET_DESC),
+        watchers: z
+          .array(
+            z.object({
+              id: z.string().optional(),
+              userIds: z.array(z.string()).describe('Workspace member user ids to notify'),
+              events: z.array(z.enum(['created', 'updated', 'deleted'])),
+              filter: z
+                .object({
+                  propId: z.string(),
+                  op: z.enum(['is', 'contains', 'changed']),
+                  value: z.string().optional(),
+                })
+                .optional(),
+              label: z.string().optional(),
+            }),
+          )
+          .describe('The complete rule set (replaces what is stored)'),
+      },
+    },
+    async ({ databaseId, watchers }) => {
+      try {
+        const client = makeClient();
+        const id = await resolveNodeId(client, databaseId);
+        return jsonResult(await client.setDatabaseNotifications(id, watchers));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
   server.registerTool(
     'rootr_delete_column',
     {

package/lib/mcp-tools/documents.js

@@ -2,7 +2,7 @@ import { z } from 'zod';
 
 import { RootrApiError } from '../client.js';
 import { resolveTarget, requireResolved, resolveMoveDestination } from '../resolve.js';
-import { textResult, jsonResult, errorResult, makeClient } from './shared.js';
+import { textResult, jsonResult, errorResult, makeClient, NODE_TARGET_HINT } from './shared.js';
 
 /** Registers the original 6 document tools: list/read/append/edit/write/search. */
 export function registerDocumentTools(server) {
@@ -304,6 +304,24 @@ export function registerDocumentTools(server) {
           .union([z.string(), z.null()])
           .optional()
           .describe('ISO date to auto-close the public page, or null to clear an existing expiry'),
+        // PUBLIC-LOCK / PUBLIC-ACCESS — 노션 공개 페이지에 없는 것들.
+        password: z
+          .union([z.string(), z.null()])
+          .optional()
+          .describe(
+            'Lock the page so only readers who know the link AND this password can read it (4+ chars); ' +
+              'null or "" removes the lock. Team plan and up. Locking also turns search exposure off, and it ' +
+              'cannot be turned back on while the page stays locked.',
+          ),
+        allowClone: z
+          .boolean()
+          .optional()
+          .describe('Whether visitors may copy the page into their own workspace (turn off for quotes/contracts)'),
+        allowComments: z.boolean().optional().describe('Whether visitors may comment on the public page'),
+        noIndex: z
+          .boolean()
+          .optional()
+          .describe('true hides the page from search engines (Team plan and up)'),
         skin: z
           .enum([
             'classic',
@@ -336,11 +354,104 @@ export function registerDocumentTools(server) {
           .describe('Layout options; only the sub-fields you pass are changed'),
       },
     },
-    async ({ target, isPublic, allowCommits, expiresAt, skin, layout }) => {
+    async ({ target, isPublic, allowCommits, expiresAt, skin, layout, password, allowClone, allowComments, noIndex }) => {
+      try {
+        const client = makeClient();
+        const id = requireResolved(await resolveTarget(client, target));
+        // 주지 않은 값은 보내지 않는다 — 서버가 "안 보낸 것은 그대로"로 다루므로,
+        // undefined를 그대로 실어 보내면 다른 설정을 건드릴 위험이 있다.
+        const body = {};
+        for (const [k, v] of Object.entries({
+          isPublic,
+          allowCommits,
+          expiresAt,
+          skin,
+          layout,
+          password,
+          allowClone,
+          allowComments,
+          noIndex,
+        })) {
+          if (v !== undefined) body[k] = v;
+        }
+        return jsonResult(await client.setDocumentPublic(id, body));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  // PUBLIC-DOCS — 밖에서 온 변경 제안을 에이전트가 보고 처리할 수 있게. 노션에 없다.
+  server.registerTool(
+    'rootr_list_document_commits',
+    {
+      title: 'List change proposals on a Rootr document',
+      description:
+        'List the git-style change proposals people sent to a published Rootr (루터) document. Shows who proposed ' +
+        'what, whether the document moved on since (`stale`) and how many places clash (`conflicts`).',
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      inputSchema: {
+        target: z.string().describe('Document path (starting with "/") or node id, or a full rootr.io URL'),
+        status: z.enum(['OPEN', 'MERGED', 'REJECTED']).optional().describe('Defaults to OPEN'),
+      },
+    },
+    async ({ target, status }) => {
+      try {
+        const client = makeClient();
+        const id = requireResolved(await resolveTarget(client, target));
+        return jsonResult(await client.listDocumentCommits(id, status ?? 'OPEN'));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_merge_document_commit',
+    {
+      title: 'Merge a change proposal',
+      description:
+        'Apply one change proposal to the document. It is a three-way MERGE, not an overwrite: only the proposer\'s ' +
+        'edits land on top of the current text, so anything the owner changed meanwhile survives. If both sides ' +
+        'touched the same lines the call is refused with the conflict count — read it, then call again with ' +
+        'force: true to take the proposal for those lines. Owner-level action (MANAGE).',
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      inputSchema: {
+        target: z.string().describe('Document path (starting with "/") or node id, or a full rootr.io URL'),
+        commitId: z.string().describe('Proposal id from rootr_list_document_commits'),
+        force: z.boolean().optional().describe('Merge even though the same lines clash (proposal wins there)'),
+      },
+    },
+    async ({ target, commitId, force }) => {
       try {
         const client = makeClient();
         const id = requireResolved(await resolveTarget(client, target));
-        return jsonResult(await client.setDocumentPublic(id, { isPublic, allowCommits, expiresAt, skin, layout }));
+        return jsonResult(await client.mergeDocumentCommit(id, commitId, force === true));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_reject_document_commit',
+    {
+      title: 'Reject a change proposal',
+      description:
+        'Turn down one change proposal. The reason (if given) is delivered to whoever proposed it — a rejection ' +
+        'with no explanation reads as being ignored. Owner-level action (MANAGE).',
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      inputSchema: {
+        target: z.string().describe('Document path (starting with "/") or node id, or a full rootr.io URL'),
+        commitId: z.string().describe('Proposal id from rootr_list_document_commits'),
+        reason: z.string().optional().describe('Sent to the proposer'),
+      },
+    },
+    async ({ target, commitId, reason }) => {
+      try {
+        const client = makeClient();
+        const id = requireResolved(await resolveTarget(client, target));
+        return jsonResult(await client.rejectDocumentCommit(id, commitId, reason));
       } catch (err) {
         return errorResult(err);
       }
@@ -421,4 +532,120 @@ export function registerDocumentTools(server) {
       }
     },
   );
+
+  // ── 공개범위·권한 (VIS-001) ─────────────────────────────────────────
+  // 화면에만 있던 "공개범위"/"권한" 창을 에이전트에게도 연다. 이게 없으면
+  // 에이전트가 문서는 만들면서 "서로 못 보게"는 사람이 따로 해야 한다.
+
+  server.registerTool(
+    'rootr_read_node_access',
+    {
+      title: "Read a node's visibility and who can access it",
+      description:
+        "Read a Rootr (루터) node's access settings: its explicit `visibility` (PUBLIC/PRIVATE/null=inherit), the " +
+        'effective value it resolves to, where an inherited value comes from, plus the permission overrides set ' +
+        'directly on it and on its ancestor folders. Requires MANAGE on the node — a caller who cannot change ' +
+        'access cannot read this either. Call before rootr_set_node_visibility / rootr_grant_node_permission.',
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      inputSchema: {
+        target: z.string().describe(`Node path (starting with "/") or node id${NODE_TARGET_HINT}`),
+      },
+    },
+    async ({ target }) => {
+      try {
+        const client = makeClient();
+        const id = requireResolved(await resolveTarget(client, target));
+        return jsonResult(await client.getNodeAccess(id));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_set_node_visibility',
+    {
+      title: "Set a node's visibility (private / inherit)",
+      description:
+        "Set a Rootr (루터) node's explicit visibility. PRIVATE hides the node and everything under it from " +
+        "workspace members' role-default access — only the creator, workspace OWNER/ADMIN, and people granted an " +
+        'explicit permission keep it. PUBLIC opens it to the workspace. Pass `visibility: null` to clear the ' +
+        'explicit value and inherit from the nearest ancestor folder / workspace default. Existing permission ' +
+        'overrides survive, so you cannot lock yourself out. This is the API behind the "공개범위" menu, and it is ' +
+        'NOT the same as publishing to the web (that is rootr_set_document_public).',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        target: z.string().describe(`Node path (starting with "/") or node id${NODE_TARGET_HINT}`),
+        visibility: z
+          .enum(['PUBLIC', 'PRIVATE'])
+          .nullable()
+          .describe('PRIVATE = restrict to the creator/admins/explicit grants, PUBLIC = open to the workspace, null = inherit'),
+      },
+    },
+    async ({ target, visibility }) => {
+      try {
+        const client = makeClient();
+        const id = requireResolved(await resolveTarget(client, target));
+        return jsonResult(await client.setNodeVisibility(id, visibility ?? null));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_grant_node_permission',
+    {
+      title: 'Give one person or group access to a node',
+      description:
+        'Grant a workspace member (or group) an explicit permission on a Rootr (루터) node and everything under ' +
+        'it: READ (open it), WRITE (edit it), or MANAGE (also change its sharing/permissions). Use this together ' +
+        'with rootr_set_node_visibility to build "private folder, these three people" — set the folder PRIVATE, ' +
+        'then grant each person. Re-granting the same subject just changes their level. The subject must already ' +
+        'be a member of this workspace.',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        target: z.string().describe(`Node path (starting with "/") or node id${NODE_TARGET_HINT}`),
+        subjectId: z.string().describe('User id (or group id when subjectType is GROUP)'),
+        level: z.enum(['READ', 'WRITE', 'MANAGE']).describe('Access level to grant'),
+        subjectType: z.enum(['USER', 'GROUP']).optional().describe('Defaults to USER'),
+      },
+    },
+    async ({ target, subjectId, level, subjectType }) => {
+      try {
+        const client = makeClient();
+        const id = requireResolved(await resolveTarget(client, target));
+        return jsonResult(await client.grantNodePermission(id, { subjectType, subjectId, level }));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_revoke_node_permission',
+    {
+      title: 'Take away one person or group\'s access to a node',
+      description:
+        'Remove an explicit permission override from a Rootr (루터) node. The subject falls back to whatever they ' +
+        'would get anyway — which on a PRIVATE node is no access, and on an inherited/PUBLIC node is their normal ' +
+        'workspace role. Call rootr_read_node_access first to see which overrides exist.',
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      inputSchema: {
+        target: z.string().describe(`Node path (starting with "/") or node id${NODE_TARGET_HINT}`),
+        subjectId: z.string().describe('User id (or group id when subjectType is GROUP)'),
+        subjectType: z.enum(['USER', 'GROUP']).optional().describe('Defaults to USER'),
+      },
+    },
+    async ({ target, subjectId, subjectType }) => {
+      try {
+        const client = makeClient();
+        const id = requireResolved(await resolveTarget(client, target));
+        await client.revokeNodePermission(id, { subjectType, subjectId });
+        return jsonResult({ revoked: true, nodeId: id, subjectId });
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
 }