"arboard",

 "clap",

 "crossterm",

 "open",

 "ratatui",

 "reqwest 0.13.2",

 "rpassword",

 "syntect",

 "toml",

# Optional. When set, enables the JSON API at /api/notes gated by x-api-key header.

# Leave unset to disable the API (returns 403).

JOTTS_API_KEY=

ratatui = "0.30"

crossterm = "0.29"

arboard = "3"

syntect = "5"

reqwest = { version = "0.13", features = ["json", "blocking"] }

clap = { version = "4", features = ["derive", "env"] }

toml = "1.0"

rpassword = "7"

open = "5.3.3"

[[bin]]

name = "jotts"

path = "src/main.rs"

| `JOTTS_API_KEY` | API key for `/api/notes` JSON endpoints (unset = API disabled) | _(unset)_ |

## CLI / TUI

The `jotts` binary also ships an interactive terminal UI and a minimal CLI.

```bash

jotts               # Launch TUI (local SQLite by default, remote if configured)

jotts server        # Run the web server

jotts tui           # Launch TUI explicitly

jotts auth          # Prompt for remote URL + API key, save to ~/.config/jotts/config.toml

```

Flags: `--remote <URL>` (env `JOTTS_REMOTE_URL`), `--api-key <KEY>` (env `JOTTS_API_KEY`).

Against a remote server, set `JOTTS_API_KEY` on the server and pass the same key from the CLI. Requests go to `/api/notes` with the `x-api-key` header. The TUI renders note content with syntect Markdown syntax highlighting.

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">

<plist version="1.0">

    <dict>

        <!--

        The colors in this theme are encoded as #RRGGBBAA where:

        * If AA is 00, then RR is an ANSI palette number from 00 to 07.

        * If AA is 01, the terminal's default fg/bg color is used.

        -->

        <key>author</key>

        <string>Template: Chris Kempson, Scheme: Mitchell Kember</string>

        <key>name</key>

        <string>ANSI</string>

        <key>colorSpaceName</key>

        <string>sRGB</string>

        <key>settings</key>

        <array>

            <dict>

                <key>settings</key>

                <dict>

                    <key>background</key>

                    <string>#00000001</string>

                    <key>foreground</key>

                    <string>#00000001</string>

                    <!--

                    Explicitly set the gutter color since bat falls back to a

                    hardcoded DEFAULT_GUTTER_COLOR otherwise.

                    -->

                    <key>gutter</key>

                    <string>#00000001</string>

                    <key>gutterForeground</key>

                    <string>#00000001</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Comments</string>

                <key>scope</key>

                <string>comment, punctuation.definition.comment</string>

                <key>settings</key>

                <dict>

                    <key>foreground</key>

                    <string>#02000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Keywords</string>

                <key>scope</key>

                <string>keyword</string>

                <key>settings</key>

                <dict>

                    <key>foreground</key>

                    <string>#05000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Functions</string>

                <key>scope</key>

                <string>entity.name.function, meta.require, support.function.any-method</string>

                <key>settings</key>

                <dict>

                    <key>foreground</key>

                    <string>#04000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Labels</string>

                <key>scope</key>

                <string>entity.name.label, variable.parameter</string>

                <key>settings</key>

                <dict>

                    <key>foreground</key>

                    <string>#06000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Classes</string>

                <key>scope</key>

                <string>support.class, entity.name.class, entity.name.type.class, entity.name</string>

                <key>settings</key>

                <dict>

                    <key>foreground</key>

                    <string>#03000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Methods</string>

                <key>scope</key>

                <string>keyword.other.special-method</string>

                <key>settings</key>

                <dict>

                    <key>foreground</key>

                    <string>#04000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Storage</string>

                <key>scope</key>

                <string>storage</string>

                <key>settings</key>

                <dict>

                    <key>foreground</key>

                    <string>#05000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Support</string>

                <key>scope</key>

                <string>support.function</string>

                <key>settings</key>

                <dict>

                    <key>foreground</key>

                    <string>#06000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Strings, Inherited Class</string>

                <key>scope</key>

                <string>string, constant.other.symbol, entity.other.inherited-class</string>

                <key>settings</key>

                <dict>

                    <key>foreground</key>

                    <string>#02000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Integers</string>

                <key>scope</key>

                <string>constant.numeric</string>

                <key>settings</key>

                <dict>

                    <key>foreground</key>

                    <string>#03000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Floats</string>

                <key>scope</key>

                <string>none</string>

                <key>settings</key>

                <dict>

                    <key>foreground</key>

                    <string>#03000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Boolean</string>

                <key>scope</key>

                <string>none</string>

                <key>settings</key>

                <dict>

                    <key>foreground</key>

                    <string>#03000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Constants</string>

                <key>scope</key>

                <string>constant</string>

                <key>settings</key>

                <dict>

                    <key>foreground</key>

                    <string>#03000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Tags</string>

                <key>scope</key>

                <string>entity.name.tag</string>

                <key>settings</key>

                <dict>

                    <key>foreground</key>

                    <string>#01000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Attributes</string>

                <key>scope</key>

                <string>entity.other.attribute-name</string>

                <key>settings</key>

                <dict>

                    <key>foreground</key>

                    <string>#03000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Attribute IDs</string>

                <key>scope</key>

                <string>entity.other.attribute-name.id, punctuation.definition.entity</string>

                <key>settings</key>

                <dict>

                    <key>foreground</key>

                    <string>#04000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Selector</string>

                <key>scope</key>

                <string>meta.selector</string>

                <key>settings</key>

                <dict>

                    <key>foreground</key>

                    <string>#05000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Values</string>

                <key>scope</key>

                <string>none</string>

                <key>settings</key>

                <dict>

                    <key>foreground</key>

                    <string>#03000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Headings</string>

                <key>scope</key>

                <string>markup.heading punctuation.definition.heading, entity.name.section, markup.heading - text.html.markdown, meta.mapping.key string.quoted.double</string>

                <key>settings</key>

                <dict>

                    <key>fontStyle</key>

                    <string></string>

                    <key>foreground</key>

                    <string>#04000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Units</string>

                <key>scope</key>

                <string>keyword.other.unit</string>

                <key>settings</key>

                <dict>

                    <key>foreground</key>

                    <string>#03000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Bold</string>

                <key>scope</key>

                <string>markup.bold, punctuation.definition.bold</string>

                <key>settings</key>

                <dict>

                    <key>fontStyle</key>

                    <string>bold</string>

                    <key>foreground</key>

                    <string>#03000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Italic</string>

                <key>scope</key>

                <string>markup.italic, punctuation.definition.italic</string>

                <key>settings</key>

                <dict>

                    <key>fontStyle</key>

                    <string>italic</string>

                    <key>foreground</key>

                    <string>#05000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Code</string>

                <key>scope</key>

                <string>markup.raw.inline</string>

                <key>settings</key>

                <dict>

                    <key>foreground</key>

                    <string>#02000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Link Text</string>

                <key>scope</key>

                <string>string.other.link, punctuation.definition.string.end.markdown, punctuation.definition.string.begin.markdown</string>

                <key>settings</key>

                <dict>

                    <key>foreground</key>

                    <string>#01000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Link Url</string>

                <key>scope</key>

                <string>meta.link</string>

                <key>settings</key>

                <dict>

                    <key>foreground</key>

                    <string>#03000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Quotes</string>

                <key>scope</key>

                <string>markup.quote</string>

                <key>settings</key>

                <dict>

                    <key>foreground</key>

                    <string>#03000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Inserted</string>

                <key>scope</key>

                <string>markup.inserted</string>

                <key>settings</key>

                <dict>

                    <key>foreground</key>

                    <string>#02000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Deleted</string>

                <key>scope</key>

                <string>markup.deleted</string>

                <key>settings</key>

                <dict>

                    <key>foreground</key>

                    <string>#01000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Changed</string>

                <key>scope</key>

                <string>markup.changed</string>

                <key>settings</key>

                <dict>

                    <key>foreground</key>

                    <string>#05000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Colors</string>

                <key>scope</key>

                <string>constant.other.color</string>

                <key>settings</key>

                <dict>

                    <key>foreground</key>

                    <string>#06000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Regular Expressions</string>

                <key>scope</key>

                <string>string.regexp</string>

                <key>settings</key>

                <dict>

                    <key>foreground</key>

                    <string>#06000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Escape Characters</string>

                <key>scope</key>

                <string>constant.character.escape</string>

                <key>settings</key>

                <dict>

                    <key>foreground</key>

                    <string>#06000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Embedded</string>

                <key>scope</key>

                <string>punctuation.section.embedded, variable.interpolation</string>

                <key>settings</key>

                <dict>

                    <key>foreground</key>

                    <string>#05000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Illegal</string>

                <key>scope</key>

                <string>invalid.illegal</string>

                <key>settings</key>

                <dict>

                    <key>background</key>

                    <string>#01000000</string>

                </dict>

            </dict>

            <dict>

                <key>name</key>

                <string>Broken</string>

                <key>scope</key>

                <string>invalid.broken</string>

                <key>settings</key>

                <dict>

                    <key>background</key>

                    <string>#03000000</string>

                </dict>

            </dict>

        </array>

        <key>uuid</key>

        <string>uuid</string>

    </dict>

</plist>

use crate::db::{self, Db, Note};

use std::fmt;

#[derive(Debug)]

pub enum BackendError {

    #[allow(dead_code)]

    NotFound,

    Unauthorized(String),

    Network(String),

    Database(String),

}

impl fmt::Display for BackendError {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        match self {

            BackendError::NotFound => write!(f, "Not found"),

            BackendError::Unauthorized(msg) => write!(f, "Unauthorized: {}", msg),

            BackendError::Network(msg) => write!(f, "Network error: {}", msg),

            BackendError::Database(msg) => write!(f, "Database error: {}", msg),

        }

    }

}

impl std::error::Error for BackendError {}

impl From<db::DbError> for BackendError {

    fn from(e: db::DbError) -> Self {

        BackendError::Database(e.to_string())

    }

}

pub enum Backend {

    Local {

        db: Db,

    },

    Remote {

        base_url: String,

        api_key: Option<String>,

        client: reqwest::blocking::Client,

    },

}

impl Backend {

    pub fn local() -> Self {

        Backend::Local { db: db::init_db() }

    }

    pub fn remote(base_url: String, api_key: Option<String>) -> Self {

        Backend::Remote {

            base_url,

            api_key,

            client: reqwest::blocking::Client::new(),

        }

    }

    pub fn list_notes(&self) -> Result<Vec<Note>, BackendError> {

        match self {

            Backend::Local { db } => Ok(db::get_all_notes(db)?),

            Backend::Remote {

                base_url,

                api_key,

                client,

            } => {

                let mut req = client.get(format!("{}/api/notes", base_url));

                if let Some(key) = api_key {

                    req = req.header("x-api-key", key);

                }

                let resp = req

                    .send()

                    .map_err(|e| BackendError::Network(e.to_string()))?;

                match resp.status().as_u16() {

                    200 => resp

                        .json::<Vec<Note>>()

                        .map_err(|e| BackendError::Network(e.to_string())),

                    401 => Err(BackendError::Unauthorized("Invalid API key".into())),

                    403 => Err(BackendError::Unauthorized(

                        "No API key configured on server".into(),

                    )),

                    _ => Err(BackendError::Network(format!("HTTP {}", resp.status()))),

                }

            }

        }

    }

    pub fn create_note(&self, title: &str, content: &str) -> Result<Note, BackendError> {

        match self {

            Backend::Local { db } => Ok(db::create_note(db, title, content)?),

            Backend::Remote {

                base_url,

                api_key,

                client,

            } => {

                let mut req = client

                    .post(format!("{}/api/notes", base_url))

                    .json(&serde_json::json!({"title": title, "content": content}));

                if let Some(key) = api_key {

                    req = req.header("x-api-key", key);

                }

                let resp = req

                    .send()

                    .map_err(|e| BackendError::Network(e.to_string()))?;

                match resp.status().as_u16() {

                    201 => resp

                        .json::<Note>()

                        .map_err(|e| BackendError::Network(e.to_string())),

                    401 => Err(BackendError::Unauthorized("Invalid API key".into())),

                    403 => Err(BackendError::Unauthorized(

                        "No API key configured on server".into(),

                    )),

                    _ => Err(BackendError::Network(format!("HTTP {}", resp.status()))),

                }

            }

        }

    }

    pub fn update_note(

        &self,

        short_id: &str,

        title: &str,

        content: &str,

    ) -> Result<Option<Note>, BackendError> {

        match self {

            Backend::Local { db } => Ok(db::update_note_by_short_id(db, short_id, title, content)?),

            Backend::Remote {

                base_url,

                api_key,

                client,

            } => {

                let mut req = client

                    .put(format!("{}/api/notes/{}", base_url, short_id))

                    .json(&serde_json::json!({"title": title, "content": content}));

                if let Some(key) = api_key {

                    req = req.header("x-api-key", key);

                }

                let resp = req

                    .send()

                    .map_err(|e| BackendError::Network(e.to_string()))?;

                match resp.status().as_u16() {

                    200 => resp

                        .json::<Note>()

                        .map(Some)

                        .map_err(|e| BackendError::Network(e.to_string())),

                    401 => Err(BackendError::Unauthorized("Invalid API key".into())),

                    403 => Err(BackendError::Unauthorized(

                        "No API key configured on server".into(),

                    )),

                    404 => Ok(None),

                    _ => Err(BackendError::Network(format!("HTTP {}", resp.status()))),

                }

            }

        }

    }

    pub fn delete_note(&self, short_id: &str) -> Result<bool, BackendError> {

        match self {

            Backend::Local { db } => Ok(db::delete_note_by_short_id(db, short_id)?),

            Backend::Remote {

                base_url,

                api_key,

                client,

            } => {

                let mut req = client.delete(format!("{}/api/notes/{}", base_url, short_id));

                if let Some(key) = api_key {

                    req = req.header("x-api-key", key);

                }

                let resp = req

                    .send()

                    .map_err(|e| BackendError::Network(e.to_string()))?;

                match resp.status().as_u16() {

                    200 | 204 => Ok(true),

                    401 => Err(BackendError::Unauthorized("Invalid API key".into())),

                    403 => Err(BackendError::Unauthorized(

                        "No API key configured on server".into(),

                    )),

                    404 => Ok(false),

                    _ => Err(BackendError::Network(format!("HTTP {}", resp.status()))),

                }

            }

        }

    }

}

use serde::{Deserialize, Serialize};

use std::path::PathBuf;

#[derive(Debug, Default, Serialize, Deserialize)]

pub struct Config {

    pub remote_url: Option<String>,

    pub api_key: Option<String>,

}

pub fn config_path() -> PathBuf {

    let home = std::env::var("HOME").unwrap_or_else(|_| ".".to_string());

    PathBuf::from(home).join(".config/jotts/config.toml")

}

pub fn load_config() -> Config {

    let path = config_path();

    match std::fs::read_to_string(&path) {

        Ok(contents) => toml::from_str(&contents).unwrap_or_default(),

        Err(_) => Config::default(),

    }

}

pub fn save_config(config: &Config) -> Result<(), Box<dyn std::error::Error>> {

    let path = config_path();

    if let Some(parent) = path.parent() {

        std::fs::create_dir_all(parent)?;

    }

    let contents = toml::to_string_pretty(config)?;

    std::fs::write(&path, contents)?;

    Ok(())

}

use ratatui::style::{Color, Style};

use ratatui::text::{Line, Span, Text};

use std::io::Cursor;

use syntect::easy::HighlightLines;

use syntect::highlighting::Theme;

use syntect::parsing::SyntaxSet;

use syntect::util::LinesWithEndings;

pub struct Highlighter {

    syntax_set: SyntaxSet,

    theme: Theme,

}

impl Highlighter {

    pub fn new() -> Self {

        let theme_data = include_bytes!("ansi.tmTheme");

        let theme =

            syntect::highlighting::ThemeSet::load_from_reader(&mut Cursor::new(&theme_data[..]))

                .expect("failed to load ansi theme");

        Self {

            syntax_set: SyntaxSet::load_defaults_newlines(),

            theme,

        }

    }

    pub fn highlight_markdown(&self, content: &str) -> Text<'static> {

        let syntax = self

            .syntax_set

            .find_syntax_by_extension("md")

            .or_else(|| self.syntax_set.find_syntax_by_name("Markdown"))

            .unwrap_or_else(|| self.syntax_set.find_syntax_plain_text());

        let mut h = HighlightLines::new(syntax, &self.theme);

        let lines: Vec<Line<'static>> = LinesWithEndings::from(content)

            .map(|line| {

                let ranges = h

                    .highlight_line(line, &self.syntax_set)

                    .unwrap_or_default();

                let spans: Vec<Span<'static>> = ranges

                    .into_iter()

                    .map(|(style, text)| {

                        let color = to_ratatui_color(style.foreground);

                        Span::styled(text.to_owned(), Style::default().fg(color))

                    })

                    .collect();

                Line::from(spans)

            })

            .collect();

        Text::from(lines)

    }

}

fn to_ratatui_color(color: syntect::highlighting::Color) -> Color {

    if color.a == 0 {

        Color::Indexed(color.r)

    } else {

        Color::Reset

    }

}

pub mod auth;

pub mod backend;

pub mod config;

pub mod db;

pub mod highlight;

pub mod server;

pub mod tui;

use clap::{Parser, Subcommand};

#[derive(Parser)]

#[command(name = "jotts", about = "Markdown notes — TUI, server, and CLI")]

struct Cli {

    /// Remote server URL (e.g. http://localhost:3000)

    #[arg(short, long, env = "JOTTS_REMOTE_URL")]

    remote: Option<String>,

    /// API key for authenticated operations

    #[arg(short = 'k', long, env = "JOTTS_API_KEY")]

    api_key: Option<String>,

    #[command(subcommand)]

    command: Option<Commands>,

}

#[derive(Subcommand)]

enum Commands {

    /// Start the web server

    Server {

        /// Port to listen on

        #[arg(short, long, default_value_t = 3000)]

        port: u16,

        /// Host to bind to

        #[arg(long, default_value = "127.0.0.1")]

        host: String,

    },

    /// Launch the interactive TUI

    Tui {

        #[arg(short, long, env = "JOTTS_REMOTE_URL")]

        remote: Option<String>,

        #[arg(short = 'k', long, env = "JOTTS_API_KEY")]

        api_key: Option<String>,

    },

    /// Save remote URL and API key to config file

    Auth,

}

fn main() -> Result<(), Box<dyn std::error::Error>> {

    dotenvy::dotenv().ok();

    let cli = Cli::parse();

    match cli.command {

        Some(Commands::Server { port, host }) => {

            let rt = tokio::runtime::Runtime::new()?;

            rt.block_on(jotts::server::run(host, port));

        }

        Some(Commands::Tui { remote, api_key }) => {

            jotts::tui::run_interactive(remote, api_key)?;

        }

        Some(Commands::Auth) => {

            jotts::tui::run_auth()?;

        }

        None => {

            jotts::tui::run_interactive(cli.remote, cli.api_key)?;

        }

    }

    Ok(())

    extract::{Form, Path, Query, Request, State},

    middleware::{self, Next},

    Json, Router,

    pub api_key: Option<String>,

}

#[derive(serde::Deserialize)]

struct NoteJson {

    title: String,

    content: String,

}

// --- API key middleware ---

async fn api_key_guard(

    State(state): State<Arc<AppState>>,

    req: Request,

    next: Next,

) -> Response {

    let expected = match &state.api_key {

        Some(k) if !k.is_empty() => k.clone(),

        _ => {

            return (StatusCode::FORBIDDEN, "API key not configured on server").into_response();

        }

    };

    let provided = req

        .headers()

        .get("x-api-key")

        .and_then(|v| v.to_str().ok())

        .unwrap_or("");

    if !andromeda_auth::verify_api_key(provided, &expected) {

        return (StatusCode::UNAUTHORIZED, "Invalid API key").into_response();

    }

    next.run(req).await

}

// --- JSON API handlers ---

async fn api_list_notes(State(state): State<Arc<AppState>>) -> Response {

    match db::get_all_notes(&state.db) {

        Ok(notes) => Json(notes).into_response(),

        Err(e) => {

            tracing::error!("Failed to list notes: {}", e);

            (StatusCode::INTERNAL_SERVER_ERROR, "Server error").into_response()

        }

    }

}

async fn api_get_note(

    State(state): State<Arc<AppState>>,

    Path(short_id): Path<String>,

) -> Response {

    match db::get_note_by_short_id(&state.db, &short_id) {

        Ok(Some(note)) => Json(note).into_response(),

        Ok(None) => StatusCode::NOT_FOUND.into_response(),

        Err(e) => {

            tracing::error!("Failed to get note: {}", e);

            (StatusCode::INTERNAL_SERVER_ERROR, "Server error").into_response()

        }

    }

}

async fn api_create_note(

    State(state): State<Arc<AppState>>,

    Json(body): Json<NoteJson>,

) -> Response {

    let title = body.title.trim();

    if title.is_empty() {

        return (StatusCode::BAD_REQUEST, "title required").into_response();

    }

    match db::create_note(&state.db, title, &body.content) {

        Ok(note) => (StatusCode::CREATED, Json(note)).into_response(),

        Err(e) => {

            tracing::error!("Failed to create note: {}", e);

            (StatusCode::INTERNAL_SERVER_ERROR, "Server error").into_response()

        }

    }

}

async fn api_update_note(

    State(state): State<Arc<AppState>>,

    Path(short_id): Path<String>,

    Json(body): Json<NoteJson>,

) -> Response {

    let title = body.title.trim();

    if title.is_empty() {

        return (StatusCode::BAD_REQUEST, "title required").into_response();

    }

    match db::update_note_by_short_id(&state.db, &short_id, title, &body.content) {

        Ok(Some(note)) => Json(note).into_response(),

        Ok(None) => StatusCode::NOT_FOUND.into_response(),

        Err(e) => {

            tracing::error!("Failed to update note: {}", e);

            (StatusCode::INTERNAL_SERVER_ERROR, "Server error").into_response()

        }

    }

}

async fn api_delete_note(

    State(state): State<Arc<AppState>>,

    Path(short_id): Path<String>,

) -> Response {

    match db::delete_note_by_short_id(&state.db, &short_id) {

        Ok(true) => StatusCode::NO_CONTENT.into_response(),

        Ok(false) => StatusCode::NOT_FOUND.into_response(),

        Err(e) => {

            tracing::error!("Failed to delete note: {}", e);

            (StatusCode::INTERNAL_SERVER_ERROR, "Server error").into_response()

        }

    }

    let api_key = std::env::var("JOTTS_API_KEY")

        .ok()

        .filter(|k| !k.is_empty());

    if api_key.is_none() {

        tracing::info!("JOTTS_API_KEY not set, /api/* will return 403");

    }

        api_key,

    let api_router = Router::new()

        .route("/api/notes", get(api_list_notes).post(api_create_note))

        .route(

            "/api/notes/{short_id}",

            get(api_get_note)

                .put(api_update_note)

                .delete(api_delete_note),

        )

        .route_layer(middleware::from_fn_with_state(

            state.clone(),

            api_key_guard,

        ));

        .merge(api_router)

use crate::backend::Backend;

use crate::config;

use crate::db::Note;

use crate::highlight::Highlighter;

use arboard::Clipboard;

use crossterm::event::{self, Event, KeyCode, KeyModifiers};

use ratatui::{

    DefaultTerminal,

    layout::{Alignment, Constraint, Layout},

    style::{Color, Modifier, Style},

    text::{Line, Span, Text},

    widgets::{Block, Borders, Clear, List, ListItem, ListState, Paragraph, Widget, Wrap},

};

use std::time::{Duration, Instant};

enum Focus {

    List,

    Content,

    CreateTitle,

    CreateContent,

    EditTitle,

    EditContent,

    Search,

}

struct App {

    notes: Vec<Note>,

    list_state: ListState,

    should_quit: bool,

    status_message: Option<(String, Instant)>,

    focus: Focus,

    content_scroll: u16,

    show_help: bool,

    confirm_delete: bool,

    highlighter: Highlighter,

    edit_title: String,

    edit_content: String,

    edit_short_id: Option<String>,

    search_query: String,

    filtered_indices: Option<Vec<usize>>,

    is_remote: bool,

    remote_url: Option<String>,

    wrap_content: bool,

    edit_scroll: u16,

}

impl App {

    fn new(notes: Vec<Note>, is_remote: bool, remote_url: Option<String>) -> Self {

        let mut list_state = ListState::default();

        if !notes.is_empty() {

            list_state.select(Some(0));

        }

        Self {

            notes,

            list_state,

            should_quit: false,

            status_message: None,

            focus: Focus::List,

            content_scroll: 0,

            show_help: false,

            confirm_delete: false,

            highlighter: Highlighter::new(),

            edit_title: String::new(),

            edit_content: String::new(),

            edit_short_id: None,

            search_query: String::new(),

            filtered_indices: None,

            is_remote,

            remote_url,

            wrap_content: true,

            edit_scroll: 0,

        }

    }

    fn selected_note(&self) -> Option<&Note> {

        self.list_state.selected().and_then(|i| {

            if let Some(indices) = &self.filtered_indices {

                indices.get(i).and_then(|&real| self.notes.get(real))

            } else {

                self.notes.get(i)

            }

        })

    }

    fn visible_count(&self) -> usize {

        match &self.filtered_indices {

            Some(indices) => indices.len(),

            None => self.notes.len(),

        }

    }

    fn move_up(&mut self) {

        let count = self.visible_count();

        if count == 0 {

            return;

        }

        let i = match self.list_state.selected() {

            Some(i) if i > 0 => i - 1,

            Some(_) => count - 1,

            None => 0,

        };

        self.list_state.select(Some(i));

        self.content_scroll = 0;

    }

    fn move_down(&mut self) {

        let count = self.visible_count();

        if count == 0 {

            return;

        }

        let i = match self.list_state.selected() {

            Some(i) if i < count - 1 => i + 1,

            Some(_) => 0,

            None => 0,

        };

        self.list_state.select(Some(i));

        self.content_scroll = 0;

    }

    fn scroll_up(&mut self) {

        self.content_scroll = self.content_scroll.saturating_sub(1);

    }

    fn scroll_down(&mut self, max_lines: u16) {

        if self.content_scroll < max_lines {

            self.content_scroll += 1;

        }

    }

    fn copy_selected(&mut self) {

        if let Some(note) = self.selected_note() {

            if let Ok(mut clipboard) = Clipboard::new() {

                let _ = clipboard.set_text(&note.content);

                self.status_message = Some(("Copied!".to_string(), Instant::now()));

            }

        }

    }

    fn copy_link(&mut self) {

        match &self.remote_url {

            Some(url) => {

                if let Some(note) = self.selected_note() {

                    let link = format!("{}/notes/{}", url.trim_end_matches('/'), note.short_id);

                    if let Ok(mut clipboard) = Clipboard::new() {

                        let _ = clipboard.set_text(&link);

                        self.status_message =

                            Some(("Link copied!".to_string(), Instant::now()));

                    }

                }

            }

            None => {

                self.status_message =

                    Some(("No remote URL configured".to_string(), Instant::now()));

            }

        }

    }

    fn open_in_browser(&mut self) {

        match &self.remote_url {

            Some(url) => {

                if let Some(note) = self.selected_note() {

                    let link = format!("{}/notes/{}", url.trim_end_matches('/'), note.short_id);

                    if let Err(e) = open::that(&link) {

                        self.status_message =

                            Some((format!("Failed to open browser: {}", e), Instant::now()));

                    } else {

                        self.status_message =

                            Some(("Opened in browser!".to_string(), Instant::now()));

                    }

                }

            }

            None => {

                self.status_message =

                    Some(("No remote URL configured".to_string(), Instant::now()));

            }

        }

    }

    fn delete_selected(&mut self, backend: &Backend) {

        if let Some(selected_index) = self.list_state.selected() {

            let real_index = if let Some(indices) = &self.filtered_indices {

                match indices.get(selected_index) {

                    Some(&ri) => ri,

                    None => return,

                }

            } else {

                selected_index

            };

            if let Some(note) = self.notes.get(real_index) {

                let short_id = note.short_id.clone();

                match backend.delete_note(&short_id) {

                    Ok(true) => {

                        self.notes.remove(real_index);

                        if self.filtered_indices.is_some() {

                            self.update_search_filter();

                        }

                        let count = self.visible_count();

                        if count == 0 {

                            self.list_state.select(None);

                        } else if selected_index >= count {

                            self.list_state.select(Some(count - 1));

                        } else {

                            self.list_state.select(Some(selected_index));

                        }

                        self.status_message = Some(("Deleted!".to_string(), Instant::now()));

                    }

                    Ok(false) => {

                        self.status_message =

                            Some(("Note not found".to_string(), Instant::now()));

                    }

                    Err(e) => {

                        self.status_message = Some((e.to_string(), Instant::now()));

                    }

                }

            }

        }

    }

    fn refresh(&mut self, backend: &Backend) {

        match backend.list_notes() {

            Ok(notes) => {

                self.notes = notes;

                self.filtered_indices = None;

                self.search_query.clear();

                if self.notes.is_empty() {

                    self.list_state.select(None);

                } else {

                    let idx = self.list_state.selected().unwrap_or(0);

                    if idx >= self.notes.len() {

                        self.list_state.select(Some(self.notes.len() - 1));

                    }

                }

                self.status_message = Some(("Refreshed!".to_string(), Instant::now()));

            }

            Err(e) => {

                self.status_message = Some((e.to_string(), Instant::now()));

            }

        }

    }

    fn cursor_position_wrapped(&self, width: u16) -> (u16, u16) {

        let w = width as usize;

        if w == 0 {

            return (0, 0);

        }

        let text = &self.edit_content;

        let mut visual_row: usize = 0;

        let lines: Vec<&str> = if text.is_empty() {

            vec![""]

        } else {

            text.split('\n').collect()

        };

        let last_idx = lines.len() - 1;

        for (i, line) in lines.iter().enumerate() {

            let line_len = line.len();

            let wrapped_lines = if line_len == 0 {

                1

            } else {

                (line_len + w - 1) / w

            };

            if i < last_idx {

                visual_row += wrapped_lines;

            } else {

                let cursor_col = if text.ends_with('\n') { 0 } else { line_len };

                let extra_rows = cursor_col / w;

                let col = cursor_col % w;

                visual_row += extra_rows;

                return (col as u16, visual_row as u16);

            }

        }

        (0, visual_row as u16)

    }