drafted 1.7.18 → 1.7.20

package/install-mcp.sh

@@ -215,8 +215,10 @@ export PATH="$HOME/.drafted/npm-global/bin:$PATH"
 
 step "Installing Drafted"
 
-npm install -g drafted@latest --force --silent 2>/dev/null
+npm install -g drafted@latest --force
 hash -r 2>/dev/null || true
+NPM_ROOT="$(npm root -g)"
+node -e "import('node:url').then(({ pathToFileURL }) => import(pathToFileURL(process.argv[1]).href)).then(() => process.exit(0), (err) => { console.error(err); process.exit(1); })" "$NPM_ROOT/drafted/mcp/server.mjs"
 ok "Installed $(drafted --version 2>/dev/null || echo 'drafted') via npm"
 
 # ── Configure ─────────────────────────────────────────────────────
@@ -586,6 +588,7 @@ struct DraftedUpdaterApp: App {
   var body: some Scene {
     MenuBarExtra {
       Button("Update Drafted") { Actions.updateDrafted() }
+      Button("View Logs") { Actions.viewLogs() }
       Button("Open Drafted") { Actions.openDrafted() }
       Divider()
       Button("Quit") { NSApp.terminate(nil) }
@@ -735,6 +738,47 @@ struct Actions {
     }
   }
 
+  static func viewLogs() {
+    let fm = FileManager.default
+    let home = fm.homeDirectoryForCurrentUser
+    let fallback = home.appendingPathComponent(".drafted")
+    try? fm.createDirectory(at: fallback, withIntermediateDirectories: true)
+    let readme = fallback.appendingPathComponent("logs-readme.txt")
+    if !fm.fileExists(atPath: readme.path) {
+      let text = """
+Drafted MCP logs are written by the host app that launched drafted-mcp.
+
+Most useful locations:
+- Drafted MCP client errors: ~/.drafted/mcp-client.log
+- Claude Desktop: ~/Library/Logs/Claude/mcp-server-drafted.log
+- Claude Code: ~/.claude/projects (session transcripts) or ~/.claude/logs when present
+- Drafted installer/updater: ~/.drafted
+
+If a tool returns `fetch failed`, open the Claude log or transcript from the same run and look for `mcp-server-drafted` or `Drafted MCP`.
+"""
+      try? text.write(to: readme, atomically: true, encoding: .utf8)
+    }
+
+    let candidates = [
+      home.appendingPathComponent(".drafted/mcp-client.log"),
+      home.appendingPathComponent("Library/Logs/Claude/mcp-server-drafted.log"),
+      home.appendingPathComponent("Library/Logs/Claude"),
+      home.appendingPathComponent(".claude/logs"),
+      home.appendingPathComponent(".claude/projects"),
+      fallback,
+    ]
+    for url in candidates where fm.fileExists(atPath: url.path) {
+      var isDirectory: ObjCBool = false
+      fm.fileExists(atPath: url.path, isDirectory: &isDirectory)
+      if isDirectory.boolValue {
+        NSWorkspace.shared.open(url)
+      } else {
+        NSWorkspace.shared.activateFileViewerSelecting([url])
+      }
+      return
+    }
+  }
+
   static func openDrafted() {
     NSWorkspace.shared.open(URL(string: "https://drafted.live")!)
   }

package/mcp/server.mjs

@@ -10,9 +10,9 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { execFile } from 'child_process';
 import { createHash } from 'node:crypto';
-import { readFileSync, existsSync, realpathSync, writeFileSync, mkdirSync, unlinkSync } from 'fs';
+import { readFileSync, existsSync, realpathSync, writeFileSync, mkdirSync, unlinkSync, appendFileSync } from 'fs';
 import { join, dirname, basename, extname, resolve } from 'path';
-import { homedir } from 'os';
+import { homedir, platform, release as osRelease, arch as osArch } from 'os';
 import { fileURLToPath } from 'url';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { z } from 'zod';
@@ -20,7 +20,21 @@ import { registerAppResource, RESOURCE_MIME_TYPE } from '@modelcontextprotocol/e
 import WebSocket from 'ws';
 import { LAYERS } from '../src/shared/constants.mjs';
 import { emptyExcalidrawScene, excalidrawSceneFromMermaid, stringifyExcalidrawScene } from '../src/shared/excalidraw.mjs';
-import { UMAMI_EVENTS, trackUmamiEvent } from '../server/lib/umami.mjs';
+const { UMAMI_EVENTS, trackUmamiEvent } = await (async () => {
+  try {
+    return await import('../server/lib/umami.mjs');
+  } catch {
+    return {
+      UMAMI_EVENTS: Object.freeze({
+        MCP_CONNECTED: 'mcp_connected',
+        MCP_TOOL_CALLED: 'mcp_tool_called',
+        DRAFTED_MCP_REQUEST: 'drafted_mcp_request',
+        DRAFTED_MCP_ERROR: 'drafted_mcp_error',
+      }),
+      trackUmamiEvent: () => {},
+    };
+  }
+})();
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -202,9 +216,15 @@ function tool(name, descOrSchema, schemaOrHandler, handler) {
   }
   return server.registerTool(name, config, async (...args) => {
     const state = getState();
+    const previousTool = state.currentTool;
+    state.currentTool = name;
     trackUmamiEvent(UMAMI_EVENTS.MCP_TOOL_CALLED, { tool: name, projectId: state.projectId || undefined, source: 'mcp' });
-    reportInstallationEvent(UMAMI_EVENTS.DRAFTED_MCP_REQUEST);
-    return cb(...args);
+    reportInstallationEvent(UMAMI_EVENTS.DRAFTED_MCP_REQUEST, { tool: name });
+    try {
+      return await cb(...args);
+    } finally {
+      state.currentTool = previousTool;
+    }
   });
 }
 
@@ -301,7 +321,25 @@ function getInstallInfo() {
   }
 }
 
-function reportInstallationEvent(event) {
+
+function osFamily() {
+  const p = platform();
+  if (p === 'darwin') return 'macos';
+  if (p === 'win32') return 'windows';
+  if (p === 'linux') return 'linux';
+  return 'unknown';
+}
+
+function normalizedArch() {
+  const a = osArch();
+  return ['x64', 'arm64', 'arm', 'ia32'].includes(a) ? a : 'unknown';
+}
+
+function mcpMode() {
+  return process.argv.includes('--http') ? 'http' : 'stdio';
+}
+
+function reportInstallationEvent(event, extra = {}) {
   const info = getInstallInfo();
   if (!info) return;
   fetch(`${getServerUrl()}/api/installations/report`, {
@@ -312,12 +350,78 @@ function reportInstallationEvent(event) {
       event,
       schemaVersion: 1,
       cliVersion: PACKAGE_VERSION,
-      mcpMode: process.argv.includes('--http') ? 'http' : 'stdio',
+      osFamily: osFamily(),
+      osVersion: osRelease().slice(0, 60),
+      arch: normalizedArch(),
+      nodeVersion: process.version,
+      mcpMode: mcpMode(),
       source: 'mcp',
+      ...extra,
     }),
   }).catch(() => {});
 }
 
+function classifyMcpError(error) {
+  const msg = String(error?.message || error || '').toLowerCase();
+  const causeCode = String(error?.cause?.code || error?.code || '').toLowerCase();
+  if (causeCode) return causeCode.slice(0, 80);
+  if (msg.includes('fetch failed')) return 'fetch_failed';
+  if (msg.includes('failed to fetch')) return 'fetch_failed';
+  if (msg.includes('network')) return 'network_error';
+  if (msg.includes('timeout') || msg.includes('timed out')) return 'timeout';
+  const httpMatch = msg.match(/http\s+(\d{3})/);
+  if (httpMatch) return `http_${httpMatch[1]}`;
+  if (msg.includes('unauthorized') || msg.includes('401')) return 'auth_401';
+  if (msg.includes('forbidden') || msg.includes('403')) return 'auth_403';
+  return 'tool_error';
+}
+
+function scrubLogValue(value) {
+  if (typeof value !== 'string') return value;
+  return value
+    .replace(/([?&](?:token|code|dci|session|auth|password|secret)=)[^&\s]+/gi, '$1[Filtered]')
+    .replace(/(Bearer\s+)[A-Za-z0-9._~+\/-]+=*/gi, '$1[Filtered]')
+    .replace(/(gc_session=)[^;\s]+/gi, '$1[Filtered]')
+    .slice(0, 500);
+}
+
+function serverOriginForLog() {
+  try { return new URL(getServerUrl()).origin; } catch { return 'invalid_server_url'; }
+}
+
+function writeMcpClientLog(tool, error) {
+  const entry = {
+    ts: new Date().toISOString(),
+    level: 'error',
+    component: 'drafted-mcp-client',
+    version: PACKAGE_VERSION,
+    tool: String(tool || 'unknown').slice(0, 80),
+    errorCode: classifyMcpError(error),
+    message: scrubLogValue(error?.message || String(error)),
+    causeCode: scrubLogValue(error?.cause?.code || error?.code || ''),
+    causeMessage: scrubLogValue(error?.cause?.message || ''),
+    server: serverOriginForLog(),
+    osFamily: osFamily(),
+    nodeVersion: process.version,
+    mcpMode: mcpMode(),
+  };
+  const line = `[Drafted MCP] ${JSON.stringify(entry)}\n`;
+  try { console.error(line.trimEnd()); } catch { /* ignore */ }
+  try {
+    const logPath = join(homedir(), '.drafted', 'mcp-client.log');
+    mkdirSync(dirname(logPath), { recursive: true });
+    appendFileSync(logPath, line, { mode: 0o600 });
+  } catch { /* best effort */ }
+}
+
+function reportMcpToolError(tool, error) {
+  writeMcpClientLog(tool, error);
+  reportInstallationEvent(UMAMI_EVENTS.DRAFTED_MCP_ERROR, {
+    tool: String(tool || 'unknown').slice(0, 80),
+    errorCode: classifyMcpError(error),
+  });
+}
+
 function wikiBrowserUrl(path = '') {
   const normalized = normalizeWikiPath(path || '');
   if (!normalized) return `${getServerUrl()}/wiki`;
@@ -702,6 +806,7 @@ if (!globalThis.__draftedAgentWsBootstrapped) {
 }
 
 function err(error) {
+  reportMcpToolError(getState().currentTool, error);
   return { content: [{ type: 'text', text: error.message || String(error) }], isError: true };
 }
 

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "drafted",
-  "version": "1.7.18",
+  "version": "1.7.20",
   "description": "Drafted — visual thinking surface for humans and AI agents. Renders HTML, markdown, images, and code as frames on a zoomable canvas, with MCP tools for AI agents and real-time sync for humans.",
   "type": "module",
   "files": [
     "cli/",
     "mcp/",
+    "server/lib/umami.mjs",
     "src/shared/",
     "agent-instructions/",
     "install-mcp.sh"
@@ -31,7 +32,8 @@
     "version:check": "node scripts/sync-versions.mjs",
     "postpublish": "bash scripts/sync-plugin.sh \"chore: sync plugin to v$npm_package_version\"",
     "deploy:check:google": "node scripts/check-google-drive-deploy.mjs",
-    "build:excalidraw": "node scripts/build-excalidraw-editor.mjs"
+    "build:excalidraw": "node scripts/build-excalidraw-editor.mjs",
+    "prepublishOnly": "node scripts/check-npm-package.mjs"
   },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.1007.0",

package/server/lib/umami.mjs

@@ -0,0 +1,156 @@
+export const UMAMI_EVENTS = Object.freeze({
+  SIGNUP_STARTED: 'signup_started',
+  SIGNUP_COMPLETED: 'signup_completed',
+  ORG_CREATED: 'org_created',
+  PROJECT_CREATED: 'project_created',
+  PROJECT_OPENED: 'project_opened',
+  TEMPLATE_USED: 'template_used',
+  FRAME_CREATED: 'frame_created',
+  FRAME_UPDATED: 'frame_updated',
+  FRAME_DELETED: 'frame_deleted',
+  SHARE_CREATED: 'share_created',
+  SHARE_ACCEPTED: 'share_accepted',
+  INVITE_SENT: 'invite_sent',
+  MCP_CONNECTED: 'mcp_connected',
+  MCP_TOOL_CALLED: 'mcp_tool_called',
+  WIKI_PAGE_CREATED: 'wiki_page_created',
+  SKILL_ATTACHED: 'skill_attached',
+  DRIVE_CONNECTED: 'drive_connected',
+  DRIVE_SYNC_COMPLETED: 'drive_sync_completed',
+  DRAFTED_INSTALL: 'drafted_install',
+  DRAFTED_UPDATE: 'drafted_update',
+  DRAFTED_HEARTBEAT: 'drafted_heartbeat',
+  DRAFTED_MCP_CONFIGURED: 'drafted_mcp_configured',
+  DRAFTED_MCP_REQUEST: 'drafted_mcp_request',
+  DRAFTED_MCP_ERROR: 'drafted_mcp_error',
+  DRAFTED_UPDATE_HELPER_STARTED: 'drafted_update_helper_started',
+  DRAFTED_UPDATE_HELPER_FAILED: 'drafted_update_helper_failed',
+  CTA_CLICKED: 'cta_clicked',
+  TEMPLATE_SELECTED: 'template_selected',
+  PROJECT_NAVIGATED: 'project_navigated',
+  SHARE_MODAL_OPENED: 'share_modal_opened',
+  SHARE_MODAL_ACTION: 'share_modal_action',
+  SURFACE_LOADED: 'surface_loaded',
+  SIDEBAR_USED: 'sidebar_used',
+  TOOL_PANEL_USED: 'tool_panel_used',
+});
+
+const BLOCKED_KEYS = new Set([
+  'email', 'userEmail', 'name', 'userName', 'orgName', 'projectName', 'label', 'title',
+  'content', 'html', 'markdown', 'body', 'prompt', 'token', 'cookie', 'authorization',
+  'password', 'secret', 'apiKey', 'request', 'headers', 'file', 'buffer', 'dataUrl',
+]);
+const ID_KEYS = new Set(['userId', 'orgId', 'projectId', 'projectSlug', 'frameId', 'shareId', 'skillId', 'templateId', 'templateSlug', 'userRole', 'role', 'buildId', 'pageType', 'tool', 'action', 'source', 'layer', 'lane', 'mode', 'installId', 'schemaVersion', 'installerVersion', 'cliVersion', 'osFamily', 'osVersion', 'arch', 'nodeVersion', 'npmVersion', 'claudeDesktop', 'claudeCode', 'codex', 'cursor', 'updateHelperStatus', 'mcpMode', 'errorCode']);
+
+export function getUmamiConfig(config = {}) {
+  const hostUrl = (config.umamiHostUrl || process.env.UMAMI_HOST_URL || '').replace(/\/$/, '');
+  const websiteId = config.umamiWebsiteId || process.env.UMAMI_WEBSITE_ID || '';
+  return { hostUrl, websiteId, enabled: Boolean(hostUrl && websiteId) };
+}
+
+export function sanitizeUmamiEventData(data = {}) {
+  const output = {};
+  if (!data || typeof data !== 'object' || Array.isArray(data)) return output;
+  for (const [key, value] of Object.entries(data)) {
+    if (BLOCKED_KEYS.has(key)) continue;
+    if (value === undefined || value === null) continue;
+    if (typeof value === 'object') continue;
+    if (!ID_KEYS.has(key) && /email|name|content|html|markdown|body|prompt|token|cookie|auth|secret|password|key|file/i.test(key)) continue;
+    if (typeof value === 'string') {
+      if (value.length > 120) continue;
+      if (/@/.test(value)) continue;
+      output[key] = value;
+    } else if (typeof value === 'number' || typeof value === 'boolean') {
+      output[key] = value;
+    }
+  }
+  return output;
+}
+
+export function getUmamiHead(config = {}) {
+  const umami = getUmamiConfig(config);
+  if (!umami.enabled) return '';
+  const ctx = sanitizeUmamiEventData({
+    userId: config.userId,
+    orgId: config.orgId,
+    projectId: config.projectId,
+    projectSlug: config.projectSlug,
+    userRole: config.userRole,
+    buildId: config.buildId,
+    pageType: config.pageType,
+  });
+  return `<script defer src="${umami.hostUrl}/script.js" data-website-id="${umami.websiteId}"></script>
+<script>
+window.__DRAFTED_ANALYTICS__ = ${JSON.stringify(ctx)};
+window.draftedTrack = function(name, data) {
+  var base = window.__DRAFTED_ANALYTICS__ || {};
+  var payload = Object.assign({}, base, data || {});
+  if (window.umami && typeof window.umami.track === 'function') window.umami.track(name, payload);
+};
+window.addEventListener('load', function() {
+  var c = window.__DRAFTED_ANALYTICS__ || {};
+  if (c.userId && window.umami && typeof window.umami.identify === 'function') window.umami.identify(c.userId, { orgId: c.orgId, role: c.userRole });
+});
+</script>`;
+}
+
+export function getUmamiInteractionScript(pageType) {
+  return `<script>
+(function() {
+  function track(name, data) { if (window.draftedTrack) window.draftedTrack(name, Object.assign({ pageType: ${JSON.stringify(pageType)} }, data || {})); }
+  window.addEventListener('load', function() {
+    if (${JSON.stringify(pageType)} === 'surface') track('surface_loaded');
+  });
+  document.addEventListener('click', function(event) {
+    var el = event.target && event.target.closest && event.target.closest('a,button,[data-analytics-event],[data-template-slug],[data-project-id]');
+    if (!el) return;
+    var eventName = el.getAttribute('data-analytics-event');
+    if (eventName) return track(eventName, { action: el.getAttribute('data-analytics-action') || undefined });
+    var href = el.getAttribute('href') || '';
+    var cls = el.className || '';
+    if (el.matches('.nav-cta,.btn-primary,.btn-secondary')) track('cta_clicked', { action: href || (el.textContent || '').trim().slice(0, 40) });
+    if (el.getAttribute('data-template-slug')) track('template_selected', { templateSlug: el.getAttribute('data-template-slug') });
+    if (el.getAttribute('data-project-id')) track('project_navigated', { projectId: el.getAttribute('data-project-id') });
+    if (/share/i.test(String(cls)) || /share/i.test(el.textContent || '')) track('share_modal_action');
+    if (/sidebar/i.test(String(cls))) track('sidebar_used');
+    if (/tool|panel/i.test(String(cls))) track('tool_panel_used');
+  }, true);
+})();
+</script>`;
+}
+
+function getRequestUrl(req) {
+  if (!req) return undefined;
+  const host = typeof req.get === 'function' ? req.get('host') : req.headers?.host;
+  const protocol = req.protocol || 'https';
+  return host ? `${protocol}://${host}${req.originalUrl || req.url || ''}` : undefined;
+}
+
+export function trackUmamiEvent(name, data = {}, req = null) {
+  const umami = getUmamiConfig();
+  if (!umami.enabled || !name || name.length > 50) return;
+  const payload = {
+    type: 'event',
+    payload: {
+      website: umami.websiteId,
+      name,
+      url: getRequestUrl(req) || process.env.BASE_URL || 'https://drafted.live',
+      hostname: req?.hostname || 'drafted.live',
+      language: req?.headers?.['accept-language'],
+      referrer: req?.headers?.referer,
+      data: sanitizeUmamiEventData(data),
+    },
+  };
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 1500);
+  fetch(`${umami.hostUrl}/api/send`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'User-Agent': req?.headers?.['user-agent'] || 'Drafted Server Analytics',
+      'X-Forwarded-For': req?.ip || req?.headers?.['x-forwarded-for'] || '',
+    },
+    body: JSON.stringify(payload),
+    signal: controller.signal,
+  }).catch(() => {}).finally(() => clearTimeout(timeout));
+}