@gpdoc/cli 1.4.0 → 1.6.0

package/bin/gpdoc.js

@@ -159,7 +159,7 @@ function parseArguments(argv) {
       options[key] = true;
       continue;
     }
-    if (!['title', 'to', 'output', 'drive-id', 'item-id', 'parent-id', 'revision', 'filetype', 'filename', 'role', 'scope', 'description', 'branch', 'path', 'message', 'editor', 'cursor', 'query'].includes(key) || !rest[index + 1] || rest[index + 1].startsWith('--')) {
+    if (!['title', 'to', 'output', 'drive-id', 'item-id', 'parent-id', 'revision', 'filetype', 'filename', 'role', 'scope', 'description', 'branch', 'path', 'message', 'editor', 'cursor', 'query', 'open'].includes(key) || !rest[index + 1] || rest[index + 1].startsWith('--')) {
       throw new CliError('USAGE', `Unknown or incomplete option: ${value}.`);
     }
     options[key] = rest[index + 1];
@@ -318,18 +318,91 @@ function renderRemote(result, json) {
   return printResult(result, false);
 }
 
-function renderList(result, json) {
-  if (json) return printResult(result, true);
+function truncate(value, width) {
+  const text = String(value || '');
+  if (text.length <= width) return text;
+  if (width < 2) return text.slice(0, width);
+  const prefixLength = Math.ceil((width - 1) * 0.7);
+  const suffixLength = Math.floor((width - 1) * 0.3);
+  return `${text.slice(0, prefixLength)}…${suffixLength ? text.slice(-suffixLength) : ''}`;
+}
+
+function formatBytes(value) {
+  const bytes = Number(value || 0);
+  if (!Number.isFinite(bytes) || bytes <= 0) return '—';
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(bytes >= 10 * 1024 ? 0 : 1)} KiB`;
+  return `${(bytes / (1024 * 1024)).toFixed(bytes >= 10 * 1024 * 1024 ? 0 : 1)} MiB`;
+}
+
+function formatDate(value) {
+  const date = new Date(value || '');
+  return Number.isNaN(date.getTime()) ? '—' : date.toISOString().slice(0, 10);
+}
+
+function displayProvider(provider) {
+  return provider === 'google' ? 'Google Drive' : provider === 'microsoft' ? 'Microsoft 365' : 'GPDoc';
+}
+
+function listedItemId(item) {
+  return item?.providerData?.itemId || item?.itemId || item?.id || '';
+}
+
+// @spec CLI-038
+export function selectListedItem(items, row) {
+  const index = Number(row);
+  if (!Number.isSafeInteger(index) || index < 1 || index > items.length) {
+    throw new CliError('USAGE', 'Choose a row number from the displayed list.');
+  }
+  return items[index - 1];
+}
+
+// @spec CLI-038
+export function formatList(result) {
   if (Array.isArray(result.items)) {
-    const rows = result.items.map((item) => {
-      const id = item?.providerData?.itemId || item?.itemId || item?.id || '';
-      return `${item?.kind || 'file'}\t${item?.name || 'Untitled'}\t${id}\t${item?.webUrl || ''}`;
+    if (!result.items.length) return 'No files found.';
+    const columns = [
+      ['#', 3], ['Type', 8], ['Name', 34], ['Modified', 10], ['Size', 9], ['ID', 18],
+    ];
+    const header = columns.map(([label, width]) => label.padEnd(width)).join('  ').trimEnd();
+    const divider = columns.map(([, width]) => '─'.repeat(width)).join('  ');
+    const rows = result.items.map((item, index) => {
+      const values = [
+        String(index + 1),
+        item?.kind === 'folder' ? 'Folder' : 'File',
+        item?.name || 'Untitled',
+        formatDate(item?.modifiedAt),
+        item?.kind === 'folder' ? '—' : formatBytes(item?.size),
+        listedItemId(item),
+      ];
+      return values.map((value, columnIndex) => truncate(value, columns[columnIndex][1]).padEnd(columns[columnIndex][1])).join('  ').trimEnd();
     });
-    return printResult(rows.length ? `kind\tname\tid\turl\n${rows.join('\n')}` : 'No files found.', false);
-  }
-  const owned = (result.owned || []).map((file) => `owned\t${file?.filename || 'Untitled'}\t${file?.shareId || ''}`);
-  const shared = (result.sharedWithMe || []).map((file) => `shared\t${file?.filename || 'Untitled'}\t${file?.shareId || ''}`);
-  return printResult([...owned, ...shared].length ? `access\tname\tshareId\n${[...owned, ...shared].join('\n')}` : 'No shared files found.', false);
+    const provider = result.provider || 'provider';
+    return `${displayProvider(provider)}\n${header}\n${divider}\n${rows.join('\n')}\n\nOpen an item: gpdoc ${provider} list --open ROW\nUse --json for full IDs and URLs.`;
+  }
+  const entries = [
+    ...(result.owned || []).map((file) => ({ access: 'Owned', name: file?.filename || 'Untitled', id: file?.shareId || '' })),
+    ...(result.sharedWithMe || []).map((file) => ({ access: 'Shared', name: file?.filename || 'Untitled', id: file?.shareId || '' })),
+  ];
+  if (!entries.length) return 'No shared files found.';
+  const header = 'Access  Name                                Share ID';
+  const rows = entries.map((entry) => `${entry.access.padEnd(6)}  ${truncate(entry.name, 34).padEnd(34)}  ${truncate(entry.id, 18)}`);
+  return `GPDoc shared files\n${header}\n${'─'.repeat(header.length)}\n${rows.join('\n')}\n\nUse --json for full IDs.`;
+}
+
+function renderList(result, json) {
+  if (json) return printResult(result, true);
+  return printResult(formatList(result), false);
+}
+
+async function renderProviderList(result, { open, json, runtime }) {
+  if (!open) return renderList(result, json);
+  if (json) throw new CliError('USAGE', 'Use either --open ROW or --json, not both.');
+  const item = selectListedItem(result.items || [], open);
+  if (!item?.webUrl) throw new CliError('PROVIDER_URL_UNAVAILABLE', 'The selected provider item has no browser URL. Use --json to inspect its identifiers.');
+  renderList(result, false);
+  const browserOpened = await (runtime.openBrowser || openBrowser)(item.webUrl);
+  process.stdout.write(browserOpened ? `Opened ${item.name || 'provider item'} in your browser.\n` : `Could not open a browser. Open this URL manually: ${item.webUrl}\n`);
 }
 
 function createProgressReporter(stderr = process.stderr) {
@@ -372,7 +445,7 @@ async function waitForProviderConnection(remote, providerName, sleep = delay) {
   throw new CliError('PROVIDER_CONNECTION_TIMEOUT', `Timed out waiting for ${providerName} connection. Run gpdoc ${providerName} status to check it later.`);
 }
 
-// @spec CLI-001, CLI-002, CLI-003, CLI-004, CLI-005, CLI-006, CLI-007, CLI-008, CLI-009, CLI-014, CLI-015, CLI-016, CLI-017, CLI-018, CLI-019, CLI-020, CLI-021, CLI-022, CLI-023, CLI-024, CLI-025, CLI-028, CLI-030, CLI-032, CLI-033, CLI-034, CLI-035, CLI-036
+// @spec CLI-001, CLI-002, CLI-003, CLI-004, CLI-005, CLI-006, CLI-007, CLI-008, CLI-009, CLI-014, CLI-015, CLI-016, CLI-017, CLI-018, CLI-019, CLI-020, CLI-021, CLI-022, CLI-023, CLI-024, CLI-025, CLI-028, CLI-030, CLI-032, CLI-033, CLI-034, CLI-035, CLI-036, CLI-038
 export async function run(argv, runtime = {}) {
   if (argv[0] === 'knowledge') {
     await runKnowledge(argv.slice(1), runtime);
@@ -381,6 +454,7 @@ export async function run(argv, runtime = {}) {
   const parsed = parseArguments(argv);
   if (parsed.command === 'help') {
     process.stdout.write(usage());
+    process.stdout.write('\nCloud file lists: use gpdoc google list --open ROW or gpdoc microsoft list --open ROW to open a numbered item in your browser.\n');
     return;
   }
   if (parsed.command === 'version') {
@@ -434,7 +508,7 @@ export async function run(argv, runtime = {}) {
       const connected = await waitForProviderConnection(remote, 'google', runtime.sleep || delay);
       return renderRemote({ ...started, browserOpened, ...connected }, parsed.options.json);
     }
-    if (action === 'list') return renderList(await remote.googleList({ driveId: parsed.options['drive-id'], parentId: parsed.options['parent-id'], cursor: parsed.options.cursor, shared: parsed.options.shared === true }), parsed.options.json);
+    if (action === 'list') return renderProviderList(await remote.googleList({ driveId: parsed.options['drive-id'], parentId: parsed.options['parent-id'], cursor: parsed.options.cursor, shared: parsed.options.shared === true }), { open: parsed.options.open, json: parsed.options.json, runtime });
     const filePath = await requireLocalInput(input);
     const progress = parsed.options.json ? undefined : (runtime.progress || createProgressReporter(runtime.stderr));
     if (action === 'upload') return renderRemote(await remote.googleSave({ filePath, title: parsed.options.title, filetype: parsed.options.filetype || 'document', onProgress: progress }), parsed.options.json);
@@ -452,7 +526,7 @@ export async function run(argv, runtime = {}) {
       const connected = await waitForProviderConnection(remote, 'microsoft', runtime.sleep || delay);
       return renderRemote({ ...started, browserOpened, ...connected }, parsed.options.json);
     }
-    if (action === 'list') return renderList(await remote.microsoftList({ driveId: parsed.options['drive-id'], itemId: parsed.options['item-id'], cursor: parsed.options.cursor, query: parsed.options.query, shared: parsed.options.shared === true }), parsed.options.json);
+    if (action === 'list') return renderProviderList(await remote.microsoftList({ driveId: parsed.options['drive-id'], itemId: parsed.options['item-id'], cursor: parsed.options.cursor, query: parsed.options.query, shared: parsed.options.shared === true }), { open: parsed.options.open, json: parsed.options.json, runtime });
     if (action === 'share') return renderRemote(await remote.microsoftShare({ driveId: requireOption(parsed.options, 'drive-id'), itemId: requireOption(parsed.options, 'item-id'), role: requireOption(parsed.options, 'role'), scope: requireOption(parsed.options, 'scope') }), parsed.options.json);
     const filePath = await requireLocalInput(input);
     const progress = parsed.options.json ? undefined : (runtime.progress || createProgressReporter(runtime.stderr));

package/lib/remote.js

@@ -1,5 +1,10 @@
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
+const {
+  convertDocument,
+  detectFormat,
+  readDocument,
+} = await import('@gpdoc/filekit').catch(() => import('../../gpdoc-filekit/src/index.js'));
 
 export class RemoteError extends Error {
   constructor(code, message) {
@@ -49,6 +54,19 @@ function titleFrom(filePath, fallback = 'GPDoc Export') {
   return path.basename(filePath).replace(/\.gpdoc\.md$/i, '').replace(/\.[^.]+$/, '') || fallback;
 }
 
+async function readExportDocument(filePath) {
+  const format = detectFormat(filePath);
+  if (['docx', 'pptx'].includes(format)) return null;
+  return readDocument(await readFile(filePath, 'utf8'), filePath);
+}
+
+function microsoftFilename(filename, title) {
+  const preferred = String(filename || `${title || 'GPDoc Export'}.docx`).trim() || 'GPDoc Export.docx';
+  return /\.docx$/i.test(preferred)
+    ? preferred
+    : `${preferred.replace(/\.[^.]+$/, '')}.docx`;
+}
+
 async function githubToken({ auth, env, fetchImpl }) {
   const token = await auth.getAccessToken();
   const payload = await jsonRequest(fetchImpl, `${apiBase(env)}/.netlify/functions/get-user-profile`, { headers: bearer(token) }, 'GITHUB_IDENTITY_REQUIRED');
@@ -70,7 +88,7 @@ function githubHeaders(token) {
   return { Authorization: `Bearer ${token}`, Accept: 'application/vnd.github+json', 'Content-Type': 'application/json', 'X-GitHub-Api-Version': '2022-11-28' };
 }
 
-// @spec CLI-019, CLI-020, CLI-021, CLI-022, CLI-023, CLI-024, CLI-025
+// @spec CLI-019, CLI-020, CLI-021, CLI-022, CLI-023, CLI-024, CLI-025, CLI-037
 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', onProgress) {
@@ -90,10 +108,12 @@ export function createRemoteClient({ auth, env = process.env, fetchImpl = global
     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');
+      const document = await readExportDocument(filePath);
+      if (!document) throw new RemoteError('GOOGLE_FILE_TYPE_UNSUPPORTED', 'Google Drive upload requires a text-based GPDoc document. Convert Office files before uploading.');
+      const markdown = convertDocument(document, 'markdown');
       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,
+        title: title || document.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 };
@@ -102,11 +122,23 @@ export function createRemoteClient({ auth, env = process.env, fetchImpl = global
     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);
+      const document = await readExportDocument(filePath);
+      if (document && document.filetype !== 'document') {
+        throw new RemoteError('MICROSOFT_FILE_TYPE_UNSUPPORTED', 'Microsoft 365 CLI export supports GPDoc documents.');
+      }
+      const bytes = document
+        ? Buffer.from(convertDocument(document, 'docx'))
+        : await readFile(filePath);
+      const remoteFilename = document
+        ? microsoftFilename(filename, document.title || titleFrom(filePath))
+        : filename || path.basename(filePath);
+      const remoteMimeType = document
+        ? 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
+        : mimeType(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'),
+        mode, driveId, itemId, filename: remoteFilename, mimeType: remoteMimeType, bytes: bytes.toString('base64'),
       }, 'POST', () => {});
       onProgress?.({ provider: 'microsoft', stage: 'complete', current: 3, total: 3, filePath });
       return { provider: 'microsoft', mode, item: payload.item || payload };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gpdoc/cli",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "type": "module",
   "description": "GPDoc command-line file conversion and validation tools",
   "repository": "https://github.com/repetere/gpdoc.git",