pharos_native/runtime/

agent_architect.rs

use serde_json::Value;
use std::path::{Component, Path, PathBuf};

use super::agent_bridge::{self, AgentErrorKind, PathClassification};
pub use pharos_runtime_architect::editor_state::load_architect_editor_source_view_from_root;
use pharos_runtime_architect::lifecycle_validation::{
    ArchitectLifecycleTools,
    apply_and_validate_review_workspace as architect_apply_and_validate_review_workspace,
    architect_current_dir_lock,
};
use pharos_runtime_architect::llm_vendor::ArchitectLlmSecretProvider;
pub use pharos_runtime_architect::source_bundle::source_export_relative_path_allowed;
pub use pharos_runtime_architect::source_export::{
    ArchitectSourceExport, ArchitectSourceExportDownload, ArchitectSourceExportKind,
    export_architect_source, export_kind_slug, parse_source_export_kind,
    read_architect_source_export, validate_source_export_id,
};
pub use pharos_runtime_architect::task_planning::prepare_architect_task_plan;
pub use pharos_runtime_architect::task_state::{
    ArchitectEditorProjectDeleteResult, ArchitectEditorProjectDuplicateResult,
    ArchitectEditorProjectRenameResult, ArchitectEditorRollbackResult,
    ArchitectEditorSelectedSource, ArchitectEditorSourceAppImportResult,
    ArchitectEditorSourceEditApplyResult, ArchitectEditorSourceEditPlan, ArchitectEditorSourceFile,
    ArchitectEditorSourceView, ArchitectEditorStructuredEditPlan, ArchitectLlmVendorVaultPaths,
    ArchitectTaskApplyResult, ArchitectTaskDeleteResult, ArchitectWorkerLoopRun,
    ArchitectWorkerRun, ArchitectWorkerTaskResult,
};

/// Resolves typed Architect entities through the configured primary database adapter.
pub fn architect_database_storage(
    app_root: &Path,
    artifact_root: &Path,
    runtime_conf: Option<&Path>,
    entities: &[&str],
) -> Result<
    (
        pharos_runtime_database::DbBackendConfig,
        std::sync::Arc<dyn pharos_runtime_database::operations::DatabaseOperations>,
        pharos_runtime_database::operations::AppSchema,
    ),
    AgentErrorKind,
> {
    let config =
        super::database::load_cli_backend_config(app_root, runtime_conf, Some("architect"))
            .ok_or(AgentErrorKind::InvalidPath)?;
    let adapter = super::database::operations::resolve(&config)
        .map_err(|_| AgentErrorKind::PolicyViolation)?;
    let contract = super::database::selected_logical_contract(artifact_root, "architect")
        .map_err(|_| AgentErrorKind::PolicyViolation)?
        .ok_or(AgentErrorKind::PolicyViolation)?;
    if entities.is_empty() || entities.len() > 256 {
        return Err(AgentErrorKind::PolicyViolation);
    }
    let mut requested = std::collections::BTreeSet::new();
    for name in entities {
        if !requested.insert(*name)
            || !contract
                .schema
                .entities
                .iter()
                .any(|entity| entity.name == *name)
        {
            return Err(AgentErrorKind::PolicyViolation);
        }
    }
    // Keep the complete selected schema so references and constraints retain
    // the same meaning for workers, HTTP callers and migration readiness.
    let schema = contract.schema;
    Ok((config, adapter, schema))
}

/// Loads the worker's declared Architect entities through one configured adapter.
pub fn architect_worker_store(
    app_root: &Path,
    artifact_root: &Path,
    runtime_conf: Option<&Path>,
) -> Result<pharos_runtime_architect::database::ArchitectStore, AgentErrorKind> {
    let (config, adapter, schema) = architect_database_storage(
        app_root,
        artifact_root,
        runtime_conf,
        &[
            "architect_task",
            "architect_task_event",
            "architect_attachment_extract",
            "architect_attachment",
            "architect_transcript",
            "architect_llm_vendor",
            "architect_editor_project",
            "architect_editor_version",
            "architect_editor_source_file",
            "architect_editor_change",
            "architect_source_export",
            "architect_vault_audit",
            "architect_user_activity",
            "architect_workspace",
            "architect_privacy_setting",
            "architect_target_profile",
            "user_account",
            "store_membership",
            "auth_session",
            "rate_limit_event",
        ],
    )?;
    pharos_runtime_architect::database::ArchitectStore::new(config, adapter, schema)
        .map_err(|_| AgentErrorKind::PolicyViolation)
}

/// Loads a validated Architect editor version through the logical database store.
pub fn load_architect_editor_source_view_in_store(
    store: &pharos_runtime_architect::database::ArchitectStore,
    version_id: i64,
    selected_path: Option<&str>,
) -> Result<ArchitectEditorSourceView, AgentErrorKind> {
    pharos_runtime_architect::editor_state::load_editor_source_view_in_store(
        store,
        version_id,
        selected_path,
    )
}

/// Plans one source-file edit against the current validated editor version.
pub fn prepare_architect_editor_source_edit_in_store(
    store: &pharos_runtime_architect::database::ArchitectStore,
    version_id: i64,
    source_path: &str,
    proposed_content: &str,
    actor_id: i64,
) -> Result<ArchitectEditorSourceEditPlan, AgentErrorKind> {
    pharos_runtime_architect::editor_state::prepare_editor_changes_in_store(
        store,
        version_id,
        &[(source_path.to_owned(), proposed_content.to_owned())],
        actor_id,
        "source_edit",
    )
}

/// Plans a declarative entity, field, or layout edit through the same source ledger.
pub fn prepare_architect_editor_structured_edit_in_store(
    store: &pharos_runtime_architect::database::ArchitectStore,
    version_id: i64,
    edit_kind: &str,
    params: &Value,
    actor_id: i64,
) -> Result<ArchitectEditorStructuredEditPlan, AgentErrorKind> {
    if version_id <= 0 || actor_id <= 0 {
        return Err(AgentErrorKind::InvalidIdentifier);
    }
    let edit_kind =
        pharos_runtime_architect::editor_state::normalize_structured_edit_kind(edit_kind)?;
    let source_view = load_architect_editor_source_view_in_store(store, version_id, None)?;
    let changes = pharos_runtime_architect::editor_state::prepare_structured_editor_changes(
        &source_view,
        edit_kind,
        params,
    )?;
    if changes.is_empty() {
        return Err(AgentErrorKind::StalePlan);
    }
    let owned = changes
        .into_iter()
        .map(|change| (change.source_path.to_owned(), change.content))
        .collect::<Vec<_>>();
    let plan = pharos_runtime_architect::editor_state::prepare_editor_changes_in_store(
        store,
        version_id,
        &owned,
        actor_id,
        match edit_kind {
            "layout_pattern" => "page_edit",
            "entity_add" | "entity_rename" | "entity_remove" => "entity_edit",
            _ => "field_edit",
        },
    )?;
    Ok(ArchitectEditorStructuredEditPlan {
        schema: "pharos.architect.editor_structured_edit_plan.v1".to_owned(),
        edit_kind: edit_kind.to_owned(),
        project_id: source_view.project_id,
        version_id,
        plans: vec![plan],
    })
}

/// Renames an Architect project through the app's configured primary backend.
pub fn rename_architect_editor_project_for_app(
    app: &crate::config::AppRuntime,
    project_id: i64,
    title: &str,
) -> Result<ArchitectEditorProjectRenameResult, AgentErrorKind> {
    if app.app_id.as_deref() != Some("architect") {
        return Err(AgentErrorKind::PolicyViolation);
    }
    let app_root = app
        .app_root
        .as_deref()
        .map(Path::new)
        .ok_or(AgentErrorKind::InvalidPath)?;
    let artifact_root = app
        .artifact_dir
        .as_deref()
        .map(Path::new)
        .unwrap_or(app_root);
    let (config, adapter, schema) = architect_database_storage(
        app_root,
        artifact_root,
        app.runtime_conf_path.as_deref().map(Path::new),
        &["architect_editor_project"],
    )?;
    pharos_runtime_architect::project_state::rename_architect_editor_project(
        &config,
        adapter.as_ref(),
        &schema,
        project_id,
        title,
    )
}

struct RootArchitectLifecycleTools<'a> {
    connection_task: Option<(&'a pharos_runtime_architect::database::ArchitectStore, i64)>,
}

impl ArchitectLifecycleTools for RootArchitectLifecycleTools<'_> {
    /// Rechecks a subscription task without coupling ordinary edits to a provider connection.
    fn before_source_promotion(&mut self) -> Result<(), AgentErrorKind> {
        if let Some((store, task_id)) = self.connection_task {
            let task = pharos_runtime_architect::task_repository::load_task(store, task_id)?;
            if task.llm_vendor_id == "chatgpt" {
                pharos_runtime_architect::chatgpt::repository::connection_for_task(store, task_id)
                    .map_err(|_| AgentErrorKind::CredentialUnavailable)?;
            }
        }
        Ok(())
    }
    fn apply_change(&mut self, app_id: &str, plan_digest: &str) -> Result<Value, AgentErrorKind> {
        agent_bridge::apply_app_change(app_id, plan_digest)
    }

    fn run_app_tool(
        &mut self,
        tool: &str,
        app_id: &str,
        app_root: Option<&str>,
        build_dir: Option<&str>,
        config_path: Option<&str>,
    ) -> Result<Value, AgentErrorKind> {
        let result =
            agent_bridge::run_lifecycle_app_tool(tool, app_id, app_root, build_dir, config_path);
        if let Err(error) = &result {
            eprintln!("architect lifecycle {tool} failed: {error:?}");
        }
        result
    }

    fn seed_app(
        &mut self,
        app_id: &str,
        app_root: Option<&str>,
        config_path: Option<&str>,
        backend: &str,
    ) -> Result<Value, AgentErrorKind> {
        let result = agent_bridge::seed_app_tool(app_id, app_root, config_path, backend);
        if let Err(error) = &result {
            eprintln!("architect lifecycle seed failed: {error:?}");
        }
        result
    }
}

struct RootArchitectLlmSecretProvider;

impl ArchitectLlmSecretProvider for RootArchitectLlmSecretProvider {
    fn get_llm_vendor_secret(
        &self,
        vault_path: &Path,
        root_key_file: &Path,
        llm_vendor_id: &str,
    ) -> Result<Vec<u8>, AgentErrorKind> {
        super::agent_vault::get_architect_runtime_llm_vendor_secret(
            vault_path,
            root_key_file,
            llm_vendor_id,
        )
    }
}

/// Runs one bounded Architect worker iteration against the configured database.
pub fn run_architect_worker_once(
    store: &pharos_runtime_architect::database::ArchitectStore,
    output_root: &Path,
) -> Result<ArchitectWorkerRun, AgentErrorKind> {
    run_architect_worker_once_with_llm_vendor_vault(store, output_root, None)
}

/// Runs one bounded Architect worker iteration with optional external LLM vendor vault access.
pub fn run_architect_worker_once_with_llm_vendor_vault(
    store: &pharos_runtime_architect::database::ArchitectStore,
    output_root: &Path,
    llm_vendor_vault: Option<ArchitectLlmVendorVaultPaths>,
) -> Result<ArchitectWorkerRun, AgentErrorKind> {
    validate_worker_output_root(output_root)?;
    pharos_runtime_architect::worker_runtime::run_architect_worker_once_with_services(
        store,
        output_root,
        llm_vendor_vault,
        &RootArchitectLlmSecretProvider,
    )
}

/// Runs a bounded Architect worker loop for service supervisors.
pub fn run_architect_worker_loop(
    store: &pharos_runtime_architect::database::ArchitectStore,
    output_root: &Path,
    max_iterations: usize,
) -> Result<ArchitectWorkerLoopRun, AgentErrorKind> {
    validate_worker_output_root(output_root)?;
    pharos_runtime_architect::worker_runtime::run_architect_worker_loop_with_services(
        store,
        output_root,
        max_iterations,
        &RootArchitectLlmSecretProvider,
    )
}

/// Runs one Architect task from browser submission through local app validation.
pub fn run_architect_task_to_validated(
    store: &pharos_runtime_architect::database::ArchitectStore,
    task_id: i64,
    output_root: &Path,
    llm_vendor_vault: Option<ArchitectLlmVendorVaultPaths>,
) -> Result<ArchitectTaskApplyResult, AgentErrorKind> {
    if task_id <= 0 {
        return Err(AgentErrorKind::InvalidIdentifier);
    }
    validate_worker_output_root(output_root)?;
    plan_architect_task_for_auto_build(store, task_id, output_root, llm_vendor_vault)?;
    approve_architect_task_plan(store, task_id, output_root)
}

/// Queues a new Architect build task or resets the latest failed same-app task for a clean retry.
pub fn queue_or_retry_architect_task(
    store: &pharos_runtime_architect::database::ArchitectStore,
    output_app_id: &str,
    llm_vendor_id: &str,
    brief: &str,
    actor_id: i64,
) -> Result<i64, AgentErrorKind> {
    pharos_runtime_architect::task_repository::queue_or_retry_task_for_actor(
        store,
        output_app_id,
        llm_vendor_id,
        brief,
        actor_id,
    )
}

fn plan_architect_task_for_auto_build(
    store: &pharos_runtime_architect::database::ArchitectStore,
    task_id: i64,
    output_root: &Path,
    llm_vendor_vault: Option<ArchitectLlmVendorVaultPaths>,
) -> Result<(), AgentErrorKind> {
    pharos_runtime_architect::worker_runtime::plan_architect_task_for_auto_build(
        store,
        task_id,
        output_root,
        llm_vendor_vault,
        &RootArchitectLlmSecretProvider,
    )
}

/// Applies one browser-approved Architect task plan and runs local lifecycle validation.
pub fn approve_architect_task_plan(
    store: &pharos_runtime_architect::database::ArchitectStore,
    task_id: i64,
    generated_root: &Path,
) -> Result<ArchitectTaskApplyResult, AgentErrorKind> {
    if task_id <= 0 || generated_root.as_os_str().is_empty() {
        return Err(AgentErrorKind::InvalidPath);
    }
    let task = pharos_runtime_architect::task_repository::load_review_task(store, task_id)?;
    pharos_runtime_architect::task_repository::transition_task(
        store,
        task_id,
        "applying",
        "apply_started",
        "Architect started validating the approved plan.",
        std::collections::BTreeMap::new(),
    )?;
    let _dir_guard = architect_current_dir_lock()
        .lock()
        .map_err(|_| AgentErrorKind::PolicyViolation)?;
    let mut lifecycle_tools = RootArchitectLifecycleTools {
        connection_task: Some((store, task_id)),
    };
    let result = architect_apply_and_validate_review_workspace(
        &task,
        task_id,
        generated_root,
        store.config(),
        &mut lifecycle_tools,
    );
    match result {
        Ok(result) => {
            pharos_runtime_architect::task_repository::mark_apply_success(store, task_id, &result)?;
            Ok(result)
        }
        Err(error) => {
            let _ = pharos_runtime_architect::task_repository::transition_task(
                store,
                task_id,
                "failed",
                "apply_failed",
                "Architect could not validate the approved plan.",
                std::collections::BTreeMap::new(),
            );
            Err(error)
        }
    }
}

/// Applies one approved planned source edit through the generic Architect store.
pub fn apply_architect_editor_source_edit(
    store: &pharos_runtime_architect::database::ArchitectStore,
    change_id: i64,
    generated_root: &Path,
    actor_id: i64,
) -> Result<ArchitectEditorSourceEditApplyResult, AgentErrorKind> {
    apply_architect_editor_source_edit_inner(store, change_id, generated_root, actor_id, false)
}

/// Applies one approved planned source edit with an injected post-validation failure for local rollback proof.
pub fn apply_architect_editor_source_edit_with_injected_failure(
    store: &pharos_runtime_architect::database::ArchitectStore,
    change_id: i64,
    generated_root: &Path,
    actor_id: i64,
) -> Result<ArchitectEditorSourceEditApplyResult, AgentErrorKind> {
    apply_architect_editor_source_edit_inner(store, change_id, generated_root, actor_id, true)
}

pub fn validate_existing_architect_task_source(
    store: &pharos_runtime_architect::database::ArchitectStore,
    task_id: i64,
    generated_root: &Path,
    actor_id: i64,
) -> Result<(), AgentErrorKind> {
    let mut tools = RootArchitectLifecycleTools {
        connection_task: None,
    };
    pharos_runtime_architect::editor_runtime::validate_existing_task_source(
        store,
        task_id,
        generated_root,
        actor_id,
        &mut tools,
    )
}

fn apply_architect_editor_source_edit_inner(
    store: &pharos_runtime_architect::database::ArchitectStore,
    change_id: i64,
    generated_root: &Path,
    actor_id: i64,
    inject_failure_after_validation: bool,
) -> Result<ArchitectEditorSourceEditApplyResult, AgentErrorKind> {
    let mut lifecycle_tools = RootArchitectLifecycleTools {
        connection_task: None,
    };
    pharos_runtime_architect::editor_runtime::apply_architect_editor_source_edit_with_services(
        store,
        change_id,
        generated_root,
        actor_id,
        inject_failure_after_validation,
        &mut lifecycle_tools,
    )
}

/// Marks one task as ready for browser review after deterministic synthesis and change planning.
/// Validates one generated app id before resolving a browser preview path.
pub fn normalize_architect_preview_app_id(value: &str) -> Result<String, AgentErrorKind> {
    agent_bridge::normalize_app_id(value)
}

/// Converts bytes into lower-case hex text.
fn validate_worker_output_root(output_root: &Path) -> Result<(), AgentErrorKind> {
    if output_root.as_os_str().is_empty() {
        return Err(AgentErrorKind::InvalidPath);
    }
    if let Ok(repo_root) = resolve_repo_root() {
        let output_relative = repo_relative_path(&repo_root, output_root)?;
        return match agent_bridge::classify_repo_path(&output_relative)? {
            PathClassification::Artifact => Err(AgentErrorKind::PolicyViolation),
            PathClassification::Source | PathClassification::Temp => Ok(()),
        };
    }
    validate_installed_state_path(output_root)
}

fn validate_installed_state_path(path: &Path) -> Result<(), AgentErrorKind> {
    if !path.is_absolute()
        || path
            .components()
            .any(|component| matches!(component, Component::ParentDir))
    {
        return Err(AgentErrorKind::InvalidPath);
    }
    let parent = path.parent().ok_or(AgentErrorKind::InvalidPath)?;
    let canonical_parent = parent
        .canonicalize()
        .map_err(|_| AgentErrorKind::InvalidPath)?;
    if canonical_parent.starts_with("/var/state/pharos")
        || canonical_parent.starts_with("/var/lib/pharos")
    {
        Ok(())
    } else {
        Err(AgentErrorKind::PolicyViolation)
    }
}

/// Resolves the current Pharos repository root for Architect worker path checks.
fn resolve_repo_root() -> Result<PathBuf, AgentErrorKind> {
    let cwd = std::env::current_dir().map_err(|_| AgentErrorKind::InvalidPath)?;
    let mut current = Some(cwd.as_path());
    while let Some(path) = current {
        if path.join("apps").is_dir() && path.join("scripts").is_dir() {
            return path.canonicalize().map_err(|_| AgentErrorKind::InvalidPath);
        }
        current = path.parent();
    }
    Err(AgentErrorKind::InvalidPath)
}

/// Converts an output path into a repository-relative, traversal-free string.
fn repo_relative_path(repo_root: &Path, path: &Path) -> Result<String, AgentErrorKind> {
    let absolute = if path.is_absolute() {
        path.to_path_buf()
    } else {
        repo_root.join(path)
    };
    if absolute
        .components()
        .any(|component| matches!(component, Component::ParentDir))
    {
        return Err(AgentErrorKind::InvalidPath);
    }
    let parent = absolute.parent().ok_or(AgentErrorKind::InvalidPath)?;
    let canonical_parent = parent
        .canonicalize()
        .map_err(|_| AgentErrorKind::InvalidPath)?;
    if !canonical_parent.starts_with(repo_root) {
        return Err(AgentErrorKind::InvalidPath);
    }
    let normalized =
        canonical_parent.join(absolute.file_name().ok_or(AgentErrorKind::InvalidPath)?);
    let relative = normalized
        .strip_prefix(repo_root)
        .map_err(|_| AgentErrorKind::InvalidPath)?;
    Ok(relative.to_string_lossy().into_owned())
}