Drive (#583)

* add drive sync up and down

* add drive button

* google doc icon

* icon changes

* show error state with retry in google doc picker

* feat(google-docs): import and sync down as Markdown, record remote revision

* feat(google-docs): structure-preserving sync up with remote-conflict guard

* feat(google-docs): overwrite-confirm on sync conflict and last-synced indicator

* feat(google-docs): store linked docs as .docx, edit in docx editor, sync via Drive

* feat(google-docs): offer BYOK connect in picker so signed-in users can grant Drive/Docs scopes

* fix(google-docs): request full drive scope so .docx sync-up can write back

* fix(google-docs): search all drives in doc picker, log result count

* feat(google-docs): import native Docs AND uploaded .docx files from Drive

* chore(google-docs): drop dev-only test file

* feat(google-docs): use Google Picker + drive.file scope instead of full-drive listing

* fix(google-oauth): request offline access so BYOK tokens refresh

BYOK never requested access_type=offline/prompt=consent so no refresh token was issued and tokens died after ~1h; also stop handing back expired tokens and extend the connect timeout to 10m.

* feat(google-docs): pick docs via system-browser Google Picker

Runs the Picker in the user's real browser (it 403s inside Electron), sets appId so the drive.file grant attaches to the picked file, and downloads + opens the selected doc.

* feat(google-docs): managed OAuth-redirect Picker (no API key, no BYOK) (#620)

* feat(google-docs): managed OAuth-redirect Picker (no API key, no BYOK)

Adds the managed (rowboat-mode) Google Docs picker via Google's trigger_onepick
flow. The Rowboat backend runs a standalone drive.file OAuth with the company
client, renders the Picker inside the browser consent screen, and deep-links the
selection back; the desktop downloads the picked doc with the fresh drive.file
token the backend returns. No Picker API key, appId, or BYOK credentials on the
desktop.

- core: importGoogleDocWithToken downloads a picked doc with an explicit token;
  fetch/metadata helpers take an optional Drive client and share writeDocxAndLink.
  claimPickedFilesViaBackend claims the parked file ids + token from the api.
- main: google-picker-managed.ts opens the backend start URL and resolves on the
  rowboat://oauth/google/picker/done deep link; deeplink.ts routes that completion.
- ipc: google-docs:pickViaManaged.
- renderer: the picker dialog gates on Rowboat sign-in (the picker grants
  drive.file per-file, so no pre-existing connection or scope is required).

Backend contract: rowboatlabs/rowboatx-backend#7
(GET /oauth/google/picker/{start,callback}, POST /v1/google-oauth/claim-picked).

* chore(google-docs): remove the dead API-key/system-browser Picker

The managed picker replaced the only consumer (the picker dialog), so the
experimental API-key Picker is now unused. Removes:
- main: google-docs:openPicker handler (system-browser loopback Picker)
- shared: google-docs:openPicker + google-docs:getAccessToken IPC schemas
- core: getGoogleAccessToken (token plumbing for the client-side Picker)
- renderer: lib/google-picker.ts (Picker JS SDK loader)

Kept GoogleClientIdModal / google-credentials-store — still used by the
general BYOK Google connect in onboarding, connectors, and settings.

---------

Co-authored-by: Gagancreates <gaganp000999@gmail.com>

apps/x/packages/shared/src/ipc.ts

@@ -1096,6 +1096,89 @@ const ipcSchemas = {
     req: z.object({}),
     res: z.null(),
   },
+  // Google Docs linked knowledge files
+  'google-docs:getStatus': {
+    req: z.null(),
+    res: z.object({
+      connected: z.boolean(),
+      hasRequiredScopes: z.boolean(),
+      missingScopes: z.array(z.string()),
+    }),
+  },
+  'google-docs:import': {
+    req: z.object({
+      fileId: z.string().min(1),
+      targetFolder: RelPath,
+    }),
+    res: z.object({
+      path: RelPath,
+      doc: z.object({
+        id: z.string(),
+        name: z.string(),
+        url: z.string(),
+        modifiedTime: z.string().nullable(),
+        owner: z.string().nullable(),
+      }),
+    }),
+  },
+  // Managed OAuth-redirect Picker: the Rowboat backend runs the pick with the
+  // company Google client; the desktop opens the start URL, waits for the deep
+  // link, and imports with the existing managed token. No API key or BYOK creds.
+  'google-docs:pickViaManaged': {
+    req: z.object({
+      targetFolder: RelPath,
+    }),
+    res: z.object({
+      path: RelPath,
+      doc: z.object({
+        id: z.string(),
+        name: z.string(),
+        url: z.string(),
+        modifiedTime: z.string().nullable(),
+        owner: z.string().nullable(),
+      }),
+    }).nullable(),
+  },
+  'google-docs:refreshSnapshot': {
+    req: z.object({
+      path: RelPath,
+    }),
+    res: z.object({
+      ok: z.literal(true),
+      syncedAt: z.string(),
+    }),
+  },
+  'google-docs:sync': {
+    req: z.object({
+      path: RelPath,
+      // Overwrite the Google Doc even if it changed remotely since last sync.
+      force: z.boolean().optional(),
+      // Legacy field from the markdown-link path; ignored by the .docx sync.
+      markdown: z.string().optional(),
+    }),
+    res: z.object({
+      synced: z.boolean(),
+      syncedAt: z.string().optional(),
+      // True when a remote edit was detected and the push was held back.
+      conflict: z.boolean().optional(),
+      error: z.string().optional(),
+    }),
+  },
+  // Is this local .docx linked to a Google Doc? Drives the sync UI in the viewer.
+  'google-docs:getLink': {
+    req: z.object({
+      path: RelPath,
+    }),
+    res: z.object({
+      link: z.object({
+        id: z.string(),
+        url: z.string(),
+        title: z.string(),
+        syncedAt: z.string(),
+        remoteModifiedTime: z.string().optional(),
+      }).nullable(),
+    }),
+  },
   // Search channels
   'search:query': {
     req: z.object({