rootr-cli 0.9.0 → 0.13.0

package/lib/mcp-tools/misc.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 
-import { jsonResult, errorResult, makeClient } from './shared.js';
+import { jsonResult, errorResult, makeClient, resolveNodeId, NODE_TARGET_HINT } from './shared.js';
 import { resolveTarget, requireResolved } from '../resolve.js';
 
 /** Miscellaneous document/node tools: version history, trash. */
@@ -95,4 +95,87 @@ export function registerMiscTools(server) {
       }
     },
   );
+
+  // ── READ-ACK — 읽고 확인해야 하는 문서 ─────────────────────────────────
+  // 규정·공지처럼 "읽었다"를 남겨야 하는 것. 표·폴더에 걸면 그 안의 문서 전부에
+  // 걸리고, 얼마나 읽었는지 완료율로 본다.
+
+  server.registerTool(
+    'rootr_read_requirement',
+    {
+      title: 'Read the read-acknowledgement status',
+      description:
+        'Read the READ-ACK state of a Rootr (루터) node — who must read it, the due date, who has read or ' +
+        'acknowledged, and (for a DATABASE or FOLDER) how far through the documents inside each person is. ' +
+        'Use it to answer "누가 아직 안 읽었나" for a 규정/공지/교육자료. If the node itself has no requirement ' +
+        'but an ancestor does, `ancestorRequirementId` names the node that carries it.',
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      inputSchema: {
+        nodeId: z.string().describe(`Node id${NODE_TARGET_HINT}`),
+      },
+    },
+    async ({ nodeId }) => {
+      try {
+        const client = makeClient();
+        return jsonResult(await client.readRequirement(await resolveNodeId(client, nodeId)));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_set_read_requirement',
+    {
+      title: 'Require people to read a document',
+      description:
+        'Make a Rootr (루터) node REQUIRED READING for the given people. Put it on a DOCUMENT for one notice, ' +
+        'or on a DATABASE/FOLDER to require everything inside (완료율 rolls up per person). `dueAt` is an ISO ' +
+        'date or null for no deadline; `requireExplicitAck: true` means opening it is not enough — the person ' +
+        'must press 확인. Replaces the whole roster, so send the full `userIds` list. NOTE: this records a real ' +
+        'person as the setter, so it needs a key that acts as a user (a PAT); a workspace connector key with no ' +
+        'user attached is refused.',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        nodeId: z.string().describe(`Node id${NODE_TARGET_HINT}`),
+        userIds: z.array(z.string()).describe('Everyone who must read it (replaces the current roster)'),
+        dueAt: z.string().nullable().optional().describe('ISO date, or null for no deadline'),
+        requireExplicitAck: z
+          .boolean()
+          .optional()
+          .describe('true = opening is not enough, the person must press 확인'),
+      },
+    },
+    async ({ nodeId, userIds, dueAt, requireExplicitAck }) => {
+      try {
+        const client = makeClient();
+        const id = await resolveNodeId(client, nodeId);
+        return jsonResult(await client.setReadRequirement(id, { userIds, dueAt, requireExplicitAck }));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_clear_read_requirement',
+    {
+      title: 'Stop requiring a document to be read',
+      description:
+        'Remove the READ-ACK requirement from a Rootr (루터) node. The record of who already read it is not ' +
+        'shown any more; the node itself is untouched.',
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      inputSchema: {
+        nodeId: z.string().describe(`Node id${NODE_TARGET_HINT}`),
+      },
+    },
+    async ({ nodeId }) => {
+      try {
+        const client = makeClient();
+        return jsonResult(await client.clearReadRequirement(await resolveNodeId(client, nodeId)));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
 }

package/lib/mcp-tools/presentations.js

@@ -268,7 +268,11 @@ export function registerPresentationTools(server) {
       try {
         const client = makeClient();
         presentationId = await resolveNodeId(client, presentationId);
-        const result = await client.updatePresentationSlide(presentationId, slideId, slide);
+        // 블록 id 는 이 도구도 채워 준다 — 스키마가 "생략하면 자동 생성"이라고
+        // 적어 두고서 이 길로만 400(blocks[].id is required)을 내던 것을 고친다
+        // (2026-08-29 실측). 슬라이드 id 는 서버가 어차피 slideId 로 못 박는다.
+        const patched = ensureSlideIds([{ ...slide, id: slideId }])[0];
+        const result = await client.updatePresentationSlide(presentationId, slideId, patched);
         return jsonResult(result);
       } catch (err) {
         return errorResult(err);

package/lib/mcp-tools/public.js

@@ -0,0 +1,148 @@
+import { z } from 'zod';
+
+import { jsonResult, errorResult, makeClient, resolveNodeId, NODE_TARGET_HINT } from './shared.js';
+
+/**
+ * PUBLIC-DB-DESIGN — 공개한 표를 **표 말고 다른 꼴로도** 보여준다
+ * (창업자 지시 2026-08-28: "꼭 표 형태일 필욘 없잖아").
+ * 값 목록은 서버(`public-nodes.dto.ts`)와 **같아야** 한다.
+ */
+const DB_DESIGN_SCHEMA = z.object({
+  layout: z
+    .enum(['table', 'cards', 'gallery', 'list', 'board', 'timeline', 'calendar', 'chart', 'ranking'])
+    .optional(),
+  skin: z.enum(['clean', 'paper', 'dark', 'vivid', 'bento', 'brutal']).optional(),
+});
+
+/**
+ * PUBLIC-ANY — **어떤 타입이든 공개 발행한다**(창업자 지시 2026-08-27).
+ *
+ * 문서·덱만 되던 것을 표·시트·화이트보드·폼·이슈·로그·CRM·녹음·서명문서까지 열었다.
+ * 문서는 이 도구로 불러도 예전 발행 경로로 넘어가므로, **무엇을 공개하든 여기 하나만
+ * 쓰면 된다** — 타입마다 다른 도구를 찾을 필요가 없다.
+ */
+export function registerPublicTools(server) {
+  server.registerTool(
+    'rootr_publish_node',
+    {
+      title: 'Publish anything to a public URL',
+      description:
+        'Publish ANY Rootr (루터) node at a public read-only URL (rootr.io/p/{slug}) — a DATABASE (visitors get a ' +
+        'searchable table and can clone it into their own workspace), SPREADSHEET, WHITEBOARD, FORM (questions only), ' +
+        'ISSUE_TRACKER, LOG, CRM, RECORDING (transcript only), SIGNED or DOCUMENT. Use this instead of ' +
+        'rootr_publish_document unless you specifically want the document-only extras (skins, edit proposals). ' +
+        'FOLDER cannot be published. ' +
+        'Set `includeChildren: true` to publish everything underneath as well — the WHOLE subtree, grandchildren ' +
+        'included, each getting its own URL and listed on the parent page. Leave it off and only this one node goes ' +
+        'out (its sub-page names do not even appear). Turning it back off, closing the parent, moving a child out, ' +
+        'or deleting the parent all close the pages that went out because of it — pages the owner published on their ' +
+        'own are left alone. ' +
+        'What is deliberately NOT exposed: a table\'s person/attachment/relation columns, the documents attached to ' +
+        'its rows, form responses, recording audio, CRM contacts and deal amounts, and signer names on a signed ' +
+        'document. Rows/entries are capped at 500 per page and the page says so when it truncates. ' +
+        'Owner-level action (MANAGE): use an ACCOUNT key (PAT), not a workspace-scoped/connector token. ' +
+        'Safe to call again — the slug never changes, so links already shared stay valid.',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        target: z.string().describe(`Node id${NODE_TARGET_HINT}`),
+        includeChildren: z
+          .boolean()
+          .optional()
+          .describe('Also publish everything underneath (whole subtree). Default false.'),
+        view: z
+          .string()
+          .optional()
+          .describe('DATABASE only: which saved view the public page opens with (view id).'),
+        design: DB_DESIGN_SCHEMA.optional().describe(
+          'DATABASE only: how the public page presents the table. `layout` is one of ' +
+            'table, cards, gallery, list, board, timeline, calendar, chart, ranking; `skin` is one of ' +
+            'clean, paper, dark, vivid, bento, brutal. Only the keys you send change — setting a skin ' +
+            'leaves the layout alone. Layouts that need a column (calendar/timeline need a date, board a ' +
+            'select/status, ranking a number, chart either) fall back to the table and say why.',
+        ),
+      },
+    },
+    async ({ target, includeChildren, view, design }) => {
+      try {
+        const client = makeClient();
+        const id = await resolveNodeId(client, target);
+        return jsonResult(await client.publishNode(id, { includeChildren, view, design }));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_set_node_public',
+    {
+      title: 'Update public settings of anything published',
+      description:
+        'Partially update a published Rootr (루터) node\'s public settings — only the fields you pass change, and ' +
+        'the slug is never touched, so shared links stay valid. ' +
+        '`{"isPublic": false}` closes it (and closes whatever went out under it); ' +
+        '`{"includeChildren": false}` closes just the sub-pages; ' +
+        '`{"allowClone": false}` hides the "clone this" button AND refuses the clone API; ' +
+        '`{"password": "..."}` locks the page (the content is not sent at all until the password is entered — it is ' +
+        'not hidden in the browser), `{"password": null}` unlocks; ' +
+        '`{"expiresAt": "2026-12-31T00:00:00Z"}` auto-closes on that date, `null` clears it; ' +
+        '`{"noIndex": true}` asks search engines to stay away; ' +
+        '`{"design": {"layout": "board", "skin": "paper"}}` changes how a published TABLE looks — it does not ' +
+        'have to be a table (cards, gallery, list, board, timeline, calendar, chart, ranking). ' +
+        'For DOCUMENT nodes use rootr_set_document_public instead — documents keep their own settings (skins, ' +
+        'edit proposals) on the older path. Owner-level action (MANAGE): use an account key (PAT).',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        target: z.string().describe(`Node id${NODE_TARGET_HINT}`),
+        isPublic: z.boolean().optional(),
+        includeChildren: z.boolean().optional(),
+        allowClone: z.boolean().optional(),
+        noIndex: z.boolean().optional(),
+        expiresAt: z.string().nullable().optional().describe('ISO date, or null to clear'),
+        password: z.string().nullable().optional().describe('null or "" removes the lock'),
+        view: z.string().optional().describe('DATABASE only: view id the public page opens with'),
+        design: DB_DESIGN_SCHEMA.optional().describe(
+          'DATABASE only: how the public page presents the table. `layout` — table, cards, gallery, list, ' +
+            'board, timeline, calendar, chart, ranking. `skin` — clean, paper, dark, vivid, bento, brutal. ' +
+            'Only the keys you send change.',
+        ),
+      },
+    },
+    async ({ target, ...settings }) => {
+      try {
+        const client = makeClient();
+        const id = await resolveNodeId(client, target);
+        const body = Object.fromEntries(Object.entries(settings).filter(([, v]) => v !== undefined));
+        return jsonResult(await client.setNodePublic(id, body));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_node_public_status',
+    {
+      title: 'Is this published, and at what URL',
+      description:
+        'Check whether a Rootr (루터) node is published and how: its public slug (rootr.io/p/{slug}), whether it is ' +
+        'currently open, when it expires, whether a password is set (the password itself is never returned), whether ' +
+        'cloning is allowed, and whether the pages underneath went out with it. ' +
+        '`publishable: false` means this type cannot be published at all (FOLDER). ' +
+        'Call this before publishing so you do not tell the user a page is new when it already had a URL.',
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      inputSchema: {
+        target: z.string().describe(`Node id${NODE_TARGET_HINT}`),
+      },
+    },
+    async ({ target }) => {
+      try {
+        const client = makeClient();
+        const id = await resolveNodeId(client, target);
+        return jsonResult(await client.nodePublicStatus(id));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+}