feat: replace cortex-gui with full-featured desktop from cortex-app

- Replace stub implementations with full Linear integration
- Replace stub implementations with full workspace_scripts support
- Export linear and workspace_scripts modules from cortex-engine
- Fix create_default_client imports to use cortex_common
- Update dependency paths to point to cortex-cli workspace
- Re-enable all Tauri commands in mod.rs and lib.rs

This brings feature parity with the cortex-app GUI:
- Full Linear API integration (teams, issues, OAuth)
- Workspace scripts (setup, dev, archive)
- All 55+ Tauri commands now functional

Author: factorydroid

cortex-engine/src/billing_client.rs

@@ -14,7 +14,7 @@ use reqwest::Client;
 use serde::{Deserialize, Serialize};
 use tracing::{debug, error, info};
 
-use crate::api_client::create_default_client;
+use cortex_common::create_default_client;
 use crate::error::{CortexError, Result};
 
 // ============================================================================
@@ -289,7 +289,7 @@ impl BillingClient {
     pub fn new() -> Result<Self> {
         let base_url =
             std::env::var("CORTEX_API_URL").unwrap_or_else(|_| DEFAULT_API_URL.to_string());
-        let client = create_default_client()?;
+        let client = create_default_client().map_err(CortexError::internal)?;
 
         Ok(Self {
             client,
@@ -300,7 +300,7 @@ impl BillingClient {
 
     /// Creates a billing client with explicit base URL.
     pub fn with_base_url(base_url: String) -> Result<Self> {
-        let client = create_default_client()?;
+        let client = create_default_client().map_err(CortexError::internal)?;
 
         Ok(Self {
             client,

cortex-engine/src/lib.rs

@@ -45,6 +45,7 @@ pub mod summarization;
 pub mod acp;
 pub mod api_client;
 pub mod github;
+pub mod linear;
 pub mod mcp;
 
 // === NETWORK DISCOVERY ===
@@ -119,6 +120,7 @@ pub mod unified_exec;
 pub mod validation;
 pub mod version_utils;
 pub mod workspace;
+pub mod workspace_scripts;
 
 // Background terminal management (different from TUI terminal)
 pub mod terminal;

cortex-engine/src/linear/client.rs

@@ -7,7 +7,7 @@ use serde::{Deserialize, Serialize};
 use std::time::{Duration, Instant};
 use tokio::sync::Mutex;
 
-use crate::api_client::create_default_client;
+use cortex_common::create_default_client;
 
 /// Linear GraphQL endpoint.
 const LINEAR_GRAPHQL_ENDPOINT: &str = "https://api.linear.app/graphql";
@@ -32,7 +32,7 @@ pub struct LinearClient {
 impl LinearClient {
     /// Create a new authenticated Linear client.
     pub fn new(token: &str) -> Result<Self> {
-        let client = create_default_client().context("Failed to create HTTP client")?;
+        let client = create_default_client().map_err(|e| anyhow::anyhow!(e))?;
 
         Ok(Self {
             client,

cortex-gui/src-tauri/Cargo.toml

@@ -26,8 +26,8 @@ tauri-plugin-fs = "2"
 tauri-plugin-shell = "2"
 
 # Workspace dependencies
-cortex-engine = { workspace = true }
-cortex-protocol = { workspace = true }
+cortex-engine = { path = "../../cortex-engine" }
+cortex-protocol = { path = "../../cortex-protocol" }
 
 # Async runtime
 tokio.workspace = true

cortex-gui/src-tauri/src/commands/linear.rs

@@ -1,90 +1,206 @@
-//! Linear integration commands - DISABLED
-//!
-//! This module is disabled because cortex_engine::linear is not available in cortex-cli.
-//! The linear module exists in cortex-app but was not migrated to cortex-cli.
-//! 
-//! To re-enable this feature, the linear module would need to be copied from cortex-app
-//! and all its dependencies resolved in cortex-cli's cortex-engine.
+//! Linear integration commands.
+
+use cortex_engine::linear::client::{Issue, IssueDetails, LinearClient, Team};
+use keyring::Entry;
+use serde::Deserialize;
+use std::env;
+use tauri::State;
 
 use crate::error::CommandError;
+use crate::state::AppState;
+
+const SERVICE_NAME: &str = "cortex-linear";
+const USER_NAME: &str = "auth-token";
+
+/// Get Linear token from keychain or environment.
+fn get_linear_token() -> Result<String, CommandError> {
+    if let Ok(token) = env::var("LINEAR_API_KEY") {
+        return Ok(token);
+    }
+
+    let entry = Entry::new(SERVICE_NAME, USER_NAME)
+        .map_err(|e| CommandError::EngineError(format!("Failed to access keychain: {}", e)))?;
 
-/// Placeholder for linear_set_token - feature disabled
+    match entry.get_password() {
+        Ok(token) => Ok(token),
+        Err(keyring::Error::NoEntry) => Err(CommandError::ValidationError(
+            "Linear token not found. Please sign in.".to_string(),
+        )),
+        Err(e) => Err(CommandError::EngineError(format!(
+            "Failed to retrieve token: {}",
+            e
+        ))),
+    }
+}
+
+/// Store Linear token in keychain.
 #[tauri::command]
-pub async fn linear_set_token(_token: String) -> Result<(), CommandError> {
-    Err(CommandError::EngineError(
-        "Linear integration is not available in this build".to_string(),
-    ))
+pub async fn linear_set_token(token: String) -> Result<(), CommandError> {
+    let entry = Entry::new(SERVICE_NAME, USER_NAME)
+        .map_err(|e| CommandError::EngineError(format!("Failed to access keychain: {}", e)))?;
+
+    entry
+        .set_password(&token)
+        .map_err(|e| CommandError::EngineError(format!("Failed to store token: {}", e)))?;
+
+    Ok(())
 }
 
-/// Placeholder for linear_logout - feature disabled
+/// Remove Linear token from keychain.
 #[tauri::command]
 pub async fn linear_logout() -> Result<(), CommandError> {
-    Err(CommandError::EngineError(
-        "Linear integration is not available in this build".to_string(),
-    ))
+    let entry = Entry::new(SERVICE_NAME, USER_NAME)
+        .map_err(|e| CommandError::EngineError(format!("Failed to access keychain: {}", e)))?;
+
+    match entry.delete_credential() {
+        Ok(_) => Ok(()),
+        Err(keyring::Error::NoEntry) => Ok(()),
+        Err(e) => Err(CommandError::EngineError(format!(
+            "Failed to delete token: {}",
+            e
+        ))),
+    }
 }
 
-/// Placeholder for linear_check_auth - feature disabled
+/// Check if user is authenticated with Linear.
 #[tauri::command]
 pub async fn linear_check_auth() -> Result<bool, CommandError> {
-    Err(CommandError::EngineError(
-        "Linear integration is not available in this build".to_string(),
-    ))
+    match get_linear_token() {
+        Ok(_) => Ok(true),
+        Err(_) => Ok(false),
+    }
 }
 
-/// Placeholder for linear_auth_url - feature disabled
+/// Get Linear OAuth URL.
 #[tauri::command]
 pub async fn linear_auth_url(
-    _client_id: String,
-    _redirect_uri: String,
-    _state: String,
+    client_id: String,
+    redirect_uri: String,
+    state: String,
 ) -> Result<String, CommandError> {
-    Err(CommandError::EngineError(
-        "Linear integration is not available in this build".to_string(),
+    Ok(format!(
+        "{}?client_id={}&redirect_uri={}&response_type=code&state={}&scope=read,write",
+        cortex_engine::linear::client::LINEAR_OAUTH_AUTHORIZE,
+        client_id,
+        redirect_uri,
+        state
     ))
 }
 
-/// Placeholder for linear_exchange_token - feature disabled
+/// Exchange OAuth code for token.
 #[tauri::command]
 pub async fn linear_exchange_token(
-    _code: String,
-    _client_id: String,
-    _client_secret: String,
-    _redirect_uri: String,
+    code: String,
+    client_id: String,
+    client_secret: String,
+    redirect_uri: String,
 ) -> Result<String, CommandError> {
-    Err(CommandError::EngineError(
-        "Linear integration is not available in this build".to_string(),
-    ))
+    let client = reqwest::Client::new();
+
+    let params = [
+        ("code", code),
+        ("client_id", client_id),
+        ("client_secret", client_secret),
+        ("redirect_uri", redirect_uri),
+        ("grant_type", "authorization_code".to_string()),
+    ];
+
+    let response = client
+        .post(cortex_engine::linear::client::LINEAR_OAUTH_TOKEN)
+        .form(&params)
+        .send()
+        .await
+        .map_err(|e| CommandError::EngineError(format!("Failed to send token request: {}", e)))?;
+
+    if !response.status().is_success() {
+        let body = response.text().await.unwrap_or_default();
+        return Err(CommandError::EngineError(format!(
+            "Token exchange failed: {}",
+            body
+        )));
+    }
+
+    #[derive(Deserialize)]
+    struct TokenResponse {
+        access_token: String,
+    }
+
+    let token_res: TokenResponse = response
+        .json()
+        .await
+        .map_err(|e| CommandError::EngineError(format!("Failed to parse token response: {}", e)))?;
+
+    linear_set_token(token_res.access_token.clone()).await?;
+
+    Ok(token_res.access_token)
 }
 
-/// Placeholder for linear_get_teams - feature disabled
+/// Get all teams.
 #[tauri::command]
-pub async fn linear_get_teams() -> Result<Vec<String>, CommandError> {
-    Err(CommandError::EngineError(
-        "Linear integration is not available in this build".to_string(),
-    ))
+pub async fn linear_get_teams(_state: State<'_, AppState>) -> Result<Vec<Team>, CommandError> {
+    let token = get_linear_token()?;
+    let client = LinearClient::new(&token)
+        .map_err(|e| CommandError::EngineError(format!("Failed to create Linear client: {}", e)))?;
+
+    client
+        .get_teams()
+        .await
+        .map_err(|e| CommandError::EngineError(format!("Failed to get teams: {}", e)))
 }
 
-/// Placeholder for linear_get_issues - feature disabled
+/// Get issues for a team.
 #[tauri::command]
-pub async fn linear_get_issues(_team_id: String) -> Result<Vec<String>, CommandError> {
-    Err(CommandError::EngineError(
-        "Linear integration is not available in this build".to_string(),
-    ))
+pub async fn linear_get_issues(
+    _state: State<'_, AppState>,
+    team_id: String,
+) -> Result<Vec<Issue>, CommandError> {
+    let token = get_linear_token()?;
+    let client = LinearClient::new(&token)
+        .map_err(|e| CommandError::EngineError(format!("Failed to create Linear client: {}", e)))?;
+
+    client
+        .get_issues(&team_id)
+        .await
+        .map_err(|e| CommandError::EngineError(format!("Failed to get issues: {}", e)))
 }
 
-/// Placeholder for linear_get_issue_details - feature disabled
+/// Get issue details.
 #[tauri::command]
-pub async fn linear_get_issue_details(_issue_id: String) -> Result<String, CommandError> {
-    Err(CommandError::EngineError(
-        "Linear integration is not available in this build".to_string(),
-    ))
+pub async fn linear_get_issue_details(
+    _state: State<'_, AppState>,
+    issue_id: String,
+) -> Result<IssueDetails, CommandError> {
+    let token = get_linear_token()?;
+    let client = LinearClient::new(&token)
+        .map_err(|e| CommandError::EngineError(format!("Failed to create Linear client: {}", e)))?;
+
+    client
+        .get_issue_details(&issue_id)
+        .await
+        .map_err(|e| CommandError::EngineError(format!("Failed to get issue details: {}", e)))
 }
 
-/// Placeholder for linear_create_session_from_issue - feature disabled
+/// Create a session from a Linear issue.
 #[tauri::command]
-pub async fn linear_create_session_from_issue(_issue_id: String) -> Result<String, CommandError> {
-    Err(CommandError::EngineError(
-        "Linear integration is not available in this build".to_string(),
-    ))
+pub async fn linear_create_session_from_issue(
+    _state: State<'_, AppState>,
+    issue_id: String,
+) -> Result<String, CommandError> {
+    let token = get_linear_token()?;
+    let client = LinearClient::new(&token)
+        .map_err(|e| CommandError::EngineError(format!("Failed to create Linear client: {}", e)))?;
+
+    let issue = client
+        .get_issue_details(&issue_id)
+        .await
+        .map_err(|e| CommandError::EngineError(format!("Failed to get issue details: {}", e)))?;
+
+    let prompt = format!(
+        "I'm working on Linear issue {}: {}\n\nDescription:\n{}\n\nPlease help me implement this.",
+        issue.identifier,
+        issue.title,
+        issue.description.unwrap_or_default()
+    );
+
+    Ok(prompt)
 }

cortex-gui/src-tauri/src/commands/mod.rs

@@ -8,7 +8,7 @@ pub mod context;
 pub mod files;
 pub mod git;
 pub mod github;
-// pub mod linear;  // DISABLED: cortex_engine::linear not available in cortex-cli
+pub mod linear;
 pub mod mcp;
 pub mod message;
 pub mod plan;
@@ -17,12 +17,12 @@ pub mod share;
 pub mod submit;
 pub mod terminal;
 pub mod tools;
-// pub mod workspace_scripts;  // DISABLED: cortex_engine::workspace_scripts not available in cortex-cli
+pub mod workspace_scripts;
 
 // Re-export command handlers for registration in lib.rs
 pub use message::{interrupt_session, submit_message};
 pub use session::{create_session, delete_session, get_session, list_sessions};
 pub use tools::approve_tool;
-// pub use workspace_scripts::{  // DISABLED: cortex_engine::workspace_scripts not available in cortex-cli
-//     check_scripts_exist, run_archive_script, run_dev_script, run_setup_script,
-// };
+pub use workspace_scripts::{
+    check_scripts_exist, run_archive_script, run_dev_script, run_setup_script,
+};