drafted 1.19.24 → 1.19.26

package/mcp/server.mjs

@@ -633,6 +633,11 @@ registerAppResource(
 
 const AUTH_FILE = process.env.DRAFTED_AUTH_FILE || join(homedir(), '.drafted', 'auth.json');
 const PENDING_AUTH_FILE = process.env.DRAFTED_PENDING_AUTH_FILE || `${AUTH_FILE}.pending`;
+// The DESKTOP app's own browser session (desktop/src-tauri/src/main.rs writes it beside
+// auth.json). Never read for a credential here — only to answer "is the app signed in?",
+// which is a different question from "is this MCP signed in?" and the one that decides
+// whether an agent can reach the human at all.
+const DESKTOP_SESSION_FILE = join(dirname(AUTH_FILE), 'desktop.json');
 
 // Active-project persistence (stdio only): see mcp/active-project-store.mjs.
 // Persisted so a `system restart mode=mcp` / skill-edit pass that re-spawns the
@@ -2218,7 +2223,60 @@ if (!isRemote) tool('auth', 'Sign in to Drafted.\n\n`action=get_link` ALWAYS ret
           });
           if (res.ok) {
             const me = await res.json();
-            return ok({ status: 'already_authenticated', userId: me.userId, email: me.userEmail, org: me.currentOrg?.name });
+            // "Signed in" has to mean THIS MACHINE is signed in, not "this process
+            // happens to hold a session". The two came apart the first time anything
+            // deleted ~/.drafted/auth.json underneath a running MCP (the desktop's
+            // credential burn does exactly that, by design): the in-process session
+            // stayed valid, so login answered already_authenticated — truthfully, and
+            // uselessly — while every OTHER reader on the machine stayed signed out.
+            // The desktop's focus listener is one of those readers, so an agent asking
+            // for a human reached nobody and the tool that exists to fix it reported
+            // success.
+            let restoredAuthFile = false;
+            if (!getBootstrapSessionId()) {
+              try {
+                persistAuthSession({ sessionId: existing, userId: me.userId, orgId: me.currentOrg?.id });
+                restoredAuthFile = true;
+              } catch { /* read-only home: report the truth below rather than throwing */ }
+            }
+            // The DESKTOP's own browser credential is a separate file, and an agent
+            // cannot mint one — it is the origin='browser' class that may approve
+            // actions, which is exactly what the two-credential split protects. But
+            // "cannot mint it" is not "cannot ask for it": opening the app's sign-in
+            // window is this tool's documented job, and the window usually completes
+            // with no interaction at all because the shared cookie store still holds a
+            // valid login. Short-circuiting on the agent session skipped that entirely,
+            // so `login` reported success while the app stayed signed out and every
+            // agent that pinged the human reached nobody.
+            let openedDesktopSignin = false;
+            if (desktopAppBinary() && !existsSync(DESKTOP_SESSION_FILE)) {
+              openedDesktopSignin = await launchDesktopSignin();
+              if (openedDesktopSignin) {
+                // Give the app a moment to re-capture the cookie so the caller can act
+                // on a true answer rather than an optimistic one.
+                for (let i = 0; i < 20 && !existsSync(DESKTOP_SESSION_FILE); i++) {
+                  await new Promise((r) => setTimeout(r, 500));
+                }
+              }
+            }
+            const desktopSignedIn = !desktopAppBinary() ? null : existsSync(DESKTOP_SESSION_FILE);
+            return ok({
+              status: 'already_authenticated',
+              userId: me.userId,
+              email: me.userEmail,
+              org: me.currentOrg?.name,
+              ...(restoredAuthFile ? {
+                restoredAuthFile: true,
+                note: 'This session was signed in but ~/.drafted/auth.json was missing, so other readers on this machine (the desktop app, the CLI) were not. Rewrote it from the live session.',
+              } : {}),
+              ...(desktopSignedIn === null ? {} : { desktopSignedIn }),
+              ...(openedDesktopSignin ? {
+                openedDesktopSignin: true,
+                desktopNote: desktopSignedIn
+                  ? 'The desktop app was signed out; opened its sign-in window and it completed on its own from the existing browser session.'
+                  : 'The desktop app is signed out and its sign-in window is open — it needs one approval there. Until then it holds no session, so an agent asking for attention cannot reach this machine.',
+              } : {}),
+            });
           }
         } catch { /* session invalid, proceed with login */ }
       }

package/package.json

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

package/src/shared/root-route.mjs

@@ -0,0 +1,45 @@
+/**
+ * ONE definition of the root-URL grammar, shared by the server, the client
+ * router and the tests:
+ *
+ *   /o/<org>[/<folder chain>]/wiki|skills|tasks|projects[/<path>]
+ *
+ * The regex is a literal copy of the four root routes in server/server.mjs. It
+ * must stay that way: the client router uses it to decide what it may handle
+ * without a round trip, so any divergence renders a different page than the URL
+ * names.
+ *
+ * The source form carries ZERO BACKSLASHES on purpose. This function is
+ * embedded into client JS via `String(parseRootPath)` inside a template literal
+ * (see AGENTS.md's escape trap: a `\/` written inside a template literal
+ * collapses to `/`). Interpolating a runtime string is safe either way, but a
+ * body with no backslashes cannot be broken by a later copy-paste into a
+ * literal region.
+ */
+
+export const ROOTS = ['wiki', 'skills', 'tasks', 'projects'];
+
+/**
+ * @param {string} pathname
+ * @returns {{orgParam: string, chain: string, root: string, path: string}|null}
+ *   `null` means "not a root URL" — the caller must let the server decide.
+ *   `chain` is decoded ('' = the org itself); `path` is left RAW/encoded,
+ *   exactly as the server's `req.params[2]` is, so both halves agree.
+ */
+export function parseRootPath(pathname) {
+  var re = new RegExp('^/o/([^/]+)/(?:(.+?)/)?(wiki|skills|tasks|projects)(?:/(.*))?$');
+  var m = re.exec(String(pathname || ''));
+  if (!m) return null;
+  var path = m[4] || '';
+  while (path.length && path.charAt(path.length - 1) === '/') path = path.slice(0, -1);
+  // The projects root takes NO sub-path on the server, because
+  // /o/<org>/projects/<slug> is the PROJECT CANVAS. Claiming it here would make
+  // the client router swallow every project link and render the folder list.
+  if (m[3] === 'projects' && path) return null;
+  return {
+    orgParam: decodeURIComponent(m[1]),
+    chain: m[2] ? decodeURIComponent(m[2]) : '',
+    root: m[3],
+    path: path,
+  };
+}