rootr-cli 0.8.1 → 0.10.0

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);
+      }
+    },
+  );
 }

package/lib/mcp-tools/forms.js

@@ -126,13 +126,20 @@ export function registerFormTools(server) {
       annotations: { readOnlyHint: true, destructiveHint: false },
       inputSchema: {
         formId: z.string().describe(`FORM node id${NODE_TARGET_HINT}`),
+        latestPerRespondent: z
+          .boolean()
+          .optional()
+          .describe(
+            'Keep only the newest response per signed-in submitter (`submitterUserId`), dropping their earlier ' +
+              'drafts. Anonymous share-link submissions have no submitter and are never merged. Default false.',
+          ),
       },
     },
-    async ({ formId }) => {
+    async ({ formId, latestPerRespondent }) => {
       try {
         const client = makeClient();
         formId = await resolveNodeId(client, formId);
-        const result = await client.listFormResponses(formId);
+        const result = await client.listFormResponses(formId, { latestPerRespondent });
         return jsonResult({ responses: result });
       } catch (err) {
         return errorResult(err);
@@ -166,6 +173,84 @@ export function registerFormTools(server) {
     },
   );
 
+  server.registerTool(
+    'rootr_create_form_collector',
+    {
+      title: 'Create a table or spreadsheet that collects this form\'s responses',
+      description:
+        'Create a destination for a Rootr (루터) FORM\'s responses and link it in one call. ' +
+        '`target: "database"` builds a DATABASE whose columns come straight from the form\'s questions ' +
+        '(same names, matching types, select options carried over) — this is the right way to answer ' +
+        '"collect the answers in a table", because a hand-built table only mirrors when every column name ' +
+        'matches a question exactly. `target: "spreadsheet"` creates a SPREADSHEET whose sheet is bound to ' +
+        'the form, so its rows ARE the responses. Both replace any previous destination — a form collects ' +
+        'into one place. To link an already-built table instead, use rootr_update_form with targetDatabaseId.',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        formId: z.string().describe(`FORM node id${NODE_TARGET_HINT}`),
+        target: z
+          .enum(['database', 'spreadsheet'])
+          .describe('database = typed columns/views (filters, boards); spreadsheet = one sheet of rows for formulas'),
+      },
+    },
+    async ({ formId, target }) => {
+      try {
+        const client = makeClient();
+        formId = await resolveNodeId(client, formId);
+        return jsonResult(await client.createFormCollector(formId, target));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_update_form_response',
+    {
+      title: 'Fix an already-submitted Rootr form response',
+      description:
+        'Correct one response that was already submitted to a Rootr (루터) FORM. `values` REPLACES the whole ' +
+        'answer set and is re-checked against the form\'s current fields (required/type rules), so send every ' +
+        'answer you want to keep — call rootr_list_form_responses first. Use this instead of deleting and ' +
+        're-submitting when you want the original submitter and submission time preserved.',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        responseId: z.string().describe('Response id from rootr_list_form_responses'),
+        values: z.record(z.any()).describe('Full replacement answers, keyed by field id'),
+      },
+    },
+    async ({ responseId, values }) => {
+      try {
+        const result = await makeClient().updateFormResponse(responseId, values);
+        return jsonResult(result);
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_delete_form_response',
+    {
+      title: 'Delete one Rootr form response',
+      description:
+        'Permanently delete a single response submitted to a Rootr (루터) FORM. This cannot be undone — the ' +
+        'answers are gone. Use rootr_update_form_response to correct a response instead of deleting it.',
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      inputSchema: {
+        responseId: z.string().describe('Response id from rootr_list_form_responses'),
+      },
+    },
+    async ({ responseId }) => {
+      try {
+        await makeClient().deleteFormResponse(responseId);
+        return jsonResult({ deleted: true, responseId });
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
   server.registerTool(
     'rootr_create_form_share_link',
     {

package/lib/mcp-tools/misc.js

@@ -31,6 +31,46 @@ export function registerMiscTools(server) {
     },
   );
 
+  server.registerTool(
+    'rootr_update_node',
+    {
+      title: 'Rename / re-icon / move any node',
+      description:
+        'Change a Rootr (루터) node\'s NAME, ICON, TAGS, or PARENT — works for every node type ' +
+        '(DOCUMENT, FOLDER, DATABASE, SPREADSHEET, FORM, …). Until now icons could only be set when a node ' +
+        'was CREATED, so matching a migrated tree to its Notion icons was impossible without recreating ' +
+        'everything. Only the fields you pass change. `parentId: null` moves the node to the workspace root; ' +
+        'a node cannot be moved inside its own subtree.',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        target: z.string().describe('Node path (starting with "/") or node id'),
+        name: z.string().optional().describe('New name'),
+        icon: z.string().optional().describe('New emoji icon, e.g. "📋". Empty string clears it.'),
+        tags: z.array(z.string()).optional().describe('Replaces the tag list'),
+        parentId: z
+          .string()
+          .nullable()
+          .optional()
+          .describe('Move under this folder/document/database (id or path). null = workspace root.'),
+      },
+    },
+    async ({ target, name, icon, tags, parentId }) => {
+      try {
+        const client = makeClient();
+        const id = requireResolved(await resolveTarget(client, target));
+        // 부모도 경로로 줄 수 있어야 한다 — id를 미리 아는 쪽이 오히려 드물다.
+        let parent = parentId;
+        if (typeof parentId === 'string' && parentId) {
+          parent = requireResolved(await resolveTarget(client, parentId));
+        }
+        const node = await client.updateNode(id, { name, icon, tags, parentId: parent });
+        return jsonResult(node);
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
   server.registerTool(
     'rootr_delete_node',
     {