geowiki-cli 1.0.1

package/cli/commands/geo.js

@@ -0,0 +1,144 @@
+/**
+ * GEO status and manifest commands
+ * Usage: geo geo [status|manifest|llms|sitemap] [options]
+ */
+
+import { hasFlag } from '../utils/args.js';
+import { apiGet, apiGetRaw, apiPost, getBaseUrl } from '../utils/api.js';
+import { outputJson, outputSuccess } from '../utils/output.js';
+
+const subActions = { status, manifest, llms, sitemap, report, rebuild };
+
+export async function geo(args) {
+  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+    printGeoHelp();
+    return;
+  }
+
+  const [action, ...subArgs] = args;
+
+  if (subArgs.includes('--help') || subArgs.includes('-h')) {
+    printSubHelp(action);
+    return;
+  }
+
+  if (!subActions[action]) {
+    console.error(`Unknown action: ${action}`);
+    printGeoHelp();
+    process.exit(1);
+  }
+
+  await subActions[action](subArgs);
+}
+
+function printGeoHelp() {
+  console.log(`
+Usage: geo geo <action> [options]
+
+Actions:
+  status     Show GEO status and coverage
+  manifest   Show site manifest (JSON)
+  llms       Show llms.txt content
+  sitemap    Show sitemap.xml content
+  report     Show GEO analysis report
+  rebuild    Rebuild GEO files (llms.txt, sitemap.xml)
+
+Options:
+  --json     Machine-readable JSON output
+  --help     Show help
+
+Examples:
+  geo geo status
+  geo geo rebuild
+  geo geo report --json`);
+}
+
+function printSubHelp(action) {
+  const helps = {
+    status: `Show GEO status and coverage.
+
+Usage: geo geo status [--json]`,
+    manifest: `Show site manifest as JSON.
+
+Usage: geo geo manifest`,
+    llms: `Display llms.txt content (AI crawler feed).
+
+Usage: geo geo llms`,
+    sitemap: `Display sitemap.xml content.
+
+Usage: geo geo sitemap`,
+    report: `Show GEO analysis report.
+
+Usage: geo geo report [--json]`,
+    rebuild: `Rebuild GEO files (llms.txt, sitemap.xml).
+
+Usage: geo geo rebuild [--json]`
+  };
+  console.log(helps[action] || `Unknown action: ${action}`);
+}
+
+async function status(args = []) {
+  const json = hasFlag(args, '--json');
+  const baseUrl = getBaseUrl();
+
+  const data = await apiGet('/api/v1/geo/manifest');
+  const geoData = data.data || {};
+  // Server returns counts.totalDocs (nested), also check root level for compatibility
+  const counts = geoData.counts || {};
+  const total = counts.totalDocs || geoData.totalDocs || 0;
+
+  // Check AI compatibility features
+  const aiCompat = geoData.aiCompatibility || {};
+  const jsonLdSupported = aiCompat.jsonLdSupported || false;
+  const llmsTxtPath = aiCompat.llmsTxtPath || null;
+
+  // Calculate coverage based on categories with docs
+  const categories = geoData.categories || [];
+  const catsWithDocs = categories.filter(c => c.docCount > 0).length;
+  const coverage = categories.length > 0 ? ((catsWithDocs / categories.length) * 100).toFixed(1) : '0.0';
+
+  if (outputJson({ baseUrl, ...geoData, coverage: `${coverage}%` }, json)) return;
+
+  console.log('\n=== GEO Status ===\n');
+  console.log(`Base URL: ${baseUrl}`);
+  console.log(`Total Docs: ${total}`);
+  console.log(`Categories: ${categories.length}`);
+  console.log(`JSON-LD Supported: ${jsonLdSupported ? 'Yes' : 'No'}`);
+  console.log(`llms.txt: ${llmsTxtPath || 'Not configured'}`);
+  if (categories.length > 0) console.log(`\nGEO Coverage: ${coverage}% (${catsWithDocs}/${categories.length} categories with docs)`);
+}
+
+async function manifest(_args) {
+  const data = await apiGet('/api/v1/geo/manifest');
+  outputJson(data.data, true); // always JSON format
+}
+
+async function llms() {
+  const text = await apiGetRaw('/api/v1/llms.txt');
+  console.log(text);
+}
+
+async function sitemap() {
+  const text = await apiGetRaw('/api/v1/geo/sitemap.xml');
+  console.log(text);
+}
+
+async function report(args = []) {
+  const json = args.includes('--json');
+
+  const data = await apiGet('/api/v1/admin/geo/report');
+  const reportData = data.data || {};
+
+  if (outputJson(reportData, json)) return;
+
+  console.log('\n=== GEO Report ===\n');
+  console.log(JSON.stringify(reportData, null, 2));
+  console.log('');
+}
+
+async function rebuild(args = []) {
+  const json = args.includes('--json');
+  console.log('Rebuilding GEO files (llms.txt, sitemap.xml)...');
+  const data = await apiPost('/api/v1/geo/rebuild', {});
+  outputSuccess('GEO files rebuilt', json, data.data);
+}

package/cli/commands/guestbook.js

@@ -0,0 +1,114 @@
+/**
+ * Guestbook management commands
+ * Usage: geo guestbook [list|toggle|update|delete] [options]
+ */
+
+import { extractArg, hasFlag } from '../utils/args.js';
+import { apiGet, apiPut, apiDelete } from '../utils/api.js';
+import { outputJson, outputSuccess, confirmDelete } from '../utils/output.js';
+import { dispatch } from '../utils/dispatch.js';
+
+export async function guestbook(args) {
+  const result = dispatch(args, actions, ['list', 'toggle', 'update', 'delete'], printGuestbookHelp);
+  if (result) await actions[result.action](result.subArgs);
+}
+
+const actions = {
+  async list(args) {
+    const json = hasFlag(args, '--json');
+
+    const data = await apiGet('/api/v1/admin/guestbook');
+    const entries = data.data || [];
+
+    if (outputJson(entries, json)) return;
+
+    console.log(`\nGuestbook Entries (${entries.length} found):\n`);
+    entries.forEach(e => {
+      const id = (e.id || e._id || '').toString().slice(0, 8);
+      const status = e.status || 'pending';
+      console.log(`  ${id.padEnd(10)} | ${status.padEnd(10)} | ${(e.name || '').padEnd(15)} | ${(e.message || '').substring(0, 40)}`);
+    });
+  },
+
+  async toggle(args) {
+    const enabled = extractArg(args, '--enabled');
+    const json = hasFlag(args, '--json');
+
+    if (enabled === null || enabled === undefined) {
+      console.error('Error: --enabled is required (true or false)');
+      process.exit(1);
+    }
+
+    const enabledBool = enabled === 'true' || enabled === '1';
+
+    await apiPut('/api/v1/admin/guestbook-toggle', { enabled: enabledBool });
+    outputSuccess(`Guestbook ${enabledBool ? 'enabled' : 'disabled'}`, json, { enabled: enabledBool });
+  },
+
+  async update(args) {
+    const id = extractArg(args, '--id');
+    const status = extractArg(args, '--status');
+    const json = hasFlag(args, '--json');
+
+    if (!id) {
+      console.error('Error: --id is required');
+      process.exit(1);
+    }
+
+    if (!status) {
+      console.error('Error: --status is required (approved or rejected)');
+      process.exit(1);
+    }
+
+    if (!['approved', 'rejected'].includes(status)) {
+      console.error('Error: --status must be "approved" or "rejected"');
+      process.exit(1);
+    }
+
+    await apiPut(`/api/v1/admin/guestbook/${encodeURIComponent(id)}`, { status });
+    outputSuccess(`Guestbook entry ${status}: ${id}`, json, { id, status });
+  },
+
+  async delete(args) {
+    const id = extractArg(args, '--id');
+    const json = hasFlag(args, '--json');
+
+    if (!id) {
+      console.error('Error: --id is required');
+      process.exit(1);
+    }
+
+    const confirmed = await confirmDelete(`Delete guestbook entry "${id}"?`, args);
+    if (!confirmed) {
+      console.log('Cancelled.');
+      return;
+    }
+
+    await apiDelete(`/api/v1/admin/guestbook/${encodeURIComponent(id)}`);
+    outputSuccess(`Guestbook entry deleted: ${id}`, json, { deleted: id });
+  }
+};
+
+function printGuestbookHelp() {
+  console.log(`
+Usage: geo guestbook <action> [options]
+
+Actions:
+  list       List all guestbook entries
+  toggle     Enable or disable guestbook
+  update     Update entry status (approve/reject)
+  delete     Delete a guestbook entry
+
+Options:
+  --id              Entry ID (required for update/delete)
+  --status          New status: approved, rejected (required for update)
+  --enabled         Enable/disable guestbook: true, false (required for toggle)
+  --json            Machine-readable JSON output
+
+Examples:
+  geo guestbook list --json
+  geo guestbook toggle --enabled true
+  geo guestbook update --id "entry-id" --status approved
+  geo guestbook delete --id "entry-id"
+`);
+}

package/cli/commands/login.js

@@ -0,0 +1,181 @@
+/**
+ * Login command
+ * Usage:
+ *   geo login --url URL --user USER --pass PASS    (password login)
+ *   geo login --url URL --token TOKEN              (token login)
+ */
+
+import { extractArg } from '../utils/args.js';
+import { config } from '../utils/config.js';
+import readline from 'readline';
+
+const COOKIE_NAME = 'geo_wiki_token';
+const CSRF_COOKIE_NAME = 'XSRF-TOKEN';
+
+/**
+ * Read password from stdin without echoing to terminal.
+ */
+async function readPasswordFromStdin() {
+  // If stdin is not a TTY, read from pipe
+  if (!process.stdin.isTTY) {
+    return new Promise((resolve) => {
+      let data = '';
+      process.stdin.setEncoding('utf-8');
+      process.stdin.on('data', (chunk) => { data += chunk; });
+      process.stdin.on('end', () => resolve(data.trim()));
+    });
+  }
+  // Interactive prompt
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => {
+    rl.question('Password: ', (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+
+/**
+ * Parse the geo_wiki_token cookie pair out of a Set-Cookie header.
+ * Exported for unit testing.
+ */
+export function extractCookiePair(setCookieHeader) {
+  if (!setCookieHeader) return null;
+  const entries = String(setCookieHeader).split(/,(?=\s*[A-Za-z0-9_-]+=)/);
+  const cookies = [];
+  for (const entry of entries) {
+    const pair = entry.split(';')[0].trim();
+    if (pair.startsWith(`${COOKIE_NAME}=`) || pair.startsWith(`${CSRF_COOKIE_NAME}=`)) {
+      cookies.push(pair);
+    }
+  }
+  return cookies.length > 0 ? cookies.join('; ') : null;
+}
+
+export async function login(args) {
+  if (args.includes('--help') || args.includes('-h')) {
+    printLoginHelp();
+    return;
+  }
+
+  const url = extractArg(args, '--url') || extractArg(args, '-u');
+  const token = extractArg(args, '--token') || extractArg(args, '-t');
+  const user = extractArg(args, '--user') || extractArg(args, '-U');
+  const pass = extractArg(args, '--pass') || extractArg(args, '-p');
+
+  if (!url) {
+    printLoginHelp();
+    process.exit(1);
+  }
+
+  // Warn about HTTP (credentials sent in plaintext)
+  if (url.startsWith('http://') && !url.includes('localhost') && !url.includes('127.0.0.1')) {
+    console.warn('⚠️  Warning: Using HTTP — credentials will be transmitted in plaintext. Use HTTPS for production.');
+  }
+
+  // Token login
+  if (token) {
+    console.log(`Connecting to ${url}...`);
+    try {
+      const res = await fetch(`${url}/api/v1/auth/me`, {
+        headers: { 'Authorization': `Bearer ${token}` }
+      });
+      const data = await res.json().catch(() => ({}));
+      if (!res.ok || !data.success) {
+        console.error(`Token login failed: ${data.message || res.statusText}`);
+        process.exit(1);
+      }
+      config.setBaseUrl(url);
+      config.setApiToken(token);
+      const u = data.data?.user;
+      if (u && u.username) {
+        console.log('Login successful!');
+        console.log(`User: ${u.username} (${u.role || 'unknown'})`);
+      } else {
+        console.log('Login successful!');
+        console.log('Token accepted (user info will be shown on next status check)');
+      }
+    } catch (e) {
+      console.error(`Login failed: ${e.message}`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Password login
+  if (!user) {
+    printLoginHelp();
+    process.exit(1);
+  }
+
+  // Read password from stdin if --pass is '-' or not provided
+  let password = pass;
+  if (!password || password === '-') {
+    password = await readPasswordFromStdin();
+    if (!password) {
+      console.error('Error: password is required (use --pass or pipe via stdin)');
+      process.exit(1);
+    }
+  }
+
+  console.log(`Logging in to ${url}...`);
+  try {
+    const res = await fetch(`${url}/api/v1/auth/login`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Client': 'geowiki-cli'
+      },
+      body: JSON.stringify({ username: user, password: password })
+    });
+
+    const data = await res.json().catch(() => ({}));
+
+    if (!res.ok || !data.success) {
+      console.error(`Login failed: ${data.message || data.error || res.statusText}`);
+      process.exit(1);
+    }
+
+    const setCookie = res.headers.get('set-cookie');
+    const cookiePair = extractCookiePair(setCookie);
+    if (!cookiePair) {
+      console.error('Login failed: server did not return geo_wiki_token cookie.');
+      process.exit(1);
+    }
+
+    config.setBaseUrl(url);
+    config.setCookie(cookiePair);
+    config.clearApiToken(); // Clear any stale API token when logging in with password
+
+    const u = data.data?.user || {};
+    console.log('Login successful!');
+    console.log(`User: ${u.username || user} (${u.role || 'unknown'})`);
+  } catch (e) {
+    console.error(`Login failed: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+function printLoginHelp() {
+  console.log(`
+Usage:
+  geo login --url URL --user USER --pass PASS    (password login)
+  geo login --url URL --user USER                (prompt for password)
+  echo "pass" | geo login --url URL --user USER  (password from stdin)
+  geo login --url URL --token TOKEN              (token login)
+
+Options:
+  --url, -u     Wiki base URL (e.g., http://your-site:9002)
+  --user, -U    Username (password login)
+  --pass, -p    Password (password login). Use '-' to read from stdin.
+  --token, -t   API Token (token login)
+
+Security tip: Avoid --pass in shell history. Use prompt or stdin instead.
+
+Examples:
+  geo login --url http://your-site:9002 --user admin --pass <password>
+  geo login --url http://your-site:9002 --user admin
+  echo "mypassword" | geo login --url http://your-site:9002 --user admin --pass -
+  geo login --url http://your-site:9002 --token geo_xxxxx
+`);
+}

package/cli/commands/media.js

@@ -0,0 +1,187 @@
+/**
+ * Media management commands
+ * Usage: geo media [upload|list|delete|tree|mkdir|rmdir|move] [options]
+ */
+
+import { extractArg, hasFlag } from '../utils/args.js';
+import { apiGet, apiPost, apiDelete, apiUpload, getBaseUrl } from '../utils/api.js';
+import { outputJson, outputSuccess } from '../utils/output.js';
+import { dispatch } from '../utils/dispatch.js';
+import fs from 'fs';
+
+export async function media(args) {
+  const result = dispatch(args, actions, ['upload', 'list', 'delete', 'tree', 'mkdir', 'rmdir', 'move'], printMediaHelp);
+  if (result) await actions[result.action](result.subArgs);
+}
+
+const actions = {
+  async upload(args) {
+    const file = extractArg(args, '--file') || extractArg(args, '-f');
+    const directory = extractArg(args, '--directory') || extractArg(args, '-d');
+    const json = hasFlag(args, '--json');
+
+    if (!file) {
+      console.error('Error: --file is required');
+      process.exit(1);
+    }
+
+    if (!fs.existsSync(file)) {
+      console.error(`File not found: ${file}`);
+      process.exit(1);
+    }
+
+    if (!json) console.log(`Uploading: ${file}${directory ? ` -> ${directory}/` : ''}...`);
+
+    const data = await apiUpload('/api/v1/media/upload', file, { directory });
+    const baseUrl = getBaseUrl();
+    const payload = data.data || {};
+
+    if (outputJson({ ...payload, fullUrl: `${baseUrl}${payload.url || ''}` }, json)) return;
+
+    console.log('Uploaded successfully!');
+    console.log(`File: ${payload.filename}`);
+    console.log(`URL:  ${baseUrl}${payload.url}`);
+    console.log(`\nTip: To delete this file later, use:\n  geo media delete --file ${payload.filename}`);
+  },
+
+  async list(args) {
+    const dir = extractArg(args, '--dir') || '';
+    const json = hasFlag(args, '--json');
+
+    const qs = dir ? `?dir=${encodeURIComponent(dir)}` : '';
+    const data = await apiGet(`/api/v1/media${qs}`);
+    const files = data.data?.files || data.data || [];
+
+    if (outputJson(files, json)) return;
+
+    console.log(`\nMedia files (${files.length} found)${dir ? ` in ${dir}` : ''}:\n`);
+    files.forEach(f => {
+      const size = f.size > 1024 * 1024 ? `${(f.size / 1024 / 1024).toFixed(1)}MB` : `${(f.size / 1024).toFixed(1)}KB`;
+      console.log(`  ${(f.originalFilename || f.filename || '').padEnd(40)} | ${size.padEnd(10)} | ${f.uploadedBy || '—'}`);
+    });
+  },
+
+  async tree(args) {
+    const json = hasFlag(args, '--json');
+
+    const data = await apiGet('/api/v1/media?tree=1');
+    const tree = data.data?.tree || [];
+
+    if (outputJson(tree, json)) return;
+
+    console.log('\nMedia directory tree:\n');
+    printTree(tree, '');
+  },
+
+  async mkdir(args) {
+    const name = extractArg(args, '--name') || extractArg(args, '-n');
+    const parent = extractArg(args, '--parent') || extractArg(args, '-p') || '';
+    const json = hasFlag(args, '--json');
+
+    if (!name) {
+      console.error('Error: --name is required');
+      process.exit(1);
+    }
+
+    if (!json) console.log(`Creating folder: ${parent ? parent + '/' : ''}${name}...`);
+
+    const data = await apiPost('/api/v1/media/folder', { name, parentPath: parent });
+    outputSuccess(`Created: ${data.data?.path || name}`, json, data.data);
+  },
+
+  async rmdir(args) {
+    const path = extractArg(args, '--path') || extractArg(args, '-p');
+    const json = hasFlag(args, '--json');
+
+    if (!path) {
+      console.error('Error: --path is required');
+      process.exit(1);
+    }
+
+    if (!json) console.log(`Deleting folder: ${path}...`);
+
+    await apiDelete('/api/v1/media/folder', { folderPath: path });
+    outputSuccess(`Deleted folder: ${path}`, json, { deleted: path });
+  },
+
+  async move(args) {
+    const source = extractArg(args, '--source') || extractArg(args, '-s');
+    const target = extractArg(args, '--target') || extractArg(args, '-t') || '';
+    const json = hasFlag(args, '--json');
+
+    if (!source) {
+      console.error('Error: --source is required');
+      process.exit(1);
+    }
+
+    if (!json) console.log(`Moving: ${source} -> ${target || '(root)'}...`);
+
+    const data = await apiPost('/api/v1/media/move', { sourcePath: source, targetDir: target });
+    outputSuccess(`Moved: ${source}`, json, data.data);
+  },
+
+  async delete(args) {
+    const filename = extractArg(args, '--file') || extractArg(args, '-f');
+    const json = hasFlag(args, '--json');
+
+    if (!filename) {
+      console.error('Error: --file is required');
+      process.exit(1);
+    }
+
+    if (!json) console.log(`Deleting: ${filename}...`);
+
+    await apiDelete(`/api/v1/media/${encodeURIComponent(filename)}`);
+    outputSuccess(`Deleted: ${filename}`, json, { deleted: filename });
+  }
+};
+
+function printTree(nodes, prefix) {
+  nodes.forEach((node, i) => {
+    const isLast = i === nodes.length - 1;
+    const connector = isLast ? '└── ' : '├── ';
+    const childPrefix = isLast ? '    ' : '│   ';
+    console.log(`${prefix}${connector}${node.name}/`);
+    if (node.children && node.children.length) {
+      printTree(node.children, prefix + childPrefix);
+    }
+  });
+}
+
+function printMediaHelp() {
+  console.log(`
+Usage: geo media <action> [options]
+
+Actions:
+  upload    Upload a file (image / video / 3D model / document)
+  list      List media files in a directory
+  tree      Show directory tree
+  mkdir     Create a folder
+  rmdir     Delete a folder
+  move      Move a file to another directory
+  delete    Delete a media file (admin)
+
+Options:
+  --file, -f         Local file path (upload) or filename (delete)
+  --directory, -d    Sub-directory for upload (e.g. "products/eva-kit")
+  --dir              Directory to list (e.g. "products")
+  --name, -n         Folder name (mkdir)
+  --parent, -p       Parent directory (mkdir)
+  --path, -p         Folder path to delete (rmdir)
+  --source, -s       Source file path (move, e.g. "test/image.png")
+  --target, -t       Target directory (move, empty = root)
+  --json             Machine-readable JSON output
+
+Examples:
+  geo media upload --file ./diagram.jpg
+  geo media upload --file ./model.step --directory models
+  geo media list --dir products
+  geo media tree
+  geo media mkdir --name products
+  geo media mkdir --name images --parent products
+  geo media rmdir --path old-folder
+  geo media move --source test/img.png --target products
+  geo media move --source products/img.png            # move to root
+  geo media delete --file old-image.jpg
+`);
+}

package/cli/commands/search.js

@@ -0,0 +1,67 @@
+/**
+ * Search documents
+ * Usage: geo search <query> [options]
+ */
+
+import { extractArg, hasFlag } from '../utils/args.js';
+import { apiGet, getBaseUrl } from '../utils/api.js';
+import { outputJson } from '../utils/output.js';
+
+export async function search(args) {
+  const query = args[0];
+
+  if (!query || query === '--help' || query === '-h') {
+    printSearchHelp();
+    return;
+  }
+
+  const category = extractArg(args, '--category') || extractArg(args, '-c');
+  const lang = extractArg(args, '--lang') || extractArg(args, '-l') || 'zh';
+  const limit = extractArg(args, '--limit') || '20';
+  const json = hasFlag(args, '--json');
+
+  let url = `/api/v1/docs/search?q=${encodeURIComponent(query)}&lang=${lang}&limit=${limit}`;
+  if (category) url += `&category=${encodeURIComponent(category)}`;
+
+  const data = await apiGet(url);
+  const results = data.data || [];
+
+  if (outputJson(results, json)) return;
+
+  console.log(`\nFound ${results.length} result(s):\n`);
+
+  if (results.length === 0) {
+    console.log('  No results found.');
+    return;
+  }
+
+  const baseUrl = getBaseUrl();
+  results.forEach((r, i) => {
+    console.log(`${i + 1}. ${r.title || r.slug}`);
+    console.log(`   URL: ${baseUrl}/docs/${r.slug}`);
+    if (r.description) {
+      console.log(`   ${r.description.substring(0, 80)}...`);
+    }
+    console.log('');
+  });
+}
+
+function printSearchHelp() {
+  console.log(`
+Usage: geo search <query> [options]
+
+Arguments:
+  query              Search query string
+
+Options:
+  --category, -c     Filter by category
+  --lang, -l         Language (zh/en), default: zh
+  --limit            Max results, default: 20
+  --json             Machine-readable JSON output
+
+Examples:
+  geo search "CAN bus"
+  geo search "motor" --category can-motion
+  geo search "Arduino" --lang en
+`);
+}