onako 0.2.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

onako/__init__.py

@@ -1 +1 @@
-__version__ = "0.2.1"
+__version__ = "0.4.0"

onako/cli.py

@@ -1,5 +1,5 @@
 import os
-import platform
+import socket
 import shutil
 import subprocess
 import sys
@@ -9,12 +9,52 @@ import click
 
 ONAKO_DIR = Path.home() / ".onako"
 LOG_DIR = ONAKO_DIR / "logs"
+PID_FILE = ONAKO_DIR / "onako.pid"
 
 
-@click.group()
-def main():
+@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.option("--dangerously-skip-permissions", "skip_permissions", is_flag=True, default=False, help="Pass --dangerously-skip-permissions to all Claude Code tasks.")
+@click.pass_context
+def main(ctx, host, port, session, working_dir, skip_permissions):
     """Onako — Dispatch and monitor Claude Code tasks from your phone."""
-    pass
+    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, skip_permissions)
+
+    # 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()
@@ -27,24 +67,25 @@ def 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, working_dir, background):
+@click.option("--dangerously-skip-permissions", "skip_permissions", is_flag=True, default=False, help="Pass --dangerously-skip-permissions to all Claude Code tasks.")
+def serve(host, port, session, working_dir, skip_permissions):
     """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
+    if skip_permissions:
+        os.environ["ONAKO_SKIP_PERMISSIONS"] = "1"
 
     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
@@ -55,32 +96,21 @@ def serve(host, port, working_dir, background):
 @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}.")
+    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)
+
+    if not stopped:
+        click.echo("Onako service is not running.")
 
 
 @main.command()
@@ -99,110 +129,95 @@ def status():
         click.echo("Onako server: not running")
 
 
-def _start_background(host, port, working_dir):
-    """Install and start Onako as a background service."""
-    system = platform.system()
+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, skip_permissions=False):
+    """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_DIR.mkdir(parents=True, exist_ok=True)
+    log_out = LOG_DIR / "onako.log"
+
+    cmd = [onako_bin, "serve", "--host", host, "--port", str(port), "--session", session, "--dir", working_dir]
+    if skip_permissions:
+        cmd.append("--dangerously-skip-permissions")
+
+    with open(log_out, "a") as log_fh:
+        proc = subprocess.Popen(
+            cmd,
+            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)
 
-    # 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)
+    return True
 
 
-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."""
-    tmux_path = shutil.which("tmux")
-    if not tmux_path:
+    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)
-    click.echo(f"  tmux: {tmux_path}")
 
-    claude_path = shutil.which("claude")
-    if not claude_path:
+    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)
-    else:
-        click.echo(f"  claude: {claude_path}")

onako/server.py

@@ -8,13 +8,16 @@ from pydantic import BaseModel
 from onako.tmux_orchestrator import TmuxOrchestrator
 
 app = FastAPI()
-orch = TmuxOrchestrator()
+session_name = os.environ.get("ONAKO_SESSION", "onako")
+skip_permissions_default = os.environ.get("ONAKO_SKIP_PERMISSIONS") == "1"
+orch = TmuxOrchestrator(session_name=session_name)
 static_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "static")
 
 
 class CreateTaskRequest(BaseModel):
     prompt: str
     working_dir: str | None = None
+    skip_permissions: bool | None = None
 
 
 class SendMessageRequest(BaseModel):
@@ -28,12 +31,16 @@ def dashboard():
 
 @app.get("/health")
 def health():
-    return {"status": "ok"}
+    return {"status": "ok", "skip_permissions": skip_permissions_default}
 
 
 @app.post("/tasks")
 def create_task(req: CreateTaskRequest):
-    command = f"claude {shlex.quote(req.prompt)}"
+    skip = req.skip_permissions if req.skip_permissions is not None else skip_permissions_default
+    if skip:
+        command = f"claude --dangerously-skip-permissions {shlex.quote(req.prompt)}"
+    else:
+        command = f"claude {shlex.quote(req.prompt)}"
     task = orch.create_task(command, working_dir=req.working_dir, prompt=req.prompt)
     return task
 
@@ -69,10 +76,20 @@ def send_message(task_id: str, req: SendMessageRequest):
     return {"status": "sent"}
 
 
+@app.post("/tasks/{task_id}/interrupt")
+def interrupt_task(task_id: str):
+    if task_id not in orch.tasks:
+        raise HTTPException(status_code=404, detail="Task not found")
+    orch.send_interrupt(task_id)
+    return {"status": "interrupted"}
+
+
 @app.delete("/tasks/{task_id}")
 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/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;
@@ -88,6 +98,16 @@
             cursor: pointer;
             font-size: 14px;
         }
+        #interrupt-btn {
+            background: #f59e0b;
+            color: white;
+            border: none;
+            padding: 6px 12px;
+            border-radius: 6px;
+            cursor: pointer;
+            font-size: 12px;
+        }
+        #interrupt-btn.hidden { display: none; }
         #kill-btn {
             background: #ef4444;
             color: white;
@@ -211,6 +231,7 @@
         <div id="detail-header">
             <button id="back-btn">&larr; Back</button>
             <span id="detail-task-id"></span>
+            <button id="interrupt-btn">Interrupt</button>
             <button id="kill-btn">Kill</button>
         </div>
         <div id="output"></div>
@@ -225,6 +246,10 @@
     <div id="modal">
         <textarea id="prompt-input" placeholder="What do you want done?"></textarea>
         <input id="workdir-input" type="text" placeholder="Working directory (optional)">
+        <label id="skip-perms-label" style="display:flex;align-items:center;gap:8px;margin-top:8px;font-size:13px;color:#aaa;cursor:pointer;">
+            <input type="checkbox" id="skip-perms-input" style="width:auto;margin:0;">
+            Skip permissions
+        </label>
         <button id="submit-task-btn">Start Task</button>
     </div>
 
@@ -233,6 +258,7 @@
         let currentTaskId = null;
         let currentTaskStatus = null;
         let pollInterval = null;
+        let skipPermissionsDefault = false;
 
         function timeAgo(dateStr) {
             if (!dateStr) return '';
@@ -250,6 +276,15 @@
             document.getElementById('connection-banner').style.display = show ? 'block' : 'none';
         }
 
+        async function loadConfig() {
+            try {
+                const res = await fetch(`${API}/health`);
+                const data = await res.json();
+                skipPermissionsDefault = data.skip_permissions || false;
+                document.getElementById('skip-perms-input').checked = skipPermissionsDefault;
+            } catch (e) {}
+        }
+
         async function loadTasks() {
             try {
                 const res = await fetch(`${API}/tasks`);
@@ -260,7 +295,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 +316,13 @@
             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('interrupt-btn').classList.add('hidden');
+                document.getElementById('kill-btn').classList.add('hidden');
+            } else {
+                document.getElementById('interrupt-btn').classList.remove('hidden');
+                document.getElementById('kill-btn').classList.remove('hidden');
+            }
             await refreshOutput();
             pollInterval = setInterval(refreshOutput, 3000);
         }
@@ -301,6 +342,7 @@
                 // Stop polling and hide kill button when task is done
                 if (data.status === 'done' && currentTaskStatus !== 'done') {
                     currentTaskStatus = 'done';
+                    document.getElementById('interrupt-btn').classList.add('hidden');
                     document.getElementById('kill-btn').classList.add('hidden');
                     if (pollInterval) {
                         clearInterval(pollInterval);
@@ -338,6 +380,15 @@
             }
         }
 
+        async function interruptTask() {
+            if (!currentTaskId) return;
+            try {
+                await fetch(`${API}/tasks/${currentTaskId}/interrupt`, {method: 'POST'});
+            } catch (e) {
+                showConnectionError(true);
+            }
+        }
+
         async function killTask() {
             if (!currentTaskId) return;
             if (!confirm('Kill this task?')) return;
@@ -352,6 +403,7 @@
         function showModal() {
             document.getElementById('modal').style.display = 'block';
             document.getElementById('modal-overlay').style.display = 'block';
+            document.getElementById('skip-perms-input').checked = skipPermissionsDefault;
             document.getElementById('prompt-input').focus();
         }
 
@@ -364,7 +416,8 @@
             const prompt = document.getElementById('prompt-input').value.trim();
             if (!prompt) return;
             const workdir = document.getElementById('workdir-input').value.trim() || null;
-            const body = {prompt};
+            const skipPerms = document.getElementById('skip-perms-input').checked;
+            const body = {prompt, skip_permissions: skipPerms};
             if (workdir) body.working_dir = workdir;
             try {
                 const res = await fetch(`${API}/tasks`, {
@@ -393,6 +446,7 @@
         document.getElementById('modal-overlay').addEventListener('click', hideModal);
         document.getElementById('submit-task-btn').addEventListener('click', submitTask);
         document.getElementById('back-btn').addEventListener('click', showList);
+        document.getElementById('interrupt-btn').addEventListener('click', interruptTask);
         document.getElementById('kill-btn').addEventListener('click', killTask);
         document.getElementById('send-btn').addEventListener('click', sendMessage);
         document.getElementById('message-input').addEventListener('keydown', e => {
@@ -403,6 +457,7 @@
         });
 
         // Init
+        loadConfig();
         loadTasks();
         setInterval(() => { if (!currentTaskId) loadTasks(); }, 10000);
     </script>

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,19 +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 = {
@@ -89,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())
 
@@ -126,32 +153,41 @@ 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 send_interrupt(self, task_id: str):
+        self._run_tmux("send-keys", "-t", self._task_target(task_id), "Escape")
+
     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"
@@ -160,17 +196,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.1.dist-info → onako-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onako
-Version: 0.2.1
+Version: 0.4.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 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.4.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+onako/__init__.py,sha256=42STGor_9nKYXumfeV5tiyD_M8VdcddX7CEexmibPBk,22
+onako/cli.py,sha256=8nsQj0XbgRlS9DsgYfao2uc1hyTE8q9ULVyGtPOgP9I,7629
+onako/server.py,sha256=NfP2CaecxAzuq0tSIaatfYX3d98EuLfhIwK00oHNjro,2883
+onako/tmux_orchestrator.py,sha256=URAOdYo88SzW1ef0o9_hKxJ0SeTtuqZlex1kgTMv42w,8277
+onako/static/index.html,sha256=ioombLZg8uhVHL64saB50ikYBUYNDgw5yClA-QoNxEo,16802
+onako-0.4.0.dist-info/METADATA,sha256=dv588takf4ASUQzsuF7mMYPwJs1Gq4WDU741BvAwegY,1945
+onako-0.4.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+onako-0.4.0.dist-info/entry_points.txt,sha256=51KRJzuVpr69iT_k4JO0Lj3DQv_HbgtGjTBTev13JAQ,41
+onako-0.4.0.dist-info/top_level.txt,sha256=EZsc5qq2paM9GTbaFE9Xar4B5wFdfIqK9l_bDQVcmZ4,6
+onako-0.4.0.dist-info/RECORD,,

onako/templates/com.onako.server.plist.tpl

@@ -1,34 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-    <key>Label</key>
-    <string>com.onako.server</string>
-    <key>ProgramArguments</key>
-    <array>
-        <string>{onako_bin}</string>
-        <string>serve</string>
-        <string>--host</string>
-        <string>{host}</string>
-        <string>--port</string>
-        <string>{port}</string>
-        <string>--dir</string>
-        <string>{working_dir}</string>
-    </array>
-    <key>WorkingDirectory</key>
-    <string>{working_dir}</string>
-    <key>RunAtLoad</key>
-    <true/>
-    <key>KeepAlive</key>
-    <true/>
-    <key>StandardOutPath</key>
-    <string>{log_dir}/server.stdout.log</string>
-    <key>StandardErrorPath</key>
-    <string>{log_dir}/server.stderr.log</string>
-    <key>EnvironmentVariables</key>
-    <dict>
-        <key>PATH</key>
-        <string>{path_value}</string>
-    </dict>
-</dict>
-</plist>

onako/templates/onako.service.tpl

@@ -1,12 +0,0 @@
-[Unit]
-Description=Onako - Claude Code Task Orchestrator
-After=network.target
-
-[Service]
-ExecStart={onako_bin} serve --host {host} --port {port} --dir {working_dir}
-WorkingDirectory={working_dir}
-Restart=on-failure
-Environment=PATH={path_value}
-
-[Install]
-WantedBy=default.target

onako-0.2.1.dist-info/RECORD

@@ -1,12 +0,0 @@
-onako/__init__.py,sha256=HfjVOrpTnmZ-xVFCYSVmX50EXaBQeJteUHG-PD6iQs8,22
-onako/cli.py,sha256=scmBfnyRAaT_yJziVQyumV6SyureGx6FXumV_r6KGxE,7217
-onako/server.py,sha256=lBNaT8Xq5Jw8EpN1CZNWzKQ2TudAMpSE4L0PY4ucW10,2065
-onako/tmux_orchestrator.py,sha256=vnhNda6VRhPIi28EaHJn67WiRCPvMGnoG7uwCD2MDtU,6111
-onako/static/index.html,sha256=7TjxfF38Spnuerd6u0vbwGpJApstsxzVS3F-YUGCp7I,14403
-onako/templates/com.onako.server.plist.tpl,sha256=XvjvRz_AnjcREVjDPFu2qGMVCxojp6hhTwMfvrFcEbY,994
-onako/templates/onako.service.tpl,sha256=EOVOaLtxC1FrcLdy7DtEbtf9ImgN6PmnMb57ZT81nTM,280
-onako-0.2.1.dist-info/METADATA,sha256=L52xdawAyV0GjqXFwbdGJfZnE6o4P8tGKu0oF8ZPWt0,1891
-onako-0.2.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-onako-0.2.1.dist-info/entry_points.txt,sha256=51KRJzuVpr69iT_k4JO0Lj3DQv_HbgtGjTBTev13JAQ,41
-onako-0.2.1.dist-info/top_level.txt,sha256=EZsc5qq2paM9GTbaFE9Xar4B5wFdfIqK9l_bDQVcmZ4,6
-onako-0.2.1.dist-info/RECORD,,