drafted 1.19.43 → 1.19.45

package/mcp/server.mjs

@@ -469,6 +469,9 @@ const TOOL_ANNOTATIONS = {
   minion:              { title: 'Minions',             readOnlyHint: false, destructiveHint: true,  openWorldHint: false, description: 'Manage Minions: checklist-driven intake surfaces that guide a consumer through a checklist (via a shareable /c/<slug>-<token> link) and write a producible into the project. Dispatch by `action`: meta, list, get, create, update, enable, disable, delete. QA your own Minions with test_start/test_say/test_resolve — drive the checklist conversation yourself (works even when disabled). Requires the agent allowlist.' },
   trigger:             { title: 'Inbound triggers',    readOnlyHint: false, destructiveHint: true,  openWorldHint: true,  description: 'Manage inbound webhook triggers for the ACTIVE PROJECT: an external system (AppSheet bot, GitHub, form tool) POSTs to the trigger URL and the server runs an agent conversation in the project from the stored prompt template + payload. Dispatch by `action`: create (returns URL + secret token ONCE — relay it to the user immediately, not retrievable later), list, update (enable/disable, edit template, daily limit, executor), rotate (new token), test (fire a synthetic delivery), deliveries (audit log), delete; for executor="queue" triggers, pending/claim/complete let a LOCAL agent poll and work queued deliveries. Requires the agent allowlist.' },
   fs:                  { title: 'Filesystem',           readOnlyHint: false, destructiveHint: true,  openWorldHint: false, description: 'Navigate Drafted like a local filesystem: /wiki/<path> pages, /skills/<slug> procedures, /projects/<folder?>/<project>/<layer>/<lane>/<file> frames. Verbs: ls, read, write, edit, mv, rm, search, link, unlink, links.' },
+  // Google Drive mirror triage. Mutating (resolve/retry_all/sync rewrite frame
+  // content and re-push files) and openWorld (it reaches Google).
+  drive:               { title: 'Drive conflicts',     readOnlyHint: false, destructiveHint: true,  openWorldHint: true },
   repo:                { title: 'Git repos',           readOnlyHint: false, destructiveHint: true,  openWorldHint: true,  description: 'Registered git repos — the org index of .agents/ skills + identities. A connected repo is the source of truth for its skills; EVERY repo connected to ANY folder in the org is searchable and usable org-wide (no org-level repo — the union is the library). Skills from connected repos are readable via fs(read, path="/skills/<slug>") — fetched from git at read time, always fresh. Authoring a Drafted skill whose slug collides with a repo-indexed skill returns 409 repo_owned pointing at the repo. Dispatch by `action`: list (paginated, compact mode), rescan (re-fetch the tracked branch), entries (search the index). Linking and unlinking are NOT here — a human does them in the Drafted UI. Content stays in git; Drafted keeps a read-only index.' },
 };
 
@@ -4348,6 +4351,99 @@ tool('repo', 'Registered git repos — the org index of .agents/ skills + identi
   }
   return err(new Error(`unknown repo action: ${action}`));
 });
+
+tool('drive', 'The org\'s Google Drive mirror: its state, and the conflicts a human would otherwise clear by hand one button at a time. Org-wide (org members only) — dispatch by `action`:\n- `status` — connection mode (`dwd` = domain-wide delegation, `oauth` = per-user), root folder, sync/pull job state, and OPEN CONFLICT COUNTS BY TYPE. Start here.\n- `conflicts` — the open conflicts (paginated, `compact` mode). Each carries `conflictType`, the Drive error, the frame label and its ids, so you can decide per file instead of guessing.\n- `resolve` — decide ONE conflict: `keep_drafted` (re-push Drafted content to Drive), `keep_drive` (pull Drive content into the frame, with a version snapshot), `duplicate_both`, `retry` (re-check on the next sync, content untouched), `ignore_once`, `archive_mirror` (stop mirroring this file).\n- `retry_all` — close EVERY open `inaccessible_file` conflict as `retry` and queue a sync. This is the right move for a pile of access failures: a broken credential files one conflict per frame, and re-checking is not a decision anyone should make hundreds of times. Files that are genuinely gone come back as fresh, accurate conflicts.\n- `sync` — queue the org push, then re-read `status`.\n\nTRIAGE ORDER that avoids wasted decisions: `status` → if `inaccessible_file` dominates, `retry_all` → `sync` → `conflicts` again, and only then decide the survivors one by one. `archive_mirror` on a stale access failure deactivates a HEALTHY mirror — prefer `retry` unless the file is really gone.', {
+  action: z.enum(['status', 'conflicts', 'resolve', 'retry_all', 'sync']).describe('status: connection + conflict counts; conflicts: list them; resolve: decide one; retry_all: bulk-retry access failures; sync: queue the org push.'),
+  conflictId: z.string().optional().describe('[resolve] the conflict id from `conflicts`.'),
+  resolution: z.enum(['keep_drafted', 'keep_drive', 'duplicate_both', 'retry', 'ignore_once', 'archive_mirror']).optional().describe('[resolve] what to do with it.'),
+  conflictType: z.string().optional().describe('[conflicts] filter to one type, e.g. inaccessible_file, content_conflict, drive_deleted, drafted_deleted.'),
+  limit: z.number().int().min(1).max(100).optional().describe('page size (default 25, max 100).'),
+  offset: z.number().int().min(0).optional().describe('page offset (default 0).'),
+  compact: z.boolean().optional().describe('[conflicts] return only {id,conflictType,label} (default false).'),
+  org: z.string().optional().describe('Org (id or name) to scope this call; defaults to the session\'s working org.'),
+}, async (args) => {
+  const { action, conflictId, resolution, conflictType, limit, offset, compact, org } = args;
+  const orgHeader = org ? { 'X-Drafted-Org': org } : {};
+  const cap = Math.min(Math.max(1, Math.floor(Number(limit) || 25)), 100);
+  const start = Math.max(0, Math.floor(Number(offset) || 0));
+
+  const listConflicts = async () => {
+    const data = await api('GET', '/api/google/drive/conflicts', undefined, orgHeader);
+    const rows = Array.isArray(data?.conflicts) ? data.conflicts : [];
+    return conflictType ? rows.filter((c) => c.conflictType === conflictType) : rows;
+  };
+  // The counts are the whole point of `status`: 744 open conflicts that are three
+  // causes reads as 744 decisions, which is why nobody clears them.
+  const countByType = (rows) => rows.reduce((acc, c) => {
+    const k = c.conflictType || 'unknown';
+    acc[k] = (acc[k] || 0) + 1;
+    return acc;
+  }, {});
+
+  if (action === 'status') {
+    const [conn, sync, pull, rows] = await Promise.all([
+      api('GET', '/api/google/status', undefined, orgHeader).catch(() => null),
+      api('GET', '/api/google/drive/sync-status', undefined, orgHeader).catch(() => null),
+      api('GET', '/api/google/drive/pull-status', undefined, orgHeader).catch(() => null),
+      listConflicts().catch(() => []),
+    ]);
+    return ok({
+      connected: !!conn?.connected,
+      connectionMode: conn?.connectionMode || null,
+      googleEmail: conn?.googleEmail || null,
+      driveRootFolderName: conn?.driveRootFolderName || null,
+      syncEnabled: conn?.syncEnabled ?? null,
+      openConflicts: rows.length,
+      openConflictsByType: countByType(rows),
+      lastSync: sync ? { status: sync.status, finishedAt: sync.finishedAt, error: sync.error } : null,
+      lastPull: pull ? { status: pull.status, finishedAt: pull.finishedAt, error: pull.error } : null,
+    });
+  }
+
+  if (action === 'conflicts') {
+    const rows = await listConflicts();
+    const page = rows.slice(start, start + cap);
+    return ok({
+      totalAvailable: rows.length, offset: start, returned: page.length, truncated: start + page.length < rows.length,
+      byType: countByType(rows),
+      conflicts: page.map(compact ? (c => ({ id: c.id, conflictType: c.conflictType, label: c.details?.label || null })) : (c => ({
+        id: c.id,
+        conflictType: c.conflictType,
+        label: c.details?.label || null,
+        error: c.details?.error || null,
+        frameId: c.frameId,
+        projectId: c.projectId,
+        driveFileId: c.driveFileId,
+        createdAt: c.createdAt,
+      }))),
+    });
+  }
+
+  if (action === 'resolve') {
+    if (!conflictId) return err(new Error('resolve requires conflictId (get it from action="conflicts")'));
+    if (!resolution) return err(new Error('resolve requires resolution: keep_drafted | keep_drive | duplicate_both | retry | ignore_once | archive_mirror'));
+    const data = await api('POST', `/api/google/drive/conflicts/${encodeURIComponent(conflictId)}/resolve`, { action: resolution }, orgHeader);
+    return ok({ resolved: 1, conflictId, resolution, conflict: data?.conflict || null });
+  }
+
+  if (action === 'retry_all') {
+    const data = await api('POST', '/api/google/drive/conflicts/retry-all', undefined, orgHeader);
+    return ok({
+      retried: data?.retried || 0,
+      note: data?.retried
+        ? 'A sync was queued. Re-read action="status" once it finishes: anything still broken comes back as a fresh conflict with an accurate reason.'
+        : 'Nothing to retry — no open inaccessible_file conflicts.',
+    });
+  }
+
+  if (action === 'sync') {
+    const job = await api('POST', '/api/google/drive/sync', undefined, orgHeader);
+    return ok({ queued: true, jobId: job?.id || null, status: job?.status || null });
+  }
+
+  return err(new Error(`unknown drive action: ${action}`));
+});
+
 function normalizeMcpUpdatePolicy(policy) {
   const severity = policy?.policy?.severity || 'unknown';
   const updateAvailable = !!policy?.policy?.updateAvailable;

package/package.json

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