Skip to content

LLM Wiki is a cross-platform desktop application that turns your documents into an organized, interlinked knowledge base — automatically. Instead of traditional RAG (retrieve-and-answer from scratch every time), the LLM incrementally builds and maintains a persistent wiki from your sources。

TypeScript

fix: run Codex CLI from project root

nash_su7576a3a926a7
diff --git a/src-tauri/src/commands/codex_cli.rs b/src-tauri/src/commands/codex_cli.rs
index 212afeb1..37dc06f7 100644
--- a/src-tauri/src/commands/codex_cli.rs
+++ b/src-tauri/src/commands/codex_cli.rs
@@ -5,7 +5,7 @@
//! spawn this fixed command; it cannot execute arbitrary shell commands.
use std::collections::HashMap;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
use std::process::Stdio;
use std::sync::{
atomic::{AtomicBool, Ordering},
@@ -141,11 +141,13 @@ pub async fn codex_cli_spawn(
prompt: String,
isolate_local_config: bool,
timeout_minutes: Option<u64>,
+ working_directory: Option<String>,
) -> Result<(), String> {
if prompt.trim().is_empty() {
return Err("No prompt to send to codex CLI".to_string());
}
+ let working_directory = resolve_codex_working_directory(working_directory).await?;
let codex = find_codex_command().await?;
let mut cmd = Command::new(&codex);
suppress_windows_console(&mut cmd);
@@ -155,6 +157,7 @@ pub async fn codex_cli_spawn(
cmd.env("PATH", path_env);
}
cmd.args(build_codex_cli_args(&model, isolate_local_config));
+ cmd.current_dir(&working_directory);
cmd.stdin(Stdio::piped())
.stdout(Stdio::piped())
@@ -312,6 +315,39 @@ fn build_codex_cli_args(model: &str, isolate_local_config: bool) -> Vec<String>
args
}
+async fn resolve_codex_working_directory(value: Option<String>) -> Result<PathBuf, String> {
+ let raw = value
+ .as_deref()
+ .map(str::trim)
+ .filter(|v| !v.is_empty())
+ .map(str::to_string)
+ .ok_or_else(|| "Codex CLI requires an active project working directory".to_string())?;
+ let path = Path::new(raw.as_str());
+ if !path.is_absolute() {
+ return Err("Codex CLI working directory must be an absolute project path".to_string());
+ }
+ let path_meta = tokio::fs::metadata(path).await.map_err(|e| {
+ eprintln!("[codex-cli] failed to read working directory metadata {raw}: {e}");
+ format!("Codex CLI working directory does not exist or cannot be read: {raw}")
+ })?;
+ if !path_meta.is_dir() {
+ return Err(format!("Codex CLI working directory is not a directory: {raw}"));
+ }
+ let index_path = path.join("wiki").join("index.md");
+ let index_meta = tokio::fs::metadata(&index_path).await.map_err(|e| {
+ eprintln!("[codex-cli] failed to read wiki/index.md metadata for {raw}: {e}");
+ format!("Codex CLI working directory must be an LLM Wiki project containing wiki/index.md: {raw}")
+ })?;
+ if !index_meta.is_file() {
+ return Err(format!(
+ "Codex CLI working directory must be an LLM Wiki project containing wiki/index.md: {raw}"
+ ));
+ }
+ tokio::fs::canonicalize(path)
+ .await
+ .map_err(|e| format!("Failed to canonicalize Codex CLI working directory {raw}: {e}"))
+}
+
#[tauri::command]
pub async fn codex_cli_kill(
state: State<'_, CodexCliState>,
@@ -396,4 +432,87 @@ mod tests {
assert!(ignore_config_pos > exec_pos);
assert!(ignore_rules_pos > exec_pos);
}
+
+ struct TestDir(PathBuf);
+
+ impl Drop for TestDir {
+ fn drop(&mut self) {
+ let _ = std::fs::remove_dir_all(&self.0);
+ }
+ }
+
+ #[tokio::test]
+ async fn codex_working_directory_requires_absolute_existing_project() {
+ assert!(resolve_codex_working_directory(None)
+ .await
+ .unwrap_err()
+ .contains("requires an active project"));
+ assert!(resolve_codex_working_directory(Some("".to_string()))
+ .await
+ .unwrap_err()
+ .contains("requires an active project"));
+ assert!(resolve_codex_working_directory(Some(" ".to_string()))
+ .await
+ .unwrap_err()
+ .contains("requires an active project"));
+ assert!(resolve_codex_working_directory(Some("relative/project".to_string()))
+ .await
+ .unwrap_err()
+ .contains("absolute"));
+
+ let missing = std::env::temp_dir().join(format!(
+ "llm-wiki-codex-cli-missing-{}",
+ std::process::id()
+ ));
+ let _ = std::fs::remove_dir_all(&missing);
+ assert!(resolve_codex_working_directory(Some(missing.to_string_lossy().to_string()))
+ .await
+ .unwrap_err()
+ .contains("does not exist or cannot be read"));
+
+ let file_path = std::env::temp_dir().join(format!(
+ "llm-wiki-codex-cli-file-{}",
+ std::process::id()
+ ));
+ let _ = std::fs::remove_file(&file_path);
+ std::fs::write(&file_path, "not a directory").expect("temp file");
+ struct TestFile(PathBuf);
+ impl Drop for TestFile {
+ fn drop(&mut self) {
+ let _ = std::fs::remove_file(&self.0);
+ }
+ }
+ let _file_guard = TestFile(file_path.clone());
+ assert!(resolve_codex_working_directory(Some(file_path.to_string_lossy().to_string()))
+ .await
+ .unwrap_err()
+ .contains("not a directory"));
+
+ let dir = std::env::temp_dir().join(format!(
+ "llm-wiki-codex-cli-test-{}",
+ std::process::id()
+ ));
+ let _ = std::fs::remove_dir_all(&dir);
+ std::fs::create_dir_all(&dir).expect("tempdir");
+ let _guard = TestDir(dir.clone());
+ assert!(resolve_codex_working_directory(Some(dir.to_string_lossy().to_string()))
+ .await
+ .unwrap_err()
+ .contains("wiki/index.md"));
+
+ let wiki_dir = dir.join("wiki");
+ std::fs::create_dir_all(&wiki_dir).expect("wiki dir");
+ let index_dir = wiki_dir.join("index.md");
+ std::fs::create_dir_all(&index_dir).expect("index dir");
+ assert!(resolve_codex_working_directory(Some(dir.to_string_lossy().to_string()))
+ .await
+ .unwrap_err()
+ .contains("wiki/index.md"));
+ std::fs::remove_dir_all(&index_dir).expect("remove index dir");
+ std::fs::write(wiki_dir.join("index.md"), "# Index\n").expect("index");
+ let resolved = resolve_codex_working_directory(Some(dir.to_string_lossy().to_string()))
+ .await
+ .expect("valid project path");
+ assert_eq!(resolved, dir.canonicalize().expect("canonical tempdir"));
+ }
}
diff --git a/src/lib/codex-cli-transport.test.ts b/src/lib/codex-cli-transport.test.ts
index 86889453..acdadcb8 100644
--- a/src/lib/codex-cli-transport.test.ts
+++ b/src/lib/codex-cli-transport.test.ts
@@ -28,11 +28,19 @@ vi.mock("@tauri-apps/api/event", () => ({
}))
import { buildPrompt, parseCodexCliLine, streamCodexCli } from "./codex-cli-transport"
+import { useWikiStore } from "@/stores/wiki-store"
beforeEach(() => {
vi.clearAllMocks()
tauriMocks.reset()
tauriMocks.invoke.mockResolvedValue(undefined)
+ useWikiStore.setState({
+ project: {
+ id: "test-project",
+ name: "Test Project",
+ path: "/Users/me/default-wiki-project",
+ },
+ })
})
describe("parseCodexCliLine", () => {
@@ -293,6 +301,92 @@ describe("streamCodexCli", () => {
expect(callbacks.onError).not.toHaveBeenCalled()
})
+ it("passes the active project path as the Codex CLI working directory", async () => {
+ useWikiStore.setState({
+ project: {
+ id: "p1",
+ name: "Project One",
+ path: "/Users/me/wiki-project",
+ },
+ })
+ const callbacks = {
+ onToken: vi.fn(),
+ onDone: vi.fn(),
+ onError: vi.fn(),
+ }
+
+ const stream = streamCodexCli(
+ {
+ provider: "codex-cli",
+ apiKey: "",
+ model: "gpt-5.1-codex-mini",
+ ollamaUrl: "",
+ customEndpoint: "",
+ maxContextSize: 128000,
+ },
+ [{ role: "user", content: "Analyze this source." }],
+ callbacks,
+ )
+
+ await vi.waitFor(() => {
+ expect(tauriMocks.invoke).toHaveBeenCalledWith(
+ "codex_cli_spawn",
+ expect.objectContaining({ workingDirectory: "/Users/me/wiki-project" }),
+ )
+ })
+
+ const payload = tauriMocks.invoke.mock.calls[0]?.[1] as { streamId: string }
+ tauriMocks.emit(
+ `codex-cli:${payload.streamId}`,
+ JSON.stringify({
+ type: "item.completed",
+ item: { type: "agent_message", text: "project-aware analysis" },
+ }),
+ )
+ tauriMocks.emit(`codex-cli:${payload.streamId}:done`, {
+ code: 0,
+ stderr: "",
+ stdout: "",
+ })
+
+ await stream
+
+ expect(callbacks.onToken).toHaveBeenCalledWith("project-aware analysis")
+ expect(callbacks.onDone).toHaveBeenCalledTimes(1)
+ expect(callbacks.onError).not.toHaveBeenCalled()
+ })
+
+ it("surfaces a clear error when Codex CLI has no active project directory", async () => {
+ useWikiStore.setState({ project: null })
+ const callbacks = {
+ onToken: vi.fn(),
+ onDone: vi.fn(),
+ onError: vi.fn(),
+ }
+
+ await streamCodexCli(
+ {
+ provider: "codex-cli",
+ apiKey: "",
+ model: "gpt-5.1-codex-mini",
+ ollamaUrl: "",
+ customEndpoint: "",
+ maxContextSize: 128000,
+ },
+ [{ role: "user", content: "Analyze this source." }],
+ callbacks,
+ )
+
+ expect(tauriMocks.invoke).not.toHaveBeenCalled()
+ expect(callbacks.onToken).not.toHaveBeenCalled()
+ expect(callbacks.onDone).not.toHaveBeenCalled()
+ expect(callbacks.onError).toHaveBeenCalledWith(
+ expect.objectContaining({
+ message: expect.stringContaining("active project"),
+ }),
+ )
+ })
+
it("does not replay done stdout when a live agent message was already emitted", async () => {
const callbacks = {
onToken: vi.fn(),
diff --git a/src/lib/codex-cli-transport.ts b/src/lib/codex-cli-transport.ts
index 36d6cb1d..eef9b3ba 100644
--- a/src/lib/codex-cli-transport.ts
+++ b/src/lib/codex-cli-transport.ts
@@ -9,6 +9,7 @@
import { invoke } from "@tauri-apps/api/core"
import { listen, type UnlistenFn } from "@tauri-apps/api/event"
import type { LlmConfig } from "@/stores/wiki-store"
+import { useWikiStore } from "@/stores/wiki-store"
import type { ChatMessage, ContentBlock, RequestOverrides } from "./llm-providers"
import type { StreamCallbacks } from "./llm-client"
@@ -63,6 +64,7 @@ type SpawnPayload = Record<string, unknown> & {
prompt: string
isolateLocalConfig: boolean
timeoutMinutes?: number
+ workingDirectory?: string
}
export async function streamCodexCli(
@@ -194,12 +196,18 @@ export async function streamCodexCli(
if (aborted) return
+ const workingDirectory = useWikiStore.getState().project?.path
+ if (!workingDirectory) {
+ throw new Error("Codex CLI requires an active project working directory")
+ }
+
const payload: SpawnPayload = {
streamId,
model: config.model,
prompt: buildPrompt(messages),
isolateLocalConfig: config.localCliIsolation === true,
timeoutMinutes: config.codexCliTimeoutMinutes,
+ workingDirectory,
}
await invoke("codex_cli_spawn", payload)
if (aborted || signal?.aborted) {