execsql2 2.0.1__py3-none-any.whl → 2.1.1__py3-none-any.whl

execsql/cli.py

@@ -12,17 +12,19 @@ import getpass
 import os
 import sys
 import traceback
+from pathlib import Path
 from encodings.aliases import aliases as codec_dict
-from typing import List, Optional
 
 import typer
 from rich.console import Console
 from rich.table import Table
-from rich.text import Text
 
 from execsql import __version__
 from execsql.config import ConfigData, StatObj
 from execsql.exceptions import ConfigError, ErrInfo
+from execsql.script import SubVarSet, current_script_line, read_sqlfile, read_sqlstring, runscripts
+from execsql.utils.fileio import FileWriter, Logger, filewriter_end
+from execsql.utils.gui import gui_connect, gui_console_isrunning, gui_console_off, gui_console_on, gui_console_wait_user
 
 _console = Console()
 _err_console = Console(stderr=True)
@@ -193,7 +195,7 @@ def _version_callback(value: bool) -> None:
 def main(
     ctx: typer.Context,
     # Positional args collected manually (script + optional server/db/file)
-    args: Optional[List[str]] = typer.Argument(
+    args: list[str] | None = typer.Argument(
         None,
         metavar="SQL_SCRIPT [SERVER DATABASE | DATABASE_FILE]",
         help=(
@@ -202,46 +204,46 @@ def main(
         ),
     ),
     # Named options — grouped to mirror the original argparse interface
-    sub_vars: Optional[List[str]] = typer.Option(
+    sub_vars: list[str] | None = typer.Option(
         None,
         "-a",
         "--assign-arg",
         metavar="VALUE",
         help="Define the replacement string for a substitution variable [cyan]\\$ARG_x[/cyan].",
     ),
-    boolean_int: Optional[str] = typer.Option(
+    boolean_int: str | None = typer.Option(
         None,
         "-b",
         "--boolean-int",
         metavar="{0,1,t,f,y,n}",
         help="Treat integers 0 and 1 as boolean values.",
     ),
-    make_dirs: Optional[str] = typer.Option(
+    make_dirs: str | None = typer.Option(
         None,
         "-d",
         "--directories",
         metavar="{0,1,t,f,y,n}",
         help="Auto-create directories for EXPORT metacommand. [dim]n=no (default), y=yes[/dim]",
     ),
-    database_encoding: Optional[str] = typer.Option(
+    database_encoding: str | None = typer.Option(
         None,
         "-e",
         "--database-encoding",
         help="Character encoding used in the database.",
     ),
-    script_encoding: Optional[str] = typer.Option(
+    script_encoding: str | None = typer.Option(
         None,
         "-f",
         "--script-encoding",
         help="Character encoding of the script file. [dim]Default: UTF-8[/dim]",
     ),
-    output_encoding: Optional[str] = typer.Option(
+    output_encoding: str | None = typer.Option(
         None,
         "-g",
         "--output-encoding",
         help="Encoding for WRITE and EXPORT output.",
     ),
-    import_encoding: Optional[str] = typer.Option(
+    import_encoding: str | None = typer.Option(
         None,
         "-i",
         "--import-encoding",
@@ -271,20 +273,20 @@ def main(
         "--online-help",
         help="Open the online documentation in the default browser.",
     ),
-    port: Optional[int] = typer.Option(
+    port: int | None = typer.Option(
         None,
         "-p",
         "--port",
         help="Database server port.",
     ),
-    scanlines: Optional[int] = typer.Option(
+    scanlines: int | None = typer.Option(
         None,
         "-s",
         "--scan-lines",
         metavar="N",
         help="Lines to scan for IMPORT format detection. [dim]0 = scan entire file.[/dim]",
     ),
-    db_type: Optional[str] = typer.Option(
+    db_type: str | None = typer.Option(
         None,
         "-t",
         "--type",
@@ -296,24 +298,28 @@ def main(
             "[bold]d[/bold]=DSN."
         ),
     ),
-    user: Optional[str] = typer.Option(
+    user: str | None = typer.Option(
         None,
         "-u",
         "--user",
         help="Database user name.",
     ),
-    use_gui: Optional[str] = typer.Option(
+    use_gui: str | None = typer.Option(
         None,
         "-v",
         "--visible-prompts",
         metavar="{0,1,2,3}",
         help=(
             "GUI level: [bold]0[/bold]=none (default), [bold]1[/bold]=GUI for password/pause, "
-            "[bold]2[/bold]=GUI for password/pause + DB selection, [bold]3[/bold]=full GUI console. "
-            "Set [cyan]gui_framework[/cyan] in the config [interface] section to choose "
-            "'tkinter' (default) or 'textual'."
+            "[bold]2[/bold]=GUI for password/pause + DB selection, [bold]3[/bold]=full GUI console."
         ),
     ),
+    gui_framework: str | None = typer.Option(
+        None,
+        "--gui-framework",
+        metavar="{tkinter,textual}",
+        help="GUI framework to use with [cyan]--visible-prompts[/cyan]. [dim]Default: tkinter[/dim]",
+    ),
     no_passwd: bool = typer.Option(
         False,
         "-w",
@@ -326,14 +332,50 @@ def main(
         "--encodings",
         help="List available encoding names and exit.",
     ),
-    import_buffer: Optional[int] = typer.Option(
+    import_buffer: int | None = typer.Option(
         None,
         "-z",
         "--import-buffer",
         metavar="KB",
         help="Import buffer size in KB. [dim]Default: 32[/dim]",
     ),
-    version: Optional[bool] = typer.Option(
+    command: str | None = typer.Option(
+        None,
+        "-c",
+        "--command",
+        metavar="SCRIPT",
+        help=(
+            "Execute an inline SQL/metacommand script string instead of a script file. "
+            "Use shell [cyan]$'line1\\nline2'[/cyan] syntax for multi-line scripts."
+        ),
+    ),
+    dry_run: bool = typer.Option(
+        False,
+        "--dry-run",
+        help=("Parse the script and print the command list without connecting to a database or executing anything."),
+    ),
+    dsn: str | None = typer.Option(
+        None,
+        "--dsn",
+        "--connection-string",
+        metavar="URL",
+        help=(
+            "Database connection URL, e.g. [cyan]postgresql://user:pass@host:5432/db[/cyan]. "
+            "Supported schemes: postgresql, mysql, mssql, oracle, firebird, sqlite, duckdb. "
+            "Overrides [cyan]-t[/cyan]/[cyan]-u[/cyan]/[cyan]-p[/cyan] and positional server/db args."
+        ),
+    ),
+    output_dir: str | None = typer.Option(
+        None,
+        "--output-dir",
+        metavar="DIR",
+        help=(
+            "Default base directory for EXPORT output files. "
+            "Relative paths in EXPORT metacommands are joined to this directory. "
+            "Absolute paths and [cyan]stdout[/cyan] are unaffected."
+        ),
+    ),
+    version: bool | None = typer.Option(
         None,
         "--version",
         callback=_version_callback,
@@ -365,20 +407,28 @@ def main(
     if online_help:
         import webbrowser
 
-        webbrowser.open("https://execsql.readthedocs.io/en/latest/", new=2, autoraise=True)
+        webbrowser.open("https://execsql2.readthedocs.io/en/latest/", new=2, autoraise=True)
+        raise typer.Exit()
 
     positional = args or []
-    if not positional:
-        _err_console.print("[bold red]Error:[/bold red] No SQL script file specified.")
-        raise typer.Exit(code=1)
+    if command is not None:
+        script_name = None  # inline mode — no script file
+    else:
+        if not positional:
+            _err_console.print(
+                "[bold red]Error:[/bold red] No SQL script file specified. Use [cyan]-c[/cyan] to run an inline script.",
+            )
+            raise typer.Exit(code=1)
+        script_name = positional[0]
+        if not Path(script_name).exists():
+            _err_console.print(
+                f'[bold red]Error:[/bold red] SQL script file [cyan]"{script_name}"[/cyan] does not exist.',
+            )
+            raise typer.Exit(code=1)
 
     # ------------------------------------------------------------------
     # Validate positional args and db_type choice
     # ------------------------------------------------------------------
-    script_name = positional[0]
-    if not os.path.exists(script_name):
-        _err_console.print(f'[bold red]Error:[/bold red] SQL script file [cyan]"{script_name}"[/cyan] does not exist.')
-        raise typer.Exit(code=1)
 
     if db_type and db_type not in ("a", "d", "p", "s", "l", "m", "k", "o", "f"):
         _err_console.print(
@@ -393,6 +443,12 @@ def main(
         )
         raise typer.Exit(code=2)
 
+    if gui_framework and gui_framework.lower() not in ("tkinter", "textual"):
+        _err_console.print(
+            f"[bold red]Error:[/bold red] Invalid GUI framework [cyan]{gui_framework!r}[/cyan]. Choose from: tkinter, textual",
+        )
+        raise typer.Exit(code=2)
+
     if boolean_int and boolean_int.lower() not in ("0", "1", "t", "f", "y", "n"):
         _err_console.print(
             f"[bold red]Error:[/bold red] Invalid --boolean-int value [cyan]{boolean_int!r}[/cyan].",
@@ -418,12 +474,122 @@ def main(
         db_type=db_type,
         user=user,
         use_gui=use_gui,
+        gui_framework=gui_framework,
         no_passwd=no_passwd,
         import_buffer=import_buffer,
         script_name=script_name,
+        command=command,
+        dry_run=dry_run,
+        dsn=dsn,
+        output_dir=output_dir,
     )
 
 
+# ---------------------------------------------------------------------------
+# Connection-string parser
+# ---------------------------------------------------------------------------
+
+#: Mapping from URL scheme → execsql db_type code
+_SCHEME_TO_DBTYPE: dict[str, str] = {
+    "postgresql": "p",
+    "postgres": "p",
+    "mysql": "m",
+    "mariadb": "m",
+    "mssql": "s",
+    "sqlserver": "s",
+    "oracle": "o",
+    "oracle+cx_oracle": "o",
+    "firebird": "f",
+    "sqlite": "l",
+    "duckdb": "k",
+}
+
+
+def _parse_connection_string(dsn: str) -> dict:
+    """Parse a database URL into a dict of connection parameters.
+
+    Supports the common form::
+
+        scheme://[user[:password]@][host[:port]]/database
+
+    For file-based databases (SQLite, DuckDB) the path after ``//`` is
+    treated as the database file path::
+
+        sqlite:///path/to/file.db   → db_file = /path/to/file.db
+        duckdb:///path/to/file.db   → db_file = /path/to/file.db
+
+    Returns a dict with keys: ``db_type``, ``server``, ``db``, ``db_file``,
+    ``user``, ``password``, ``port``.  Absent components are ``None``.
+
+    Raises :class:`~execsql.exceptions.ConfigError` for an unrecognised
+    URL scheme or a completely un-parseable string.
+    """
+    from urllib.parse import urlparse
+
+    parsed = urlparse(dsn)
+    scheme = parsed.scheme.lower()
+    if not scheme:
+        raise ConfigError(f"Cannot parse connection string (no scheme): {dsn!r}")
+    if scheme not in _SCHEME_TO_DBTYPE:
+        raise ConfigError(
+            f"Unrecognised connection-string scheme {scheme!r}. "
+            f"Supported schemes: {', '.join(sorted(_SCHEME_TO_DBTYPE))}",
+        )
+
+    db_type = _SCHEME_TO_DBTYPE[scheme]
+    port: int | None = parsed.port
+    server: str | None = parsed.hostname or None
+    user: str | None = parsed.username or None
+    password: str | None = parsed.password or None
+
+    # Database / file path
+    # urlparse puts the path in parsed.path.  For three-slash URIs like
+    # sqlite:///foo.db the path starts with "/"; strip exactly one leading
+    # slash for relative paths (sqlite:///foo.db → foo.db) and leave
+    # absolute paths intact (sqlite:////abs/path → /abs/path).
+    raw_path = parsed.path
+    if db_type in ("l", "k", "a"):
+        # File-based: no server component
+        if raw_path.startswith("/") and not raw_path.startswith("//"):
+            db_file: str | None = raw_path[1:] or None
+        else:
+            db_file = raw_path or None
+        db: str | None = None
+    else:
+        db_file = None
+        # Remove leading "/"
+        db = raw_path.lstrip("/") or None
+
+    return {
+        "db_type": db_type,
+        "server": server,
+        "db": db,
+        "db_file": db_file,
+        "user": user,
+        "password": password,
+        "port": port,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Dry-run helper
+# ---------------------------------------------------------------------------
+
+
+def _print_dry_run(cmdlist: object) -> None:
+    """Print the parsed command list for --dry-run mode."""
+    if cmdlist is None or not cmdlist.cmdlist:
+        _console.print("[yellow]No commands found in script.[/yellow]")
+        return
+    n = len(cmdlist.cmdlist)
+    _console.print(f"[bold cyan]Dry Run[/bold cyan] — [dim]{n} command(s) parsed[/dim]")
+    _console.print()
+    for i, cmd in enumerate(cmdlist.cmdlist, 1):
+        ctype = "SQL    " if cmd.command_type == "sql" else "METACMD"
+        source_info = f"[dim]{cmd.source}:{cmd.line_no}[/dim]"
+        _console.print(f"  [dim]{i:>4}[/dim]  [bold green]{ctype}[/bold green]  {source_info}  {cmd.commandline()}")
+
+
 # ---------------------------------------------------------------------------
 # Core execution (split from argument parsing for testability)
 # ---------------------------------------------------------------------------
@@ -431,44 +597,56 @@ def main(
 
 def _run(
     positional: list,
-    sub_vars: Optional[List[str]],
-    boolean_int: Optional[str],
-    make_dirs: Optional[str],
-    database_encoding: Optional[str],
-    script_encoding: Optional[str],
-    output_encoding: Optional[str],
-    import_encoding: Optional[str],
+    sub_vars: list[str] | None,
+    boolean_int: str | None,
+    make_dirs: str | None,
+    database_encoding: str | None,
+    script_encoding: str | None,
+    output_encoding: str | None,
+    import_encoding: str | None,
     user_logfile: bool,
     new_db: bool,
-    port: Optional[int],
-    scanlines: Optional[int],
-    db_type: Optional[str],
-    user: Optional[str],
-    use_gui: Optional[str],
-    no_passwd: bool,
-    import_buffer: Optional[int],
-    script_name: str,
+    port: int | None,
+    scanlines: int | None,
+    db_type: str | None,
+    user: str | None,
+    use_gui: str | None,
+    gui_framework: str | None = None,
+    no_passwd: bool = False,
+    import_buffer: int | None = None,
+    script_name: str | None = None,
+    command: str | None = None,
+    dry_run: bool = False,
+    dsn: str | None = None,
+    output_dir: str | None = None,
 ) -> None:
-    """Core execution logic, separated from argument parsing."""
+    """Initialise state, connect to the database, load the script, and run it.
+
+    Separated from argument parsing so it can be called directly in tests
+    without going through the Typer CLI layer. All parameters mirror the
+    corresponding CLI options; see [Syntax & Options](../syntax.md) for
+    descriptions.
+    """
     import execsql.state as _state
 
     # ------------------------------------------------------------------
     # Early setup: substitution variables seeded before arg parsing
     # ------------------------------------------------------------------
-    _state.subvars = _state.SubVarSet()
+    _state.subvars = SubVarSet()
 
+    # Security note: ALL environment variables are exposed as &-prefixed
+    # substitution variables.  Sensitive values (API keys, tokens) in the
+    # process environment will be accessible to scripts.  See the
+    # "Environment Variables" section in docs/substitution_vars.md.
     for k in os.environ:
         try:
             _state.subvars.add_substitution("&" + k, os.environ[k])
         except Exception:
-            pass
+            pass  # Skip env vars with names that can't be substitution keys.
     _state.subvars.add_substitution("$LAST_ROWCOUNT", None)
 
     dt_now = datetime.datetime.now()
-    if sys.version_info < (3, 12):
-        dt_now_utc = datetime.datetime.utcnow()
-    else:
-        dt_now_utc = datetime.datetime.now(tz=datetime.timezone.utc)
+    dt_now_utc = datetime.datetime.now(tz=datetime.timezone.utc)
 
     _state.subvars.add_substitution("$SCRIPT_START_TIME", dt_now.strftime("%Y-%m-%d %H:%M"))
     _state.subvars.add_substitution("$SCRIPT_START_TIME_UTC", dt_now_utc.strftime("%Y-%m-%d %H:%M"))
@@ -492,9 +670,36 @@ def _run(
     # ------------------------------------------------------------------
     # Read configuration file
     # ------------------------------------------------------------------
-    _state.conf = ConfigData(os.path.dirname(os.path.abspath(script_name)), _state.subvars)
+    script_path = str(Path(script_name).resolve().parent) if script_name else os.getcwd()
+    _state.conf = ConfigData(script_path, _state.subvars)
     conf = _state.conf
 
+    # ------------------------------------------------------------------
+    # Connection string (--dsn / --connection-string): overrides -t/-u/-p
+    # and positional server/db args when provided.
+    # ------------------------------------------------------------------
+    if dsn:
+        try:
+            parsed_dsn = _parse_connection_string(dsn)
+        except ConfigError as exc:
+            _err_console.print(f"[bold red]Error:[/bold red] {exc}")
+            raise SystemExit(1)
+        db_type = db_type or parsed_dsn["db_type"]
+        conf.db_type = db_type
+        if parsed_dsn["server"] and not conf.server:
+            conf.server = parsed_dsn["server"]
+        if parsed_dsn["db"] and not conf.db:
+            conf.db = parsed_dsn["db"]
+        if parsed_dsn["db_file"] and not conf.db_file:
+            conf.db_file = parsed_dsn["db_file"]
+        if parsed_dsn["user"] and not user:
+            user = parsed_dsn["user"]
+        if parsed_dsn["password"]:
+            conf.db_password = parsed_dsn["password"]
+            conf.passwd_prompt = False
+        if parsed_dsn["port"] and not port:
+            port = parsed_dsn["port"]
+
     # Apply CLI options over config-file values
     if user:
         conf.username = user
@@ -530,6 +735,8 @@ def _run(
         conf.gui_level = 0
     elif conf.gui_level not in range(4):
         raise ConfigError(f"Invalid GUI level specification: {conf.gui_level}")
+    if gui_framework:
+        conf.gui_framework = gui_framework.lower()
     if db_type:
         conf.db_type = db_type
     if conf.db_type is None:
@@ -542,22 +749,27 @@ def _run(
         conf.access_username = user
     if new_db:
         conf.new_db = True
-
-    # Positional arguments after the script name
-    if len(positional) == 2:
+    if output_dir:
+        conf.export_output_dir = str(Path(output_dir).resolve())
+
+    # Positional arguments after the script name (or all positionals in inline mode)
+    # off=1: script file occupies positional[0]; connection args start at [1]
+    # off=0: no script file; all positionals are connection args
+    off = 0 if command is not None else 1
+    if len(positional) == off + 1:
         if conf.db_type in ("a", "l", "k"):
-            conf.db_file = positional[1]
+            conf.db_file = positional[off]
         elif conf.db_type == "d":
-            conf.db = positional[1]
+            conf.db = positional[off]
         else:
             if conf.server and not conf.db:
-                conf.db = positional[1]
+                conf.db = positional[off]
             else:
-                conf.server = positional[1]
-    elif len(positional) == 3:
-        conf.server = positional[1]
-        conf.db = positional[2]
-    elif len(positional) > 3:
+                conf.server = positional[off]
+    elif len(positional) == off + 2:
+        conf.server = positional[off]
+        conf.db = positional[off + 1]
+    elif len(positional) > off + 2:
         from execsql.utils.errors import fatal_error
 
         fatal_error("Incorrect number of command-line arguments.")
@@ -567,20 +779,25 @@ def _run(
     # ------------------------------------------------------------------
     from execsql.utils.errors import file_size_date
 
-    _state.subvars.add_substitution("$STARTING_SCRIPT", script_name)
-    _state.subvars.add_substitution("$STARTING_SCRIPT_NAME", os.path.basename(script_name))
-    _state.subvars.add_substitution("$STARTING_SCRIPT_REVTIME", file_size_date(script_name)[1])
+    if script_name is not None:
+        _state.subvars.add_substitution("$STARTING_SCRIPT", script_name)
+        _state.subvars.add_substitution("$STARTING_SCRIPT_NAME", Path(script_name).name)
+        _state.subvars.add_substitution("$STARTING_SCRIPT_REVTIME", file_size_date(script_name)[1])
+    else:
+        _state.subvars.add_substitution("$STARTING_SCRIPT", "<inline>")
+        _state.subvars.add_substitution("$STARTING_SCRIPT_NAME", "<inline>")
+        _state.subvars.add_substitution("$STARTING_SCRIPT_REVTIME", "")
 
     # ------------------------------------------------------------------
     # Initialise state objects
     # ------------------------------------------------------------------
-    _state.if_stack = _state.IfLevels()
-    _state.counters = _state.CounterVars()
-    _state.timer = _state.Timer()
+    from execsql.metacommands import DISPATCH_TABLE
+    from execsql.metacommands.conditions import CONDITIONAL_TABLE
+
+    _state.initialize(conf, DISPATCH_TABLE, CONDITIONAL_TABLE)
+
+    # Local-only objects that require CLI-specific args or class definitions
     _state.status = StatObj()
-    _state.dbs = _state.DatabasePool()
-    _state.tempfiles = _state.TempFileMgr()
-    _state.export_metadata = _state.ExportMetadata()
 
     from execsql.config import WriteHooks
 
@@ -589,22 +806,14 @@ def _run(
     import execsql.utils.fileio as _fileio
 
     if _state.filewriter is None or not _state.filewriter.is_alive():
-        _state.filewriter = _state.FileWriter(
+        _fileio.filewriter = _state.filewriter = FileWriter(
             _fileio.fw_input,
             _fileio.fw_output,
             file_encoding=conf.output_encoding,
             open_timeout=getattr(conf, "outfile_open_timeout", 10),
         )
         _state.filewriter.start()
-        atexit.register(_state.filewriter_end)
-
-    from execsql.metacommands import DISPATCH_TABLE
-
-    _state.metacommandlist = DISPATCH_TABLE
-
-    from execsql.metacommands.conditions import CONDITIONAL_TABLE
-
-    _state.conditionallist = CONDITIONAL_TABLE
+        atexit.register(filewriter_end)
 
     # ------------------------------------------------------------------
     # Logging
@@ -631,15 +840,15 @@ def _run(
         }.items()
         if v
     }
-    _state.exec_log = _state.Logger(
-        script_name,
+    _state.exec_log = Logger(
+        script_name or "<inline>",
         conf.db,
         conf.server,
         opts_dict,
         conf.user_logfile,
     )
     _state.exec_log.log_status_info(
-        "Python version %d.%d.%d %s" % sys.version_info[:4],
+        f"Python version {sys.version_info[0]}.{sys.version_info[1]}.{sys.version_info[2]} {sys.version_info[3]}",
     )
     _state.exec_log.log_status_info(f"execsql version {__version__}")
     _state.exec_log.log_status_info(f"System user: {getpass.getuser()}")
@@ -662,20 +871,30 @@ def _run(
     # ------------------------------------------------------------------
     # Load the SQL script
     # ------------------------------------------------------------------
-    _state.read_sqlfile(script_name)
+    if command is not None:
+        read_sqlstring(command.replace("\\n", "\n").replace("\\t", "\t"), "<inline>")
+    else:
+        read_sqlfile(script_name)
+
+    # ------------------------------------------------------------------
+    # Dry-run: print command list and exit without connecting to DB
+    # ------------------------------------------------------------------
+    if dry_run:
+        _print_dry_run(_state.commandliststack[-1] if _state.commandliststack else None)
+        raise SystemExit(0)
 
     # ------------------------------------------------------------------
     # Start GUI console if requested
     # ------------------------------------------------------------------
     if conf.gui_level > 2:
-        _state.gui_console_on()
+        gui_console_on()
 
     # ------------------------------------------------------------------
     # Establish database connection
     # ------------------------------------------------------------------
     if conf.server is None and conf.db is None and conf.db_file is None:
         if conf.gui_level > 1:
-            _state.gui_connect("initial", f"Select the database to use with {script_name}.")
+            gui_connect("initial", f"Select the database to use with {script_name or '<inline>'}.")
             db = _state.dbs.current()
         else:
             from execsql.utils.errors import fatal_error
@@ -717,7 +936,7 @@ def _execute_script_textual_console(conf: ConfigData) -> None:
     _state.gui_manager_queue = dialog_queue
 
     app = ConsoleApp(
-        script_runner=_state.runscripts,
+        script_runner=runscripts,
         dialog_queue=dialog_queue,
         wait_on_exit=conf.gui_wait_on_exit,
     )
@@ -745,8 +964,8 @@ def _execute_script_textual_console(conf: ConfigData) -> None:
         else:
             strace = traceback.extract_tb(exc.__traceback__)[-1:]
             lno = strace[0][1] if strace else "?"
-            msg = f"{os.path.basename(sys.argv[0])}: Uncaught exception {type(exc)} ({exc}) on line {lno}"
-            script, slno = _state.current_script_line()
+            msg = f"{Path(sys.argv[0]).name}: Uncaught exception {type(exc)} ({exc}) on line {lno}"
+            script, slno = current_script_line()
             if script is not None:
                 msg += f" in script {script}, line {slno}"
             from execsql.utils.errors import exit_now
@@ -775,14 +994,14 @@ def _execute_script_direct(conf: ConfigData) -> None:
             pass
 
     try:
-        _state.runscripts()
+        runscripts()
     except SystemExit as exc:
-        if _state.gui_console_isrunning() and conf.gui_wait_on_exit:
-            _state.gui_console_wait_user(
+        if gui_console_isrunning() and conf.gui_wait_on_exit:
+            gui_console_wait_user(
                 "Script complete; close the console window to exit execsql.",
             )
-            if _state.gui_console_isrunning():
-                _state.gui_console_off()
+            if gui_console_isrunning():
+                gui_console_off()
         _state.exec_log.log_status_info(f"{_state.cmds_run} commands run")
         sys.exit(exc.code)
     except ConfigError:
@@ -794,11 +1013,8 @@ def _execute_script_direct(conf: ConfigData) -> None:
     except Exception:
         strace = traceback.extract_tb(sys.exc_info()[2])[-1:]
         lno = strace[0][1]
-        msg = (
-            f"{os.path.basename(sys.argv[0])}: Uncaught exception "
-            f"{sys.exc_info()[0]} ({sys.exc_info()[1]}) on line {lno}"
-        )
-        script, slno = _state.current_script_line()
+        msg = f"{Path(sys.argv[0]).name}: Uncaught exception {sys.exc_info()[0]} ({sys.exc_info()[1]}) on line {lno}"
+        script, slno = current_script_line()
         if script is not None:
             msg += f" in script {script}, line {slno}"
         from execsql.utils.errors import exit_now
@@ -806,12 +1022,12 @@ def _execute_script_direct(conf: ConfigData) -> None:
         exit_now(1, ErrInfo("exception", exception_msg=msg))
 
     _state.dbs.do_rollback = False
-    if _state.gui_console_isrunning() and conf.gui_wait_on_exit:
-        _state.gui_console_wait_user(
+    if gui_console_isrunning() and conf.gui_wait_on_exit:
+        gui_console_wait_user(
             "Script complete; close the console window to exit execsql.",
         )
-        if _state.gui_console_isrunning():
-            _state.gui_console_off()
+        if gui_console_isrunning():
+            gui_console_off()
     _state.exec_log.log_status_info(f"{_state.cmds_run} commands run")
     _state.exec_log.log_exit_end()
 
@@ -855,6 +1071,7 @@ def _connect_initial_db(conf: ConfigData):
             port=conf.port,
             encoding=conf.db_encoding,
             new_db=conf.new_db,
+            password=getattr(conf, "db_password", None),
         )
     elif conf.db_type == "s":
         return db_SqlServer(
@@ -939,10 +1156,7 @@ def _legacy_main() -> None:
     except Exception:
         strace = traceback.extract_tb(sys.exc_info()[2])[-1:]
         lno = strace[0][1]
-        msg = (
-            f"{os.path.basename(sys.argv[0])}: Uncaught exception "
-            f"{sys.exc_info()[0]} ({sys.exc_info()[1]}) on line {lno}"
-        )
+        msg = f"{Path(sys.argv[0]).name}: Uncaught exception {sys.exc_info()[0]} ({sys.exc_info()[1]}) on line {lno}"
         from execsql.utils.errors import exit_now
 
         exit_now(1, ErrInfo("exception", exception_msg=msg))