drafted 1.7.21 → 1.7.23

package/cli/drafted.mjs

@@ -11,7 +11,7 @@ import { program } from 'commander';
 import { spawn, execSync } from 'child_process';
 import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync, unlinkSync } from 'fs';
 import { join, dirname, basename, resolve } from 'path';
-import { homedir, tmpdir } from 'os';
+import { homedir, tmpdir, platform } from 'os';
 import { fileURLToPath } from 'url';
 import { DESIGN_SYSTEM_PROMPT, buildDesignPrompt } from './prompts.mjs';
 
@@ -140,6 +140,24 @@ function getServerUrl() {
   return `http://localhost:${process.env.DRAFTED_PORT || DEFAULT_PORT}`;
 }
 
+function buildUpdateCommand() {
+  const server = getServerUrl().replace(/\/$/, '');
+  if (platform() === 'win32') {
+    const script = `$tmp = Join-Path $env:TEMP "drafted-install.ps1"; Invoke-WebRequest -UseBasicParsing "${server}/install.ps1" -OutFile $tmp; powershell -NoProfile -ExecutionPolicy Bypass -File $tmp`;
+    return {
+      shell: 'powershell.exe',
+      args: ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-Command', script],
+      manualCommand: script,
+    };
+  }
+  const script = `tmp=$(mktemp); curl -fsSL ${server}/install.sh -o "$tmp" && bash "$tmp"`;
+  return {
+    shell: 'sh',
+    args: ['-lc', script],
+    manualCommand: script,
+  };
+}
+
 // --- Auth helpers ---
 
 function readAuth() {
@@ -347,6 +365,47 @@ program
     process.exit(1);
   });
 
+// Command: update
+program
+  .command('update')
+  .description('Update the npm-installed Drafted MCP daemon')
+  .option('--dry-run', 'Print update instructions without starting the updater')
+  .option('--yes', 'Start the updater out-of-process')
+  .action((options) => {
+    const update = buildUpdateCommand();
+    const data = {
+      started: false,
+      command: 'drafted update --yes',
+      dryRunCommand: 'drafted update --dry-run',
+      manualCommand: update.manualCommand,
+      restartRequired: true,
+      restartGuidance: 'Restart your agent/editor after updating so it starts the new drafted-mcp.',
+    };
+
+    if (options.yes && !options.dryRun) {
+      const child = spawn(update.shell, update.args, {
+        detached: true,
+        stdio: 'ignore',
+      });
+      child.unref();
+      data.started = true;
+    }
+
+    jsonOut(true, 'update', data);
+
+    if (data.started) {
+      console.log('Drafted updater started in the background.');
+    } else {
+      console.log('Drafted updater was not started.');
+      console.log('Run this command to update:');
+      console.log(`  ${data.command}`);
+      console.log('');
+      console.log('Manual updater command:');
+      console.log(`  ${data.manualCommand}`);
+    }
+    console.log(data.restartGuidance);
+  });
+
 // Command: logout
 program
   .command('logout')

package/mcp/server.mjs

@@ -186,6 +186,56 @@ const TOOL_ANNOTATIONS = {
   wiki:                { title: 'Wiki',                readOnlyHint: false, destructiveHint: true,  openWorldHint: false, description: 'Per-org wiki. Markdown pages with paths as hierarchy. Dispatch by `action`.' },
 };
 
+function isMutatingToolCall(name, args = {}) {
+  const action = args?.action;
+  switch (name) {
+    case 'project':
+      return ['create', 'update', 'move'].includes(action);
+    case 'template':
+      return ['create', 'update', 'delete', 'fork'].includes(action);
+    case 'layer':
+      return ['add', 'update', 'remove', 'reorder'].includes(action);
+    case 'frame':
+      return ![
+        'read', 'search', 'versions', 'read_version',
+        'get_sheet', 'read_sheet_values',
+        'get_doc', 'read_doc_content',
+        'get_slide', 'read_slide_content',
+        'get_excel', 'read_excel_range',
+      ].includes(action);
+    case 'asset':
+      return ['upload', 'rm'].includes(action);
+    case 'skill':
+      return ['add', 'update', 'remove', 'attach', 'detach', 'favorite', 'unfavorite', 'update_file'].includes(action);
+    case 'wiki':
+      return ['log', 'write', 'edit', 'mv', 'rm', 'source-register', 'bulk-write'].includes(action);
+    case 'rm':
+    case 'shape':
+    case 'group':
+    case 'connector':
+    case 'layout':
+      return true;
+    default:
+      return false;
+  }
+}
+
+async function getRequiredMcpUpdateError(name, args = {}) {
+  if (mcpMode() !== 'stdio') return null;
+  if (!isMutatingToolCall(name, args)) return null;
+  const updateMetadata = await getMcpUpdateMetadata();
+  if (!updateMetadata?.required) return null;
+  const instructions = buildInstalledMcpUpdateInstructions(updateMetadata);
+  return [
+    `Drafted MCP update required before running ${name}${args?.action ? `.${args.action}` : ''}.`,
+    `Current version: ${instructions.currentVersion || PACKAGE_VERSION}.`,
+    instructions.latestVersion ? `Latest version: ${instructions.latestVersion}.` : null,
+    instructions.minimumRequiredVersion ? `Minimum required version: ${instructions.minimumRequiredVersion}.` : null,
+    `Run: ${instructions.command}`,
+    `Then restart your agent/editor so it starts the updated drafted-mcp.`,
+  ].filter(Boolean).join(' ');
+}
+
 function tool(name, descOrSchema, schemaOrHandler, handler) {
   const ann = TOOL_ANNOTATIONS[name];
   if (!ann) throw new Error(`MCP tool "${name}" missing entry in TOOL_ANNOTATIONS`);
@@ -221,6 +271,8 @@ function tool(name, descOrSchema, schemaOrHandler, handler) {
     trackUmamiEvent(UMAMI_EVENTS.MCP_TOOL_CALLED, { tool: name, projectId: state.projectId || undefined, source: 'mcp' });
     reportInstallationEvent(UMAMI_EVENTS.DRAFTED_MCP_REQUEST, { tool: name });
     try {
+      const requiredUpdateError = await getRequiredMcpUpdateError(name, args?.[0] || {});
+      if (requiredUpdateError) return err(new Error(requiredUpdateError));
       return await cb(...args);
     } finally {
       state.currentTool = previousTool;
@@ -1528,14 +1580,137 @@ async function getGoogleDriveAvailability() {
   }
 }
 
+function normalizeMcpUpdatePolicy(policy) {
+  const severity = policy?.policy?.severity || 'unknown';
+  const updateAvailable = !!policy?.policy?.updateAvailable;
+  const required = !!policy?.policy?.required;
+  return {
+    status: required ? 'required' : updateAvailable ? 'stale' : severity === 'unknown' ? 'unknown' : 'current',
+    currentVersion: policy?.versions?.client || PACKAGE_VERSION,
+    latestVersion: policy?.versions?.latest || null,
+    recommendedVersion: policy?.versions?.recommended || null,
+    minimumRequiredVersion: policy?.versions?.minimumRequired || null,
+    severity,
+    updateAvailable,
+    stale: updateAvailable,
+    required,
+    reason: policy?.policy?.reason || null,
+    enabled: policy?.policy?.enabled !== false,
+    mode: policy?.package?.mcpMode || mcpMode(),
+    distribution: policy?.package?.distribution || (mcpMode() === 'stdio' ? 'npm-stdio' : 'hosted-http'),
+    update: {
+      command: policy?.update?.command || null,
+      helper: policy?.update?.helper || null,
+      packageManager: policy?.update?.packageManager || 'npm',
+    },
+    restart: {
+      required: !!policy?.restart?.required,
+      guidance: policy?.restart?.guidance || null,
+    },
+    checkedAt: policy?.serverTimestamp || null,
+  };
+}
+
+function buildInstalledMcpUpdateInstructions(updateMetadata = null) {
+  const mode = updateMetadata?.mode || mcpMode();
+  const restart = updateMetadata?.restart || {
+    required: mode === 'stdio',
+    guidance: 'Restart agents after updating the npm-installed Drafted MCP daemon.',
+  };
+
+  if (mode !== 'stdio') {
+    return {
+      action: 'update_mcp',
+      started: false,
+      updateSupported: false,
+      mode,
+      currentVersion: updateMetadata?.currentVersion || PACKAGE_VERSION,
+      latestVersion: updateMetadata?.latestVersion || null,
+      updateAvailable: false,
+      required: false,
+      command: null,
+      dryRunCommand: null,
+      manualCommand: null,
+      restart: {
+        required: false,
+        guidance: restart.guidance || 'Hosted HTTP MCP updates with the Drafted server deploy.',
+      },
+      note: 'This session is using hosted HTTP MCP, so there is no npm-installed stdio daemon to update on this machine.',
+    };
+  }
+
+  const server = getServerUrl().replace(/\/$/, '');
+  const manualCommand = platform() === 'win32'
+    ? `$tmp = Join-Path $env:TEMP "drafted-install.ps1"; Invoke-WebRequest -UseBasicParsing "${server}/install.ps1" -OutFile $tmp; powershell -NoProfile -ExecutionPolicy Bypass -File $tmp`
+    : `tmp=$(mktemp); curl -fsSL ${server}/install.sh -o "$tmp" && bash "$tmp"`;
+
+  return {
+    action: 'update_mcp',
+    started: false,
+    updateSupported: true,
+    mode: 'stdio',
+    currentVersion: updateMetadata?.currentVersion || PACKAGE_VERSION,
+    latestVersion: updateMetadata?.latestVersion || null,
+    recommendedVersion: updateMetadata?.recommendedVersion || null,
+    minimumRequiredVersion: updateMetadata?.minimumRequiredVersion || null,
+    updateAvailable: !!updateMetadata?.updateAvailable,
+    required: !!updateMetadata?.required,
+    command: 'drafted update --yes',
+    dryRunCommand: 'drafted update --dry-run',
+    manualCommand,
+    restart: {
+      required: true,
+      guidance: restart.guidance || 'Restart agents after updating the npm-installed Drafted MCP daemon.',
+    },
+    note: 'This action is intentionally advisory: it does not replace the currently running MCP process. Run the command, then restart your agent/editor so it starts the updated drafted-mcp.',
+    mcpUpdate: updateMetadata || null,
+  };
+}
+
+async function getMcpUpdateMetadata() {
+  const mode = mcpMode();
+  try {
+    const query = new URLSearchParams({
+      cliVersion: PACKAGE_VERSION,
+      mcpMode: mode,
+    });
+    const policy = await api('GET', `/api/installations/latest?${query.toString()}`);
+    return normalizeMcpUpdatePolicy(policy);
+  } catch (error) {
+    return {
+      status: 'unknown',
+      currentVersion: PACKAGE_VERSION,
+      latestVersion: null,
+      recommendedVersion: null,
+      minimumRequiredVersion: null,
+      severity: 'unknown',
+      updateAvailable: false,
+      stale: false,
+      required: false,
+      reason: 'latest_check_failed',
+      enabled: false,
+      mode,
+      distribution: mode === 'stdio' ? 'npm-stdio' : 'hosted-http',
+      update: { command: null, helper: null, packageManager: 'npm' },
+      restart: { required: false, guidance: 'Drafted MCP update status is unavailable; get_org still succeeded.' },
+      checkedAt: null,
+    };
+  }
+}
+
 
 tool('get_org', {
-  action: z.enum(['get', 'switch']).optional().describe('Default: "get" returns active org and member info. Use "switch" with orgId to change the active org without opening a project.'),
+  action: z.enum(['get', 'switch', 'update_mcp']).optional().describe('Default: "get" returns active org and member info. Use "switch" with orgId to change the active org without opening a project. Use "update_mcp" to get explicit installed stdio MCP update instructions.'),
   orgId: z.string().optional().describe('[switch] target org ID to switch to. Must be one of the orgs the user is a member of.'),
 }, async (args = {}) => {
   try {
     const action = args.action || 'get';
 
+    if (action === 'update_mcp') {
+      const mcpUpdate = await getMcpUpdateMetadata();
+      return ok(buildInstalledMcpUpdateInstructions(mcpUpdate));
+    }
+
     if (action === 'switch') {
       if (!args.orgId) throw new Error('orgId is required for action=switch');
       await api('POST', '/auth/switch-org', { orgId: args.orgId });
@@ -1550,7 +1725,8 @@ tool('get_org', {
       const orgs = (await api('GET', '/api/orgs')).orgs || [];
       const activeOrg = (orgs || []).map(o => ({ id: o.orgId || o.id, name: o.orgName || o.name })).find(o => o.id === me?.orgId) || null;
       const googleDrive = await getGoogleDriveAvailability();
-      return ok({ switched: true, activeOrg, googleDrive, note: 'Active org switched. Wiki and skill calls now target this org. Active project cleared — open a project (or stay org-scoped for wiki/skill). If googleDrive.connected is true, prefer Google Workspace frames for docs, sheets, and slides.' });
+      const mcpUpdate = await getMcpUpdateMetadata();
+      return ok({ switched: true, activeOrg, googleDrive, mcpVersion: PACKAGE_VERSION, mcpUpdate, note: 'Active org switched. Wiki and skill calls now target this org. Active project cleared — open a project (or stay org-scoped for wiki/skill). If googleDrive.connected is true, prefer Google Workspace frames for docs, sheets, and slides.' });
     }
 
     // Source of truth = THIS MCP session's bound org (what mutations will actually
@@ -1564,6 +1740,7 @@ tool('get_org', {
     const activeOrg = sessionOrgId ? (orgs.find(o => o.id === sessionOrgId) || null) : null;
 
     const googleDrive = await getGoogleDriveAvailability();
+    const mcpUpdate = await getMcpUpdateMetadata();
 
     let members = [];
     if (sessionOrgId) {
@@ -1578,6 +1755,7 @@ tool('get_org', {
       members: members.map(m => ({ id: m.userId, name: m.username, email: m.email, role: m.role })),
       googleDrive,
       mcpVersion: PACKAGE_VERSION,
+      mcpUpdate,
       note: "activeOrg is the org bound to THIS MCP session — what mutations will actually target. To switch orgs without creating a project, call get_org(action=\"switch\", orgId=\"...\"). Browser tabs and other MCP sessions for the same user can be on different orgs. If googleDrive.connected is true, strongly prefer Google Workspace frames for docs, sheets, and slides.",
     });
   } catch (error) { return err(error); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drafted",
-  "version": "1.7.21",
+  "version": "1.7.23",
   "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": [