@klosedoc/mcp 0.1.1 → 0.1.2

package/README.md

@@ -12,7 +12,7 @@
 - 可访问的 KloseDoc 地址，以及在“账户菜单 → Agent 接入”创建的用户级令牌。
 - 各个项目中已存在的演示产物目录（例如 dist），项目可分散放置。
 
-在已开放接入的 KloseDoc 页面选择客户端并复制配置。客户端通过 `npx -y @klosedoc/mcp@0.1.1` 启动适配器；不要使用未固定版本的 `latest`。0.1.1 必须发布并验证后才会开放此版本配置；旧版 0.1.0 仍需要终端授权。
+在已开放接入的 KloseDoc 页面选择客户端并复制配置。客户端通过 `npx -y @klosedoc/mcp@0.1.2` 启动适配器；不要使用未固定版本的 `latest`。0.1.2 必须发布并验证后才会开放此版本配置；0.1.0 / 0.1.1 的旧授权流程不适用于本版本。
 
 配置所需环境变量：
 
@@ -23,39 +23,24 @@
 
 本地 HTTP 地址只能连接本机 KloseDoc，不能用于给其他人分享。
 
-## 上传时确认（0.1.1 起）
+## 自动上传（0.1.2 起）
 
-配置完成后，直接让 Agent 上传项目中的演示，不必先执行授权命令。客户端需要支持 MCP 表单交互确认（form elicitation）。
+统一使用自动上传，不再选择模式、不调用 MCP 表单确认，也不需要逐个目录运行授权命令。用户安装并配置此版本后，Agent 可以读取其指定的项目产物及根目录的 `klosedoc.json`，上传到配置的 KloseDoc 站点。
 
-1. Agent 指定绝对项目路径 `configDirectory` 和项目内的产物 `path`（例如 `dist`）。
-2. 客户端弹出确认，展示项目目录、实际读取路径、接收站点和演示项目。确认也包括读取项目根目录的 `klosedoc.json`。
-3. 你勾选允许并提交后，适配器才读取文件并上传草稿；拒绝、关闭、超时或取消调用都会停止，不会自动改用其他授权途径。
-4. 发布仍是单独操作，需要你明确要求，以及具备发布权限的令牌。
+1. 在接入页创建令牌，选择客户端并保存生成的配置；只需要服务地址和令牌。
+2. 重启 MCP 连接，让 Agent 指定绝对项目路径 `configDirectory`、相对产物路径 `path` 和入口 `entry`。
+3. 适配器校验并打包所选产物，上传为草稿。
+4. 发布仍是独立工具调用，需要用户明确要求以及具备发布权限的令牌。
 
-每次上传都确认，不保存长期目录授权；没有 `approved: true` 之类可由 Agent 代填的参数。只列出演示、创建空项目或查询状态无需本地目录授权。不同客户端是否支持确认，取决于初始化时声明的能力；适配器依赖客户端真实展示给用户，无法替代客户端权限控制或操作系统沙箱。
+`path` 默认是 `dist`。自定义目录必须显式传入，`klosedoc.json` 不能扩大或替换本次选择的读取范围。项目可分散存放，本地路径不发送至 KloseDoc 服务器。禁止整个项目目录、主目录、文件系统根目录、隐藏路径和符号链接。
 
-`path` 默认是 `dist`。自定义产物目录必须显式传入 `path`，不能通过 `klosedoc.json` 把已确认的读取范围扩大或换成另一个目录。禁止整个项目目录、用户主目录、文件系统根目录、隐藏路径及符号链接。
+自动上传不是目录白名单。仅向你信任的 Agent 配置令牌，使用不含私密信息的独立产物目录。过滤不能识别 HTML、JSON 或 ZIP 中的所有敏感内容。本包不修改客户端自身的工具审批策略；客户端仍可能提示确认或阻止工具调用。
 
-## 不支持交互确认的客户端
+### 旧配置升级
 
-适配器会明确提示缺少确认能力，不会默认放开本地读取。可换用支持 form elicitation 的客户端，或使用备用的终端授权：
+`authorize`、`unauthorize`、`authorizations` 命令已移除，旧的目录授权文件不再读取或写入。不要继续依赖它限制上传范围。客户端仅配置 `KLOSEDOCPUBLISH_URL` 和 `KLOSEDOCPUBLISH_TOKEN`；若检测到旧的 `KLOSEDOCPUBLISH_ROOT` 或 `KLOSEDOCPUBLISH_UPLOAD_MODE`，适配器会停止并提示用户检查和更换配置，不会静默忽略旧的限制。更新固定包版本前，请先了解自动上传的行为变化。
 
-```sh
-mkdir -p dist
-npx -y @klosedoc/mcp@0.1.1 authorize . dist
-```
-
-内部测试使用已安装的入口替代 npx，例如：
-
-```sh
-node /path/to/installed/@klosedoc/mcp/server.mjs authorize . dist
-```
-
-命令会显示项目的规范绝对路径和产物目录，输入 yes 后授权。此备用方式每个项目单独执行一次；无需移动项目或修改全局 MCP 配置。授权仅允许读取指定产物目录，以及项目根目录的 klosedoc.json。修改 klosedoc.json 的 output 不会扩大授权。支持交互确认的客户端始终走当次确认，不因旧的终端授权而跳过确认。
-
-使用相同入口的 `authorizations` 查看授权，`unauthorize .` 撤销当前项目；之后的上传会立即拒绝，已发布内容不受影响。授权记录保存在本机 `~/.config/klosedoc/authorizations.json`，不发送至服务器。不要把该文件交给 Agent 修改。交互确认不是操作系统沙箱；拥有同一用户任意文件写权限或终端控制权限的程序仍能改变授权记录，需由客户端限制这些权限。
-
-不支持旧的 KLOSEDOCPUBLISH_ROOT 环境变量。上传必须提供绝对项目路径 configDirectory，path/output 相对于项目；不默认使用 MCP 进程工作目录。本地路径不会发送到 KloseDoc 服务端，只在本地 MCP 适配器与客户端之间用于操作和确认。
+取消尚未完成的工具调用可以中止本次传输；服务端已提交的版本不会因此删除。撤销 KloseDoc 令牌可阻止后续服务访问，移除客户端 MCP 配置可停止接入；已发布内容需单独下线。
 
 ## 关联项目
 
@@ -71,7 +56,7 @@ node /path/to/installed/@klosedoc/mcp/server.mjs authorize . dist
 
 已有项目也可以使用配置文件：
 
-在演示详情页“来源与同步 → Agent 项目配置”复制 `klosedoc.json`，保存到本地项目根目录。文件包含 `projectId`、相对于配置文件的 `output`（例如 `dist`）和 `entry`（例如 `index.html`），不包含令牌。上传时传入项目的绝对路径 `configDirectory`；非默认产物目录同时传入 `path`，以便准确展示确认范围。
+在演示详情页“来源与同步 → Agent 项目配置”复制 `klosedoc.json`，保存到本地项目根目录。文件包含 `projectId`、相对于配置文件的 `output`（例如 `dist`）和 `entry`（例如 `index.html`），不包含令牌。上传时传入项目的绝对路径 `configDirectory`；非默认产物目录同时传入 `path`，以便限定本次读取范围。
 
 让 Agent 调用 `klosedoc_presentation_upload` 上传输出目录，生成草稿。确认预览后再调用 `klosedoc_publication_publish`；默认令牌没有发布权限。也可用 `klosedoc_presentation_create` 创建项目、`klosedoc_publication_status` 读取状态、`klosedoc_publication_rollback` 恢复草稿、`klosedoc_publication_revoke` 下线。
 
@@ -79,7 +64,7 @@ node /path/to/installed/@klosedoc/mcp/server.mjs authorize . dist
 
 ## 安全边界
 
-适配器仅打包本次已确认的路径，或不支持确认客户端的终端授权产物目录，不执行构建脚本，不支持产物符号链接，目录上传要求独立输出目录。目录打包跳过隐藏文件、`node_modules` 和 `klosedoc.json`。单文件最大 10 MB，包解压后最大 50 MB、1000 个文件；账户配额与权限由服务端检查。确认前不读取配置或产物内容；确认后重新检查路径。授权期间不要让不可信进程并发替换目录；本地检查不能替代操作系统级文件隔离。
+适配器仅打包本次指定的输出路径，不执行构建脚本，不支持符号链接或硬链接，禁止整个项目、主目录和根目录。目录打包跳过隐藏文件、`node_modules` 和 `klosedoc.json`，非允许类型文件会拒绝上传。单文件最大 10 MB，包解压后最大 50 MB、1000 个文件；账户配额、令牌权限和有效性由服务端检查。操作期间不要让不可信进程并发替换目录；路径检查不能替代操作系统级文件隔离。
 
 本包仅含客户端适配器，不包含 KloseDoc 的服务端、数据库、密钥或其他产品源码。
 

package/authorization.mjs

@@ -1,120 +1,73 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import os from 'node:os';
-import { createInterface } from 'node:readline/promises';
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
 
-const registry = process.env.KLOSEDOC_AUTH_FILE || path.join(os.homedir(), '.config', 'klosedoc', 'authorizations.json');
 export function within(parent, target) {
   const relative = path.relative(parent, target);
-  return relative === '' || (!relative.startsWith('..' + path.sep) && relative !== '..' && !path.isAbsolute(relative));
+  return (
+    relative === "" ||
+    (!relative.startsWith(".." + path.sep) &&
+      relative !== ".." &&
+      !path.isAbsolute(relative))
+  );
 }
 export async function checkedPath(value) {
-  if (!value || !path.isAbsolute(value)) throw new Error('An absolute project path is required');
+  if (!value || !path.isAbsolute(value))
+    throw new Error("An absolute project path is required");
   const resolved = path.resolve(value);
   let current = path.parse(resolved).root;
-  for (const part of resolved.slice(current.length).split(path.sep).filter(Boolean)) {
+  for (const part of resolved
+    .slice(current.length)
+    .split(path.sep)
+    .filter(Boolean)) {
     current = path.join(current, part);
-    if ((await fs.lstat(current)).isSymbolicLink()) throw new Error('Symlinks are not supported');
+    if ((await fs.lstat(current)).isSymbolicLink())
+      throw new Error("Symlinks are not supported");
   }
   return resolved;
 }
-async function load() {
-  try {
-    await checkedPath(registry);
-    const data = JSON.parse(await fs.readFile(registry, 'utf8'));
-    if (data.version !== 1 || !Array.isArray(data.projects)) throw new Error('Invalid local authorization registry');
-    return data;
-  } catch (error) { if (error.code === 'ENOENT') return { version: 1, projects: [] }; throw error; }
-}
-export async function authorization(projectDirectory) {
-  const project = await checkedPath(projectDirectory);
-  const grant = (await load()).projects.find(item => item.project === project);
-  if (!grant) throw new Error('Project is not authorized. Run klosedoc-mcp authorize in your terminal.');
-  const output = await checkedPath(grant.output);
-  if (output === project || !within(project, output)) throw new Error('Invalid authorized output directory');
-  return { project, output };
-}
-
-// Approval comes from the MCP client, never from an agent-supplied tool argument.
-// This grant lives for one upload only and is not written to the local registry.
-export async function uploadAuthorization({ server, projectDirectory, output, destination, projectId, signal }) {
-  const capability = server.getClientCapabilities()?.elicitation;
-  const supportsForm = capability && (capability.form !== undefined || Object.keys(capability).length === 0);
-  if (!supportsForm) {
-    try { return await authorization(projectDirectory); }
-    catch (error) {
-      if (!error.message.includes('not authorized')) throw error;
-      throw new Error('This client does not support MCP form confirmation. Use a client with elicitation support, or run klosedoc-mcp authorize "' + projectDirectory + '" dist in an interactive terminal (replace dist with your output directory). No files were uploaded.');
-    }
-  }
+// Automatic uploads still validate the exact output scope before reading content.
+export async function validateUploadTarget({
+  projectDirectory,
+  output,
+  signal,
+}) {
+  signal?.throwIfAborted();
   const project = await checkedPath(projectDirectory);
-  if (project === path.parse(project).root || project === os.homedir() || !(await fs.stat(project)).isDirectory()) {
-    throw new Error('Choose an individual project, not a home directory or filesystem root');
+  if (
+    project === path.parse(project).root ||
+    project === os.homedir() ||
+    !(await fs.stat(project)).isDirectory()
+  ) {
+    throw new Error(
+      "Choose an individual project, not a home directory or filesystem root",
+    );
   }
-  const selected = output || 'dist';
-  if (path.isAbsolute(selected)) throw new Error('Output path must be relative to the project');
+  const selected = output || "dist";
+  if (path.isAbsolute(selected))
+    throw new Error("Output path must be relative to the project");
   const target = path.resolve(project, selected);
-  if (target === project || !within(project, target)) throw new Error('Choose a dedicated output directory or HTML/ZIP file inside the project');
+  if (target === project || !within(project, target))
+    throw new Error(
+      "Choose a dedicated output directory or HTML/ZIP file inside the project",
+    );
   const segments = path.relative(project, target).split(path.sep);
-  if (segments.some(part => part.startsWith('.') || part === 'node_modules') || path.basename(target) === 'klosedoc.json') {
-    throw new Error('Hidden paths, node_modules and project configuration cannot be uploaded');
+  if (
+    segments.some((part) => part.startsWith(".") || part === "node_modules") ||
+    path.basename(target) === "klosedoc.json"
+  ) {
+    throw new Error(
+      "Hidden paths, node_modules and project configuration cannot be uploaded",
+    );
   }
   await checkedPath(target);
   const stat = await fs.stat(target);
-  if (!stat.isDirectory() && !(stat.isFile() && /\.(html?|zip)$/i.test(target))) {
-    throw new Error('Choose a dedicated output directory or HTML/ZIP file');
+  if (
+    !stat.isDirectory() &&
+    !(stat.isFile() && /\.(html?|zip)$/i.test(target))
+  ) {
+    throw new Error("Choose a dedicated output directory or HTML/ZIP file");
   }
   signal?.throwIfAborted();
-  const reply = await server.elicitInput({
-    mode: 'form',
-    message: `KloseDoc: allow this upload?\nProject directory: ${JSON.stringify(project)}\nUpload path: ${JSON.stringify(target)}\nDestination: ${destination}\nPresentation: ${projectId || 'the projectId in klosedoc.json'}\nThis reads the selected file/directory and klosedoc.json at the project root, then uploads a draft. It does not publish. Approval applies to this upload only.`,
-    requestedSchema: {
-      type: 'object',
-      properties: { allowUpload: { type: 'boolean', title: 'Allow this upload', default: false } },
-      required: ['allowUpload'],
-    },
-  }, { signal, timeout: 120000 });
-  signal?.throwIfAborted();
-  if (reply.action !== 'accept' || reply.content?.allowUpload !== true) {
-    throw new Error('Upload cancelled: local files were not read or uploaded.');
-  }
-  // Repeat path checks after the user interaction; never authorize a symlink
-  // swapped into place while the confirmation was open.
-  await checkedPath(project);
-  await checkedPath(target);
-  return { project, output: target, selected, oneTime: true };
-}
-export async function authorizationCommand(command, args) {
-  if (command === 'authorizations') { console.log(JSON.stringify((await load()).projects, null, 2)); return; }
-  if (!process.stdin.isTTY || !process.stdout.isTTY) throw new Error('Authorization changes require an interactive terminal; no unattended approval is supported.');
-  const requested = path.resolve(args[0] || '.');
-  const project = await fs.realpath(requested).catch(error => {
-    if (command === 'unauthorize' && error.code === 'ENOENT') return requested;
-    throw error;
-  });
-  if (project === path.parse(project).root || project === os.homedir()) throw new Error('Choose an individual project, not a home directory or filesystem root');
-  const data = await load();
-  let output;
-  if (command === 'authorize') {
-    await checkedPath(project);
-    if (!(await fs.stat(project)).isDirectory()) throw new Error('Choose a project directory');
-    const relative = args[1] || 'dist';
-    if (path.isAbsolute(relative)) throw new Error('Output must be relative to the project');
-    output = await checkedPath(path.resolve(project, relative));
-    if (output === project || !within(project, output) || !(await fs.stat(output)).isDirectory()) throw new Error('Choose an existing dedicated output directory inside the project');
-  }
-  console.log(`${command === 'authorize' ? 'Allow uploads from' : 'Revoke access to'} project: ${project}`);
-  if (output) console.log(`Output: ${output}\nAlso allows reading only klosedoc.json at the project root. Paths remain local.`);
-  const prompt = createInterface({ input: process.stdin, output: process.stdout });
-  let answer;
-  try { answer = await prompt.question('Type yes to confirm: '); } finally { prompt.close(); }
-  if (answer.trim() !== 'yes') throw new Error('Cancelled; authorization unchanged');
-  data.projects = data.projects.filter(item => item.project !== project);
-  if (output) data.projects.push({ project, output });
-  await fs.mkdir(path.dirname(registry), { recursive: true, mode: 0o700 });
-  await checkedPath(path.dirname(registry));
-  const temporary = registry + '.' + process.pid + '.tmp';
-  await fs.writeFile(temporary, JSON.stringify(data, null, 2), { mode: 0o600, flag: 'wx' });
-  await fs.rename(temporary, registry);
-  console.log('Local authorization updated.');
+  return { project, output: target, selected };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@klosedoc/mcp",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "MCP adapter for KloseDoc. Currently supports presentation workflows only.",
   "license": "MIT",
   "files": ["server.mjs", "authorization.mjs", "README.md", "LICENSE"],

package/server.mjs

@@ -1,137 +1,375 @@
 #!/usr/bin/env node
-import fs from 'node:fs/promises';
-import { constants } from 'node:fs';
-import path from 'node:path';
-import crypto from 'node:crypto';
-import { zipSync } from 'fflate';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { z } from 'zod';
-import { uploadAuthorization, authorizationCommand, checkedPath, within } from './authorization.mjs';
-import metadata from './package.json' with { type: 'json' };
+import fs from "node:fs/promises";
+import { constants } from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import { zipSync } from "fflate";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { validateUploadTarget, checkedPath, within } from "./authorization.mjs";
+import metadata from "./package.json" with { type: "json" };
 
-if (process.argv.includes('--version')) { console.log(metadata.version); process.exit(0); }
-if (process.argv.includes('--help')) {
-  console.log('KloseDoc MCP (stdio) — currently supports presentations only.\nRequires Node.js 24+.\nSet KLOSEDOCPUBLISH_URL, KLOSEDOCPUBLISH_TOKEN in your MCP client.\nUploads ask for one-time path confirmation via MCP form elicitation before reading files.\nFallback for clients without form confirmation: authorize [project-directory] [output-directory=dist], authorizations, unauthorize [project-directory].\nSee the package README for setup and safety boundaries.');
+if (process.argv.includes("--version")) {
+  console.log(metadata.version);
   process.exit(0);
 }
-if (['authorize', 'unauthorize', 'authorizations'].includes(process.argv[2])) {
-  await authorizationCommand(process.argv[2], process.argv.slice(3));
+if (process.argv.includes("--help")) {
+  console.log(
+    "KloseDoc MCP (stdio) — presentations only. Requires Node.js 24+.\nSet KLOSEDOCPUBLISH_URL and KLOSEDOCPUBLISH_TOKEN in your MCP client.\nUploads automatically read the specified presentation output and create a draft. No form confirmation or directory authorization command is required.\nPublishing remains a separate tool and token permission. Client tool-approval policies are unchanged.\nSee the package README for setup and safety boundaries.",
+  );
   process.exit(0);
 }
-if (process.env.KLOSEDOCPUBLISH_ROOT) throw new Error('KLOSEDOCPUBLISH_ROOT is no longer supported. Use local project authorization.');
-const server = new McpServer({ name: 'klosedoc-mcp', version: metadata.version });
-const base = new URL(process.env.KLOSEDOCPUBLISH_URL || 'http://127.0.0.1:3000/api/agent/slides');
-if ((base.protocol !== 'https:' && !(base.protocol === 'http:' && ['localhost','127.0.0.1','[::1]'].includes(base.hostname)))
-    || base.username || base.password || base.search || base.hash || base.pathname.replace(/\/$/, '') !== '/api/agent/slides') throw new Error('Use an HTTPS KloseDoc URL, or HTTP on localhost');
+if (process.argv.length > 2)
+  throw new Error(
+    "Unknown command. Directory authorization commands are no longer supported; see --help.",
+  );
+// Do not silently reinterpret an older, explicitly restricted configuration.
+if (
+  process.env.KLOSEDOCPUBLISH_ROOT !== undefined ||
+  process.env.KLOSEDOCPUBLISH_UPLOAD_MODE !== undefined
+)
+  throw new Error(
+    "Legacy root or upload-mode settings are no longer supported. Review the automatic-upload behavior and replace the KloseDoc client configuration yourself.",
+  );
+const server = new McpServer({
+  name: "klosedoc-mcp",
+  version: metadata.version,
+});
+const base = new URL(
+  process.env.KLOSEDOCPUBLISH_URL || "http://127.0.0.1:3000/api/agent/slides",
+);
+if (
+  (base.protocol !== "https:" &&
+    !(
+      base.protocol === "http:" &&
+      ["localhost", "127.0.0.1", "[::1]"].includes(base.hostname)
+    )) ||
+  base.username ||
+  base.password ||
+  base.search ||
+  base.hash ||
+  base.pathname.replace(/\/$/, "") !== "/api/agent/slides"
+)
+  throw new Error("Use an HTTPS KloseDoc URL, or HTTP on localhost");
 const token = process.env.KLOSEDOCPUBLISH_TOKEN;
-if (!token) throw new Error('KLOSEDOCPUBLISH_TOKEN is required');
+if (!token) throw new Error("KLOSEDOCPUBLISH_TOKEN is required");
 const maxBytes = 50 * 1024 * 1024;
-const extensions = new Set(['.html','.htm','.css','.js','.mjs','.json','.png','.jpg','.jpeg','.gif','.webp','.avif','.svg','.ico','.woff','.woff2','.ttf','.otf','.mp4','.webm','.mp3','.ogg','.wav','.txt','.pdf']);
+const extensions = new Set([
+  ".html",
+  ".htm",
+  ".css",
+  ".js",
+  ".mjs",
+  ".json",
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".avif",
+  ".svg",
+  ".ico",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".mp4",
+  ".webm",
+  ".mp3",
+  ".ogg",
+  ".wav",
+  ".txt",
+  ".pdf",
+]);
 async function readFile(file, limit) {
   await checkedPath(file);
-  const handle = await fs.open(file,constants.O_RDONLY | constants.O_NOFOLLOW);
+  const handle = await fs.open(file, constants.O_RDONLY | constants.O_NOFOLLOW);
   try {
     const stat = await handle.stat();
-    if (stat.nlink !== 1) throw new Error('Hard links are not supported');
-    if (!stat.isFile() || stat.size > limit) throw new Error('File exceeds the size limit');
+    if (stat.nlink !== 1) throw new Error("Hard links are not supported");
+    if (!stat.isFile() || stat.size > limit)
+      throw new Error("File exceeds the size limit");
     const bytes = await handle.readFile();
     await checkedPath(file);
-    if (bytes.length > limit) throw new Error('File exceeds the size limit');
+    if (bytes.length > limit) throw new Error("File exceeds the size limit");
     return bytes;
-  } finally { await handle.close(); }
+  } finally {
+    await handle.close();
+  }
 }
 async function configFor(directory) {
-  const filename = path.join(directory,'klosedoc.json');
+  const filename = path.join(directory, "klosedoc.json");
   try {
-    const value = JSON.parse((await readFile(filename,64*1024)).toString('utf8'));
-    if (value.type && value.type !== 'web_slides') throw new Error('type must be web_slides');
+    const value = JSON.parse(
+      (await readFile(filename, 64 * 1024)).toString("utf8"),
+    );
+    if (value.type && value.type !== "web_slides")
+      throw new Error("type must be web_slides");
     return value;
-  } catch (error) { if (error.code === 'ENOENT') return {}; throw new Error('Invalid klosedoc.json: ' + error.message); }
+  } catch (error) {
+    if (error.code === "ENOENT") return {};
+    throw new Error("Invalid klosedoc.json: " + error.message);
+  }
 }
-async function bundle(value, configPath, projectId, signal) {
-  const grant = await uploadAuthorization({ server: server.server, projectDirectory: configPath, output: value, destination: base.toString(), projectId, signal });
+async function bundle(value, configPath, signal) {
+  const grant = await validateUploadTarget({
+    projectDirectory: configPath,
+    output: value,
+    signal,
+  });
   const config = await configFor(grant.project);
-  if (grant.oneTime && !value && config.output && path.resolve(grant.project, config.output) !== grant.output) {
-    throw new Error('klosedoc.json selects a different output. Retry with an explicit path so the client can confirm that directory.');
+  if (
+    !value &&
+    config.output &&
+    path.resolve(grant.project, config.output) !== grant.output
+  ) {
+    throw new Error(
+      "klosedoc.json selects a different output. Supply that directory explicitly as path; configuration cannot expand the selected scope.",
+    );
   }
-  const selected = grant.oneTime ? grant.selected : value || config.output || path.relative(grant.project, grant.output);
-  if (path.isAbsolute(selected)) throw new Error('Output path must be relative to the project');
+  const selected = grant.selected;
+  if (path.isAbsolute(selected))
+    throw new Error("Output path must be relative to the project");
   const target = path.resolve(grant.project, selected);
   async function localPath(filename) {
-    if (!within(grant.output, filename)) throw new Error('Path is outside the authorized output directory');
+    if (!within(grant.output, filename))
+      throw new Error("Path is outside the selected output directory");
     return checkedPath(filename);
   }
   await localPath(target);
   const stat = await fs.lstat(target);
   if (stat.isFile()) {
-    if (!/\.(html?|zip)$/i.test(target)) throw new Error('Expected an HTML or ZIP file');
-    return { bytes: await readFile(target, /\.zip$/i.test(target) ? maxBytes : 10*1024*1024), filename: path.basename(target), config };
+    if (!/\.(html?|zip)$/i.test(target))
+      throw new Error("Expected an HTML or ZIP file");
+    return {
+      bytes: await readFile(
+        target,
+        /\.zip$/i.test(target) ? maxBytes : 10 * 1024 * 1024,
+      ),
+      filename: path.basename(target),
+      config,
+    };
   }
-  if (!stat.isDirectory()) throw new Error('Select a dedicated output directory, inside the authorized project');
+  if (!stat.isDirectory())
+    throw new Error("Select a dedicated output directory inside the project");
   const files = Object.create(null);
-  let total = 0, count = 0;
+  let total = 0,
+    count = 0;
   async function walk(directory) {
-    for (const entry of (await fs.readdir(directory,{withFileTypes:true})).sort((a,b)=>a.name.localeCompare(b.name))) {
-      if (entry.name.startsWith('.') || entry.name === 'node_modules' || entry.name === 'klosedoc.json') continue;
-      const filename = await localPath(path.join(directory,entry.name));
-      if (entry.isDirectory()) { await walk(filename); continue; }
-      if (!entry.isFile() || !extensions.has(path.extname(filename).toLowerCase())) throw new Error('Unsupported output file: ' + entry.name);
-      if (++count > 1000) throw new Error('Maximum 1000 files');
-      const bytes = await readFile(filename,10*1024*1024);
+    for (const entry of (
+      await fs.readdir(directory, { withFileTypes: true })
+    ).sort((a, b) => a.name.localeCompare(b.name))) {
+      if (
+        entry.name.startsWith(".") ||
+        entry.name === "node_modules" ||
+        entry.name === "klosedoc.json"
+      )
+        continue;
+      const filename = await localPath(path.join(directory, entry.name));
+      if (entry.isDirectory()) {
+        await walk(filename);
+        continue;
+      }
+      if (
+        !entry.isFile() ||
+        !extensions.has(path.extname(filename).toLowerCase())
+      )
+        throw new Error("Unsupported output file: " + entry.name);
+      if (++count > 1000) throw new Error("Maximum 1000 files");
+      const bytes = await readFile(filename, 10 * 1024 * 1024);
       total += bytes.length;
-      if (total > maxBytes) throw new Error('Output exceeds 50 MB');
-      const relative = path.relative(target,filename).split(path.sep).join('/');
-      files[relative] = [bytes,{mtime:new Date('2020-01-01T00:00:00Z')}];
+      if (total > maxBytes) throw new Error("Output exceeds 50 MB");
+      const relative = path
+        .relative(target, filename)
+        .split(path.sep)
+        .join("/");
+      files[relative] = [bytes, { mtime: new Date("2020-01-01T00:00:00Z") }];
     }
   }
   await walk(target);
-  if (!count) throw new Error('Output directory is empty');
-  return { bytes: zipSync(files,{level:6}), filename:'slides.zip', config };
+  if (!count) throw new Error("Output directory is empty");
+  return {
+    bytes: zipSync(files, { level: 6 }),
+    filename: "slides.zip",
+    config,
+  };
 }
-async function request(route = '', input, key, bytes, signal) {
-  const options = { method: input === undefined && !bytes ? 'GET' : 'POST', redirect:'error',
-    headers:{Authorization:'Bearer ' + token}, signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(120000)]) : AbortSignal.timeout(120000) };
-  if (key) options.headers['Idempotency-Key'] = key;
-  if (bytes) { options.headers['Content-Type']='application/octet-stream'; options.body=bytes; }
-  else if (input !== undefined) { options.headers['Content-Type']='application/json'; options.body=JSON.stringify(input); }
-  const response = await fetch(base.toString().replace(/\/$/,'') + route,options);
+async function request(route = "", input, key, bytes, signal) {
+  const options = {
+    method: input === undefined && !bytes ? "GET" : "POST",
+    redirect: "error",
+    headers: { Authorization: "Bearer " + token },
+    signal: signal
+      ? AbortSignal.any([signal, AbortSignal.timeout(120000)])
+      : AbortSignal.timeout(120000),
+  };
+  if (key) options.headers["Idempotency-Key"] = key;
+  if (bytes) {
+    options.headers["Content-Type"] = "application/octet-stream";
+    options.body = bytes;
+  } else if (input !== undefined) {
+    options.headers["Content-Type"] = "application/json";
+    options.body = JSON.stringify(input);
+  }
+  const response = await fetch(
+    base.toString().replace(/\/$/, "") + route,
+    options,
+  );
   const payload = await response.json();
-  if (!response.ok) throw new Error(payload.error?.message || 'KloseDoc request failed (' + response.status + ')');
+  if (!response.ok)
+    throw new Error(
+      payload.error?.message ||
+        "KloseDoc request failed (" + response.status + ")",
+    );
   return payload.data;
 }
 function register(name, description, schema, action, readOnly = false) {
-  server.registerTool(name,{ description, inputSchema:schema,
-    annotations:{readOnlyHint:readOnly,destructiveHint:!readOnly,idempotentHint:true,openWorldHint:true} },async (input, extra) => {
-    try {
-      const result = await action(input, extra);
-      return { content:[{type:'text',text:JSON.stringify(result)}], structuredContent:result };
-    } catch (error) { return { isError:true,content:[{type:'text',text:error.message.replaceAll(token,'[redacted]')}] }; }
-  });
+  server.registerTool(
+    name,
+    {
+      description,
+      inputSchema: schema,
+      annotations: {
+        readOnlyHint: readOnly,
+        destructiveHint: !readOnly,
+        idempotentHint: true,
+        openWorldHint: true,
+      },
+    },
+    async (input, extra) => {
+      try {
+        const result = await action(input, extra);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result) }],
+          structuredContent: result,
+        };
+      } catch (error) {
+        const message = error.message.replaceAll(token, "[redacted]");
+        return { isError: true, content: [{ type: "text", text: message }] };
+      }
+    },
+  );
 }
 const project = z.string().uuid();
-const idempotencyKey = z.string().regex(/^[A-Za-z0-9_.:-]{8,160}$/).describe('Reuse the same key when retrying the same operation.');
-register('klosedoc_presentation_create','Create a Web Slides project. Never publishes content.',{
-  title:z.string().min(1).max(160),folderId:project.optional(),idempotencyKey,
-},input=>request('',{title:input.title,...(input.folderId?{folderId:input.folderId}:{})},input.idempotencyKey));
-register('klosedoc_publication_status','Read status and version IDs, or list presentations. Preview links require the owner to sign in.',{
-  projectId:project.optional(),query:z.string().optional(),page:z.number().int().min(1).optional(),
-},input=>request(input.projectId ? '/' + input.projectId : '?' + new URLSearchParams({query:input.query||'',page:String(input.page||1)})),true);
-register('klosedoc_presentation_upload','Upload a draft after the user confirms the exact local path in the MCP client. Requires form elicitation or an existing terminal grant for clients without it. Reads klosedoc.json only after authorization. Never auto-publishes. Do not edit local authorization records or approve on the user’s behalf.',{
-  projectId:project.optional(),path:z.string().optional().describe('Relative dedicated output directory or HTML/ZIP file; defaults to dist for client confirmation. Specify custom output explicitly.'),configDirectory:z.string().describe('Absolute local project directory. No prior terminal authorization needed with a form-elicitation client. Never sent to the KloseDoc service.'),entry:z.string().optional(),idempotencyKey,
-},async (input, extra)=>{
-  const packed=await bundle(input.path,input.configDirectory,input.projectId,extra.signal);
-  extra.signal.throwIfAborted();
-  const id=project.parse(input.projectId || packed.config.projectId);
-  const query=new URLSearchParams({filename:packed.filename,entry:input.entry||packed.config.entry||''});
-  const output=await request('/'+id+'/upload?'+query,undefined,input.idempotencyKey,packed.bytes,extra.signal);
-  return {...output,checksum:crypto.createHash('sha256').update(packed.bytes).digest('hex')};
-});
-for (const operation of ['publish','rollback']) register('klosedoc_publication_'+operation,
-  operation==='publish'?'Publish the specified version. Requires user authorization and a publish-enabled token; preserves audience and expiry.':'Restore a historical version as the draft. The live link stays unchanged until a separate publish operation.',{
-    projectId:project,versionId:project,expectedCurrentVersionId:project.nullable(),expectedDraftVersionId:project.nullable(),idempotencyKey,
-  },input=>request('/'+input.projectId+'/'+operation,{versionId:input.versionId,expectedCurrentVersionId:input.expectedCurrentVersionId,expectedDraftVersionId:input.expectedDraftVersionId},input.idempotencyKey));
-register('klosedoc_publication_revoke','Take the presentation offline without deleting versions. Requires publish permission.',{
-  projectId:project,idempotencyKey,
-},input=>request('/'+input.projectId+'/revoke',{},input.idempotencyKey));
+const idempotencyKey = z
+  .string()
+  .regex(/^[A-Za-z0-9_.:-]{8,160}$/)
+  .describe("Reuse the same key when retrying the same operation.");
+register(
+  "klosedoc_presentation_create",
+  "Create a Web Slides project. Never publishes content.",
+  {
+    title: z.string().min(1).max(160),
+    folderId: project.optional(),
+    idempotencyKey,
+  },
+  (input) =>
+    request(
+      "",
+      {
+        title: input.title,
+        ...(input.folderId ? { folderId: input.folderId } : {}),
+      },
+      input.idempotencyKey,
+    ),
+);
+register(
+  "klosedoc_publication_status",
+  "Read status and version IDs, or list presentations. Preview links require the owner to sign in.",
+  {
+    projectId: project.optional(),
+    query: z.string().optional(),
+    page: z.number().int().min(1).optional(),
+  },
+  (input) =>
+    request(
+      input.projectId
+        ? "/" + input.projectId
+        : "?" +
+            new URLSearchParams({
+              query: input.query || "",
+              page: String(input.page || 1),
+            }),
+    ),
+  true,
+);
+register(
+  "klosedoc_presentation_upload",
+  "Automatically read the explicitly selected local presentation output and upload a draft. No form elicitation or directory authorization is needed. Does not publish. Follow the user’s requested files and destination; do not change client approval policies.",
+  {
+    projectId: project.optional(),
+    path: z
+      .string()
+      .optional()
+      .describe(
+        "Relative dedicated output directory or HTML/ZIP file; defaults to dist. Specify custom output explicitly.",
+      ),
+    configDirectory: z
+      .string()
+      .describe(
+        "Absolute local project directory. Select only the presentation output requested by the user. Never sent to the KloseDoc service.",
+      ),
+    entry: z.string().optional(),
+    idempotencyKey,
+  },
+  async (input, extra) => {
+    const packed = await bundle(
+      input.path,
+      input.configDirectory,
+      extra.signal,
+    );
+    extra.signal.throwIfAborted();
+    const id = project.parse(input.projectId || packed.config.projectId);
+    const query = new URLSearchParams({
+      filename: packed.filename,
+      entry: input.entry || packed.config.entry || "",
+    });
+    const output = await request(
+      "/" + id + "/upload?" + query,
+      undefined,
+      input.idempotencyKey,
+      packed.bytes,
+      extra.signal,
+    );
+    return {
+      ...output,
+      checksum: crypto.createHash("sha256").update(packed.bytes).digest("hex"),
+    };
+  },
+);
+for (const operation of ["publish", "rollback"])
+  register(
+    "klosedoc_publication_" + operation,
+    operation === "publish"
+      ? "Publish the specified version. Requires user authorization and a publish-enabled token; preserves audience and expiry."
+      : "Restore a historical version as the draft. The live link stays unchanged until a separate publish operation.",
+    {
+      projectId: project,
+      versionId: project,
+      expectedCurrentVersionId: project.nullable(),
+      expectedDraftVersionId: project.nullable(),
+      idempotencyKey,
+    },
+    (input) =>
+      request(
+        "/" + input.projectId + "/" + operation,
+        {
+          versionId: input.versionId,
+          expectedCurrentVersionId: input.expectedCurrentVersionId,
+          expectedDraftVersionId: input.expectedDraftVersionId,
+        },
+        input.idempotencyKey,
+      ),
+  );
+register(
+  "klosedoc_publication_revoke",
+  "Take the presentation offline without deleting versions. Requires publish permission.",
+  {
+    projectId: project,
+    idempotencyKey,
+  },
+  (input) =>
+    request("/" + input.projectId + "/revoke", {}, input.idempotencyKey),
+);
 await server.connect(new StdioServerTransport());