@gpdoc/cli 1.2.2 → 1.4.0

package/lib/editor-preview.js

@@ -0,0 +1,186 @@
+import crypto from 'node:crypto';
+import { createServer } from 'node:http';
+import { readFile, rename, unlink, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+const {
+  readDocument,
+  serializeManagedMarkdown,
+  validateDocument,
+} = await import('@gpdoc/filekit').catch(() => import('../../gpdoc-filekit/src/index.js'));
+
+export class EditorPreviewError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+}
+
+const BODY_LIMIT = 2 * 1024 * 1024;
+
+function revisionFor(value) {
+  return crypto.createHash('sha256').update(value).digest('hex');
+}
+
+function snapshotFor(filePath, source) {
+  const document = readDocument(source, filePath);
+  if (!['markdown', 'gpdoc-markdown'].includes(document.format) || document.filetype !== 'document') {
+    throw new EditorPreviewError('UNSUPPORTED_EDITOR', 'GPEditor preview supports Markdown and GPDoc document files.');
+  }
+  return {
+    document,
+    editor: {
+      filePath,
+      fileName: path.basename(filePath),
+      format: document.format,
+      managed: document.managed,
+      filetype: document.filetype,
+      content: document.body,
+      revision: revisionFor(source),
+      comments: document.metadata?.comments ?? null,
+      suggestions: document.metadata?.suggestions ?? null,
+      metadata: document.metadata ?? null,
+    },
+  };
+}
+
+async function readSnapshot(filePath) {
+  return snapshotFor(filePath, await readFile(filePath, 'utf8'));
+}
+
+async function atomicWrite(target, content) {
+  const temporary = path.join(path.dirname(target), `.${path.basename(target)}.${process.pid}.${Date.now()}.tmp`);
+  try {
+    await writeFile(temporary, content, 'utf8');
+    await rename(temporary, target);
+  } catch (error) {
+    await unlink(temporary).catch(() => {});
+    throw error;
+  }
+}
+
+function sendJson(response, status, value) {
+  const body = JSON.stringify(value);
+  response.writeHead(status, {
+    'Content-Type': 'application/json; charset=utf-8',
+    'Content-Length': Buffer.byteLength(body),
+    'Cache-Control': 'no-store',
+    'X-Content-Type-Options': 'nosniff',
+  });
+  response.end(body);
+}
+
+async function readJson(request) {
+  const declared = Number(request.headers['content-length'] || 0);
+  if (declared > BODY_LIMIT) throw new EditorPreviewError('REQUEST_TOO_LARGE', 'The editor request is too large.');
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of request) {
+    size += chunk.byteLength;
+    if (size > BODY_LIMIT) throw new EditorPreviewError('REQUEST_TOO_LARGE', 'The editor request is too large.');
+    chunks.push(chunk);
+  }
+  try {
+    const parsed = JSON.parse(Buffer.concat(chunks).toString('utf8') || '{}');
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) throw new Error('Invalid body');
+    return parsed;
+  } catch {
+    throw new EditorPreviewError('INVALID_INPUT', 'The editor request body must be a JSON object.');
+  }
+}
+
+function writePreviewError(response, error) {
+  const code = error?.code || 'EDITOR_PREVIEW_FAILED';
+  const status = code === 'REQUEST_TOO_LARGE' ? 413
+    : code === 'INVALID_INPUT' ? 400
+      : code === 'REVISION_CONFLICT' ? 409
+        : 500;
+  sendJson(response, status, { error: { code, message: error?.message || 'GPDoc editor preview failed.' } });
+}
+
+function contentForSave(snapshot, content) {
+  if (snapshot.document.managed) return serializeManagedMarkdown(snapshot.document.metadata, content);
+  return content;
+}
+
+// @spec CLI-032
+export async function startGPEditorPreview({ filePath, editorHtml }) {
+  if (!editorHtml) throw new EditorPreviewError('EDITOR_PREVIEW_UNAVAILABLE', 'GPEditor preview assets are unavailable. Reinstall @gpdoc/cli.');
+  const target = path.resolve(filePath);
+  const localEditorHtml = editorHtml.replace(/<\/head>/i, '<style>.share-action{display:none!important}</style></head>');
+  await readSnapshot(target);
+  const token = crypto.randomBytes(32).toString('base64url');
+  let origin = '';
+  const server = createServer((request, response) => {
+    void (async () => {
+      try {
+        const url = new URL(request.url || '/', origin || 'http://127.0.0.1');
+        const editorPath = `/editor/${token}`;
+        const apiPath = `/api/editor/${token}`;
+        if (request.method === 'GET' && url.pathname === editorPath) {
+          response.writeHead(200, {
+            'Content-Type': 'text/html; charset=utf-8',
+            'Cache-Control': 'no-store',
+            'Content-Security-Policy': "default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; img-src data: blob: https:; connect-src 'self'; font-src data:; base-uri 'none'; frame-ancestors 'self'",
+            'Referrer-Policy': 'no-referrer',
+            'X-Content-Type-Options': 'nosniff',
+          });
+          response.end(localEditorHtml);
+          return;
+        }
+        if (url.pathname !== apiPath && url.pathname !== `${apiPath}/save`) {
+          sendJson(response, 404, { error: { code: 'ROUTE_NOT_FOUND', message: 'The editor route was not found.' } });
+          return;
+        }
+        if (request.headers.origin && request.headers.origin !== origin) {
+          sendJson(response, 403, { error: { code: 'ORIGIN_DENIED', message: 'The editor request origin was denied.' } });
+          return;
+        }
+        if (request.method === 'GET' && url.pathname === apiPath) {
+          const { editor } = await readSnapshot(target);
+          sendJson(response, 200, { editor });
+          return;
+        }
+        if (request.method !== 'POST' || url.pathname !== `${apiPath}/save`) {
+          sendJson(response, 405, { error: { code: 'METHOD_NOT_ALLOWED', message: 'The editor operation does not support this method.' } });
+          return;
+        }
+        if (!String(request.headers['content-type'] || '').toLowerCase().startsWith('application/json')) {
+          sendJson(response, 415, { error: { code: 'CONTENT_TYPE_REQUIRED', message: 'The editor operation requires JSON.' } });
+          return;
+        }
+        const input = await readJson(request);
+        if (typeof input.content !== 'string') throw new EditorPreviewError('INVALID_INPUT', 'Editor content must be text.');
+        const snapshot = await readSnapshot(target);
+        if (String(input.expectedRevision || '') !== snapshot.editor.revision) {
+          throw new EditorPreviewError('REVISION_CONFLICT', 'The local file changed. Reload the editor before saving.');
+        }
+        const nextSource = contentForSave(snapshot, input.content);
+        const prospective = snapshotFor(target, nextSource);
+        validateDocument(prospective.document);
+        await atomicWrite(target, nextSource);
+        const next = await readSnapshot(target);
+        sendJson(response, 200, { editor: next.editor, result: { path: target, revision: next.editor.revision } });
+      } catch (error) {
+        writePreviewError(response, error);
+      }
+    })();
+  });
+
+  await new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(0, '127.0.0.1', () => {
+      server.off('error', reject);
+      resolve();
+    });
+  });
+  const address = server.address();
+  if (!address || typeof address === 'string') {
+    server.close();
+    throw new EditorPreviewError('EDITOR_PREVIEW_FAILED', 'The local GPEditor preview could not start.');
+  }
+  origin = `http://127.0.0.1:${address.port}`;
+  return {
+    url: `${origin}/editor/${token}`,
+    close: () => new Promise((resolve) => server.close(() => resolve())),
+  };
+}

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.2.2",
+  "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": {