open-notepad 1.0.0

package/bin/note.js

@@ -0,0 +1,565 @@
+#!/usr/bin/env node
+
+import fs from 'fs/promises';
+import { existsSync } from 'fs';
+import path from 'path';
+import os from 'os';
+import { spawn } from 'child_process';
+import readline from 'readline';
+import { Writable } from 'stream';
+
+const CONFIG_PATH = path.join(os.homedir(), '.notepad-cli.json');
+
+// Color helpers
+const colors = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  blue: '\x1b[94m',
+  green: '\x1b[92m',
+  yellow: '\x1b[93m',
+  cyan: '\x1b[96m',
+  red: '\x1b[91m',
+  bgBlue: '\x1b[44m',
+  white: '\x1b[97m'
+};
+
+// Console formatting utils
+function log(msg) { console.log(msg); }
+function error(msg) { console.error(`${colors.bold}${colors.red}Error:${colors.reset} ${msg}`); }
+function success(msg) { log(`${colors.bold}${colors.green}Success:${colors.reset} ${msg}`); }
+function warning(msg) { log(`${colors.bold}${colors.yellow}Warning:${colors.reset} ${msg}`); }
+function info(msg) { log(`${colors.cyan}i${colors.reset} ${msg}`); }
+
+function clearScreen() {
+  process.stdout.write('\x1B[2J\x1B[3J\x1B[H');
+}
+
+// Readline prompt helpers
+function ask(query, defaultValue = '') {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const suffix = defaultValue ? ` (${colors.dim}${defaultValue}${colors.reset})` : '';
+  return new Promise((resolve) => {
+    rl.question(`${colors.bold}${query}${suffix}: ${colors.reset}`, (answer) => {
+      rl.close();
+      resolve(answer.trim() || defaultValue);
+    });
+  });
+}
+
+function askPassword(query) {
+  return new Promise((resolve) => {
+    const mutableStdout = new Writable({
+      write: function (chunk, encoding, callback) {
+        if (!this.muted) {
+          process.stdout.write(chunk, encoding);
+        }
+        callback();
+      }
+    });
+    mutableStdout.muted = false;
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: mutableStdout,
+      terminal: true
+    });
+    process.stdout.write(`${colors.bold}${query}: ${colors.reset}`);
+    mutableStdout.muted = true;
+    rl.question('', (value) => {
+      rl.close();
+      process.stdout.write('\n');
+      resolve(value);
+    });
+  });
+}
+
+// Config management
+async function loadConfig() {
+  if (existsSync(CONFIG_PATH)) {
+    try {
+      const data = await fs.readFile(CONFIG_PATH, 'utf-8');
+      return JSON.parse(data);
+    } catch (e) {
+      error(`Failed to parse configuration: ${e.message}`);
+    }
+  }
+  return {
+    apiUrl: 'https://api-yuulabs-v1.notepad.web.id',
+    roomId: '',
+    apiKey: ''
+  };
+}
+
+async function saveConfig(config) {
+  try {
+    await fs.writeFile(CONFIG_PATH, JSON.stringify(config, null, 2), 'utf-8');
+    success(`Configuration saved to ${CONFIG_PATH}`);
+  } catch (e) {
+    error(`Failed to save configuration: ${e.message}`);
+  }
+}
+
+// HTTP request wrappers
+async function apiFetch(config, endpoint, options = {}) {
+  const url = `${config.apiUrl.replace(/\/$/, '')}${endpoint}`;
+
+  const headers = {
+    'Content-Type': 'application/json',
+    ...options.headers
+  };
+
+  if (config.apiKey && !options.skipApiKey) {
+    headers['x-api-key'] = config.apiKey;
+    headers['Authorization'] = `Bearer ${config.apiKey}`;
+  }
+
+  try {
+    const res = await fetch(url, {
+      ...options,
+      headers
+    });
+
+    return res;
+  } catch (e) {
+    throw new Error(`Connection failed. Check your API URL (${config.apiUrl}). Error: ${e.message}`);
+  }
+}
+
+// Commands
+async function handleLogin() {
+  clearScreen();
+  log(`${colors.bgBlue}${colors.white}${colors.bold}   Configure Notepad CLI   ${colors.reset}\n`);
+
+  const current = await loadConfig();
+
+  const apiUrl = await ask('Enter Server API URL', current.apiUrl);
+  const roomId = await ask('Enter Subdomain/Room ID (e.g. "saya")', current.roomId);
+  const apiKey = await ask('Enter Room API Token/Key', current.apiKey);
+
+  await saveConfig({ apiUrl, roomId, apiKey });
+}
+
+async function handleList() {
+  const config = await loadConfig();
+  if (!config.roomId) {
+    warning('Not configured. Please run `note login` first.');
+    return;
+  }
+
+  info(`Fetching notes for room ${colors.bold}${config.roomId}${colors.reset}...`);
+  try {
+    const res = await apiFetch(config, `/api/rooms/${config.roomId}/notes`);
+    if (res.status === 403) {
+      error('Access Denied. Check your API key.');
+      return;
+    }
+    if (!res.ok) {
+      error(`API returned error code ${res.status}`);
+      return;
+    }
+
+    const notes = await res.json();
+    clearScreen();
+    log(`${colors.blue}${colors.bold}Notes in /${config.roomId}:${colors.reset}`);
+    log(`${colors.dim}------------------------------------------------------------${colors.reset}`);
+
+    if (notes.length === 0) {
+      log('No notes found in this room room.');
+    } else {
+      for (const note of notes) {
+        const vis = note.is_public ? `${colors.green}Public${colors.reset}` : `${colors.red}Private${colors.reset}`;
+        const prot = note.has_password ? `${colors.yellow}Locked${colors.reset}` : 'Open';
+        const date = new Date(note.updated_at).toLocaleString();
+        log(` 📄 ${colors.bold}${colors.cyan}${note.code.padEnd(20)}${colors.reset} [${vis}] [${prot.padEnd(6)}] ${colors.dim}${date}${colors.reset}`);
+      }
+    }
+    log(`${colors.dim}------------------------------------------------------------${colors.reset}`);
+  } catch (e) {
+    error(e.message);
+  }
+}
+
+async function handleView(codeArg) {
+  const config = await loadConfig();
+  if (!config.roomId) {
+    warning('Not configured. Please run `note login` first.');
+    return;
+  }
+
+  const code = codeArg || await ask('Enter note code to view');
+  if (!code) return;
+
+  info(`Loading note ${colors.bold}/${config.roomId}/${code}${colors.reset}...`);
+
+  try {
+    // Attempt standard fetch with API key
+    let res = await apiFetch(config, `/api/notes/room/${config.roomId}/${code}`);
+
+    if (res.status === 404) {
+      error(`Note "${code}" not found.`);
+      return;
+    }
+
+    let noteData = await res.json();
+
+    // Check if the note needs a password
+    if (noteData.has_password && (!noteData.content || res.status === 403)) {
+      const pwd = await askPassword('Enter note password');
+
+      // Note: We bypass API Key header if providing note password for private notes
+      // because backend rejects (is_api = true && private_note = true) outright.
+      res = await apiFetch(config, `/api/notes/room/${config.roomId}/${code}`, {
+        headers: { 'x-note-password': pwd },
+        skipApiKey: true
+      });
+
+      if (!res.ok) {
+        error('Invalid note password or unauthorized access.');
+        return;
+      }
+      noteData = await res.json();
+    }
+
+    if (res.status === 403) {
+      error('Access Denied: Private note requires correct password.');
+      return;
+    }
+
+    clearScreen();
+    log(`${colors.bold}${colors.blue}Note: /${config.roomId}/${code}${colors.reset}`);
+    log(`${colors.dim}------------------------------------------------------------${colors.reset}`);
+    log(noteData.content || `${colors.dim}(Empty note)${colors.reset}`);
+    log(`${colors.dim}------------------------------------------------------------${colors.reset}`);
+  } catch (e) {
+    error(e.message);
+  }
+}
+
+async function handleCreate(codeArg) {
+  const config = await loadConfig();
+  if (!config.roomId) {
+    warning('Not configured. Please run `note login` first.');
+    return;
+  }
+
+  const code = codeArg || await ask('Enter new note code');
+  if (!code) return;
+
+  const isPublicStr = await ask('Make note public? (y/n)', 'y');
+  const isPublic = isPublicStr.toLowerCase().startsWith('y');
+
+  let password = '';
+  if (!isPublic) {
+    password = await askPassword('Set password lock (required for private notes)');
+    if (!password) {
+      error('Password is required for private notes.');
+      return;
+    }
+  } else {
+    const setPass = await ask('Set optional password lock? (y/n)', 'n');
+    if (setPass.toLowerCase().startsWith('y')) {
+      password = await askPassword('Enter note password');
+    }
+  }
+
+  info(`Creating note ${colors.bold}/${config.roomId}/${code}${colors.reset}...`);
+
+  try {
+    // 1. Create/Save note with empty content (must send API key)
+    let saveRes = await apiFetch(config, `/api/notes/room/${config.roomId}/${code}`, {
+      method: 'POST',
+      body: JSON.stringify({ content: '' })
+    });
+
+    if (!saveRes.ok) {
+      error(`Failed to create note (status: ${saveRes.status})`);
+      return;
+    }
+
+    // 2. Set visibility and password (calls settings endpoint)
+    const settingsRes = await apiFetch(config, `/api/notes/room/${config.roomId}/${code}/settings`, {
+      method: 'POST',
+      body: JSON.stringify({
+        is_public: isPublic,
+        password: password || ""
+      })
+    });
+
+    if (!settingsRes.ok) {
+      error(`Failed to set note settings (status: ${settingsRes.status})`);
+      return;
+    }
+
+    success(`Note "${code}" created successfully!`);
+
+    const editNow = await ask('Open editor to write content now? (y/n)', 'y');
+    if (editNow.toLowerCase().startsWith('y')) {
+      await handleEdit(code);
+    }
+  } catch (e) {
+    error(e.message);
+  }
+}
+
+async function handleEdit(codeArg) {
+  const config = await loadConfig();
+  if (!config.roomId) {
+    warning('Not configured. Please run `note login` first.');
+    return;
+  }
+
+  const code = codeArg || await ask('Enter note code to edit');
+  if (!code) return;
+
+  info(`Fetching current content of /${config.roomId}/${code}...`);
+
+  try {
+    let notePassword = '';
+    let res = await apiFetch(config, `/api/notes/room/${config.roomId}/${code}`);
+
+    // If it doesn't exist, offer to create it
+    if (res.status === 404) {
+      const create = await ask('Note does not exist. Create it? (y/n)', 'y');
+      if (create.toLowerCase().startsWith('y')) {
+        await handleCreate(code);
+      }
+      return;
+    }
+
+    let noteData = await res.json();
+
+    // If locked, request password
+    if (noteData.has_password && (!noteData.content || res.status === 403)) {
+      notePassword = await askPassword('Enter note password to edit');
+
+      res = await apiFetch(config, `/api/notes/room/${config.roomId}/${code}`, {
+        headers: { 'x-note-password': notePassword },
+        skipApiKey: true
+      });
+
+      if (!res.ok) {
+        error('Invalid note password or unauthorized access.');
+        return;
+      }
+      noteData = await res.json();
+    }
+
+    if (res.status === 403) {
+      error('Access Denied: Private note requires correct password.');
+      return;
+    }
+
+    const initialContent = noteData.content || '';
+
+    // Create temp file
+    const tempDir = os.tmpdir();
+    const tempFilePath = path.join(tempDir, `note_${config.roomId}_${code}.txt`);
+    await fs.writeFile(tempFilePath, initialContent, 'utf-8');
+
+    // Open editor
+    const editor = process.env.EDITOR || (process.platform === 'win32' ? 'notepad' : 'nano');
+    info(`Opening editor: ${colors.bold}${editor}${colors.reset} with note content...`);
+
+    const child = spawn(editor, [tempFilePath], { stdio: 'inherit', shell: true });
+
+    child.on('exit', async (exitCode) => {
+      try {
+        const updatedContent = await fs.readFile(tempFilePath, 'utf-8');
+
+        // Cleanup temp file
+        await fs.unlink(tempFilePath).catch(() => { });
+
+        if (updatedContent === initialContent) {
+          info('No changes made. Note not saved.');
+          return;
+        }
+
+        info('Saving changes back to server...');
+
+        // Save note
+        const saveRes = await apiFetch(config, `/api/notes/room/${config.roomId}/${code}`, {
+          method: 'POST',
+          headers: notePassword ? { 'x-note-password': notePassword } : {},
+          skipApiKey: !!notePassword, // Skip API key header if note password is used
+          body: JSON.stringify({ content: updatedContent })
+        });
+
+        if (saveRes.ok) {
+          success(`Saved /${config.roomId}/${code} successfully!`);
+        } else {
+          error(`Failed to save changes. Server returned status: ${saveRes.status}`);
+        }
+      } catch (e) {
+        error(`Failed to save: ${e.message}`);
+      }
+    });
+  } catch (e) {
+    error(e.message);
+  }
+}
+
+async function handleDelete(codeArg) {
+  const config = await loadConfig();
+  if (!config.roomId) {
+    warning('Not configured. Please run `note login` first.');
+    return;
+  }
+
+  const code = codeArg || await ask('Enter note code to delete');
+  if (!code) return;
+
+  const confirm = await ask(`Are you sure you want to delete /${config.roomId}/${code}? (y/n)`, 'n');
+  if (!confirm.toLowerCase().startsWith('y')) {
+    info('Delete canceled.');
+    return;
+  }
+
+  info(`Deleting note /${config.roomId}/${code}...`);
+  try {
+    const res = await apiFetch(config, `/api/rooms/${config.roomId}/notes/${code}`, {
+      method: 'DELETE'
+    });
+
+    if (res.ok) {
+      success(`Note "${code}" deleted successfully.`);
+    } else {
+      error(`Failed to delete note. Status: ${res.status}`);
+    }
+  } catch (e) {
+    error(e.message);
+  }
+}
+
+function handleHelp() {
+  log(`
+${colors.bold}${colors.cyan}Notepad CLI Help${colors.reset}
+  Command: ${colors.bold}note${colors.reset}
+
+${colors.bold}Commands:${colors.reset}
+  ${colors.bold}note login${colors.reset}           Interactive setup config (Server URL, Room ID, API Token)
+  ${colors.bold}note list${colors.reset}            List all notes in your room
+  ${colors.bold}note view [code]${colors.reset}     View content of a note (prompts for password if locked)
+  ${colors.bold}note create [code]${colors.reset}   Create a new note with custom visibility and password
+  ${colors.bold}note edit [code]${colors.reset}     Edit a note interactively in your favorite editor
+  ${colors.bold}note delete [code]${colors.reset}   Delete a note
+  ${colors.bold}note config${colors.reset}           Show current configurations
+  ${colors.bold}note help${colors.reset}             Show this help screen
+  
+  If run without commands, opens a fully interactive menu.
+`);
+}
+
+async function handleConfig() {
+  const config = await loadConfig();
+  log(`
+${colors.bold}${colors.blue}Current Notepad Config:${colors.reset}
+  ${colors.bold}Server API URL:${colors.reset} ${config.apiUrl}
+  ${colors.bold}Room ID:       ${colors.reset} ${config.roomId || colors.dim + '(Not set)' + colors.reset}
+  ${colors.bold}API Token:     ${colors.reset} ${config.apiKey ? config.apiKey.slice(0, 10) + '...' : colors.dim + '(Not set)' + colors.reset}
+`);
+}
+
+// Interactive Dashboard Menu (If no arguments)
+async function startMainMenu() {
+  while (true) {
+    clearScreen();
+    log(`${colors.bgBlue}${colors.white}${colors.bold}          Notepad CLI Menu          ${colors.reset}`);
+    const config = await loadConfig();
+    log(`${colors.dim}Namespace: ${colors.reset}${config.roomId ? colors.green + config.roomId : colors.red + '(Not logged in)'}${colors.reset}\n`);
+
+    log(`${colors.cyan}1. 📁 List all notes${colors.reset}`);
+    log(`${colors.cyan}2. 📖 View a note${colors.reset}`);
+    log(`${colors.cyan}3. ✍️ Create a new note${colors.reset}`);
+    log(`${colors.cyan}4. ✏️ Edit an existing note${colors.reset}`);
+    log(`${colors.cyan}5. ❌ Delete a note${colors.reset}`);
+    log(`${colors.cyan}6. 🔑 Configure / Login${colors.reset}`);
+    log(`${colors.cyan}7. 🚪 Exit${colors.reset}\n`);
+
+    const choice = await ask('Select option (1-7)');
+
+    switch (choice) {
+      case '1':
+        await handleList();
+        await ask('Press Enter to return to menu');
+        break;
+      case '2':
+        await handleView();
+        await ask('Press Enter to return to menu');
+        break;
+      case '3':
+        await handleCreate();
+        await ask('Press Enter to return to menu');
+        break;
+      case '4':
+        await handleEdit();
+        await ask('Press Enter to return to menu');
+        break;
+      case '5':
+        await handleDelete();
+        await ask('Press Enter to return to menu');
+        break;
+      case '6':
+        await handleLogin();
+        await ask('Press Enter to return to menu');
+        break;
+      case '7':
+        clearScreen();
+        log('Goodbye!');
+        process.exit(0);
+      default:
+        warning('Invalid option. Please choose 1-7.');
+        await new Promise(r => setTimeout(r, 1200));
+    }
+  }
+}
+
+// CLI Entrypoint Router
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0]?.toLowerCase();
+  const subArg = args[1];
+
+  if (!command) {
+    await startMainMenu();
+  } else {
+    switch (command) {
+      case 'login':
+        await handleLogin();
+        break;
+      case 'list':
+        await handleList();
+        break;
+      case 'view':
+        await handleView(subArg);
+        break;
+      case 'create':
+        await handleCreate(subArg);
+        break;
+      case 'edit':
+        await handleEdit(subArg);
+        break;
+      case 'delete':
+        await handleDelete(subArg);
+        break;
+      case 'config':
+        await handleConfig();
+        break;
+      case 'help':
+      case '-h':
+      case '--help':
+        handleHelp();
+        break;
+      default:
+        error(`Unknown command: "${command}". Run \`note help\` for usage.`);
+        process.exit(1);
+    }
+  }
+}
+
+main().catch(e => {
+  error(`Unhandled exception: ${e.message}`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "open-notepad",
+  "version": "1.0.0",
+  "description": "CLI tool for notepad.web.id to access, edit, create, and list room notes interactively.",
+  "type": "module",
+  "bin": {
+    "note": "./bin/note.js"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "note",
+    "notepad",
+    "cli",
+    "interactive"
+  ],
+  "author": "",
+  "license": "ISC"
+}