```
#!/usr/bin/env python3
import argparse
import os
import struct
import sys
import json
from pathlib import Path
from collections import defaultdict
import datetime

# Constants for command types
K_COMMAND_UPDATE_TAB_NAVIGATION = 6
K_COMMAND_SET_SELECTED_TAB_IN_INDEX = 8
K_COMMAND_SET_TAB_WINDOW = 0
K_COMMAND_SET_TAB_GROUP = 25
K_COMMAND_SET_TAB_GROUP_METADATA2 = 27
K_COMMAND_SET_SELECTED_NAVIGATION_INDEX = 7
K_COMMAND_TAB_CLOSED = 16
K_COMMAND_WINDOW_CLOSED = 17
K_COMMAND_SET_TAB_INDEX_IN_WINDOW = 2
K_COMMAND_SET_ACTIVE_WINDOW = 20
K_COMMAND_LAST_ACTIVE_TIME = 21

MAGIC_HEADER = b"SNSS"

# Data Structures
class Group:
    def __init__(self, high, low, name=""):
        self.high = high
        self.low = low
        self.name = name

class Window:
    def __init__(self, id):
        self.id = id
        self.active_tab_idx = 0
        self.deleted = False
        self.tabs = []

class HistoryItem:
    def __init__(self, idx, url="", title=""):
        self.idx = idx
        self.url = url
        self.title = title

class Tab:
    def __init__(self, id):
        self.id = id
        self.history = []
        self.idx = 0
        self.win = 0
        self.deleted = False
        self.current_history_idx = 0
        self.group = None

class Result:
    def __init__(self):
        self.windows = []

# Helper Functions
def read_uint8(f):
    data = f.read(1)
    if len(data) != 1:
        raise EOFError("Failed to read uint8.")
    return struct.unpack("<B", data)[0]

def read_uint16(f):
    data = f.read(2)
    if len(data) != 2:
        raise EOFError("Failed to read uint16.")
    return struct.unpack("<H", data)[0]

def read_uint32(f):
    data = f.read(4)
    if len(data) != 4:
        raise EOFError("Failed to read uint32.")
    return struct.unpack("<I", data)[0]

def read_uint64(f):
    data = f.read(8)
    if len(data) != 8:
        raise EOFError("Failed to read uint64.")
    return struct.unpack("<Q", data)[0]

def read_string(f):
    sz = read_uint32(f)
    rsz = sz
    if rsz % 4 != 0:
        rsz += 4 - (rsz % 4)
    data = f.read(rsz)
    if len(data) != rsz:
        raise EOFError("Failed to read string.")
    return data[:sz].decode('utf-8', errors='replace')

def read_string16(f):
    sz = read_uint32(f)
    rsz = sz * 2
    if rsz % 4 != 0:
        rsz += 4 - (rsz % 4)
    data = f.read(rsz)
    if len(data) != rsz:
        raise EOFError("Failed to read string16.")
    # Interpret as little-endian UTF-16
    return data[:sz*2].decode('utf-16le', errors='replace')

# Main Parsing Function
def parse_session(file_path):
    tabs = {}
    windows = {}
    groups = {}
    active_window = None

    def get_window(id):
        if id not in windows:
            windows[id] = Window(id)
        return windows[id]

    def get_group(high, low):
        key = f"{high:x}{low:x}"
        if key not in groups:
            groups[key] = Group(high, low)
        return groups[key]

    def get_tab(id):
        if id not in tabs:
            tabs[id] = Tab(id)
        return tabs[id]

    with open(file_path, 'rb') as f:
        # Read and validate magic header
        magic = f.read(4)
        if magic != MAGIC_HEADER:
            raise ValueError("Invalid SNSS file: Incorrect magic header.")

        # Read and validate version
        version = read_uint32(f)
        if version not in [1, 3]:
            raise ValueError(f"Invalid SNSS file: Unsupported version {version}.")

        while True:
            try:
                sz = read_uint16(f) -1
                cmd_type = read_uint8(f)
                payload = f.read(sz)
                if len(payload) != sz:
                    raise EOFError("Incomplete command payload.")
                data = io.BytesIO(payload)

                if cmd_type == K_COMMAND_UPDATE_TAB_NAVIGATION:
                    data_size = read_uint32(data)
                    tab_id = read_uint32(data)
                    hist_idx = read_uint32(data)
                    url = read_string(data)
                    title = read_string16(data)

                    tab = get_tab(tab_id)
                    # Find or create history item
                    item = next((h for h in tab.history if h.idx == hist_idx), None)
                    if not item:
                        item = HistoryItem(hist_idx)
                        tab.history.append(item)
                    item.url = url
                    item.title = title

                elif cmd_type == K_COMMAND_SET_SELECTED_TAB_IN_INDEX:
                    win_id = read_uint32(data)
                    idx = read_uint32(data)
                    win = get_window(win_id)
                    win.active_tab_idx = idx

                elif cmd_type == K_COMMAND_SET_TAB_GROUP_METADATA2:
                    data_size = read_uint32(data)
                    high = read_uint64(data)
                    low = read_uint64(data)
                    name = read_string16(data)
                    group = get_group(high, low)
                    group.name = name

                elif cmd_type == K_COMMAND_SET_TAB_GROUP:
                    tab_id = read_uint32(data)
                    padding = read_uint32(data)  # Struct padding
                    high = read_uint64(data)
                    low = read_uint64(data)
                    tab = get_tab(tab_id)
                    tab.group = get_group(high, low)

                elif cmd_type == K_COMMAND_SET_TAB_WINDOW:
                    win_id = read_uint32(data)
                    tab_id = read_uint32(data)
                    tab = get_tab(tab_id)
                    tab.win = win_id

                elif cmd_type == K_COMMAND_WINDOW_CLOSED:
                    win_id = read_uint32(data)
                    win = get_window(win_id)
                    win.deleted = True

                elif cmd_type == K_COMMAND_TAB_CLOSED:
                    tab_id = read_uint32(data)
                    tab = get_tab(tab_id)
                    tab.deleted = True

                elif cmd_type == K_COMMAND_SET_TAB_INDEX_IN_WINDOW:
                    tab_id = read_uint32(data)
                    index = read_uint32(data)
                    tab = get_tab(tab_id)
                    tab.idx = index

                elif cmd_type == K_COMMAND_SET_ACTIVE_WINDOW:
                    win_id = read_uint32(data)
                    active_window = get_window(win_id)

                elif cmd_type == K_COMMAND_LAST_ACTIVE_TIME:
                    # Skipping proper implementation as noted in Go code
                    data.read(4 + 8)  # Skip id and time

                elif cmd_type == K_COMMAND_SET_SELECTED_NAVIGATION_INDEX:
                    tab_id = read_uint32(data)
                    idx = read_uint32(data)
                    tab = get_tab(tab_id)
                    tab.current_history_idx = idx

                else:
                    # Unknown command type; skip
                    pass

            except EOFError:
                break

    # Organize tabs into windows
    for tab in tabs.values():
        # Skip tabs without a window
        if tab.win == 0:
            continue
        win = get_window(tab.win)
        win.tabs.append(tab)

    # Sort tabs within windows
    for win in windows.values():
        win.tabs.sort(key=lambda t: t.idx)

    # Prepare Result
    result = Result()
    for win in windows.values():
        window_obj = {
            "active": (win == active_window),
            "deleted": win.deleted,
            "tabs": []
        }
        for idx, tab in enumerate(win.tabs):
            if not tab.deleted:
                is_active = (idx == win.active_tab_idx)
            else:
                is_active = False
            tab_obj = {
                "active": is_active,
                "history": [{"url": h.url, "title": h.title} for h in sorted(tab.history, key=lambda x: x.idx)],
                "url": "",
                "title": "",
                "deleted": tab.deleted,
                "group": tab.group.name if tab.group else ""
            }
            # Truncate history to current_history_idx
            for h in sorted(tab.history, key=lambda x: x.idx):
                tab_obj["history"].append({"url": h.url, "title": h.title})
                if h.idx == tab.current_history_idx:
                    tab_obj["url"] = h.url
                    tab_obj["title"] = h.title
                    break
            window_obj["tabs"].append(tab_obj)
        result.windows.append(window_obj)

    return result

# Function to find the latest session file
def find_session(path):
    session_files = []

    for root, dirs, files in os.walk(path):
        for file in files:
            if file.startswith("Session_"):
                full_path = os.path.join(root, file)
                session_files.append(full_path)

    if not session_files:
        return ""

    # Return the most recently modified session file
    session_files.sort(key=lambda x: os.path.getmtime(x), reverse=True)
    return session_files[0]

# Function to handle printf-like formatting
def format_output(format_str, tab, include_history):
    outputs = []
    if include_history:
        for item in tab["history"]:
            s = format_str.replace("%u", item["url"])
            s = s.replace("%g", tab["group"])
            s = s.replace("%t", item["title"])
            s = s.replace("\\n", "\n")
            s = s.replace("\\t", "\t")
            s = s.replace("\\0", "\x00")
            outputs.append(s)
    else:
        s = format_str.replace("%u", tab["url"])
        s = s.replace("%g", tab["group"])
        s = s.replace("%t", tab["title"])
        s = s.replace("\\n", "\n")
        s = s.replace("\\t", "\t")
        s = s.replace("\\0", "\x00")
        outputs.append(s)
    return "".join(outputs)

# Main Function
def main():
    parser = argparse.ArgumentParser(
        description="Chrome Session Dump - Parses Chrome's session files to extract window and tab information."
    )
    parser.add_argument(
        "target",
        nargs="?",
        default=None,
        help="Path to the session file or Chrome directory. Defaults to Chrome's config directory."
    )
    parser.add_argument(
        "--json",
        action="store_true",
        help="Produce JSON formatted output. Includes all tabs with their history and metadata."
    )
    parser.add_argument(
        "--active",
        action="store_true",
        help="Print the currently active tab."
    )
    parser.add_argument(
        "--deleted",
        action="store_true",
        help="Include tabs and windows that have been deleted."
    )
    parser.add_argument(
        "--history",
        action="store_true",
        help="Include the history of each tab in the output."
    )
    parser.add_argument(
        "--printf",
        default="%u\n",
        help="The output format for tabs if --json is not specified. (Default: '%%u\\n')"
    )

    args = parser.parse_args()

    # Determine the target path
    if args.target:
        target = Path(os.path.expanduser(args.target))
    else:
        # Default Chrome config directories
        possible_dirs = [
            Path.home() / ".config" / "chromium",
            Path.home() / ".config" / "google-chrome",
            Path.home() / ".config" / "chrome"
        ]
        target = next((d for d in possible_dirs if d.exists()), None)
        if not target:
            print("Default Chrome config directories not found. Please specify a session file or Chrome directory.", file=sys.stderr)
            sys.exit(1)

    # If target is a directory, find the latest session file
    if target.is_dir():
        session_file = find_session(str(target))
        if not session_file:
            print("No session file found in the specified directory.", file=sys.stderr)
            sys.exit(1)
    else:
        session_file = str(target)

    # Parse the session file
    try:
        result = parse_session(session_file)
    except Exception as e:
        print(f"Error parsing session file: {e}", file=sys.stderr)
        sys.exit(1)

    # Output the results
    if args.json:
        print(json.dumps({
            "windows": result.windows
        }, indent=2))
    elif args.active:
        for win in result.windows:
            if win["active"]:
                for tab in win["tabs"]:
                    if tab["active"]:
                        output = format_output(args.printf, tab, args.history)
                        print(output, end='')
    else:
        for win in result.windows:
            if not win["deleted"] or args.deleted:
                for tab in win["tabs"]:
                    if not tab["deleted"] or args.deleted:
                        output = format_output(args.printf, tab, args.history)
                        print(output, end='')

if __name__ == "__main__":
    main()
```
update the code with these requirements:
"""
Dump a single file into a specified output file.
Dump multiple files into a designated output folder, creating separate output files for each session.
Provide clear usage instructions and help messages.
Include example CLI commands for various use cases.
"""