drafted 1.14.9 → 1.14.11

package/mcp/server.mjs

@@ -404,6 +404,14 @@ function tool(name, descOrSchema, schemaOrHandler, handler) {
           }
         }
       }
+      // Per-call project override (see withProjectOverride). Scoping happens here so
+      // every project-scoped tool gets it from one seam instead of each handler.
+      const ref = PROJECT_SCOPED_TOOLS.has(name) ? args?.[0]?.projectId : null;
+      if (ref) {
+        const meta = await resolveProjectRef(ref);
+        if (!meta) return err(new Error(`Project "${ref}" not found — pass a project UUID, slug, or name from project(action="list").`));
+        return await withProjectOverride(meta, () => cb(...args));
+      }
       return await cb(...args);
     } finally {
       state.currentTool = previousTool;
@@ -926,6 +934,11 @@ async function api(method, path, body, extraHeaders = {}, _retried = false) {
   const scopedPath = pid ? `${path}${sep}projectId=${pid}` : path;
   const url = `${getServerUrl()}${scopedPath}`;
   const headers = { ...getAuthHeaders(), ...extraHeaders };
+  // Declare an unbound session explicitly. Without this the server falls back to the
+  // user's SHARED active-project row (any browser tab or parallel agent can rewrite it)
+  // and a frame write silently succeeds in the WRONG project. Project-scoped routes
+  // fail closed on this header; org-scoped ones (wiki, skill, get_org) ignore it.
+  if (!pid) headers['X-Drafted-Project'] = 'none';
   // Bind every data request to the org this MCP session is actually working in
   // (the active project's org, or the org chosen via get_org switch). Without
   // this, project-scoped routes that resolve org from the SHARED server-side
@@ -988,7 +1001,10 @@ async function api(method, path, body, extraHeaders = {}, _retried = false) {
     // a get_org switch), and now the project is invisible. Clear our
     // sticky reference so the next tool call doesn't append a stale
     // projectId to its URL — and tell the agent what happened.
-    if ((res.status === 404 || /project not found/i.test(msg)) && pid && getState().projectId === pid) {
+    // Only a PROJECT-not-found clears the binding. A bare 404 also means "frame not
+    // found" / "page not found" — clearing on those unbound the session mid-turn, and
+    // the next write fell through to the shared active-project row in another project.
+    if (/project not found/i.test(msg) && pid && getState().projectId === pid) {
       const meta = getState().projectMeta;
       getState().projectId = null;
       getState().projectMeta = null;
@@ -1078,6 +1094,15 @@ function shapeSkillCatalog(result, { limit, offset = 0, compact = false } = {})
   return result;
 }
 
+// Semantic frame URL (/o/<org>/<project>/<layer>/<lane>/<label>) from a row that
+// carries slugs (e.g. /api/search hits). Returns null when a slug is missing so the
+// caller can fall back to the /f/<uuid> resolver.
+function semanticFrameUrl({ orgSlug, projectSlug, layer, lane, label }) {
+  if (!orgSlug || !projectSlug || !label) return null;
+  const e = encodeURIComponent;
+  return `${getServerUrl()}/o/${e(orgSlug)}/${e(projectSlug)}/${e(layer || 'designs')}/${e(lane || 'default')}/${e(label)}`;
+}
+
 // Build the structuredContent shape that the frame-preview widget reads.
 // Tools that produce or return a frame (read/write/edit) call this so the
 // model and widget see the same metadata view.
@@ -1093,7 +1118,9 @@ function frameStructuredContent(result, project = null) {
     lane: result.lane,
     width: result.width,
     height: result.height,
-    frameUrl: result.id ? `${getServerUrl()}/f/${result.id}` : undefined,
+    // Server emits the semantic /o/<org>/<project>/<layer>/... URL; /f/<uuid> is the
+    // fallback (still resolved + redirected server-side).
+    frameUrl: result.frameUrl || (result.id ? `${getServerUrl()}/f/${result.id}` : undefined),
     project, // {id, slug, name, orgId} of the active project — visible in client UI
   };
 }
@@ -1150,6 +1177,55 @@ function setMcpActiveProject(projectId, meta = null) {
   }
 }
 
+// Resolve a project reference — UUID, slug, or name (case-insensitive) — to its meta.
+// Agents carry slugs in context ("ios-app-shell-re-ui"), not UUIDs; demanding a UUID
+// forced a frame-search dance just to name a project. Backs both project(action="open")
+// and the per-call `projectId` override below.
+// ponytail: process-lifetime cache, no TTL — a project rename goes stale until restart.
+// Add invalidation if renames ever become common.
+const projectRefCache = new Map();
+async function resolveProjectRef(ref) {
+  if (!ref) return null;
+  const hit = projectRefCache.get(ref);
+  if (hit) return hit;
+  const data = await api('GET', '/api/projects');
+  const list = Array.isArray(data?.projects) ? data.projects : [];
+  const want = String(ref).toLowerCase();
+  const p =
+    list.find(x => x.id === ref) ||
+    list.find(x => String(x.slug || '').toLowerCase() === want) ||
+    list.find(x => String(x.name || '').toLowerCase() === want);
+  if (!p) return null;
+  const meta = { id: p.id, slug: p.slug || null, name: p.name || null, orgId: p.orgId || null, orgSlug: p.orgSlug || null };
+  projectRefCache.set(ref, meta);
+  projectRefCache.set(p.id, meta);
+  return meta;
+}
+
+// Run one tool call against a caller-named project WITHOUT rebinding the session.
+// The override lives in this call's AsyncLocalStorage frame only — request-local, so
+// it satisfies the DRAFT-36 addressing invariant (no shared, another-session-writable
+// resolution state) while giving a reconnected agent a way to address the project it
+// already knows, and to reach into another project for a one-off (e.g. deleting a
+// stray frame) without the open → act → re-open dance.
+function withProjectOverride(meta, fn) {
+  const base = getState();
+  return requestState.run(
+    { ...base, projectId: meta.id, projectMeta: meta, _session: base._session || getSessionState() },
+    fn,
+  );
+}
+
+// Tools that address frames/assets/layout inside ONE project. These accept the
+// per-call `projectId` override; everything else resolves org-side.
+const PROJECT_SCOPED_TOOLS = new Set(['frame', 'ls', 'rm', 'asset', 'connector', 'layout']);
+
+const PROJECT_OVERRIDE_PARAM = z.string().optional().describe(
+  'Target project (UUID, slug, or name) for THIS call only — does NOT rebind the session. ' +
+  'Use it when the session lost its binding (a reconnect), or to touch another project once ' +
+  'without re-opening it. Omit to use the project bound by project(action="open").',
+);
+
 // Returns { id, slug, name, orgId } for the project this MCP session most
 // recently opened — what frame mutations will actually target. Echoed on
 // every mutation so silent cross-project drift is visible.
@@ -1874,23 +1950,22 @@ tool('project', 'START HERE for project management. Dispatch by `action`: list (
         return ok(data, { structuredContent });
       }
       case 'open': {
-        const { projectId } = args;
-        if (!projectId) throw new Error('projectId required for action=open');
+        const ref = args.projectId;
+        if (!ref) throw new Error('projectId required for action=open (UUID, slug, or name)');
+        // Accept a slug or name, not just a UUID — the slug is what an agent actually has
+        // in context after a reconnect.
+        const resolved = await resolveProjectRef(ref).catch(() => null);
+        const projectId = resolved?.id || ref;
         const result = await api('POST', '/api/project/switch', { projectId });
         joinAgentWsRoom(projectId);
         const base = getServerUrl();
-        let projectSlug = projectId;
-        let projectMeta = { id: projectId, slug: null, name: null, orgId: null };
-        try {
-          const data = await api('GET', '/api/projects');
-          const proj = (data.projects || []).find(p => p.id === projectId);
-          if (proj) {
-            projectSlug = proj.slug || projectId;
-            projectMeta = { id: proj.id, slug: proj.slug || null, name: proj.name || null, orgId: proj.orgId || null };
-          }
-        } catch { /* fall back to projectId */ }
+        const projectMeta = resolved || { id: projectId, slug: null, name: null, orgId: null, orgSlug: null };
+        const projectSlug = projectMeta.slug || projectId;
+        const orgSlug = projectMeta.orgSlug || null;
         setMcpActiveProject(projectId, projectMeta);
-        const url = `${base}/project/${projectSlug}`;
+        // Semantic /o/<org-slug>/<project-slug> when the org slug is known; otherwise
+        // the /project/<slug> resolver redirects to it.
+        const url = orgSlug ? `${base}/o/${encodeURIComponent(orgSlug)}/${encodeURIComponent(projectSlug)}` : `${base}/project/${projectSlug}`;
         // Surfacing to the user is the focus mechanism's job now (agent-active ping ->
         // desktop window / notification+glow for browser tabs) — this used to also force
         // `exec('open <url>')` on the MCP host machine, an unsolicited GUI action that both
@@ -2549,6 +2624,7 @@ tool('get_org', {
 // ── Filesystem tools (direct HTTP to /api/fs) ─────────────────────
 
 tool('frame', 'Frame CRUD in the ACTIVE PROJECT. Dispatch by `action`: read (by path, frame URL, or UUID), write (new frame or overwrite), set_state / get_state (persist or read a deployed windowType:"app" frame\'s hydration state — push e.g. {specText} to drive a generic app frame with data after deploy; the canvas hydrates the app from it on load), Google Sheet actions (`get_sheet`, `read_sheet_values`, `write_sheet_values`, `append_sheet_rows`, `clear_sheet_range`, `update_sheet`), Google Doc actions (`get_doc`, `read_doc_content`, `write_doc_content`, `append_doc_content`, `clear_doc_content`, `update_doc`), Google Slide actions (`get_slide`, `read_slide_content`, `write_slide_content`, `append_slides`, `clear_slides`, `update_slide`), write_excalidraw (native editable Excalidraw diagram), edit (hashline ops), mv (rename/move), anchor (mark as required-read for the layer), search (match frame names). Use project(action="open") first. For listing use `ls`, for deletion use `rm`.\n\n**Google Workspace native content:** Create or attach Google Docs/Sheets/Slides with `frame(action="write", googleType=...)`. After creating, immediately populate the native file using the matching write action in the same tool — do NOT leave it empty and do NOT tell the user you cannot write to it. For Sheets: `write_sheet_values` or `append_sheet_rows` (pass `path` or `googleId` from the create response). For Docs: `write_doc_content`/`append_doc_content`. For Slides: `write_slide_content`/`append_slides`. Read with `read_sheet_values`/`read_doc_content`/`read_slide_content`. Do NOT use inline `frame.write(content)` or hashline `frame.edit` to populate Google Workspace frames.\n\n**Write — content, binary, or Google Workspace frame:** ' + (isRemote ? 'Provide exactly one of `content` (HTML/markdown/text), `base64` (base64-encoded binary with optional `content_type`), or `googleType` (`google-doc`, `google-sheet`, `google-slide`).' : 'Provide exactly one of `content` (HTML/markdown/text), `file_path` (absolute local file), `base64` (base64-encoded binary with optional `content_type`), or `googleType` (`google-doc`, `google-sheet`, `google-slide`).') + ' Call get_org first; when `googleDrive.connected` is true, strongly prefer Google Workspace frames for docs, sheets, and slides in that org. For inline content, filename extension matters: use `.html` for complete HTML documents and `.md` for Markdown. Never place a full HTML document in a `.md` or extensionless frame. For a new Google file, pass `googleType` and optional `title`; for an existing Google file, pass `googleType` plus `url` or `googleId`. ' + (isRemote ? 'For binary frames (images, PDFs, videos), pass `base64` with the binary bytes.' : 'For binary frames (images, PDFs, videos), use `file_path` when the file is local to the MCP host, or `base64` when the caller already has binary bytes.') + '\n\n**Write — dimensions:** By default, frames use the layer\'s default size (e.g. 1440×900 for designs, 1440×3000 for wireframes). Often too large for small content. Use `autoSize: true` to measure HTML content and size to fit, or pass explicit `width`/`height`.', {
+  projectId: PROJECT_OVERRIDE_PARAM,
   action: z.enum(['read', 'write', 'set_state', 'get_state', 'write_sheet_values', 'read_sheet_values', 'append_sheet_rows', 'clear_sheet_range', 'get_sheet', 'update_sheet', 'get_doc', 'read_doc_content', 'write_doc_content', 'append_doc_content', 'clear_doc_content', 'update_doc', 'get_slide', 'read_slide_content', 'write_slide_content', 'append_slides', 'clear_slides', 'update_slide', 'create_office', 'read_office', 'edit_office', 'write_excalidraw', 'edit', 'mv', 'anchor', 'search', 'versions', 'read_version', 'restore_version']).describe('Operation to perform. Use native Doc/Slide actions for Google Docs/Slides; do not use inline write/edit for native Workspace content.'),
   path: z.string().optional().describe('[read] /{layer}/{lane}/{filename}, frame URL, or UUID. [write|edit|anchor] /{layer}/{lane}/{filename}.'),
   lines: z.string().optional().describe('[read] line range (e.g. "1-50"). Omit to read all.'),
@@ -2635,7 +2711,6 @@ tool('frame', 'Frame CRUD in the ACTIVE PROJECT. Dispatch by `action`: read (by
   dryRun: z.boolean().optional().describe('[mv] preview the move without applying it; returns the resolved frame and current path so you can confirm before retrying with dryRun=false.'),
   anchored: z.boolean().optional().describe('[anchor] true to anchor, false to unanchor. Anchored frames MUST be read before writing/editing in the same layer.'),
   query: z.string().optional().describe('[search] term to match against frame names'),
-  projectId: z.string().optional().describe('[search] limit to a specific project (optional)'),
   limit: z.number().optional().describe('[search] max results (default 50, max 200)'),
   versionId: z.string().optional().describe('[read_version|restore_version] version id'),
   reason: z.string().optional().describe('[restore_version] reason recorded on the snapshot of current content'),
@@ -3025,7 +3100,9 @@ tool('frame', 'Frame CRUD in the ACTIVE PROJECT. Dispatch by `action`: read (by
         const { query, projectId, limit = 50 } = args;
         if (!query) throw new Error('query required for action=search');
         const params = new URLSearchParams({ q: query });
-        if (projectId) params.set('projectId', projectId);
+        // projectId may be a slug/name (the shared override param) — the tool() seam has
+        // already resolved it into state, so take the resolved UUID from there.
+        if (projectId) params.set('projectId', getState().projectId || projectId);
         await ensureSession();
         const url = `${getServerUrl()}/api/search?${params.toString()}`;
         const res = await fetch(url, { headers: getAuthHeaders() });
@@ -3039,7 +3116,7 @@ tool('frame', 'Frame CRUD in the ACTIVE PROJECT. Dispatch by `action`: read (by
             path: `/${r.layer}/${r.lane}/${r.label}`,
             project: r.projectName,
             projectId: r.projectId,
-            frameUrl: `${getServerUrl()}/f/${r.id}`,
+            frameUrl: semanticFrameUrl(r) || `${getServerUrl()}/f/${r.id}`,
             contentType: r.contentType,
             updatedAt: r.updatedAt,
           })),
@@ -3054,6 +3131,7 @@ tool('frame', 'Frame CRUD in the ACTIVE PROJECT. Dispatch by `action`: read (by
 });
 
 tool('ls', 'List contents of the ACTIVE PROJECT. Use ls / after project(action="open") to see layers, workflow, and confirm you\'re in the right project.', {
+  projectId: PROJECT_OVERRIDE_PARAM,
   path: z.string().optional().default('/').describe('Directory path: / (layers), /{layer} (lanes), /{layer}/{lane} (frames). Frame entries include frameUrl (canvas deep link) and id (frame UUID).'),
   recursive: z.boolean().optional().describe('List contents of subdirectories. When true, forces summary mode (metadata only, no full content) to keep results under the 25k token cap.'),
   summary: z.boolean().optional().describe('Include size, updatedAt, title for frames'),
@@ -3112,7 +3190,11 @@ tool('ls', 'List contents of the ACTIVE PROJECT. Use ls / after project(action="
     const projectId = getState().projectId;
     const structuredContent = {
       project: result?.project || result?.projectName,
-      canvasUrl: result?.projectSlug ? `${getServerUrl()}/project/${result.projectSlug}` : undefined,
+      canvasUrl: result?.project?.slug
+        ? (result.project.orgSlug
+            ? `${getServerUrl()}/o/${encodeURIComponent(result.project.orgSlug)}/${encodeURIComponent(result.project.slug)}`
+            : `${getServerUrl()}/project/${encodeURIComponent(result.project.slug)}`)
+        : undefined,
       byLayer,
       truncated: result?.truncated || false,
       totalAvailable: result?.totalAvailable,
@@ -3121,10 +3203,17 @@ tool('ls', 'List contents of the ACTIVE PROJECT. Use ls / after project(action="
   } catch (error) { return err(error); }
 });
 
-tool('rm', 'Delete a frame or lane from the ACTIVE PROJECT. Response includes "project" field so you see where the deletion landed.', {
-  path: z.string().describe('Path to delete: /{layer}/{lane}/{filename} or /{layer}/{lane} (deletes entire lane).'),
-}, async ({ path }) => {
+tool('rm', 'Delete a frame or lane. Defaults to the ACTIVE PROJECT; pass projectId to delete in another project, or frameId to delete a frame by UUID from anywhere (no project binding needed — the frame\'s own org/project is authoritative). Response includes "project" so you see where the deletion landed.', {
+  projectId: PROJECT_OVERRIDE_PARAM,
+  path: z.string().optional().describe('Path to delete: /{layer}/{lane}/{filename} or /{layer}/{lane} (deletes entire lane). Mutually exclusive with frameId.'),
+  frameId: z.string().optional().describe('Frame UUID to delete, resolved independently of the active project — the one-call cleanup for a frame that landed in the wrong place. Mutually exclusive with path.'),
+}, async ({ path, frameId }) => {
   try {
+    if (frameId && path) throw new Error('Pass either path or frameId, not both.');
+    if (!frameId && !path) throw new Error('rm needs a path or a frameId.');
+    // A frame UUID self-derives its org and project server-side, so this works from an
+    // unbound session and across projects — no open/re-open dance to remove a stray frame.
+    if (frameId) return ok(await api('DELETE', `/api/designs/${encodeURIComponent(frameId)}`));
     const clean = path.replace(/^\/+|\/+$/g, '');
     const result = await api('DELETE', `/api/fs/${clean}`);
     return ok({ ...result, project: getCurrentProjectContext() });
@@ -3238,6 +3327,7 @@ tool('batch', 'Batch operations on the ACTIVE PROJECT. Response includes "projec
 // ── Asset tools ──────────────────────────────────────────────────
 
 tool('asset', 'Manage supporting files (CSS, JS, images, fonts) in the ACTIVE PROJECT. Assets are referenced by frames via relative paths — e.g., if your HTML has <link href="css/styles.css">, upload with asset_path="css/styles.css". Assets are NOT frames — they don\'t appear on the canvas. `action=upload` to add/replace, `action=list` to browse, `action=rm` to delete.', {
+  projectId: PROJECT_OVERRIDE_PARAM,
   action: z.enum(['upload', 'list', 'rm']).describe('Operation to perform.'),
   asset_path: z.string().optional().describe('[upload] relative asset path (e.g. "css/styles.css"). Must match the path used in HTML references.'),
   file_path: z.string().optional().describe('[upload] absolute path to a local file. Mutually exclusive with content/base64.'),
@@ -3292,6 +3382,7 @@ tool('asset', 'Manage supporting files (CSS, JS, images, fonts) in the ACTIVE PR
 // ── Connector tools ───────────────────────────────────────────────
 
 tool('connector', 'Create or remove connectors (arrows) between frames on the surface. `action=connect` adds an arrow from source to target. `action=disconnect` removes one — pass either connectorId directly or source+target to find and delete.', {
+  projectId: PROJECT_OVERRIDE_PARAM,
   action: z.enum(['connect', 'disconnect']).describe('Operation to perform.'),
   source: z.string().optional().describe('[connect|disconnect] source frame path or ID'),
   target: z.string().optional().describe('[connect|disconnect] target frame path or ID'),
@@ -3338,6 +3429,7 @@ tool('connector', 'Create or remove connectors (arrows) between frames on the su
 // ── Layout tools ──────────────────────────────────────────────────
 
 tool('layout', 'Auto-arrange frames using graph layout algorithm. Positions connected frames as a directed graph.', {
+  projectId: PROJECT_OVERRIDE_PARAM,
   direction: z.enum(['TB', 'LR', 'BT', 'RL']).optional().default('TB').describe('Layout direction: TB (top-bottom), LR (left-right), BT (bottom-top), RL (right-left)'),
 }, async ({ direction }) => {
   try {

package/package.json

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