onako 0.2.0__tar.gz → 0.3.0__tar.gz

{onako-0.2.0 → onako-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onako
-Version: 0.2.0
+Version: 0.3.0
 Summary: Dispatch and monitor Claude Code tasks from your phone
 Author: Amir
 License-Expression: MIT
@@ -32,27 +32,21 @@ Requires [tmux](https://github.com/tmux/tmux) and [Claude Code](https://docs.ant
 ## Usage
 
 ```bash
-cd ~/projects
-onako serve
+onako                              # starts server, drops you into tmux
+onako --session my-project         # custom session name
 ```
 
-Open http://localhost:8787 on your phone (same network) or set up [Tailscale](https://tailscale.com) for access from anywhere.
-
-### Run in the background
-
-```bash
-onako serve --background
-```
-
-This installs a system service (launchd on macOS, systemd on Linux) that starts on boot. Tasks run in the directory where you ran the command.
+If you're already inside tmux, onako auto-detects your session and skips the attach. Open http://localhost:8787 on your phone (same network) or set up [Tailscale](https://tailscale.com) for access from anywhere.
 
 ```bash
-onako serve --background --dir ~/projects   # override working directory
-onako status                                 # check if running
-onako stop                                   # stop the background service
-onako version                                # print version
+onako stop                         # stop the background server
+onako status                       # check if running
+onako serve                        # foreground server (for development)
+onako version                      # print version
 ```
 
 ## How it works
 
-Each task is a tmux window running an interactive Claude Code session. The web dashboard reads tmux output and lets you send messages to running sessions. Task state is persisted in SQLite so it survives server restarts.
+Onako monitors all tmux windows in the configured session. Windows it creates (via the dashboard) are "managed" tasks. Windows created by you or other tools are discovered automatically as "external" — both get full dashboard support: view output, send messages, kill.
+
+Task state is persisted in SQLite so it survives server restarts.

onako-0.3.0/README.md

@@ -0,0 +1,35 @@
+# Onako
+
+Dispatch and monitor Claude Code tasks from your phone.
+
+Onako is a lightweight server that runs on your machine. It spawns Claude Code sessions in tmux, and you monitor them through a mobile-friendly web dashboard. Fire off tasks from an iOS Shortcut or the dashboard, check in from anywhere.
+
+## Install
+
+```bash
+pipx install onako
+```
+
+Requires [tmux](https://github.com/tmux/tmux) and [Claude Code](https://docs.anthropic.com/en/docs/claude-code).
+
+## Usage
+
+```bash
+onako                              # starts server, drops you into tmux
+onako --session my-project         # custom session name
+```
+
+If you're already inside tmux, onako auto-detects your session and skips the attach. Open http://localhost:8787 on your phone (same network) or set up [Tailscale](https://tailscale.com) for access from anywhere.
+
+```bash
+onako stop                         # stop the background server
+onako status                       # check if running
+onako serve                        # foreground server (for development)
+onako version                      # print version
+```
+
+## How it works
+
+Onako monitors all tmux windows in the configured session. Windows it creates (via the dashboard) are "managed" tasks. Windows created by you or other tools are discovered automatically as "external" — both get full dashboard support: view output, send messages, kill.
+
+Task state is persisted in SQLite so it survives server restarts.

{onako-0.2.0 → onako-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "onako"
-version = "0.2.0"
+version = "0.3.0"
 description = "Dispatch and monitor Claude Code tasks from your phone"
 readme = "README.md"
 license = "MIT"

onako-0.3.0/src/onako/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.0"

onako-0.3.0/src/onako/cli.py

@@ -0,0 +1,338 @@
+import os
+import platform
+import socket
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+import click
+
+ONAKO_DIR = Path.home() / ".onako"
+LOG_DIR = ONAKO_DIR / "logs"
+PID_FILE = ONAKO_DIR / "onako.pid"
+
+
+@click.group(invoke_without_command=True)
+@click.option("--host", default="0.0.0.0", help="Host to bind to.")
+@click.option("--port", default=8787, type=int, help="Port to bind to.")
+@click.option("--session", default="onako", help="tmux session name (auto-detected if inside tmux).")
+@click.option("--dir", "working_dir", default=None, type=click.Path(exists=True), help="Working directory for tasks (default: current directory).")
+@click.pass_context
+def main(ctx, host, port, session, working_dir):
+    """Onako — Dispatch and monitor Claude Code tasks from your phone."""
+    if ctx.invoked_subcommand is not None:
+        return
+
+    _check_prerequisites()
+    working_dir = str(Path(working_dir).resolve()) if working_dir else os.getcwd()
+
+    # Auto-detect current tmux session if inside one
+    if os.environ.get("TMUX"):
+        try:
+            result = subprocess.run(
+                ["tmux", "display-message", "-p", "#S"],
+                capture_output=True, text=True,
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                detected = result.stdout.strip()
+                click.echo(f"Detected tmux session: {detected}")
+                session = detected
+        except FileNotFoundError:
+            pass
+
+    _start_server(host, port, session, working_dir)
+
+    # If not inside tmux, ensure session exists and attach
+    if not os.environ.get("TMUX"):
+        result = subprocess.run(
+            ["tmux", "has-session", "-t", session],
+            capture_output=True,
+        )
+        if result.returncode != 0:
+            subprocess.run(
+                ["tmux", "new-session", "-d", "-s", session],
+                check=True,
+            )
+        os.execvp("tmux", ["tmux", "attach-session", "-t", session])
+
+
+@main.command()
+def version():
+    """Print the version."""
+    from onako import __version__
+    click.echo(f"onako {__version__}")
+
+
+@main.command()
+@click.option("--host", default="0.0.0.0", help="Host to bind to.")
+@click.option("--port", default=8787, type=int, help="Port to bind to.")
+@click.option("--session", default="onako", help="tmux session name.")
+@click.option("--dir", "working_dir", default=None, type=click.Path(exists=True), help="Working directory for tasks (default: current directory).")
+@click.option("--background", is_flag=True, help="Run as a background service (launchd/systemd).")
+def serve(host, port, session, working_dir, background):
+    """Start the Onako server."""
+    working_dir = str(Path(working_dir).resolve()) if working_dir else os.getcwd()
+
+    if background:
+        _start_background(host, port, working_dir)
+        return
+
+    _check_prerequisites()
+
+    os.environ["ONAKO_WORKING_DIR"] = working_dir
+    os.environ["ONAKO_SESSION"] = session
+
+    from onako import __version__
+    click.echo(f"Onako v{__version__}")
+    click.echo(f"Starting server at http://{host}:{port}")
+    click.echo(f"Working directory: {working_dir}")
+    click.echo(f"Session: {session}")
+    click.echo()
+
+    import uvicorn
+    from onako.server import app
+    uvicorn.run(app, host=host, port=port)
+
+
+@main.command()
+def stop():
+    """Stop the background Onako service."""
+    stopped = False
+
+    # Try pid file first (from `onako start`)
+    if PID_FILE.exists():
+        try:
+            pid = int(PID_FILE.read_text().strip())
+            os.kill(pid, 15)  # SIGTERM
+            click.echo(f"Onako server stopped (pid {pid}).")
+            stopped = True
+        except (ValueError, ProcessLookupError):
+            click.echo("Stale pid file found, cleaning up.")
+        PID_FILE.unlink(missing_ok=True)
+
+    # Fall back to launchd/systemd
+    if not stopped:
+        system = platform.system()
+        if system == "Darwin":
+            plist_path = Path.home() / "Library" / "LaunchAgents" / "com.onako.server.plist"
+            if plist_path.exists():
+                uid = os.getuid()
+                result = subprocess.run(
+                    ["launchctl", "bootout", f"gui/{uid}", str(plist_path)],
+                    capture_output=True,
+                )
+                if result.returncode != 0:
+                    subprocess.run(["launchctl", "unload", str(plist_path)], capture_output=True)
+                plist_path.unlink()
+                click.echo("Onako service stopped and removed.")
+                stopped = True
+        elif system == "Linux":
+            unit_path = Path.home() / ".config" / "systemd" / "user" / "onako.service"
+            if unit_path.exists():
+                subprocess.run(["systemctl", "--user", "disable", "--now", "onako"])
+                unit_path.unlink()
+                subprocess.run(["systemctl", "--user", "daemon-reload"])
+                click.echo("Onako service stopped and removed.")
+                stopped = True
+
+    if not stopped:
+        click.echo("Onako service is not running.")
+
+
+@main.command()
+def status():
+    """Check if Onako is running."""
+    import urllib.request
+    try:
+        r = urllib.request.urlopen("http://127.0.0.1:8787/health", timeout=2)
+        data = r.read().decode()
+        if '"ok"' in data:
+            click.echo("Onako server: running")
+            click.echo("  URL: http://127.0.0.1:8787")
+        else:
+            click.echo("Onako server: not responding correctly")
+    except Exception:
+        click.echo("Onako server: not running")
+
+
+def _is_server_running():
+    """Check if the onako server is already running via pid file."""
+    if not PID_FILE.exists():
+        return False
+    try:
+        pid = int(PID_FILE.read_text().strip())
+        os.kill(pid, 0)  # signal 0 = check if process exists
+        return True
+    except (ValueError, ProcessLookupError, PermissionError):
+        PID_FILE.unlink(missing_ok=True)
+        return False
+
+
+def _start_server(host, port, session, working_dir):
+    """Start the Onako server in the background if not already running.
+
+    Returns True if the server was started or is already running.
+    """
+    if _is_server_running():
+        click.echo(f"Onako server already running (pid {PID_FILE.read_text().strip()})")
+        return True
+
+    LOG_DIR.mkdir(parents=True, exist_ok=True)
+    onako_bin = shutil.which("onako")
+    if not onako_bin:
+        click.echo("Error: 'onako' command not found on PATH.", err=True)
+        sys.exit(1)
+
+    log_out = LOG_DIR / "onako.log"
+
+    with open(log_out, "a") as log_fh:
+        proc = subprocess.Popen(
+            [onako_bin, "serve", "--host", host, "--port", str(port), "--session", session, "--dir", working_dir],
+            stdout=log_fh,
+            stderr=subprocess.STDOUT,
+            start_new_session=True,
+        )
+    PID_FILE.parent.mkdir(parents=True, exist_ok=True)
+    PID_FILE.write_text(str(proc.pid))
+
+    local_ip = _get_local_ip()
+    banner = [
+        f"Onako server started (pid {proc.pid})",
+        f"  Dashboard: http://{host}:{port}",
+    ]
+    if local_ip:
+        banner.append(f"             http://{local_ip}:{port}")
+    banner.append(f"  Session:   {session}")
+    banner.append(f"  Logs:      {log_out}")
+    for line in banner:
+        click.echo(line)
+
+    # Wait for server to be ready
+    import urllib.request
+    for _ in range(20):
+        try:
+            urllib.request.urlopen(f"http://127.0.0.1:{port}/health", timeout=1)
+            break
+        except Exception:
+            import time
+            time.sleep(0.25)
+
+    return True
+
+
+
+def _start_background(host, port, working_dir):
+    """Install and start Onako as a background service."""
+    system = platform.system()
+    onako_bin = shutil.which("onako")
+    if not onako_bin:
+        click.echo("Error: 'onako' command not found on PATH.", err=True)
+        sys.exit(1)
+
+    LOG_DIR.mkdir(parents=True, exist_ok=True)
+
+    # Build PATH that includes dirs for tmux and claude
+    path_dirs = set()
+    for cmd in ["tmux", "claude"]:
+        p = shutil.which(cmd)
+        if p:
+            path_dirs.add(str(Path(p).parent))
+    path_dirs.update(["/usr/local/bin", "/usr/bin", "/bin"])
+    path_value = ":".join(sorted(path_dirs))
+
+    if system == "Darwin":
+        _install_launchd(onako_bin, host, port, working_dir, path_value)
+    elif system == "Linux":
+        _install_systemd(onako_bin, host, port, working_dir, path_value)
+    else:
+        click.echo(f"Background mode is not supported on {system}. Run 'onako serve' manually.", err=True)
+        sys.exit(1)
+
+
+def _install_launchd(onako_bin, host, port, working_dir, path_value):
+    from importlib.resources import files
+    tpl = files("onako").joinpath("templates", "com.onako.server.plist.tpl").read_text()
+    plist = tpl.format(
+        onako_bin=onako_bin,
+        host=host,
+        port=port,
+        working_dir=working_dir,
+        log_dir=LOG_DIR,
+        path_value=path_value,
+    )
+    plist_path = Path.home() / "Library" / "LaunchAgents" / "com.onako.server.plist"
+    plist_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Unload existing service if present
+    uid = os.getuid()
+    subprocess.run(
+        ["launchctl", "bootout", f"gui/{uid}", str(plist_path)],
+        capture_output=True,
+    )
+
+    plist_path.write_text(plist)
+
+    # Register and start the service
+    result = subprocess.run(
+        ["launchctl", "bootstrap", f"gui/{uid}", str(plist_path)],
+        capture_output=True, text=True,
+    )
+    if result.returncode != 0:
+        subprocess.run(["launchctl", "load", str(plist_path)], check=True)
+
+    # kickstart forces the service to run now (bootstrap alone may not start it)
+    subprocess.run(
+        ["launchctl", "kickstart", f"gui/{uid}/com.onako.server"],
+        capture_output=True,
+    )
+
+    click.echo(f"Onako running in background at http://{host}:{port}")
+    click.echo(f"  Working directory: {working_dir}")
+    click.echo(f"  Logs: {LOG_DIR}")
+    click.echo()
+    click.echo("If macOS blocks this service, allow it in:")
+    click.echo("  System Settings > General > Login Items & Extensions")
+
+
+def _install_systemd(onako_bin, host, port, working_dir, path_value):
+    from importlib.resources import files
+    tpl = files("onako").joinpath("templates", "onako.service.tpl").read_text()
+    unit = tpl.format(
+        onako_bin=onako_bin,
+        host=host,
+        port=port,
+        working_dir=working_dir,
+        path_value=path_value,
+    )
+    unit_path = Path.home() / ".config" / "systemd" / "user" / "onako.service"
+    unit_path.parent.mkdir(parents=True, exist_ok=True)
+    unit_path.write_text(unit)
+    subprocess.run(["systemctl", "--user", "daemon-reload"], check=True)
+    subprocess.run(["systemctl", "--user", "enable", "--now", "onako"], check=True)
+    click.echo(f"Onako running in background at http://{host}:{port}")
+    click.echo(f"  Working directory: {working_dir}")
+
+
+def _get_local_ip():
+    """Get the machine's local network IP address."""
+    try:
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        s.connect(("8.8.8.8", 80))
+        ip = s.getsockname()[0]
+        s.close()
+        return ip
+    except Exception:
+        return None
+
+
+def _check_prerequisites():
+    """Check that tmux and claude are installed."""
+    if not shutil.which("tmux"):
+        click.echo("Error: tmux is not installed.", err=True)
+        click.echo("Install it with: brew install tmux (macOS) or apt install tmux (Linux)", err=True)
+        sys.exit(1)
+
+    if not shutil.which("claude"):
+        click.echo("Warning: claude CLI not found on PATH.", err=True)
+        click.echo("Install Claude Code from: https://docs.anthropic.com/en/docs/claude-code", err=True)

{onako-0.2.0 → onako-0.3.0}/src/onako/server.py

@@ -8,7 +8,8 @@ from pydantic import BaseModel
 from onako.tmux_orchestrator import TmuxOrchestrator
 
 app = FastAPI()
-orch = TmuxOrchestrator()
+session_name = os.environ.get("ONAKO_SESSION", "onako")
+orch = TmuxOrchestrator(session_name=session_name)
 static_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "static")
 
 
@@ -73,6 +74,8 @@ def send_message(task_id: str, req: SendMessageRequest):
 def delete_task(task_id: str):
     if task_id not in orch.tasks:
         raise HTTPException(status_code=404, detail="Task not found")
+    if task_id == "onako-main":
+        raise HTTPException(status_code=400, detail="Cannot kill the main window")
     orch.kill_task(task_id)
     return {"status": "deleted"}
 

{onako-0.2.0 → onako-0.3.0}/src/onako/static/index.html

@@ -55,6 +55,16 @@
         }
         .status-running { color: #22c55e; }
         .status-done { color: #888; }
+        .origin-badge {
+            display: inline-block;
+            background: #444;
+            color: #aaa;
+            font-size: 10px;
+            padding: 1px 6px;
+            border-radius: 8px;
+            margin-left: 6px;
+            vertical-align: middle;
+        }
         .empty-state {
             text-align: center;
             color: #666;
@@ -260,7 +270,7 @@
                 } else {
                     list.innerHTML = tasks.map(t => `
                         <div class="task-item" onclick="showTask('${t.id}')">
-                            <div class="task-id">${t.id}</div>
+                            <div class="task-id">${t.id}${t.origin === 'external' ? '<span class="origin-badge">external</span>' : ''}</div>
                             <div class="task-prompt">${escapeHtml(t.prompt)}</div>
                             <div class="task-meta">
                                 <span class="status-${t.status}">${t.status}</span>
@@ -281,7 +291,11 @@
             document.getElementById('list-view').classList.add('hidden');
             document.getElementById('detail-view').classList.add('active');
             document.getElementById('detail-task-id').textContent = id;
-            document.getElementById('kill-btn').classList.remove('hidden');
+            if (id === 'onako-main') {
+                document.getElementById('kill-btn').classList.add('hidden');
+            } else {
+                document.getElementById('kill-btn').classList.remove('hidden');
+            }
             await refreshOutput();
             pollInterval = setInterval(refreshOutput, 3000);
         }

{onako-0.2.0 → onako-0.3.0}/src/onako/tmux_orchestrator.py

@@ -15,6 +15,7 @@ class TmuxOrchestrator:
         self.session_name = session_name
         self.db_path = db_path or DB_PATH
         self.tasks: dict[str, dict] = {}
+        self._window_ids: dict[str, str] = {}  # window_name -> @id
         self._init_db()
         self._load_tasks()
         self._ensure_session()
@@ -27,7 +28,7 @@ class TmuxOrchestrator:
         )
         if result.returncode != 0:
             subprocess.run(
-                ["tmux", "new-session", "-d", "-s", self.session_name],
+                ["tmux", "new-session", "-d", "-s", self.session_name, "-n", "onako-main"],
                 check=True,
             )
 
@@ -39,15 +40,21 @@ class TmuxOrchestrator:
                 id TEXT PRIMARY KEY,
                 prompt TEXT,
                 status TEXT,
-                started_at TEXT
+                started_at TEXT,
+                origin TEXT DEFAULT 'managed'
             )
         """)
+        # Migrate existing DBs that lack the origin column
+        cursor = conn.execute("PRAGMA table_info(tasks)")
+        columns = [row[1] for row in cursor.fetchall()]
+        if "origin" not in columns:
+            conn.execute("ALTER TABLE tasks ADD COLUMN origin TEXT DEFAULT 'managed'")
         conn.commit()
         conn.close()
 
     def _load_tasks(self):
         conn = sqlite3.connect(self.db_path)
-        rows = conn.execute("SELECT id, prompt, status, started_at FROM tasks").fetchall()
+        rows = conn.execute("SELECT id, prompt, status, started_at, origin FROM tasks").fetchall()
         conn.close()
         for row in rows:
             self.tasks[row[0]] = {
@@ -55,13 +62,14 @@ class TmuxOrchestrator:
                 "prompt": row[1],
                 "status": row[2],
                 "started_at": row[3],
+                "origin": row[4] or "managed",
             }
 
     def _save_task(self, task: dict):
         conn = sqlite3.connect(self.db_path)
         conn.execute(
-            "INSERT OR REPLACE INTO tasks (id, prompt, status, started_at) VALUES (?, ?, ?, ?)",
-            (task["id"], task["prompt"], task["status"], task["started_at"]),
+            "INSERT OR REPLACE INTO tasks (id, prompt, status, started_at, origin) VALUES (?, ?, ?, ?, ?)",
+            (task["id"], task["prompt"], task["status"], task["started_at"], task.get("origin", "managed")),
         )
         conn.commit()
         conn.close()
@@ -69,18 +77,36 @@ class TmuxOrchestrator:
     def _run_tmux(self, *args) -> subprocess.CompletedProcess:
         return subprocess.run(["tmux", *args], capture_output=True, text=True)
 
+    def _task_target(self, task_id: str) -> str:
+        """Return a safe tmux target for a task, using window ID when available."""
+        window_id = self._window_ids.get(task_id)
+        if window_id:
+            return window_id
+        return f"{self.session_name}:{task_id}"
+
     def create_task(self, command: str, working_dir: str | None = None, prompt: str | None = None) -> dict:
+        self._ensure_session()
         task_id = f"task-{secrets.token_hex(4)}"
         self._run_tmux(
             "new-window", "-t", self.session_name, "-n", task_id,
         )
+        # Look up the window ID for safe targeting
+        result = self._run_tmux(
+            "list-windows", "-t", self.session_name, "-F", "#{window_name}|#{window_id}",
+        )
+        if result.stdout.strip():
+            for line in result.stdout.strip().split("\n"):
+                name, _, wid = line.partition("|")
+                if name == task_id and wid:
+                    self._window_ids[task_id] = wid
+                    break
         if working_dir:
             self._run_tmux(
-                "send-keys", "-t", f"{self.session_name}:{task_id}",
+                "send-keys", "-t", self._task_target(task_id),
                 f"cd {shlex.quote(working_dir)}", "Enter",
             )
         self._run_tmux(
-            "send-keys", "-t", f"{self.session_name}:{task_id}",
+            "send-keys", "-t", self._task_target(task_id),
             command, "Enter",
         )
         task = {
@@ -88,12 +114,14 @@ class TmuxOrchestrator:
             "prompt": prompt or command,
             "status": "running",
             "started_at": datetime.now(timezone.utc).isoformat(),
+            "origin": "managed",
         }
         self.tasks[task_id] = task
         self._save_task(task)
         return task
 
     def list_tasks(self) -> list[dict]:
+        self.rediscover_tasks()
         self._sync_task_status()
         return list(self.tasks.values())
 
@@ -125,32 +153,38 @@ class TmuxOrchestrator:
 
     def get_raw_output(self, task_id: str) -> str:
         result = self._run_tmux(
-            "capture-pane", "-t", f"{self.session_name}:{task_id}",
+            "capture-pane", "-t", self._task_target(task_id),
             "-p", "-S", "-",
         )
         return result.stdout
 
     def send_message(self, task_id: str, message: str):
         self._run_tmux(
-            "send-keys", "-t", f"{self.session_name}:{task_id}",
+            "send-keys", "-t", self._task_target(task_id),
             "-l", message,
         )
         self._run_tmux(
-            "send-keys", "-t", f"{self.session_name}:{task_id}",
+            "send-keys", "-t", self._task_target(task_id),
             "Enter",
         )
 
     def kill_task(self, task_id: str):
-        self._run_tmux("kill-window", "-t", f"{self.session_name}:{task_id}")
+        self._run_tmux("kill-window", "-t", self._task_target(task_id))
         if task_id in self.tasks:
             self.tasks[task_id]["status"] = "done"
             self._save_task(self.tasks[task_id])
 
     def _sync_task_status(self):
         result = self._run_tmux(
-            "list-windows", "-t", self.session_name, "-F", "#{window_name}",
+            "list-windows", "-t", self.session_name, "-F", "#{window_name}|#{window_id}",
         )
-        active_windows = set(result.stdout.strip().split("\n")) if result.stdout.strip() else set()
+        active_windows = set()
+        if result.stdout.strip():
+            for line in result.stdout.strip().split("\n"):
+                parts = line.split("|", 1)
+                active_windows.add(parts[0])
+                if len(parts) > 1:
+                    self._window_ids[parts[0]] = parts[1]
         for task_id, task in self.tasks.items():
             if task["status"] == "running" and task_id not in active_windows:
                 task["status"] = "done"
@@ -159,17 +193,27 @@ class TmuxOrchestrator:
     def rediscover_tasks(self):
         """Rediscover tasks from existing tmux windows on server restart."""
         result = self._run_tmux(
-            "list-windows", "-t", self.session_name, "-F", "#{window_name}",
+            "list-windows", "-t", self.session_name, "-F", "#{window_name}|#{window_id}",
         )
         if not result.stdout.strip():
             return
-        for window_name in result.stdout.strip().split("\n"):
-            if window_name.startswith("task-") and window_name not in self.tasks:
+        for line in result.stdout.strip().split("\n"):
+            parts = line.split("|", 1)
+            window_name = parts[0]
+            window_id = parts[1] if len(parts) > 1 else None
+            if window_id:
+                self._window_ids[window_name] = window_id
+            if window_name not in self.tasks:
+                is_managed = window_name.startswith("task-")
                 task = {
                     "id": window_name,
-                    "prompt": "(rediscovered)",
+                    "prompt": "(rediscovered)" if is_managed else window_name,
                     "status": "running",
                     "started_at": None,
+                    "origin": "managed" if is_managed else "external",
                 }
                 self.tasks[window_name] = task
                 self._save_task(task)
+            elif self.tasks[window_name]["status"] == "done":
+                self.tasks[window_name]["status"] = "running"
+                self._save_task(self.tasks[window_name])

{onako-0.2.0 → onako-0.3.0}/src/onako.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onako
-Version: 0.2.0
+Version: 0.3.0
 Summary: Dispatch and monitor Claude Code tasks from your phone
 Author: Amir
 License-Expression: MIT
@@ -32,27 +32,21 @@ Requires [tmux](https://github.com/tmux/tmux) and [Claude Code](https://docs.ant
 ## Usage
 
 ```bash
-cd ~/projects
-onako serve
+onako                              # starts server, drops you into tmux
+onako --session my-project         # custom session name
 ```
 
-Open http://localhost:8787 on your phone (same network) or set up [Tailscale](https://tailscale.com) for access from anywhere.
-
-### Run in the background
-
-```bash
-onako serve --background
-```
-
-This installs a system service (launchd on macOS, systemd on Linux) that starts on boot. Tasks run in the directory where you ran the command.
+If you're already inside tmux, onako auto-detects your session and skips the attach. Open http://localhost:8787 on your phone (same network) or set up [Tailscale](https://tailscale.com) for access from anywhere.
 
 ```bash
-onako serve --background --dir ~/projects   # override working directory
-onako status                                 # check if running
-onako stop                                   # stop the background service
-onako version                                # print version
+onako stop                         # stop the background server
+onako status                       # check if running
+onako serve                        # foreground server (for development)
+onako version                      # print version
 ```
 
 ## How it works
 
-Each task is a tmux window running an interactive Claude Code session. The web dashboard reads tmux output and lets you send messages to running sessions. Task state is persisted in SQLite so it survives server restarts.
+Onako monitors all tmux windows in the configured session. Windows it creates (via the dashboard) are "managed" tasks. Windows created by you or other tools are discovered automatically as "external" — both get full dashboard support: view output, send messages, kill.
+
+Task state is persisted in SQLite so it survives server restarts.

{onako-0.2.0 → onako-0.3.0}/tests/test_api.py

@@ -1,17 +1,34 @@
+import subprocess
 import pytest
 from fastapi.testclient import TestClient
 
+API_SESSION = "onako-api-test"
+
+
+@pytest.fixture(autouse=True)
+def cleanup_session():
+    subprocess.run(["tmux", "kill-session", "-t", API_SESSION], capture_output=True)
+    yield
+    subprocess.run(["tmux", "kill-session", "-t", API_SESSION], capture_output=True)
+
 
 @pytest.fixture
-def client():
+def client(tmp_path):
+    import os
     import importlib
+    os.environ["ONAKO_SESSION"] = API_SESSION
+    from onako import tmux_orchestrator
+    original_db = tmux_orchestrator.DB_PATH
+    tmux_orchestrator.DB_PATH = tmp_path / "test.db"
     from onako import server
     importlib.reload(server)
     client = TestClient(server.app)
     yield client
     response = client.get("/tasks")
     for task in response.json():
-        client.delete(f"/tasks/{task['id']}")
+        if task["id"] != "onako-main":
+            client.delete(f"/tasks/{task['id']}")
+    tmux_orchestrator.DB_PATH = original_db
 
 
 def test_health(client):

{onako-0.2.0 → onako-0.3.0}/tests/test_cli.py

@@ -6,7 +6,16 @@ def test_version():
     runner = CliRunner()
     result = runner.invoke(main, ["version"])
     assert result.exit_code == 0
-    assert "0.2.0" in result.output
+    assert "0.3.0" in result.output
+
+
+def test_default_help():
+    runner = CliRunner()
+    result = runner.invoke(main, ["--help"])
+    assert result.exit_code == 0
+    assert "--session" in result.output
+    assert "--host" in result.output
+    assert "--port" in result.output
 
 
 def test_serve_help():
@@ -15,5 +24,6 @@ def test_serve_help():
     assert result.exit_code == 0
     assert "--host" in result.output
     assert "--port" in result.output
+    assert "--session" in result.output
     assert "--background" in result.output
     assert "--dir" in result.output

{onako-0.2.0 → onako-0.3.0}/tests/test_cli_service.py

@@ -14,3 +14,10 @@ def test_stop_completes():
     result = runner.invoke(main, ["stop"])
     assert result.exit_code == 0
     assert "not running" in result.output or "stopped" in result.output
+
+
+def test_stop_handles_no_service():
+    """Stop should handle the case where neither pid file nor service exists."""
+    runner = CliRunner()
+    result = runner.invoke(main, ["stop"])
+    assert result.exit_code == 0

{onako-0.2.0 → onako-0.3.0}/tests/test_tmux_orchestrator.py

@@ -71,3 +71,65 @@ def test_create_multiple_tasks(orch):
     assert t1["id"] in ids
     assert t2["id"] in ids
     assert t1["id"] != t2["id"]
+
+
+def test_created_task_has_managed_origin(orch):
+    task = orch.create_task("echo hello")
+    assert task["origin"] == "managed"
+
+
+def test_rediscover_external_window(orch):
+    """Windows not created by onako are discovered with origin=external."""
+    subprocess.run([
+        "tmux", "new-window", "-t", SESSION_NAME, "-n", "my-feature",
+    ], check=True)
+    time.sleep(0.5)
+    orch.rediscover_tasks()
+    tasks = orch.list_tasks()
+    external = [t for t in tasks if t["id"] == "my-feature"]
+    assert len(external) == 1
+    assert external[0]["origin"] == "external"
+
+
+def test_external_window_output(orch):
+    """Can read output from externally created windows."""
+    subprocess.run([
+        "tmux", "new-window", "-t", SESSION_NAME, "-n", "ext-test",
+    ], check=True)
+    subprocess.run([
+        "tmux", "send-keys", "-t", f"{SESSION_NAME}:ext-test",
+        "echo external-output", "Enter",
+    ], check=True)
+    time.sleep(1)
+    orch.rediscover_tasks()
+    output = orch.get_output("ext-test")
+    assert "external-output" in output
+
+
+def test_external_window_send_message(orch):
+    """Can send messages to externally created windows."""
+    subprocess.run([
+        "tmux", "new-window", "-t", SESSION_NAME, "-n", "ext-msg",
+    ], check=True)
+    subprocess.run([
+        "tmux", "send-keys", "-t", f"{SESSION_NAME}:ext-msg",
+        "cat", "Enter",
+    ], check=True)
+    time.sleep(0.5)
+    orch.rediscover_tasks()
+    orch.send_message("ext-msg", "hello-external")
+    time.sleep(1)
+    output = orch.get_output("ext-msg")
+    assert "hello-external" in output
+
+
+def test_external_window_kill(orch):
+    """Can kill externally created windows."""
+    subprocess.run([
+        "tmux", "new-window", "-t", SESSION_NAME, "-n", "ext-kill",
+    ], check=True)
+    time.sleep(0.5)
+    orch.rediscover_tasks()
+    orch.kill_task("ext-kill")
+    tasks = orch.list_tasks()
+    assert not any(t["id"] == "ext-kill" and t["status"] == "running" for t in tasks)

onako-0.2.0/README.md

@@ -1,41 +0,0 @@
-# Onako
-
-Dispatch and monitor Claude Code tasks from your phone.
-
-Onako is a lightweight server that runs on your machine. It spawns Claude Code sessions in tmux, and you monitor them through a mobile-friendly web dashboard. Fire off tasks from an iOS Shortcut or the dashboard, check in from anywhere.
-
-## Install
-
-```bash
-pipx install onako
-```
-
-Requires [tmux](https://github.com/tmux/tmux) and [Claude Code](https://docs.anthropic.com/en/docs/claude-code).
-
-## Usage
-
-```bash
-cd ~/projects
-onako serve
-```
-
-Open http://localhost:8787 on your phone (same network) or set up [Tailscale](https://tailscale.com) for access from anywhere.
-
-### Run in the background
-
-```bash
-onako serve --background
-```
-
-This installs a system service (launchd on macOS, systemd on Linux) that starts on boot. Tasks run in the directory where you ran the command.
-
-```bash
-onako serve --background --dir ~/projects   # override working directory
-onako status                                 # check if running
-onako stop                                   # stop the background service
-onako version                                # print version
-```
-
-## How it works
-
-Each task is a tmux window running an interactive Claude Code session. The web dashboard reads tmux output and lets you send messages to running sessions. Task state is persisted in SQLite so it survives server restarts.

onako-0.2.0/src/onako/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.2.0"

onako-0.2.0/src/onako/cli.py

@@ -1,208 +0,0 @@
-import os
-import platform
-import shutil
-import subprocess
-import sys
-from pathlib import Path
-
-import click
-
-ONAKO_DIR = Path.home() / ".onako"
-LOG_DIR = ONAKO_DIR / "logs"
-
-
-@click.group()
-def main():
-    """Onako — Dispatch and monitor Claude Code tasks from your phone."""
-    pass
-
-
-@main.command()
-def version():
-    """Print the version."""
-    from onako import __version__
-    click.echo(f"onako {__version__}")
-
-
-@main.command()
-@click.option("--host", default="0.0.0.0", help="Host to bind to.")
-@click.option("--port", default=8787, type=int, help="Port to bind to.")
-@click.option("--dir", "working_dir", default=None, type=click.Path(exists=True), help="Working directory for tasks (default: current directory).")
-@click.option("--background", is_flag=True, help="Run as a background service (launchd/systemd).")
-def serve(host, port, working_dir, background):
-    """Start the Onako server."""
-    working_dir = str(Path(working_dir).resolve()) if working_dir else os.getcwd()
-
-    if background:
-        _start_background(host, port, working_dir)
-        return
-
-    _check_prerequisites()
-
-    os.environ["ONAKO_WORKING_DIR"] = working_dir
-
-    from onako import __version__
-    click.echo(f"Onako v{__version__}")
-    click.echo(f"Starting server at http://{host}:{port}")
-    click.echo(f"Working directory: {working_dir}")
-    click.echo()
-
-    import uvicorn
-    from onako.server import app
-    uvicorn.run(app, host=host, port=port)
-
-
-@main.command()
-def stop():
-    """Stop the background Onako service."""
-    system = platform.system()
-    if system == "Darwin":
-        plist_path = Path.home() / "Library" / "LaunchAgents" / "com.onako.server.plist"
-        if plist_path.exists():
-            uid = os.getuid()
-            result = subprocess.run(
-                ["launchctl", "bootout", f"gui/{uid}", str(plist_path)],
-                capture_output=True,
-            )
-            if result.returncode != 0:
-                subprocess.run(["launchctl", "unload", str(plist_path)], capture_output=True)
-            plist_path.unlink()
-            click.echo("Onako service stopped and removed.")
-        else:
-            click.echo("Onako service is not running.")
-    elif system == "Linux":
-        unit_path = Path.home() / ".config" / "systemd" / "user" / "onako.service"
-        if unit_path.exists():
-            subprocess.run(["systemctl", "--user", "disable", "--now", "onako"])
-            unit_path.unlink()
-            subprocess.run(["systemctl", "--user", "daemon-reload"])
-            click.echo("Onako service stopped and removed.")
-        else:
-            click.echo("Onako service is not running.")
-    else:
-        click.echo(f"Not supported on {system}.")
-
-
-@main.command()
-def status():
-    """Check if Onako is running."""
-    import urllib.request
-    try:
-        r = urllib.request.urlopen("http://127.0.0.1:8787/health", timeout=2)
-        data = r.read().decode()
-        if '"ok"' in data:
-            click.echo("Onako server: running")
-            click.echo("  URL: http://127.0.0.1:8787")
-        else:
-            click.echo("Onako server: not responding correctly")
-    except Exception:
-        click.echo("Onako server: not running")
-
-
-def _start_background(host, port, working_dir):
-    """Install and start Onako as a background service."""
-    system = platform.system()
-    onako_bin = shutil.which("onako")
-    if not onako_bin:
-        click.echo("Error: 'onako' command not found on PATH.", err=True)
-        sys.exit(1)
-
-    LOG_DIR.mkdir(parents=True, exist_ok=True)
-
-    # Build PATH that includes dirs for tmux and claude
-    path_dirs = set()
-    for cmd in ["tmux", "claude"]:
-        p = shutil.which(cmd)
-        if p:
-            path_dirs.add(str(Path(p).parent))
-    path_dirs.update(["/usr/local/bin", "/usr/bin", "/bin"])
-    path_value = ":".join(sorted(path_dirs))
-
-    if system == "Darwin":
-        _install_launchd(onako_bin, host, port, working_dir, path_value)
-    elif system == "Linux":
-        _install_systemd(onako_bin, host, port, working_dir, path_value)
-    else:
-        click.echo(f"Background mode is not supported on {system}. Run 'onako serve' manually.", err=True)
-        sys.exit(1)
-
-
-def _install_launchd(onako_bin, host, port, working_dir, path_value):
-    from importlib.resources import files
-    tpl = files("onako").joinpath("templates", "com.onako.server.plist.tpl").read_text()
-    plist = tpl.format(
-        onako_bin=onako_bin,
-        host=host,
-        port=port,
-        working_dir=working_dir,
-        log_dir=LOG_DIR,
-        path_value=path_value,
-    )
-    plist_path = Path.home() / "Library" / "LaunchAgents" / "com.onako.server.plist"
-    plist_path.parent.mkdir(parents=True, exist_ok=True)
-
-    # Unload existing service if present
-    uid = os.getuid()
-    subprocess.run(
-        ["launchctl", "bootout", f"gui/{uid}", str(plist_path)],
-        capture_output=True,
-    )
-
-    plist_path.write_text(plist)
-
-    # Register and start the service
-    result = subprocess.run(
-        ["launchctl", "bootstrap", f"gui/{uid}", str(plist_path)],
-        capture_output=True, text=True,
-    )
-    if result.returncode != 0:
-        subprocess.run(["launchctl", "load", str(plist_path)], check=True)
-
-    # kickstart forces the service to run now (bootstrap alone may not start it)
-    subprocess.run(
-        ["launchctl", "kickstart", f"gui/{uid}/com.onako.server"],
-        capture_output=True,
-    )
-
-    click.echo(f"Onako running in background at http://{host}:{port}")
-    click.echo(f"  Working directory: {working_dir}")
-    click.echo(f"  Logs: {LOG_DIR}")
-    click.echo()
-    click.echo("If macOS blocks this service, allow it in:")
-    click.echo("  System Settings > General > Login Items & Extensions")
-
-
-def _install_systemd(onako_bin, host, port, working_dir, path_value):
-    from importlib.resources import files
-    tpl = files("onako").joinpath("templates", "onako.service.tpl").read_text()
-    unit = tpl.format(
-        onako_bin=onako_bin,
-        host=host,
-        port=port,
-        working_dir=working_dir,
-        path_value=path_value,
-    )
-    unit_path = Path.home() / ".config" / "systemd" / "user" / "onako.service"
-    unit_path.parent.mkdir(parents=True, exist_ok=True)
-    unit_path.write_text(unit)
-    subprocess.run(["systemctl", "--user", "daemon-reload"], check=True)
-    subprocess.run(["systemctl", "--user", "enable", "--now", "onako"], check=True)
-    click.echo(f"Onako running in background at http://{host}:{port}")
-    click.echo(f"  Working directory: {working_dir}")
-
-
-def _check_prerequisites():
-    """Check that tmux and claude are installed."""
-    tmux_path = shutil.which("tmux")
-    if not tmux_path:
-        click.echo("Error: tmux is not installed.", err=True)
-        click.echo("Install it with: brew install tmux (macOS) or apt install tmux (Linux)", err=True)
-        sys.exit(1)
-    click.echo(f"  tmux: {tmux_path}")
-
-    claude_path = shutil.which("claude")
-    if not claude_path:
-        click.echo("Warning: claude CLI not found on PATH.", err=True)
-        click.echo("Install Claude Code from: https://docs.anthropic.com/en/docs/claude-code", err=True)
-    else:
-        click.echo(f"  claude: {claude_path}")