promty-collector 0.1.0 → 0.1.2

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "promty-collector",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Promty local event collector",
   "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NaHyeongyu/BuildHub.git"
+  },
   "type": "module",
   "bin": {
     "promty": "bin/promty.js",

package/src/cli.py

@@ -5,6 +5,7 @@ from http.server import BaseHTTPRequestHandler, HTTPServer
 import json
 import os
 import secrets
+import shlex
 import subprocess
 import sys
 import time
@@ -40,13 +41,16 @@ from payloads import (
     WORKSPACE_KEYS,
     get_first_string,
 )
-from runtime_install import install_runtime, quote_command_path
+from runtime_install import install_runtime, launcher_path, quote_command_path
 from sequence import SequenceStore
 from session_index import SessionIndex
 from uploader.client import PromptHubUploader
 from uploader.queue import JSONLQueue
+from updater import auto_update
+from version import COLLECTOR_VERSION
 
 InstallTarget = Literal["all", "claude-code", "codex-cli"]
+Profile = Literal["dev", "prod"]
 INSTALL_TOOLS: tuple[SupportedTool, ...] = ("codex-cli", "claude-code")
 INSTALL_TOOL_ALIASES: dict[str, InstallTarget] = {
     "all": "all",
@@ -55,6 +59,11 @@ INSTALL_TOOL_ALIASES: dict[str, InstallTarget] = {
     "codex": "codex-cli",
     "codex-cli": "codex-cli",
 }
+PROFILE_URLS: dict[Profile, tuple[str, str]] = {
+    "dev": ("http://127.0.0.1:5173", "http://127.0.0.1:8011"),
+    "prod": ("https://promty.org", "https://api.promty.org"),
+}
+AUTO_UPDATE_INTERVAL_SECONDS = 6 * 60 * 60
 CODEX_HOOKS: tuple[dict[str, Any], ...] = (
     {
         "event": "UserPromptSubmit",
@@ -184,6 +193,26 @@ def _tools_for_install_target(target: InstallTarget) -> tuple[SupportedTool, ...
     return (target,)
 
 
+def _apply_profile_defaults(args: argparse.Namespace) -> None:
+    profile = getattr(args, "profile", None)
+    if not profile:
+        return
+
+    profile_root = Path("~/.prompthub/profiles").expanduser() / profile
+    app_url, api_url = PROFILE_URLS[profile]
+    defaults = {
+        "app_url": app_url,
+        "api_url": api_url,
+        "config_path": str(profile_root / "config.json"),
+        "queue_path": str(profile_root / "events"),
+        "pid_path": str(profile_root / "uploader.pid"),
+        "log_path": str(profile_root / "uploader.log"),
+    }
+    for name, value in defaults.items():
+        if hasattr(args, name) and getattr(args, name) is None:
+            setattr(args, name, value)
+
+
 def _apply_known_session(
     *,
     index: SessionIndex,
@@ -348,8 +377,20 @@ def upload(args: argparse.Namespace) -> int:
         f"{JSONLQueue(args.queue_path).path} -> {api_url} "
         f"every {interval:g}s"
     )
+    next_update_check = 0.0
     while True:
         try:
+            now = time.monotonic()
+            if not args.no_auto_update and now >= next_update_check:
+                next_update_check = now + AUTO_UPDATE_INTERVAL_SECONDS
+                updated_version = auto_update()
+                if updated_version:
+                    print(
+                        f"Promty updated {COLLECTOR_VERSION} -> {updated_version}; restarting",
+                        flush=True,
+                    )
+                    launcher = launcher_path()
+                    os.execv(str(launcher), [str(launcher), *sys.argv[1:]])
             uploaded_count = _upload_queued_events(args)
             if uploaded_count:
                 print(f"Uploaded {uploaded_count} events", flush=True)
@@ -615,6 +656,7 @@ def _install_codex_hooks(
     command_prefix: str,
     normalized_tool: SupportedTool,
     repo_root: Path,
+    queue_path: str | None = None,
 ) -> int:
     hooks_path = repo_root / ".codex" / "hooks.json"
     config = _read_hooks_config(hooks_path)
@@ -622,6 +664,8 @@ def _install_codex_hooks(
 
     for spec in CODEX_HOOKS:
         command = f"{command_prefix} {spec['subcommand']} --tool {normalized_tool}"
+        if queue_path:
+            command += f" --queue-path {shlex.quote(str(Path(queue_path).expanduser()))}"
         hook = {
             "type": "command",
             "command": command,
@@ -649,6 +693,7 @@ def _install_claude_hooks(
     command_prefix: str,
     normalized_tool: SupportedTool,
     repo_root: Path,
+    queue_path: str | None = None,
 ) -> int:
     settings_path = repo_root / ".claude" / "settings.local.json"
     config = _read_hooks_config(settings_path)
@@ -656,6 +701,8 @@ def _install_claude_hooks(
 
     for spec in CLAUDE_HOOKS:
         command = f"{command_prefix} {spec['subcommand']} --tool {normalized_tool}"
+        if queue_path:
+            command += f" --queue-path {shlex.quote(str(Path(queue_path).expanduser()))}"
         hook = {
             "type": "command",
             "command": command,
@@ -687,6 +734,8 @@ def install_hooks(args: argparse.Namespace) -> int:
         command_prefix = quote_command_path(launcher_path)
         print(f"Promty runtime ready: {launcher_path}")
 
+    queue_path = getattr(args, "queue_path", None)
+
     failures: list[tuple[SupportedTool, Exception]] = []
     for normalized_tool in _tools_for_install_target(target):
         try:
@@ -695,12 +744,14 @@ def install_hooks(args: argparse.Namespace) -> int:
                     command_prefix=command_prefix,
                     normalized_tool=normalized_tool,
                     repo_root=repo_root,
+                    queue_path=queue_path,
                 )
             elif normalized_tool == "claude-code":
                 _install_claude_hooks(
                     command_prefix=command_prefix,
                     normalized_tool=normalized_tool,
                     repo_root=repo_root,
+                    queue_path=queue_path,
                 )
             else:
                 raise AssertionError(f"Unexpected hook tool: {normalized_tool}")
@@ -757,6 +808,10 @@ def start_uploader(args: argparse.Namespace) -> int:
         "--interval",
         str(max(args.interval, 0.25)),
     ]
+    if getattr(args, "queue_path", None):
+        command.extend(["--queue-path", str(Path(args.queue_path).expanduser())])
+    if getattr(args, "no_auto_update", False):
+        command.append("--no-auto-update")
     process = subprocess.Popen(
         command,
         stdout=log_file,
@@ -910,6 +965,7 @@ def init(args: argparse.Namespace) -> int:
         source=None,
         repo_root=args.repo_root,
         hook_command=args.hook_command,
+        queue_path=args.queue_path,
     )
     hooks_result = install_hooks(install_args)
 
@@ -920,6 +976,8 @@ def init(args: argparse.Namespace) -> int:
             interval=args.upload_interval,
             log_path=args.log_path,
             pid_path=args.pid_path,
+            queue_path=args.queue_path,
+            no_auto_update=args.no_auto_update,
             token=args.token,
         )
         start_uploader(uploader_args)
@@ -997,6 +1055,8 @@ def build_parser() -> argparse.ArgumentParser:
     upload_parser.add_argument("--token", default=None)
     upload_parser.add_argument("--config-path")
     upload_parser.add_argument("--queue-path")
+    upload_parser.add_argument("--profile", choices=sorted(PROFILE_URLS))
+    upload_parser.add_argument("--no-auto-update", action="store_true")
     upload_parser.add_argument("--limit", type=int, default=100)
     upload_parser.add_argument("--timeout", type=float, default=10)
     upload_parser.add_argument(
@@ -1017,6 +1077,7 @@ def build_parser() -> argparse.ArgumentParser:
     login_parser.add_argument("--api-url")
     login_parser.add_argument("--callback-port", type=int, default=0)
     login_parser.add_argument("--config-path")
+    login_parser.add_argument("--profile", choices=sorted(PROFILE_URLS))
     login_parser.add_argument("--no-browser", action="store_true")
     login_parser.add_argument("--timeout", type=float, default=180)
     login_parser.add_argument("--token")
@@ -1036,6 +1097,8 @@ def build_parser() -> argparse.ArgumentParser:
         help="Deprecated alias for --tool",
     )
     install_hooks_parser.add_argument("--repo-root")
+    install_hooks_parser.add_argument("--profile", choices=sorted(PROFILE_URLS))
+    install_hooks_parser.add_argument("--queue-path")
     install_hooks_parser.add_argument(
         "--hook-command",
         help="Command prefix that the AI tool should call before the hook subcommand.",
@@ -1048,6 +1111,9 @@ def build_parser() -> argparse.ArgumentParser:
     start_uploader_parser.add_argument("--interval", type=float, default=2)
     start_uploader_parser.add_argument("--log-path")
     start_uploader_parser.add_argument("--pid-path")
+    start_uploader_parser.add_argument("--profile", choices=sorted(PROFILE_URLS))
+    start_uploader_parser.add_argument("--queue-path")
+    start_uploader_parser.add_argument("--no-auto-update", action="store_true")
     start_uploader_parser.add_argument("--token")
     start_uploader_parser.set_defaults(func=start_uploader)
 
@@ -1059,6 +1125,7 @@ def build_parser() -> argparse.ArgumentParser:
     doctor_parser.add_argument("--repo-root")
     doctor_parser.add_argument("--timeout", type=float, default=3)
     doctor_parser.add_argument("--token")
+    doctor_parser.add_argument("--profile", choices=sorted(PROFILE_URLS))
     doctor_parser.add_argument(
         "--tool",
         choices=sorted(INSTALL_TOOL_ALIASES),
@@ -1076,6 +1143,9 @@ def build_parser() -> argparse.ArgumentParser:
     init_parser.add_argument("--log-path")
     init_parser.add_argument("--no-browser", action="store_true")
     init_parser.add_argument("--pid-path")
+    init_parser.add_argument("--profile", choices=sorted(PROFILE_URLS))
+    init_parser.add_argument("--queue-path")
+    init_parser.add_argument("--no-auto-update", action="store_true")
     init_parser.add_argument("--repo-root")
     init_parser.add_argument("--skip-login", action="store_true")
     init_parser.add_argument("--skip-uploader", action="store_true")
@@ -1090,12 +1160,22 @@ def build_parser() -> argparse.ArgumentParser:
     init_parser.add_argument("--upload-interval", type=float, default=2)
     init_parser.set_defaults(func=init)
 
+    update_runtime_parser = subparsers.add_parser("update-runtime")
+    update_runtime_parser.set_defaults(func=lambda _: _update_runtime())
+
     return parser
 
 
+def _update_runtime() -> int:
+    path = install_runtime()
+    print(f"Promty {COLLECTOR_VERSION} runtime ready: {path}")
+    return 0
+
+
 def main(argv: Sequence[str] | None = None) -> int:
     parser = build_parser()
     args = parser.parse_args(argv)
+    _apply_profile_defaults(args)
     try:
         return args.func(args)
     except KeyboardInterrupt:

package/src/runtime_install.py

@@ -25,6 +25,8 @@ RUNTIME_MODULES: tuple[str, ...] = (
     "runtime_install.py",
     "sequence.py",
     "session_index.py",
+    "updater.py",
+    "version.py",
 )
 RUNTIME_PACKAGES: tuple[str, ...] = ("adapters", "uploader")
 

package/src/updater.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+from urllib import request
+
+from version import COLLECTOR_VERSION
+
+
+NPM_PACKAGE = "promty-collector"
+NPM_REGISTRY_URL = f"https://registry.npmjs.org/{NPM_PACKAGE}/latest"
+
+
+def _version_tuple(value: str) -> tuple[int, ...]:
+    core = value.strip().split("-", 1)[0]
+    try:
+        return tuple(int(part) for part in core.split("."))
+    except ValueError:
+        return ()
+
+
+def latest_version(timeout: float = 5) -> str | None:
+    with request.urlopen(NPM_REGISTRY_URL, timeout=timeout) as response:
+        payload = json.loads(response.read().decode("utf-8"))
+    version = payload.get("version")
+    return version.strip() if isinstance(version, str) and version.strip() else None
+
+
+def update_available(current: str, latest: str) -> bool:
+    current_parts = _version_tuple(current)
+    latest_parts = _version_tuple(latest)
+    return bool(current_parts and latest_parts and latest_parts > current_parts)
+
+
+def install_latest(version: str) -> bool:
+    npx = shutil.which("npx")
+    if npx is None:
+        return False
+    result = subprocess.run(
+        [npx, "--yes", f"{NPM_PACKAGE}@{version}", "update-runtime"],
+        check=False,
+        capture_output=True,
+        text=True,
+        timeout=120,
+    )
+    if result.returncode != 0:
+        message = result.stderr.strip() or result.stdout.strip() or "unknown error"
+        raise RuntimeError(f"automatic update failed: {message}")
+    return True
+
+
+def auto_update() -> str | None:
+    newest = latest_version()
+    if newest is None or not update_available(COLLECTOR_VERSION, newest):
+        return None
+    return newest if install_latest(newest) else None

package/src/uploader/client.py

@@ -4,6 +4,8 @@ import json
 from typing import Any
 from urllib import request
 
+from version import COLLECTOR_VERSION
+
 
 class PromptHubUploader:
     def __init__(self, api_url: str, token: str | None = None, timeout: float = 10) -> None:
@@ -16,7 +18,10 @@ class PromptHubUploader:
             return []
 
         body = json.dumps({"events": events}).encode("utf-8")
-        headers = {"Content-Type": "application/json"}
+        headers = {
+            "Content-Type": "application/json",
+            "X-Promty-Collector-Version": COLLECTOR_VERSION,
+        }
         if self.token:
             headers["Authorization"] = f"Bearer {self.token}"
 

package/src/version.py

@@ -0,0 +1 @@
+COLLECTOR_VERSION = "0.1.2"