geowiki-cli 1.0.1

package/cli/utils/api.js

@@ -0,0 +1,197 @@
+/**
+ * Unified API client for CLI commands
+ * Auto-injects baseUrl, cookie auth, CSRF token, and error handling.
+ *
+ * Round 2 migration: server uses httpOnly Cookie (geo_wiki_token).
+ * We send the persisted cookie pair via the `Cookie` header on every call.
+ * CSRF token is extracted from the cookie and sent in x-xsrf-token header.
+ */
+
+import path from 'path';
+import { config } from './config.js';
+
+const REQUEST_TIMEOUT = 30000; // 30 seconds
+
+function fail(msg) {
+  console.error(msg);
+  process.exit(1);
+}
+
+function extractCsrfToken(cookie) {
+  if (!cookie) return '';
+  const match = cookie.match(/XSRF-TOKEN=([^;]+)/);
+  return match ? match[1] : '';
+}
+
+function authHeader(extra = {}) {
+  // API token takes precedence
+  const apiToken = config.getApiToken();
+  if (apiToken) {
+    return { ...extra, 'Authorization': `Bearer ${apiToken}` };
+  }
+  // Fall back to cookie auth
+  const cookie = config.getCookie();
+  if (!cookie) return extra;
+  const csrfToken = extractCsrfToken(cookie);
+  const headers = { ...extra, Cookie: cookie };
+  if (csrfToken) {
+    headers['x-xsrf-token'] = csrfToken;
+  }
+  return headers;
+}
+
+async function handleResponse(res, errorMessage) {
+  const data = await res.json().catch(() => ({}));
+
+  if (!res.ok || (data.success === false)) {
+    fail(`${errorMessage}: ${data.message || data.error || res.statusText}`);
+  }
+
+  return data;
+}
+
+export async function apiGet(path) {
+  const baseUrl = config.getBaseUrl();
+  try {
+    const res = await fetch(`${baseUrl}${path}`, {
+      headers: authHeader(),
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT)
+    });
+    return await handleResponse(res, `Request failed`);
+  } catch (e) {
+    fail(`Error: ${e.message}`);
+  }
+}
+
+export async function apiGetRaw(path) {
+  const baseUrl = config.getBaseUrl();
+  try {
+    const res = await fetch(`${baseUrl}${path}`, {
+      headers: authHeader(),
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT)
+    });
+    if (!res.ok) fail(`Request failed: ${res.statusText}`);
+    return await res.text();
+  } catch (e) {
+    fail(`Error: ${e.message}`);
+  }
+}
+
+export async function apiPost(path, body) {
+  const baseUrl = config.getBaseUrl();
+  try {
+    const res = await fetch(`${baseUrl}${path}`, {
+      method: 'POST',
+      headers: authHeader({ 'Content-Type': 'application/json' }),
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT)
+    });
+    return await handleResponse(res, `Request failed`);
+  } catch (e) {
+    fail(`Error: ${e.message}`);
+  }
+}
+
+export async function apiPut(path, body) {
+  const baseUrl = config.getBaseUrl();
+  try {
+    const res = await fetch(`${baseUrl}${path}`, {
+      method: 'PUT',
+      headers: authHeader({ 'Content-Type': 'application/json' }),
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT)
+    });
+    return await handleResponse(res, `Request failed`);
+  } catch (e) {
+    fail(`Error: ${e.message}`);
+  }
+}
+
+export async function apiDelete(path, body) {
+  const baseUrl = config.getBaseUrl();
+  try {
+    const opts = {
+      method: 'DELETE',
+      headers: authHeader({ 'Content-Type': 'application/json' }),
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT)
+    };
+    if (body) opts.body = JSON.stringify(body);
+    const res = await fetch(`${baseUrl}${path}`, opts);
+    if (!res.ok) {
+      const data = await res.json().catch(() => ({}));
+      fail(`Failed to delete: ${data.message || data.error || res.statusText}`);
+    }
+    return true;
+  } catch (e) {
+    fail(`Error: ${e.message}`);
+  }
+}
+
+const MIME_BY_EXT = {
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.png': 'image/png',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.mp4': 'video/mp4',
+  '.webm': 'video/webm',
+  '.mp3': 'audio/mpeg',
+  '.wav': 'audio/wav',
+  '.ogg': 'audio/ogg',
+  '.pdf': 'application/pdf',
+  '.doc': 'application/msword',
+  '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  '.txt': 'text/plain',
+  '.md': 'text/markdown',
+  '.step': 'application/step',
+  '.stp': 'application/stp',
+  '.igs': 'application/iges',
+  '.iges': 'application/iges'
+};
+
+function guessMime(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return MIME_BY_EXT[ext] || 'application/octet-stream';
+}
+
+// Exported for unit testing; mirrors the server's ALLOWED_TYPES table.
+export const __test = { guessMime, MIME_BY_EXT };
+
+/**
+ * Upload a file as raw binary body (server expects req.headers + raw bytes).
+ * @param {string} apiPath  Always '/api/v1/media/upload'.
+ * @param {string} file     Local file path.
+ * @param {object} [opts]
+ * @param {string} [opts.directory]  Optional sub-directory under public/media.
+ */
+export async function apiUpload(apiPath, file, opts = {}) {
+  const baseUrl = config.getBaseUrl();
+  const fs = await import('fs');
+  const buffer = fs.readFileSync(file);
+  const fileName = path.basename(file);
+  const mime = guessMime(file);
+
+  const headers = authHeader({
+    'Content-Type': mime,
+    'X-Original-Filename': encodeURIComponent(fileName)
+  });
+  if (opts.directory) {
+    headers['X-Media-Directory'] = opts.directory;
+  }
+
+  try {
+    const res = await fetch(`${baseUrl}${apiPath}`, {
+      method: 'POST',
+      headers,
+      body: buffer,
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT * 3) // Uploads can be larger
+    });
+    return await handleResponse(res, `Upload failed`);
+  } catch (e) {
+    fail(`Error: ${e.message}`);
+  }
+}
+
+export function getBaseUrl() {
+  return config.getBaseUrl();
+}

package/cli/utils/args.js

@@ -0,0 +1,25 @@
+/**
+ * Argument parsing helpers for CLI commands
+ */
+
+export function extractArg(args, flag) {
+  // Support --flag=value syntax
+  for (const arg of args) {
+    if (arg.startsWith(flag + '=')) {
+      return arg.slice(flag.length + 1);
+    }
+  }
+  // Support --flag value syntax
+  const idx = args.indexOf(flag);
+  if (idx < 0) return null;
+  const val = args[idx + 1];
+  // Reject if next token is itself a flag
+  if (val !== undefined && !val.startsWith('-')) {
+    return val;
+  }
+  return null;
+}
+
+export function hasFlag(args, flag) {
+  return args.includes(flag);
+}

package/cli/utils/config.js

@@ -0,0 +1,94 @@
+/**
+ * Config manager for GEO Wiki CLI
+ * Stores cookie and base URL in user's home directory.
+ *
+ * Round 2 migration: server uses httpOnly Cookie (geo_wiki_token) for auth.
+ * The CLI persists the raw cookie pair (e.g. "geo_wiki_token=eyJ...") and
+ * sends it back via the `Cookie` request header on subsequent calls.
+ */
+
+import os from 'os';
+import path from 'path';
+import fs from 'fs';
+
+const CONFIG_DIR = path.join(os.homedir(), '.geowiki');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+function load() {
+  try {
+    if (fs.existsSync(CONFIG_FILE)) {
+      return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+    }
+  } catch (e) {}
+  return { cookie: null, baseUrl: null, apiToken: null };
+}
+
+function save(data) {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(data, null, 2), { mode: 0o600 });
+}
+
+export const config = {
+  getCookie() {
+    return load().cookie;
+  },
+
+  setCookie(cookie) {
+    const data = load();
+    data.cookie = cookie;
+    save(data);
+  },
+
+  clearCookie() {
+    const data = load();
+    data.cookie = null;
+    save(data);
+  },
+
+  // API Token support
+  getApiToken() {
+    return load().apiToken || null;
+  },
+
+  setApiToken(token) {
+    const data = load();
+    data.apiToken = token;
+    save(data);
+  },
+
+  clearApiToken() {
+    const data = load();
+    data.apiToken = null;
+    save(data);
+  },
+
+  // Backwards-compatible aliases
+  getToken() {
+    const data = load();
+    return data.cookie || data.apiToken;
+  },
+  clearToken() {
+    const data = load();
+    data.cookie = null;
+    data.apiToken = null;
+    save(data);
+  },
+
+  getBaseUrl() {
+    return load().baseUrl;
+  },
+
+  setBaseUrl(baseUrl) {
+    const data = load();
+    data.baseUrl = baseUrl;
+    save(data);
+  },
+
+  clearAll() {
+    if (fs.existsSync(CONFIG_FILE)) {
+      fs.unlinkSync(CONFIG_FILE);
+    }
+  }
+};

package/cli/utils/dispatch.js

@@ -0,0 +1,20 @@
+/**
+ * Generic action dispatch for CLI subcommands
+ */
+
+export function dispatch(args, actions, validActions, printHelp) {
+  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+    printHelp();
+    return null;
+  }
+
+  const [action, ...subArgs] = args;
+
+  if (!validActions.includes(action)) {
+    console.error(`Unknown action: ${action}`);
+    printHelp();
+    process.exit(1);
+  }
+
+  return { action, subArgs };
+}

package/cli/utils/output.js

@@ -0,0 +1,41 @@
+/**
+ * Output helpers for CLI commands
+ * Supports --json flag for agent-friendly structured output
+ */
+
+import readline from 'readline';
+
+export function outputJson(data, jsonFlag) {
+  if (jsonFlag) {
+    console.log(JSON.stringify(data, null, 2));
+    return true;
+  }
+  return false;
+}
+
+export function outputSuccess(message, jsonFlag, data = {}) {
+  if (jsonFlag) {
+    console.log(JSON.stringify({ success: true, ...data }, null, 2));
+    return;
+  }
+  console.log(message);
+}
+
+/**
+ * Prompt user for confirmation. Returns true if confirmed.
+ * Skips prompt if --yes/-y flag is present.
+ * @param {string} message - Confirmation message
+ * @param {string[]} args - Command args to check for --yes/-y
+ * @returns {Promise<boolean>}
+ */
+export async function confirmDelete(message, args = []) {
+  if (args.includes('--yes') || args.includes('-y')) return true;
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => {
+    rl.question(`${message} (y/N) `, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+    });
+  });
+}

package/package.json

@@ -0,0 +1,98 @@
+{
+  "name": "geowiki-cli",
+  "version": "1.0.1",
+  "description": "GEO Wiki Pro - AI-powered knowledge base with GEO optimization",
+  "type": "module",
+  "bin": "bin/geo.js",
+  "files": [
+    "bin/",
+    "cli/commands/",
+    "cli/utils/",
+    "cli/index.js",
+    "cli/package.json"
+  ],
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview",
+    "server": "node server/index.js",
+    "dev:full": "concurrently \"npm run dev\" \"npm run server\"",
+    "import:data": "node scripts/import-data.js",
+    "lint": "eslint src --ext .vue,.js",
+    "test": "vitest run",
+    "test:e2e": "node tests/e2e/setup.js && playwright test",
+    "test:e2e:ui": "playwright test --ui",
+    "test:e2e:headed": "playwright test --headed",
+    "prepare": "node -e \"try{require('husky')}catch{}\""
+  },
+  "dependencies": {
+    "@codemirror/autocomplete": "^6.20.2",
+    "@codemirror/commands": "^6.10.3",
+    "@codemirror/lang-markdown": "^6.5.0",
+    "@codemirror/language": "^6.12.3",
+    "@codemirror/language-data": "^6.5.2",
+    "@codemirror/search": "^6.7.0",
+    "@codemirror/state": "^6.6.0",
+    "@codemirror/theme-one-dark": "^6.1.3",
+    "@codemirror/view": "^6.42.1",
+    "bcryptjs": "^3.0.3",
+    "compression": "^1.8.1",
+    "cors": "^2.8.0",
+    "dompurify": "^3.4.5",
+    "express": "^4.18.0",
+    "fuse.js": "^7.0.0",
+    "gray-matter": "^4.0.3",
+    "helmet": "^8.0.0",
+    "highlight.js": "^11.9.0",
+    "jsonwebtoken": "^9.0.0",
+    "markdown-it": "^14.1.1",
+    "markdown-it-anchor": "^8.6.7",
+    "markdown-it-container": "^3.0.0",
+    "markdown-it-emoji": "^2.0.2",
+    "markdown-it-footnote": "^3.0.3",
+    "markdown-it-mark": "^3.0.1",
+    "markdown-it-task-lists": "^1.4.1",
+    "pinia": "^2.1.0",
+    "pino": "^10.3.1",
+    "pino-pretty": "^13.1.3",
+    "sql.js": "^1.14.1",
+    "vue": "^3.4.0",
+    "vue-router": "^4.2.0"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.44.0",
+    "@vitejs/plugin-vue": "^5.0.0",
+    "@vue/test-utils": "^2.4.10",
+    "autoprefixer": "^10.4.0",
+    "concurrently": "^8.2.0",
+    "eslint": "^8.57.0",
+    "eslint-plugin-vue": "^9.33.0",
+    "husky": "^9.1.7",
+    "jsdom": "^29.1.1",
+    "lint-staged": "^16.4.0",
+    "postcss": "^8.4.0",
+    "tailwindcss": "^3.4.0",
+    "vite": "^5.0.0",
+    "vitest": "^1.2.0",
+    "vue-eslint-parser": "^9.4.3"
+  },
+  "keywords": [
+    "geo",
+    "wiki",
+    "knowledge-base",
+    "cli",
+    "ai",
+    "seo",
+    "documentation"
+  ],
+  "author": "GEO Wiki Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ai-littleyao/geo-wiki-framework.git"
+  },
+  "lint-staged": {
+    "*.{vue,js}": "eslint --fix",
+    "*.{json,md,yml}": "prettier --write"
+  }
+}