rootr-cli 0.18.0 → 0.20.0

package/lib/mcp-tools/attachments.js

@@ -2,33 +2,73 @@ import { readFileSync } from 'node:fs';
 
 import { z } from 'zod';
 
-import { jsonResult, errorResult, makeClient, requireWorkspace, resolveOptionalNodeId, NODE_TARGET_HINT } from './shared.js';
+import {
+  jsonResult,
+  errorResult,
+  makeClient,
+  requireWorkspace,
+  resolveOptionalNodeId,
+  NODE_TARGET_HINT,
+  assertLocalFilesAllowed,
+  isHostedMcp,
+  localFileArg,
+} from './shared.js';
 import { resolveTarget, requireResolved } from '../resolve.js';
-import { RootrApiError } from '../client.js';
+import { RootrApiError, imageMarkdown } from '../client.js';
+
+// ISSUE-222 — 원격 커넥터에서 filePath 를 쓰려다 막힌 호출자가 막다른 길에 서지 않게, 거절하면서
+// 새 길(주소를 받아 직접 올리기)을 같이 알려 준다. 큰 파일은 base64Data 로도 못 싣는다.
+const PRESIGN_HINT =
+  '큰 파일은 rootr_create_upload_url 로 올리기 주소를 받아 파일 바이트를 그 주소에 직접 PUT 한 뒤 ' +
+  'rootr_complete_upload 를 부르세요 (파일 내용이 도구 호출에 실리지 않습니다).';
 
 /** Reads file bytes from a local path or a base64 string; exactly one must be given. */
 function readAttachmentBytes({ filePath, base64Data }) {
+  // SEC-MCP-FILES — 원격 커넥터에서는 서버 파일을 읽게 되므로 읽기 전에 거절한다.
+  if (isHostedMcp() && filePath) {
+    throw new RootrApiError('원격 커넥터에서는 filePath 를 쓸 수 없습니다.', {
+      hint:
+        'filePath 는 MCP 서버가 도는 기계의 파일을 가리킵니다. 원격 커넥터에서는 그 기계가 Rootr 서버라 ' +
+        `쓸 수 없습니다 — 작은 파일은 내용을 base64Data 로 보내세요. ${PRESIGN_HINT}`,
+    });
+  }
+  assertLocalFilesAllowed(filePath); // 위에서 걸렀지만 두 겹으로 둔다
   if (filePath) return readFileSync(filePath);
   if (base64Data) return Buffer.from(base64Data, 'base64');
+  if (isHostedMcp()) {
+    throw new RootrApiError('base64Data 가 필요합니다 (원격 커넥터에서는 filePath 를 쓸 수 없습니다).', {
+      hint: PRESIGN_HINT,
+    });
+  }
   throw new RootrApiError('filePath 또는 base64Data 중 하나가 필요합니다.');
 }
 
-const uploadInputSchema = {
+/** 첨부 id 모양(UUID). 주소 칸에 들어가는 값이라 다른 모양은 서버에 보내지 않는다. */
+const ATTACHMENT_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+/** 빈 값·공백뿐인 값은 받지 않는다(값 자체는 건드리지 않는다 — 앞뒤 공백도 이름의 일부일 수 있다). */
+const nonBlank = (what) => [(v) => typeof v === 'string' && v.trim().length > 0, `${what} must not be empty`];
+
+// 등록 시점(원격이면 요청마다)에 만든다 — 원격 커넥터에서는 filePath 칸이 스키마에서 빠진다.
+const buildUploadInputSchema = () => ({
   filename: z.string().describe('File name to store, e.g. "screenshot.png"'),
   mimeType: z.string().describe('MIME type, e.g. "image/png"'),
-  filePath: z
-    .string()
-    .optional()
-    .describe('Local filesystem path to the file to upload (the MCP server reads this itself, e.g. "/tmp/screenshot.png")'),
+  ...localFileArg(
+    z
+      .string()
+      .optional()
+      .describe('Local filesystem path to the file to upload (the MCP server reads this itself, e.g. "/tmp/screenshot.png")'),
+  ),
   base64Data: z
     .string()
     .optional()
     .describe('Base64-encoded file bytes; use this when the caller has the file in memory instead of on disk'),
   nodeId: z.string().optional().describe(`Document/node id${NODE_TARGET_HINT} to associate the attachment with (permission-checked)`),
   workspace: z.string().optional().describe('Workspace id; defaults to ROOTR_WORKSPACE/config'),
-};
+});
 
 export function registerAttachmentTools(server) {
+  const uploadInputSchema = buildUploadInputSchema();
   server.registerTool(
     'rootr_upload_attachment',
     {
@@ -40,14 +80,19 @@ export function registerAttachmentTools(server) {
         '{ id, url, markdown, filename, mimeType, size } — `url` is the public, unauthenticated ' +
         '/attachments/{id}/raw link (renders in <img> tags and on published /p/ documents without login), and ' +
         '`markdown` is ready to paste into a document body (![alt](url)). For the common case of inserting an ' +
-        'image straight into a document, prefer rootr_attach_image_to_document instead.',
+        'image straight into a document, prefer rootr_attach_image_to_document instead. For a large file (or ' +
+        'over the remote connector, where filePath is not available), use rootr_create_upload_url → PUT → ' +
+        'rootr_complete_upload instead of inlining the bytes as base64Data.',
       annotations: { readOnlyHint: false, destructiveHint: false },
       inputSchema: uploadInputSchema,
     },
     async ({ filename, mimeType, filePath, base64Data, nodeId, workspace }) => {
       try {
-        const client = makeClient();
+        // ISSUE-61 — workspace 를 먼저 정하고 그 워크스페이스의 키로 클라이언트를 만든다. 인자 없이
+        // makeClient() 를 부르면 기본 키가 골라져, 키를 워크스페이스별로 둔 구성에서 403 이 났다.
+        // (원격 커넥터는 makeClient 가 연결된 워크스페이스와 다른 값을 거절한다.)
         const ws = requireWorkspace(workspace);
+        const client = makeClient(ws);
         nodeId = await resolveOptionalNodeId(client, nodeId);
         const data = readAttachmentBytes({ filePath, base64Data });
         const { id } = await client.uploadAttachment(ws, { filename, mimeType, nodeId, data });
@@ -55,7 +100,7 @@ export function registerAttachmentTools(server) {
         return jsonResult({
           id,
           url,
-          markdown: `![${filename}](${url})`,
+          markdown: imageMarkdown(filename, url),
           filename,
           mimeType,
           size: data.length,
@@ -81,7 +126,7 @@ export function registerAttachmentTools(server) {
         target: z.string().describe('Document path (starting with "/") or node id to insert the image into'),
         filename: uploadInputSchema.filename,
         mimeType: uploadInputSchema.mimeType,
-        filePath: uploadInputSchema.filePath,
+        ...(uploadInputSchema.filePath ? { filePath: uploadInputSchema.filePath } : {}),
         base64Data: uploadInputSchema.base64Data,
         alt: z.string().optional().describe('Alt text / caption for the image (defaults to filename)'),
         underHeading: z
@@ -93,14 +138,14 @@ export function registerAttachmentTools(server) {
     },
     async ({ target, filename, mimeType, filePath, base64Data, alt, underHeading, workspace }) => {
       try {
-        const client = makeClient();
-        const ws = requireWorkspace(workspace);
+        const ws = requireWorkspace(workspace); // ISSUE-61 — 위와 같다: 워크스페이스 → 그 키
+        const client = makeClient(ws);
         const resolved = await resolveTarget(client, target);
         const nodeId = requireResolved(resolved);
         const data = readAttachmentBytes({ filePath, base64Data });
         const { id } = await client.uploadAttachment(ws, { filename, mimeType, nodeId, data });
         const url = client.attachmentRawUrl(id);
-        const markdown = `![${alt || filename}](${url})`;
+        const markdown = imageMarkdown(alt || filename, url);
         const result = await client.appendDocument(nodeId, { content: markdown, underHeading });
         return jsonResult({ id, url, markdown, appended: true, etag: result.etag });
       } catch (err) {
@@ -108,4 +153,97 @@ export function registerAttachmentTools(server) {
       }
     },
   );
+
+  // ISSUE-222 — rootr_upload_attachment/rootr_attach_image_to_document require
+  // the full file as base64Data over the remote connector (it can't read
+  // filePath), which breaks down for larger images. This gives the caller a
+  // short-lived presigned S3 URL instead: PUT the bytes there directly (works
+  // from anywhere with local disk access, no MCP message-size cost), then call
+  // rootr_complete_upload with the returned id.
+  server.registerTool(
+    'rootr_create_upload_url',
+    {
+      title: 'Get a presigned URL to upload a file/image as a Rootr attachment',
+      description:
+        'Get a short-lived presigned URL for uploading a file (screenshot, photo, diagram export, ...) to the ' +
+        'Rootr (루터) workspace as an attachment. PUT the raw file bytes to `uploadUrl` yourself (Content-Type ' +
+        'must match the `mimeType` you gave here) — this is the preferred path for larger files, since no file ' +
+        'bytes travel through this tool call. After the PUT succeeds, call rootr_complete_upload with the ' +
+        'returned `id` to mark the attachment ready and get its `url`/`markdown`.',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        filename: z.string().refine(...nonBlank('filename')).describe('File name to store, e.g. "diagram.png"'),
+        mimeType: z.string().refine(...nonBlank('mimeType')).describe('MIME type, e.g. "image/png"'),
+        size: z
+          .number()
+          .int()
+          .positive()
+          .describe('File size in bytes (max 75MB). The stored size is whatever you actually PUT to uploadUrl.'),
+        nodeId: z.string().optional().describe(`Document/node id${NODE_TARGET_HINT} to associate the attachment with (permission-checked)`),
+        workspace: z.string().optional().describe('Workspace id; defaults to ROOTR_WORKSPACE/config'),
+      },
+    },
+    async ({ filename, mimeType, size, nodeId, workspace }) => {
+      try {
+        const ws = requireWorkspace(workspace);
+        const client = makeClient(ws);
+        nodeId = await resolveOptionalNodeId(client, nodeId);
+        const { id, uploadUrl, expiresIn } = await client.presignAttachment(ws, { filename, mimeType, size, nodeId });
+        return jsonResult({
+          id,
+          uploadUrl,
+          expiresIn,
+          instructions: `PUT the raw file bytes to uploadUrl with header Content-Type: ${mimeType}, then call rootr_complete_upload with id "${id}".`,
+        });
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_complete_upload',
+    {
+      title: 'Finish a presigned attachment upload',
+      description:
+        'Call this after PUTting file bytes to the `uploadUrl` from rootr_create_upload_url. Verifies the ' +
+        'upload landed in storage and marks the attachment READY. Returns { id, url, markdown } — `url` is the ' +
+        'public /attachments/{id}/raw link and `markdown` is ready to paste into a document body.',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        // id 는 주소의 한 칸으로 들어간다. `../workspaces` 같은 값은 인코딩해 보내도 운영의 프록시가
+        // 풀어서 다른 길(/v1/workspaces/complete)로 보내고, 호출한 쪽은 "Cannot POST …" 라는 날것의
+        // 라우팅 오류를 받는다(운영 실측 2026-10-09). 받은 id 모양이 아니면 보내기 전에 거절한다.
+        id: z
+          .string()
+          .refine(...nonBlank('id'))
+          .refine(
+            (v) => typeof v !== 'string' || v.trim().length === 0 || ATTACHMENT_ID.test(v),
+            'id must be the attachment id returned by rootr_create_upload_url (a UUID) — not a path, URL or filename',
+          )
+          .describe('The attachment id returned by rootr_create_upload_url'),
+        filename: z.string().optional().describe('Filename to use in the markdown alt text (defaults to the one given at presign time)'),
+        workspace: z.string().optional().describe('Workspace id; defaults to ROOTR_WORKSPACE/config'),
+      },
+    },
+    async ({ id, filename, workspace }) => {
+      try {
+        const ws = requireWorkspace(workspace);
+        const client = makeClient(ws);
+        const attachment = await client.completeAttachment(id);
+        const url = client.attachmentRawUrl(id);
+        const name = filename || attachment.filename;
+        return jsonResult({
+          id,
+          url,
+          markdown: imageMarkdown(name, url),
+          filename: name,
+          mimeType: attachment.mimeType,
+          size: attachment.size,
+        });
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
 }

package/lib/mcp-tools/booking.js

@@ -0,0 +1,403 @@
+import { z } from 'zod';
+
+import { jsonResult, errorResult, makeClient, resolveNodeId, NODE_TARGET_HINT } from './shared.js';
+
+/**
+ * BOOKING — 공개한 표를 **예약 페이지**로 쓰는 도구들(창업자 지시 2026-09-23).
+ *
+ * 화면에서 하던 것을 에이전트도 그대로 할 수 있어야 한다는 요구다. 그래서 여기에는
+ * 켜기·규칙·확정 방식·물어볼 칸·구글 캘린더 고르기, 그리고 **방문자가 보는 빈 시간**까지
+ * 다 있다 — 마지막 것이 없으면 에이전트는 자기가 건 규칙이 실제로 어떻게 보이는지 모른 채
+ * "설정했습니다"라고만 말하게 된다.
+ *
+ * 구글 연결(동의)은 여기에 없다. 구글이 **브라우저에서 사람 손으로 한 번** 허용받기를
+ * 요구하기 때문이다. 대신 `rootr_connect_google_calendar` 가 그 주소를 만들어 주고,
+ * 허용한 뒤로는 목록 보기·고르기가 전부 도구로 된다.
+ */
+
+const WEEKDAY_HINT =
+  '0=Sunday … 6=Saturday. Weekdays only is [1,2,3,4,5].';
+
+const ASK_FIELD = z.object({
+  propId: z
+    .string()
+    .describe('Column id, or the column NAME as shown in the table (names are resolved for you).'),
+  required: z.boolean().optional().describe('Must the visitor fill this in? Default false.'),
+});
+
+/**
+ * 열어 둔 시간 중 **못 잡게 막는 구간**. 하루를 통째로 쉬는 것은 blockedDates 로 두고,
+ * 여기는 "매일 점심", "매주 월요일 오전", "10월 5일 오후만" 같은 시간 구간을 다룬다.
+ */
+const BLOCK = z.object({
+  kind: z
+    .enum(['date', 'daily', 'weekly'])
+    .describe('date = that one day · daily = every day · weekly = every week on that weekday.'),
+  date: z.string().optional().describe('kind="date": the day, "YYYY-MM-DD".'),
+  weekday: z.number().optional().describe(`kind="weekly": which day. ${WEEKDAY_HINT}`),
+  start: z.string().optional().describe('"HH:mm". Leave out to block from the start of the day.'),
+  end: z.string().optional().describe('"HH:mm". Leave out to block until the end of the day.'),
+  label: z
+    .string()
+    .optional()
+    .describe('Your own note (e.g. "lunch"). Only the owner sees it — visitors never do.'),
+});
+
+const GOOGLE_SCHEMA = z.object({
+  connectionId: z
+    .string()
+    .describe('Connection id from rootr_list_google_calendars. The connection belongs to ONE person.'),
+  busyCalendarIds: z
+    .array(z.string())
+    .optional()
+    .describe('Calendars whose busy times block bookings. Only free/busy is read — never event titles.'),
+  writeCalendarId: z
+    .string()
+    .nullable()
+    .optional()
+    .describe('Calendar that receives confirmed bookings. null = do not write anything to Google.'),
+  meet: z
+    .boolean()
+    .optional()
+    .describe(
+      'Also create a Google Meet room on each booking. Needs writeCalendarId. No extra permission is needed. ' +
+        'Rootr puts the link in a "회의 링크" column (created for you) and in both confirmation emails.',
+    ),
+});
+
+export function registerBookingTools(server) {
+  server.registerTool(
+    'rootr_get_booking',
+    {
+      title: 'Read a table\'s visitor-booking settings',
+      description:
+        'Read the visitor booking (scheduling) setup of a Rootr (루터) DATABASE: whether it is on, the rules ' +
+        '(days, hours, slot length, gap, notice, how far ahead, per-day cap, days off, blocked times, timezone), whether bookings ' +
+        'are confirmed instantly or after approval, who gets notified by email, whether a Google Meet room is created, ' +
+        'which columns visitors are asked for, and which Google Calendar ' +
+        'account/calendars are wired up. Also reports whether the table is published (booking only works on a ' +
+        'published table) and whether any booking failed to reach Google. Use this before changing anything.',
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      inputSchema: {
+        target: z.string().describe(`DATABASE node id${NODE_TARGET_HINT}`),
+      },
+    },
+    async ({ target }) => {
+      try {
+        const client = makeClient();
+        const id = await resolveNodeId(client, target);
+        return jsonResult(await client.getBooking(id));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_set_booking',
+    {
+      title: 'Turn on / configure visitor booking on a table',
+      description:
+        'Turn a published Rootr (루터) DATABASE into a booking page and set its rules. Visitors open the public ' +
+        'link, pick a date, pick an open time, and their booking lands as ONE ROW in the table. ' +
+        'ONLY the fields you pass change; everything else is left alone. ' +
+        'The table must be published first (rootr_publish_node) — otherwise this returns an error saying so. ' +
+        'Columns you do not have are CREATED for you: a date column, an email column, and (for approval mode) a ' +
+        'status column with 승인 대기/확정/거절. ' +
+        'Visitors never see other people\'s bookings: rows are stripped from the public payload and cloning is ' +
+        'blocked while booking is on. Two people clicking the same slot: only one gets it. ' +
+        'Google Calendar is OPTIONAL — pass `google` only after rootr_list_google_calendars shows a connection ' +
+        '(picking a connection requires a human account, not a bare API key).',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        target: z.string().describe(`DATABASE node id${NODE_TARGET_HINT}`),
+        enabled: z.boolean().optional().describe('Turn visitor booking on or off.'),
+        weekdays: z.array(z.number()).optional().describe(`Days that accept bookings. ${WEEKDAY_HINT}`),
+        startTime: z.string().optional().describe('First bookable time, "HH:mm" (e.g. "10:00"). Owner timezone.'),
+        endTime: z.string().optional().describe('Last bookable time ends by this, "HH:mm" (e.g. "18:00").'),
+        durationMin: z
+          .number()
+          .optional()
+          .describe('Length of one booking in minutes: 15, 20, 30, 45, 60, 90, 120, 180 or 240.'),
+        bufferMin: z.number().optional().describe('Gap kept before AND after each booking, in minutes.'),
+        minNoticeHours: z.number().optional().describe('No bookings closer than this many hours from now.'),
+        maxDaysAhead: z.number().optional().describe('How far ahead visitors may book, in days.'),
+        maxPerDay: z.number().optional().describe('Max bookings per day. 0 = unlimited.'),
+        blockedDates: z
+          .array(z.string())
+          .optional()
+          .describe('Days off, "YYYY-MM-DD". A date-only entry already in the table also blocks that day.'),
+        blockedTimes: z
+          .array(BLOCK)
+          .optional()
+          .describe(
+            'Times that stay closed inside the open hours. Replaces the whole list — send every rule you want kept. ' +
+              'Leave out both times to block the whole day: {"kind":"weekly","weekday":5} closes every Friday. ' +
+              'Examples: one afternoon {"kind":"date","date":"2026-10-05","start":"13:00","end":"15:00"}; ' +
+              'lunch every day {"kind":"daily","start":"12:00","end":"13:00"}; ' +
+              'Monday mornings {"kind":"weekly","weekday":1,"start":"09:00","end":"11:00"}.',
+          ),
+        timezone: z.string().optional().describe('IANA timezone the rules and the visitor page use (e.g. "Asia/Seoul").'),
+        approval: z
+          .enum(['instant', 'manual'])
+          .optional()
+          .describe(
+            'instant = confirmed the moment the visitor books (and written to Google right away). ' +
+              'manual = arrives as "승인 대기"; it still HOLDS the slot, and you confirm or decline in the table.',
+          ),
+        notice: z.string().optional().describe('Short note shown at the top of the visitor page.'),
+        askFields: z
+          .array(ASK_FIELD)
+          .optional()
+          .describe(
+            'Extra columns to ask the visitor for. Name and email are ALWAYS asked, so do not list them. ' +
+              'Only text/number/select/multi_select/checkbox/url/email/phone columns can be asked.',
+          ),
+        google: GOOGLE_SCHEMA.optional().describe('Google Calendar wiring. Omit to leave it untouched.'),
+        notifyVisitor: z
+          .boolean()
+          .optional()
+          .describe('Email the visitor when their booking is confirmed, still pending, or declined. On by default.'),
+        allowVisitorCancel: z
+          .boolean()
+          .optional()
+          .describe(
+            'Put a cancel link in the visitor\'s email so they can cancel without an account. ' +
+              'The link is a secret only that one booking\'s email carries. On by default; turning it off also ' +
+              'refuses links already sent.',
+          ),
+        types: z
+          .array(
+            z.object({
+              id: z.string().optional().describe('Short label used in the ?type= link. Derived from the name when omitted.'),
+              name: z.string(),
+              durationMin: z.number().int(),
+              description: z.string().optional(),
+            }),
+          )
+          .optional()
+          .describe(
+            'Several kinds of appointment at ONE address, e.g. a 15-minute call and a 60-minute demo. ' +
+              'Replaces the whole list; send [] for a single kind using durationMin. The visitor picks one before ' +
+              'the calendar appears, and ?type=<id> links straight to one. All kinds share the same busy time, ' +
+              'which is why this beats making one table per kind. A column records which kind was booked.',
+          ),
+        hosts: z
+          .array(
+            z.object({
+              id: z.string().optional(),
+              name: z.string(),
+              email: z.string(),
+              google: GOOGLE_SCHEMA.optional().nullable().describe("That host's own Google Calendar wiring, so their busy time blocks their slots."),
+            }),
+          )
+          .optional()
+          .describe(
+            'The people who take these appointments. Replaces the whole list; send [] to drop the idea of hosts. ' +
+              'A column records who got each booking, and each host is emailed their own bookings.',
+          ),
+        assign: z
+          .enum(['none', 'roundRobin', 'collective'])
+          .optional()
+          .describe(
+            'How the hosts are used. roundRobin: ONE host takes it — a slot is open when ANY host is free, and the ' +
+              'booking goes to whoever has taken the fewest so far. collective: EVERYONE joins — a slot is open only ' +
+              'when ALL hosts are free. none (default): no hosts. Ignored unless `hosts` is non-empty.',
+          ),
+        allowGuests: z
+          .boolean()
+          .optional()
+          .describe('Let the visitor add other email addresses. Guests get the same emails and the same calendar invite.'),
+        maxGuests: z.number().int().optional().describe('How many guests a visitor may add (default 5). 0 turns it off.'),
+        redirectUrl: z
+          .string()
+          .optional()
+          .describe(
+            'Where to send the visitor after they book — your own thank-you page. http/https only; anything else is ' +
+              'dropped. Empty keeps them on the Rootr confirmation screen.',
+          ),
+        allowVisitorReschedule: z
+          .boolean()
+          .optional()
+          .describe(
+            'Let the visitor move their booking to another time from the same emailed link, without an account. ' +
+              'One locked check picks the new slot, so there is no gap where someone else can take it. On by default.',
+          ),
+        reminders: z
+          .array(z.number().int())
+          .optional()
+          .describe(
+            'Minutes before the meeting to email both sides a reminder, e.g. [1440, 60] for a day and an hour before. ' +
+              'Up to 4 values; [] stops reminders. Defaults to [1440]. Only confirmed bookings are reminded, and a ' +
+              'reminder whose moment already passed when the booking was made is skipped instead of firing at once.',
+          ),
+        notifyEmails: z
+          .array(z.string())
+          .optional()
+          .describe(
+            'Who on the owner side gets an email for each new booking. Replaces the whole list; send [] to stop. ' +
+              'Defaults to the account that first set booking up.',
+          ),
+      },
+    },
+    async ({ target, askFields, ...rest }) => {
+      try {
+        const client = makeClient();
+        const id = await resolveNodeId(client, target);
+        const body = { ...rest };
+        if (askFields) {
+          // 칸 이름으로 골라도 받는다 — 사람도 에이전트도 칸 id 를 외우고 있지 않다.
+          const db = await client.getDatabase(id);
+          const props = db.properties || [];
+          const ids = new Set(props.map((p) => p.id));
+          const byName = new Map(props.map((p) => [p.name, p.id]));
+          body.askFields = askFields.map((a) => {
+            if (ids.has(a.propId)) return a;
+            const found = byName.get(a.propId);
+            if (!found) {
+              throw new Error(
+                `No column "${a.propId}" in this table. Columns: ${props.map((p) => p.name).join(', ')}`,
+              );
+            }
+            return { ...a, propId: found };
+          });
+        }
+        return jsonResult(await client.setBooking(id, body));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_booking_slots',
+    {
+      title: 'See the open times visitors see',
+      description:
+        'List the times a visitor could actually book on a Rootr (루터) booking page, day by day. This is the ' +
+        'SAME calculation the public page and the server use, so it is the way to check that the rules you set ' +
+        'do what you meant — including which days are closed and which times the owner\'s Google Calendar blocks. ' +
+        'Days with nothing open are omitted entirely. If Google Calendar is wired up but unreachable, this errors ' +
+        'rather than showing times that might already be taken.',
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      inputSchema: {
+        target: z.string().describe(`DATABASE node id${NODE_TARGET_HINT}`),
+        from: z.string().optional().describe('First day to look at, "YYYY-MM-DD". Defaults to today.'),
+        to: z.string().optional().describe('Last day, "YYYY-MM-DD". At most 62 days after `from`.'),
+        type: z
+          .string()
+          .optional()
+          .describe(
+            'Which kind of appointment to look at, when the page takes several (the `id` from `types`). Each kind ' +
+              'has its own length, so the open times differ. Omitted or unknown falls back to the first kind.',
+          ),
+      },
+    },
+    async ({ target, from, to, type }) => {
+      try {
+        const client = makeClient();
+        const id = await resolveNodeId(client, target);
+        const status = await client.nodePublicStatus(id);
+        if (!status.slug) {
+          throw new Error('This table is not published yet — publish it first (rootr_publish_node).');
+        }
+        const today = new Date(Date.now() + 9 * 3600e3).toISOString().slice(0, 10);
+        const start = from || today;
+        const end = to || new Date(Date.parse(`${start}T00:00:00Z`) + 30 * 864e5).toISOString().slice(0, 10);
+        return jsonResult(await client.bookingSlots(status.slug, { from: start, to: end, type }));
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_list_google_calendars',
+    {
+      title: 'List connected Google accounts and their calendars',
+      description:
+        'List the Google accounts this PERSON has connected to Rootr (루터) for booking, and — when you pass a ' +
+        'connectionId — the calendars on that account with whether each one can be written to. ' +
+        'Use the ids from here in rootr_set_booking `google`. ' +
+        'A Google connection belongs to one person, so this needs a human account: a bare API key (legacy or the ' +
+        'hosted MCP connector) gets a clear error instead of an empty list. If `available` is false, the server ' +
+        'itself has no Google setup yet and booking simply runs without Google.',
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      inputSchema: {
+        connectionId: z
+          .string()
+          .optional()
+          .describe('Also list the calendars on this connection. Omit to just list the connected accounts.'),
+      },
+    },
+    async ({ connectionId }) => {
+      try {
+        const client = makeClient();
+        const connections = await client.googleCalendarConnections();
+        if (!connectionId) return jsonResult(connections);
+        const calendars = await client.googleCalendars(connectionId);
+        return jsonResult({ ...connections, ...calendars });
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_connect_google_calendar',
+    {
+      title: 'Start connecting a Google Calendar account',
+      description:
+        'Get the Google consent URL to connect a Google Calendar account for booking. ' +
+        'You cannot finish this for the user: Google requires a PERSON to open that URL in a browser and approve ' +
+        'the calendar permissions once. Hand them the URL and say so. After they approve, everything else ' +
+        '(listing calendars, wiring them to a table) works through the tools. ' +
+        'Rootr asks only for: the list of their calendars, free/busy times, and permission to manage the events it ' +
+        'creates — never the contents of their existing events. Needs a human account, not a bare API key.',
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      inputSchema: {
+        returnTo: z
+          .string()
+          .optional()
+          .describe('In-app path to come back to after approving, e.g. "/ko". Must start with "/".'),
+      },
+    },
+    async ({ returnTo }) => {
+      try {
+        const client = makeClient();
+        const res = await client.googleCalendarAuthorizeUrl(returnTo || '/');
+        return jsonResult({
+          ...res,
+          next: 'Ask the person to open `url` in a browser and approve. Then call rootr_list_google_calendars.',
+        });
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+
+  server.registerTool(
+    'rootr_disconnect_google_calendar',
+    {
+      title: 'Disconnect a Google Calendar account',
+      description:
+        'Disconnect a Google Calendar account from Rootr (루터) and revoke Rootr\'s access on Google\'s side. ' +
+        'Tables using that connection stop blocking busy times and stop writing new bookings to Google; bookings ' +
+        'already written stay in the calendar. Ask the person before doing this — it affects every table wired to ' +
+        'that account.',
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      inputSchema: {
+        connectionId: z.string().describe('Connection id from rootr_list_google_calendars.'),
+      },
+    },
+    async ({ connectionId }) => {
+      try {
+        const client = makeClient();
+        await client.disconnectGoogleCalendar(connectionId);
+        return jsonResult({ ok: true, connectionId });
+      } catch (err) {
+        return errorResult(err);
+      }
+    },
+  );
+}