rootr-cli 0.18.0 → 0.20.0

package/lib/mcp-tools/workspaces.js

@@ -3,8 +3,27 @@ import { z } from 'zod';
 import { textResult, jsonResult, errorResult, makeClient, requireWorkspace } from './shared.js';
 import { loadConfig } from '../config.js';
 import { currentClientOverride } from '../context.js';
-import { candidateClients, rememberWorkspace, resolveWorkspaceSwitch, surveyWorkspaces } from '../credentials.js';
+import {
+  candidateClients,
+  rememberSessionKey,
+  rememberWorkspace,
+  resolveWorkspaceSwitch,
+  surveyWorkspaces,
+} from '../credentials.js';
 import { parseRootrUrl } from '../resolve.js';
+import { t as tr } from '../i18n.js';
+
+/**
+ * ISSUE-221 — the workspace this server process was pinned to at launch via the
+ * ROOTR_WORKSPACE env var ('' when it was not). Read once, before any switch
+ * rewrites process.env: a switch on an env-pinned server only lasts as long as
+ * the process does (the MCP client passes the same env again on every restart
+ * or reconnect, and env deliberately wins over the config file), so the switch
+ * reply has to say where the server will be after a restart — otherwise the
+ * next write after a reconnect lands in the pinned workspace while the agent
+ * still believes it is in the one it switched to.
+ */
+const LAUNCH_WORKSPACE = process.env.ROOTR_WORKSPACE || '';
 
 /**
  * Scaffold `tree` argument schema. Declared as an ARRAY of node objects so MCP
@@ -19,7 +38,12 @@ const ACCESS_HINT =
   '`access` can see it and everything under it) plus `access: [{ subjectId: "<userId>", level: "READ"|"WRITE"|' +
   '"MANAGE" }]` — that pair is how "make a folder these three people can see" happens in one call instead of ' +
   'leaving the locking to the user afterwards. A DATABASE node may also carry `database.permissions` (칸/행 ' +
-  'lock) and `database.notifications` (who to notify on row changes).';
+  'lock) and `database.notifications` (who to notify on row changes). A database property may carry ' +
+  '`searchExcluded: true` (values stay out of the search index behind ask / AI explore / similar rows — not a read permission) and a `type: "vector"` ' +
+  'property needs `dimensions` (an embedding column agents fill with rootr_set_row_vectors). ' +
+  'A DOCUMENT\'s `content` may embed a live ' +
+  'table/sheet/deck with a line `[[embed:<name of a node in this same tree>]]` or `[[embed:/absolute/path]]` — it is ' +
+  'linked to the real node after the whole tree is built (an unknown name rolls the whole tree back).';
 
 const treeArg = (desc) => z.array(z.record(z.any())).or(z.string()).describe(desc + ACCESS_HINT);
 
@@ -44,6 +68,8 @@ export function registerWorkspaceTools(server) {
         'reconfiguration, no restart. With an account key (PAT) you can switch to any workspace you belong ' +
         'to; if separate workspace keys are configured, the one that covers the target is selected and ' +
         'remembered automatically. Call rootr_workspaces first if you need to see what is available. ' +
+        'If the server was started with the ROOTR_WORKSPACE env var, the switch lasts until the server ' +
+        'restarts (the reply says so) — after a restart/reconnect, check rootr_workspaces again. ' +
         '(A hosted/remote connector is bound to a single workspace at consent time and cannot switch.)',
       annotations: { readOnlyHint: false, destructiveHint: false },
       inputSchema: {
@@ -73,8 +99,55 @@ export function registerWorkspaceTools(server) {
         const match = await resolveWorkspaceSwitch(workspace, cfg);
         if (match.error) return errorResult(new Error(match.error));
         rememberWorkspace(match, cfg);
+        // ISSUE-172 — rememberWorkspace() only writes ~/.rootr/config.json.
+        // loadConfig()/keyForWorkspace() both give ROOTR_WORKSPACE/ROOTR_API_KEY
+        // env vars priority over that file (deliberately — see config.js
+        // ENV-WINS comment), so on a server launched with those env vars set
+        // (the common case for MCP client configs that pass env: {...}) every
+        // later tool call kept reading the OLD workspace/key from the
+        // process's environment no matter what got written to disk. The tool
+        // still replied with a success message, so the switch looked like it
+        // worked while nothing after it actually moved. Fix: mutate this
+        // process's env too, so the very next loadConfig() call (same
+        // process, same request loop) picks up the switch immediately.
+        if (process.env.ROOTR_WORKSPACE) process.env.ROOTR_WORKSPACE = match.workspace.id;
+        if (process.env.ROOTR_API_KEY && match.candidate && match.candidate.apiKey !== process.env.ROOTR_API_KEY) {
+          // ISSUE-221 — the key being replaced may exist nowhere but in this
+          // process's environment; keep it so switching back still works.
+          rememberSessionKey(process.env.ROOTR_API_KEY);
+          process.env.ROOTR_API_KEY = match.candidate.apiKey;
+        }
+        // Verify the switch actually took before reporting success — never
+        // report a switch that didn't actually move the active workspace.
+        const after = loadConfig();
+        if (after.workspace !== match.workspace.id) {
+          return errorResult(
+            new Error(
+              `워크스페이스를 "${match.workspace.id}" 로 바꾸지 못했습니다 — 이 서버 프로세스가 ROOTR_WORKSPACE 환경변수로 ` +
+                '고정되어 있어 전환이 적용되지 않습니다.\n' +
+                '조치: MCP 서버를 실행하는 환경설정에서 ROOTR_WORKSPACE 환경변수를 제거하거나 원하는 워크스페이스 id로 바꾼 뒤 ' +
+                '서버를 재시작하세요.',
+            ),
+          );
+        }
         const name = match.workspace.name || match.workspace.slug || '';
-        return textResult(`활성 워크스페이스를 "${name}" (${match.workspace.id}) 로 바꿨습니다. 이후 도구 호출은 여기에 적용됩니다.`);
+        // ISSUE-221 — say how long the switch lasts when the server is env-pinned.
+        const pinnedNote =
+          LAUNCH_WORKSPACE && LAUNCH_WORKSPACE !== match.workspace.id
+            ? tr(
+                `\n주의: 이 MCP 서버는 ROOTR_WORKSPACE 환경변수(${LAUNCH_WORKSPACE})로 고정되어 시작됐습니다. 이 전환은 서버가 ` +
+                  `켜져 있는 동안만 유효하고, 서버가 재시작(재연결)되면 ${LAUNCH_WORKSPACE} 로 돌아갑니다 — 재시작 뒤에는 쓰기 전에 ` +
+                  'rootr_workspaces 로 현재 워크스페이스를 다시 확인하세요. 계속 이 워크스페이스를 쓰려면 MCP 서버 설정의 ' +
+                  `ROOTR_WORKSPACE 를 ${match.workspace.id} 로 바꾸거나 지우세요 (사용자가 직접).`,
+                `\nNote: this MCP server was started pinned to ROOTR_WORKSPACE=${LAUNCH_WORKSPACE}. The switch lasts only while ` +
+                  `the server keeps running; after a restart/reconnect it is back on ${LAUNCH_WORKSPACE} — check rootr_workspaces ` +
+                  'again before writing. To stay on this workspace, change (or remove) ROOTR_WORKSPACE in the MCP server ' +
+                  `config to ${match.workspace.id} (a step for the user).`,
+              )
+            : '';
+        return textResult(
+          `활성 워크스페이스를 "${name}" (${match.workspace.id}) 로 바꿨습니다. 이후 도구 호출은 여기에 적용됩니다.${pinnedNote}`,
+        );
       } catch (err) {
         return errorResult(err);
       }
@@ -190,79 +263,99 @@ export function registerWorkspaceTools(server) {
     },
   );
 
-  server.registerTool(
-    'rootr_create_workspace',
-    {
-      title: 'Create a brand-new Rootr workspace from a scaffold tree',
-      description:
-        'Create an entirely new Rootr (루터) workspace pre-populated with the given document tree. ' +
-        'REQUIRES an account key (PAT) with the workspaces:create scope — a workspace-scoped key cannot do this. ' +
-        'PRECONDITION: rootr_scaffold_plan first, ask the user its 3-10 clarifying questions, design the tree from ' +
-        'their answers, then run rootr_scaffold_review and fix everything it flags at `error` level. The ' +
-        'response carries the same `review` back, so a low score here means you shipped something thin. ' +
-        'Build a real tool, not a pile of thin markdown files: mix DATABASE (board/' +
-        'timeline views, seed rows), SPREADSHEET (formulas), FORM, ISSUE_TRACKER and rich multi-section DOCUMENTs ' +
-        'where they fit, and set an emoji `icon` on folders/databases/key documents. The `tree` shape follows ' +
-        'the scaffold schema in llms.txt (max 200 nodes). AFTER creating: if your runtime can receive HTTP ' +
-        'callbacks, offer the user to register a webhook on the new tree (rootr_create_webhook with scopeNodeId) ' +
-        'so changes flow back to you — skip your own actorId to avoid self-triggering.',
-      annotations: { readOnlyHint: false, destructiveHint: false },
-      inputSchema: {
-        name: z.string().describe('Name for the new workspace'),
-        intent: z.string().optional().describe('Original natural-language intent, for reference/regeneration'),
-        tree: treeArg('Scaffold tree — an ARRAY of node objects to populate the new workspace with (see llms.txt tree schema)'),
+  // A hosted/remote connector (ChatGPT, Claude web, etc.) is bound to exactly
+  // one workspace chosen at OAuth consent time and its token can never carry
+  // `workspaces:create` (see MCP_PERMISSION_SCOPES in mcp-oauth.service.ts —
+  // deliberately excluded there). Advertising these two tools anyway meant a
+  // hosted session always saw rootr_create_workspace/rootr_delete_workspace in
+  // tools/list but every call 403'd with "missing scope: workspaces:create" —
+  // the tool looked broken with no way to know why. Only the local stdio CLI
+  // (PAT-backed, no client override) can ever satisfy that scope, so skip
+  // registering them entirely for hosted sessions.
+  if (!currentClientOverride()) {
+    server.registerTool(
+      'rootr_create_workspace',
+      {
+        title: 'Create a brand-new Rootr workspace from a scaffold tree',
+        description:
+          'Create an entirely new Rootr (루터) workspace pre-populated with the given document tree. ' +
+          'REQUIRES an account key (PAT) with the workspaces:create scope — a workspace-scoped key cannot do this. ' +
+          'PRECONDITION: rootr_scaffold_plan first, ask the user its 3-10 clarifying questions, design the tree from ' +
+          'their answers, then run rootr_scaffold_review and fix everything it flags at `error` level. The ' +
+          'response carries the same `review` back, so a low score here means you shipped something thin. ' +
+          'Build a real tool, not a pile of thin markdown files: mix DATABASE (board/' +
+          'timeline views, seed rows), SPREADSHEET (formulas), FORM, ISSUE_TRACKER and rich multi-section DOCUMENTs ' +
+          'where they fit, and set an emoji `icon` on folders/databases/key documents. The `tree` shape follows ' +
+          'the scaffold schema in llms.txt (max 200 nodes). AFTER creating: if your runtime can receive HTTP ' +
+          'callbacks, offer the user to register a webhook on the new tree (rootr_create_webhook with scopeNodeId) ' +
+          'so changes flow back to you — skip your own actorId to avoid self-triggering.',
+        annotations: { readOnlyHint: false, destructiveHint: false },
+        inputSchema: {
+          name: z.string().describe('Name for the new workspace'),
+          intent: z.string().optional().describe('Original natural-language intent, for reference/regeneration'),
+          tree: treeArg('Scaffold tree — an ARRAY of node objects to populate the new workspace with (see llms.txt tree schema)'),
+          mode: z
+            .enum(['docs', 'minimal'])
+            .optional()
+            .describe(
+              'Lower the review bar when the system-building rules do not apply: "docs" for a document-only ' +
+                'tree with no tables at all, "minimal" for a small personal/few-person tree (e.g. a couple\'s ' +
+                'shared ledger) where relations, a how-to-use guide, forms, and rollups are overkill. Omit for ' +
+                'normal multi-table workspaces.',
+            ),
+        },
       },
-    },
-    async ({ name, intent, tree }) => {
-      try {
-        const client = makeClient();
-        const result = await client.createWorkspaceScaffold({ name, intent, tree: parseTree(tree) });
-        return jsonResult(result);
-      } catch (err) {
-        return errorResult(err);
-      }
-    },
-  );
+      async ({ name, intent, tree, mode }) => {
+        try {
+          const client = makeClient();
+          const result = await client.createWorkspaceScaffold({ name, intent, tree: parseTree(tree), mode });
+          return jsonResult(result);
+        } catch (err) {
+          return errorResult(err);
+        }
+      },
+    );
 
-  /**
-   * WS-CLEANUP — **짓다 실패해서 남은 빈 워크스페이스를 에이전트가 치울 수 있게.**
-   *
-   * 스캐폴딩이 중간에 실패하면 껍데기만 남는데 지우는 문이 없었다. 무료 한도가
-   * 5개라 몇 번 실패하면 사용자가 바로 막히고, 그 잔해를 사람이 화면에서 하나씩
-   * 지워야 했다(2026-08-30 실측: 치과 3개·아파트 4개).
-   *
-   * 이름을 그대로 다시 적게 한다 — 서버가 요구하는 안전장치이자, 모델이 엉뚱한
-   * 워크스페이스를 지목했을 때 걸리는 그물이다.
-   */
-  server.registerTool(
-    'rootr_delete_workspace',
-    {
-      title: 'Delete a workspace you created (cleanup after a failed scaffold)',
-      description:
-        'Permanently delete a Rootr (루터) workspace. Intended for cleaning up EMPTY leftovers from a scaffold ' +
-        'run that failed halfway — the free plan allows only a handful of workspaces, so abandoned shells block ' +
-        'the user from trying again. Requires OWNER on that workspace, and you must pass `confirmName` exactly ' +
-        'matching the workspace name (call rootr_workspaces first to read it). THIS CANNOT BE UNDONE: everything ' +
-        'inside is removed. Never call this on a workspace that holds the user\'s real work — if you did not ' +
-        'create it in this session, ask the user first.',
-      annotations: { readOnlyHint: false, destructiveHint: true },
-      inputSchema: {
-        workspaceId: z.string().describe('Id of the workspace to delete'),
-        confirmName: z
-          .string()
-          .describe('The workspace name, typed again exactly — the server rejects the call if it does not match'),
+    /**
+     * WS-CLEANUP — **짓다 실패해서 남은 빈 워크스페이스를 에이전트가 치울 수 있게.**
+     *
+     * 스캐폴딩이 중간에 실패하면 껍데기만 남는데 지우는 문이 없었다. 무료 한도가
+     * 5개라 몇 번 실패하면 사용자가 바로 막히고, 그 잔해를 사람이 화면에서 하나씩
+     * 지워야 했다(2026-08-30 실측: 치과 3개·아파트 4개).
+     *
+     * 이름을 그대로 다시 적게 한다 — 서버가 요구하는 안전장치이자, 모델이 엉뚱한
+     * 워크스페이스를 지목했을 때 걸리는 그물이다.
+     */
+    server.registerTool(
+      'rootr_delete_workspace',
+      {
+        title: 'Delete a workspace you created (cleanup after a failed scaffold)',
+        description:
+          'Permanently delete a Rootr (루터) workspace. Intended for cleaning up EMPTY leftovers from a scaffold ' +
+          'run that failed halfway — the free plan allows only a handful of workspaces, so abandoned shells block ' +
+          'the user from trying again. Requires OWNER on that workspace, and you must pass `confirmName` exactly ' +
+          'matching the workspace name (call rootr_workspaces first to read it). THIS CANNOT BE UNDONE: everything ' +
+          'inside is removed. Never call this on a workspace that holds the user\'s real work — if you did not ' +
+          'create it in this session, ask the user first.',
+        annotations: { readOnlyHint: false, destructiveHint: true },
+        inputSchema: {
+          workspaceId: z.string().describe('Id of the workspace to delete'),
+          confirmName: z
+            .string()
+            .describe('The workspace name, typed again exactly — the server rejects the call if it does not match'),
+        },
       },
-    },
-    async ({ workspaceId, confirmName }) => {
-      try {
-        const client = makeClient();
-        await client.deleteWorkspace({ workspaceId, confirmName });
-        return jsonResult({ deleted: true, workspaceId });
-      } catch (err) {
-        return errorResult(err);
-      }
-    },
-  );
+      async ({ workspaceId, confirmName }) => {
+        try {
+          const client = makeClient();
+          await client.deleteWorkspace({ workspaceId, confirmName });
+          return jsonResult({ deleted: true, workspaceId });
+        } catch (err) {
+          return errorResult(err);
+        }
+      },
+    );
+  }
 
   server.registerTool(
     'rootr_scaffold_review',
@@ -280,12 +373,21 @@ export function registerWorkspaceTools(server) {
       annotations: { readOnlyHint: true, destructiveHint: false },
       inputSchema: {
         tree: treeArg('The scaffold tree you designed — an ARRAY of node objects, same shape you would pass to rootr_scaffold_apply'),
+        mode: z
+          .enum(['docs', 'minimal'])
+          .optional()
+          .describe(
+            'Lower the review bar when the system-building rules do not apply: "docs" for a document-only tree ' +
+              'with no tables at all, "minimal" for a small personal/few-person tree (e.g. a couple\'s shared ' +
+              'ledger) where relations, a how-to-use guide, forms, and rollups are overkill. Omit for normal ' +
+              'multi-table workspaces.',
+          ),
       },
     },
-    async ({ tree }) => {
+    async ({ tree, mode }) => {
       try {
         const client = makeClient();
-        const result = await client.scaffoldReview(parseTree(tree));
+        const result = await client.scaffoldReview(parseTree(tree), mode);
         return jsonResult(result);
       } catch (err) {
         return errorResult(err);
@@ -309,13 +411,20 @@ export function registerWorkspaceTools(server) {
       inputSchema: {
         rootPath: z.string().optional().describe('Grade only this subtree, e.g. "/동네 빵집 운영"'),
         workspace: z.string().optional().describe('Workspace id; defaults to ROOTR_WORKSPACE/config'),
+        mode: z
+          .enum(['docs', 'minimal'])
+          .optional()
+          .describe(
+            'Same meaning as on rootr_scaffold_review: "docs" for a document-only subtree, "minimal" for a ' +
+              'small personal/few-person subtree where relations/guide/forms/rollups are overkill.',
+          ),
       },
     },
-    async ({ rootPath, workspace }) => {
+    async ({ rootPath, workspace, mode }) => {
       try {
         const ws = requireWorkspace(workspace);
         const client = makeClient(ws);
-        return jsonResult(await client.scaffoldReviewBuilt(ws, rootPath));
+        return jsonResult(await client.scaffoldReviewBuilt(ws, rootPath, mode));
       } catch (err) {
         return errorResult(err);
       }
@@ -373,13 +482,22 @@ export function registerWorkspaceTools(server) {
           .string()
           .optional()
           .describe('Workspace id; defaults to ROOTR_WORKSPACE/config if omitted'),
+        mode: z
+          .enum(['docs', 'minimal'])
+          .optional()
+          .describe(
+            'Lower the review bar when the system-building rules do not apply: "docs" for a document-only tree ' +
+              'with no tables at all, "minimal" for a small personal/few-person tree (e.g. a couple\'s shared ' +
+              'ledger) where relations, a how-to-use guide, forms, and rollups are overkill. Omit for normal ' +
+              'multi-table workspaces.',
+          ),
       },
     },
-    async ({ tree, rootPath, workspace }) => {
+    async ({ tree, rootPath, workspace, mode }) => {
       try {
         const ws = requireWorkspace(workspace);
         const client = makeClient(ws);
-        const result = await client.scaffoldApply(ws, { rootPath, tree: parseTree(tree) });
+        const result = await client.scaffoldApply(ws, { rootPath, tree: parseTree(tree), mode });
         return jsonResult(result);
       } catch (err) {
         return errorResult(err);

package/lib/mcp.js

@@ -11,6 +11,8 @@ import { registerTemplateTools } from './mcp-tools/templates.js';
 import { registerWebhookTools } from './mcp-tools/webhooks.js';
 import { registerMiscTools } from './mcp-tools/misc.js';
 import { registerPublicTools } from './mcp-tools/public.js';
+// BOOKING — 공개한 표를 예약 페이지로 쓰는 도구 + 구글 캘린더 연결.
+import { registerBookingTools } from './mcp-tools/booking.js';
 import { registerCrmTools } from './mcp-tools/crm.js';
 import { registerPresentationTools } from './mcp-tools/presentations.js';
 import { registerPageTools } from './mcp-tools/pages.js';
@@ -272,6 +274,7 @@ export function buildMcpServer({ name, version }) {
   registerWebhookTools(server);
   registerMiscTools(server);
   registerPublicTools(server);
+  registerBookingTools(server);
   registerCrmTools(server);
   registerPresentationTools(server);
   registerPageTools(server);

package/lib/resolve.js

@@ -30,6 +30,26 @@ export function parseRootrUrl(target) {
   return { workspaceId: segments[at + 1], nodeId: id, kind: id ? kind : undefined };
 }
 
+/**
+ * Parse a published public document URL: `rootr.io/p/{slug}` (optionally
+ * locale-prefixed, e.g. `/ko/p/{slug}`). This is the "share this doc"
+ * address — it carries no workspace id, unlike `/w/{ws}/...` URLs, so it
+ * needs its own recognizer. Returns null for anything else.
+ */
+export function parsePublicSlugUrl(target) {
+  if (typeof target !== 'string' || !/^https?:\/\//i.test(target)) return null;
+  let url;
+  try {
+    url = new URL(target);
+  } catch {
+    return null;
+  }
+  const segments = url.pathname.split('/').filter(Boolean);
+  const at = segments.indexOf('p');
+  if (at === -1 || !segments[at + 1]) return null;
+  return { slug: segments[at + 1] };
+}
+
 /**
  * Resolve a CLI/MCP "target" argument to a node id.
  * A full rootr.io URL is unpacked to the node id it points at; a value
@@ -78,6 +98,27 @@ export async function resolveTarget(client, target) {
     return { id: url.nodeId, existed: true, path: undefined, url };
   }
 
+  const publicUrl = parsePublicSlugUrl(target);
+  if (publicUrl) {
+    if (!client.workspace) {
+      throw new RootrApiError(
+        tr(
+          `이 주소는 공개 문서 주소(/p/${publicUrl.slug})입니다. 먼저 rootr_use_workspace 로 워크스페이스를 선택하세요.`,
+          `This is a public document URL (/p/${publicUrl.slug}). Select a workspace with rootr_use_workspace first.`,
+        ),
+      );
+    }
+    const node = await client.getNodeBySlug(publicUrl.slug);
+    if (!node) {
+      // ISSUE-127 — 못 찾은 공개 주소는 "새로 만들 경로"가 아니다. 예전에는 path 에 주소를 그대로 실어, rootr_write 가
+      // `/https:/rootr.io/p/<slug>` 라는 폴더 줄기와 헛문서를 만들었다(격리 dev 실측). path 는 비우고 주소는 target 으로만 남긴다.
+      // publicSlug 는 rootr_read 가 공개 발행본으로 되받을 때만 쓴다(쓰기 도구는 안 본다).
+      return { id: undefined, existed: false, path: undefined, target, publicSlug: publicUrl.slug };
+    }
+    const id = node.id || (node.node && node.node.id);
+    return { id, existed: true, path: undefined, node: node.node || node };
+  }
+
   if (!target.startsWith('/')) {
     return { id: target, existed: true, path: undefined };
   }
@@ -92,7 +133,8 @@ export async function resolveTarget(client, target) {
 
 export function requireResolved(resolved) {
   if (!resolved.existed || !resolved.id) {
-    throw new RootrApiError(tr(`경로를 찾을 수 없습니다: ${resolved.path}`, `Path not found: ${resolved.path}`));
+    const what = resolved.path ?? resolved.target;
+    throw new RootrApiError(tr(`경로를 찾을 수 없습니다: ${what}`, `Path not found: ${what}`));
   }
   return resolved.id;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rootr-cli",
-  "version": "0.18.0",
+  "version": "0.20.0",
   "description": "Official Rootr CLI + MCP server — read, write, edit and search Rootr documents from the shell or from an AI agent.",
   "type": "module",
   "bin": {