onako 0.1.0__tar.gz

onako-0.1.0/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: onako
+Version: 0.1.0
+Summary: Dispatch and monitor Claude Code tasks from your phone
+Author: Amir
+License-Expression: MIT
+Project-URL: Repository, https://github.com/AzRu/onako
+Keywords: claude,claude-code,tmux,orchestrator,ai
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi>=0.100.0
+Requires-Dist: uvicorn>=0.20.0
+Requires-Dist: click>=8.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: httpx>=0.24.0; extra == "dev"
+
+# 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 serve
+```
+
+Open http://localhost:8000 on your phone (same network) or set up [Tailscale](https://tailscale.com) for access from anywhere.
+
+### Auto-start on boot
+
+```bash
+onako install
+```
+
+### Other commands
+
+```bash
+onako status      # Check if server is running
+onako uninstall   # Remove auto-start 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.1.0/README.md

@@ -0,0 +1,39 @@
+# 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 serve
+```
+
+Open http://localhost:8000 on your phone (same network) or set up [Tailscale](https://tailscale.com) for access from anywhere.
+
+### Auto-start on boot
+
+```bash
+onako install
+```
+
+### Other commands
+
+```bash
+onako status      # Check if server is running
+onako uninstall   # Remove auto-start 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.1.0/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "onako"
+version = "0.1.0"
+description = "Dispatch and monitor Claude Code tasks from your phone"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    {name = "Amir"}
+]
+keywords = ["claude", "claude-code", "tmux", "orchestrator", "ai"]
+dependencies = [
+    "fastapi>=0.100.0",
+    "uvicorn>=0.20.0",
+    "click>=8.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "httpx>=0.24.0",
+]
+
+[project.scripts]
+onako = "onako.cli:main"
+
+[project.urls]
+Repository = "https://github.com/AzRu/onako"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+onako = [
+    "static/**/*",
+    "templates/*",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

onako-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

onako-0.1.0/src/onako/__init__.py

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

onako-0.1.0/src/onako/cli.py

@@ -0,0 +1,168 @@
+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="127.0.0.1", help="Host to bind to.")
+@click.option("--port", default=8000, type=int, help="Port to bind to.")
+def serve(host, port):
+    """Start the Onako server."""
+    _check_prerequisites()
+
+    from onako import __version__
+    click.echo(f"Onako v{__version__}")
+    click.echo(f"Starting server at http://{host}:{port}")
+    click.echo(f"Dashboard: http://{host}:{port}")
+    click.echo()
+
+    import uvicorn
+    from onako.server import app
+    uvicorn.run(app, host=host, port=port)
+
+
+@main.command()
+@click.option("--host", default="127.0.0.1", help="Host to bind to.")
+@click.option("--port", default=8000, type=int, help="Port to bind to.")
+def install(host, port):
+    """Install Onako as a background service (launchd on macOS, systemd on Linux)."""
+    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, path_value)
+    elif system == "Linux":
+        _install_systemd(onako_bin, host, port, path_value)
+    else:
+        click.echo(f"Auto-start is not supported on {system}. Run 'onako serve' manually.", err=True)
+        sys.exit(1)
+
+
+def _install_launchd(onako_bin, host, port, 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,
+        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)
+    plist_path.write_text(plist)
+    subprocess.run(["launchctl", "load", str(plist_path)], check=True)
+    click.echo(f"Installed launchd service: {plist_path}")
+    click.echo(f"Logs: {LOG_DIR}")
+    click.echo(f"Onako is running at http://{host}:{port}")
+
+
+def _install_systemd(onako_bin, host, port, 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,
+        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"Installed systemd service: {unit_path}")
+    click.echo(f"Onako is running at http://{host}:{port}")
+
+
+@main.command()
+def uninstall():
+    """Remove the Onako background service."""
+    system = platform.system()
+    if system == "Darwin":
+        plist_path = Path.home() / "Library" / "LaunchAgents" / "com.onako.server.plist"
+        if plist_path.exists():
+            subprocess.run(["launchctl", "unload", str(plist_path)])
+            plist_path.unlink()
+            click.echo("Onako service removed.")
+        else:
+            click.echo("Onako service is not installed.")
+    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 removed.")
+        else:
+            click.echo("Onako service is not installed.")
+    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:8000/health", timeout=2)
+        data = r.read().decode()
+        if '"ok"' in data:
+            click.echo("Onako server: running")
+            click.echo("  URL: http://127.0.0.1:8000")
+        else:
+            click.echo("Onako server: not responding correctly")
+    except Exception:
+        click.echo("Onako server: not running")
+
+
+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}")

onako-0.1.0/src/onako/server.py

@@ -0,0 +1,80 @@
+import os
+import shlex
+
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel
+from onako.tmux_orchestrator import TmuxOrchestrator
+
+app = FastAPI()
+orch = TmuxOrchestrator()
+static_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "static")
+
+
+class CreateTaskRequest(BaseModel):
+    prompt: str
+    working_dir: str | None = None
+
+
+class SendMessageRequest(BaseModel):
+    message: str
+
+
+@app.get("/")
+def dashboard():
+    return FileResponse(os.path.join(static_dir, "index.html"))
+
+
+@app.get("/health")
+def health():
+    return {"status": "ok"}
+
+
+@app.post("/tasks")
+def create_task(req: CreateTaskRequest):
+    command = f"claude {shlex.quote(req.prompt)}"
+    task = orch.create_task(command, working_dir=req.working_dir, prompt=req.prompt)
+    return task
+
+
+@app.get("/tasks")
+def list_tasks():
+    return orch.list_tasks()
+
+
+@app.get("/tasks/{task_id}")
+def get_task(task_id: str):
+    if task_id not in orch.tasks:
+        raise HTTPException(status_code=404, detail="Task not found")
+    task = orch.tasks[task_id].copy()
+    task["output"] = orch.get_output(task_id)
+    return task
+
+
+@app.get("/tasks/{task_id}/raw")
+def get_task_raw(task_id: str):
+    if task_id not in orch.tasks:
+        raise HTTPException(status_code=404, detail="Task not found")
+    task = orch.tasks[task_id].copy()
+    task["output"] = orch.get_raw_output(task_id)
+    return task
+
+
+@app.post("/tasks/{task_id}/message")
+def send_message(task_id: str, req: SendMessageRequest):
+    if task_id not in orch.tasks:
+        raise HTTPException(status_code=404, detail="Task not found")
+    orch.send_message(task_id, req.message)
+    return {"status": "sent"}
+
+
+@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")
+    orch.kill_task(task_id)
+    return {"status": "deleted"}
+
+
+app.mount("/static", StaticFiles(directory=static_dir), name="static")

onako-0.1.0/src/onako/static/index.html

@@ -0,0 +1,410 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, viewport-fit=cover">
+    <meta name="apple-mobile-web-app-capable" content="yes">
+    <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">
+    <meta name="theme-color" content="#1a1a1a">
+    <title>Onako</title>
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+            background: #1a1a1a;
+            color: #e0e0e0;
+            min-height: 100dvh;
+        }
+        header {
+            padding: 16px;
+            padding-top: max(16px, env(safe-area-inset-top));
+            border-bottom: 1px solid #333;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+        header h1 { font-size: 18px; font-weight: 600; }
+        #new-task-btn {
+            background: #3b82f6;
+            color: white;
+            border: none;
+            padding: 8px 16px;
+            border-radius: 6px;
+            cursor: pointer;
+            font-size: 14px;
+        }
+        .task-list { padding: 8px; }
+        .task-item {
+            padding: 12px;
+            border-bottom: 1px solid #2a2a2a;
+            cursor: pointer;
+        }
+        .task-item:hover { background: #222; }
+        .task-item .task-id { font-size: 12px; color: #888; }
+        .task-item .task-prompt {
+            font-size: 14px;
+            margin-top: 4px;
+            white-space: nowrap;
+            overflow: hidden;
+            text-overflow: ellipsis;
+        }
+        .task-item .task-meta {
+            font-size: 12px;
+            color: #888;
+            margin-top: 4px;
+        }
+        .status-running { color: #22c55e; }
+        .status-done { color: #888; }
+        .empty-state {
+            text-align: center;
+            color: #666;
+            padding: 48px 16px;
+            font-size: 14px;
+        }
+        #connection-banner {
+            display: none;
+            background: #ef4444;
+            color: white;
+            text-align: center;
+            padding: 6px;
+            font-size: 12px;
+        }
+
+        #detail-view { display: none; flex-direction: column; height: 100dvh; }
+        #detail-view.active { display: flex; }
+        #list-view.hidden { display: none; }
+        #detail-header {
+            padding: 12px 16px;
+            padding-top: max(12px, env(safe-area-inset-top));
+            border-bottom: 1px solid #333;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+        #back-btn {
+            background: none;
+            border: none;
+            color: #3b82f6;
+            cursor: pointer;
+            font-size: 14px;
+        }
+        #kill-btn {
+            background: #ef4444;
+            color: white;
+            border: none;
+            padding: 6px 12px;
+            border-radius: 6px;
+            cursor: pointer;
+            font-size: 12px;
+        }
+        #kill-btn.hidden { display: none; }
+        #output {
+            padding: 12px;
+            font-family: "SF Mono", "Menlo", "Monaco", monospace;
+            font-size: 12px;
+            white-space: pre-wrap;
+            word-break: break-all;
+            line-height: 1.4;
+            overflow-y: auto;
+            flex: 1;
+        }
+        #message-bar {
+            padding: 8px;
+            padding-bottom: max(8px, env(safe-area-inset-bottom));
+            border-top: 1px solid #333;
+            display: flex;
+            flex-shrink: 0;
+            gap: 8px;
+            align-items: center;
+        }
+        #message-input {
+            flex: 1;
+            min-width: 0;
+            background: #2a2a2a;
+            border: 1px solid #444;
+            color: #e0e0e0;
+            padding: 8px 12px;
+            border-radius: 6px;
+            font-size: 16px;
+            -webkit-appearance: none;
+        }
+        #send-btn {
+            background: #3b82f6;
+            color: white;
+            border: none;
+            padding: 8px 12px;
+            border-radius: 6px;
+            cursor: pointer;
+            font-size: 14px;
+            flex-shrink: 0;
+            white-space: nowrap;
+        }
+
+        #modal-overlay {
+            display: none;
+            position: fixed;
+            inset: 0;
+            background: rgba(0,0,0,0.7);
+            z-index: 10;
+        }
+        #modal {
+            position: fixed;
+            bottom: 0;
+            left: 0;
+            right: 0;
+            background: #222;
+            padding: 16px;
+            padding-bottom: max(16px, env(safe-area-inset-bottom));
+            border-radius: 12px 12px 0 0;
+            z-index: 11;
+            display: none;
+        }
+        #modal textarea {
+            width: 100%;
+            background: #2a2a2a;
+            border: 1px solid #444;
+            color: #e0e0e0;
+            padding: 12px;
+            border-radius: 6px;
+            font-size: 14px;
+            resize: vertical;
+            min-height: 80px;
+            font-family: inherit;
+        }
+        #modal input {
+            width: 100%;
+            background: #2a2a2a;
+            border: 1px solid #444;
+            color: #e0e0e0;
+            padding: 10px 12px;
+            border-radius: 6px;
+            font-size: 14px;
+            margin-top: 8px;
+        }
+        #modal button {
+            width: 100%;
+            background: #3b82f6;
+            color: white;
+            border: none;
+            padding: 12px;
+            border-radius: 6px;
+            cursor: pointer;
+            font-size: 16px;
+            margin-top: 12px;
+        }
+    </style>
+</head>
+<body>
+    <div id="connection-banner">Connection lost. Retrying...</div>
+
+    <!-- List View -->
+    <div id="list-view">
+        <header>
+            <h1>Onako</h1>
+            <button id="new-task-btn">+ New Task</button>
+        </header>
+        <div class="task-list" id="task-list"></div>
+    </div>
+
+    <!-- Detail View -->
+    <div id="detail-view">
+        <div id="detail-header">
+            <button id="back-btn">&larr; Back</button>
+            <span id="detail-task-id"></span>
+            <button id="kill-btn">Kill</button>
+        </div>
+        <div id="output"></div>
+        <div id="message-bar">
+            <input id="message-input" type="text" placeholder="Send a message...">
+            <button id="send-btn">Send</button>
+        </div>
+    </div>
+
+    <!-- New Task Modal -->
+    <div id="modal-overlay"></div>
+    <div id="modal">
+        <textarea id="prompt-input" placeholder="What do you want done?"></textarea>
+        <input id="workdir-input" type="text" placeholder="Working directory (optional)">
+        <button id="submit-task-btn">Start Task</button>
+    </div>
+
+    <script>
+        const API = '';
+        let currentTaskId = null;
+        let currentTaskStatus = null;
+        let pollInterval = null;
+
+        function timeAgo(dateStr) {
+            if (!dateStr) return '';
+            const seconds = Math.floor((Date.now() - new Date(dateStr).getTime()) / 1000);
+            if (seconds < 60) return 'just now';
+            const minutes = Math.floor(seconds / 60);
+            if (minutes < 60) return `${minutes}m ago`;
+            const hours = Math.floor(minutes / 60);
+            if (hours < 24) return `${hours}h ago`;
+            const days = Math.floor(hours / 24);
+            return `${days}d ago`;
+        }
+
+        function showConnectionError(show) {
+            document.getElementById('connection-banner').style.display = show ? 'block' : 'none';
+        }
+
+        async function loadTasks() {
+            try {
+                const res = await fetch(`${API}/tasks`);
+                const tasks = (await res.json()).filter(t => t.status === 'running');
+                const list = document.getElementById('task-list');
+                if (tasks.length === 0) {
+                    list.innerHTML = '<div class="empty-state">No tasks running</div>';
+                } else {
+                    list.innerHTML = tasks.map(t => `
+                        <div class="task-item" onclick="showTask('${t.id}')">
+                            <div class="task-id">${t.id}</div>
+                            <div class="task-prompt">${escapeHtml(t.prompt)}</div>
+                            <div class="task-meta">
+                                <span class="status-${t.status}">${t.status}</span>
+                                ${t.started_at ? ' &middot; ' + timeAgo(t.started_at) : ''}
+                            </div>
+                        </div>
+                    `).join('');
+                }
+                showConnectionError(false);
+            } catch (e) {
+                showConnectionError(true);
+            }
+        }
+
+        async function showTask(id) {
+            currentTaskId = id;
+            currentTaskStatus = null;
+            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');
+            await refreshOutput();
+            pollInterval = setInterval(refreshOutput, 3000);
+        }
+
+        async function refreshOutput() {
+            if (!currentTaskId) return;
+            try {
+                const res = await fetch(`${API}/tasks/${currentTaskId}`);
+                if (!res.ok) return;
+                const data = await res.json();
+                const el = document.getElementById('output');
+                const wasAtBottom = el.scrollHeight - el.scrollTop - el.clientHeight < 50;
+                el.textContent = data.output || '(no output yet)';
+                if (wasAtBottom) el.scrollTop = el.scrollHeight;
+                showConnectionError(false);
+
+                // Stop polling and hide kill button when task is done
+                if (data.status === 'done' && currentTaskStatus !== 'done') {
+                    currentTaskStatus = 'done';
+                    document.getElementById('kill-btn').classList.add('hidden');
+                    if (pollInterval) {
+                        clearInterval(pollInterval);
+                        pollInterval = null;
+                    }
+                }
+            } catch (e) {
+                showConnectionError(true);
+            }
+        }
+
+        function showList() {
+            currentTaskId = null;
+            currentTaskStatus = null;
+            if (pollInterval) clearInterval(pollInterval);
+            pollInterval = null;
+            document.getElementById('detail-view').classList.remove('active');
+            document.getElementById('list-view').classList.remove('hidden');
+            loadTasks();
+        }
+
+        async function sendMessage() {
+            const input = document.getElementById('message-input');
+            const msg = input.value.trim();
+            if (!msg || !currentTaskId) return;
+            try {
+                await fetch(`${API}/tasks/${currentTaskId}/message`, {
+                    method: 'POST',
+                    headers: {'Content-Type': 'application/json'},
+                    body: JSON.stringify({message: msg}),
+                });
+                input.value = '';
+            } catch (e) {
+                showConnectionError(true);
+            }
+        }
+
+        async function killTask() {
+            if (!currentTaskId) return;
+            if (!confirm('Kill this task?')) return;
+            try {
+                await fetch(`${API}/tasks/${currentTaskId}`, {method: 'DELETE'});
+                showList();
+            } catch (e) {
+                showConnectionError(true);
+            }
+        }
+
+        function showModal() {
+            document.getElementById('modal').style.display = 'block';
+            document.getElementById('modal-overlay').style.display = 'block';
+            document.getElementById('prompt-input').focus();
+        }
+
+        function hideModal() {
+            document.getElementById('modal').style.display = 'none';
+            document.getElementById('modal-overlay').style.display = 'none';
+        }
+
+        async function submitTask() {
+            const prompt = document.getElementById('prompt-input').value.trim();
+            if (!prompt) return;
+            const workdir = document.getElementById('workdir-input').value.trim() || null;
+            const body = {prompt};
+            if (workdir) body.working_dir = workdir;
+            try {
+                const res = await fetch(`${API}/tasks`, {
+                    method: 'POST',
+                    headers: {'Content-Type': 'application/json'},
+                    body: JSON.stringify(body),
+                });
+                const task = await res.json();
+                document.getElementById('prompt-input').value = '';
+                document.getElementById('workdir-input').value = '';
+                hideModal();
+                showTask(task.id);
+            } catch (e) {
+                showConnectionError(true);
+            }
+        }
+
+        function escapeHtml(s) {
+            const d = document.createElement('div');
+            d.textContent = s;
+            return d.innerHTML;
+        }
+
+        // Event listeners
+        document.getElementById('new-task-btn').addEventListener('click', showModal);
+        document.getElementById('modal-overlay').addEventListener('click', hideModal);
+        document.getElementById('submit-task-btn').addEventListener('click', submitTask);
+        document.getElementById('back-btn').addEventListener('click', showList);
+        document.getElementById('kill-btn').addEventListener('click', killTask);
+        document.getElementById('send-btn').addEventListener('click', sendMessage);
+        document.getElementById('message-input').addEventListener('keydown', e => {
+            if (e.key === 'Enter') sendMessage();
+        });
+        document.getElementById('prompt-input').addEventListener('keydown', e => {
+            if ((e.metaKey || e.ctrlKey) && e.key === 'Enter') submitTask();
+        });
+
+        // Init
+        loadTasks();
+        setInterval(() => { if (!currentTaskId) loadTasks(); }, 10000);
+    </script>
+</body>
+</html>

onako-0.1.0/src/onako/templates/com.onako.server.plist.tpl

@@ -0,0 +1,30 @@
+<?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>
+    </array>
+    <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-0.1.0/src/onako/templates/onako.service.tpl

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

onako-0.1.0/src/onako/tmux_orchestrator.py

@@ -0,0 +1,175 @@
+import re
+import secrets
+import shlex
+import sqlite3
+import subprocess
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+DB_PATH = Path.home() / ".onako" / "onako.db"
+
+
+class TmuxOrchestrator:
+    def __init__(self, session_name: str = "onako", db_path: Path | None = None):
+        self.session_name = session_name
+        self.db_path = db_path or DB_PATH
+        self.tasks: dict[str, dict] = {}
+        self._init_db()
+        self._load_tasks()
+        self._ensure_session()
+        self.rediscover_tasks()
+
+    def _ensure_session(self):
+        result = subprocess.run(
+            ["tmux", "has-session", "-t", self.session_name],
+            capture_output=True,
+        )
+        if result.returncode != 0:
+            subprocess.run(
+                ["tmux", "new-session", "-d", "-s", self.session_name],
+                check=True,
+            )
+
+    def _init_db(self):
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        conn = sqlite3.connect(self.db_path)
+        conn.execute("""
+            CREATE TABLE IF NOT EXISTS tasks (
+                id TEXT PRIMARY KEY,
+                prompt TEXT,
+                status TEXT,
+                started_at TEXT
+            )
+        """)
+        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()
+        conn.close()
+        for row in rows:
+            self.tasks[row[0]] = {
+                "id": row[0],
+                "prompt": row[1],
+                "status": row[2],
+                "started_at": row[3],
+            }
+
+    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"]),
+        )
+        conn.commit()
+        conn.close()
+
+    def _run_tmux(self, *args) -> subprocess.CompletedProcess:
+        return subprocess.run(["tmux", *args], capture_output=True, text=True)
+
+    def create_task(self, command: str, working_dir: str | None = None, prompt: str | None = None) -> dict:
+        task_id = f"task-{secrets.token_hex(4)}"
+        self._run_tmux(
+            "new-window", "-t", self.session_name, "-n", task_id,
+        )
+        if working_dir:
+            self._run_tmux(
+                "send-keys", "-t", f"{self.session_name}:{task_id}",
+                f"cd {shlex.quote(working_dir)}", "Enter",
+            )
+        self._run_tmux(
+            "send-keys", "-t", f"{self.session_name}:{task_id}",
+            command, "Enter",
+        )
+        task = {
+            "id": task_id,
+            "prompt": prompt or command,
+            "status": "running",
+            "started_at": datetime.now(timezone.utc).isoformat(),
+        }
+        self.tasks[task_id] = task
+        self._save_task(task)
+        return task
+
+    def list_tasks(self) -> list[dict]:
+        self._sync_task_status()
+        return list(self.tasks.values())
+
+    def get_output(self, task_id: str) -> str:
+        raw = self.get_raw_output(task_id)
+        cleaned = re.sub(r"\x1b\[[0-9;]*[a-zA-Z]", "", raw)
+        return self._strip_claude_chrome(cleaned)
+
+    @staticmethod
+    def _strip_claude_chrome(text: str) -> str:
+        lines = text.split("\n")
+        # Strip from the bottom: Claude Code's TUI draws box-drawing chars,
+        # the › prompt, and status lines like "accept edits on..."
+        while lines:
+            line = lines[-1].strip()
+            if (
+                not line
+                or all(c in "─━╭╮╰╯│┃┌┐└┘├┤┬┴┼╋═║ ›❯▸▶" for c in line)
+                or "accept edits" in line
+                or "esc to interrupt" in line
+                or "shift+tab to cycle" in line
+                or "ctrl+" in line.lower()
+                or line == "›"
+            ):
+                lines.pop()
+            else:
+                break
+        return "\n".join(lines)
+
+    def get_raw_output(self, task_id: str) -> str:
+        result = self._run_tmux(
+            "capture-pane", "-t", f"{self.session_name}:{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}",
+            "-l", message,
+        )
+        self._run_tmux(
+            "send-keys", "-t", f"{self.session_name}:{task_id}",
+            "Enter",
+        )
+
+    def kill_task(self, task_id: str):
+        self._run_tmux("kill-window", "-t", f"{self.session_name}:{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}",
+        )
+        active_windows = set(result.stdout.strip().split("\n")) if result.stdout.strip() else set()
+        for task_id, task in self.tasks.items():
+            if task["status"] == "running" and task_id not in active_windows:
+                task["status"] = "done"
+                self._save_task(task)
+
+    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}",
+        )
+        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:
+                task = {
+                    "id": window_name,
+                    "prompt": "(rediscovered)",
+                    "status": "running",
+                    "started_at": None,
+                }
+                self.tasks[window_name] = task
+                self._save_task(task)

onako-0.1.0/src/onako.egg-info/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: onako
+Version: 0.1.0
+Summary: Dispatch and monitor Claude Code tasks from your phone
+Author: Amir
+License-Expression: MIT
+Project-URL: Repository, https://github.com/AzRu/onako
+Keywords: claude,claude-code,tmux,orchestrator,ai
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi>=0.100.0
+Requires-Dist: uvicorn>=0.20.0
+Requires-Dist: click>=8.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: httpx>=0.24.0; extra == "dev"
+
+# 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 serve
+```
+
+Open http://localhost:8000 on your phone (same network) or set up [Tailscale](https://tailscale.com) for access from anywhere.
+
+### Auto-start on boot
+
+```bash
+onako install
+```
+
+### Other commands
+
+```bash
+onako status      # Check if server is running
+onako uninstall   # Remove auto-start 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.1.0/src/onako.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+README.md
+pyproject.toml
+src/onako/__init__.py
+src/onako/cli.py
+src/onako/server.py
+src/onako/tmux_orchestrator.py
+src/onako.egg-info/PKG-INFO
+src/onako.egg-info/SOURCES.txt
+src/onako.egg-info/dependency_links.txt
+src/onako.egg-info/entry_points.txt
+src/onako.egg-info/requires.txt
+src/onako.egg-info/top_level.txt
+src/onako/static/index.html
+src/onako/templates/com.onako.server.plist.tpl
+src/onako/templates/onako.service.tpl
+tests/test_api.py
+tests/test_cli.py
+tests/test_cli_service.py
+tests/test_tmux_orchestrator.py

onako-0.1.0/src/onako.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

onako-0.1.0/src/onako.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+onako = onako.cli:main

onako-0.1.0/src/onako.egg-info/requires.txt

@@ -0,0 +1,7 @@
+fastapi>=0.100.0
+uvicorn>=0.20.0
+click>=8.0.0
+
+[dev]
+pytest>=7.0
+httpx>=0.24.0

onako-0.1.0/src/onako.egg-info/top_level.txt

@@ -0,0 +1 @@
+onako

onako-0.1.0/tests/test_api.py

@@ -0,0 +1,74 @@
+import pytest
+from fastapi.testclient import TestClient
+
+
+@pytest.fixture
+def client():
+    import importlib
+    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']}")
+
+
+def test_health(client):
+    r = client.get("/health")
+    assert r.status_code == 200
+    assert r.json()["status"] == "ok"
+
+
+def test_create_task(client):
+    r = client.post("/tasks", json={"prompt": "echo api-test"})
+    assert r.status_code == 200
+    assert r.json()["id"].startswith("task-")
+
+
+def test_list_tasks(client):
+    client.post("/tasks", json={"prompt": "echo one"})
+    client.post("/tasks", json={"prompt": "echo two"})
+    r = client.get("/tasks")
+    assert r.status_code == 200
+    assert len(r.json()) >= 2
+
+
+def test_get_task(client):
+    create = client.post("/tasks", json={"prompt": "echo detail-test"})
+    task_id = create.json()["id"]
+    import time
+    time.sleep(1)
+    r = client.get(f"/tasks/{task_id}")
+    assert r.status_code == 200
+    assert r.json()["id"] == task_id
+    assert "output" in r.json()
+
+
+def test_get_task_raw(client):
+    create = client.post("/tasks", json={"prompt": "echo raw-api-test"})
+    task_id = create.json()["id"]
+    import time
+    time.sleep(1)
+    r = client.get(f"/tasks/{task_id}/raw")
+    assert r.status_code == 200
+    assert "output" in r.json()
+
+
+def test_send_message(client):
+    create = client.post("/tasks", json={"prompt": "cat"})
+    task_id = create.json()["id"]
+    r = client.post(f"/tasks/{task_id}/message", json={"message": "hello"})
+    assert r.status_code == 200
+
+
+def test_delete_task(client):
+    create = client.post("/tasks", json={"prompt": "sleep 999"})
+    task_id = create.json()["id"]
+    r = client.delete(f"/tasks/{task_id}")
+    assert r.status_code == 200
+
+
+def test_get_nonexistent_task(client):
+    r = client.get("/tasks/task-nonexistent")
+    assert r.status_code == 404

onako-0.1.0/tests/test_cli.py

@@ -0,0 +1,17 @@
+from click.testing import CliRunner
+from onako.cli import main
+
+
+def test_version():
+    runner = CliRunner()
+    result = runner.invoke(main, ["version"])
+    assert result.exit_code == 0
+    assert "0.1.0" in result.output
+
+
+def test_serve_help():
+    runner = CliRunner()
+    result = runner.invoke(main, ["serve", "--help"])
+    assert result.exit_code == 0
+    assert "--host" in result.output
+    assert "--port" in result.output

onako-0.1.0/tests/test_cli_service.py

@@ -0,0 +1,16 @@
+from click.testing import CliRunner
+from onako.cli import main
+
+
+def test_status_reports_something():
+    runner = CliRunner()
+    result = runner.invoke(main, ["status"])
+    assert result.exit_code == 0
+    assert "Onako server:" in result.output
+
+
+def test_uninstall_when_not_installed():
+    runner = CliRunner()
+    result = runner.invoke(main, ["uninstall"])
+    assert result.exit_code == 0
+    assert "not installed" in result.output

onako-0.1.0/tests/test_tmux_orchestrator.py

@@ -0,0 +1,73 @@
+import subprocess
+import time
+from pathlib import Path
+import pytest
+from onako.tmux_orchestrator import TmuxOrchestrator
+
+SESSION_NAME = "onako-test"
+
+
+@pytest.fixture(autouse=True)
+def cleanup(tmp_path):
+    """Kill test tmux session before and after each test."""
+    subprocess.run(["tmux", "kill-session", "-t", SESSION_NAME], capture_output=True)
+    yield
+    subprocess.run(["tmux", "kill-session", "-t", SESSION_NAME], capture_output=True)
+
+
+@pytest.fixture
+def orch(tmp_path):
+    return TmuxOrchestrator(session_name=SESSION_NAME, db_path=tmp_path / "test.db")
+
+
+def test_create_task_returns_id(orch):
+    task = orch.create_task("echo hello")
+    assert task["id"].startswith("task-")
+    assert task["status"] == "running"
+    assert task["prompt"] == "echo hello"
+
+
+def test_list_tasks_shows_created_task(orch):
+    task = orch.create_task("echo hello")
+    tasks = orch.list_tasks()
+    assert any(t["id"] == task["id"] for t in tasks)
+
+
+def test_get_output_captures_pane(orch):
+    task = orch.create_task("echo hello-from-test")
+    time.sleep(1)
+    output = orch.get_output(task["id"])
+    assert "hello-from-test" in output
+
+
+def test_get_raw_output(orch):
+    task = orch.create_task("echo raw-test")
+    time.sleep(1)
+    raw = orch.get_raw_output(task["id"])
+    assert "raw-test" in raw
+
+
+def test_send_message(orch):
+    task = orch.create_task("cat")  # cat waits for stdin
+    time.sleep(0.5)
+    orch.send_message(task["id"], "hello-input")
+    time.sleep(1)
+    output = orch.get_output(task["id"])
+    assert "hello-input" in output
+
+
+def test_kill_task(orch):
+    task = orch.create_task("sleep 999")
+    orch.kill_task(task["id"])
+    tasks = orch.list_tasks()
+    assert not any(t["id"] == task["id"] and t["status"] == "running" for t in tasks)
+
+
+def test_create_multiple_tasks(orch):
+    t1 = orch.create_task("echo one")
+    t2 = orch.create_task("echo two")
+    tasks = orch.list_tasks()
+    ids = [t["id"] for t in tasks]
+    assert t1["id"] in ids
+    assert t2["id"] in ids
+    assert t1["id"] != t2["id"]