xai-org/grok-build · error · io::Error

{}

Error message

{}

What it means

persist_state_to_path_with_writer serializes the permission state with toml::to_string_pretty, then spawns a blocking task to run the caller-supplied writer. Two failure modes surface as the message '{}' (the Display of the inner error): a TOML serialization failure wrapped as InvalidData with the toml error text, or the blocking writer/spawn_blocking join failing, converted via std::io::Error::other. The '{}' is just the inner error's message. This is called from try_load_state_with_writer and persist_state_to_dir.

Source

Thrown at crates/codegen/xai-grok-workspace/src/permission/state.rs:377

        let sig = self.current_sig().await;
        if sig == self.last_sig {
            return None;
        }
        self.last_sig = sig;
        Some(self.read().await)
    }
}

async fn persist_state_to_path_with_writer<F>(
    path: &std::path::Path,
    state: &PermissionState,
    writer: F,
) -> std::io::Result<()>
where
    F: FnOnce(&std::path::Path, &str) -> std::io::Result<()> + Send + 'static,
{
    let contents = toml::to_string_pretty(state)
        .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))?;
    let path = path.to_path_buf();
    tokio::task::spawn_blocking(move || writer(&path, &contents))
        .await
        .map_err(std::io::Error::other)?
}

async fn persist_state_to_dir(
    dir: &std::path::Path,
    state: &PermissionState,
    client_identifier: Option<&str>,
) {
    let path = state_file_path(dir, client_identifier);
    let dir = dir.to_path_buf();
    // Owner-only dir creation rides the writer's spawn_blocking: GROK_HOME may
    // sit on a slow filesystem, so no blocking fs work on the async worker.
    let result = persist_state_to_path_with_writer(&path, state, move |path, contents| {
        xai_grok_config::create_dir_all_owner_only(&dir)?;
        xai_grok_config::fs_atomic::write_atomically(path, contents, None)

View on GitHub (pinned to bc7f02eddd)

Solutions

1. Read the inner '{}' message in the error to identify whether it's a toml error or a writer I/O error.
2. Fix the writer closure: ensure its target directory exists and is writable before persisting.
3. Ensure the tokio runtime is alive when persisting and the state type contains no non-serializable fields/keys.
4. Convert problematic map keys to strings in the state model so toml::to_string_pretty succeeds.
5. If panics in the writer are possible, wrap writer internals and return Err instead of panicking.

Example fix

// before
let path = PathBuf::from("/var/lib/state/permissions.toml"); // dir may not exist
persist_state_to_path_with_writer(&state, &path, write_fn).await?;
// after
std::fs::create_dir_all("/var/lib/state")?;
persist_state_to_path_with_writer(&state, &path, write_fn).await
    .map_err(|e| eprintln!("persist failed: {e}"))?;

fn can_persist(state: &PermissionState, path: &std::path::Path) -> Result<(), String> {
    toml::to_string_pretty(state).map(|_| ()).map_err(|e| e.to_string())?;
    if let Some(p) = path.parent() {
        if !p.exists() { return Err(format!("dir missing: {}", p.display())); }
    }
    Ok(())
}

match persist_state_to_path_with_writer(&state, &path, writer).await {
    Ok(()) => {}
    Err(e) => {
        // e displays as the inner toml/writer error ('{}')
        log::error!("state persist failed: {e}");
        // fall back to in-memory state or a backup location
        persist_to_backup(&state)?;
    }
}

When it happens

Trigger: Calling persist_state_to_path_with_writer (directly or via persist_state_to_dir / try_load_state_with_writer) when (a) the permission state contains data TOML cannot serialize (e.g. map keys that aren't string-like, unsupported types), or (b) the writer closure fails writing to its target (bad path, permissions, disk full), or (c) the blocking task panics or the runtime is shutting down.

Common situations: Custom writer closures pointing at read-only or nonexistent directories; state containing non-string keys or exotic types added to the permission model; calling persist during runtime shutdown so spawn_blocking join fails; toml serialization of state loaded from an older format.

Related errors

• Connection cancelled
• Authentication cancelled
• waiting on command: {e}
• failed to serialize MCP server {name}: {e}
• failed to serialize MCP server config: {e}

AI-assisted analysis of xai-org/grok-build@bc7f02eddd (2026-08-31). Data as JSON: /api/errors/3e2ecfaf4e886a2d. Report an issue: GitHub.