cursor-portable 1.0.4__py3-none-any.whl

cursor_portable/__init__.py

@@ -0,0 +1,5 @@
+"""Portable Cursor installer and launcher."""
+
+from cursor_portable._version import __version__
+
+__all__ = ["__version__"]

cursor_portable/__main__.py

@@ -0,0 +1,6 @@
+"""``python -m cursor_portable``."""
+
+from cursor_portable.cli.main import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

cursor_portable/_version.py

@@ -0,0 +1,102 @@
+"""Package version.
+
+The only edited copy is ``[project].version`` in ``pyproject.toml``.
+Copies of this package that leave the repository get a ``VERSION`` stamp.
+"""
+
+from __future__ import annotations
+
+import importlib.metadata
+import logging
+from pathlib import Path
+import re
+import tomllib
+
+LOGGER = logging.getLogger(__name__)
+PROJECT_NAME = "cursor-portable"
+RELEASE_VERSION = re.compile(r"^\d+\.\d+\.\d+$")
+_STAMP = "VERSION"
+
+
+def read_project_fields(text: str) -> tuple[str | None, str | None]:
+    """Return the project name and version from pyproject text.
+
+    Invalid TOML raises ``ValueError``. A file without a project table
+    returns ``(None, None)``.
+    """
+    try:
+        document: object = tomllib.loads(text)
+    except tomllib.TOMLDecodeError as exc:
+        raise ValueError(f"pyproject.toml is invalid: {exc}") from exc
+    if not isinstance(document, dict):
+        raise ValueError("pyproject.toml is not a table")
+    project = document.get("project")
+    if not isinstance(project, dict):
+        return None, None
+    name = project.get("name")
+    version = project.get("version")
+    project_name = name.strip() if isinstance(name, str) else ""
+    project_version = version.strip() if isinstance(version, str) else ""
+    return project_name or None, project_version or None
+
+
+def read_stamp(package_dir: Path) -> str | None:
+    """Return the version stamped beside a copied package."""
+    path = package_dir / _STAMP
+    if not path.is_file():
+        return None
+    text = path.read_text(encoding="utf-8").strip()
+    if not text:
+        return None
+    LOGGER.debug("Using stamped version %s from %s", text, path)
+    return text
+
+
+def nearest_project_version(start: Path) -> str | None:
+    """Return this project's version from the nearest pyproject.toml."""
+    for directory in (start, *start.parents):
+        candidate = directory / "pyproject.toml"
+        if not candidate.is_file():
+            continue
+        name, version = read_project_fields(candidate.read_text(encoding="utf-8"))
+        if name == PROJECT_NAME and version:
+            LOGGER.debug("Using version %s from %s", version, candidate)
+            return version
+        LOGGER.debug("Ignoring %s while resolving the package version", candidate)
+        return None
+    return None
+
+
+def resolve_version(package_dir: Path | None = None) -> str:
+    """Return the package version from a stamp, pyproject.toml, or metadata."""
+    origin = Path(__file__).resolve().parent if package_dir is None else package_dir
+    stamped = read_stamp(origin)
+    if stamped:
+        return stamped
+    found = nearest_project_version(origin)
+    if found:
+        return found
+    try:
+        installed = importlib.metadata.version(PROJECT_NAME)
+    except importlib.metadata.PackageNotFoundError:
+        installed = ""
+    if installed:
+        LOGGER.debug("Using installed metadata version %s", installed)
+        return installed
+    raise RuntimeError(
+        "cursor-portable version is not in a VERSION stamp, pyproject.toml, "
+        "or package metadata."
+    )
+
+
+def write_version_stamp(package_dir: Path, version: str) -> None:
+    """Write the version next to a copied package."""
+    text = version.strip()
+    if not text:
+        raise ValueError("Refusing to stamp an empty version")
+    path = package_dir / _STAMP
+    path.write_text(f"{text}\n", encoding="utf-8")
+    LOGGER.info("Stamped %s %s at %s", PROJECT_NAME, text, path)
+
+
+__version__ = resolve_version()

cursor_portable/cli/__init__.py

@@ -0,0 +1 @@
+"""Command line entry points."""

cursor_portable/cli/args.py

@@ -0,0 +1,46 @@
+"""Argument parser for ``cursor-portable``."""
+
+from __future__ import annotations
+
+import argparse
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Return the command line parser."""
+    parser = argparse.ArgumentParser(prog="cursor-portable")
+    parser.add_argument("--version", action="store_true")
+    commands = parser.add_subparsers(dest="command")
+    commands.add_parser("wizard")
+    launch = commands.add_parser("launch")
+    launch.add_argument("--root", required=True)
+    commands.add_parser("uninstall-host")
+    commands.add_parser("uninstall")
+    pack = commands.add_parser("pack-sfx")
+    pack.add_argument("--module", required=True)
+    pack.add_argument("--archive", required=True)
+    pack.add_argument("--output", required=True)
+    posix = commands.add_parser("pack-posix")
+    posix.add_argument("--extractor", required=True)
+    posix.add_argument("--archive", required=True)
+    posix.add_argument("--output", required=True)
+    repair = commands.add_parser("repair")
+    _add_disk_arguments(repair)
+    repair.add_argument("--apply", action="store_true")
+    fmt = commands.add_parser("format-volume")
+    _add_disk_arguments(fmt)
+    fmt.add_argument("--apply", action="store_true")
+    return parser
+
+
+def _add_disk_arguments(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--device", required=True)
+    parser.add_argument("--mount", required=True)
+    parser.add_argument("--label", default="")
+    parser.add_argument("--filesystem", required=True)
+    parser.add_argument("--typed", required=True)
+    parser.add_argument("--removable", action="store_true")
+    parser.add_argument("--system-disk", action="store_true")
+    parser.add_argument("--boot-disk", action="store_true")
+    parser.add_argument("--size", type=int, default=0)
+    parser.add_argument("--target", default="")
+    parser.add_argument("--read-only", action="store_true")

cursor_portable/cli/disk_cmd.py

@@ -0,0 +1,142 @@
+"""Format and repair commands that print a plan unless ``--apply`` is set."""
+
+from __future__ import annotations
+
+import argparse
+import logging
+
+from cursor_portable.disk.apply import apply_repair
+from cursor_portable.disk.commands import DiskPlan, RepairMode, format_plan, repair_plan
+from cursor_portable.disk.listing import load_probed_volumes
+from cursor_portable.disk.spawn import capture_command
+from cursor_portable.disk.volume import Volume
+from cursor_portable.failure import Failure
+from cursor_portable.host.activity import volume_busy
+from cursor_portable.models import HostSystem
+
+LOGGER = logging.getLogger(__name__)
+
+
+def volume_from_args(args: argparse.Namespace) -> Volume:
+    """Build a volume from explicit command arguments."""
+    return Volume(
+        device_id=str(args.device),
+        mount_point=str(args.mount),
+        label=str(args.label),
+        filesystem=str(args.filesystem),
+        size_bytes=int(args.size),
+        removable=bool(args.removable),
+        is_system=bool(args.system_disk),
+        is_boot=bool(args.boot_disk),
+        writable=not bool(getattr(args, "read_only", False)),
+    )
+
+
+def _probed_volume(
+    device_id: str,
+    system: HostSystem,
+    probed: tuple[Volume, ...] | None,
+) -> Volume | Failure:
+    volumes = probed if probed is not None else load_probed_volumes(system)
+    if isinstance(volumes, Failure):
+        return volumes
+    for item in volumes:
+        if item.device_id.casefold() == device_id.casefold():
+            return item
+    return Failure("missing-volume", f"{device_id} is not a mounted volume.")
+
+
+def chosen_target(args: argparse.Namespace, host: HostSystem) -> HostSystem | Failure:
+    """Return ``--target`` or the computer running the command."""
+    raw = str(getattr(args, "target", "") or "")
+    if not raw:
+        return host
+    try:
+        return HostSystem(raw)
+    except ValueError:
+        return Failure("target", f"Unknown target system: {raw}.")
+
+
+def run_disk_command(
+    args: argparse.Namespace,
+    system: HostSystem,
+    *,
+    repair: bool,
+    probed: tuple[Volume, ...] | None = None,
+) -> int:
+    """Print the plan. Run it only when ``--apply`` is present."""
+    volume = volume_from_args(args)
+    if args.apply:
+        matched = _probed_volume(volume.device_id, system, probed)
+        if isinstance(matched, Failure):
+            LOGGER.error("%s", matched.message)
+            print(matched.message)
+            return 1
+        volume = matched
+    busy = volume_busy(volume, system)
+    target = chosen_target(args, system)
+    if isinstance(target, Failure):
+        LOGGER.error("%s", target.message)
+        print(target.message)
+        return 1
+    if repair:
+        plan: DiskPlan | Failure = repair_plan(
+            volume,
+            str(args.typed),
+            system,
+            RepairMode.APPLY if args.apply else RepairMode.CHECK,
+            busy=busy,
+            target=target,
+        )
+    else:
+        plan = format_plan(
+            volume,
+            str(args.typed),
+            system,
+            busy=busy,
+            target=target,
+        )
+    if isinstance(plan, Failure):
+        LOGGER.error("%s", plan.message)
+        print(plan.message)
+        return 1
+    print(plan.summary)
+    print(" ".join(plan.command))
+    if not args.apply:
+        return 0
+    LOGGER.info("Applying disk command: %s", plan.command)
+    if repair:
+        failure = apply_repair(plan)
+        if failure is not None:
+            LOGGER.error("%s", failure.message)
+            print(failure.message)
+            return 1
+        return 0
+    return execute_plan(plan)
+
+
+def execute_plan_result(plan: DiskPlan) -> Failure | None:
+    """Run a format command. Windows asks for approval when this process is not elevated."""
+    captured = capture_command(plan.command, elevate=plan.needs_elevation)
+    if isinstance(captured, Failure):
+        return captured
+    code, output = captured
+    if output.strip():
+        LOGGER.info("%s", output[-4000:])
+    if code != 0:
+        detail = output.strip().splitlines()[-1] if output.strip() else ""
+        message = f"Disk command exited {code}."
+        if detail:
+            message = f"{message} {detail}"
+        return Failure("disk", message)
+    return None
+
+
+def execute_plan(plan: DiskPlan) -> int:
+    """Run a format or repair command that already passed the guards."""
+    failure = execute_plan_result(plan)
+    if failure is None:
+        return 0
+    LOGGER.error("%s", failure.message)
+    print(failure.message)
+    return 1

cursor_portable/cli/launch_cmd.py

@@ -0,0 +1,175 @@
+"""Launch and host uninstall. These talk to the real user profile."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+import logging
+import os
+from pathlib import Path
+
+from cursor_portable.host.cleanup import (
+    cache_directory,
+    cleanup_session,
+    default_host_root,
+    delete_managed_shortcuts,
+    delete_runtime_cache,
+)
+from cursor_portable.launcher.host_watch import (
+    read_processes,
+    read_shortcuts,
+    restore_shortcuts,
+    stop_processes,
+    write_managed_shortcut,
+)
+from cursor_portable.launcher.launch_plan import LaunchCommand, build_launch
+from cursor_portable.launcher.links import DirectoryLinker
+from cursor_portable.launcher.path_store import (
+    PathStore,
+    path_store_for,
+    shell_rc_paths,
+)
+from cursor_portable.launcher.processes import pid_alive
+from cursor_portable.launcher.runner import run_until_exit
+from cursor_portable.launcher.session import LaunchHooks, run_launch
+from cursor_portable.launcher.session_file import read_session
+from cursor_portable.launcher.shortcuts import Shortcut
+from cursor_portable.models import HostSystem, host_system_name
+from cursor_portable.repack.layout import StickLayout
+from cursor_portable.runtime import is_windows
+
+LOGGER = logging.getLogger(__name__)
+
+
+def _alive(pid: int) -> bool:
+    if pid <= 0:
+        return False
+    if is_windows():
+        return pid_alive(pid)
+    try:
+        os.kill(pid, 0)
+    except OSError:
+        return False
+    return True
+
+
+def _host_root(system: HostSystem) -> Path:
+    local = os.environ.get("LOCALAPPDATA")
+    local_path = Path(local) if local else None
+    return default_host_root(
+        Path.home(),
+        local_path,
+        windows=system is HostSystem.WINDOWS,
+    )
+
+
+def _run_command(command: LaunchCommand, on_tick: Callable[[], None]) -> int:
+    return run_until_exit(command, dict(os.environ), on_tick)
+
+
+def _path_store(system: HostSystem) -> PathStore:
+    paths = shell_rc_paths(Path.home(), system)
+    return path_store_for(system, None if not paths else paths)
+
+
+def _hooks(system: HostSystem, layout: StickLayout) -> LaunchHooks:
+    launcher = (
+        layout.windows_launcher
+        if system is HostSystem.WINDOWS
+        else layout.unix_launcher
+    )
+    return LaunchHooks(
+        store=_path_store(system),
+        linker=DirectoryLinker(),
+        run=_run_command,
+        processes=read_processes,
+        stop=stop_processes,
+        read_shortcuts=read_shortcuts,
+        restore_shortcuts=restore_shortcuts,
+        alive=_alive,
+        ensure_shortcut=lambda: write_managed_shortcut(
+            launcher,
+            windows=system is HostSystem.WINDOWS,
+        ),
+    )
+
+
+def _stop_nothing(pids: tuple[int, ...]) -> None:
+    LOGGER.info("Installer pids not stopped by the default hook: %s", pids)
+
+
+def _restore_nothing(items: tuple[Shortcut, ...]) -> None:
+    LOGGER.info("Shortcut restore received %s items", len(items))
+
+
+def launch_root(root: Path) -> int:
+    """Start Cursor from a ``CursorPortable`` directory."""
+    system = host_system_name()
+    layout = StickLayout.from_root(root)
+    host = _host_root(system)
+    cache = cache_directory(host, layout.root)
+    scratch = host / "scratch"
+    LOGGER.info("Launching %s with cache %s", layout.root, cache)
+    return run_launch(
+        layout,
+        host,
+        cache,
+        scratch,
+        Path.home() / ".cursor",
+        system,
+        _hooks(system, layout),
+    )
+
+
+def uninstall_host() -> int:
+    """Remove host leftovers. The removable drive is not changed."""
+    system = host_system_name()
+    host = _host_root(system)
+    session_path = host / "session.txt"
+    record = read_session(session_path)
+    store = _path_store(system)
+    if record is not None and _session_busy(record.pid):
+        LOGGER.error("Cursor Portable is still running as pid %s", record.pid)
+        return 3
+    if record is not None:
+        cleanup_session(record, store, DirectoryLinker(), delete_cache=True)
+        session_path.unlink(missing_ok=True)
+    delete_runtime_cache(host)
+    removed = delete_managed_shortcuts(_shortcut_candidates())
+    LOGGER.info("Removed %s managed shortcuts", len(removed))
+    return 0
+
+
+def _session_busy(pid_text: str) -> bool:
+    try:
+        previous = int(pid_text)
+    except ValueError:
+        return False
+    return _alive(previous)
+
+
+def _shortcut_candidates() -> tuple[Path, ...]:
+    home = Path.home()
+    roots = [
+        home / "Desktop",
+        home / ".local" / "share" / "applications",
+    ]
+    appdata = os.environ.get("APPDATA")
+    if appdata:
+        roots.append(
+            Path(appdata) / "Microsoft" / "Windows" / "Start Menu" / "Programs"
+        )
+    names = ("Cursor Portable.lnk", "cursor-portable.desktop")
+    found: list[Path] = []
+    for root in roots:
+        for name in names:
+            candidate = root / name
+            if candidate.is_file():
+                found.append(candidate)
+    return tuple(found)
+
+
+def describe_launch(root: Path, system: HostSystem) -> tuple[str, ...]:
+    """Return the Cursor command without starting it."""
+    layout = StickLayout.from_root(root)
+    command = build_launch(layout, root / "cache", root / "scratch", system)
+    return command.argv

cursor_portable/cli/live.py

@@ -0,0 +1,202 @@
+"""Wire the wizard to a payload directory. Disk plans still go through the guards."""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import os
+from pathlib import Path
+
+from cursor_portable.cli.disk_cmd import execute_plan_result
+from cursor_portable.cli.launch_cmd import uninstall_host
+from cursor_portable.disk.apply import apply_repair
+from cursor_portable.disk.commands import DiskPlan
+from cursor_portable.disk.filesystem import display_filesystem, filesystem_for
+from cursor_portable.disk.listing import load_probed_volumes
+from cursor_portable.disk.volume import Volume, confirmation_hint, label_matches
+from cursor_portable.failure import Failure
+from cursor_portable.host.activity import cursor_editor_running, volume_busy
+from cursor_portable.install.acquire import Progress, acquire_payload, payload_cache
+from cursor_portable.install.apply import install_tree, scope_dir
+from cursor_portable.models import (
+    HostSystem,
+    InstallChoices,
+    ProfileMode,
+    host_system_name,
+)
+from cursor_portable.profile.sources import profile_sources
+from cursor_portable.repack.archive import run_command, seven_zip_extract
+from cursor_portable.repack.layout import StickLayout
+from cursor_portable.wizard.flow import DriveDisposition, classify_drive
+from cursor_portable.wizard.window import WizardCallbacks
+
+LOGGER = logging.getLogger(__name__)
+
+
+def payload_directory(argv: list[str] | None = None) -> Path | None:
+    """Read ``--payload-dir`` or ``--payload``."""
+    parser = argparse.ArgumentParser(add_help=False)
+    parser.add_argument("--payload-dir")
+    parser.add_argument("--payload")
+    known, _unused = parser.parse_known_args(argv)
+    if known.payload_dir:
+        return Path(str(known.payload_dir))
+    if known.payload:
+        return Path(str(known.payload))
+    return None
+
+
+def bundled_extractor() -> str:
+    """Use the extractor shipped beside the wizard, then a system 7-Zip."""
+    override = os.environ.get("CURSOR_PORTABLE_7Z")
+    if override:
+        return override
+    for name in ("7zz.exe", "7zz", "7z.exe", "7z"):
+        candidate = Path.cwd() / name
+        if candidate.is_file():
+            return str(candidate)
+    return "7z"
+
+
+def _extract_payload(path: Path) -> Path | Failure:
+    if path.is_dir():
+        return path
+    extractor = bundled_extractor()
+    destination = path.parent / f"{path.stem}-extracted"
+    failure = run_command(seven_zip_extract(extractor, path, destination))
+    if failure is not None:
+        return failure
+    return destination
+
+
+def _run_plan(plan: DiskPlan) -> Failure | None:
+    return execute_plan_result(plan)
+
+
+def _refuse_unready(
+    choices: InstallChoices,
+    volume: Volume,
+    host: HostSystem,
+) -> Failure | None:
+    if not label_matches(volume, choices.typed_label):
+        message = (
+            "Type the volume label exactly."
+            if volume.label.strip()
+            else confirmation_hint(volume)
+        )
+        return Failure("label-mismatch", message)
+    disposition = classify_drive(
+        volume,
+        host,
+        choices.target_os,
+        busy=volume_busy(volume, host),
+    )
+    if isinstance(disposition, Failure):
+        return disposition
+    if disposition is DriveDisposition.READY:
+        return None
+    expected = display_filesystem(filesystem_for(choices.target_os))
+    return Failure(
+        "needs-format",
+        f"Format the drive as {expected} before installing.",
+    )
+
+
+def _acquire_payload(
+    choices: InstallChoices,
+    host: HostSystem,
+    payload: Path | None,
+    progress: Progress | None,
+) -> Path | Failure:
+    if payload is None:
+        payload = payload_cache()
+        LOGGER.info("No payload was provided. Downloading into %s", payload)
+        if progress is not None:
+            progress("Downloading Cursor. This can take several minutes.")
+        downloaded = acquire_payload(choices, host, payload, progress=progress)
+        if downloaded is not None:
+            return downloaded
+    return _extract_payload(payload)
+
+
+def install_payload(
+    choices: InstallChoices,
+    volume: Volume,
+    payload: Path | None,
+    *,
+    system: HostSystem | None = None,
+    progress: Progress | None = None,
+) -> Failure | None:
+    """Install after the wizard has already checked the label and filesystem."""
+    host = host_system_name() if system is None else system
+    refused = _refuse_unready(choices, volume, host)
+    if refused is not None:
+        return refused
+    if choices.profile is ProfileMode.COPY and choices.target_os is not host:
+        return Failure(
+            "profile",
+            "Settings from this computer are only copied onto a stick for the same system.",
+        )
+    opened = _acquire_payload(choices, host, payload, progress)
+    if isinstance(opened, Failure):
+        return opened
+    sources = None
+    if choices.profile.value == "copy":
+        loaded = profile_sources(host)
+        if isinstance(loaded, Failure):
+            return loaded
+        sources = loaded
+    return install_tree(
+        scope_dir(opened, choices.scope),
+        StickLayout.from_mount(Path(volume.mount_point)),
+        choices,
+        host,
+        sources=sources,
+        cursor_running=cursor_editor_running(),
+        python_source=opened / "python" if (opened / "python").is_dir() else None,
+        cli_source=opened / "cli" if (opened / "cli").is_dir() else None,
+        tool_source=opened / "tool" if (opened / "tool").is_dir() else None,
+        progress=progress,
+    )
+
+
+def wizard_callbacks(
+    volumes: tuple[Volume, ...] = (),
+    payload: Path | None = None,
+    system: HostSystem | None = None,
+    *,
+    probe: bool = False,
+) -> WizardCallbacks:
+    """Build wizard callbacks. Volumes default to the list the caller supplies."""
+    host = host_system_name() if system is None else system
+
+    def listed() -> tuple[Volume, ...] | Failure:
+        if volumes:
+            return volumes
+        if probe:
+            return load_probed_volumes(host)
+        return ()
+
+    callbacks_ref: list[WizardCallbacks] = []
+
+    def install(choices: InstallChoices, volume: Volume) -> Failure | None:
+        current = callbacks_ref[0].progress if callbacks_ref else None
+        return install_payload(choices, volume, payload, system=host, progress=current)
+
+    def run_format(plan: DiskPlan) -> Failure | None:
+        return _run_plan(plan)
+
+    def run_repair(plan: DiskPlan) -> Failure | None:
+        return apply_repair(plan)
+
+    built = WizardCallbacks(
+        volumes=listed,
+        busy=lambda volume: volume_busy(volume, host),
+        run_format=run_format,
+        run_repair=run_repair,
+        install=install,
+        system=host,
+        uninstall=uninstall_host,
+    )
+    callbacks_ref.append(built)
+    return built