@livedesk/hub 0.1.40 → 0.1.42

package/src/agents/codex-mcp-server.js

@@ -1,100 +1,100 @@
-import readline from 'node:readline';
-import { AGENT_TOOL_DEFINITIONS } from './agent-tool-registry.js';
-
-const hubUrl = String(process.env.LIVEDESK_AGENT_MCP_URL || '').replace(/\/+$/, '');
-const token = String(process.env.LIVEDESK_AGENT_MCP_TOKEN || '');
-const protocolVersion = '2025-06-18';
-
-const toolDefinitions = AGENT_TOOL_DEFINITIONS.map(tool => ({
-  name: tool.name,
-  description: tool.description,
-  inputSchema: { $schema: 'https://json-schema.org/draft/2020-12/schema', ...tool.inputSchema },
-  annotations: {
-    readOnlyHint: tool.readOnly === true,
-    // Codex exec cannot service an interactive MCP approval prompt. Device
-    // mutations are proposals at this boundary and remain fail-closed behind
-    // LiveDesk's own signed permission policy and Hub approval workflow.
-    destructiveHint: false,
-    idempotentHint: tool.readOnly === true || tool.reversible === true,
-    openWorldHint: false
-  }
-}));
-
-function response(id, result) {
-  process.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', id, result })}\n`);
-}
-
-function errorResponse(id, code, message) {
-  process.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', id, error: { code, message } })}\n`);
-}
-
-async function callHub(name, args) {
-  if (!hubUrl || !token) throw new Error('LiveDesk MCP session is not configured.');
-  const result = await fetch(`${hubUrl}/api/internal/agent-mcp/tool`, {
-    method: 'POST',
-    headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
-    body: JSON.stringify({ name, arguments: args && typeof args === 'object' ? args : {} })
-  });
-  const body = await result.json().catch(() => ({}));
-  if (!result.ok || body.ok !== true) throw new Error(String(body.error || `LiveDesk tool failed (${result.status}).`));
-  return body.result;
-}
-
-async function handle(message) {
-  const id = message?.id;
-  const method = String(message?.method || '');
-  if (!method) return;
-  if (method === 'initialize') {
-    response(id, {
-      protocolVersion,
-      capabilities: { tools: { listChanged: false } },
-      serverInfo: { name: 'livedesk', version: '1.0.0' }
-    });
-    return;
-  }
-  if (method === 'notifications/initialized' || method === 'ping') {
-    if (id !== undefined) response(id, {});
-    return;
-  }
-  if (method === 'tools/list') {
-    response(id, { tools: toolDefinitions });
-    return;
-  }
-  if (method === 'tools/call') {
-    const name = String(message?.params?.name || '');
-    if (!toolDefinitions.some(tool => tool.name === name)) {
-      errorResponse(id, -32602, 'Unknown LiveDesk tool.');
-      return;
-    }
-    try {
-      const result = await callHub(name, message?.params?.arguments || {});
-      response(id, {
-        content: [{ type: 'text', text: JSON.stringify(result) }],
-        structuredContent: result,
-        isError: false
-      });
-    } catch (error) {
-      response(id, {
-        content: [{ type: 'text', text: String(error?.message || 'LiveDesk tool failed.') }],
-        isError: true
-      });
-    }
-    return;
-  }
-  if (id !== undefined) errorResponse(id, -32601, `Unsupported MCP method: ${method}`);
-}
-
-const input = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
-input.on('line', line => {
-  const trimmed = String(line || '').trim();
-  if (!trimmed) return;
-  let message;
-  try {
-    message = JSON.parse(trimmed);
-  } catch {
-    return;
-  }
-  void handle(message).catch(error => {
-    if (message?.id !== undefined) errorResponse(message.id, -32603, String(error?.message || 'MCP server error.'));
-  });
-});
+import readline from 'node:readline';
+import { AGENT_TOOL_DEFINITIONS } from './agent-tool-registry.js';
+
+const hubUrl = String(process.env.LIVEDESK_AGENT_MCP_URL || '').replace(/\/+$/, '');
+const token = String(process.env.LIVEDESK_AGENT_MCP_TOKEN || '');
+const protocolVersion = '2025-06-18';
+
+const toolDefinitions = AGENT_TOOL_DEFINITIONS.map(tool => ({
+  name: tool.name,
+  description: tool.description,
+  inputSchema: { $schema: 'https://json-schema.org/draft/2020-12/schema', ...tool.inputSchema },
+  annotations: {
+    readOnlyHint: tool.readOnly === true,
+    // Codex exec cannot service an interactive MCP approval prompt. Device
+    // mutations are proposals at this boundary and remain fail-closed behind
+    // LiveDesk's own signed permission policy and Hub approval workflow.
+    destructiveHint: false,
+    idempotentHint: tool.readOnly === true || tool.reversible === true,
+    openWorldHint: false
+  }
+}));
+
+function response(id, result) {
+  process.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', id, result })}\n`);
+}
+
+function errorResponse(id, code, message) {
+  process.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', id, error: { code, message } })}\n`);
+}
+
+async function callHub(name, args) {
+  if (!hubUrl || !token) throw new Error('LiveDesk MCP session is not configured.');
+  const result = await fetch(`${hubUrl}/api/internal/agent-mcp/tool`, {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+    body: JSON.stringify({ name, arguments: args && typeof args === 'object' ? args : {} })
+  });
+  const body = await result.json().catch(() => ({}));
+  if (!result.ok || body.ok !== true) throw new Error(String(body.error || `LiveDesk tool failed (${result.status}).`));
+  return body.result;
+}
+
+async function handle(message) {
+  const id = message?.id;
+  const method = String(message?.method || '');
+  if (!method) return;
+  if (method === 'initialize') {
+    response(id, {
+      protocolVersion,
+      capabilities: { tools: { listChanged: false } },
+      serverInfo: { name: 'livedesk', version: '1.0.0' }
+    });
+    return;
+  }
+  if (method === 'notifications/initialized' || method === 'ping') {
+    if (id !== undefined) response(id, {});
+    return;
+  }
+  if (method === 'tools/list') {
+    response(id, { tools: toolDefinitions });
+    return;
+  }
+  if (method === 'tools/call') {
+    const name = String(message?.params?.name || '');
+    if (!toolDefinitions.some(tool => tool.name === name)) {
+      errorResponse(id, -32602, 'Unknown LiveDesk tool.');
+      return;
+    }
+    try {
+      const result = await callHub(name, message?.params?.arguments || {});
+      response(id, {
+        content: [{ type: 'text', text: JSON.stringify(result) }],
+        structuredContent: result,
+        isError: false
+      });
+    } catch (error) {
+      response(id, {
+        content: [{ type: 'text', text: String(error?.message || 'LiveDesk tool failed.') }],
+        isError: true
+      });
+    }
+    return;
+  }
+  if (id !== undefined) errorResponse(id, -32601, `Unsupported MCP method: ${method}`);
+}
+
+const input = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+input.on('line', line => {
+  const trimmed = String(line || '').trim();
+  if (!trimmed) return;
+  let message;
+  try {
+    message = JSON.parse(trimmed);
+  } catch {
+    return;
+  }
+  void handle(message).catch(error => {
+    if (message?.id !== undefined) errorResponse(message.id, -32603, String(error?.message || 'MCP server error.'));
+  });
+});

package/src/filesystem/directory-reader.js

@@ -1,187 +1,187 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { setImmediate as yieldToEventLoop } from 'node:timers/promises';
-import { isPathWithinRoot } from './path-registry.js';
-
-function filesystemError(message, code = 'FILESYSTEM_ERROR', status = 400) {
-  const error = new Error(message);
-  error.code = code;
-  error.status = status;
-  return error;
-}
-
-function safeEntryName(name) {
-  return String(name || '').replace(/[\0\r\n\t]/g, ' ').slice(0, 512);
-}
-
-function toPublicEntry(entry) {
-  return {
-    id: entry.id,
-    parentId: entry.parentId,
-    name: entry.name,
-    type: entry.type,
-    size: entry.size || 0,
-    modifiedAt: entry.modifiedAt || null,
-    extension: entry.type === 'file' ? path.extname(entry.name).toLowerCase() : '',
-    hasChildren: entry.type !== 'file' && entry.hasChildren === true,
-    displayPath: entry.displayPath,
-    locked: entry.locked === true
-  };
-}
-
-async function readEntryStat(absolutePath) {
-  try {
-    return await fs.lstat(absolutePath);
-  } catch (error) {
-    if (error?.code === 'EACCES' || error?.code === 'EPERM') throw filesystemError('filesystem-access-denied', 'ACCESS_DENIED', 403);
-    if (error?.code === 'ENOENT' || error?.code === 'ENOTDIR') throw filesystemError('filesystem-entry-unavailable', 'NOT_FOUND', 404);
-    throw error;
-  }
-}
-
-export async function readDirectoryEntries(registry, folderId) {
-  const folder = registry.resolve(folderId);
-  if (folder.type === 'file') throw filesystemError('filesystem-entry-is-not-folder', 'NOT_A_FOLDER', 400);
-  if (folder.locked) throw filesystemError('filesystem-access-denied', 'ACCESS_DENIED', 403);
-  let entries;
-  try {
-    entries = await fs.readdir(folder.absolutePath, { withFileTypes: true });
-  } catch (error) {
-    if (error?.code === 'EACCES' || error?.code === 'EPERM') throw filesystemError('filesystem-access-denied', 'ACCESS_DENIED', 403);
-    if (error?.code === 'ENOENT' || error?.code === 'ENOTDIR') throw filesystemError('filesystem-entry-unavailable', 'NOT_FOUND', 404);
-    throw error;
-  }
-
-  const output = [];
-  for (const dirent of entries) {
-    const name = safeEntryName(dirent.name);
-    if (!name || name === '.' || name === '..') continue;
-    const absolutePath = path.resolve(folder.absolutePath, name);
-    if (!isPathWithinRoot(folder.rootPath, absolutePath)) continue;
-    const stat = await readEntryStat(absolutePath).catch(error => {
-      if (error?.code === 'ACCESS_DENIED' || error?.code === 'NOT_FOUND') return null;
-      throw error;
-    });
-    if (!stat) continue;
-    const isSymlink = dirent.isSymbolicLink() || stat.isSymbolicLink();
-    const type = !isSymlink && (dirent.isDirectory() || stat.isDirectory()) ? 'folder' : 'file';
-    const child = registry.register({
-      absolutePath,
-      rootPath: folder.rootPath,
-      rootId: folder.rootId,
-      parentId: folder.id,
-      name,
-      type,
-      displayPath: path.join(folder.displayPath, name),
-      locked: isSymlink
-    });
-    output.push(toPublicEntry({
-      ...child,
-      size: type === 'file' ? stat.size : 0,
-      modifiedAt: stat.mtime?.toISOString(),
-      hasChildren: type === 'folder' && !isSymlink
-    }));
-  }
-  output.sort((left, right) => {
-    if (left.type !== right.type) return left.type === 'folder' ? -1 : 1;
-    return left.name.localeCompare(right.name, undefined, { numeric: true, sensitivity: 'base' });
-  });
-  return {
-    folder: toPublicEntry({ ...folder, hasChildren: true }),
-    entries: output
-  };
-}
-
-async function walkDirectory(registry, entry, relativePrefix, output, visited, counters) {
-  const realPath = await fs.realpath(entry.absolutePath).catch(() => entry.absolutePath);
-  if (visited.has(realPath)) return;
-  visited.add(realPath);
-  let dirents;
-  try {
-    dirents = await fs.readdir(entry.absolutePath, { withFileTypes: true });
-  } catch (error) {
-    if (error?.code === 'EACCES' || error?.code === 'EPERM') throw filesystemError('filesystem-access-denied', 'ACCESS_DENIED', 403);
-    throw error;
-  }
-  for (const dirent of dirents) {
-    const name = safeEntryName(dirent.name);
-    if (!name || name === '.' || name === '..' || dirent.isSymbolicLink()) continue;
-    const absolutePath = path.resolve(entry.absolutePath, name);
-    if (!isPathWithinRoot(entry.rootPath, absolutePath)) continue;
-    const stat = await readEntryStat(absolutePath);
-    const relativePath = path.posix.join(relativePrefix, name);
-    if (stat.isDirectory()) {
-      counters.folders += 1;
-      const child = registry.register({
-        absolutePath,
-        rootPath: entry.rootPath,
-        rootId: entry.rootId,
-        parentId: entry.id,
-        name,
-        type: 'folder',
-        displayPath: path.join(entry.displayPath, name)
-      });
-      await walkDirectory(registry, child, relativePath, output, visited, counters);
-    } else if (stat.isFile()) {
-      const child = registry.register({
-        absolutePath,
-        rootPath: entry.rootPath,
-        rootId: entry.rootId,
-        parentId: entry.id,
-        name,
-        type: 'file',
-        displayPath: path.join(entry.displayPath, name)
-      });
-      output.push({
-        id: child.id,
-        absolutePath,
-        relativePath,
-        name,
-        size: stat.size,
-        modifiedMs: stat.mtimeMs,
-        modifiedAt: stat.mtime?.toISOString() || null
-      });
-      counters.files += 1;
-      counters.totalBytes += stat.size;
-    }
-    if ((counters.files + counters.folders) % 100 === 0) await yieldToEventLoop();
-  }
-}
-
-export async function scanSelection(registry, itemIds) {
-  const ids = [...new Set((Array.isArray(itemIds) ? itemIds : []).map(value => String(value || '').trim()).filter(Boolean))].slice(0, 5000);
-  if (ids.length === 0) throw filesystemError('no-filesystem-items-selected', 'NO_SELECTION', 400);
-  const selected = ids.map(id => registry.resolve(id));
-  const selectedPaths = selected.filter(entry => entry.type === 'folder').map(entry => path.resolve(entry.absolutePath));
-  const topLevel = selected.filter(entry => !selectedPaths.some(parent => parent !== entry.absolutePath && isPathWithinRoot(parent, entry.absolutePath)));
-  const files = [];
-  const counters = { files: 0, folders: 0, totalBytes: 0 };
-  const visited = new Set();
-  for (const entry of topLevel) {
-    const stat = await readEntryStat(entry.absolutePath);
-    if (entry.type === 'file' || stat.isFile()) {
-      files.push({
-        id: entry.id,
-        absolutePath: entry.absolutePath,
-        relativePath: entry.name,
-        name: entry.name,
-        size: stat.size,
-        modifiedMs: stat.mtimeMs,
-        modifiedAt: stat.mtime?.toISOString() || null
-      });
-      counters.files += 1;
-      counters.totalBytes += stat.size;
-      continue;
-    }
-    counters.folders += 1;
-    await walkDirectory(registry, entry, entry.name, files, visited, counters);
-  }
-  files.sort((left, right) => left.relativePath.localeCompare(right.relativePath, undefined, { numeric: true }));
-  return { ...counters, files };
-}
-
-export function toFilesystemHttpError(error) {
-  return error?.status
-    ? error
-    : filesystemError('filesystem-operation-failed', 'FILESYSTEM_ERROR', 500);
-}
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { setImmediate as yieldToEventLoop } from 'node:timers/promises';
+import { isPathWithinRoot } from './path-registry.js';
+
+function filesystemError(message, code = 'FILESYSTEM_ERROR', status = 400) {
+  const error = new Error(message);
+  error.code = code;
+  error.status = status;
+  return error;
+}
+
+function safeEntryName(name) {
+  return String(name || '').replace(/[\0\r\n\t]/g, ' ').slice(0, 512);
+}
+
+function toPublicEntry(entry) {
+  return {
+    id: entry.id,
+    parentId: entry.parentId,
+    name: entry.name,
+    type: entry.type,
+    size: entry.size || 0,
+    modifiedAt: entry.modifiedAt || null,
+    extension: entry.type === 'file' ? path.extname(entry.name).toLowerCase() : '',
+    hasChildren: entry.type !== 'file' && entry.hasChildren === true,
+    displayPath: entry.displayPath,
+    locked: entry.locked === true
+  };
+}
+
+async function readEntryStat(absolutePath) {
+  try {
+    return await fs.lstat(absolutePath);
+  } catch (error) {
+    if (error?.code === 'EACCES' || error?.code === 'EPERM') throw filesystemError('filesystem-access-denied', 'ACCESS_DENIED', 403);
+    if (error?.code === 'ENOENT' || error?.code === 'ENOTDIR') throw filesystemError('filesystem-entry-unavailable', 'NOT_FOUND', 404);
+    throw error;
+  }
+}
+
+export async function readDirectoryEntries(registry, folderId) {
+  const folder = registry.resolve(folderId);
+  if (folder.type === 'file') throw filesystemError('filesystem-entry-is-not-folder', 'NOT_A_FOLDER', 400);
+  if (folder.locked) throw filesystemError('filesystem-access-denied', 'ACCESS_DENIED', 403);
+  let entries;
+  try {
+    entries = await fs.readdir(folder.absolutePath, { withFileTypes: true });
+  } catch (error) {
+    if (error?.code === 'EACCES' || error?.code === 'EPERM') throw filesystemError('filesystem-access-denied', 'ACCESS_DENIED', 403);
+    if (error?.code === 'ENOENT' || error?.code === 'ENOTDIR') throw filesystemError('filesystem-entry-unavailable', 'NOT_FOUND', 404);
+    throw error;
+  }
+
+  const output = [];
+  for (const dirent of entries) {
+    const name = safeEntryName(dirent.name);
+    if (!name || name === '.' || name === '..') continue;
+    const absolutePath = path.resolve(folder.absolutePath, name);
+    if (!isPathWithinRoot(folder.rootPath, absolutePath)) continue;
+    const stat = await readEntryStat(absolutePath).catch(error => {
+      if (error?.code === 'ACCESS_DENIED' || error?.code === 'NOT_FOUND') return null;
+      throw error;
+    });
+    if (!stat) continue;
+    const isSymlink = dirent.isSymbolicLink() || stat.isSymbolicLink();
+    const type = !isSymlink && (dirent.isDirectory() || stat.isDirectory()) ? 'folder' : 'file';
+    const child = registry.register({
+      absolutePath,
+      rootPath: folder.rootPath,
+      rootId: folder.rootId,
+      parentId: folder.id,
+      name,
+      type,
+      displayPath: path.join(folder.displayPath, name),
+      locked: isSymlink
+    });
+    output.push(toPublicEntry({
+      ...child,
+      size: type === 'file' ? stat.size : 0,
+      modifiedAt: stat.mtime?.toISOString(),
+      hasChildren: type === 'folder' && !isSymlink
+    }));
+  }
+  output.sort((left, right) => {
+    if (left.type !== right.type) return left.type === 'folder' ? -1 : 1;
+    return left.name.localeCompare(right.name, undefined, { numeric: true, sensitivity: 'base' });
+  });
+  return {
+    folder: toPublicEntry({ ...folder, hasChildren: true }),
+    entries: output
+  };
+}
+
+async function walkDirectory(registry, entry, relativePrefix, output, visited, counters) {
+  const realPath = await fs.realpath(entry.absolutePath).catch(() => entry.absolutePath);
+  if (visited.has(realPath)) return;
+  visited.add(realPath);
+  let dirents;
+  try {
+    dirents = await fs.readdir(entry.absolutePath, { withFileTypes: true });
+  } catch (error) {
+    if (error?.code === 'EACCES' || error?.code === 'EPERM') throw filesystemError('filesystem-access-denied', 'ACCESS_DENIED', 403);
+    throw error;
+  }
+  for (const dirent of dirents) {
+    const name = safeEntryName(dirent.name);
+    if (!name || name === '.' || name === '..' || dirent.isSymbolicLink()) continue;
+    const absolutePath = path.resolve(entry.absolutePath, name);
+    if (!isPathWithinRoot(entry.rootPath, absolutePath)) continue;
+    const stat = await readEntryStat(absolutePath);
+    const relativePath = path.posix.join(relativePrefix, name);
+    if (stat.isDirectory()) {
+      counters.folders += 1;
+      const child = registry.register({
+        absolutePath,
+        rootPath: entry.rootPath,
+        rootId: entry.rootId,
+        parentId: entry.id,
+        name,
+        type: 'folder',
+        displayPath: path.join(entry.displayPath, name)
+      });
+      await walkDirectory(registry, child, relativePath, output, visited, counters);
+    } else if (stat.isFile()) {
+      const child = registry.register({
+        absolutePath,
+        rootPath: entry.rootPath,
+        rootId: entry.rootId,
+        parentId: entry.id,
+        name,
+        type: 'file',
+        displayPath: path.join(entry.displayPath, name)
+      });
+      output.push({
+        id: child.id,
+        absolutePath,
+        relativePath,
+        name,
+        size: stat.size,
+        modifiedMs: stat.mtimeMs,
+        modifiedAt: stat.mtime?.toISOString() || null
+      });
+      counters.files += 1;
+      counters.totalBytes += stat.size;
+    }
+    if ((counters.files + counters.folders) % 100 === 0) await yieldToEventLoop();
+  }
+}
+
+export async function scanSelection(registry, itemIds) {
+  const ids = [...new Set((Array.isArray(itemIds) ? itemIds : []).map(value => String(value || '').trim()).filter(Boolean))].slice(0, 5000);
+  if (ids.length === 0) throw filesystemError('no-filesystem-items-selected', 'NO_SELECTION', 400);
+  const selected = ids.map(id => registry.resolve(id));
+  const selectedPaths = selected.filter(entry => entry.type === 'folder').map(entry => path.resolve(entry.absolutePath));
+  const topLevel = selected.filter(entry => !selectedPaths.some(parent => parent !== entry.absolutePath && isPathWithinRoot(parent, entry.absolutePath)));
+  const files = [];
+  const counters = { files: 0, folders: 0, totalBytes: 0 };
+  const visited = new Set();
+  for (const entry of topLevel) {
+    const stat = await readEntryStat(entry.absolutePath);
+    if (entry.type === 'file' || stat.isFile()) {
+      files.push({
+        id: entry.id,
+        absolutePath: entry.absolutePath,
+        relativePath: entry.name,
+        name: entry.name,
+        size: stat.size,
+        modifiedMs: stat.mtimeMs,
+        modifiedAt: stat.mtime?.toISOString() || null
+      });
+      counters.files += 1;
+      counters.totalBytes += stat.size;
+      continue;
+    }
+    counters.folders += 1;
+    await walkDirectory(registry, entry, entry.name, files, visited, counters);
+  }
+  files.sort((left, right) => left.relativePath.localeCompare(right.relativePath, undefined, { numeric: true }));
+  return { ...counters, files };
+}
+
+export function toFilesystemHttpError(error) {
+  return error?.status
+    ? error
+    : filesystemError('filesystem-operation-failed', 'FILESYSTEM_ERROR', 500);
+}