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

onako/__init__.py

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

onako/cli.py

@@ -1,5 +1,6 @@
 import os
 import platform
+import socket
 import shutil
 import subprocess
 import sys
@@ -9,12 +10,51 @@ 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.pass_context
+def main(ctx, host, port, session, working_dir):
     """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)
+
+    # 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,9 +67,10 @@ 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):
+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()
 
@@ -40,11 +81,13 @@ def serve(host, port, working_dir, background):
     _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
@@ -55,32 +98,46 @@ 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)
+
+    # 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()
@@ -99,6 +156,72 @@ def status():
         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()
@@ -191,18 +314,25 @@ def _install_systemd(onako_bin, host, port, working_dir, path_value):
     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,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/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/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,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"
@@ -160,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.1.dist-info → onako-0.3.0.dist-info}/METADATA

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

@@ -0,0 +1,12 @@
+onako/__init__.py,sha256=VrXpHDu3erkzwl_WXrqINBm9xWkcyUy53IQOj042dOs,22
+onako/cli.py,sha256=S6Haa3X16s5EaLzbLw6W2W3bO_26jt3utgMB8sohM-k,11786
+onako/server.py,sha256=cff5cKRgeItRNLfvPHQ5NMX8eBl5Sesn26G3rac7KyY,2261
+onako/tmux_orchestrator.py,sha256=D83eY7iSSgKoZwhd-sjk-JM2bfNE30AyoPAbNwrTZIg,8152
+onako/static/index.html,sha256=_l_ELWjtmLBk-5p3b3tjJ0fj83IT4GzJBrWbcaTFKQo,14917
+onako/templates/com.onako.server.plist.tpl,sha256=XvjvRz_AnjcREVjDPFu2qGMVCxojp6hhTwMfvrFcEbY,994
+onako/templates/onako.service.tpl,sha256=EOVOaLtxC1FrcLdy7DtEbtf9ImgN6PmnMb57ZT81nTM,280
+onako-0.3.0.dist-info/METADATA,sha256=_6meanq6QmLs-0ddqo8lCYR4HNXsw66fQXikk23cBoc,1956
+onako-0.3.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+onako-0.3.0.dist-info/entry_points.txt,sha256=51KRJzuVpr69iT_k4JO0Lj3DQv_HbgtGjTBTev13JAQ,41
+onako-0.3.0.dist-info/top_level.txt,sha256=EZsc5qq2paM9GTbaFE9Xar4B5wFdfIqK9l_bDQVcmZ4,6
+onako-0.3.0.dist-info/RECORD,,

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,,