@aaronshaf/confluence-cli 0.1.15

package/src/cli/index.ts

@@ -0,0 +1,413 @@
+#!/usr/bin/env bun
+import chalk from 'chalk';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { EXIT_CODES } from '../lib/errors.js';
+import {
+  showAttachmentsHelp,
+  showCloneHelp,
+  showCommentsHelp,
+  showCreateHelp,
+  showDeleteHelp,
+  showDoctorHelp,
+  showHelp,
+  showInfoHelp,
+  showLabelsHelp,
+  showMoveHelp,
+  showOpenHelp,
+  showPullHelp,
+  showPushHelp,
+  showSearchHelp,
+  showSetupHelp,
+  showSpacesHelp,
+  showStatusHelp,
+  showTreeHelp,
+} from './help.js';
+import { attachmentsCommand } from './commands/attachments.js';
+import { cloneCommand } from './commands/clone.js';
+import { commentsCommand } from './commands/comments.js';
+import { createCommand } from './commands/create.js';
+import { deleteCommand } from './commands/delete.js';
+import { doctorCommand } from './commands/doctor.js';
+import { infoCommand } from './commands/info.js';
+import { labelsCommand } from './commands/labels.js';
+import { moveCommand } from './commands/move.js';
+import { openCommand } from './commands/open.js';
+import { pullCommand } from './commands/pull.js';
+import { pushCommand } from './commands/push.js';
+import { searchCommand } from './commands/search.js';
+import { setup } from './commands/setup.js';
+import { spacesCommand } from './commands/spaces.js';
+import { statusCommand } from './commands/status.js';
+import { treeCommand } from './commands/tree.js';
+
+// Get version from package.json
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJsonPath = join(__dirname, '..', '..', 'package.json');
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+const VERSION = packageJson.version;
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+
+  // Handle no arguments or help
+  if (args.length === 0 || args[0] === 'help' || args[0] === '--help' || args[0] === '-h') {
+    showHelp();
+    process.exit(EXIT_CODES.SUCCESS);
+  }
+
+  // Handle version
+  if (args[0] === '--version' || args[0] === '-v') {
+    console.log(`cn version ${VERSION}`);
+    process.exit(EXIT_CODES.SUCCESS);
+  }
+
+  const command = args[0];
+  const subArgs = args.slice(1);
+
+  // Check for verbose mode
+  const verbose = args.includes('--verbose');
+  if (verbose && process.env.CN_DEBUG !== '1') {
+    process.env.CN_DEBUG = '1';
+  }
+
+  try {
+    switch (command) {
+      case 'setup':
+        if (args.includes('--help')) {
+          showSetupHelp();
+          process.exit(EXIT_CODES.SUCCESS);
+        }
+        await setup();
+        break;
+
+      case 'clone': {
+        if (args.includes('--help')) {
+          showCloneHelp();
+          process.exit(EXIT_CODES.SUCCESS);
+        }
+
+        // Get space keys (all non-flag arguments after 'clone')
+        const spaceKeys = subArgs.filter((arg) => !arg.startsWith('--'));
+        if (spaceKeys.length === 0) {
+          console.error(chalk.red('At least one space key is required.'));
+          console.log(chalk.gray('Usage: cn clone <SPACE_KEY> [SPACE_KEY...]'));
+          process.exit(EXIT_CODES.INVALID_ARGUMENTS);
+        }
+
+        await cloneCommand({ spaceKeys });
+        break;
+      }
+
+      case 'pull': {
+        if (args.includes('--help')) {
+          showPullHelp();
+          process.exit(EXIT_CODES.SUCCESS);
+        }
+
+        const dryRun = args.includes('--dry-run');
+        const force = args.includes('--force');
+
+        let depth: number | undefined;
+        const depthIndex = args.indexOf('--depth');
+        if (depthIndex !== -1 && depthIndex + 1 < args.length) {
+          depth = Number.parseInt(args[depthIndex + 1], 10);
+        }
+
+        // Collect all --page arguments (can appear multiple times)
+        const pages: string[] = [];
+        for (let i = 0; i < args.length; i++) {
+          if (args[i] === '--page' && i + 1 < args.length) {
+            pages.push(args[i + 1]);
+          }
+        }
+
+        await pullCommand({ dryRun, force, depth, pages: pages.length > 0 ? pages : undefined });
+        break;
+      }
+
+      case 'push': {
+        if (args.includes('--help')) {
+          showPushHelp();
+          process.exit(EXIT_CODES.SUCCESS);
+        }
+
+        // File is optional - if not provided, scan for changes
+        const file = subArgs.find((arg) => !arg.startsWith('--'));
+
+        await pushCommand({
+          file,
+          force: args.includes('--force'),
+          dryRun: args.includes('--dry-run'),
+        });
+        break;
+      }
+
+      case 'status':
+        if (args.includes('--help')) {
+          showStatusHelp();
+          process.exit(EXIT_CODES.SUCCESS);
+        }
+        await statusCommand({ xml: args.includes('--xml') });
+        break;
+
+      case 'tree': {
+        if (args.includes('--help')) {
+          showTreeHelp();
+          process.exit(EXIT_CODES.SUCCESS);
+        }
+
+        // Find space key (first non-flag argument)
+        const spaceKey = subArgs.find((arg) => !arg.startsWith('--'));
+
+        let depth: number | undefined;
+        const depthIndex = args.indexOf('--depth');
+        if (depthIndex !== -1 && depthIndex + 1 < args.length) {
+          depth = Number.parseInt(args[depthIndex + 1], 10);
+        }
+
+        await treeCommand({
+          spaceKey,
+          remote: args.includes('--remote') || !args.includes('--local'),
+          depth,
+          xml: args.includes('--xml'),
+        });
+        break;
+      }
+
+      case 'open': {
+        if (args.includes('--help')) {
+          showOpenHelp();
+          process.exit(EXIT_CODES.SUCCESS);
+        }
+
+        // Find page argument (first non-flag argument)
+        const page = subArgs.find((arg) => !arg.startsWith('--'));
+
+        let spaceKey: string | undefined;
+        const spaceIndex = args.indexOf('--space');
+        if (spaceIndex !== -1 && spaceIndex + 1 < args.length) {
+          spaceKey = args[spaceIndex + 1];
+        }
+
+        await openCommand({ page, spaceKey });
+        break;
+      }
+
+      case 'doctor':
+        if (args.includes('--help')) {
+          showDoctorHelp();
+          process.exit(EXIT_CODES.SUCCESS);
+        }
+        await doctorCommand({
+          fix: args.includes('--fix'),
+          xml: args.includes('--xml'),
+        });
+        break;
+
+      case 'spaces':
+        if (args.includes('--help')) {
+          showSpacesHelp();
+          process.exit(EXIT_CODES.SUCCESS);
+        }
+        await spacesCommand({ xml: args.includes('--xml') });
+        break;
+
+      case 'search': {
+        if (args.includes('--help')) {
+          showSearchHelp();
+          process.exit(EXIT_CODES.SUCCESS);
+        }
+        let spaceKey: string | undefined;
+        const spaceIdx = args.indexOf('--space');
+        if (spaceIdx !== -1 && spaceIdx + 1 < args.length) {
+          spaceKey = args[spaceIdx + 1];
+        }
+        let limit: number | undefined;
+        const limitIdx = args.indexOf('--limit');
+        if (limitIdx !== -1 && limitIdx + 1 < args.length) {
+          limit = Number.parseInt(args[limitIdx + 1], 10);
+        }
+        const searchFlagValues = new Set(
+          [spaceKey, limit !== undefined ? args[limitIdx + 1] : undefined].filter(Boolean),
+        );
+        const query = subArgs.find((arg) => !arg.startsWith('--') && !searchFlagValues.has(arg));
+        if (!query) {
+          console.error(chalk.red('Search query is required.'));
+          console.log(chalk.gray('Usage: cn search <query>'));
+          process.exit(EXIT_CODES.INVALID_ARGUMENTS);
+        }
+        await searchCommand(query, { space: spaceKey, limit, xml: args.includes('--xml') });
+        break;
+      }
+
+      case 'info': {
+        if (args.includes('--help')) {
+          showInfoHelp();
+          process.exit(EXIT_CODES.SUCCESS);
+        }
+        const target = subArgs.find((arg) => !arg.startsWith('--'));
+        if (!target) {
+          console.error(chalk.red('Page ID or file path is required.'));
+          console.log(chalk.gray('Usage: cn info <id|file>'));
+          process.exit(EXIT_CODES.INVALID_ARGUMENTS);
+        }
+        await infoCommand(target, { xml: args.includes('--xml') });
+        break;
+      }
+
+      case 'create': {
+        if (args.includes('--help')) {
+          showCreateHelp();
+          process.exit(EXIT_CODES.SUCCESS);
+        }
+        let spaceKey: string | undefined;
+        const spaceIdx = args.indexOf('--space');
+        if (spaceIdx !== -1 && spaceIdx + 1 < args.length) {
+          spaceKey = args[spaceIdx + 1];
+        }
+        let parentId: string | undefined;
+        const parentIdx = args.indexOf('--parent');
+        if (parentIdx !== -1 && parentIdx + 1 < args.length) {
+          parentId = args[parentIdx + 1];
+        }
+        const createFlagValues = new Set([spaceKey, parentId].filter(Boolean));
+        const title = subArgs.find((arg) => !arg.startsWith('--') && !createFlagValues.has(arg));
+        if (!title) {
+          console.error(chalk.red('Page title is required.'));
+          console.log(chalk.gray('Usage: cn create <title>'));
+          process.exit(EXIT_CODES.INVALID_ARGUMENTS);
+        }
+        await createCommand(title, {
+          space: spaceKey,
+          parent: parentId,
+          open: args.includes('--open'),
+        });
+        break;
+      }
+
+      case 'delete': {
+        if (args.includes('--help')) {
+          showDeleteHelp();
+          process.exit(EXIT_CODES.SUCCESS);
+        }
+        const pageId = subArgs.find((arg) => !arg.startsWith('--'));
+        if (!pageId) {
+          console.error(chalk.red('Page ID is required.'));
+          console.log(chalk.gray('Usage: cn delete <id>'));
+          process.exit(EXIT_CODES.INVALID_ARGUMENTS);
+        }
+        await deleteCommand(pageId, { force: args.includes('--force') });
+        break;
+      }
+
+      case 'comments': {
+        if (args.includes('--help')) {
+          showCommentsHelp();
+          process.exit(EXIT_CODES.SUCCESS);
+        }
+        const target = subArgs.find((arg) => !arg.startsWith('--'));
+        if (!target) {
+          console.error(chalk.red('Page ID or file path is required.'));
+          console.log(chalk.gray('Usage: cn comments <id|file>'));
+          process.exit(EXIT_CODES.INVALID_ARGUMENTS);
+        }
+        await commentsCommand(target, { xml: args.includes('--xml') });
+        break;
+      }
+
+      case 'labels': {
+        if (args.includes('--help')) {
+          showLabelsHelp();
+          process.exit(EXIT_CODES.SUCCESS);
+        }
+        let addLabel: string | undefined;
+        const addIdx = args.indexOf('--add');
+        if (addIdx !== -1 && addIdx + 1 < args.length) {
+          addLabel = args[addIdx + 1];
+        }
+        let removeLabel: string | undefined;
+        const removeIdx = args.indexOf('--remove');
+        if (removeIdx !== -1 && removeIdx + 1 < args.length) {
+          removeLabel = args[removeIdx + 1];
+        }
+        const labelFlagValues = new Set([addLabel, removeLabel].filter(Boolean));
+        const labelsTarget = subArgs.find((arg) => !arg.startsWith('--') && !labelFlagValues.has(arg));
+        if (!labelsTarget) {
+          console.error(chalk.red('Page ID or file path is required.'));
+          console.log(chalk.gray('Usage: cn labels <id|file>'));
+          process.exit(EXIT_CODES.INVALID_ARGUMENTS);
+        }
+        await labelsCommand(labelsTarget, { add: addLabel, remove: removeLabel, xml: args.includes('--xml') });
+        break;
+      }
+
+      case 'move': {
+        if (args.includes('--help')) {
+          showMoveHelp();
+          process.exit(EXIT_CODES.SUCCESS);
+        }
+        const nonFlags = subArgs.filter((arg) => !arg.startsWith('--'));
+        if (nonFlags.length < 2) {
+          console.error(chalk.red('Page target and parent ID are required.'));
+          console.log(chalk.gray('Usage: cn move <id|file> <parentId>'));
+          process.exit(EXIT_CODES.INVALID_ARGUMENTS);
+        }
+        await moveCommand(nonFlags[0], nonFlags[1]);
+        break;
+      }
+
+      case 'attachments': {
+        if (args.includes('--help')) {
+          showAttachmentsHelp();
+          process.exit(EXIT_CODES.SUCCESS);
+        }
+        let uploadFile: string | undefined;
+        const uploadIdx = args.indexOf('--upload');
+        if (uploadIdx !== -1 && uploadIdx + 1 < args.length) {
+          uploadFile = args[uploadIdx + 1];
+        }
+        let downloadId: string | undefined;
+        const downloadIdx = args.indexOf('--download');
+        if (downloadIdx !== -1 && downloadIdx + 1 < args.length) {
+          downloadId = args[downloadIdx + 1];
+        }
+        let deleteId: string | undefined;
+        const deleteIdx = args.indexOf('--delete');
+        if (deleteIdx !== -1 && deleteIdx + 1 < args.length) {
+          deleteId = args[deleteIdx + 1];
+        }
+        const attachFlagValues = new Set([uploadFile, downloadId, deleteId].filter(Boolean));
+        const attachTarget = subArgs.find((arg) => !arg.startsWith('--') && !attachFlagValues.has(arg));
+        if (!attachTarget) {
+          console.error(chalk.red('Page ID or file path is required.'));
+          console.log(chalk.gray('Usage: cn attachments <id|file>'));
+          process.exit(EXIT_CODES.INVALID_ARGUMENTS);
+        }
+        await attachmentsCommand(attachTarget, {
+          upload: uploadFile,
+          download: downloadId,
+          delete: deleteId,
+          xml: args.includes('--xml'),
+        });
+        break;
+      }
+
+      default:
+        console.error(`Unknown command: ${command}`);
+        console.log('Run "cn help" for usage information');
+        process.exit(EXIT_CODES.INVALID_ARGUMENTS);
+    }
+  } catch (error) {
+    console.error('Error:', error instanceof Error ? error.message : 'Unknown error');
+    process.exit(EXIT_CODES.GENERAL_ERROR);
+  }
+}
+
+// Run the CLI
+main().catch((error) => {
+  console.error('Fatal error:', error);
+  process.exit(EXIT_CODES.GENERAL_ERROR);
+});

package/src/cli/utils/browser.ts

@@ -0,0 +1,34 @@
+import { spawn } from 'node:child_process';
+import { platform } from 'node:os';
+import chalk from 'chalk';
+
+/**
+ * Open a URL in the default browser.
+ * Uses spawn with arguments array to prevent command injection.
+ */
+export function openUrl(url: string): void {
+  const os = platform();
+  let command: string;
+  let args: string[];
+
+  switch (os) {
+    case 'darwin':
+      command = 'open';
+      args = [url];
+      break;
+    case 'win32':
+      command = 'cmd';
+      args = ['/c', 'start', '', url];
+      break;
+    default:
+      command = 'xdg-open';
+      args = [url];
+  }
+
+  const child = spawn(command, args, { stdio: 'ignore', detached: true });
+  child.on('error', (error) => {
+    console.error(chalk.red(`Failed to open browser: ${error.message}`));
+    console.log(chalk.gray(`URL: ${url}`));
+  });
+  child.unref();
+}

package/src/cli/utils/progress-reporter.ts

@@ -0,0 +1,49 @@
+import chalk from 'chalk';
+import ora, { type Ora } from 'ora';
+import type { SyncProgressReporter } from '../../lib/sync/index.js';
+
+/**
+ * Create a progress reporter for sync operations (pull/clone)
+ */
+export function createProgressReporter(): SyncProgressReporter {
+  let spinner: Ora | undefined;
+
+  return {
+    onFetchStart: () => {
+      spinner = ora({
+        text: 'Fetching pages from Confluence...',
+        hideCursor: false,
+        discardStdin: false,
+      }).start();
+    },
+    onFetchComplete: (pageCount, folderCount) => {
+      const folderText = folderCount > 0 ? ` and ${folderCount} folders` : '';
+      spinner?.succeed(`Found ${pageCount} pages${folderText}`);
+      spinner = undefined;
+    },
+    onDiffComplete: (added, modified, deleted) => {
+      const total = added + modified + deleted;
+      if (total === 0) {
+        console.log(chalk.green('  Already up to date'));
+      } else {
+        const parts = [];
+        if (added > 0) parts.push(chalk.green(`${added} new`));
+        if (modified > 0) parts.push(chalk.yellow(`${modified} modified`));
+        if (deleted > 0) parts.push(chalk.red(`${deleted} deleted`));
+        console.log(`  ${parts.join(', ')}`);
+        console.log('');
+      }
+    },
+    onPageStart: (_index, _total, _title, _type) => {
+      // No-op - we show progress on complete only
+    },
+    onPageComplete: (index, total, _title, localPath) => {
+      const icon = localPath ? chalk.green('✓') : chalk.red('×');
+      const progress = chalk.gray(`(${index}/${total})`);
+      console.log(`  ${icon} ${progress} ${localPath || 'deleted'}`);
+    },
+    onPageError: (title, error) => {
+      console.log(`  ${chalk.red('✗')} ${title}: ${error}`);
+    },
+  };
+}

package/src/cli.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env bun
+/**
+ * Main CLI entry point - imports from the modular command structure
+ * All commands have been extracted to src/cli/commands/
+ */
+import './cli/index.js';

package/src/lib/config.ts

@@ -0,0 +1,156 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { Effect, pipe, Schema } from 'effect';
+import { ConfigError, FileSystemError, ParseError, ValidationError } from './errors.js';
+
+/**
+ * Schema for Confluence Cloud URL validation
+ * Only accepts https://*.atlassian.net URLs per ADR-0012
+ */
+const ConfluenceUrlSchema = Schema.String.pipe(
+  Schema.pattern(/^https:\/\/.+\.atlassian\.net$/),
+  Schema.annotations({
+    message: () => 'URL must be a Confluence Cloud URL (https://*.atlassian.net)',
+  }),
+);
+
+/**
+ * Schema for email validation
+ */
+const EmailSchema = Schema.String.pipe(
+  Schema.pattern(/^[^\s@]+@[^\s@]+\.[^\s@]+$/),
+  Schema.annotations({
+    message: () => 'Invalid email format',
+  }),
+);
+
+/**
+ * Configuration schema for cn CLI
+ */
+const ConfigSchema = Schema.Struct({
+  confluenceUrl: ConfluenceUrlSchema,
+  email: EmailSchema,
+  apiToken: Schema.String.pipe(Schema.minLength(1)),
+});
+
+export type Config = Schema.Schema.Type<typeof ConfigSchema>;
+
+/**
+ * ConfigManager handles reading and writing the cn CLI configuration
+ * Configuration is stored in ~/.cn/config.json with 600 permissions
+ */
+export class ConfigManager {
+  private configDir: string;
+  private configFile: string;
+
+  constructor() {
+    this.configDir = process.env.CN_CONFIG_PATH ? process.env.CN_CONFIG_PATH : join(homedir(), '.cn');
+    this.configFile = join(this.configDir, 'config.json');
+
+    if (!existsSync(this.configDir)) {
+      mkdirSync(this.configDir, { recursive: true });
+    }
+  }
+
+  /**
+   * Get the path to the config file
+   */
+  getConfigPath(): string {
+    return this.configFile;
+  }
+
+  /**
+   * Check if configuration exists
+   */
+  hasConfig(): boolean {
+    return existsSync(this.configFile);
+  }
+
+  /**
+   * Effect-based configuration retrieval with detailed error handling
+   */
+  getConfigEffect(): Effect.Effect<Config, ConfigError | FileSystemError | ParseError | ValidationError> {
+    return pipe(
+      Effect.sync(() => existsSync(this.configFile)),
+      Effect.flatMap(
+        (fileExists): Effect.Effect<Config, ConfigError | FileSystemError | ParseError | ValidationError> => {
+          if (fileExists) {
+            return pipe(
+              Effect.try(() => readFileSync(this.configFile, 'utf-8')),
+              Effect.mapError((error) => new FileSystemError(`Failed to read config file: ${error}`)),
+              Effect.flatMap((configData) =>
+                Effect.try(() => JSON.parse(configData)).pipe(
+                  Effect.mapError((error) => new ParseError(`Invalid JSON in config file: ${error}`)),
+                ),
+              ),
+              Effect.flatMap((config) =>
+                Schema.decodeUnknown(ConfigSchema)(config).pipe(
+                  Effect.mapError((error) => new ValidationError(`Invalid config schema: ${error}`)),
+                ),
+              ),
+            ) as Effect.Effect<Config, ConfigError | FileSystemError | ParseError | ValidationError>;
+          }
+
+          return Effect.fail(new ConfigError('No configuration found. Please run "cn setup" first.'));
+        },
+      ),
+    );
+  }
+
+  /**
+   * Async wrapper for getConfigEffect
+   */
+  async getConfig(): Promise<Config | null> {
+    if (existsSync(this.configFile)) {
+      try {
+        const configData = readFileSync(this.configFile, 'utf-8');
+        const config = JSON.parse(configData);
+        return Schema.decodeUnknownSync(ConfigSchema)(config);
+      } catch {
+        // Invalid config file - return null to indicate no valid config
+        return null;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Effect-based configuration update
+   */
+  setConfigEffect(config: Config): Effect.Effect<void, ValidationError | FileSystemError> {
+    return pipe(
+      Schema.decodeUnknown(ConfigSchema)(config),
+      Effect.mapError((error) => new ValidationError(`Invalid config: ${error}`)),
+      Effect.flatMap((validated) =>
+        Effect.try(() => {
+          writeFileSync(this.configFile, JSON.stringify(validated, null, 2), 'utf-8');
+          chmodSync(this.configFile, 0o600);
+        }).pipe(Effect.mapError((error) => new FileSystemError(`Failed to save config: ${error}`))),
+      ),
+    );
+  }
+
+  /**
+   * Async wrapper for setConfigEffect
+   */
+  async setConfig(config: Config): Promise<void> {
+    const validated = Schema.decodeUnknownSync(ConfigSchema)(config);
+    writeFileSync(this.configFile, JSON.stringify(validated, null, 2), 'utf-8');
+    chmodSync(this.configFile, 0o600);
+  }
+
+  /**
+   * Validate a Confluence URL
+   */
+  static validateUrl(url: string): boolean {
+    return /^https:\/\/.+\.atlassian\.net$/.test(url);
+  }
+
+  /**
+   * Validate an email address
+   */
+  static validateEmail(email: string): boolean {
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
+  }
+}