drafted 1.24.2 → 1.24.4

package/package.json

@@ -1,44 +1,38 @@
 {
   "name": "drafted",
-  "version": "1.24.2",
-  "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.",
+  "version": "1.24.4",
+  "description": "Shared surface for AI-human collaboration — MCP server and CLI",
   "type": "module",
   "bin": {
     "drafted": "./cli/drafted.mjs",
     "drafted-mcp": "./mcp/server.mjs"
   },
   "files": [
-    "cli/",
     "mcp/",
-    "server/lib/umami.mjs",
-    "src/shared/",
-    "agent-instructions/",
-    "plugin/skills/",
-    "plugin/commands/",
-    "install-mcp.sh"
-  ],
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/ddfourtwo/drafted.git"
-  },
-  "keywords": [
-    "design",
-    "canvas",
-    "preview",
-    "html",
-    "claude"
+    "cli/",
+    "shared/",
+    "skills/",
+    "README.md"
   ],
   "dependencies": {
-    "@modelcontextprotocol/ext-apps": "^1.6.0",
     "@modelcontextprotocol/sdk": "^1.27.1",
     "commander": "^11.1.0",
     "qrcode-terminal": "^0.12.0",
-    "ws": "^8.21.3",
-    "yaml": "^2.8.3",
+    "ws": "^8.16.0",
     "zod": "^4.3.6"
   },
-  "scripts": {
-    "postpublish": "bash ../scripts/sync-plugin.sh \"chore: sync plugin to v$npm_package_version\" && bash ../scripts/sync-web-plugin.sh \"chore: sync web-plugin to v$npm_package_version\""
-  }
+  "keywords": [
+    "drafted",
+    "design",
+    "mcp",
+    "claude",
+    "ai",
+    "canvas"
+  ],
+  "author": "ddfourtwo",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ddfourtwo/drafted.git"
+  },
+  "license": "MIT"
 }

package/skills/import-website-to-drafted.md

@@ -0,0 +1,329 @@
+---
+description: Import an existing website into Drafted as a design frame. Renders the page in a headless browser to capture the full DOM (including SPA content), downloads all assets, rewrites paths, then uploads via MCP tools.
+argument-hint: "[URL or local path, e.g., 'https://example.com' or './dist']"
+---
+# /import-website-to-drafted
+
+Import a website into Drafted as a fully rendered frame with all its assets.
+
+> **Partially stale — steps 4-6 predate the `fs` tool grammar.** `write`, `batch`,
+> `upload_asset` and `list_assets` are retired MCP tools; asset upload now goes
+> through `fs(write, ..., file_path=...)`. Step 1 and the Puppeteer capture
+> (steps 2-3) are current. Verify tool names against `fs` before relying on the
+> later steps.
+
+## How it works
+
+Drafted frames render in iframes. The server injects a `<base>` tag so relative paths like `<link href="css/styles.css">` resolve to the frame's assets in R2 storage. You write the HTML as a frame with `fs(write, ...)`, and all referenced files (CSS, JS, images, fonts) alongside it.
+
+**Most modern sites are SPAs** (React, Framer, Webflow, Next.js) where the HTML source is just a shell and the real content is rendered by JavaScript. A simple HTTP fetch won't capture the content. This skill uses Puppeteer to render the page fully before capturing.
+
+## Step 1: Pick the project
+
+There is no create-then-open step: the project is part of the path, and writing
+into a project that does not exist creates it. Address it directly.
+
+```
+fs(write, path="/o/<org>/projects/my-import/designs/homepage/index.html", ...)
+```
+
+To see what already exists first, `fs(ls, path="/o/<org>/projects")` lists them
+and `fs(search, path="/o/<org>/projects", query="<terms>")` finds one by name —
+do not enumerate the whole org to pick a project you can already name.
+
+## Step 2: Ensure Puppeteer is available
+
+```bash
+npm ls puppeteer 2>/dev/null || npm install puppeteer
+```
+
+## Step 3: Render, capture, and download assets
+
+Run this script locally. It launches a headless browser, renders the page fully (including SPA content), captures the complete DOM, then downloads all external assets and rewrites URLs to relative paths.
+
+**Adapt `SITE_URL` as needed:**
+
+```bash
+node -e "
+const puppeteer = require('puppeteer');
+const https = require('https');
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const { URL } = require('url');
+
+const SITE_URL = 'https://example.com';  // ← CHANGE THIS
+const OUT_DIR = '/tmp/site-import';
+
+// ── Helpers ──────────────────────────────────────────────────────
+
+function download(url) {
+  return new Promise((resolve, reject) => {
+    const mod = url.startsWith('https') ? https : http;
+    mod.get(url, { headers: { 'User-Agent': 'Mozilla/5.0' } }, res => {
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        return download(res.headers.location).then(resolve, reject);
+      }
+      if (res.statusCode >= 400) return reject(new Error('HTTP ' + res.statusCode));
+      const chunks = [];
+      res.on('data', c => chunks.push(c));
+      res.on('end', () => resolve(Buffer.concat(chunks)));
+      res.on('error', reject);
+    }).on('error', reject);
+  });
+}
+
+function urlToAssetPath(urlStr) {
+  try {
+    const u = new URL(urlStr);
+    const domain = u.hostname.replace(/[^a-z0-9.-]/g, '_');
+    let p = u.pathname.replace(/[?#].*/, '');
+    if (!p || p === '/') p = '/index';
+    if (!path.extname(p)) {
+      // Guess extension from common patterns
+      if (urlStr.includes('font') || urlStr.includes('woff')) p += '.woff2';
+      else if (urlStr.includes('css') || urlStr.includes('stylesheet')) p += '.css';
+      else p += '.bin';
+    }
+    return 'assets/' + domain + p;
+  } catch { return null; }
+}
+
+const MIME_BY_EXT = {
+  '.css': 'text/css', '.js': 'application/javascript', '.mjs': 'application/javascript',
+  '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif',
+  '.webp': 'image/webp', '.svg': 'image/svg+xml', '.ico': 'image/x-icon',
+  '.woff': 'font/woff', '.woff2': 'font/woff2', '.ttf': 'font/ttf', '.otf': 'font/otf',
+  '.json': 'application/json', '.pdf': 'application/pdf',
+};
+
+// ── Main ─────────────────────────────────────────────────────────
+
+(async () => {
+  fs.mkdirSync(OUT_DIR, { recursive: true });
+
+  // 1. Render the page in a real browser
+  console.log('Launching browser...');
+  const browser = await puppeteer.launch({
+    headless: true,
+    args: ['--no-sandbox', '--disable-setuid-sandbox'],
+  });
+  const page = await browser.newPage();
+  await page.setViewport({ width: 1440, height: 900 });
+
+  console.log('Navigating to', SITE_URL);
+  await page.goto(SITE_URL, { waitUntil: 'networkidle0', timeout: 30000 });
+
+  // Scroll to bottom to trigger lazy-loaded content
+  await page.evaluate(async () => {
+    await new Promise(resolve => {
+      let total = 0;
+      const timer = setInterval(() => {
+        window.scrollBy(0, 400);
+        total += 400;
+        if (total >= document.body.scrollHeight) { clearInterval(timer); resolve(); }
+      }, 100);
+      setTimeout(() => { clearInterval(timer); resolve(); }, 5000);
+    });
+    window.scrollTo(0, 0);
+  });
+  await new Promise(r => setTimeout(r, 1000)); // let lazy content settle
+
+  // 2. Capture the fully rendered DOM
+  let html = await page.content();
+  const pageHeight = await page.evaluate(() => document.documentElement.scrollHeight);
+  console.log('Captured rendered DOM (' + (html.length / 1024).toFixed(0) + ' KB, page height: ' + pageHeight + 'px)');
+
+  // 3. Capture computed styles and inline them (prevents style loss)
+  const inlineStyles = await page.evaluate(() => {
+    const styles = [];
+    for (const sheet of document.styleSheets) {
+      try {
+        const rules = Array.from(sheet.cssRules || []).map(r => r.cssText).join('\\n');
+        if (rules) styles.push(rules);
+      } catch { /* cross-origin stylesheet, skip */ }
+    }
+    return styles.join('\\n');
+  });
+
+  await browser.close();
+
+  // 4. Find all external URLs in the rendered HTML + inline styles
+  const combined = html + '\\n' + inlineStyles;
+  const urlPattern = /(?:src|href|srcset)=[\"']?(https?:\\/\\/[^\"'\\s,>]+)[\"']?|url\\([\"']?(https?:\\/\\/[^\"')]+)[\"']?\\)/g;
+  const skipDomains = ['google-analytics.com', 'googletagmanager.com', 'segment.com', 'hotjar.com', 'facebook.net', 'events.framer.com'];
+  const assetExtensions = /\\.(css|js|mjs|json|png|jpe?g|gif|webp|svg|ico|woff2?|ttf|otf|eot|mp4|webm|pdf)(\\?|$)/i;
+
+  const assets = new Map();
+  let match;
+  while ((match = urlPattern.exec(combined)) !== null) {
+    const url = (match[1] || match[2] || '').split(/[\\s,]/)[0]; // handle srcset
+    if (!url || assets.has(url)) continue;
+    try { if (skipDomains.some(d => url.includes(d))) continue; } catch {}
+    if (!assetExtensions.test(url) && !url.includes('font') && !url.includes('woff')) continue;
+    const assetPath = urlToAssetPath(url);
+    if (assetPath) assets.set(url, assetPath);
+  }
+
+  console.log('Found', assets.size, 'assets to download');
+
+  // 5. Download each asset
+  let downloaded = 0, failed = 0;
+  for (const [url, relPath] of assets) {
+    const outPath = path.join(OUT_DIR, relPath);
+    fs.mkdirSync(path.dirname(outPath), { recursive: true });
+    try {
+      const data = await download(url);
+      fs.writeFileSync(outPath, data);
+      downloaded++;
+    } catch (e) {
+      console.error('  FAILED:', url.substring(0, 80), e.message);
+      failed++;
+      assets.delete(url); // remove so we don't rewrite to a missing file
+    }
+  }
+  console.log('Downloaded:', downloaded, '| Failed:', failed);
+
+  // 6. Rewrite URLs in HTML AND in downloaded text files (CSS, JS, MJS)
+  const rewriteTargets = [{ content: html, path: path.join(OUT_DIR, 'index.html') }];
+  for (const [, relPath] of assets) {
+    const ext = path.extname(relPath).toLowerCase();
+    if (['.css', '.js', '.mjs', '.json', '.svg'].includes(ext)) {
+      const filePath = path.join(OUT_DIR, relPath);
+      if (fs.existsSync(filePath)) {
+        rewriteTargets.push({ content: fs.readFileSync(filePath, 'utf8'), path: filePath });
+      }
+    }
+  }
+
+  for (const target of rewriteTargets) {
+    let content = target.content;
+    for (const [url, relPath] of assets) {
+      // In the main HTML, use relative paths directly
+      // In asset files, compute the relative path from the asset to the referenced asset
+      if (target.path.endsWith('index.html')) {
+        content = content.split(url).join(relPath);
+      } else {
+        const fromDir = path.dirname(target.path.replace(OUT_DIR + '/', ''));
+        const toPath = relPath;
+        const rel = path.relative(fromDir, toPath);
+        content = content.split(url).join(rel);
+      }
+    }
+    if (target.path.endsWith('index.html')) html = content;
+    fs.writeFileSync(target.path, content);
+  }
+
+  // 7. Inject captured styles into the HTML (ensures styles survive without external sheets)
+  if (inlineStyles) {
+    const styleTag = '<style id=\"captured-styles\">' + inlineStyles + '</style>';
+    if (html.includes('</head>')) {
+      html = html.replace('</head>', styleTag + '</head>');
+    } else {
+      html = styleTag + html;
+    }
+  }
+
+  // 8. Clean up HTML
+  html = html.replace(/<base[^>]*>/gi, '');
+  html = html.replace(/<meta[^>]*Content-Security-Policy[^>]*>/gi, '');
+  html = html.replace(/<script[^>]*(?:analytics|gtag|segment|hotjar|events\\.framer)[^>]*>.*?<\\/script>/gis, '');
+  html = html.replace(/navigator\\.serviceWorker\\.register\\([^)]*\\)/g, '');
+  html = html.replace(/\\/\\/# sourceMappingURL=[^\\n]*/g, '');
+
+  // 9. Write final HTML
+  fs.writeFileSync(path.join(OUT_DIR, 'index.html'), html);
+
+  // 10. Write manifest
+  const manifest = Array.from(assets.entries()).map(([url, relPath]) => ({
+    asset_path: relPath,
+    file_path: path.join(OUT_DIR, relPath),
+    exists: fs.existsSync(path.join(OUT_DIR, relPath)),
+  })).filter(a => a.exists);
+  fs.writeFileSync(path.join(OUT_DIR, 'manifest.json'), JSON.stringify(manifest, null, 2));
+
+  console.log('\\nOutput:', OUT_DIR);
+  console.log('HTML:', path.join(OUT_DIR, 'index.html'), '(' + (html.length / 1024).toFixed(0) + ' KB)');
+  console.log('Page height:', pageHeight, 'px (use this for frame height)');
+  console.log('Manifest:', manifest.length, 'assets ready to upload');
+})().catch(e => { console.error(e); process.exit(1); });
+"
+```
+
+This outputs:
+- `/tmp/site-import/index.html` — fully rendered HTML with relative paths and captured styles
+- `/tmp/site-import/assets/...` — all downloaded assets (with URLs rewritten inside CSS/JS files too)
+- `/tmp/site-import/manifest.json` — asset list for the upload step
+- The page height in pixels (use this for the frame height)
+
+**Key improvements over a plain HTTP fetch:**
+- Renders the page in a real browser — captures SPA content (React, Framer, Webflow, etc.)
+- Scrolls to trigger lazy-loaded images and content
+- Captures computed CSS and inlines it — styles survive even if external sheets fail
+- Rewrites URLs inside CSS and JS files, not just HTML
+- Handles `srcset` attributes
+
+## Step 4: Write the frame
+
+Use `file_path` to write the HTML directly from disk — this handles large files that won't fit in a `content` parameter:
+
+```
+write({
+  path: "/designs/my-site/homepage.html",
+  file_path: "/tmp/site-import/index.html",
+  width: 1440,
+  height: <page-height-from-script-output>
+})
+```
+
+The `write` tool reads `.html` files as inline content (not binary), so the frame gets proper base tag injection and all relative asset paths will resolve. Note the frame ID in the response — you'll use it in the next step.
+
+**Use the page height from the script output** as the frame height so the full page is visible without scrolling within the frame.
+
+## Step 5: Upload assets
+
+Read `manifest.json` and batch upload all assets:
+
+```
+batch({
+  operations: [
+    { tool: "upload_asset", asset_path: "assets/fonts.gstatic.com/s/outfit/v14/abc.woff2", file_path: "/tmp/site-import/assets/fonts.gstatic.com/s/outfit/v14/abc.woff2", frame_id: "<frame-id>" },
+    { tool: "upload_asset", asset_path: "assets/cdn.example.com/img/hero.png", file_path: "/tmp/site-import/assets/cdn.example.com/img/hero.png", frame_id: "<frame-id>" },
+    // ... one entry per asset from manifest.json
+  ]
+})
+```
+
+Associate assets with the frame via `frame_id` so they're cleaned up if the frame is deleted.
+
+**For large manifests (30+ assets):** Split into batches of 20-30 operations to avoid timeouts.
+
+## Step 6: Verify
+
+```
+screenshot({ target: "/designs/my-site/homepage.html", fullPage: true })
+```
+
+Check for missing images, broken styles, or layout issues. If assets are missing, check `list_assets({ frame_id: "..." })` against the manifest.
+
+## For local build directories
+
+If importing from a local build output (e.g., `./dist` from Vite, `./build` from CRA):
+
+1. Skip the Puppeteer step — read `index.html` directly
+2. Find all asset references in the HTML
+3. Copy assets to `/tmp/site-import/assets/` preserving relative paths
+4. `write` the HTML + `batch upload_asset` the assets
+
+The Puppeteer approach is only needed for live URLs where JS rendering matters.
+
+## Common issues
+
+| Problem | Cause | Fix |
+|---------|-------|-----|
+| Blank frame | CSP meta tag not stripped | Check the cleanup regex caught it |
+| Missing images | `srcset` or `<picture>` not captured | Add patterns for these to the URL regex |
+| Broken layout | Computed styles not captured | Check the inlined `<style id="captured-styles">` tag |
+| 404 on assets | URL rewriting missed some references | Check downloaded CSS/JS files for un-rewritten absolute URLs |
+| Frame too short | Used default height instead of page height | Use the page height from script output |
+| Puppeteer not found | Not installed | Run `npm install puppeteer` first |

package/agent-instructions/global.md

@@ -1,3 +0,0 @@
-<drafted>
-You have Drafted MCP tools — a shared surface for durable, reviewable work: produce substantive output as frames on the surface (not only in chat), put knowledge in the org wiki, and encode repeatable methods as skills. The full operating manual is the `drafted` skill installed with the plugin — follow it when working with Drafted. Address orgs by path: `fs(ls, path="/")` lists them, and `/o/<org>/<root>/...` (root ∈ wiki, skills, projects) is the canonical path form — the org is part of the path, never a separate switch. Before writing, verify the org/project echoed in the response is the one you intend.
-</drafted>

package/cli/google-setup.sh

@@ -1,186 +0,0 @@
-#!/bin/bash
-# Connect the user's OWN Google account to their local agent, through Google's
-# Workspace CLI (`gws`, npm @googleworkspace/cli) and a Cloud project THEY own.
-#
-# Why not Drafted's Google connection: full-inbox read needs a restricted Gmail
-# scope, and a restricted scope on Drafted's consent screen means an annual,
-# paid CASA assessment (see GOOGLE_SCOPES in server/lib/google-auth.mjs). On the
-# user's own project the scope is theirs, the token stays on this machine
-# (encrypted, OS keyring), and Drafted's servers never see a message. The agent
-# reads source material with `gws`; Drafted holds the work it produces.
-#
-# Run by install-mcp.sh (interactive installs only) and by `drafted google-setup`.
-#   --from-installer   remember a "no" so the auto-updater's re-runs never re-ask
-set -e
-
-FROM_INSTALLER=0
-[ "${1:-}" = "--from-installer" ] && FROM_INSTALLER=1
-
-BOLD="\033[1m"; DIM="\033[2m"; GREEN="\033[32m"; YELLOW="\033[33m"; RED="\033[31m"; RESET="\033[0m"
-say() { echo -e "    $1"; }
-ok() { echo -e "    ${GREEN}✓${RESET} $1"; }
-warn() { echo -e "    ${YELLOW}!${RESET} $1"; }
-# Prompts read the terminal, not stdin (stdin may be a pipe). DRAFTED_TTY lets
-# the test feed answers from a file.
-TTY="${DRAFTED_TTY:-/dev/tty}"
-exec 3<"$TTY" 2>/dev/null || exec 3</dev/null
-ask() { local reply; read -r -p "    $1 " reply <&3 || reply=""; echo "$reply"; }
-pause() { read -r -p "    $1 — press Enter when done " _ <&3 || true; }
-open_url() {
-  say "${DIM}$1${RESET}"
-  if command -v open >/dev/null 2>&1; then open "$1" >/dev/null 2>&1 || true
-  elif command -v xdg-open >/dev/null 2>&1; then xdg-open "$1" >/dev/null 2>&1 || true
-  fi
-}
-
-DRAFTED_HOME="$HOME/.drafted"
-DECLINED_MARKER="$DRAFTED_HOME/google-setup.declined"
-NPM_GLOBAL_PREFIX="${NPM_GLOBAL_PREFIX:-$DRAFTED_HOME/npm-global}"
-GWS_CONFIG_DIR="${GOOGLE_WORKSPACE_CLI_CONFIG_DIR:-$HOME/.config/gws}"
-# Read-only, deliberately: the agent reads with gws, and EVERY send goes through
-# Drafted's send_email action, which the user approves in the Drafted UI. A
-# send-capable gws token would be a way around that approval.
-GWS_SERVICES="gmail,drive,calendar,docs,sheets"
-APIS="gmail.googleapis.com,drive.googleapis.com,calendar-json.googleapis.com,docs.googleapis.com,sheets.googleapis.com"
-
-# `gws auth status` prints JSON; read ONE field without echoing the rest (it
-# carries the account's client id and scopes, which don't belong in a log).
-gws_status_field() {
-  "$GWS" auth status 2>/dev/null | node -e '
-    let s = ""; process.stdin.on("data", (d) => (s += d)).on("end", () => {
-      let j = {}; try { j = JSON.parse(s); } catch {}
-      const f = process.argv[1];
-      if (f === "gmail") return console.log((j.has_refresh_token && (j.scopes || []).some((x) => x.includes("/auth/gmail"))) ? "yes" : "no");
-      console.log(j[f] === undefined || j[f] === null ? "" : String(j[f]));
-    });' "$1"
-}
-
-# Replies to email threads you connect to a project are noticed on THIS computer:
-# `drafted mail-watch` checks them every 5 minutes with your read-only gws sign-in
-# and tells Drafted only that a new message arrived. Idempotent.
-install_watcher() {
-  # DRAFTED_NO_WATCHER: tests must never load a real LaunchAgent.
-  [ -z "${DRAFTED_NO_WATCHER:-}" ] && [ "$(uname -s)" = "Darwin" ] || return 0
-  local drafted_bin; drafted_bin="$(command -v drafted 2>/dev/null || echo "$NPM_GLOBAL_PREFIX/bin/drafted")"
-  [ -x "$drafted_bin" ] || return 0
-  "$drafted_bin" mail-watch --install >/dev/null 2>&1 && ok "Checking connected email threads for replies every 5 minutes" || true
-}
-
-# ── The gws CLI ─────────────────────────────────────────────────
-# Resolve Google's gws specifically: Homebrew's `gws` formula is an unrelated
-# git-workspace tool that installs a binary of the same name.
-GWS=""
-for candidate in "$NPM_GLOBAL_PREFIX/bin/gws" "$(command -v gws 2>/dev/null || true)"; do
-  if [ -n "$candidate" ] && [ -x "$candidate" ] && "$candidate" --help 2>&1 | grep -q "Google Workspace"; then
-    GWS="$candidate"; break
-  fi
-done
-# Already connected: nothing to ask. Checked BEFORE the consent prompt so an
-# interactive installer re-run doesn't re-pitch a finished setup.
-if [ -n "$GWS" ] && [ "$(gws_status_field gmail)" = "yes" ]; then
-  ok "Google is connected for your agent (gws)"
-  install_watcher
-  exit 0
-fi
-
-# ── Consent ───────────────────────────────────────────────────────
-echo ""
-echo -e "  ${BOLD}Let your agent read your Gmail, Drive and Calendar${RESET} ${DIM}(optional, ~5 minutes)${RESET}"
-say "Your agent (Claude or Codex) can then find the work already sitting in your inbox"
-say "and files, and build it out on your Drafted surface."
-say "${DIM}• Uses a Google Cloud project that YOU own — not a Drafted app.${RESET}"
-say "${DIM}• Read-only. The login token is stored encrypted on this machine only.${RESET}"
-say "${DIM}• Drafted's servers never receive your mail. Only what you ask your agent to${RESET}"
-say "${DIM}  put on a surface is uploaded.${RESET}"
-answer="$(ask "Set this up now? [y/N]")"
-case "$answer" in
-  [yY]*) /bin/rm -f "$DECLINED_MARKER" ;;
-  *)
-    [ "$FROM_INSTALLER" = 1 ] && { mkdir -p "$DRAFTED_HOME"; : > "$DECLINED_MARKER"; }
-    say "${DIM}Skipped. Run ${BOLD}drafted google-setup${RESET}${DIM} any time.${RESET}"
-    exit 0
-    ;;
-esac
-
-if [ -z "$GWS" ]; then
-  say "Installing Google's Workspace CLI (gws)..."
-  npm install -g @googleworkspace/cli --prefix "$NPM_GLOBAL_PREFIX" >/dev/null
-  GWS="$NPM_GLOBAL_PREFIX/bin/gws"
-fi
-ok "gws $("$GWS" --version 2>/dev/null | head -1 | sed 's/^gws //')"
-
-# ── Your Cloud project + OAuth client ───────────────────────────
-account_type="$(ask "Is this a Google Workspace (work/school) account, or a personal @gmail.com? [w/p]")"
-
-if [ "$(gws_status_field client_config_exists)" != "true" ]; then
-  if command -v gcloud >/dev/null 2>&1; then
-    say "gcloud found — ${BOLD}gws auth setup${RESET} will sign you in, create a project and enable the APIs."
-    "$GWS" auth setup || warn "gws auth setup did not finish — continuing with the manual steps."
-  else
-    say "${DIM}gcloud not installed — doing the same steps in the Cloud Console instead.${RESET}"
-  fi
-fi
-
-PROJECT_ID="$(gws_status_field project_id)"
-[ -z "$PROJECT_ID" ] && command -v gcloud >/dev/null 2>&1 && PROJECT_ID="$(gcloud config get-value project 2>/dev/null || true)"
-if [ -z "$PROJECT_ID" ]; then
-  say "Create a Cloud project (any name, e.g. ${BOLD}my-agent${RESET}):"
-  open_url "https://console.cloud.google.com/projectcreate"
-  PROJECT_ID="$(ask "Paste the project ID:")"
-  [ -z "$PROJECT_ID" ] && { warn "No project ID — stopping. Run ${BOLD}drafted google-setup${RESET} to resume."; exit 1; }
-fi
-ok "Project $PROJECT_ID"
-
-if [ "$(gws_status_field client_config_exists)" != "true" ]; then
-  say ""
-  say "${BOLD}a.${RESET} Enable the Gmail, Drive, Calendar, Docs and Sheets APIs (click Enable):"
-  open_url "https://console.cloud.google.com/flows/enableapi?apiid=$APIS&project=$PROJECT_ID"
-  pause "APIs enabled"
-  say "${BOLD}b.${RESET} Name the app (e.g. ${BOLD}My agent${RESET}) and pick your own email as support contact:"
-  open_url "https://console.cloud.google.com/auth/branding?project=$PROJECT_ID"
-  case "$account_type" in
-    [wW]*) say "   Audience: choose ${BOLD}Internal${RESET} — only your organisation, no review needed." ;;
-    *)     say "   Audience: choose ${BOLD}External${RESET}." ;;
-  esac
-  pause "Branding saved"
-  say "${BOLD}c.${RESET} Create an OAuth client: type ${BOLD}Desktop app${RESET} → Create → ${BOLD}Download JSON${RESET}:"
-  open_url "https://console.cloud.google.com/auth/clients/create?project=$PROJECT_ID"
-  pause "JSON downloaded"
-  secret="$(ls -t "$HOME"/Downloads/client_secret_*.json 2>/dev/null | head -1 || true)"
-  if [ -z "$secret" ]; then
-    secret="$(ask "Couldn't find client_secret_*.json in Downloads. Path to the file:")"
-  fi
-  [ -f "$secret" ] || { warn "No client file — stopping. Run ${BOLD}drafted google-setup${RESET} to resume."; exit 1; }
-  mkdir -p "$GWS_CONFIG_DIR"
-  # Moved, not copied: a client secret shouldn't be left lying in Downloads.
-  /bin/mv -f "$secret" "$GWS_CONFIG_DIR/client_secret.json"
-  chmod 600 "$GWS_CONFIG_DIR/client_secret.json"
-  ok "OAuth client saved"
-fi
-
-# External apps left in "Testing" get refresh tokens Google expires after
-# 7 days. Publishing the user's OWN unverified app is allowed for personal use
-# (Google caps unverified apps at 100 users) and makes the token long-lived.
-case "$account_type" in
-  [wW]*) ;;
-  *)
-    say ""
-    say "${BOLD}d.${RESET} Click ${BOLD}Publish app${RESET} → Confirm. Without this Google logs you out every 7 days."
-    open_url "https://console.cloud.google.com/auth/audience?project=$PROJECT_ID"
-    pause "App published"
-    ;;
-esac
-
-# ── Sign in ─────────────────────────────────────────────────────
-say ""
-say "Signing in. Google will say ${BOLD}\"Google hasn't verified this app\"${RESET} — it's your own app:"
-say "click ${BOLD}Advanced → Go to <your app> (unsafe)${RESET}, then allow read access."
-"$GWS" auth login --readonly -s "$GWS_SERVICES" || true
-
-if [ "$(gws_status_field gmail)" = "yes" ]; then
-  ok "Google connected — your agent can now read Gmail, Drive and Calendar via ${BOLD}gws${RESET}"
-  install_watcher
-  exit 0
-fi
-echo -e "    ${RED}✗${RESET} Sign-in didn't complete. Run ${BOLD}drafted google-setup${RESET} to try again."
-exit 1