sqlrooms 0.1.1__tar.gz → 0.1.3__tar.gz

{sqlrooms-0.1.1 → sqlrooms-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlrooms
-Version: 0.1.1
+Version: 0.1.3
 Summary: Local-first SQLRooms project launcher for DuckDB worksheets and Mosaic dashboards.
 Project-URL: homepage, https://sqlrooms.com
 Project-URL: repository, https://github.com/sqlrooms/sqlrooms
@@ -53,6 +53,7 @@ What happens:
 ## CLI flags
 
 - `DB_PATH` (positional): DuckDB project file to load/create (e.g. `sqlrooms ./my.db`). Required unless `--db-path` is provided.
+- `--version`: Print the installed `sqlrooms` CLI version and exit.
 - `--db-path`: DuckDB database to use as a flag alternative. Pass a filepath to persist, or `:memory:` for an explicit temporary in-memory session.
 - `--host` / `--port`: HTTP host/port for the UI. The default bind address is `127.0.0.1`. If `--port` is omitted, `3000` or the next free port is chosen automatically.
 - `--ws-port`: WebSocket port for DuckDB queries. If omitted, a free port is chosen automatically.
@@ -108,46 +109,6 @@ Then open the printed UI URL and verify:
 - Map, notebook, canvas, app, HTML app, pivot, and SQL query surfaces stay hidden unless `--experimental` is provided.
 - Restarting the same command with `./smoke.duckdb` restores the imported table and persisted workspace state.
 
-## Release workflow
-
-The Python CLI release is split into an intentional version step and a publish
-step. Publishing never bumps versions automatically.
-
-1. Choose the package target:
-   - `sqlrooms` for the CLI package and bundled UI.
-   - `sqlrooms-server` for the DuckDB websocket server package.
-   - `all` when both packages should be released in dependency order.
-2. Version the selected package or packages explicitly:
-
-   ```bash
-   pnpm cli:version --target sqlrooms-server --bump patch
-   pnpm cli:version --target sqlrooms --set 0.2.0
-   pnpm cli:version --target all --bump minor
-   ```
-
-   Hatch reads package versions from each package's `package.json`. When
-   `sqlrooms-server` is versioned, the workflow also updates the
-   `sqlrooms-server>=...` dependency floor in `python/sqlrooms/pyproject.toml`.
-
-3. Run the dry publish workflow for the intended target:
-
-   ```bash
-   pnpm cli:publish:dry --target sqlrooms
-   ```
-
-   The dry workflow runs the same validation and build steps as publish, but it
-   does not upload to PyPI.
-
-4. Publish the same target:
-
-   ```bash
-   pnpm cli:publish --target sqlrooms
-   ```
-
-   Publishing runs validation, builds the package, then uploads the built
-   distributions with Twine. Use `--target all` only when both packages are part
-   of the release.
-
 ## Config file
 
 `sqlrooms` reads AI provider and connector settings from a TOML config file.

{sqlrooms-0.1.1 → sqlrooms-0.1.3}/README.md

@@ -18,6 +18,7 @@ What happens:
 ## CLI flags
 
 - `DB_PATH` (positional): DuckDB project file to load/create (e.g. `sqlrooms ./my.db`). Required unless `--db-path` is provided.
+- `--version`: Print the installed `sqlrooms` CLI version and exit.
 - `--db-path`: DuckDB database to use as a flag alternative. Pass a filepath to persist, or `:memory:` for an explicit temporary in-memory session.
 - `--host` / `--port`: HTTP host/port for the UI. The default bind address is `127.0.0.1`. If `--port` is omitted, `3000` or the next free port is chosen automatically.
 - `--ws-port`: WebSocket port for DuckDB queries. If omitted, a free port is chosen automatically.
@@ -73,46 +74,6 @@ Then open the printed UI URL and verify:
 - Map, notebook, canvas, app, HTML app, pivot, and SQL query surfaces stay hidden unless `--experimental` is provided.
 - Restarting the same command with `./smoke.duckdb` restores the imported table and persisted workspace state.
 
-## Release workflow
-
-The Python CLI release is split into an intentional version step and a publish
-step. Publishing never bumps versions automatically.
-
-1. Choose the package target:
-   - `sqlrooms` for the CLI package and bundled UI.
-   - `sqlrooms-server` for the DuckDB websocket server package.
-   - `all` when both packages should be released in dependency order.
-2. Version the selected package or packages explicitly:
-
-   ```bash
-   pnpm cli:version --target sqlrooms-server --bump patch
-   pnpm cli:version --target sqlrooms --set 0.2.0
-   pnpm cli:version --target all --bump minor
-   ```
-
-   Hatch reads package versions from each package's `package.json`. When
-   `sqlrooms-server` is versioned, the workflow also updates the
-   `sqlrooms-server>=...` dependency floor in `python/sqlrooms/pyproject.toml`.
-
-3. Run the dry publish workflow for the intended target:
-
-   ```bash
-   pnpm cli:publish:dry --target sqlrooms
-   ```
-
-   The dry workflow runs the same validation and build steps as publish, but it
-   does not upload to PyPI.
-
-4. Publish the same target:
-
-   ```bash
-   pnpm cli:publish --target sqlrooms
-   ```
-
-   Publishing runs validation, builds the package, then uploads the built
-   distributions with Twine. Use `--target all` only when both packages are part
-   of the release.
-
 ## Config file
 
 `sqlrooms` reads AI provider and connector settings from a TOML config file.

{sqlrooms-0.1.1 → sqlrooms-0.1.3}/node_modules/sqlrooms-cli-app/README.md

@@ -18,9 +18,9 @@ cd /Users/ilya/Workspace/sqlrooms
 
 pnpm --dir python/sqlrooms build
 
-uv run --project python --package sqlrooms sqlrooms \
+uv run --project python/sqlrooms sqlrooms \
   --no-open-browser \
-  ./smoke.duckdb
+  /tmp/sqlrooms-smoke.duckdb
 ```
 
 Open the UI URL printed in the terminal. It should be
@@ -31,15 +31,15 @@ The bare CLI command works only after installing the CLI somewhere on your
 
 ```bash
 uv tool install /Users/ilya/Workspace/sqlrooms/python/sqlrooms
-sqlrooms --no-open-browser ./smoke.duckdb
+sqlrooms --no-open-browser /tmp/sqlrooms-smoke.duckdb
 ```
 
 For release smoke testing, verify both local execution paths:
 
 ```bash
-uv run --project python --package sqlrooms sqlrooms --no-open-browser ./smoke.duckdb
+uv run --project python/sqlrooms sqlrooms --no-open-browser /tmp/sqlrooms-smoke.duckdb
 uv tool install --reinstall /Users/ilya/Workspace/sqlrooms/python/sqlrooms
-sqlrooms --no-open-browser ./smoke.duckdb
+sqlrooms --no-open-browser /tmp/sqlrooms-smoke.duckdb
 ```
 
 In the UI, drag in:
@@ -51,6 +51,80 @@ In the UI, drag in:
 Verify `cars` appears, create a worksheet/Mosaic chart/dashboard, stop the
 server, restart the same command, and confirm the state comes back.
 
+## Python CLI release workflow
+
+The Python CLI release is split into an intentional version step and a publish
+step. Publishing never bumps versions automatically.
+
+Before versioning or publishing, test a production build locally:
+
+```bash
+pnpm --dir python/sqlrooms build
+
+# Source/workspace check. This should reflect python/sqlrooms/package.json.
+uv run --project python/sqlrooms sqlrooms --version
+
+uv run --project python/sqlrooms sqlrooms --no-open-browser --experimental /tmp/sqlrooms-smoke.duckdb
+```
+
+For the closest local install check, install the freshly built wheel from
+`python/dist` into a `uv tool` environment. Use the exact wheel for the current
+`python/sqlrooms/package.json` version so older files in `python/dist` are not
+selected accidentally. Run these commands from the repository root:
+
+```bash
+SQLROOMS_VERSION=$(node -p "require('./python/sqlrooms/package.json').version")
+uv tool install --reinstall "python/dist/sqlrooms-${SQLROOMS_VERSION}-py3-none-any.whl"
+sqlrooms --version
+sqlrooms --no-open-browser /tmp/sqlrooms-smoke.duckdb
+```
+
+Open the printed UI URL, drag in the CSV fixture listed above, create a
+worksheet/chart/dashboard, then restart against the same `/tmp/sqlrooms-smoke.duckdb` and
+confirm the imported data and workspace state come back.
+
+1. Choose the package target:
+   - `sqlrooms` for the CLI package and bundled UI.
+   - `sqlrooms-server` for the DuckDB websocket server package.
+   - `all` when both packages should be released in dependency order.
+2. Version the selected package or packages explicitly:
+
+   ```bash
+   pnpm cli:version --target sqlrooms --bump patch
+   pnpm cli:version --target sqlrooms-server --set 0.2.0
+   pnpm cli:version --target all --bump minor
+   ```
+
+   Hatch reads package versions from each package's `package.json`. When
+   `sqlrooms-server` is versioned, the workflow also updates the
+   `sqlrooms-server>=...` dependency floor in `python/sqlrooms/pyproject.toml`.
+
+3. Format the Python CLI packages before running publish checks:
+
+   ```bash
+   uv run --project python/sqlrooms ruff format
+   uv run --project python/sqlrooms ruff check --fix
+   ```
+
+4. Run the dry publish workflow for the intended target:
+
+   ```bash
+   pnpm cli:publish:dry --target sqlrooms
+   ```
+
+   The dry workflow runs validation and builds the selected package or packages,
+   but it does not upload to PyPI.
+
+5. Publish the same target:
+
+   ```bash
+   pnpm cli:publish --target sqlrooms
+   ```
+
+   Publishing runs validation, builds the package, then uploads the built
+   distributions with Twine. Use `--target all` only when both packages are part
+   of the release.
+
 ## Dev mode (UI + Python server together)
 
 From the repo root:

{sqlrooms-0.1.1 → sqlrooms-0.1.3}/node_modules/sqlrooms-cli-app/node_modules/@sqlrooms/canvas/node_modules/@sqlrooms/cells/node_modules/@sqlrooms/vega/node_modules/@sqlrooms/documents/README.md

@@ -129,6 +129,8 @@ and provide block DTO helpers for command and AI authoring surfaces:
 ```tsx
 import {
   BlockDocumentsSliceConfig,
+  createAddBlockDocumentTextBlockTool,
+  createListBlockDocumentBlocksTool,
   createBlockDocumentsSlice,
 } from '@sqlrooms/documents';
 
@@ -147,6 +149,24 @@ const roomStore = createRoomStore(
 );
 ```
 
+Generic AI helpers use the same block DTOs as commands and the editor. Hosts
+provide a small `BlockDocumentAiAdapter` that ensures a document, lists its
+blocks, and appends new blocks; feature packages or apps can then compose these
+tools with their own stateful-block tools:
+
+```ts
+const tools = {
+  add_block_document_text_block: createAddBlockDocumentTextBlockTool({
+    blockDocumentAdapter,
+    blockDocumentId,
+  }),
+  list_block_document_blocks: createListBlockDocumentBlocksTool({
+    blockDocumentAdapter,
+    blockDocumentId,
+  }),
+};
+```
+
 The slice can create block documents, replace the Tiptap JSON body, and
 append/insert/update/remove/reorder top-level blocks. Supported block DTOs
 include headings, paragraphs, lists, todos, images, chart images,

{sqlrooms-0.1.1 → sqlrooms-0.1.3}/node_modules/sqlrooms-cli-app/node_modules/@sqlrooms/deck/node_modules/@sqlrooms/mosaic/README.md

@@ -176,12 +176,13 @@ Use `DataTableSelector` or `DataTableSelectorEmptyState` when another host
 surface needs the same searchable table picker used by dashboards and data
 table blocks.
 
-### Worksheet Agent HTML App Tools
+### Block Document AI Integrations
 
-`createWorksheetAgentTool` exposes worksheet HTML app block workflows by
-default. Hosts that gate or do not support HTML app blocks should pass
-`htmlAppBlocksEnabled: false` so the agent omits `add_html_app_block` and does
-not advertise HTML app block workflows in its instructions.
+`createBlockDocumentChartTools`, `createAddMosaicDashboardBlockTool`, and
+`createBlockDocumentDataTableExplorerTool` expose Mosaic-owned capabilities for
+block-document hosts. The host provides a `BlockDocumentAiAdapter` from
+`@sqlrooms/documents` plus callbacks for creating host-specific stateful block
+state, then composes these tools with app-specific agent policy.
 
 ### Mosaic Dashboard Panels
 

{sqlrooms-0.1.1 → sqlrooms-0.1.3}/sqlrooms/cli.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import hashlib
+from importlib.metadata import PackageNotFoundError, version
 import logging
 import json
 import os
@@ -40,6 +41,29 @@ DEFAULT_CONFIG_PATH = _config_base / "config.toml"
 DEFAULT_HTTP_PORT = 3000
 
 
+def _get_cli_version() -> str:
+    package_json = Path(__file__).resolve().parents[1] / "package.json"
+    try:
+        payload = json.loads(package_json.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        pass
+    else:
+        package_version = payload.get("version")
+        if isinstance(package_version, str):
+            return package_version
+
+    try:
+        return version("sqlrooms")
+    except PackageNotFoundError:
+        return "unknown"
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"sqlrooms {_get_cli_version()}")
+        raise typer.Exit()
+
+
 def _configure_logging(*, debug: bool) -> None:
     logging.getLogger().setLevel(logging.DEBUG if debug else logging.INFO)
 
@@ -404,6 +428,13 @@ def export_project(
 
 @app.callback(invoke_without_command=True)
 def main(
+    show_version: bool = typer.Option(
+        False,
+        "--version",
+        callback=_version_callback,
+        is_eager=True,
+        help="Show the sqlrooms CLI version and exit.",
+    ),
     db_path: str | None = typer.Argument(
         None,
         help="DuckDB database to use (positional). Pass a filepath to persist, or ':memory:' for an in-memory DB (no file).",

{sqlrooms-0.1.1 → sqlrooms-0.1.3}/sqlrooms/web/launcher.py

@@ -579,6 +579,9 @@ class SqlroomsHttpServer:
             or f"ws://{self._host_for_url(self._public_host())}:{self.ws_port}"
         )
 
+    def _ws_proxy_url(self) -> str:
+        return f"ws://{self._host_for_url(self._ui_host())}:{self.port}/ws/duckdb"
+
     def _assert_ui_available(self) -> None:
         if not self.serve_ui:
             return
@@ -698,7 +701,7 @@ class SqlroomsHttpServer:
             if self.external_url and not self.external_ws_url
             else None
         )
-        ws_url = self.external_ws_url or derived_ws_url or self._ws_url()
+        ws_url = self.external_ws_url or derived_ws_url or self._ws_proxy_url()
         return {
             "wsUrl": ws_url,
             "wsAuthToken": self.session_token,
@@ -748,6 +751,33 @@ class SqlroomsHttpServer:
             return None
         return JSONResponse({"error": "unauthorized"}, status_code=401)
 
+    async def _authenticate_duckdb_proxy_websocket(self, client_ws: WebSocket) -> bool:
+        await client_ws.accept()
+
+        query_token = (client_ws.query_params.get("token") or "").strip()
+        if query_token == self.session_token:
+            return True
+
+        try:
+            message = await asyncio.wait_for(client_ws.receive_text(), timeout=5)
+            payload = json.loads(message)
+        except Exception:
+            await client_ws.close(code=1008, reason="unauthorized")
+            return False
+
+        token = payload.get("token") if isinstance(payload, dict) else None
+        if (
+            isinstance(payload, dict)
+            and payload.get("type") == "auth"
+            and token == self.session_token
+        ):
+            await client_ws.send_json({"type": "authAck"})
+            return True
+
+        await client_ws.send_json({"type": "error", "error": "Unauthorized"})
+        await client_ws.close(code=1008, reason="unauthorized")
+        return False
+
     def _build_app(self) -> FastAPI:
         app = FastAPI(title="sqlrooms", version="0.1.0")
         app.add_middleware(
@@ -781,7 +811,9 @@ class SqlroomsHttpServer:
 
         @app.websocket("/ws/duckdb")
         async def duckdb_websocket_proxy(client_ws: WebSocket):
-            await client_ws.accept()
+            if not await self._authenticate_duckdb_proxy_websocket(client_ws):
+                return
+
             try:
                 import websockets
             except ImportError: