#!/usr/bin/env node
// Stdio MCP server: sandboxes file operations to SANDBOX_ROOT.
// Used as a goosed extension to replace the built-in developer extension for
// regular users — enforces path boundaries at the OS level rather than relying
// on AI model compliance with text constraints.
//
// SANDBOX_ROOT is passed as argv[2] (primary) or SANDBOX_ROOT env var (fallback).
// argv[2] is preferred because some goosed versions don't forward env to stdio MCPs.
// Optional env:  ALLOWED_TOOLS — comma-separated tool whitelist (default: all tools)

import path from 'node:path';
import fs from 'node:fs';
import readline from 'node:readline';
import { fileURLToPath } from 'node:url';
import { execFileSync } from 'node:child_process';
import mysql from 'mysql2/promise';
import { createScheduleService } from './schedule-service.mjs';
import { resolveScheduleTimestamp } from './schedule-time.mjs';
import { shouldAutoCreateReminderAtStart } from './schedule-service.mjs';
import { renderLongImage } from './mindspace-long-image.mjs';
import { createUserDataSpaceService } from './user-data-space-service.mjs';
import { writePageAccessPolicy, readPageAccessPolicy } from './page-data-policy-store.mjs';
import { closePolicyDataset, normalizePageAccessPolicy } from './page-access-policy.mjs';
import { upsertPageDataPolicyIndex } from './page-data-policy-index.mjs';
import { bindWorkspaceHtmlForPageData } from './page-data-workspace-bind.mjs';
import { resolveMindSpaceStorageRoot } from './mindspace-runtime-config.mjs';
import { assertNoProhibitedBrowserStorage } from './mindspace-browser-storage-policy.mjs';

const SANDBOX_ROOT = process.argv[2]?.trim() || process.env.SANDBOX_ROOT?.trim();
if (!SANDBOX_ROOT) {
  process.stderr.write('[mindspace-sandbox-mcp] SANDBOX_ROOT is not set — refusing to start\n');
  process.exit(1);
}

const SANDBOX = path.resolve(SANDBOX_ROOT);
const SANDBOX_MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
const PRIVATE_DATA_DIR = path.join(SANDBOX, '.mindspace');
const SQLITE_BIN = process.env.SQLITE_BIN?.trim() || 'sqlite3';
const PRIVATE_DATA_MAX_BYTES = Number(process.env.PRIVATE_DATA_MAX_BYTES ?? 20 * 1024 * 1024);
const PRIVATE_DATA_QUERY_TIMEOUT_MS = Number(process.env.PRIVATE_DATA_QUERY_TIMEOUT_MS ?? 5000);
const PRIVATE_DATA_MAX_ROWS = Number(process.env.PRIVATE_DATA_MAX_ROWS ?? 200);
const PRIVATE_DATA_USER_ID = process.env.PRIVATE_DATA_USER_ID?.trim();

const allowedToolsEnv = process.env.ALLOWED_TOOLS?.trim();
const ALLOWED_TOOLS = allowedToolsEnv ? new Set(allowedToolsEnv.split(',').map((s) => s.trim())) : null;

/** Resolve and validate that the path is inside SANDBOX. Returns absolute path. */
function resolveSandboxed(p) {
  if (!p || typeof p !== 'string') throw new Error('路径参数无效');
  const resolved = path.isAbsolute(p) ? path.resolve(p) : path.resolve(SANDBOX, p);
  if (resolved !== SANDBOX && !resolved.startsWith(SANDBOX + path.sep)) {
    throw Object.assign(new Error(`路径越界：${p} 不在当前工作区内`), { code: 'EACCES' });
  }
  if (resolved === PRIVATE_DATA_DIR || resolved.startsWith(PRIVATE_DATA_DIR + path.sep)) {
    throw Object.assign(new Error('禁止直接访问私有数据目录，请使用 private_data_* 工具'), { code: 'EACCES' });
  }
  return resolved;
}

function resolveDocxGenerateScript() {
  const candidates = [
    path.join(SANDBOX, '.agents', 'skills', 'docx-generate', 'generate_docx.py'),
    path.join(SANDBOX_MODULE_DIR, 'skills', 'docx-generate', 'generate_docx.py'),
  ];
  for (const candidate of candidates) {
    if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
      return candidate;
    }
  }
  throw new Error(
    'generate_docx: 未找到 generate_docx.py，请先 load_skill → docx-generate 同步技能到工作区',
  );
}

function normalizeDocxSections(sections) {
  if (!Array.isArray(sections) || sections.length === 0) {
    throw new Error('generate_docx: sections 必须是非空数组');
  }
  return sections.map((section, index) => {
    if (!section || typeof section !== 'object') {
      throw new Error(`generate_docx: sections[${index}] 必须是对象`);
    }
    const normalized = {
      heading: section.heading != null ? String(section.heading) : '',
      paragraphs: Array.isArray(section.paragraphs)
        ? section.paragraphs.map((paragraph) => String(paragraph))
        : [],
    };
    if (section.table && typeof section.table === 'object') {
      normalized.table = section.table;
    }
    return normalized;
  });
}

function runGenerateDocxScript({ outputPath, title, sections }) {
  const script = resolveDocxGenerateScript();
  const python = process.env.PYTHON_BIN?.trim() || 'python3';
  const payload = JSON.stringify({
    title: String(title ?? ''),
    sections: normalizeDocxSections(sections),
  });
  const stdout = execFileSync(
    python,
    [script, '--json', '-', '--output', outputPath],
    {
      cwd: SANDBOX,
      input: payload,
      encoding: 'utf8',
      maxBuffer: 10 * 1024 * 1024,
    },
  );
  const abs = resolveSandboxed(outputPath);
  if (!fs.existsSync(abs) || !fs.statSync(abs).isFile()) {
    throw new Error(`generate_docx: 脚本执行后未找到 ${outputPath}`);
  }
  const size = fs.statSync(abs).size;
  if (size < 64) {
    throw new Error(`generate_docx: ${outputPath} 体积异常（${size} 字节）`);
  }
  return { bytes: size, stdout: String(stdout ?? '').trim() };
}

const ALL_TOOLS = [
  {
    name: 'read_file',
    description: '读取文件内容（仅限工作区内的文件）',
    inputSchema: {
      type: 'object',
      properties: {
        path: { type: 'string', description: '文件路径（相对工作区或绝对路径）' },
      },
      required: ['path'],
    },
  },
  {
    name: 'write_file',
    description: '写入文件内容（仅限工作区内的文件；不存在则创建，已存在则覆盖）',
    inputSchema: {
      type: 'object',
      properties: {
        path: { type: 'string', description: '文件路径' },
        content: { type: 'string', description: '文件内容' },
      },
      required: ['path', 'content'],
    },
  },
  {
    name: 'edit_file',
    description: '将文件中的旧内容替换为新内容（仅限工作区内的文件）',
    inputSchema: {
      type: 'object',
      properties: {
        path: { type: 'string', description: '文件路径' },
        old_str: { type: 'string', description: '要替换的原始内容（必须在文件中唯一）' },
        new_str: { type: 'string', description: '替换后的新内容' },
      },
      required: ['path', 'old_str', 'new_str'],
    },
  },
  {
    name: 'list_dir',
    description: '列出目录内容（仅限工作区内的目录）',
    inputSchema: {
      type: 'object',
      properties: {
        path: {
          type: 'string',
          description: '目录路径（省略则列出工作区根目录）',
        },
      },
    },
  },
  {
    name: 'create_dir',
    description: '创建目录（仅限工作区内；已存在不报错）',
    inputSchema: {
      type: 'object',
      properties: {
        path: { type: 'string', description: '目录路径' },
      },
      required: ['path'],
    },
  },
  {
    name: 'generate_long_image',
    description:
      '用 Playwright 将工作区内的 HTML 页面渲染为整页 PNG 长图。输出文件通常为 public/<页面名>.long.png，必须在工作区内。',
    inputSchema: {
      type: 'object',
      properties: {
        html_path: { type: 'string', description: 'HTML 文件路径，如 public/report.html' },
        output_path: { type: 'string', description: '输出 PNG 路径，如 public/report.long.png；可选' },
      },
      required: ['html_path'],
    },
  },
  {
    name: 'generate_docx',
    description:
      '生成 Word .docx 文件并落盘到工作区（如 public/报告.docx）。公网下载页必须先调用本工具确认文件存在，再写 HTML 相对链接。',
    inputSchema: {
      type: 'object',
      properties: {
        output_path: { type: 'string', description: '输出 .docx 路径，如 public/协和智慧门诊研究摘要.docx' },
        title: { type: 'string', description: '文档主标题' },
        sections: {
          type: 'array',
          description: '章节数组；每项可含 heading、paragraphs、可选 table(headers/rows)',
          items: { type: 'object' },
        },
      },
      required: ['output_path', 'title', 'sections'],
    },
  },
  {
    name: 'private_data_info',
    description:
      '查看当前用户“用户私有数据空间”的状态。每个用户只有一个由平台分配和隔离的数据空间，适合保存问卷、表单、清单、调研数据和分析中间表；不要创建额外数据库文件。',
    inputSchema: { type: 'object', properties: {} },
  },
  {
    name: 'private_data_schema',
    description:
      '查看用户私有数据空间中的表和字段。用于了解当前用户自己的 SQLite 表结构。',
    inputSchema: { type: 'object', properties: {} },
  },
  {
    name: 'private_data_query',
    description:
      '只读查询用户私有数据空间。仅允许 SELECT/WITH，默认最多返回 200 行，适合统计问卷回答、筛选表单数据、分析用户私有数据。',
    inputSchema: {
      type: 'object',
      properties: {
        sql: { type: 'string', description: '只读 SQL，必须是 SELECT/WITH' },
      },
      required: ['sql'],
    },
  },
  {
    name: 'private_data_execute',
    description:
      '写入或变更用户私有数据空间。可用于创建问卷/表单/清单等私有表并写入数据；禁止 ATTACH、load_extension、PRAGMA writable_schema、VACUUM INTO 等越界或危险操作。',
    inputSchema: {
      type: 'object',
      properties: {
        sql: { type: 'string', description: '要执行的 SQLite SQL' },
      },
      required: ['sql'],
    },
  },
  {
    name: 'private_data_register_dataset',
    description:
      '注册或更新页面可访问的 dataset。Agent 建表后应注册 dataset，供 HTML 页面通过 Page Data API 受控读写。',
    inputSchema: {
      type: 'object',
      properties: {
        name: { type: 'string', description: 'dataset 名称，例如 registrations' },
        table: { type: 'string', description: '映射的 SQLite 表名' },
        description: { type: 'string', description: 'dataset 说明，可选' },
        actions: {
          type: 'array',
          items: { type: 'string' },
          description: '允许动作，例如 read、insert、update、soft_delete',
        },
        columns: {
          type: 'object',
          description: '各动作允许的字段白名单，例如 { read: ["id","name"], insert: ["name"] }',
        },
        limits: {
          type: 'object',
          description: '限制，例如 { maxRowsPerRead: 100, maxInsertBytes: 8192 }',
        },
      },
      required: ['name', 'table', 'actions', 'columns'],
    },
  },
  {
    name: 'private_data_set_page_policy',
    description:
      '为已发布页面配置 Page Data 访问策略。策略保存在工作区 .mindspace/page-data-policies/ 下，供公开页面通过 Page Data API 受控读写。',
    inputSchema: {
      type: 'object',
      properties: {
        pageId: { type: 'string', description: '页面 ID（h5_page_records.id）' },
        ownerUserId: { type: 'string', description: '页面 owner 用户 ID，可选，默认当前会话用户' },
        accessMode: {
          type: 'string',
          description: '访问模式：public、password、login_required',
        },
        datasets: {
          type: 'object',
          description:
            'dataset 授权，例如 { registrations: { insert: true, columns: { insert: ["name","phone"] }, rowPolicy: { scope: "own_rows" } } }',
        },
        defaultVisitorRole: {
          type: 'string',
          description: 'login_required 模式下未列名访问者的默认角色：deny、viewer、editor',
        },
        visitors: {
          type: 'object',
          description: '访问者角色映射，例如 { "user-2": "editor", "user-3": "viewer" }',
        },
        roles: {
          type: 'object',
          description: '可选角色权限覆盖，例如 { viewer: { read: true, insert: false } }',
        },
      },
      required: ['pageId', 'accessMode', 'datasets'],
    },
  },
  {
    name: 'private_data_close_page_dataset',
    description:
      '关闭已发布页面的某个 dataset 公开访问能力。写入策略文件并将 read/insert/update/delete 全部关闭。',
    inputSchema: {
      type: 'object',
      properties: {
        pageId: { type: 'string', description: '页面 ID' },
        dataset: { type: 'string', description: '要关闭的 dataset 名称' },
        ownerUserId: { type: 'string', description: '页面 owner 用户 ID，可选，默认当前会话用户' },
      },
      required: ['pageId', 'dataset'],
    },
  },
  {
    name: 'private_data_bind_workspace_page',
    description:
      '将工作区 public/*.html 绑定为 MindSpace 页面记录、发布并配置 Page Data 策略。返回 pageId 与可访问 URL，HTML 无需手写 pageId。',
    inputSchema: {
      type: 'object',
      properties: {
        relativePath: {
          type: 'string',
          description: '工作区相对路径，例如 public/survey.html',
        },
        title: { type: 'string', description: '页面标题，可选，默认从 HTML <title> 读取' },
        accessMode: {
          type: 'string',
          description:
            '发布访问模式：public、password、login_required；纯静态页默认 public，含 Page Data datasets 时默认 password',
        },
        password: {
          type: 'string',
          description:
            '口令访问密码，accessMode=password 时可选；未提供则默认 88888888（至少 8 位）',
        },
        urlSlug: { type: 'string', description: '发布 URL slug，可选' },
        datasets: {
          type: 'object',
          description:
            'Page Data dataset 授权，例如 { survey_responses: { insert: true, read: true, columns: { insert: ["name"], read: ["id","name"] } } }',
        },
      },
      required: ['relativePath'],
    },
  },
];

let quotaPool = null;
let scheduleService = null;
let userDataSpaceService = null;

function isQuotaSyncConfigured() {
  return Boolean(
    PRIVATE_DATA_USER_ID &&
      (process.env.DATABASE_URL ||
        (process.env.MYSQL_HOST && process.env.MYSQL_DATABASE)),
  );
}

function getQuotaPool() {
  if (!isQuotaSyncConfigured()) return null;
  if (quotaPool) return quotaPool;
  quotaPool = process.env.DATABASE_URL
    ? mysql.createPool(process.env.DATABASE_URL)
    : mysql.createPool({
        host: process.env.MYSQL_HOST ?? 'localhost',
        port: Number(process.env.MYSQL_PORT ?? 3306),
        user: process.env.MYSQL_USER ?? 'boot',
        password: process.env.MYSQL_PASSWORD ?? '',
        database: process.env.MYSQL_DATABASE ?? 'tkmind',
        waitForConnections: true,
        connectionLimit: 2,
      });
  return quotaPool;
}

function isScheduleConfigured() {
  return isQuotaSyncConfigured();
}

function getScheduleService() {
  if (!PRIVATE_DATA_USER_ID) throw new Error('当前会话没有用户上下文，不能操作待办');
  const pool = getQuotaPool();
  if (!pool || !isScheduleConfigured()) {
    throw new Error('当前环境未配置待办数据库连接');
  }
  if (!scheduleService) {
    scheduleService = createScheduleService(pool, {
      defaultTimezone: process.env.H5_DEFAULT_TIMEZONE || 'Asia/Shanghai',
    });
  }
  return scheduleService;
}

if (isScheduleConfigured()) {
  ALL_TOOLS.push(
    {
      name: 'schedule_create_item',
      description:
        '为当前用户创建待办或日程事项。仅写入当前用户自己的 h5_schedule_items，不可操作其他用户数据。',
      inputSchema: {
        type: 'object',
        properties: {
          kind: { type: 'string', description: 'task 或 event，默认 task' },
          title: { type: 'string', description: '事项标题' },
          description: { type: 'string', description: '事项描述，可选' },
          startAt: { type: 'number', description: '开始时间 Unix 毫秒时间戳，可选（优先使用 startLocal）' },
          startLocal: { type: 'string', description: '本地开始时间 YYYY-MM-DD HH:mm，推荐' },
          endAt: { type: 'number', description: '结束时间 Unix 毫秒时间戳，可选（优先使用 endLocal）' },
          endLocal: { type: 'string', description: '本地结束时间 YYYY-MM-DD HH:mm，推荐' },
          dueAt: { type: 'number', description: '截止时间 Unix 毫秒时间戳，可选（优先使用 dueLocal）' },
          dueLocal: { type: 'string', description: '本地截止时间 YYYY-MM-DD HH:mm，可选' },
          allDay: { type: 'boolean', description: '是否全天事项，可选' },
          timezone: { type: 'string', description: '时区，可选' },
          location: { type: 'string', description: '地点，可选' },
          sourceMessageId: { type: 'string', description: '服务号消息 ID；有值时必须原样传入' },
          sourceText: { type: 'string', description: '原始用户文本，可选' },
          remindAt: { type: 'number', description: '提醒触发时间 Unix 毫秒时间戳，可选（优先使用 remindLocal）' },
          remindLocal: { type: 'string', description: '本地提醒时间 YYYY-MM-DD HH:mm；需要到点提醒时推荐与 startLocal 同传' },
          offsetMinutes: { type: 'number', description: '相对事项时间的提前分钟数，可选' },
          channel: { type: 'string', description: '提醒通道，默认 wechat，可选' },
          noReminder: { type: 'boolean', description: '明确只记事项、不创建到点提醒时传 true' },
        },
        required: ['title'],
      },
    },
    {
      name: 'schedule_create_reminder',
      description:
        '为当前用户已有事项创建单次提醒。必须先有 itemId，再写入 h5_schedule_reminders。',
      inputSchema: {
        type: 'object',
        properties: {
          itemId: { type: 'string', description: '事项 ID' },
          remindAt: { type: 'number', description: '提醒触发时间 Unix 毫秒时间戳（优先使用 remindLocal）' },
          remindLocal: { type: 'string', description: '本地提醒时间 YYYY-MM-DD HH:mm，推荐' },
          offsetMinutes: { type: 'number', description: '相对事项时间的提前分钟数，可选' },
          channel: { type: 'string', description: '提醒通道，默认 wechat' },
        },
        required: ['itemId'],
      },
    },
    {
      name: 'schedule_list_items',
      description:
        '查询当前用户的待办/日程事项列表。仅返回当前用户数据，可按时间范围过滤。',
      inputSchema: {
        type: 'object',
        properties: {
          from: { type: 'number', description: '起始时间 Unix 毫秒时间戳，可选' },
          to: { type: 'number', description: '结束时间 Unix 毫秒时间戳，可选' },
          status: { type: 'string', description: '事项状态，默认 active，可选' },
          limit: { type: 'number', description: '返回数量，默认 50，可选' },
        },
      },
    },
  );
}

const TOOLS = ALLOWED_TOOLS ? ALL_TOOLS.filter((t) => ALLOWED_TOOLS.has(t.name)) : ALL_TOOLS;

function getUserDataSpaceService() {
  if (!userDataSpaceService) {
    userDataSpaceService = createUserDataSpaceService({
      workspaceRoot: SANDBOX,
      userId: PRIVATE_DATA_USER_ID || null,
      query: getQuotaPool(),
      sqliteBin: SQLITE_BIN,
      maxBytes: PRIVATE_DATA_MAX_BYTES,
      queryTimeoutMs: PRIVATE_DATA_QUERY_TIMEOUT_MS,
      maxRows: PRIVATE_DATA_MAX_ROWS,
    });
  }
  return userDataSpaceService;
}

function resolveH5RootFromSandbox() {
  const parent = path.basename(path.dirname(SANDBOX));
  if (parent === 'MindSpace') return path.dirname(path.dirname(SANDBOX));
  return SANDBOX_MODULE_DIR;
}

async function callTool(name, args) {
  if (ALLOWED_TOOLS && !ALLOWED_TOOLS.has(name)) {
    throw new Error(`工具 ${name} 未授权`);
  }
  switch (name) {
    case 'read_file': {
      const abs = resolveSandboxed(args.path);
      const content = fs.readFileSync(abs, 'utf8');
      return [{ type: 'text', text: content }];
    }
    case 'write_file': {
      const abs = resolveSandboxed(args.path);
      assertNoProhibitedBrowserStorage(args.content ?? '', { relativePath: args.path });
      fs.mkdirSync(path.dirname(abs), { recursive: true });
      fs.writeFileSync(abs, args.content ?? '', 'utf8');
      return [{ type: 'text', text: `已写入 ${args.path}（${(args.content ?? '').length} 字节）` }];
    }
    case 'edit_file': {
      const abs = resolveSandboxed(args.path);
      const original = fs.readFileSync(abs, 'utf8');
      const oldStr = args.old_str ?? '';
      if (oldStr && !original.includes(oldStr)) {
        throw new Error('edit_file: old_str 在文件中不存在，替换失败');
      }
      const updated = oldStr ? original.replace(oldStr, args.new_str ?? '') : (args.new_str ?? '');
      assertNoProhibitedBrowserStorage(updated, { relativePath: args.path });
      fs.writeFileSync(abs, updated, 'utf8');
      return [{ type: 'text', text: `已编辑 ${args.path}` }];
    }
    case 'list_dir': {
      const target = args?.path ?? '.';
      const abs = resolveSandboxed(target);
      const entries = fs.readdirSync(abs, { withFileTypes: true });
      const lines = entries.map((e) => `${e.isDirectory() ? '[目录]' : '[文件]'} ${e.name}`);
      return [{ type: 'text', text: lines.join('\n') || '（空目录）' }];
    }
    case 'create_dir': {
      const abs = resolveSandboxed(args.path);
      fs.mkdirSync(abs, { recursive: true });
      return [{ type: 'text', text: `已创建目录 ${args.path}` }];
    }
    case 'generate_long_image': {
      const htmlPath = String(args.html_path ?? args.path ?? '').trim();
      if (!htmlPath.toLowerCase().endsWith('.html')) {
        throw new Error('generate_long_image: html_path 必须是 .html 文件');
      }
      const htmlAbs = resolveSandboxed(htmlPath);
      const outputPath = String(args.output_path ?? '').trim() || htmlPath.replace(/\.html$/i, '.long.png');
      if (!outputPath.toLowerCase().endsWith('.png')) {
        throw new Error('generate_long_image: output_path 必须是 .png 文件');
      }
      const outputAbs = resolveSandboxed(outputPath);
      const result = await renderLongImage({ htmlPath: htmlAbs, outputPath: outputAbs });
      return [
        {
          type: 'text',
          text: `已生成长图 ${outputPath}（${result.bytes} 字节）`,
        },
      ];
    }
    case 'generate_docx': {
      const outputPath = String(args.output_path ?? args.path ?? '').trim();
      if (!outputPath.toLowerCase().endsWith('.docx')) {
        throw new Error('generate_docx: output_path 必须是 .docx 文件');
      }
      resolveSandboxed(outputPath);
      const title = String(args.title ?? '').trim();
      if (!title) {
        throw new Error('generate_docx: title 不能为空');
      }
      const sections = args.sections ?? args.payload?.sections;
      const result = runGenerateDocxScript({ outputPath, title, sections });
      return [
        {
          type: 'text',
          text: `已生成 ${outputPath}（${result.bytes} 字节）`,
        },
      ];
    }
    case 'private_data_info': {
      const info = await getUserDataSpaceService().getInfo();
      return [
        {
          type: 'text',
          text: JSON.stringify(
            {
              ...info,
              rules: [
                info.backend === 'postgres'
                  ? '每个用户只能使用新 PG 中分配给自己的独立 schema'
                  : '每个用户只能使用这个唯一 SQLite 数据库',
                '适合问卷、表单、清单、调研数据和分析中间表',
                '不要存账号、计费、权限、审计、公开平台数据或跨用户数据',
                'HTML 页面通过 Page Data API 访问 dataset，不要直接暴露 SQL',
              ],
            },
            null,
            2,
          ),
        },
      ];
    }
    case 'private_data_schema': {
      const schema = await getUserDataSpaceService().getSchema();
      return [{ type: 'text', text: JSON.stringify(schema, null, 2) }];
    }
    case 'private_data_query': {
      const rows = await getUserDataSpaceService().querySql(args.sql);
      return [{ type: 'text', text: JSON.stringify(rows, null, 2) }];
    }
    case 'private_data_execute': {
      const result = await getUserDataSpaceService().executeSql(args.sql);
      return [
        {
          type: 'text',
          text: result.backend === 'postgres'
            ? `已在用户专属 PG schema 中执行。命令 ${result.command ?? 'OK'}，影响 ${result.affectedRows ?? 0} 行`
            : `已执行。当前数据空间大小 ${result.sizeBytes} 字节${result.quotaSynced ? `，已同步空间占用 ${result.deltaBytes} 字节` : ''}`,
        },
      ];
    }
    case 'private_data_register_dataset': {
      const dataset = await getUserDataSpaceService().upsertDataset({
        name: args.name,
        table: args.table,
        description: args.description,
        actions: args.actions,
        columns: args.columns,
        limits: args.limits,
      });
      return [{ type: 'text', text: JSON.stringify(dataset, null, 2) }];
    }
    case 'private_data_set_page_policy': {
      const ownerUserId = String(args.ownerUserId ?? PRIVATE_DATA_USER_ID ?? '').trim();
      if (!ownerUserId) throw new Error('缺少 ownerUserId，无法保存页面数据策略');
      const policy = normalizePageAccessPolicy(
        {
          pageId: args.pageId,
          ownerUserId,
          accessMode: args.accessMode,
          datasets: args.datasets,
          defaultVisitorRole: args.defaultVisitorRole,
          visitors: args.visitors,
          roles: args.roles,
        },
        { fallbackPageId: args.pageId, fallbackOwnerUserId: ownerUserId },
      );
      const saved = writePageAccessPolicy(SANDBOX, policy);
      if (isQuotaSyncConfigured()) {
        await upsertPageDataPolicyIndex(getQuotaPool(), saved).catch(() => null);
      }
      return [{ type: 'text', text: JSON.stringify(saved, null, 2) }];
    }
    case 'private_data_close_page_dataset': {
      const ownerUserId = String(args.ownerUserId ?? PRIVATE_DATA_USER_ID ?? '').trim();
      if (!ownerUserId) throw new Error('缺少 ownerUserId，无法关闭 dataset');
      const policy = readPageAccessPolicy(SANDBOX, args.pageId);
      if (!policy) throw new Error('页面数据策略不存在');
      if (policy.ownerUserId !== ownerUserId) throw new Error('无权关闭该页面 dataset');
      const closed = closePolicyDataset(policy, args.dataset);
      const saved = writePageAccessPolicy(SANDBOX, closed);
      if (isQuotaSyncConfigured()) {
        await upsertPageDataPolicyIndex(getQuotaPool(), saved).catch(() => null);
      }
      return [{ type: 'text', text: JSON.stringify(saved.datasets[args.dataset], null, 2) }];
    }
    case 'private_data_bind_workspace_page': {
      const ownerUserId = String(PRIVATE_DATA_USER_ID ?? '').trim();
      if (!ownerUserId) throw new Error('缺少用户上下文，无法绑定页面');
      const pool = getQuotaPool();
      if (!pool) throw new Error('当前环境未配置数据库，无法绑定页面');
      const hasDatasets =
        args.datasets != null &&
        typeof args.datasets === 'object' &&
        Object.keys(args.datasets).length > 0;
      const accessMode =
        String(args.accessMode ?? (hasDatasets ? 'password' : 'public')).trim() ||
        (hasDatasets ? 'password' : 'public');
      const h5Root = resolveH5RootFromSandbox();
      const storageRoot = resolveMindSpaceStorageRoot(h5Root);
      const result = await bindWorkspaceHtmlForPageData({
        pool,
        h5Root,
        storageRoot,
        userId: ownerUserId,
        workspaceRoot: SANDBOX,
        relativePath: args.relativePath,
        title: args.title,
        accessMode,
        password: args.password,
        urlSlug: args.urlSlug,
        pageDataPolicy: hasDatasets
          ? {
              ownerUserId,
              accessMode,
              datasets: args.datasets,
            }
          : null,
      });
      return [
        {
          type: 'text',
          text: JSON.stringify(
            {
              ...result,
              userDeliveryNote:
                '向用户交付链接时优先使用 deliveryUrl / workspaceUrl（MindSpace 路径），不要用 publicationUrl',
            },
            null,
            2,
          ),
        },
      ];
    }
    case 'schedule_create_item': {
      const timezone = args.timezone ?? process.env.H5_DEFAULT_TIMEZONE ?? 'Asia/Shanghai';
      const startAt = resolveScheduleTimestamp({
        epochMs: args.startAt,
        localString: args.startLocal,
        timezone,
        fieldName: '开始时间',
      });
      const endAt = resolveScheduleTimestamp({
        epochMs: args.endAt,
        localString: args.endLocal,
        timezone,
        fieldName: '结束时间',
      });
      const dueAt = resolveScheduleTimestamp({
        epochMs: args.dueAt,
        localString: args.dueLocal,
        timezone,
        fieldName: '截止时间',
      });
      const item = await getScheduleService().createItem({
        userId: PRIVATE_DATA_USER_ID,
        kind: args.kind,
        title: args.title,
        description: args.description ?? null,
        startAt,
        endAt,
        dueAt,
        allDay: Boolean(args.allDay),
        timezone,
        location: args.location ?? null,
        sourceChannel: 'agent',
        sourceMessageId: args.sourceMessageId ?? null,
        sourceText: args.sourceText ?? null,
        metadata: { source: 'schedule_assistant_skill' },
      });
      let remindAt = resolveScheduleTimestamp({
        epochMs: args.remindAt,
        localString: args.remindLocal,
        timezone,
        fieldName: '提醒时间',
      });
      if (
        remindAt == null
        && shouldAutoCreateReminderAtStart({
          title: args.title,
          description: args.description,
          startAt,
          noReminder: Boolean(args.noReminder),
        })
      ) {
        remindAt = startAt;
      }
      if (remindAt != null) {
        const reminder = await getScheduleService().createReminder({
          userId: PRIVATE_DATA_USER_ID,
          itemId: item.id,
          remindAt,
          offsetMinutes: args.offsetMinutes ?? null,
          channel: args.channel ?? 'wechat',
        });
        return [{ type: 'text', text: JSON.stringify({ item, reminder }, null, 2) }];
      }
      return [{ type: 'text', text: JSON.stringify(item, null, 2) }];
    }
    case 'schedule_create_reminder': {
      const timezone = args.timezone ?? process.env.H5_DEFAULT_TIMEZONE ?? 'Asia/Shanghai';
      const remindAt = resolveScheduleTimestamp({
        epochMs: args.remindAt,
        localString: args.remindLocal,
        timezone,
        fieldName: '提醒时间',
      });
      if (remindAt == null) throw new Error('缺少提醒时间 remindLocal 或 remindAt');
      const reminder = await getScheduleService().createReminder({
        userId: PRIVATE_DATA_USER_ID,
        itemId: args.itemId,
        remindAt,
        offsetMinutes: args.offsetMinutes ?? null,
        channel: args.channel ?? 'wechat',
      });
      return [{ type: 'text', text: JSON.stringify(reminder, null, 2) }];
    }
    case 'schedule_list_items': {
      const items = await getScheduleService().listItems({
        userId: PRIVATE_DATA_USER_ID,
        from: args.from ?? null,
        to: args.to ?? null,
        status: args.status ?? 'active',
        limit: args.limit ?? 50,
      });
      return [{ type: 'text', text: JSON.stringify(items, null, 2) }];
    }
    default:
      throw new Error(`未知工具：${name}`);
  }
}

// ── JSON-RPC over stdio ────────────────────────────────────────────────────

function send(obj) {
  process.stdout.write(JSON.stringify(obj) + '\n');
}

function respond(id, result) {
  send({ jsonrpc: '2.0', id, result });
}

function respondError(id, message, code = -32603) {
  send({ jsonrpc: '2.0', id, error: { code, message } });
}

const rl = readline.createInterface({ input: process.stdin, terminal: false });

rl.on('line', async (raw) => {
  const line = raw.trim();
  if (!line) return;

  let msg;
  try {
    msg = JSON.parse(line);
  } catch {
    process.stderr.write(`[mindspace-sandbox-mcp] invalid JSON: ${line}\n`);
    return;
  }

  const { id, method, params } = msg;

  switch (method) {
    case 'initialize':
      respond(id, {
        protocolVersion: '2024-11-05',
        serverInfo: { name: 'mindspace-sandbox', version: '1.0.0' },
        capabilities: { tools: {} },
      });
      break;

    case 'initialized':
      // notification — no response
      break;

    case 'tools/list':
      respond(id, { tools: TOOLS });
      break;

    case 'tools/call': {
      const { name, arguments: toolArgs } = params ?? {};
      try {
        const content = await callTool(name, toolArgs ?? {});
        respond(id, { content, isError: false });
      } catch (err) {
        respond(id, {
          content: [{ type: 'text', text: err.message }],
          isError: true,
        });
      }
      break;
    }

    default:
      if (id !== undefined && id !== null) {
        respondError(id, `Method not found: ${method}`, -32601);
      }
  }
});

rl.on('close', () => process.exit(0));