liminal-cli 0.3.33

#![cfg(test)]

use super::*;

#[test]
fn generated_configuration_writes_the_operational_defaults() -> anyhow::Result<()> {
    let home = tempfile::tempdir()?;
    let text = configuration(home.path())?;
    let path = home.path().join("liminal.toml");
    write_configuration(&path, &text)?;
    let server = load_configuration(&path)?;
    let defaults = liminal_server::config::LimitsConfig::default();
    assert_eq!(server.limits.max_connections, defaults.max_connections);
    assert_eq!(
        server.limits.max_subscriptions_per_connection,
        defaults.max_subscriptions_per_connection
    );
    assert_eq!(
        server.limits.max_conversations_per_connection,
        defaults.max_conversations_per_connection
    );
    assert_eq!(
        server.limits.max_pending_pushes_per_connection,
        defaults.max_pending_pushes_per_connection
    );
    assert_eq!(
        server
            .limits
            .max_pending_conversation_replies_per_connection,
        defaults.max_pending_conversation_replies_per_connection
    );
    assert_eq!(
        server.limits.max_pending_replies_per_conversation,
        defaults.max_pending_replies_per_conversation
    );
    assert_eq!(
        server.limits.max_connection_inbox_bytes,
        defaults.max_connection_inbox_bytes
    );
    assert_eq!(
        server.limits.max_connection_outbound_bytes,
        defaults.max_connection_outbound_bytes
    );
    assert_eq!(
        server.limits.max_subscription_inbox_depth,
        defaults.max_subscription_inbox_depth
    );
    assert_eq!(
        server.limits.delivery_slice_budget,
        defaults.delivery_slice_budget
    );
    assert_eq!(server.limits.reply_timeout_ms, defaults.reply_timeout_ms);
    assert_eq!(server.limits.max_channels, Some(512));
    assert!(server.extra_listen_addresses.is_empty());
    assert!(server.channels.is_empty());
    assert!(server.routing_rules.is_empty());
    assert_eq!(server.drain_timeout_ms, 0);
    assert_eq!(server.open_reach().word(), "loopback");
    let services = liminal_server::config::ServicesConfig::default();
    assert_eq!(server.services.profile, services.profile);
    assert_eq!(
        server.services.self_streams.cost_rows,
        services.self_streams.cost_rows
    );
    assert_eq!(
        server.services.self_streams.events_rows,
        services.self_streams.events_rows
    );
    assert_eq!(
        server.agents,
        Some(liminal_server::agents::config::AgentsConfig::default())
    );
    // CON-023 R1: the console's largest set doubled, and the assistant with eight builders.
    assert_eq!(server.limits.max_subscriptions_per_connection, 1024);
    let agents = server
        .agents
        .ok_or_else(|| anyhow::anyhow!("[agents] absent"))?;
    assert_eq!(
        (agents.max_listened_subjects, agents.max_per_owner),
        (1024, 64)
    );
    assert_eq!(server.listen_address.to_string(), "127.0.0.1:7400");
    assert_eq!(server.health_listen_address.to_string(), "127.0.0.1:7401");
    assert_eq!(server.persistence_path, Some(home.path().join("store")));
    assert!(server.auth.is_none());
    assert!(server.websocket.is_none());
    assert!(server.cluster.is_none());
    assert!(server.participant.is_some());
    assert!(server.agents.is_some());
    Ok(())
}

#[test]
fn an_occupied_port_names_its_configuration_key() -> anyhow::Result<()> {
    let held = std::net::TcpListener::bind("127.0.0.1:0")?;
    let address = held.local_addr()?;
    let error = reserve(address, "console.listen")
        .err()
        .ok_or_else(|| anyhow::anyhow!("occupied socket was admitted"))?;
    let words = error.to_string();
    assert!(words.contains(&address.port().to_string()));
    assert!(words.contains("console.listen"));
    Ok(())
}

#[test]
fn a_legacy_document_has_no_console_or_assistant() -> anyhow::Result<()> {
    let table: toml::Table = toml::from_str(
        "listen_address = '127.0.0.1:7400'\nhealth_listen_address = '127.0.0.1:7401'\ndrain_timeout_ms = 0\nchannels = []\nrouting_rules = []\n",
    )?;
    assert!(console_configuration(&table)?.is_none());
    Ok(())
}

#[test]
fn a_console_document_starts_no_assistant_unless_written() -> anyhow::Result<()> {
    let table: toml::Table = toml::from_str("[console]\nlisten = '127.0.0.1:7480'\n")?;
    let console =
        console_configuration(&table)?.ok_or_else(|| anyhow::anyhow!("console absent"))?;
    assert!(!console.assistant);
    assert_eq!(console.listen.port(), 7480);
    let invalid: toml::Table =
        toml::from_str("[console]\nlisten = '127.0.0.1:7480'\nassitant = true\n")?;
    assert!(console_configuration(&invalid).is_err());
    Ok(())
}

#[test]
fn embedded_index_and_an_asset_are_the_dist_bytes() -> anyhow::Result<()> {
    let dist =
        std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../apps/liminal-console/dist");
    let (kind, index) =
        console::asset("/").ok_or_else(|| anyhow::anyhow!("embedded index absent"))?;
    assert_eq!(kind, "text/html; charset=utf-8");
    assert_eq!(index, std::fs::read(dist.join("index.html"))?);
    let entry = std::fs::read_dir(dist.join("assets"))?
        .find_map(|entry| match entry {
            Ok(entry)
                if entry
                    .path()
                    .extension()
                    .is_some_and(|extension| extension == "js") =>
            {
                Some(Ok(entry.path()))
            }
            Ok(_) => None,
            Err(error) => Some(Err(error)),
        })
        .ok_or_else(|| anyhow::anyhow!("dist has no JavaScript asset"))??;
    let name = entry
        .file_name()
        .and_then(std::ffi::OsStr::to_str)
        .ok_or_else(|| anyhow::anyhow!("asset has no Unicode filename"))?;
    let (kind, bytes) = console::asset(&format!("/assets/{name}"))
        .ok_or_else(|| anyhow::anyhow!("embedded asset absent"))?;
    assert_eq!(kind, "text/javascript; charset=utf-8");
    assert_eq!(bytes, std::fs::read(entry)?);
    assert!(console::asset("/../outside").is_none());
    Ok(())
}

#[path = "../build/assets.rs"]
mod assets;

#[test]
fn the_build_names_a_missing_dist_and_embeds_packaged_or_workspace_bytes() -> anyhow::Result<()> {
    let directory = tempfile::tempdir()?;
    let manifest = directory.path().join("project/crates/liminal-cli");
    std::fs::create_dir_all(&manifest)?;
    let words = assets::dist(&manifest)
        .err()
        .ok_or_else(|| anyhow::anyhow!("a missing dist was admitted"))?;
    assert!(
        words.contains("apps/liminal-console/dist")
            && words.contains("console-dist")
            && words.contains("bun run build"),
        "{words}"
    );
    let workspace = directory.path().join("project/apps/liminal-console/dist");
    std::fs::create_dir_all(workspace.join("assets"))?;
    std::fs::write(workspace.join("index.html"), b"<html>fixture</html>")?;
    std::fs::write(workspace.join("assets/fixture.wasm"), b"\0asm")?;
    let found = assets::dist(&manifest).map_err(anyhow::Error::msg)?;
    assert_eq!(
        std::fs::canonicalize(&found)?,
        std::fs::canonicalize(&workspace)?
    );
    let (generated, files) = assets::table(&found).map_err(|error| anyhow::anyhow!("{error}"))?;
    assert_eq!(files.len(), 2);
    assert!(generated.contains("include_bytes!") && generated.contains("application/wasm"));
    assert!(
        generated.contains("\"/index.html\"") && generated.contains("\"/assets/fixture.wasm\"")
    );
    Ok(())
}

/// CON-026 R1: a checkout embeds its own console; a packaged copy is read only by a published
/// crate, which cannot reach the workspace.
#[test]
fn a_checkout_embeds_the_workspace_console_and_a_published_crate_its_packaged_one()
-> anyhow::Result<()> {
    let directory = tempfile::tempdir()?;
    let manifest = directory.path().join("project/crates/liminal-cli");
    let packaged = manifest.join("console-dist");
    std::fs::create_dir_all(&packaged)?;
    std::fs::write(packaged.join("index.html"), b"<html>packaged</html>")?;
    assert_eq!(
        assets::dist(&manifest).map_err(anyhow::Error::msg)?,
        packaged,
        "a published crate reads the dist it carries"
    );
    let console = directory.path().join("project/apps/liminal-console");
    std::fs::create_dir_all(&console)?;
    let words = assets::dist(&manifest).err().ok_or_else(|| {
        anyhow::anyhow!("a checkout without its dist embedded a leftover packaged copy")
    })?;
    assert!(
        words.contains("apps/liminal-console/dist") && words.contains("bun run build"),
        "{words}"
    );
    let workspace = console.join("dist");
    std::fs::create_dir_all(&workspace)?;
    std::fs::write(workspace.join("index.html"), b"<html>workspace</html>")?;
    assert_eq!(
        std::fs::canonicalize(assets::dist(&manifest).map_err(anyhow::Error::msg)?)?,
        std::fs::canonicalize(&workspace)?,
        "a checkout embeds its own console over a leftover packaged copy"
    );
    Ok(())
}

#[test]
fn harness_refusals_keep_their_words_without_promoting_other_frames() {
    assert_eq!(assistant::harness_words(br#"{"jsonrpc":"2.0","id":3,"error":{"code":-32603,"message":"Claude Code fixture: sign in required"}}"#).as_deref(), Some("Claude Code fixture: sign in required"));
    assert_eq!(
        assistant::harness_words(br#"{"jsonrpc":"2.0","id":3,"result":{}}"#),
        None
    );
    assert_eq!(assistant::harness_words(b"not JSON"), None);
}