@tiwater/office-mcp 0.2.0

package/_shared/mcp-stdio.mjs

@@ -0,0 +1,152 @@
+import process from 'node:process';
+
+const JSONRPC_VERSION = '2.0';
+const SUPPORTED_PROTOCOL_VERSIONS = ['2025-06-18', '2025-03-26', '2024-11-05', '2024-10-07'];
+const FALLBACK_PROTOCOL_VERSION = '2025-06-18';
+
+function writeMessage(message) {
+  process.stdout.write(`${JSON.stringify(message)}\n`);
+}
+
+function toError(code, message, data) {
+  return { code, message, ...(data === undefined ? {} : { data }) };
+}
+
+function normalizeToolCallError(error) {
+  if (!error) return toError(-32603, 'Unknown error');
+  if (error.code && error.message) return error;
+  return toError(-32603, error instanceof Error ? error.message : String(error));
+}
+
+export class McpStdioServer {
+  constructor({ name, version, instructions, tools, callTool, logger = console.error }) {
+    this.serverInfo = { name, version };
+    this.instructions = instructions;
+    this.tools = tools;
+    this.callTool = callTool;
+    this.logger = logger;
+    this.lineBuffer = '';
+    this.binaryBuffer = Buffer.alloc(0);
+    this.initialized = false;
+  }
+
+  start() {
+    process.stdin.on('data', chunk => this.#onData(chunk));
+    process.stdin.on('end', () => process.exit(0));
+  }
+
+  #onData(chunk) {
+    const text = chunk.toString('utf8');
+
+    if (this.binaryBuffer.length > 0 || text.includes('Content-Length:')) {
+      this.binaryBuffer = Buffer.concat([this.binaryBuffer, chunk]);
+      this.#drainContentLengthBuffer();
+      return;
+    }
+
+    this.lineBuffer += text;
+    while (true) {
+      const newlineIndex = this.lineBuffer.indexOf('\n');
+      if (newlineIndex === -1) return;
+      const line = this.lineBuffer.slice(0, newlineIndex).replace(/\r$/, '').trim();
+      this.lineBuffer = this.lineBuffer.slice(newlineIndex + 1);
+      if (!line) continue;
+      this.#parseAndHandle(line, null);
+    }
+  }
+
+  #drainContentLengthBuffer() {
+    while (true) {
+      const headerEnd = this.binaryBuffer.indexOf('\r\n\r\n');
+      if (headerEnd === -1) return;
+
+      const headerText = this.binaryBuffer.subarray(0, headerEnd).toString('utf8');
+      const lengthMatch = headerText.match(/Content-Length:\s*(\d+)/i);
+      if (!lengthMatch) {
+        this.logger('Missing Content-Length header');
+        this.binaryBuffer = Buffer.alloc(0);
+        return;
+      }
+
+      const contentLength = Number(lengthMatch[1]);
+      const messageStart = headerEnd + 4;
+      const messageEnd = messageStart + contentLength;
+      if (this.binaryBuffer.length < messageEnd) return;
+
+      const body = this.binaryBuffer.subarray(messageStart, messageEnd).toString('utf8');
+      this.binaryBuffer = this.binaryBuffer.subarray(messageEnd);
+      this.#parseAndHandle(body, null);
+    }
+  }
+
+  #parseAndHandle(body, idHint) {
+    let message;
+    try {
+      message = JSON.parse(body);
+    } catch (error) {
+      writeMessage({ jsonrpc: JSONRPC_VERSION, id: idHint, error: toError(-32700, 'Parse error', String(error)) });
+      return;
+    }
+
+    void this.#handleMessage(message);
+  }
+
+  async #handleMessage(message) {
+    if (!message || message.jsonrpc !== JSONRPC_VERSION || typeof message.method !== 'string') {
+      if ('id' in (message || {})) {
+        writeMessage({ jsonrpc: JSONRPC_VERSION, id: message.id ?? null, error: toError(-32600, 'Invalid Request') });
+      }
+      return;
+    }
+
+    const { id, method, params = {} } = message;
+    const isNotification = id === undefined;
+
+    try {
+      switch (method) {
+        case 'initialize': {
+          const requested = params.protocolVersion;
+          const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.includes(requested) ? requested : FALLBACK_PROTOCOL_VERSION;
+          const result = {
+            protocolVersion,
+            capabilities: { tools: {} },
+            serverInfo: this.serverInfo,
+            ...(this.instructions ? { instructions: this.instructions } : {}),
+          };
+          if (!isNotification) writeMessage({ jsonrpc: JSONRPC_VERSION, id, result });
+          return;
+        }
+        case 'notifications/initialized': {
+          this.initialized = true;
+          return;
+        }
+        case 'ping': {
+          if (!isNotification) writeMessage({ jsonrpc: JSONRPC_VERSION, id, result: {} });
+          return;
+        }
+        case 'tools/list': {
+          if (!isNotification) writeMessage({ jsonrpc: JSONRPC_VERSION, id, result: { tools: this.tools } });
+          return;
+        }
+        case 'tools/call': {
+          const name = params?.name;
+          const args = params?.arguments ?? {};
+          if (typeof name !== 'string' || !name) {
+            if (!isNotification) writeMessage({ jsonrpc: JSONRPC_VERSION, id, error: toError(-32602, 'Invalid params: missing tool name') });
+            return;
+          }
+          const result = await this.callTool(name, args);
+          if (!isNotification) writeMessage({ jsonrpc: JSONRPC_VERSION, id, result });
+          return;
+        }
+        default: {
+          if (!isNotification) writeMessage({ jsonrpc: JSONRPC_VERSION, id, error: toError(-32601, `Method not found: ${method}`) });
+        }
+      }
+    } catch (error) {
+      if (!isNotification) {
+        writeMessage({ jsonrpc: JSONRPC_VERSION, id, error: normalizeToolCallError(error) });
+      }
+    }
+  }
+}

package/_shared/tool-runtime.mjs

@@ -0,0 +1,108 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawn } from 'node:child_process';
+
+const sharedDir = path.dirname(fileURLToPath(import.meta.url));
+export const repoRoot = path.resolve(sharedDir, '..', '..');
+
+export function createToolResult(payload) {
+  return {
+    structuredContent: payload,
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify(payload, null, 2),
+      },
+    ],
+  };
+}
+
+export function resolveRepoPath(...segments) {
+  return path.join(repoRoot, ...segments);
+}
+
+export function commandCandidate(command, argsPrefix = [], options = {}) {
+  return { command, argsPrefix, ...options };
+}
+
+export async function runCandidateChain(candidates, args, options = {}) {
+  const errors = [];
+  for (const candidate of candidates) {
+    try {
+      return await runCommand(candidate, args, options);
+    } catch (error) {
+      if (error?.code === 'ENOENT') {
+        errors.push(`${candidate.command}: not found`);
+        continue;
+      }
+      throw error;
+    }
+  }
+  throw new Error(`No runnable command candidate succeeded. ${errors.join('; ')}`);
+}
+
+export async function runJsonCandidateChain(candidates, args, options = {}) {
+  const result = await runCandidateChain(candidates, args, options);
+  const text = result.stdout.trim();
+  if (!text) return { ...result, json: null };
+  try {
+    return { ...result, json: JSON.parse(text) };
+  } catch (error) {
+    throw new Error(`Expected JSON output but received: ${text.slice(0, 300)}${text.length > 300 ? '…' : ''}`);
+  }
+}
+
+export async function withTempJsonFile(data, fn) {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'tiwater-mcp-'));
+  const filePath = path.join(dir, 'payload.json');
+  await fs.writeFile(filePath, JSON.stringify(data, null, 2), 'utf8');
+  try {
+    return await fn(filePath);
+  } finally {
+    await fs.rm(dir, { recursive: true, force: true });
+  }
+}
+
+export async function maybeReadJson(filePath) {
+  const text = await fs.readFile(filePath, 'utf8');
+  return JSON.parse(text);
+}
+
+export function requireString(value, label) {
+  if (typeof value !== 'string' || value.trim() === '') {
+    throw Object.assign(new Error(`${label} must be a non-empty string`), { code: -32602 });
+  }
+  return value;
+}
+
+async function runCommand(candidate, args, options) {
+  const env = { ...process.env, ...(candidate.env || {}), ...(options.env || {}) };
+  const cwd = candidate.cwd || options.cwd || repoRoot;
+  const commandArgs = [...(candidate.argsPrefix || []), ...args];
+
+  return await new Promise((resolve, reject) => {
+    const child = spawn(candidate.command, commandArgs, { cwd, env, stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', chunk => {
+      stdout += chunk.toString();
+    });
+
+    child.stderr.on('data', chunk => {
+      stderr += chunk.toString();
+    });
+
+    child.on('error', reject);
+    child.on('close', code => {
+      const allowedExitCodes = options.allowedExitCodes ?? [0];
+      if (allowedExitCodes.includes(code)) {
+        resolve({ code, stdout, stderr, command: candidate.command, args: commandArgs });
+        return;
+      }
+      reject(new Error(`${candidate.command} ${commandArgs.join(' ')} failed with exit code ${code}\n${stderr || stdout}`));
+    });
+  });
+}

package/office/README.md

@@ -0,0 +1,28 @@
+# office MCP server
+
+Shared stdio MCP server for Office document workflows.
+
+## Tools
+
+- `docx_inspect`
+- `docx_list_migration_choices`
+- `docx_migrate_template`
+- `docx_verify_migration`
+- `docx_compare`
+- `docx_validate_template_transform`
+- `docx_export_json`
+- `xlsx_inspect`
+- `xlsx_export_json`
+- `xlsx_validate`
+- `pptx_inspect`
+- `pptx_inspect_detail`
+- `pptx_export_json`
+
+## Run
+
+Install `@tiwater/office-mcp` together with the runtime versions required by
+the consumer, then run `tiwater-office-mcp` as a stdio MCP server.
+
+The server invokes published `tiwater-docx`, `tiwater-xlsx`, and
+`tiwater-pptx` commands from `PATH`. It does not require a source checkout or
+fall back to local projects.

package/office/index.mjs

@@ -0,0 +1,515 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { McpStdioServer } from '../_shared/mcp-stdio.mjs';
+import {
+  commandCandidate,
+  createToolResult,
+  maybeReadJson,
+  requireString,
+  resolveRepoPath,
+  runCandidateChain,
+  runJsonCandidateChain,
+  withTempJsonFile,
+} from '../_shared/tool-runtime.mjs';
+
+const docxCandidates = [
+  commandCandidate('tiwater-docx'),
+];
+
+const xlsxCandidates = [
+  commandCandidate('tiwater-xlsx'),
+];
+
+const pptxCandidates = [
+  commandCandidate('tiwater-pptx'),
+];
+
+function templateMigrationInputSchema() {
+  return {
+    type: 'object',
+    properties: {
+      source: { type: 'string', description: 'Path to the current source DOCX.' },
+      baseline: { type: 'string', description: 'Path to the selected current baseline DOCX.' },
+      output: { type: 'string', description: 'Path to the migrated output DOCX.' },
+      choices: {
+        type: 'array',
+        description: 'Exactly one business choice for every source id returned by docx_list_migration_choices.',
+        items: {
+          type: 'object',
+          properties: {
+            sourceChoiceId: { type: 'string' },
+            action: {
+              type: 'string',
+              enum: ['place-content', 'keep-template-content', 'keep-template-label', 'select-template-option', 'exclude-source', 'review-source'],
+            },
+            targetChoiceId: { type: 'string', description: 'Required only when the selected action uses a baseline target.' },
+            cardinality: { type: 'string', enum: ['one', 'all'] },
+          },
+          required: ['sourceChoiceId', 'action'],
+          additionalProperties: false,
+        },
+      },
+      templateCleanup: {
+        type: 'array',
+        description: 'Optional baseline-owned placeholders or example rows to clear.',
+        items: {
+          type: 'object',
+          properties: {
+            targetChoiceId: { type: 'string' },
+            scope: { type: 'string', enum: ['cell', 'row'] },
+          },
+          required: ['targetChoiceId', 'scope'],
+          additionalProperties: false,
+        },
+      },
+    },
+    required: ['source', 'baseline', 'output', 'choices'],
+    additionalProperties: false,
+  };
+}
+
+const runtimeIdentitySchema = {
+  type: 'object',
+  properties: {
+    command: { type: 'string' },
+    cwd: { type: 'string' },
+  },
+  required: ['command', 'cwd'],
+  additionalProperties: false,
+};
+
+const migrationChoiceSchema = {
+  type: 'object',
+  properties: {
+    id: { type: 'string' },
+    kind: { type: 'string' },
+    scope: { type: 'string' },
+    text: { type: ['string', 'null'] },
+    count: { type: 'integer' },
+    requiredCardinality: { type: ['string', 'null'] },
+    context: { type: ['object', 'null'] },
+    allowedActions: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['id', 'kind', 'scope', 'text', 'count', 'requiredCardinality', 'context', 'allowedActions'],
+  additionalProperties: false,
+};
+
+const migrationCatalogOutputSchema = {
+  type: 'object',
+  properties: {
+    tool: { const: 'docx_list_migration_choices' },
+    runtime: runtimeIdentitySchema,
+    catalog: {
+      type: 'object',
+      properties: {
+        schema: { type: 'string' },
+        pass: { type: 'boolean' },
+        sourceSha256: { type: 'string' },
+        baselineSha256: { type: 'string' },
+        sources: { type: 'array', items: migrationChoiceSchema },
+        targets: { type: 'array', items: migrationChoiceSchema },
+      },
+      required: ['schema', 'pass', 'sourceSha256', 'baselineSha256', 'sources', 'targets'],
+      additionalProperties: false,
+    },
+  },
+  required: ['tool', 'runtime', 'catalog'],
+  additionalProperties: false,
+};
+
+function migrationReceiptOutputSchema(tool) {
+  return {
+    type: 'object',
+    properties: {
+      tool: { const: tool },
+      runtime: runtimeIdentitySchema,
+      receipt: {
+        type: 'object',
+        properties: {
+          schema: { type: 'string' },
+          toolVersion: { type: 'string' },
+          status: { type: 'string', enum: ['pass', 'review-required', 'failed'] },
+          pass: { type: 'boolean' },
+          reviewRequired: { type: 'boolean' },
+          outputVerified: { type: 'boolean' },
+          output: { type: ['string', 'null'] },
+          plan: { type: ['string', 'null'] },
+          failures: { type: 'array', items: { type: 'object' } },
+        },
+        required: ['schema', 'toolVersion', 'status', 'pass', 'reviewRequired', 'outputVerified', 'output', 'plan', 'failures'],
+        additionalProperties: true,
+      },
+    },
+    required: ['tool', 'runtime', 'receipt'],
+    additionalProperties: false,
+  };
+}
+
+const tools = [
+  {
+    name: 'docx_inspect',
+    description: 'Inspect a DOCX document and return a unified structural report including placeholders, comments, anchors, tables, fields, and formatting metrics.',
+    inputSchema: {
+      type: 'object',
+      properties: { input: { type: 'string', description: 'Absolute or relative path to a .docx file.' } },
+      required: ['input'],
+    },
+  },
+  {
+    name: 'docx_inspect_tables',
+    description: 'Inspect DOCX body tables with row, cell, merge, paragraph alignment, run font, color, underline, and text-fill details.',
+    inputSchema: {
+      type: 'object',
+      properties: { input: { type: 'string', description: 'Absolute or relative path to a .docx file.' } },
+      required: ['input'],
+    },
+  },
+  {
+    name: 'docx_list_migration_choices',
+    description: 'List every current source item that still needs a business choice and the selectable current baseline targets. Returns opaque ids and context; it does not recommend a choice.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        source: { type: 'string', description: 'Path to the current source DOCX.' },
+        baseline: { type: 'string', description: 'Path to the selected current baseline DOCX.' },
+      },
+      required: ['source', 'baseline'],
+      additionalProperties: false,
+    },
+    outputSchema: migrationCatalogOutputSchema,
+  },
+  {
+    name: 'docx_migrate_template',
+    description: 'Migrate a current DOCX into the selected baseline from one complete batch of business choices. Choices reference only opaque ids returned by docx_list_migration_choices; the tool derives all document values, coordinates, plans, and edits.',
+    inputSchema: templateMigrationInputSchema(),
+    outputSchema: migrationReceiptOutputSchema('docx_migrate_template'),
+  },
+  {
+    name: 'docx_verify_migration',
+    description: 'Independently re-resolve the same business choices and verify a migrated DOCX against the current source and baseline. This does not trust the migration receipt.',
+    inputSchema: templateMigrationInputSchema(),
+    outputSchema: migrationReceiptOutputSchema('docx_verify_migration'),
+  },
+  {
+    name: 'docx_compare',
+    description: 'Compare two DOCX files and report package, metric, and style differences.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        baseline: { type: 'string' },
+        updated: { type: 'string' },
+      },
+      required: ['baseline', 'updated'],
+    },
+  },
+  {
+    name: 'docx_validate_template_transform',
+    description: 'Validate whether a source DOCX template and target DOCX template are structurally compatible.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        sourceTemplate: { type: 'string' },
+        targetTemplate: { type: 'string' },
+      },
+      required: ['sourceTemplate', 'targetTemplate'],
+    },
+  },
+  {
+    name: 'docx_export_json',
+    description: 'Export the body content of a DOCX document as structured JSON.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        input: { type: 'string' },
+        output: { type: 'string' },
+      },
+      required: ['input'],
+    },
+  },
+  {
+    name: 'xlsx_inspect',
+    description: 'Inspect an XLSX workbook and return sheet-level metrics, used ranges, formula counts, and merged ranges.',
+    inputSchema: {
+      type: 'object',
+      properties: { input: { type: 'string' } },
+      required: ['input'],
+    },
+  },
+  {
+    name: 'xlsx_export_json',
+    description: 'Export workbook sheet data from XLSX as structured JSON.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        input: { type: 'string' },
+        output: { type: 'string' },
+        resolveMergedCells: { type: 'boolean', description: 'Resolve merged cells to project values' }
+      },
+      required: ['input'],
+    },
+  },
+  {
+    name: 'xlsx_validate',
+    description: 'Validate an XLSX workbook package and return Open XML validation evidence.',
+    inputSchema: {
+      type: 'object',
+      properties: { input: { type: 'string', description: 'Absolute or relative path to a .xlsx file.' } },
+      required: ['input'],
+    },
+  },
+  {
+    name: 'pptx_inspect',
+    description: 'Inspect a PPTX file and return slide metrics and discovered placeholders.',
+    inputSchema: {
+      type: 'object',
+      properties: { input: { type: 'string' } },
+      required: ['input'],
+    },
+  },
+  {
+    name: 'pptx_inspect_detail',
+    description: 'Inspect a PPTX file and return detailed slide, shape, transform, paragraph, and run-format evidence.',
+    inputSchema: {
+      type: 'object',
+      properties: { input: { type: 'string' } },
+      required: ['input'],
+    },
+  },
+  {
+    name: 'pptx_export_json',
+    description: 'Export PPTX slide text and placeholder hints as structured JSON.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        input: { type: 'string' },
+        output: { type: 'string' },
+      },
+      required: ['input'],
+    },
+  },
+];
+
+async function callTool(name, args) {
+  switch (name) {
+    case 'docx_inspect':
+      return createToolResult(await docxInspect(args));
+    case 'docx_inspect_tables':
+      return createToolResult(await docxInspectTables(args));
+    case 'docx_list_migration_choices':
+      return createToolResult(await docxListMigrationChoices(args));
+    case 'docx_migrate_template':
+      return createToolResult(await docxMigrateTemplate(args));
+    case 'docx_verify_migration':
+      return createToolResult(await docxVerifyMigration(args));
+    case 'docx_compare':
+      return createToolResult(await docxCompare(args));
+    case 'docx_validate_template_transform':
+      return createToolResult(await docxValidateTemplateTransform(args));
+    case 'docx_export_json':
+      return createToolResult(await docxExportJson(args));
+    case 'xlsx_inspect':
+      return createToolResult(await xlsxInspect(args));
+    case 'xlsx_export_json':
+      return createToolResult(await xlsxExportJson(args));
+    case 'xlsx_validate':
+      return createToolResult(await xlsxValidate(args));
+    case 'pptx_inspect':
+      return createToolResult(await pptxInspect(args));
+    case 'pptx_inspect_detail':
+      return createToolResult(await pptxInspectDetail(args));
+    case 'pptx_export_json':
+      return createToolResult(await pptxExportJson(args));
+    default:
+      throw Object.assign(new Error(`Unknown tool: ${name}`), { code: -32601 });
+  }
+}
+
+async function docxInspect(args) {
+  const input = requireString(args.input, 'input');
+  const result = await runJsonCandidateChain(docxCandidates, ['inspect', input, '--json']);
+  return { tool: 'docx_inspect', runtime: commandRuntime(result), report: result.json };
+}
+
+async function docxInspectTables(args) {
+  const input = requireString(args.input, 'input');
+  const result = await runJsonCandidateChain(docxCandidates, ['inspect-tables', input, '--json']);
+  return { tool: 'docx_inspect_tables', runtime: commandRuntime(result), report: result.json };
+}
+
+async function docxListMigrationChoices(args) {
+  const source = requireString(args.source, 'source');
+  const baseline = requireString(args.baseline, 'baseline');
+  const result = await runJsonCandidateChain(docxCandidates, ['list-template-migration-choices', source, baseline]);
+  return { tool: 'docx_list_migration_choices', runtime: commandRuntime(result), catalog: result.json };
+}
+
+async function docxMigrateTemplate(args) {
+  return runTemplateMigrationCommand('docx_migrate_template', 'migrate-template', args);
+}
+
+async function docxVerifyMigration(args) {
+  return runTemplateMigrationCommand('docx_verify_migration', 'verify-template-migration', args);
+}
+
+async function runTemplateMigrationCommand(tool, command, args) {
+  const source = requireString(args.source, 'source');
+  const baseline = requireString(args.baseline, 'baseline');
+  const output = requireString(args.output, 'output');
+  if (!Array.isArray(args.choices)) {
+    throw Object.assign(new Error('choices must be an array'), { code: -32602 });
+  }
+  const payload = {
+    schema: 'tiwater.docx.template-migration-business-choices/v1',
+    choices: args.choices,
+    ...(Array.isArray(args.templateCleanup) ? { templateCleanup: args.templateCleanup } : {}),
+  };
+  return withTempJsonFile(payload, async choicesPath => {
+    const result = await runJsonCandidateChain(
+      docxCandidates,
+      [command, source, baseline, choicesPath, output],
+      { allowedExitCodes: [0, 1] });
+    return { tool, runtime: commandRuntime(result), receipt: result.json };
+  });
+}
+
+async function docxCompare(args) {
+  const baseline = requireString(args.baseline, 'baseline');
+  const updated = requireString(args.updated, 'updated');
+  const result = await runJsonCandidateChain(docxCandidates, ['compare', baseline, updated, '--json']);
+  return { tool: 'docx_compare', runtime: commandRuntime(result), report: result.json };
+}
+
+async function docxValidateTemplateTransform(args) {
+  const sourceTemplate = requireString(args.sourceTemplate, 'sourceTemplate');
+  const targetTemplate = requireString(args.targetTemplate, 'targetTemplate');
+  const result = await runJsonCandidateChain(docxCandidates, ['validate-template-transform', sourceTemplate, targetTemplate, '--json']);
+  return { tool: 'docx_validate_template_transform', runtime: commandRuntime(result), report: result.json };
+}
+
+async function docxExportJson(args) {
+  const input = requireString(args.input, 'input');
+  if (args.output) {
+    const output = requireString(args.output, 'output');
+    const result = await runCandidateChain(docxCandidates, ['export-json', input, output]);
+    return { tool: 'docx_export_json', runtime: commandRuntime(result), outputPath: output, document: await maybeReadJson(output) };
+  }
+  const result = await runCandidateChain(docxCandidates, ['export-json', input]);
+  return { tool: 'docx_export_json', runtime: commandRuntime(result), document: JSON.parse(result.stdout) };
+}
+
+async function xlsxInspect(args) {
+  const input = requireString(args.input, 'input');
+  const result = await runJsonCandidateChain(xlsxCandidates, ['inspect', input, '--json']);
+  return { tool: 'xlsx_inspect', runtime: commandRuntime(result), report: result.json };
+}
+
+async function xlsxExportJson(args) {
+  const input = requireString(args.input, 'input');
+  const cmdArgs = ['export-json', input];
+  if (args.resolveMergedCells) {
+    cmdArgs.push('--resolve-merged-cells');
+  }
+  if (args.output) {
+    const output = requireString(args.output, 'output');
+    cmdArgs.push(output);
+    const result = await runCandidateChain(xlsxCandidates, cmdArgs);
+    return { tool: 'xlsx_export_json', runtime: commandRuntime(result), outputPath: output, workbook: await maybeReadJson(output) };
+  }
+  const result = await runCandidateChain(xlsxCandidates, cmdArgs);
+  return { tool: 'xlsx_export_json', runtime: commandRuntime(result), workbook: JSON.parse(result.stdout) };
+}
+
+async function xlsxValidate(args) {
+  const input = requireString(args.input, 'input');
+  const result = await runXlsxValidateCandidateChain(['validate', input]);
+  return { tool: 'xlsx_validate', runtime: commandRuntime(result), result: result.json };
+}
+
+async function pptxInspect(args) {
+  const input = requireString(args.input, 'input');
+  const result = await runJsonCandidateChain(pptxCandidates, ['inspect', input, '--json']);
+  return { tool: 'pptx_inspect', runtime: commandRuntime(result), report: result.json };
+}
+
+async function pptxInspectDetail(args) {
+  const input = requireString(args.input, 'input');
+  const result = await runJsonCandidateChain(pptxCandidates, ['inspect', input, '--json', '--detail']);
+  return { tool: 'pptx_inspect_detail', runtime: commandRuntime(result), report: result.json };
+}
+
+async function pptxExportJson(args) {
+  const input = requireString(args.input, 'input');
+  if (args.output) {
+    const output = requireString(args.output, 'output');
+    const result = await runCandidateChain(pptxCandidates, ['export-json', input, output]);
+    return { tool: 'pptx_export_json', runtime: commandRuntime(result), outputPath: output, document: await maybeReadJson(output) };
+  }
+  const result = await runCandidateChain(pptxCandidates, ['export-json', input]);
+  return { tool: 'pptx_export_json', runtime: commandRuntime(result), document: JSON.parse(result.stdout) };
+}
+
+function commandRuntime(result) {
+  return {
+    command: result.command,
+    cwd: result.cwd || path.dirname(result.command),
+  };
+}
+
+await new McpStdioServer({ name: 'tiwater-office', version: '0.2.0', tools, callTool }).start();
+
+async function runXlsxValidateCandidateChain(args) {
+  const errors = [];
+  for (const candidate of xlsxCandidates) {
+    try {
+      const result = await runValidationCommand(candidate, args);
+      const text = result.stdout.trim();
+      if (!text) return { ...result, json: null };
+      try {
+        return { ...result, json: JSON.parse(text) };
+      } catch {
+        if (result.code !== 0) {
+          errors.push(`${candidate.command}: validate did not return JSON`);
+          continue;
+        }
+        throw new Error(`Expected JSON output but received: ${text.slice(0, 300)}${text.length > 300 ? '…' : ''}`);
+      }
+    } catch (error) {
+      if (error?.code === 'ENOENT') {
+        errors.push(`${candidate.command}: not found`);
+        continue;
+      }
+      throw error;
+    }
+  }
+  throw new Error(`No runnable command candidate succeeded. ${errors.join('; ')}`);
+}
+
+async function runValidationCommand(candidate, args) {
+  const env = { ...process.env, ...(candidate.env || {}) };
+  const cwd = candidate.cwd || resolveRepoPath();
+  const commandArgs = [...(candidate.argsPrefix || []), ...args];
+
+  return await new Promise((resolve, reject) => {
+    const child = spawn(candidate.command, commandArgs, { cwd, env, stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', chunk => {
+      stdout += chunk.toString();
+    });
+
+    child.stderr.on('data', chunk => {
+      stderr += chunk.toString();
+    });
+
+    child.on('error', reject);
+    child.on('close', code => {
+      if (code === 0 || code === 1) {
+        resolve({ code, stdout, stderr, command: candidate.command, args: commandArgs });
+        return;
+      }
+      reject(new Error(`${candidate.command} ${commandArgs.join(' ')} failed with exit code ${code}\n${stderr || stdout}`));
+    });
+  });
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@tiwater/office-mcp",
+  "version": "0.2.0",
+  "description": "Published MCP server for Tiwater Office document capabilities",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tiwater/mcp-servers",
+    "directory": "servers"
+  },
+  "bin": {
+    "tiwater-office-mcp": "office/index.mjs"
+  },
+  "files": [
+    "_shared/*.mjs",
+    "office/index.mjs",
+    "office/README.md"
+  ],
+  "scripts": {
+    "test": "node --test office/*.test.mjs"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}