Skip to content

Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.

fix(cli): render filesystem modtimes locally (#2576)

Hao Zhe402d51f7c0ef
diff --git a/Cargo.lock b/Cargo.lock
index e721fe096..0ba9e32b9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3235,6 +3235,7 @@ version = "0.0.0"
dependencies = [
"anyhow",
"bytes",
+ "chrono",
"clap",
"colored",
"crossterm 0.28.1",
diff --git a/crates/ov_cli/Cargo.toml b/crates/ov_cli/Cargo.toml
index a3bcbf3d4..b912f5cdb 100644
--- a/crates/ov_cli/Cargo.toml
+++ b/crates/ov_cli/Cargo.toml
@@ -22,6 +22,7 @@ futures = "0.3"
colored = "2.1"
dirs = "5.0"
anyhow = "1.0"
+chrono = "0.4"
mime_guess = "2.0"
thiserror = "1.0"
unicode-width = "0.1"
diff --git a/crates/ov_cli/src/client.rs b/crates/ov_cli/src/client.rs
index 6f228e68f..af8699a4e 100644
--- a/crates/ov_cli/src/client.rs
+++ b/crates/ov_cli/src/client.rs
@@ -1362,6 +1362,9 @@ mod tests {
use reqwest::StatusCode;
use serde_json::json;
use std::collections::HashMap;
+ use tokio::io::{AsyncReadExt, AsyncWriteExt};
+ use tokio::net::TcpListener;
+ use tokio::sync::oneshot;
#[test]
fn timeout_config_calculation() {
@@ -1434,6 +1437,38 @@ mod tests {
assert!(body.get("revectorize").is_none());
}
+ #[tokio::test]
+ async fn ls_does_not_send_display_time_query() {
+ let (base_url, request_rx) = spawn_request_capture_server().await;
+ let client = HttpClient::new(base_url, None, None, None, 5.0, false, None);
+
+ client
+ .ls("viking://resources", false, false, "agent", 256, false, 1)
+ .await
+ .expect("ls request should succeed");
+
+ let request = request_rx.await.expect("request should be captured");
+ assert!(request.starts_with("GET /api/v1/fs/ls?"));
+ assert!(!request.contains("tz="));
+ assert!(!request.contains("include_mod_time_iso="));
+ }
+
+ #[tokio::test]
+ async fn tree_does_not_send_display_time_query() {
+ let (base_url, request_rx) = spawn_request_capture_server().await;
+ let client = HttpClient::new(base_url, None, None, None, 5.0, false, None);
+
+ client
+ .tree("viking://resources", "agent", 256, false, 1, 3)
+ .await
+ .expect("tree request should succeed");
+
+ let request = request_rx.await.expect("request should be captured");
+ assert!(request.starts_with("GET /api/v1/fs/tree?"));
+ assert!(!request.contains("tz="));
+ assert!(!request.contains("include_mod_time_iso="));
+ }
+
#[test]
fn standard_error_envelope_formats_api_error() {
let body = json!({
@@ -1493,4 +1528,34 @@ mod tests {
assert_eq!(result, json!("content"));
}
+
+ async fn spawn_request_capture_server() -> (String, oneshot::Receiver<String>) {
+ let listener = TcpListener::bind("127.0.0.1:0")
+ .await
+ .expect("test server should bind");
+ let addr = listener.local_addr().expect("test server should have addr");
+ let (request_tx, request_rx) = oneshot::channel();
+
+ tokio::spawn(async move {
+ let Ok((mut stream, _)) = listener.accept().await else {
+ return;
+ };
+ let mut buffer = vec![0; 4096];
+ let Ok(read) = stream.read(&mut buffer).await else {
+ return;
+ };
+ let request = String::from_utf8_lossy(&buffer[..read]).to_string();
+ let _ = request_tx.send(request);
+
+ let body = r#"{"status":"ok","result":[]}"#;
+ let response = format!(
+ "HTTP/1.1 200 OK\r\ncontent-type: application/json\r\ncontent-length: {}\r\nconnection: close\r\n\r\n{}",
+ body.len(),
+ body
+ );
+ let _ = stream.write_all(response.as_bytes()).await;
+ });
+
+ (format!("http://{addr}"), request_rx)
+ }
}
diff --git a/crates/ov_cli/src/commands/filesystem.rs b/crates/ov_cli/src/commands/filesystem.rs
index 9c8b8a168..bf557ad3f 100644
--- a/crates/ov_cli/src/commands/filesystem.rs
+++ b/crates/ov_cli/src/commands/filesystem.rs
@@ -3,6 +3,7 @@ use crate::client::HttpClient;
use crate::error::Result;
use crate::output::{OutputFormat, output_success};
use crate::theme;
+use chrono::{DateTime, Local};
use colored::Colorize;
use serde_json::Value;
use std::io::IsTerminal;
@@ -156,7 +157,7 @@ fn filesystem_entries(value: &Value) -> Option<(Vec<&Value>, Option<&Value>)> {
fn render_ls_entry(rank: usize, entry: &Value, text_width: usize, lines: &mut Vec<String>) {
let object = entry.as_object();
- let metadata = entry_metadata(object, false);
+ let metadata = entry_metadata(object);
lines.push(format!(
"{}. {}",
theme::command(rank.to_string()).bold(),
@@ -207,10 +208,7 @@ fn render_tree_entry(rank: usize, entry: &Value, text_width: usize, lines: &mut
));
}
-fn entry_metadata(
- object: Option<&serde_json::Map<String, Value>>,
- compact_directory: bool,
-) -> Vec<String> {
+fn entry_metadata(object: Option<&serde_json::Map<String, Value>>) -> Vec<String> {
let mut metadata = vec![
theme::heading(if entry_is_dir(object) { "dir" } else { "file" })
.bold()
@@ -225,11 +223,7 @@ fn entry_metadata(
metadata.push(theme::value(format_size(size)).bold().to_string());
}
- if !compact_directory || !entry_is_dir(object) {
- if let Some(mod_time) = entry_string(object, "modTime") {
- metadata.push(theme::muted(mod_time).to_string());
- }
- } else if let Some(mod_time) = entry_string(object, "modTime") {
+ if let Some(mod_time) = entry_mod_time(object) {
metadata.push(theme::muted(mod_time).to_string());
}
@@ -265,8 +259,8 @@ fn tree_metadata(object: Option<&serde_json::Map<String, Value>>) -> Vec<String>
metadata.push(format_size(size));
}
- if let Some(mod_time) = entry_string(object, "modTime") {
- metadata.push(mod_time.to_string());
+ if let Some(mod_time) = entry_mod_time(object) {
+ metadata.push(mod_time);
}
metadata
@@ -323,6 +317,21 @@ fn entry_string<'a>(
.filter(|value| !value.is_empty())
}
+fn entry_mod_time(object: Option<&serde_json::Map<String, Value>>) -> Option<String> {
+ entry_string(object, "modTime").map(format_mod_time_for_display)
+}
+
+fn format_mod_time_for_display(value: &str) -> String {
+ // Agent output already contains compact dates/times; leave those unchanged.
+ DateTime::parse_from_rfc3339(value)
+ .map(|dt| {
+ dt.with_timezone(&Local)
+ .format("%Y-%m-%d %H:%M")
+ .to_string()
+ })
+ .unwrap_or_else(|_| value.to_string())
+}
+
fn is_directory_abstract_placeholder(value: &str) -> bool {
value.contains("[Directory abstract is not ready]")
}
@@ -510,6 +519,44 @@ mod tests {
}
}
+ #[test]
+ fn ls_table_output_renders_original_iso_modtime_in_local_timezone() {
+ let _tz = ScopedEnvVar::set("TZ", "Asia/Singapore");
+ let result = json!([
+ {
+ "uri": "viking://resources/hermes-agent/CONTRIBUTING.md",
+ "size": 44394,
+ "isDir": false,
+ "modTime": "2026-06-09T07:47:22Z",
+ "abstract": ""
+ }
+ ]);
+
+ let rendered = strip_ansi(&render_ls_entries_for_table(&result).expect("ls"));
+
+ assert!(rendered.contains("1. file · 43.4 KB · 2026-06-09 15:47"));
+ assert!(!rendered.contains("2026-06-09T07:47:22Z"));
+ }
+
+ #[test]
+ fn ls_table_output_renders_compact_raw_modtime_in_local_timezone() {
+ let _tz = ScopedEnvVar::set("TZ", "Asia/Singapore");
+ let result = json!([
+ {
+ "uri": "viking://resources/hermes-agent/CONTRIBUTING.md",
+ "size": 44394,
+ "isDir": false,
+ "modTime": "2026-06-10T16:30:17Z",
+ "abstract": ""
+ }
+ ]);
+
+ let rendered = strip_ansi(&render_ls_entries_for_table(&result).expect("ls"));
+
+ assert!(rendered.contains("1. file · 43.4 KB · 2026-06-11 00:30"));
+ assert!(!rendered.contains("2026-06-10T16:30:17Z"));
+ }
+
#[test]
fn tree_table_output_renders_indented_tree() {
let result = json!([
@@ -597,4 +644,32 @@ mod tests {
}
output
}
+
+ struct ScopedEnvVar {
+ key: &'static str,
+ previous: Option<String>,
+ }
+
+ impl ScopedEnvVar {
+ fn set(key: &'static str, value: &str) -> Self {
+ let previous = std::env::var(key).ok();
+ // Test-only process environment override; Drop restores the prior value.
+ unsafe {
+ std::env::set_var(key, value);
+ }
+ Self { key, previous }
+ }
+ }
+
+ impl Drop for ScopedEnvVar {
+ fn drop(&mut self) {
+ unsafe {
+ if let Some(previous) = &self.previous {
+ std::env::set_var(self.key, previous);
+ } else {
+ std::env::remove_var(self.key);
+ }
+ }
+ }
+ }
}
diff --git a/openviking/storage/viking_fs.py b/openviking/storage/viking_fs.py
index 07cd82679..291bbda4a 100644
--- a/openviking/storage/viking_fs.py
+++ b/openviking/storage/viking_fs.py
@@ -45,7 +45,7 @@ from openviking.storage.internal_names import (
STORAGE_INTERNAL_ENTRY_NAMES,
)
from openviking.telemetry import get_current_telemetry
-from openviking.utils.time_utils import format_simplified, get_current_timestamp, parse_iso_datetime
+from openviking.utils.time_utils import format_iso8601, get_current_timestamp, parse_iso_datetime
from openviking_cli.exceptions import (
FailedPreconditionError,
InvalidArgumentError,
@@ -1012,7 +1012,7 @@ class VikingFS:
[{'name': '.abstract.md', 'size': 100, 'mode': 420, 'modTime': '2026-02-11T16:52:16.256334192+08:00', 'isDir': False, 'rel_path': '.abstract.md', 'uri': 'viking://resources...'}]
output="agent"
- [{'uri': 'viking://resources...', 'size': 100, 'isDir': False, 'modTime': '2026-02-11 16:52:16', 'rel_path': '.abstract.md', 'abstract': "..."}]
+ [{'uri': 'viking://resources...', 'size': 100, 'isDir': False, 'modTime': '2026-02-11T08:52:16.256Z', 'rel_path': '.abstract.md', 'abstract': "..."}]
"""
self._ensure_access(uri, ctx)
if output == "original":
@@ -1068,7 +1068,6 @@ class VikingFS:
) -> List[Dict[str, Any]]:
"""Recursively list all contents (agent format with abstracts)."""
result = []
- now = datetime.now(timezone.utc)
async for entry, entry_uri in self._iter_visible_tree_entries(
uri,
@@ -1084,7 +1083,7 @@ class VikingFS:
"uri": entry_uri,
"size": 0 if is_dir else info["size"],
"isDir": is_dir,
- "modTime": format_simplified(parse_iso_datetime(info["modTime"]), now),
+ "modTime": format_iso8601(parse_iso_datetime(info["modTime"])),
"rel_path": entry["rel_path"],
}
)
@@ -2200,7 +2199,7 @@ class VikingFS:
[{'name': '.abstract.md', 'size': 100, 'mode': 420, 'modTime': '2026-02-11T16:52:16.256334192+08:00', 'isDir': False, 'meta': {'Name': 'localfs', 'Type': 'local', 'Content': None}, 'uri': 'viking://resources/.abstract.md'}]
output="agent"
- [{'name': '.abstract.md', 'size': 100, 'modTime': '2026-02-11(or 16:52:16 for today)', 'isDir': False, 'uri': 'viking://resources/.abstract.md', 'abstract': "..."}]
+ [{'name': '.abstract.md', 'size': 100, 'modTime': '2026-02-11T08:52:16.256Z', 'isDir': False, 'uri': 'viking://resources/.abstract.md', 'abstract': "..."}]
"""
self._ensure_access(uri, ctx)
if output == "original":
@@ -2226,14 +2225,14 @@ class VikingFS:
except Exception:
raise NotFoundError(uri, "directory")
# basic info
- now = datetime.now(timezone.utc)
+ fallback_time = datetime.now(timezone.utc)
all_entries = []
for entry in entries:
if len(all_entries) >= node_limit:
break
name = entry.get("name", "")
raw_time = entry.get("modTime", "")
- parsed_time = now
+ parsed_time = fallback_time
if isinstance(raw_time, (int, float)):
parsed_time = datetime.fromtimestamp(raw_time, tz=timezone.utc)
elif raw_time:
@@ -2248,7 +2247,7 @@ class VikingFS:
"uri": self._path_to_uri(f"{path}/{name}", ctx=ctx),
"size": 0 if is_dir else entry.get("size", 0),
"isDir": is_dir,
- "modTime": format_simplified(parsed_time, now),
+ "modTime": format_iso8601(parsed_time),
}
if not self._is_accessible(new_entry["uri"], real_ctx):
continue
diff --git a/tests/storage/test_viking_fs_tree.py b/tests/storage/test_viking_fs_tree.py
index 6a024ab93..4b00e7407 100644
--- a/tests/storage/test_viking_fs_tree.py
+++ b/tests/storage/test_viking_fs_tree.py
@@ -1,9 +1,12 @@
# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
# SPDX-License-Identifier: AGPL-3.0
+from datetime import datetime, timezone
+
import pytest
from openviking.server.identity import RequestContext, Role
+from openviking.storage import viking_fs as viking_fs_module
from openviking.storage.viking_fs import VikingFS
from openviking_cli.session.user_id import UserIdentifier
@@ -12,6 +15,12 @@ class _DummyAgfs:
pass
+class _FixedDatetime(datetime):
+ @classmethod
+ def now(cls, tz=None):
+ return cls(2026, 6, 11, 1, 0, 0, tzinfo=timezone.utc)
+
+
def _default_ctx() -> RequestContext:
return RequestContext(user=UserIdentifier.the_default_user(), role=Role.ROOT)
@@ -490,15 +499,71 @@ async def test_tree_agent_non_dir_abstract_empty(monkeypatch, fs):
@pytest.mark.asyncio
-async def test_tree_agent_modtime_formatted(monkeypatch, fs):
- """PY-AGENT-003: modTime is formatted via format_simplified."""
+async def test_tree_agent_modtime_is_raw_utc_iso(monkeypatch, fs):
+ """PY-AGENT-003: modTime is returned as a raw UTC timestamp."""
entries = [
make_entry("/local/test_account/resources/a", "a", size=100, mode=0o644, is_dir=False)
]
patch_tree_env(monkeypatch, fs, entries, batch_fetch=default_batch_fetch)
result = await fs._tree_agent("viking://resources", abs_limit=256, ctx=_default_ctx())
- assert result[0]["modTime"] == "2026-01-01"
+ assert result[0]["modTime"] == "2026-01-01T00:00:00.000Z"
+
+
+async def test_tree_agent_normalizes_modtime_to_utc(monkeypatch, fs):
+ entries = [
+ make_entry(
+ "/local/test_account/resources/a",
+ "a",
+ size=100,
+ mode=0o644,
+ mod_time="2026-06-11T00:30:17+08:00",
+ is_dir=False,
+ )
+ ]
+ patch_tree_env(monkeypatch, fs, entries, batch_fetch=default_batch_fetch)
+ monkeypatch.setattr(viking_fs_module, "datetime", _FixedDatetime)
+
+ result = await fs._tree_agent(
+ "viking://resources",
+ abs_limit=256,
+ ctx=_default_ctx(),
+ )
+
+ assert set(result[0].keys()) == {"uri", "size", "isDir", "modTime", "rel_path", "abstract"}
+ assert result[0]["modTime"] == "2026-06-10T16:30:17.000Z"
+
+
+async def test_ls_agent_modtime_is_raw_utc_iso(monkeypatch, fs):
+ async def fake_ls_entries(_path, **_kwargs):
+ return [
+ {
+ "name": "a.md",
+ "size": 100,
+ "mode": 0o644,
+ "modTime": "2026-06-11T00:30:17+08:00",
+ "isDir": False,
+ }
+ ]
+
+ monkeypatch.setattr(fs, "_uri_to_path", lambda _uri, **_kwargs: "/local/test_account/resources")
+ monkeypatch.setattr(fs, "_ls_entries", fake_ls_entries)
+ monkeypatch.setattr(fs, "_path_to_uri", _std_path_to_uri)
+ monkeypatch.setattr(fs, "_is_accessible", lambda _uri, _ctx: True)
+ monkeypatch.setattr(fs, "_batch_fetch_abstracts", default_batch_fetch)
+ monkeypatch.setattr(viking_fs_module, "datetime", _FixedDatetime)
+
+ result = await fs._ls_agent(
+ "viking://resources",
+ abs_limit=256,
+ show_all_hidden=False,
+ ctx=_default_ctx(),
+ )
+
+ assert set(result[0].keys()) == {"uri", "size", "isDir", "modTime", "abstract"}
+ assert result[0]["modTime"] == "2026-06-10T16:30:17.000Z"
@pytest.mark.asyncio