Merge pull request #1168 from org2AI/chloe/modularize-org2-root

refactor(org2): split the crate root and agent-session modules

Author: Harry19081

src-tauri/src/agent_sessions/cli/persistence/session_crud.rs

@@ -0,0 +1,122 @@
+//! Insert path for new CLI code-session rows, including the wire-typo
+//! guards and the frozen transcript-source decision.
+
+use rusqlite::{params, Result as SqliteResult};
+
+use agent_core::session::AgentExecMode;
+use database::db::get_connection;
+
+use crate::agent_sessions::cli::native_transcript;
+use crate::agent_sessions::cli::persistence::types::{CodeSession, CreateCodeSessionParams};
+use crate::agent_sessions::cli::types::{
+    session_defaults, KeySource, SessionRunner, SessionStatus, DEFAULT_CODE_SESSION_FLOW,
+    PERSONAL_ORG_ID,
+};
+
+use super::read::get_session;
+use super::shared::{now_iso, sync_orgtrack_mirror};
+
+/// Create a new code session. Returns the session ID.
+pub fn create_session(
+    session_id: &str,
+    params: &CreateCodeSessionParams,
+) -> SqliteResult<CodeSession> {
+    let conn = get_connection()?;
+    let ts = now_iso();
+    let name = params
+        .name
+        .clone()
+        .unwrap_or_else(|| session_defaults::CODE_SESSION_NAME.to_string());
+    let flow = params
+        .flow
+        .clone()
+        .unwrap_or_else(|| DEFAULT_CODE_SESSION_FLOW.to_string());
+    // Wire-typo guard: `runner` is read back via `SessionRunner::parse`
+    // (typed enum) at every read site. If the caller passes a typo'd
+    // string here, the row would be persisted as garbage and every
+    // subsequent `row_to_session` would reject it as a
+    // `FromSqlConversionFailure` — i.e. the session would be created
+    // but unloadable. Reject at the entry point instead.
+    let runner = match params.runner.as_deref().filter(|s| !s.is_empty()) {
+        Some(raw) => SessionRunner::parse(raw)
+            .ok_or_else(|| {
+                rusqlite::Error::ToSqlConversionFailure(
+                    format!("unknown SessionRunner value: {raw:?}").into(),
+                )
+            })?
+            .to_string(),
+        None => SessionRunner::Local.to_string(),
+    };
+
+    let background = params.background.unwrap_or(false);
+
+    // Wire-typo guard for `key_source` — same reasoning as `runner`.
+    // `row_to_session` will fail-closed on an unknown column value, so
+    // accepting an unvalidated string here would create an unloadable
+    // session row (the frontend would see a created session that can
+    // never be opened). Validate at the write boundary.
+    let key_source_str = match params.key_source.as_deref().filter(|s| !s.is_empty()) {
+        Some(raw) => KeySource::parse(raw)
+            .ok_or_else(|| {
+                rusqlite::Error::ToSqlConversionFailure(
+                    format!("unknown KeySource value: {raw:?}").into(),
+                )
+            })?
+            .to_string(),
+        None => KeySource::default().to_string(),
+    };
+
+    let org_id = params
+        .org_id
+        .clone()
+        .filter(|value| !value.trim().is_empty())
+        .unwrap_or_else(|| PERSONAL_ORG_ID.to_string());
+
+    let additional_dirs_json: Option<String> = params
+        .additional_directories
+        .as_ref()
+        .filter(|v| !v.is_empty())
+        .map(|v| serde_json::to_string(v).unwrap_or_else(|_| "[]".to_string()));
+    let product_mode = if params.work_item_id.is_some() {
+        "project".to_string()
+    } else {
+        params
+            .product_mode
+            .clone()
+            .filter(|mode| matches!(mode.as_str(), "build" | "plan" | "ask" | "project"))
+            .unwrap_or_else(|| "build".to_string())
+    };
+
+    // Native-transcript capability is decided once at creation and frozen:
+    // a later capability flip must never re-route an existing session's
+    // replay away from where its turns were actually persisted.
+    let transcript_source = key_vault::key_store::ModelType::from_str(&params.cli_agent_type)
+        .filter(native_transcript::native_transcript_enabled)
+        .map(|_| native_transcript::TRANSCRIPT_SOURCE_NATIVE)
+        .unwrap_or(native_transcript::TRANSCRIPT_SOURCE_CHUNKS);
+
+    conn.execute(
+        "INSERT INTO code_sessions
+            (session_id, name, status, flow, runner, cli_agent_type, model, tier,
+             account_id, repo_path, branch, proxy_token, proxy_url, hosted_token,
+             proxy_session_id, background, key_source, additional_directories,
+             parent_session_id, org_member_id, org_id, project_id, project_name,
+             project_slug, work_item_id, agent_role, created_at, updated_at,
+             transcript_source, product_mode, agent_exec_mode)
+         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16, ?17, ?18, ?19, ?20, ?21, ?22, ?23, ?24, ?25, ?26, ?27, ?28, ?29, ?30, ?31)",
+        params![
+            session_id, name, SessionStatus::Pending.as_ref(), flow, runner, params.cli_agent_type,
+            params.model, params.tier, params.account_id,
+            params.repo_path, params.branch, params.proxy_token, params.proxy_url,
+            params.hosted_token, params.proxy_session_id, background, key_source_str,
+            additional_dirs_json, params.parent_session_id, params.org_member_id,
+            org_id, params.project_id, params.project_name, params.project_slug,
+            params.work_item_id, params.agent_role, ts, ts, transcript_source,
+            product_mode, AgentExecMode::Build.as_str(),
+        ],
+    )?;
+
+    let session = get_session(session_id)?.ok_or(rusqlite::Error::QueryReturnedNoRows)?;
+    sync_orgtrack_mirror(session_id);
+    Ok(session)
+}

src-tauri/src/agent_sessions/cli/persistence/session_crud/create.rs

@@ -0,0 +1,73 @@
+//! Session deletion: shell-replay guard, non-CASCADE usage-table cleanup,
+//! orgtrack mirror removal, and hosted-Codex profile teardown.
+
+use rusqlite::Result as SqliteResult;
+
+use database::db::get_connection;
+
+/// Delete a session and all its chunks (CASCADE) + per-round token usage records.
+pub fn delete_session(session_id: &str) -> SqliteResult<bool> {
+    if let Err(error) =
+        agent_core::tools::impls::coding::exec::shell_replay::ensure_session_replays_deletable(
+            session_id,
+        )
+    {
+        return Err(rusqlite::Error::ToSqlConversionFailure(Box::new(
+            std::io::Error::other(error),
+        )));
+    }
+    agent_core::tools::impls::coding::exec::shell_replay::queue_session_replay_cleanup(session_id)
+        .map_err(|error| {
+            rusqlite::Error::ToSqlConversionFailure(Box::new(std::io::Error::other(error)))
+        })?;
+    let conn = get_connection()?;
+    conn.execute(
+        "DELETE FROM code_session_chunks WHERE session_id = ?1",
+        [session_id],
+    )?;
+    // Clean up per-round token usage records
+    conn.execute(
+        "DELETE FROM session_token_usage WHERE session_id = ?1",
+        [session_id],
+    )?;
+    // Per-LLM-call telemetry lives in the shared usage tables (not under the
+    // code_session_chunks CASCADE), so it needs its own cleanup here.
+    conn.execute(
+        "DELETE FROM session_llm_usage_spans WHERE session_id = ?1",
+        [session_id],
+    )?;
+    conn.execute(
+        "DELETE FROM session_tool_usage WHERE session_id = ?1",
+        [session_id],
+    )?;
+    let affected = conn.execute(
+        "DELETE FROM code_sessions WHERE session_id = ?1",
+        [session_id],
+    )?;
+    if affected > 0 {
+        if let Err(err) =
+            agent_core::tools::impls::coding::exec::shell_replay::remove_session_replays(session_id)
+        {
+            tracing::warn!(session_id, error = %err, "[cli-persistence] shell replay delete failed");
+        }
+        if let Err(err) =
+            crate::agent_sessions::session_directory::orgtrack_adapter::remove_mirrored_session(
+                session_id,
+            )
+        {
+            tracing::warn!(session_id, error = %err, "[cli-persistence] orgtrack delete mirror failed");
+        }
+        let hosted_codex_profile = app_paths::codex_hosted_cli_profile_dir(session_id);
+        if hosted_codex_profile.exists() {
+            if let Err(err) = std::fs::remove_dir_all(&hosted_codex_profile) {
+                tracing::warn!(
+                    session_id,
+                    path = %hosted_codex_profile.display(),
+                    error = %err,
+                    "[cli-persistence] hosted Codex profile delete failed"
+                );
+            }
+        }
+    }
+    Ok(affected > 0)
+}