@gpdoc/cli 1.3.0 → 1.4.0

package/lib/remote.js

@@ -21,7 +21,11 @@ async function jsonRequest(fetchImpl, url, init, fallbackCode = 'REMOTE_REQUEST_
   }
   const payload = await response.json().catch(() => ({}));
   if (!response.ok) {
-    const error = new RemoteError(payload.code || fallbackCode, payload.error || `Remote provider request failed (${response.status}).`);
+    const code = payload.code || fallbackCode;
+    const message = code === 'ACCOUNT_STATE_UNAVAILABLE'
+      ? 'GPDoc account-state verification is temporarily unavailable. No provider request was sent. Retry after the GPDoc account service is available.'
+      : payload.error || `Remote provider request failed (${response.status}).`;
+    const error = new RemoteError(code, message);
     error.status = response.status;
     throw error;
   }
@@ -69,33 +73,102 @@ function githubHeaders(token) {
 // @spec CLI-019, CLI-020, CLI-021, CLI-022, CLI-023, CLI-024, CLI-025
 export function createRemoteClient({ auth, env = process.env, fetchImpl = globalThis.fetch } = {}) {
   if (!auth) throw new Error('Remote client requires an auth manager.');
-  async function provider(functionName, body, method = 'POST') {
+  async function provider(functionName, body, method = 'POST', onProgress) {
     const token = await auth.getAccessToken();
+    onProgress?.({ stage: 'request', functionName });
     return jsonRequest(fetchImpl, `${apiBase(env)}/.netlify/functions/${functionName}`, {
       method, headers: bearer(token), ...(method === 'GET' ? {} : { body: JSON.stringify(body || {}) }),
     });
   }
 
+  function connectionFunction(providerName, action) {
+    if (!['google', 'microsoft'].includes(providerName)) throw new RemoteError('USAGE', 'Provider must be google or microsoft.');
+    return `${providerName}-oauth-${action}`;
+  }
+
   return {
-    async googleSave({ filePath, title, mode = 'new', driveId, itemId, expectedRevision, filetype = 'document' }) {
+    async googleSave({ filePath, title, mode = 'new', driveId, itemId, expectedRevision, filetype = 'document', onProgress }) {
       await auth.getAccessToken();
+      onProgress?.({ provider: 'google', stage: 'preparing', current: 1, total: 3, filePath });
       const markdown = await readFile(filePath, 'utf8');
+      onProgress?.({ provider: 'google', stage: 'uploading', current: 2, total: 3, filePath, bytes: Buffer.byteLength(markdown) });
       const payload = await provider('google-drive-source-save', {
         title: title || titleFrom(filePath), markdown, mode, driveId, itemId, expectedRevision, filetype,
-      });
+      }, 'POST', () => {});
+      onProgress?.({ provider: 'google', stage: 'complete', current: 3, total: 3, filePath });
       return { provider: 'google', mode, item: payload.item, warning: payload.warning || null };
     },
 
-    async microsoftSave({ filePath, mode = 'new', driveId, itemId, filename }) {
+    async microsoftSave({ filePath, mode = 'new', driveId, itemId, filename, onProgress }) {
       await auth.getAccessToken();
+      onProgress?.({ provider: 'microsoft', stage: 'preparing', current: 1, total: 3, filePath });
       const bytes = await readFile(filePath);
       if (bytes.byteLength > 4 * 1024 * 1024) throw new RemoteError('MICROSOFT_FILE_TOO_LARGE', 'Microsoft files must be 4 MiB or smaller.');
+      onProgress?.({ provider: 'microsoft', stage: 'uploading', current: 2, total: 3, filePath, bytes: bytes.byteLength });
       const payload = await provider('microsoft-drive-export', {
         mode, driveId, itemId, filename: filename || path.basename(filePath), mimeType: mimeType(filePath), bytes: bytes.toString('base64'),
-      });
+      }, 'POST', () => {});
+      onProgress?.({ provider: 'microsoft', stage: 'complete', current: 3, total: 3, filePath });
       return { provider: 'microsoft', mode, item: payload.item || payload };
     },
 
+    async providerStatus(providerName) {
+      const payload = await provider(connectionFunction(providerName, 'status'), undefined, 'GET');
+      return { provider: providerName, connected: Boolean(payload.connection?.connected), connection: payload.connection || null };
+    },
+
+    async providerConnect(providerName) {
+      const payload = await provider(connectionFunction(providerName, 'start'), {
+        externalClient: true,
+        returnOrigin: apiBase(env),
+      });
+      const launchUrl = typeof payload.launchUrl === 'string' ? payload.launchUrl : payload.authUrl;
+      if (!launchUrl) throw new RemoteError('OAUTH_START_FAILED', `GPDoc could not start ${providerName} authorization.`);
+      return { provider: providerName, launchUrl, expiresAt: payload.expiresAt || null };
+    },
+
+    async googleList({ driveId, parentId, cursor, shared = false }) {
+      if (driveId || parentId) {
+        if (!driveId || !parentId) throw new RemoteError('USAGE', 'Google listing requires both --drive-id and --parent-id.');
+        const payload = await provider('google-drive-browse', {
+          operation: 'children', driveId, parentId, rootKind: driveId === 'my-drive' ? 'my-drive' : 'shared-drive', continuation: cursor,
+        });
+        return { provider: 'google', items: payload.nodes || [], cursor: payload.cursor || null, incomplete: Boolean(payload.incomplete) };
+      }
+      const roots = await provider('google-drive-browse', undefined, 'GET');
+      const rootNodes = roots.nodes || [];
+      if (shared) return { provider: 'google', items: rootNodes.filter((node) => node?.providerData?.rootKind === 'shared-drive'), cursor: roots.cursor || null };
+      const myDrive = rootNodes.find((node) => node?.providerData?.rootKind === 'my-drive');
+      if (!myDrive?.providerData?.driveId || !myDrive?.providerData?.itemId) return { provider: 'google', items: [], cursor: roots.cursor || null };
+      const payload = await provider('google-drive-browse', {
+        operation: 'children', driveId: myDrive.providerData.driveId, parentId: myDrive.providerData.itemId, rootKind: 'my-drive', continuation: cursor,
+      });
+      return { provider: 'google', items: payload.nodes || [], cursor: payload.cursor || null, incomplete: Boolean(payload.incomplete) };
+    },
+
+    async microsoftList({ driveId, itemId, cursor, query, shared = false }) {
+      const payload = query
+        ? await provider('microsoft-drive-search', { query, continuation: cursor })
+        : await provider('microsoft-drive-browse', { driveId, itemId, continuation: cursor });
+      const entries = payload.nodes || payload.files || [];
+      const items = shared
+        ? entries.filter((entry) => entry?.providerData?.remote === 'true' || entry?.remote === true)
+        : entries;
+      return { provider: 'microsoft', items, cursor: payload.cursor || payload.continuation || null };
+    },
+
+    async sharedList() {
+      const token = await auth.getAccessToken();
+      const payload = await jsonRequest(fetchImpl, `${apiBase(env)}/api/shared-files`, {
+        method: 'GET', headers: bearer(token),
+      }, 'SHARED_FILES_REQUEST_FAILED');
+      return {
+        provider: 'gpdoc',
+        owned: payload.ownedFiles || [],
+        sharedWithMe: payload.collaboratingFiles || [],
+      };
+    },
+
     async microsoftShare({ driveId, itemId, role, scope }) {
       if (!driveId || !itemId) throw new RemoteError('USAGE', 'Microsoft sharing requires --drive-id and --item-id.');
       if (!['view', 'edit'].includes(role)) throw new RemoteError('USAGE', 'Microsoft sharing requires --role view or edit.');

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@gpdoc/cli",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "type": "module",
   "description": "GPDoc command-line file conversion and validation tools",
   "repository": "https://github.com/repetere/gpdoc.git",
   "files": [
     "bin",
     "lib",
+    "web",
     "README.md"
   ],
   "publishConfig": {
@@ -19,6 +20,8 @@
     "node": ">=20"
   },
   "scripts": {
+    "build:editor": "node scripts/build-editor.mjs",
+    "prepack": "npm run build:editor",
     "test": "node --test test/**/*.test.js"
   },
   "dependencies": {