dirsql 0.4.110__tar.gz → 0.4.111__tar.gz

{dirsql-0.4.110 → dirsql-0.4.111}/Cargo.lock

@@ -573,7 +573,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql"
-version = "0.4.110"
+version = "0.4.111"
 dependencies = [
  "assert_cmd",
  "axum",
@@ -625,7 +625,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.4.110"
+version = "0.4.111"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.4.110 → dirsql-0.4.111}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.4.110
+Version: 0.4.111
 Requires-Dist: bin-shim>=0.1
 Summary: Ephemeral SQL index over a local directory
 Keywords: sql,filesystem,directory,sqlite,index

{dirsql-0.4.110 → dirsql-0.4.111}/docs/reference/cli.md

@@ -237,6 +237,22 @@ On startup the server prints `Running at <host>:<port>` to stdout. It runs
 until it receives `SIGINT` (Ctrl-C) or `SIGTERM`, then drains in-flight
 requests, closes open `/events` streams, and exits.
 
+Pass `--frontend` to serve the bundled dirsql SQL explorer shell at `/` on
+the same origin as the HTTP API. It works offline and prints `Frontend at
+http://<host>:<actual-port>/` without opening a browser. With `--port 0`, the
+printed URL uses the assigned port. The initial shell shows server status;
+query controls are coming in a subsequent update.
+
+```bash
+dirsql server --frontend
+dirsql server --frontend -c .dirsql.toml
+```
+
+The shell reads `GET /frontend/state`: `{"error":null}` when the index is
+ready, or HTTP `503` with `{"error":"<diagnostic>"}` when config loading
+fails. Fix the config and restart the server. Without `--frontend`, the `/`
+and `/frontend/state` routes return `404`.
+
 ### Flags
 
 Config flags are subcommand-local: pass them after `server`
@@ -247,6 +263,7 @@ Config flags are subcommand-local: pass them after `server`
 | `-c, --config <path>` | none | Path to a [config file](./config.md). **Repeatable** (`-c a -c b`): the configs load and merge in argv order — see [Composing multiple configs](./config.md#composing-multiple-configs). The index root is the **invocation directory** (the current working directory) and governs path-tables; a config's `[[table]]` globs anchor at **that config's own directory** (see [glob anchor](./config.md#glob-anchor)), so `--config /elsewhere/.dirsql.toml` indexes `/elsewhere`, from any working directory. With none given, **no named tables are defined** — query the filesystem with a [path-table](./path-tables.md) (`FROM './'`). A `./.dirsql.toml` on disk is **not** auto-loaded; pass it explicitly. A `-c` naming a file that does not exist is an [error](#degraded-mode). |
 | `--host <addr>` | `localhost` | Bind address. |
 | `--port <n>` | `7117` | TCP port to bind. |
+| `--frontend` | off | Serve the bundled SQL explorer shell and print its URL. |
 | `--cors-origin <origin>` | off | Let browser pages on `<origin>` (an exact origin such as `http://localhost:3202`, or `*` for any) call `/query` and open `/events`. See [Cross-origin requests](#cross-origin-requests). |
 | `--persist [<path>]` | off | Keep the SQLite index on disk between runs so a restart only re-parses files that actually changed. Bare `--persist` caches under the platform cache directory (`$XDG_CACHE_HOME/dirsql/<root hash>/cache.db` on Linux), outside the root; `--persist <path>` caches at `<path>`. Off by default (the index is ephemeral). Also available on [`dirsql query`](#dirsql-query). See [Keep the index across restarts](../howto/persist.md). |
 | `--no-ignore` | off | Scan files a `.gitignore` would hide. [Path-tables](./path-tables.md#skip-rules) respect `.gitignore` files by default; this flag restores the full walk. The built-in `.git` skip and configured `ignore` patterns still apply. Also available on [`dirsql query`](#dirsql-query). |

{dirsql-0.4.110 → dirsql-0.4.111}/packages/python/Cargo.toml

@@ -4,7 +4,7 @@ name = "dirsql-py-ext"
 # pypi/maturin handler can rewrite it via `write-version` before
 # `maturin build`. `pyproject.toml` declares `dynamic = ["version"]`
 # and maturin reads this field. Mirrors `packages/rust/Cargo.toml`.
-version = "0.4.110"
+version = "0.4.111"
 # abi3 note: the `abi3-py310` pyo3 feature (below) builds ONE stable-ABI
 # `cp310-abi3` wheel per platform that loads on every CPython >= 3.10
 # (matching `pyproject.toml`'s `requires-python = ">=3.10"`), instead of

{dirsql-0.4.110/packages/rust → dirsql-0.4.111/packages/python}/docs/reference/cli.md

@@ -237,6 +237,22 @@ On startup the server prints `Running at <host>:<port>` to stdout. It runs
 until it receives `SIGINT` (Ctrl-C) or `SIGTERM`, then drains in-flight
 requests, closes open `/events` streams, and exits.
 
+Pass `--frontend` to serve the bundled dirsql SQL explorer shell at `/` on
+the same origin as the HTTP API. It works offline and prints `Frontend at
+http://<host>:<actual-port>/` without opening a browser. With `--port 0`, the
+printed URL uses the assigned port. The initial shell shows server status;
+query controls are coming in a subsequent update.
+
+```bash
+dirsql server --frontend
+dirsql server --frontend -c .dirsql.toml
+```
+
+The shell reads `GET /frontend/state`: `{"error":null}` when the index is
+ready, or HTTP `503` with `{"error":"<diagnostic>"}` when config loading
+fails. Fix the config and restart the server. Without `--frontend`, the `/`
+and `/frontend/state` routes return `404`.
+
 ### Flags
 
 Config flags are subcommand-local: pass them after `server`
@@ -247,6 +263,7 @@ Config flags are subcommand-local: pass them after `server`
 | `-c, --config <path>` | none | Path to a [config file](./config.md). **Repeatable** (`-c a -c b`): the configs load and merge in argv order — see [Composing multiple configs](./config.md#composing-multiple-configs). The index root is the **invocation directory** (the current working directory) and governs path-tables; a config's `[[table]]` globs anchor at **that config's own directory** (see [glob anchor](./config.md#glob-anchor)), so `--config /elsewhere/.dirsql.toml` indexes `/elsewhere`, from any working directory. With none given, **no named tables are defined** — query the filesystem with a [path-table](./path-tables.md) (`FROM './'`). A `./.dirsql.toml` on disk is **not** auto-loaded; pass it explicitly. A `-c` naming a file that does not exist is an [error](#degraded-mode). |
 | `--host <addr>` | `localhost` | Bind address. |
 | `--port <n>` | `7117` | TCP port to bind. |
+| `--frontend` | off | Serve the bundled SQL explorer shell and print its URL. |
 | `--cors-origin <origin>` | off | Let browser pages on `<origin>` (an exact origin such as `http://localhost:3202`, or `*` for any) call `/query` and open `/events`. See [Cross-origin requests](#cross-origin-requests). |
 | `--persist [<path>]` | off | Keep the SQLite index on disk between runs so a restart only re-parses files that actually changed. Bare `--persist` caches under the platform cache directory (`$XDG_CACHE_HOME/dirsql/<root hash>/cache.db` on Linux), outside the root; `--persist <path>` caches at `<path>`. Off by default (the index is ephemeral). Also available on [`dirsql query`](#dirsql-query). See [Keep the index across restarts](../howto/persist.md). |
 | `--no-ignore` | off | Scan files a `.gitignore` would hide. [Path-tables](./path-tables.md#skip-rules) respect `.gitignore` files by default; this flag restores the full walk. The built-in `.git` skip and configured `ignore` patterns still apply. Also available on [`dirsql query`](#dirsql-query). |

dirsql-0.4.111/packages/python/e2e-attestations/bot-1469-ci-speed-sanity-1009.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/release_speed_test.py -x -q",
+  "ran_at": 1791556899,
+  "exit_code": 0,
+  "commit": "f4ef45b80656a68f454aafdcacc9b56cd555b917",
+  "branch": "bot/1469-ci-speed-sanity-1009"
+}

dirsql-0.4.111/packages/python/e2e-attestations/bot-1503-bench-watch-1011.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m tests.e2e.bench_suite --pairs 5 --out /tmp/bench-1503 -k watch",
+  "ran_at": 1791769095,
+  "exit_code": 0,
+  "commit": "409ebb5a7e1da55d1516983fcd936cae7fdc952c",
+  "branch": "bot/1503-bench-watch-1011"
+}

dirsql-0.4.111/packages/python/e2e-attestations/bot-issue-1486-frontend-20261009.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/cli_version_test.py tests/e2e/query_contract_test.py tests/e2e/fanout_test.py tests/e2e/extension_package_test.py -x -q",
+  "ran_at": 1791556016,
+  "exit_code": 0,
+  "commit": "fc84f87effcd648162d3c143d308bc0c24222dcb",
+  "branch": "bot/issue-1486-frontend-20261009"
+}

dirsql-0.4.111/packages/python/e2e-attestations/bot-speed-parse-paths-1009.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/frontmatter_parse_speed_test.py tests/e2e/jsonl_parse_speed_test.py tests/e2e/on_file_query_test.py tests/e2e/query_contract_test.py tests/e2e/fanout_test.py tests/e2e/declared_table_name_test.py tests/e2e/use_case_dossier_test.py tests/e2e/use_case_join_test.py tests/e2e/use_case_notebook_test.py tests/e2e/use_case_transcripts_test.py -x -q -s",
+  "ran_at": 1791560842,
+  "exit_code": 0,
+  "commit": "d5ea2e249e40f6b64e6eb1f799fc47d8290b795e",
+  "branch": "bot/speed-parse-paths-1009"
+}

dirsql-0.4.111/packages/python/e2e-attestations/bot-speed-walk-sched-1009.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/glob_speed_depth_bound_test.py tests/e2e/glob_speed_one_level_test.py tests/e2e/glob_speed_recursive_test.py tests/e2e/glob_speed_symlink_test.py -x -q",
+  "ran_at": 1791561608,
+  "exit_code": 0,
+  "commit": "d4ace79bbd16978ba199811907976d240ca55507",
+  "branch": "bot/speed-walk-sched-1009"
+}

{dirsql-0.4.110 → dirsql-0.4.111}/packages/python/tests/e2e/speed_of_light.py

@@ -415,3 +415,56 @@ def assert_speed_of_light(name, result, startup):
     assert median <= TOLERANCE, (
         f"bar native {result.bar}: {line}; median is over {TOLERANCE}x"
     )
+
+
+SLOWDOWN = 1.5
+RELEASE_PAIRS = 10
+ATTEMPTS = 3
+
+
+def release_ratios(pr, release, startup, pairs=RELEASE_PAIRS):
+    """Per-pair PR/release time ratios, each side net of its own startup.
+
+    `startup.dirsql` is the PR build's, `startup.native` the release's. One
+    discarded warm-up pair, then pairs alternate which build runs first.
+    """
+    release()
+    pr()
+    series = run_pairs({"release": release}, pr, pairs)
+    return pair_ratios(series.native_seconds["release"], series.dirsql_seconds, startup)
+
+
+def assert_no_slowdown(name, measure, threshold=SLOWDOWN, attempts=ATTEMPTS):
+    """Pass on the first attempt whose median ratio is within `threshold`.
+
+    Fails only when every attempt is over, so one noisy window on a shared
+    runner does not fail the check.
+    """
+    medians = []
+    for attempt in range(1, attempts + 1):
+        ratios = measure()
+        low, median, high, spread = summarize(ratios)
+        print(
+            f"SPEED {name} vs release: attempt {attempt}, {len(ratios)} pairs,"
+            f" ratio min {low:.3f} median {median:.3f} max {high:.3f}"
+            f" spread {spread:.0%}"
+        )
+        if median <= threshold:
+            return
+        medians.append(median)
+    shown = ", ".join(f"{median:.3f}" for median in medians)
+    raise AssertionError(
+        f"{name}: PR build is over {threshold}x the previous release on every"
+        f" attempt (median ratios {shown})"
+    )
+
+
+def install_release(dest):
+    """Install the latest published dirsql into a fresh venv at `dest`."""
+    subprocess.run(["uv", "venv", str(dest)], check=True, capture_output=True)
+    subprocess.run(
+        ["uv", "pip", "install", "--python", str(dest), "dirsql"],
+        check=True,
+        capture_output=True,
+    )
+    return dest / "bin" / "dirsql"

{dirsql-0.4.110 → dirsql-0.4.111}/packages/rust/Cargo.toml

@@ -6,7 +6,7 @@ description = "Ephemeral SQL index over a local directory"
 # version stays for the binding crates (publish = false). The literal
 # intentionally lags the published version: putitoutthere rewrites it to
 # the planned release version at build time and never commits it back.
-version = "0.4.110"
+version = "0.4.111"
 edition.workspace = true
 # Literal `license` (not `license.workspace = true`) because
 # putitoutthere's preflight check reads `[package].license` directly

{dirsql-0.4.110/packages/python → dirsql-0.4.111/packages/rust}/docs/reference/cli.md

@@ -237,6 +237,22 @@ On startup the server prints `Running at <host>:<port>` to stdout. It runs
 until it receives `SIGINT` (Ctrl-C) or `SIGTERM`, then drains in-flight
 requests, closes open `/events` streams, and exits.
 
+Pass `--frontend` to serve the bundled dirsql SQL explorer shell at `/` on
+the same origin as the HTTP API. It works offline and prints `Frontend at
+http://<host>:<actual-port>/` without opening a browser. With `--port 0`, the
+printed URL uses the assigned port. The initial shell shows server status;
+query controls are coming in a subsequent update.
+
+```bash
+dirsql server --frontend
+dirsql server --frontend -c .dirsql.toml
+```
+
+The shell reads `GET /frontend/state`: `{"error":null}` when the index is
+ready, or HTTP `503` with `{"error":"<diagnostic>"}` when config loading
+fails. Fix the config and restart the server. Without `--frontend`, the `/`
+and `/frontend/state` routes return `404`.
+
 ### Flags
 
 Config flags are subcommand-local: pass them after `server`
@@ -247,6 +263,7 @@ Config flags are subcommand-local: pass them after `server`
 | `-c, --config <path>` | none | Path to a [config file](./config.md). **Repeatable** (`-c a -c b`): the configs load and merge in argv order — see [Composing multiple configs](./config.md#composing-multiple-configs). The index root is the **invocation directory** (the current working directory) and governs path-tables; a config's `[[table]]` globs anchor at **that config's own directory** (see [glob anchor](./config.md#glob-anchor)), so `--config /elsewhere/.dirsql.toml` indexes `/elsewhere`, from any working directory. With none given, **no named tables are defined** — query the filesystem with a [path-table](./path-tables.md) (`FROM './'`). A `./.dirsql.toml` on disk is **not** auto-loaded; pass it explicitly. A `-c` naming a file that does not exist is an [error](#degraded-mode). |
 | `--host <addr>` | `localhost` | Bind address. |
 | `--port <n>` | `7117` | TCP port to bind. |
+| `--frontend` | off | Serve the bundled SQL explorer shell and print its URL. |
 | `--cors-origin <origin>` | off | Let browser pages on `<origin>` (an exact origin such as `http://localhost:3202`, or `*` for any) call `/query` and open `/events`. See [Cross-origin requests](#cross-origin-requests). |
 | `--persist [<path>]` | off | Keep the SQLite index on disk between runs so a restart only re-parses files that actually changed. Bare `--persist` caches under the platform cache directory (`$XDG_CACHE_HOME/dirsql/<root hash>/cache.db` on Linux), outside the root; `--persist <path>` caches at `<path>`. Off by default (the index is ephemeral). Also available on [`dirsql query`](#dirsql-query). See [Keep the index across restarts](../howto/persist.md). |
 | `--no-ignore` | off | Scan files a `.gitignore` would hide. [Path-tables](./path-tables.md#skip-rules) respect `.gitignore` files by default; this flag restores the full walk. The built-in `.git` skip and configured `ignore` patterns still apply. Also available on [`dirsql query`](#dirsql-query). |

dirsql-0.4.111/packages/rust/src/cli/frontend.html

@@ -0,0 +1,60 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>dirsql SQL explorer</title>
+  <style>
+    :root { color-scheme: light; font-family: ui-sans-serif, system-ui, sans-serif; background: #f4f6f4; color: #173026; }
+    * { box-sizing: border-box; }
+    body { margin: 0; min-height: 100vh; }
+    header { border-bottom: 1px solid #d9e1da; background: #fff; padding: 1.1rem max(1.5rem, calc((100vw - 56rem) / 2)); }
+    header strong { font-size: 1.15rem; letter-spacing: -.03em; }
+    main { max-width: 56rem; margin: 0 auto; padding: clamp(2rem, 7vw, 5rem) 1.5rem; }
+    h1 { font-size: clamp(2rem, 5vw, 3.4rem); line-height: 1.1; letter-spacing: -.055em; margin: 0 0 1rem; }
+    p { line-height: 1.6; color: #4a5d51; max-width: 42rem; }
+    .panel { margin-top: 2.5rem; padding: 1.5rem; border: 1px solid #d9e1da; border-radius: 12px; background: #fff; box-shadow: 0 3px 12px #17302609; }
+    .panel h2 { margin: 0 0 .5rem; font-size: 1rem; }
+    .panel p { margin: 0; }
+    .error { border-color: #d7a7a1; background: #fff8f7; }
+    .error h2 { color: #a0362a; }
+    .error pre { white-space: pre-wrap; overflow-wrap: anywhere; font: .9rem/1.5 ui-monospace, monospace; margin: .8rem 0; }
+  </style>
+</head>
+<body>
+  <header><strong>dirsql</strong></header>
+  <main>
+    <h1>dirsql SQL explorer</h1>
+    <p>Explore the files and tables in this directory with SQL.</p>
+    <section class="panel" id="state" aria-live="polite">
+      <h2 id="state-title">Connecting to dirsql…</h2>
+      <p id="state-message">Checking the server state.</p>
+    </section>
+  </main>
+  <script>
+    (async () => {
+      const panel = document.getElementById('state');
+      const title = document.getElementById('state-title');
+      const message = document.getElementById('state-message');
+      try {
+        const response = await fetch('/frontend/state');
+        const state = await response.json();
+        if (state.error) {
+          panel.classList.add('error');
+          title.textContent = 'Configuration could not load';
+          message.textContent = state.error + ' Fix the configuration and restart dirsql server.';
+        } else if (response.ok) {
+          title.textContent = 'Ready to explore';
+          message.textContent = 'The SQL explorer is connected to this directory.';
+        } else {
+          throw new Error('Unexpected server response');
+        }
+      } catch (error) {
+        panel.classList.add('error');
+        title.textContent = 'Could not connect';
+        message.textContent = error.message;
+      }
+    })();
+  </script>
+</body>
+</html>

{dirsql-0.4.110 → dirsql-0.4.111}/packages/rust/src/cli/mod.rs

@@ -62,6 +62,8 @@ pub struct ServerConfig {
     /// The `Access-Control-Allow-Origin` value sent on every response, or
     /// `None` to send no CORS headers (browsers then block cross-origin reads).
     pub cors_origin: Option<HeaderValue>,
+    /// Serve the bundled SQL explorer at `/` and its state at `/frontend/state`.
+    pub frontend: bool,
 }
 
 impl ServerConfig {
@@ -73,6 +75,7 @@ impl ServerConfig {
             port: 0,
             query_timeout: Duration::from_secs(30),
             cors_origin: None,
+            frontend: false,
         }
     }
 
@@ -83,6 +86,7 @@ impl ServerConfig {
             port,
             query_timeout: Duration::from_secs(30),
             cors_origin: None,
+            frontend: false,
         }
     }
 
@@ -99,6 +103,12 @@ impl ServerConfig {
         self.cors_origin = Some(origin);
         self
     }
+
+    /// Enable the bundled, same-origin SQL explorer.
+    pub fn with_frontend(mut self) -> Self {
+        self.frontend = true;
+        self
+    }
 }
 
 impl Default for ServerConfig {
@@ -212,6 +222,12 @@ mod tests {
         assert_eq!(cfg.cors_origin, Some(HeaderValue::from_static("*")));
     }
 
+    #[test]
+    fn frontend_is_opt_in() {
+        assert!(!ServerConfig::ephemeral().frontend);
+        assert!(ServerConfig::ephemeral().with_frontend().frontend);
+    }
+
     #[test]
     fn with_query_timeout_overrides_the_default() {
         let cfg = ServerConfig::bind("127.0.0.1", 8080).with_query_timeout(Duration::from_secs(5));

{dirsql-0.4.110 → dirsql-0.4.111}/packages/rust/src/cli/router.rs

@@ -8,13 +8,13 @@
 use std::sync::Arc;
 use std::time::Duration;
 
-use axum::Json;
 use axum::Router;
 use axum::extract::State;
 use axum::http::{HeaderValue, StatusCode, header};
 use axum::response::sse::{Event as SseEvent, KeepAlive, Sse};
 use axum::response::{IntoResponse, Response};
 use axum::routing::{get, post};
+use axum::{Json, response::Html};
 use futures::stream::StreamExt;
 use serde_json::json;
 use tokio::sync::{broadcast, watch};
@@ -33,8 +33,8 @@ pub(super) struct AppContext {
 
 pub(super) type SharedCtx = Arc<AppContext>;
 
-pub(super) fn router(ctx: SharedCtx) -> Router {
-    Router::new()
+pub(super) fn router(ctx: SharedCtx, frontend: bool) -> Router {
+    let mut app = Router::new()
         .route(
             "/query",
             post(handle_query).on(axum::routing::MethodFilter::GET, method_not_allowed),
@@ -42,8 +42,24 @@ pub(super) fn router(ctx: SharedCtx) -> Router {
         .route(
             "/events",
             get(handle_events).on(axum::routing::MethodFilter::POST, method_not_allowed),
+        );
+    if frontend {
+        app = app
+            .route("/", get(|| async { Html(include_str!("frontend.html")) }))
+            .route("/frontend/state", get(handle_frontend_state));
+    }
+    app.with_state(ctx)
+}
+
+async fn handle_frontend_state(State(ctx): State<SharedCtx>) -> Response {
+    match &ctx.state {
+        AppState::Ready(_) => Json(json!({ "error": null })).into_response(),
+        AppState::Unavailable(reason) => (
+            StatusCode::SERVICE_UNAVAILABLE,
+            Json(json!({ "error": reason })),
         )
-        .with_state(ctx)
+            .into_response(),
+    }
 }
 
 async fn handle_query(State(ctx): State<SharedCtx>, body: String) -> Response {
@@ -182,6 +198,23 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::SERVICE_UNAVAILABLE);
     }
 
+    #[tokio::test]
+    async fn frontend_routes_and_state_report_a_config_failure() {
+        let (events, _) = broadcast::channel::<String>(1);
+        let (_cancel_tx, cancel) = watch::channel(false);
+        let ctx = Arc::new(AppContext {
+            state: AppState::Unavailable("failed to load config".into()),
+            events,
+            watch_failure: None,
+            cancel,
+            query_timeout: Duration::from_secs(1),
+        });
+
+        assert!(router(ctx.clone(), true).has_routes());
+        let resp = handle_frontend_state(State(ctx)).await;
+        assert_eq!(resp.status(), StatusCode::SERVICE_UNAVAILABLE);
+    }
+
     #[test]
     fn error_response_sets_json_content_type() {
         let resp = error_response(StatusCode::BAD_REQUEST, "boom");

{dirsql-0.4.110 → dirsql-0.4.111}/packages/rust/src/cli/run.rs

@@ -177,6 +177,10 @@ enum Command {
 
 #[derive(Debug, Args)]
 struct ServerArgs {
+    /// Serve the bundled SQL explorer at the server URL (no browser opens).
+    #[arg(long)]
+    frontend: bool,
+
     /// Bind address.
     #[arg(long, default_value = "localhost")]
     host: String,
@@ -480,6 +484,9 @@ async fn run_server(
     if let Some(origin) = args.cors_origin {
         server_config = server_config.with_cors_origin(origin);
     }
+    if args.frontend {
+        server_config = server_config.with_frontend();
+    }
 
     let host = args.host.clone();
     let handle = match serve_with_state(server_config, state).await {
@@ -491,6 +498,12 @@ async fn run_server(
     };
 
     // Echo back the user-facing hostname (not the resolved IP SocketAddr).
+    if args.frontend {
+        println!(
+            "Frontend at {}",
+            frontend_url(&host, handle.local_addr().port())
+        );
+    }
     println!("Running at {host}:{}", handle.local_addr().port());
 
     if let Err(err) = shutdown.await {
@@ -504,6 +517,16 @@ async fn run_server(
     0
 }
 
+fn frontend_url(host: &str, port: u16) -> String {
+    let url_host = match host {
+        "0.0.0.0" => "localhost".to_string(),
+        "::" | "[::]" => "[::1]".to_string(),
+        _ if host.contains(':') && !host.starts_with('[') => format!("[{host}]"),
+        _ => host.to_string(),
+    };
+    format!("http://{url_host}:{port}/")
+}
+
 fn load_state(cfg: &ConfigArgs, path_table_parser: Option<String>) -> AppState {
     // No `-c` -> index the invocation directory with no named tables. A
     // `./.dirsql.toml` on disk is NOT consulted (#602); pass it explicitly
@@ -870,6 +893,16 @@ mod tests {
         }
     }
 
+    #[test]
+    fn frontend_url_uses_a_reachable_and_valid_host() {
+        assert_eq!(frontend_url("localhost", 7117), "http://localhost:7117/");
+        assert_eq!(frontend_url("0.0.0.0", 7117), "http://localhost:7117/");
+        assert_eq!(frontend_url("::", 7117), "http://[::1]:7117/");
+        assert_eq!(frontend_url("[::]", 7117), "http://[::1]:7117/");
+        assert_eq!(frontend_url("::1", 7117), "http://[::1]:7117/");
+        assert_eq!(frontend_url("[::1]", 7117), "http://[::1]:7117/");
+    }
+
     fn server_args(argv: &[&str]) -> ServerArgs {
         match Cli::parse_from(argv).command {
             Some(Command::Server(args)) => args,

{dirsql-0.4.110 → dirsql-0.4.111}/packages/rust/src/cli/server.rs

@@ -53,7 +53,7 @@ pub async fn serve_with_state(
         cancel: cancel_rx,
         query_timeout: config.query_timeout,
     });
-    let mut app = router(shared);
+    let mut app = router(shared, config.frontend);
     if let Some(origin) = config.cors_origin {
         app = app.layer(
             CorsLayer::new()