lib.rs

// Copyright (C) 2026 Bryan A. Jones.
//
// This file is part of the CodeChat Editor. The CodeChat Editor is free
// software: you can redistribute it and/or modify it under the terms of the GNU
// General Public License as published by the Free Software Foundation, either
// version 3 of the License, or (at your option) any later version.
//
// The CodeChat Editor is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
// details.
//
// You should have received a copy of the GNU General Public License along with
// the CodeChat Editor. If not, see
// [http://www.gnu.org/licenses](http://www.gnu.org/licenses).
//
// `lib.rs` -- Interface to the CodeChat Editor for VSCode
// =======================================================
//
// Imports
// -------
//
// ### Standard library
use std::path::PathBuf;

// ### Third-party
use log::LevelFilter;
use napi::{Error, Status};
use napi_derive::napi;

// ### Local
use code_chat_editor::{ide, webserver};

// Code
// ----
#[napi]
pub fn init_server(extension_base_path: String) -> Result<(), Error> {
    // `extension_base_path` is this extension's install directory. In a dev
    // build, that's `extensions/VSCode/`, two directories below the
    // repository root that `webserver::set_root_path` needs; in a packaged
    // build, `client/static`, `log4rs.yml`, and `hashLocations.json` are
    // copied alongside the extension (see `builder`'s `run_postrelease`), so
    // the extension's own directory is already the root.
    let base_path = PathBuf::from(extension_base_path);
    let base_path = if cfg!(debug_assertions) {
        base_path.join("../..")
    } else {
        base_path
    };
    webserver::init_server(
        &base_path,
        if cfg!(debug_assertions) {
            LevelFilter::Debug
        } else {
            LevelFilter::Warn
        },
    )
    .map_err(|err| Error::new(Status::GenericFailure, err.to_string()))
}

#[napi]
struct CodeChatEditorServer(ide::CodeChatEditorServer);

#[napi]
// NAPI's C code calls this, which Rust can't see.
#[allow(dead_code)]
impl CodeChatEditorServer {
    #[napi(constructor)]
    pub fn new(capture_spool_path: String) -> Result<CodeChatEditorServer, Error> {
        Ok(CodeChatEditorServer(
            ide::CodeChatEditorServer::new_with_capture_spool(&PathBuf::from(capture_spool_path))?,
        ))
    }

    // This returns an error if the conversion to JSON fails, `None` if the
    // queue is closed, or a JSON-encoded string containing the message
    // otherwise.
    #[napi]
    pub async fn get_message(&self) -> Result<Option<String>, Error> {
        let editor_message = self.0.get_message().await;

        // Encode then deliver it.
        match editor_message {
            Some(editor_message) => match serde_json::to_string(&editor_message) {
                Ok(v) => Ok(Some(v)),
                Err(err) => Err(Error::new(Status::GenericFailure, err.to_string())),
            },
            None => Ok(None),
        }
    }

    #[napi]
    pub async fn send_message_opened(&self, hosted_in_ide: bool) -> std::io::Result<f64> {
        self.0.send_message_opened(hosted_in_ide).await
    }

    #[napi]
    pub async fn send_capture_event(&self, capture_event_json: String) -> std::io::Result<f64> {
        let capture_event = serde_json::from_str(&capture_event_json)
            .map_err(|err| std::io::Error::other(err.to_string()))?;
        self.0.send_capture_event(capture_event).await
    }

    #[napi]
    pub fn get_capture_status(&self) -> Result<String, Error> {
        serde_json::to_string(&self.0.capture_status())
            .map_err(|err| Error::new(Status::GenericFailure, err.to_string()))
    }

    #[napi]
    // We must pass `base_url` as a `String` per NAPI requirements.
    #[allow(clippy::needless_pass_by_value)]
    pub fn configure_capture_service(
        &self,
        base_url: String,
        token: Option<String>,
    ) -> Result<(), Error> {
        self.0
            .configure_capture_service(&base_url, token)
            .map_err(|err| Error::new(Status::GenericFailure, err))
    }

    #[napi]
    pub fn clear_capture_token(&self) -> Result<(), Error> {
        self.0
            .clear_capture_token()
            .map_err(|err| Error::new(Status::GenericFailure, err))
    }

    #[napi]
    pub fn check_capture_service_status(&self) -> Result<String, Error> {
        serde_json::to_string(
            &self
                .0
                .check_capture_service_status()
                .map_err(|err| Error::new(Status::GenericFailure, err))?,
        )
        .map_err(|err| Error::new(Status::GenericFailure, err.to_string()))
    }

    #[napi]
    pub async fn send_message_current_file(&self, url: String) -> std::io::Result<f64> {
        self.0.send_message_current_file(url).await
    }

    #[napi]
    pub async fn send_message_update_plain(
        &self,
        file_path: String,
        // `null` to send no source code; a `(string, version)` to send the
        // source code.
        option_contents: Option<(String, f64)>,
        cursor_position: Option<u32>,
        scroll_position: Option<f64>,
    ) -> std::io::Result<f64> {
        self.0
            .send_message_update_plain(file_path, option_contents, cursor_position, scroll_position)
            .await
    }

    #[napi]
    pub async fn send_result(
        &self,
        id: f64,
        // If provided, a JSON-encoded `ResultErrTypes`.
        message_result: Option<String>,
    ) -> std::io::Result<()> {
        let message = if let Some(err_json) = message_result {
            match serde_json::from_str(&err_json) {
                Ok(v) => Some(v),
                Err(err) => return Err(std::io::Error::other(err.to_string())),
            }
        } else {
            None
        };
        self.0.send_result(id, message).await
    }

    #[napi]
    pub async fn send_result_loadfile(
        &self,
        id: f64,
        load_file: Option<(String, f64)>,
    ) -> std::io::Result<()> {
        self.0.send_result_loadfile(id, load_file).await
    }

    // This returns after the server shuts down.
    #[napi]
    pub async fn stop_server(&self) {
        self.0.stop_server().await;
    }
}