drafted 1.7.17 → 1.7.19

package/install-mcp.sh

@@ -1,14 +1,56 @@
 #!/bin/bash
 set -e
 
-# Drafted — Design workspace for AI agents
+# Drafted — Shared surface for AI-human collaboration
 # This script installs the Drafted MCP server and CLI globally via npm,
-# then registers it with Claude Desktop, Claude Code, and Cursor.
+# then registers it with Claude Desktop, Claude Code, Codex, and Cursor.
 #
 # Run with:
 #   curl -fsSL https://drafted.live/install.sh | bash
 
 SERVER="https://drafted.live"
+INSTALLER_VERSION="1"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+INSTALL_MODE="production"
+INSTALL_NAME="${DRAFTED_MCP_NAME:-drafted}"
+INSTALL_SERVER="${DRAFTED_SERVER:-$SERVER}"
+INSTALL_AUTH_FILE="${DRAFTED_AUTH_FILE:-}"
+
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --local)
+      INSTALL_MODE="local"
+      INSTALL_NAME="${DRAFTED_MCP_NAME:-drafted-local}"
+      INSTALL_SERVER="${DRAFTED_SERVER:-http://localhost:3477}"
+      INSTALL_AUTH_FILE="${DRAFTED_AUTH_FILE:-$HOME/.drafted/auth.local.json}"
+      if [ -z "${DRAFTED_TELEMETRY+x}" ]; then export DRAFTED_TELEMETRY=0; fi
+      shift
+      ;;
+    --server)
+      INSTALL_SERVER="$2"
+      shift 2
+      ;;
+    --name)
+      INSTALL_NAME="$2"
+      shift 2
+      ;;
+    --auth-file)
+      INSTALL_AUTH_FILE="$2"
+      shift 2
+      ;;
+    --help|-h)
+      echo "Usage: install-mcp.sh [--local] [--server URL] [--name MCP_NAME] [--auth-file PATH]"
+      echo "  default: installs production MCP named drafted -> https://drafted.live"
+      echo "  --local: installs duplicate MCP named drafted-local -> http://localhost:3477"
+      exit 0
+      ;;
+    *)
+      echo "Unknown option: $1" >&2
+      exit 1
+      ;;
+  esac
+done
+
 
 BOLD="\033[1m"
 DIM="\033[2m"
@@ -33,12 +75,117 @@ fail() {
   echo -e "    ${RED}✗${RESET} $1"
 }
 
+init_telemetry() {
+  INSTALL_ID=""
+  TELEMETRY_ENABLED=true
+  if [ "${DRAFTED_TELEMETRY:-}" = "0" ]; then
+    TELEMETRY_ENABLED=false
+    return 0
+  fi
+  mkdir -p "$HOME/.drafted"
+  INSTALL_ID="$(node - "$HOME/.drafted/install.json" <<'NODE'
+const fs = require('fs');
+const crypto = require('crypto');
+const p = process.argv[2];
+let data = {};
+try { data = JSON.parse(fs.readFileSync(p, 'utf8')); } catch {}
+if (data.telemetry === false) process.exit(2);
+if (!/^[0-9a-f-]{36}$/i.test(String(data.installId || ''))) data.installId = crypto.randomUUID();
+data.telemetry = data.telemetry !== false;
+data.updatedAt = new Date().toISOString();
+fs.writeFileSync(p, JSON.stringify(data, null, 2) + '\n', { mode: 0o600 });
+process.stdout.write(data.installId);
+NODE
+)" || TELEMETRY_ENABLED=false
+  if [ "$TELEMETRY_ENABLED" = true ]; then
+    echo -e "    ${DIM}Drafted sends anonymous install telemetry. Set DRAFTED_TELEMETRY=0 to opt out.${RESET}"
+  fi
+}
+
+report_telemetry() {
+  [ "${TELEMETRY_ENABLED:-false}" = true ] || return 0
+  [ -n "${INSTALL_ID:-}" ] || return 0
+  local event="$1"
+  local helper_status="${2:-installed}"
+  node - "$SERVER" "$INSTALL_ID" "$event" "$INSTALLER_VERSION" "$helper_status" \
+    "${CLIENT_CLAUDE_DESKTOP:-false}" "${CLIENT_CLAUDE_CODE:-false}" "${CLIENT_CODEX:-false}" "${CLIENT_CURSOR:-false}" <<'NODE' >/dev/null 2>&1 || true
+const [server, installId, event, installerVersion, updateHelperStatus, claudeDesktop, claudeCode, codex, cursor] = process.argv.slice(2);
+const os = require('os');
+const cp = require('child_process');
+function run(cmd) { try { return cp.execSync(cmd, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim().slice(0, 80); } catch { return undefined; } }
+const platform = os.platform();
+const osFamily = platform === 'darwin' ? 'macos' : platform === 'win32' ? 'windows' : platform === 'linux' ? 'linux' : 'unknown';
+fetch(`${server}/api/installations/report`, {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json', 'User-Agent': 'Drafted Installer' },
+  body: JSON.stringify({
+    installId,
+    event,
+    schemaVersion: 1,
+    installerVersion,
+    cliVersion: run('drafted --version'),
+    osFamily,
+    osVersion: os.release(),
+    arch: os.arch(),
+    nodeVersion: process.version,
+    npmVersion: run('npm --version'),
+    clientsConfigured: {
+      claudeDesktop: claudeDesktop === 'true',
+      claudeCode: claudeCode === 'true',
+      codex: codex === 'true',
+      cursor: cursor === 'true'
+    },
+    updateHelperStatus,
+    mcpMode: 'stdio',
+    source: 'installer'
+  })
+}).catch(() => {});
+NODE
+}
+
+install_portable_node() {
+  local os arch platform filename url tmp node_dir
+  os="$(uname -s)"
+  arch="$(uname -m)"
+  case "$os" in
+    Darwin) platform="darwin" ;;
+    Linux) platform="linux" ;;
+    *) fail "Unsupported OS for automatic Node.js install: $os"; exit 1 ;;
+  esac
+  case "$arch" in
+    x86_64|amd64) arch="x64" ;;
+    arm64|aarch64) arch="arm64" ;;
+    *) fail "Unsupported CPU for automatic Node.js install: $arch"; exit 1 ;;
+  esac
+
+  mkdir -p "$HOME/.drafted"
+  node_dir="$HOME/.drafted/node"
+  tmp="$(mktemp -d)"
+  filename="$(curl -fsSL https://nodejs.org/dist/latest-v22.x/SHASUMS256.txt | awk "/node-v.*-${platform}-${arch}\\.tar\\.xz/ {print \\$2; exit}")"
+  if [ -z "$filename" ]; then
+    fail "Could not find Node.js 22 download for $platform-$arch"
+    exit 1
+  fi
+  url="https://nodejs.org/dist/latest-v22.x/$filename"
+  echo -e "    ${YELLOW}Downloading Node.js 22 for $platform-$arch...${RESET}"
+  curl -fsSL "$url" -o "$tmp/node.tar.xz"
+  rm -rf "$node_dir"
+  mkdir -p "$node_dir"
+  tar -xJf "$tmp/node.tar.xz" -C "$node_dir" --strip-components=1
+  rm -rf "$tmp"
+  export PATH="$node_dir/bin:$PATH"
+  ok "Installed portable Node.js $(node -v)"
+}
+
 # ── Welcome ───────────────────────────────────────────────────────
 
 echo ""
 echo -e "${BOLD}Welcome to Drafted${RESET}"
-echo -e "This will set up Drafted so Claude can create designs for you."
+echo -e "This will set up Drafted so your agents can create work on a shared surface."
 echo -e "It only takes a minute."
+if [ "$INSTALL_MODE" = "local" ]; then
+  echo -e "${DIM}Local mode: installing MCP ${BOLD}$INSTALL_NAME${RESET}${DIM} -> $INSTALL_SERVER without touching production drafted.${RESET}"
+fi
 
 # ── Prerequisites ─────────────────────────────────────────────────
 
@@ -48,30 +195,28 @@ step "Checking your system"
 if command -v node &>/dev/null; then
   NODE_VERSION=$(node -v | sed 's/v//' | cut -d. -f1)
   if [ "$NODE_VERSION" -lt 22 ]; then
-    fail "Node.js is too old (found $(node -v), need 22+)."
-    echo ""
-    echo -e "    Update it by running:  ${BOLD}brew upgrade node${RESET}"
-    echo -e "    Then re-run this installer."
-    exit 1
-  fi
-  ok "Node.js $(node -v)"
-else
-  fail "Node.js is not installed."
-  echo ""
-  if command -v brew &>/dev/null; then
-    echo -e "    Install it by running:  ${BOLD}brew install node${RESET}"
+    echo -e "    ${YELLOW}Node.js $(node -v) is too old; installing Node.js 22 for Drafted.${RESET}"
+    install_portable_node
   else
-    echo -e "    Download it from:  ${BOLD}https://nodejs.org${RESET}"
+    ok "Node.js $(node -v)"
   fi
-  echo -e "    Then re-run this installer."
-  exit 1
+else
+  echo -e "    ${YELLOW}Node.js is not installed; installing Node.js 22 for Drafted.${RESET}"
+  install_portable_node
 fi
 
+init_telemetry
+
+mkdir -p "$HOME/.drafted/npm-global"
+npm config set prefix "$HOME/.drafted/npm-global" >/dev/null
+export PATH="$HOME/.drafted/npm-global/bin:$PATH"
+
 # ── Install ───────────────────────────────────────────────────────
 
 step "Installing Drafted"
 
-npm install -g drafted@latest --silent 2>/dev/null
+npm install -g drafted@latest --force --silent 2>/dev/null
+hash -r 2>/dev/null || true
 ok "Installed $(drafted --version 2>/dev/null || echo 'drafted') via npm"
 
 # ── Configure ─────────────────────────────────────────────────────
@@ -80,11 +225,21 @@ step "Connecting to your tools"
 
 # Write server URL config
 mkdir -p "$HOME/.drafted"
-echo "{\"server\":\"$SERVER\"}" > "$HOME/.drafted/config.json"
-ok "Server: $SERVER"
+if [ "$INSTALL_MODE" = "production" ]; then
+  echo "{\"server\":\"$INSTALL_SERVER\"}" > "$HOME/.drafted/config.json"
+  ok "Server: $INSTALL_SERVER"
+else
+  ok "Local server: $INSTALL_SERVER"
+fi
 
-# Resolve the installed binary path for MCP configs
-DRAFTED_MCP_BIN="$(which drafted-mcp 2>/dev/null || echo "drafted-mcp")"
+# Local stdio MCP command. Production uses the installed package; --local uses this checkout when available.
+if [ "$INSTALL_MODE" = "local" ] && [ -f "$SCRIPT_DIR/mcp/server.mjs" ]; then
+  DRAFTED_MCP_COMMAND="$(command -v node)"
+  DRAFTED_MCP_ARGS_JSON="$(node -e 'console.log(JSON.stringify([process.argv[1]]))' "$SCRIPT_DIR/mcp/server.mjs")"
+else
+  DRAFTED_MCP_COMMAND="$(command -v drafted-mcp)"
+  DRAFTED_MCP_ARGS_JSON="[]"
+fi
 
 configure_mcp() {
   local config_path="$1"
@@ -96,39 +251,130 @@ configure_mcp() {
   node -e "
     const fs = require('fs');
     const p = process.argv[1];
+    const name = process.argv[2];
+    const command = process.argv[3];
+    const args = JSON.parse(process.argv[4]);
+    const server = process.argv[5];
+    const authFile = process.argv[6];
+    const mode = process.argv[7];
     let c = {};
     try { c = JSON.parse(fs.readFileSync(p, 'utf8')); } catch {}
     if (!c.mcpServers) c.mcpServers = {};
-    c.mcpServers.drafted = {
-      command: 'drafted-mcp',
-      args: []
-    };
+    const env = { DRAFTED_SERVER: server };
+    if (authFile) env.DRAFTED_AUTH_FILE = authFile;
+    if (mode === 'local') env.DRAFTED_TELEMETRY = '0';
+    c.mcpServers[name] = { command, args, env };
     fs.writeFileSync(p, JSON.stringify(c, null, 2) + '\n');
-  " "$config_path"
+  " "$config_path" "$INSTALL_NAME" "$DRAFTED_MCP_COMMAND" "$DRAFTED_MCP_ARGS_JSON" "$INSTALL_SERVER" "$INSTALL_AUTH_FILE" "$INSTALL_MODE"
+  ok "$label"
+}
+
+
+verify_no_legacy_http_config() {
+  local found=false
+  for file in "$CLAUDE_DESKTOP_CONFIG" "$CLAUDE_CODE_CONFIG" "$CURSOR_CONFIG" "$CODEX_CONFIG"; do
+    [ -f "$file" ] || continue
+    if grep -q "https://drafted.live/mcp" "$file" 2>/dev/null; then
+      found=true
+      echo -e "    ${RED}✗${RESET} Legacy HTTP Drafted MCP still present in $file"
+    fi
+  done
+  if [ "$found" = true ]; then
+    fail "Installer migration incomplete. Remove legacy https://drafted.live/mcp entries and rerun."
+    exit 1
+  fi
+}
+
+configure_codex() {
+  local config_path="$1"
+  local label="$2"
+  local config_dir
+  config_dir="$(dirname "$config_path")"
+  mkdir -p "$config_dir"
+
+  node - "$config_path" "$INSTALL_NAME" "$DRAFTED_MCP_COMMAND" "$DRAFTED_MCP_ARGS_JSON" "$INSTALL_SERVER" "$INSTALL_AUTH_FILE" "$INSTALL_MODE" <<'NODE'
+const fs = require('fs');
+const p = process.argv[2];
+const mcpName = process.argv[3];
+const command = process.argv[4];
+const args = JSON.parse(process.argv[5]);
+const server = process.argv[6];
+const authFile = process.argv[7];
+const mode = process.argv[8];
+
+let text = '';
+try { text = fs.readFileSync(p, 'utf8'); } catch {}
+
+const lines = text.split(/\r?\n/);
+const out = [];
+let skip = false;
+
+for (const line of lines) {
+  const section = line.match(/^\[(.+)\]$/);
+  if (section) {
+    const name = section[1].trim();
+    if (name === `mcp_servers.${mcpName}` || name === `mcp_servers.${mcpName}.env`) {
+      skip = true;
+      continue;
+    }
+    if (skip) skip = false;
+  }
+  if (!skip) out.push(line);
+}
+
+let next = out.join('\n').replace(/\s+$/, '');
+if (next) next += '\n\n';
+next += `[mcp_servers.${mcpName}]\n`;
+next += 'command = ' + JSON.stringify(command) + '\n';
+next += 'args = [' + args.map(a => JSON.stringify(a)).join(', ') + ']\n';
+next += `\n[mcp_servers.${mcpName}.env]\n`;
+next += 'DRAFTED_SERVER = ' + JSON.stringify(server) + '\n';
+if (authFile) next += 'DRAFTED_AUTH_FILE = ' + JSON.stringify(authFile) + '\n';
+if (mode === 'local') next += 'DRAFTED_TELEMETRY = "0"\n';
+next += '\n';
+
+fs.writeFileSync(p, next);
+NODE
+
   ok "$label"
 }
 
 CLAUDE_DESKTOP_CONFIG="$HOME/Library/Application Support/Claude/claude_desktop_config.json"
 CLAUDE_CODE_CONFIG="$HOME/.claude.json"
+CODEX_CONFIG="$HOME/.codex/config.toml"
 CURSOR_CONFIG="$HOME/.cursor/mcp.json"
 
 CONFIGURED=false
+CLIENT_CLAUDE_DESKTOP=false
+CLIENT_CLAUDE_CODE=false
+CLIENT_CODEX=false
+CLIENT_CURSOR=false
 
 # Claude Desktop
-if [ -d "/Applications/Claude.app" ] || [ -d "$HOME/Applications/Claude.app" ]; then
+if [ -d "/Applications/Claude.app" ] || [ -d "$HOME/Applications/Claude.app" ] || [ -f "$CLAUDE_DESKTOP_CONFIG" ]; then
   configure_mcp "$CLAUDE_DESKTOP_CONFIG" "Claude Desktop"
+  CLIENT_CLAUDE_DESKTOP=true
   CONFIGURED=true
 fi
 
 # Claude Code
-if command -v claude &>/dev/null; then
+if command -v claude &>/dev/null || [ -f "$CLAUDE_CODE_CONFIG" ] || [ -d "$HOME/.claude" ]; then
   configure_mcp "$CLAUDE_CODE_CONFIG" "Claude Code"
+  CLIENT_CLAUDE_CODE=true
+  CONFIGURED=true
+fi
+
+# Codex
+if command -v codex &>/dev/null || [ -d "$HOME/.codex" ]; then
+  configure_codex "$CODEX_CONFIG" "Codex"
+  CLIENT_CODEX=true
   CONFIGURED=true
 fi
 
 # Cursor
-if [ -d "/Applications/Cursor.app" ] || [ -d "$HOME/Applications/Cursor.app" ] || command -v cursor &>/dev/null; then
+if [ -d "/Applications/Cursor.app" ] || [ -d "$HOME/Applications/Cursor.app" ] || command -v cursor &>/dev/null || [ -f "$CURSOR_CONFIG" ]; then
   configure_mcp "$CURSOR_CONFIG" "Cursor"
+  CLIENT_CURSOR=true
   CONFIGURED=true
 fi
 
@@ -137,9 +383,120 @@ if [ "$CONFIGURED" = false ]; then
   echo -e "    ${YELLOW}No supported editors detected — pre-configuring all.${RESET}"
   configure_mcp "$CLAUDE_DESKTOP_CONFIG" "Claude Desktop (pre-configured)"
   configure_mcp "$CLAUDE_CODE_CONFIG" "Claude Code (pre-configured)"
+  configure_codex "$CODEX_CONFIG" "Codex (pre-configured)"
   configure_mcp "$CURSOR_CONFIG" "Cursor (pre-configured)"
+  CLIENT_CLAUDE_DESKTOP=true
+  CLIENT_CLAUDE_CODE=true
+  CLIENT_CODEX=true
+  CLIENT_CURSOR=true
 fi
 
+# ── Agent instructions ────────────────────────────────────────────
+
+step "Installing global agent instructions"
+
+load_global_agent_instructions() {
+  local local_path="$SCRIPT_DIR/agent-instructions/global.md"
+  if [ -f "$local_path" ]; then
+    cat "$local_path"
+    return 0
+  fi
+  cat <<'DRAFTED_GLOBAL_INSTRUCTIONS'
+<drafted>
+Drafted is the shared workspace for agent-produced consulting artifacts. Claude Code and Codex agents should use it proactively when the task benefits from persistent visual work, client-facing documents, reusable skills, or organization knowledge.
+
+Drafted terminology:
+- Wiki: durable organization knowledge. It may also be called the knowledge base or database. Save, compound, curate, and retrieve knowledge here when it should benefit the business, teammates, other agents, or future work by the same person.
+- Skills: reusable operating knowledge. Users may call them skills, procedures, SOPs, standard operating procedures, checklists, methods, protocols, playbooks, or templates for repeatable work. Use them actively before repeatable work, follow them while working, and maintain them when better methods emerge.
+- Projects: client-facing or reviewable work products, organized as frames on a shared surface. Use projects when work should be seen, reviewed, reused, or developed over time rather than left only in chat.
+
+Operating principle:
+- Do not treat Drafted as passive storage. Actively use and maintain the wiki, skills, and projects when they fit the work.
+- Default to creating or updating Drafted project frames for substantive outputs instead of leaving artifacts only in chat. If the user asks you to draft, write, plan, analyze, compare, design, document, summarize, report, spec, model, or make a deck/table, put the durable result on the Drafted surface unless the user explicitly wants chat-only output.
+- Put durable knowledge in the wiki, reusable methods in skills, and producible artifacts in projects.
+- Do not save reusable procedures, SOPs, checklists, methods, protocols, or repeatable work instructions to the wiki/knowledge base. Save them as Drafted skills.
+
+Before working:
+- Check whether Drafted MCP tools are available. If not authenticated, use auth(action="get_link") or auth(action="login") and give the user the sign-in link.
+- Select the correct organization first. Use get_org(action="get") and project(action="list") to identify the target org/project. Opening a project switches org context automatically; for wiki/skill-only work, use get_org(action="switch", orgId=...).
+- Check get_org(action="get") for googleDrive.connected. When Google Drive is connected for the active org, Google Workspace frames are available and should be the strong default for documents, spreadsheets, and presentations.
+- Never assume the current active Drafted project or organization is correct. Verify the returned project/org before writing.
+
+Wiki rules:
+- Search the org wiki before substantive work: wiki(action="search") with relevant keywords.
+- Read relevant pages before creating or changing artifacts.
+- Maintain the wiki when you discover durable knowledge, decisions, client constraints, project context, research notes, or facts that should compound for the business or future agents.
+- When creating or editing wiki pages, return a browser link the user can click.
+
+Skill rules:
+- Treat skill, procedure, SOP, checklist, method, protocol, playbook, and repeatable-work template as the same user intent.
+- Search skills before starting repeatable work: skill(action="search") or skill(action="list").
+- Load and follow relevant skills with skill(action="load"). Read supporting skill files when needed.
+- When the user asks to record, distill, create, save, install, or update a skill/procedure/SOP/checklist/method/protocol/playbook, create or update a Drafted skill for the org with skill tools.
+- Improve skills when you find a better checklist, standard, or operating method.
+
+Project/producible rules:
+- For client-facing, durable, or reviewable artifacts, produce the work inside the appropriate Drafted project instead of leaving it only in chat.
+- Prefer one visible frame per artifact or artifact section so the user can review, compare, and refine work on the surface.
+- Use project(action="open") before frame/asset/connector/layout changes. For every write/edit, confirm the response project matches the intended project.
+- Read anchored frames and existing neighboring frames before editing a layer.
+- After creating frames, documents, diagrams, or other producibles, use focus when available and return the clickable Drafted frame or project link.
+
+Google Workspace rules:
+- If get_org reports googleDrive.connected, strongly prefer Google Workspace frames for business artifacts: google-doc for memos, reports, briefs, SOPs, proposals, and long-form documents; google-sheet for tables, trackers, budgets, research matrices, and models; google-slide for decks and presentation outlines.
+- Create Google Workspace frames with frame(action="write", googleType="google-doc" | "google-sheet" | "google-slide", path="/{layer}/{lane}/{filename}", title="...") after opening the project.
+- For flowcharts, process maps, architecture diagrams, system diagrams, data-flow diagrams, visual maps, or other editable diagrams, load and follow the system skill `excalidraw-drafted` (Drafted Excalidraw Diagram) and create native Drafted Excalidraw frames. Use normal Drafted HTML/markdown frames for web/UI mockups, rich visual layouts, or non-editable presentation artifacts.
+- Use breadcrumbs in code or docs where useful: drafted:<frameId> for frames and drafted-project:<projectId> for projects.
+
+Collaboration rules:
+- Parallel agents must each open and verify their own Drafted project/org context.
+- If there is any doubt about the correct org, project, wiki location, or skill, ask a short clarifying question before writing.
+</drafted>
+DRAFTED_GLOBAL_INSTRUCTIONS
+}
+
+install_agent_instructions() {
+  local instructions_path="$1"
+  local label="$2"
+  local instructions_dir
+  local body
+  instructions_dir="$(dirname "$instructions_path")"
+  mkdir -p "$instructions_dir"
+
+  if ! body="$(load_global_agent_instructions)"; then
+    fail "Could not load Drafted global instructions"
+    return 1
+  fi
+
+  DRAFTED_GLOBAL_INSTRUCTIONS_BODY="$body" node - "$instructions_path" <<'NODE'
+const fs = require('fs');
+const p = process.argv[2];
+const begin = '<!-- BEGIN drafted-global-instructions -->';
+const end = '<!-- END drafted-global-instructions -->';
+const body = process.env.DRAFTED_GLOBAL_INSTRUCTIONS_BODY || '';
+if (!body.trim()) throw new Error('Drafted global instructions are empty');
+const block = `${begin}\n${body.replace(/\s+$/, '')}\n${end}`;
+let text = '';
+try { text = fs.readFileSync(p, 'utf8'); } catch {}
+const escapeRe = value => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const re = new RegExp(`${escapeRe(begin)}[\\s\\S]*?${escapeRe(end)}`);
+let next;
+if (re.test(text)) {
+  next = text.replace(re, block);
+} else {
+  next = text.replace(/\s+$/, '');
+  if (next) next += '\n\n';
+  next += block + '\n';
+}
+fs.writeFileSync(p, next.endsWith('\n') ? next : next + '\n');
+NODE
+
+  ok "$label"
+}
+
+install_agent_instructions "$HOME/.claude/CLAUDE.md" "Claude global instructions"
+install_agent_instructions "$HOME/.codex/CODEX.md" "Codex global instructions"
+
 # ── Skills ───────────────────────────────────────────────────────
 
 step "Installing skills"
@@ -170,14 +527,384 @@ else
   echo -e "    ${YELLOW}Skills directory not found in package — skipping.${RESET}"
 fi
 
+
+# ── Update menu bar helper ───────────────────────────────────────
+
+install_update_menu_icon() {
+  if [ "${DRAFTED_HEADLESS:-}" = "1" ]; then
+    echo -e "    ${YELLOW}Headless mode: skipping update menu icon.${RESET}"
+    return 0
+  fi
+  if [ "$(uname -s)" != "Darwin" ]; then
+    echo -e "    ${YELLOW}Update menu icon is only installed on macOS by this script.${RESET}"
+    return 0
+  fi
+  if ! command -v swiftc >/dev/null 2>&1; then
+    echo -e "    ${YELLOW}Swift compiler not found; skipping macOS menu bar updater.${RESET}"
+    return 0
+  fi
+
+  local work_dir install_dir app_bundle app_macos app_resources swift_file exe_path plist_dir plist uid logo_path legacy_bundle
+  work_dir="$HOME/.drafted/updater"
+  install_dir="/Applications"
+  if [ ! -w "$install_dir" ]; then
+    install_dir="$HOME/Applications"
+  fi
+  app_bundle="$install_dir/Drafted Updater.app"
+  app_macos="$app_bundle/Contents/MacOS"
+  app_resources="$app_bundle/Contents/Resources"
+  swift_file="$work_dir/DraftedUpdater.swift"
+  exe_path="$app_macos/DraftedUpdater"
+  plist_dir="$HOME/Library/LaunchAgents"
+  plist="$plist_dir/live.drafted.updater.plist"
+  uid="$(id -u)"
+  legacy_bundle="$work_dir/DraftedUpdater.app"
+  mkdir -p "$work_dir" "$install_dir" "$app_macos" "$app_resources" "$plist_dir"
+  rm -rf "$legacy_bundle"
+
+  logo_path="$app_resources/logo.svg"
+  if [ -f "$SCRIPT_DIR/server/vendor/logo.svg" ]; then
+    cp "$SCRIPT_DIR/server/vendor/logo.svg" "$logo_path"
+  else
+    curl -fsSL "$INSTALL_SERVER/vendor/logo.svg" -o "$logo_path" >/dev/null 2>&1 || true
+  fi
+  if [ -f "$logo_path" ]; then
+    perl -0pi -e 's/fill="currentColor"/fill="#FFFFFF"/g; s/fill="var\(--logo-letter, #[^)]+\)"/fill="#0A2540"/g' "$logo_path" >/dev/null 2>&1 || true
+  fi
+
+  cat > "$swift_file" <<'SWIFT'
+import SwiftUI
+import AppKit
+
+@main
+struct DraftedUpdaterApp: App {
+  init() {
+    Telemetry.report(event: "drafted_update_helper_started", updateHelperStatus: "running")
+    Telemetry.report(event: "drafted_heartbeat", updateHelperStatus: "running")
+  }
+
+  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) }
+    } label: {
+      if let image = Actions.logoImage() {
+        Image(nsImage: image)
+          .resizable()
+          .frame(width: 16, height: 18)
+          .accessibilityLabel("Drafted")
+      } else {
+        Text("Drafted")
+      }
+    }
+    .menuBarExtraStyle(.menu)
+  }
+}
+
+
+final class UpdateStatusWindow: NSWindowController {
+  private let stack = NSStackView()
+  private let spinner = NSProgressIndicator()
+  private let titleField = NSTextField(labelWithString: "Updating Drafted…")
+  private let bodyField = NSTextField(labelWithString: "Downloading and running the installer. This can take a minute.")
+  private let closeButton = NSButton(title: "OK", target: nil, action: nil)
+
+  init() {
+    let panel = NSPanel(
+      contentRect: NSRect(x: 0, y: 0, width: 380, height: 168),
+      styleMask: [.titled, .closable],
+      backing: .buffered,
+      defer: false
+    )
+    panel.title = "Drafted Update"
+    panel.isReleasedWhenClosed = false
+    panel.level = .floating
+    super.init(window: panel)
+
+    stack.orientation = .vertical
+    stack.alignment = .centerX
+    stack.spacing = 12
+    stack.translatesAutoresizingMaskIntoConstraints = false
+
+    spinner.style = .spinning
+    spinner.controlSize = .regular
+
+    titleField.font = NSFont.systemFont(ofSize: 16, weight: .semibold)
+    titleField.alignment = .center
+
+    bodyField.font = NSFont.systemFont(ofSize: 13)
+    bodyField.textColor = .secondaryLabelColor
+    bodyField.alignment = .center
+    bodyField.maximumNumberOfLines = 3
+    bodyField.lineBreakMode = .byWordWrapping
+
+    closeButton.target = self
+    closeButton.action = #selector(closeClicked)
+    closeButton.isHidden = true
+
+    stack.addArrangedSubview(spinner)
+    stack.addArrangedSubview(titleField)
+    stack.addArrangedSubview(bodyField)
+    stack.addArrangedSubview(closeButton)
+
+    panel.contentView = NSView()
+    panel.contentView?.addSubview(stack)
+    NSLayoutConstraint.activate([
+      stack.leadingAnchor.constraint(equalTo: panel.contentView!.leadingAnchor, constant: 28),
+      stack.trailingAnchor.constraint(equalTo: panel.contentView!.trailingAnchor, constant: -28),
+      stack.centerYAnchor.constraint(equalTo: panel.contentView!.centerYAnchor)
+    ])
+  }
+
+  required init?(coder: NSCoder) { fatalError("init(coder:) has not been implemented") }
+
+  func showUpdating() {
+    titleField.stringValue = "Updating Drafted…"
+    bodyField.stringValue = "Downloading and running the installer. This can take a minute."
+    closeButton.isHidden = true
+    spinner.isHidden = false
+    spinner.startAnimation(nil)
+    NSApp.activate(ignoringOtherApps: true)
+    showWindow(nil)
+    window?.center()
+  }
+
+  func showCompleted(success: Bool, message: String) {
+    spinner.stopAnimation(nil)
+    spinner.isHidden = true
+    titleField.stringValue = success ? "Update completed" : "Update failed"
+    bodyField.stringValue = message
+    closeButton.isHidden = false
+    NSApp.activate(ignoringOtherApps: true)
+    showWindow(nil)
+    window?.center()
+  }
+
+  @objc private func closeClicked() { window?.close() }
+}
+
+struct Actions {
+  static func logoImage() -> NSImage? {
+    guard
+      let url = Bundle.main.url(forResource: "logo", withExtension: "svg"),
+      let image = NSImage(contentsOf: url)
+    else { return nil }
+    image.size = NSSize(width: 16, height: 18)
+    image.isTemplate = false
+    return image
+  }
+
+  private static var isUpdating = false
+  private static var updateWindow: UpdateStatusWindow?
+
+  static func updateDrafted() {
+    if isUpdating {
+      updateWindow?.showUpdating()
+      return
+    }
+
+    isUpdating = true
+    let statusWindow = UpdateStatusWindow()
+    updateWindow = statusWindow
+    statusWindow.showUpdating()
+
+    let command = "tmp=$(mktemp); curl -fsSL https://drafted.live/install.sh -o \"$tmp\" && bash \"$tmp\""
+    let process = Process()
+    process.executableURL = URL(fileURLWithPath: "/bin/bash")
+    process.arguments = ["-lc", command]
+    process.terminationHandler = { proc in
+      if proc.terminationStatus != 0 {
+        Telemetry.report(event: "drafted_update_helper_failed", updateHelperStatus: "failed", errorCode: "installer_exit_\(proc.terminationStatus)")
+      }
+      DispatchQueue.main.async {
+        isUpdating = false
+        let success = proc.terminationStatus == 0
+        statusWindow.showCompleted(
+          success: success,
+          message: success ? "Restart your editor to use the latest MCP tools." : "Run the Drafted installer again from drafted.live/install."
+        )
+      }
+    }
+    do { try process.run() } catch {
+      isUpdating = false
+      Telemetry.report(event: "drafted_update_helper_failed", updateHelperStatus: "failed", errorCode: "process_run_failed")
+      statusWindow.showCompleted(success: false, message: error.localizedDescription)
+      return
+    }
+  }
+
+  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")!)
+  }
+}
+
+struct Telemetry {
+  static func report(event: String, updateHelperStatus: String, errorCode: String? = nil) {
+    guard ProcessInfo.processInfo.environment["DRAFTED_TELEMETRY"] != "0" else { return }
+    let path = FileManager.default.homeDirectoryForCurrentUser.appendingPathComponent(".drafted/install.json")
+    guard
+      let data = try? Data(contentsOf: path),
+      let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+      json["telemetry"] as? Bool != false,
+      let installId = json["installId"] as? String
+    else { return }
+    var body: [String: Any] = [
+      "installId": installId,
+      "event": event,
+      "schemaVersion": 1,
+      "osFamily": "macos",
+      "osVersion": ProcessInfo.processInfo.operatingSystemVersionString,
+      "arch": SystemVersion.machine,
+      "updateHelperStatus": updateHelperStatus,
+      "source": "macos-helper"
+    ]
+    if let errorCode = errorCode { body["errorCode"] = errorCode }
+    guard
+      let url = URL(string: "https://drafted.live/api/installations/report"),
+      let payload = try? JSONSerialization.data(withJSONObject: body)
+    else { return }
+    var request = URLRequest(url: url)
+    request.httpMethod = "POST"
+    request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+    request.httpBody = payload
+    URLSession.shared.dataTask(with: request).resume()
+  }
+}
+
+enum SystemVersion {
+  static var machine: String {
+    #if arch(arm64)
+    return "arm64"
+    #elseif arch(x86_64)
+    return "x64"
+    #else
+    return "unknown"
+    #endif
+  }
+}
+SWIFT
+
+  cat > "$app_bundle/Contents/Info.plist" <<APPPLIST
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleExecutable</key>
+  <string>DraftedUpdater</string>
+  <key>CFBundleIdentifier</key>
+  <string>live.drafted.updater</string>
+  <key>CFBundleName</key>
+  <string>Drafted Updater</string>
+  <key>CFBundleDisplayName</key>
+  <string>Drafted Updater</string>
+  <key>CFBundlePackageType</key>
+  <string>APPL</string>
+  <key>CFBundleShortVersionString</key>
+  <string>1.0</string>
+  <key>LSMinimumSystemVersion</key>
+  <string>13.0</string>
+  <key>LSUIElement</key>
+  <true/>
+  <key>NSHighResolutionCapable</key>
+  <true/>
+</dict>
+</plist>
+APPPLIST
+
+  if ! swiftc -parse-as-library "$swift_file" -o "$exe_path" -framework SwiftUI -framework AppKit >/dev/null 2>&1; then
+    echo -e "    ${YELLOW}Could not build macOS menu bar updater; skipping.${RESET}"
+    return 0
+  fi
+  codesign -s - -f "$exe_path" >/dev/null 2>&1 || true
+
+  cat > "$plist" <<PLIST
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>live.drafted.updater</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>open</string>
+    <string>-a</string>
+    <string>$app_bundle</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <false/>
+</dict>
+</plist>
+PLIST
+
+  launchctl bootout "gui/$uid" "$plist" >/dev/null 2>&1 || true
+  pkill -x DraftedUpdater >/dev/null 2>&1 || true
+  mdimport "$app_bundle" >/dev/null 2>&1 || true
+  open "$app_bundle" >/dev/null 2>&1 || true
+  ok "macOS menu bar updater"
+}
+if [ "$INSTALL_MODE" = "production" ]; then
+  step "Installing update helper"
+  install_update_menu_icon
+fi
+verify_no_legacy_http_config
+report_telemetry "drafted_mcp_configured" "installed"
+report_telemetry "drafted_install" "installed"
+
 # ── Done ─────────────────────────────────────────────────────────
 
 echo ""
 echo ""
 echo -e "${GREEN}${BOLD}You're all set!${RESET}"
 echo ""
-echo -e "  ${DIM}View your designs at:${RESET}  ${BOLD}https://drafted.live${RESET}"
-echo -e "  ${DIM}To update:${RESET}     npm install -g drafted@latest"
+echo -e "  ${DIM}MCP name:${RESET}  ${BOLD}$INSTALL_NAME${RESET}"
+echo -e "  ${DIM}Server:${RESET}    ${BOLD}$INSTALL_SERVER${RESET}"
+echo -e "  ${DIM}To update production:${RESET}  rerun curl -fsSL https://drafted.live/install.sh | bash"
 echo -e "  ${DIM}To uninstall:${RESET}  npm uninstall -g drafted && rm -rf ~/.drafted"
 echo ""
 echo -e "${YELLOW}${BOLD}"
@@ -186,7 +913,7 @@ echo "  │                                                         │"
 echo "  │   >>>  RESTART YOUR EDITOR TO ACTIVATE DRAFTED  <<<     │"
 echo "  │                                                         │"
 echo "  │   Close and reopen Claude Desktop, Claude Code,         │"
-echo "  │   or Cursor so it picks up the new MCP server.          │"
+echo "  │   Codex, or Cursor so it picks up the new MCP server.   │"
 echo "  │                                                         │"
 echo "  └─────────────────────────────────────────────────────────┘"
 echo -e "${RESET}"