symphony-code 0.0.1__py3-none-any.whl

coding_agent/protocols/stdio/server.py

@@ -0,0 +1,181 @@
+"""One-turn stdio command loop."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import sys
+from pathlib import Path
+from collections.abc import Sequence
+from typing import Any, Mapping
+
+from core_harness import Answer, Interrupt, UserInput
+
+from coding_agent.commands.catalog import EFFORTS
+from coding_agent.config import ensure_spawn_settings
+from coding_agent.protocols.stdio import commands as command_module
+from coding_agent.protocols.stdio.commands import load_state
+from coding_agent.protocols.stdio.transport import CAPABILITIES, PROTOCOL_VERSION, StdioSink
+
+# Look these up on the package so tests can patch ``stdio.write_frame`` and
+# ``stdio.build_agent`` without reaching into the implementation modules.
+def _package() -> Any:
+    from coding_agent.protocols import stdio
+
+    return stdio
+
+
+def _request_id(command: Mapping[str, Any], kind: str) -> str | None:
+    request_id = command.get("request_id")
+    if isinstance(request_id, str) and request_id:
+        return request_id
+    _package().write_frame({"type": "error", "message": f"{kind} requires request_id"})
+    return None
+
+
+async def _run_turn(agent: Any, prompt: str, attachments: Sequence[str], effort: str | None) -> None:
+    try:
+        if effort is not None:
+            if effort not in EFFORTS:
+                raise ValueError(f"Unsupported reasoning effort: {effort}")
+            agent.harness.reasoning_effort = None if effort == "default" else effort
+        stripped = prompt.lstrip()
+        parts = stripped[1:].split(None, 1) if stripped.startswith("/") else []
+        name = parts[0].lower() if parts else ""
+        stdio = _package()
+        names = {item["name"] for item in command_module.catalog(extra=agent.user_addons.surface.slash_commands)}
+        if name in names:
+            if attachments:
+                raise ValueError("Slash commands do not accept image attachments")
+            result = await command_module.execute(agent, stripped)
+            stdio.write_frame({"type": "event", "event": "text_delta", "payload": {"delta": result}})
+        else:
+            await agent.run(stdio.user_content(prompt, attachments))
+        stdio.write_frame({"type": "done", "status": "completed"})
+    except asyncio.CancelledError:
+        _package().write_frame({"type": "done", "status": "interrupted"})
+    except Exception as exc:
+        stdio = _package()
+        stdio.write_frame({"type": "error", "message": f"{type(exc).__name__}: {exc}"})
+        stdio.write_frame({"type": "done", "status": "errored"})
+
+
+async def serve(
+    workspace: Path,
+    model: str | None,
+    session_id: str | None,
+    *,
+    unattended: bool = False,
+) -> int:
+    stdio = _package()
+    stdio.load_provider_env(workspace)
+    sink = StdioSink()
+    try:
+        agent = stdio.build_agent(
+            workspace=workspace,
+            model_id=model,
+            session_id=session_id,
+            sink=sink,
+            config=ensure_spawn_settings(workspace, overrides={"unattended": True}) if unattended else None,
+            client="zeron",
+        )
+        load_state(agent)
+    except Exception as exc:
+        _package().write_frame({"type": "error", "message": f"{type(exc).__name__}: {exc}"})
+        return 1
+
+    stdio.write_frame({
+        "type": "ready",
+        "session_id": agent.session_id,
+        "model": getattr(agent.harness, "model_id", model or ""),
+        "protocol_version": PROTOCOL_VERSION,
+        "capabilities": CAPABILITIES,
+    })
+    run: asyncio.Task[Any] | None = None
+    while True:
+        line = await asyncio.to_thread(sys.stdin.readline)
+        if not line:
+            if run is not None and not run.done():
+                run.cancel()
+                await asyncio.gather(run, return_exceptions=True)
+            return 0
+        try:
+            command = json.loads(line)
+        except json.JSONDecodeError:
+            stdio.write_frame({"type": "error", "message": "invalid JSON command"})
+            continue
+        if not isinstance(command, dict):
+            stdio.write_frame({"type": "error", "message": "invalid command: not an object"})
+            continue
+        kind = command.get("type")
+        if kind == "model/list":
+            request_id = _request_id(command, kind)
+            if request_id is None:
+                continue
+            try:
+                stdio.write_frame(stdio.model_catalog(agent.registry, request_id))
+            except Exception as exc:
+                stdio.write_frame({
+                    "type": "error", "request_id": request_id, "message": f"{type(exc).__name__}: {exc}",
+                })
+        elif kind == "command/list":
+            request_id = _request_id(command, kind)
+            if request_id is None:
+                continue
+            try:
+                stdio.write_frame({
+                    "type": "commands",
+                    "request_id": request_id,
+                    "commands": command_module.catalog(workspace, agent.user_addons.surface.slash_commands),
+                    "protocol_version": PROTOCOL_VERSION,
+                })
+            except Exception as exc:
+                stdio.write_frame({
+                    "type": "error", "request_id": request_id, "message": f"{type(exc).__name__}: {exc}",
+                })
+        elif kind == "answer":
+            agent.harness.submit(Answer(str(command.get("request_id") or ""), str(command.get("value", ""))))
+        elif kind == "interrupt":
+            # A slash command runs outside the harness; cancel its task instead.
+            if run is not None and not run.done() and not agent.harness.submit(Interrupt()):
+                run.cancel()
+        elif kind == "steer":
+            prompt = command.get("prompt")
+            if not isinstance(prompt, str) or not prompt.strip():
+                stdio.write_frame({"type": "error", "message": "prompt is required"})
+            elif not agent.harness.submit(UserInput(prompt)):
+                stdio.write_frame({"type": "error", "message": "steer requires an active run"})
+        elif kind == "run" and (run is None or run.done()):
+            prompt = command.get("prompt")
+            if not isinstance(prompt, str) or not prompt.strip():
+                stdio.write_frame({"type": "error", "message": "prompt is required"})
+                continue
+            paths = command.get("attachments") or []
+            if not isinstance(paths, list) or not all(isinstance(path, str) for path in paths):
+                stdio.write_frame({"type": "error", "message": "attachments must be a list of paths"})
+                continue
+            effort = command.get("reasoning_effort")
+            run = asyncio.create_task(_run_turn(agent, prompt, paths, effort if isinstance(effort, str) else None))
+        else:
+            stdio.write_frame({"type": "error", "message": f"invalid command: {kind}"})
+
+
+def main(argv: Sequence[str]) -> int:
+    parser = argparse.ArgumentParser(prog="symphony stdio")
+    parser.add_argument("--workspace", default=".")
+    parser.add_argument("--model")
+    parser.add_argument("--session-id")
+    parser.add_argument("--unattended", action="store_true", help="Auto-approve tools subject to Symphony deny rules")
+    args = parser.parse_args(argv)
+    # Libraries may print diagnostics; stdout belongs exclusively to JSONL.
+    sys.stdout = sys.stderr
+    return asyncio.run(serve(
+        Path(args.workspace).expanduser().resolve(),
+        args.model,
+        args.session_id,
+        unattended=args.unattended,
+    ))
+
+
+__all__ = ["main", "serve"]

coding_agent/protocols/stdio/transport.py

@@ -0,0 +1,71 @@
+"""JSONL frames and the event sink that writes them."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+from typing import Any, Dict, Mapping, Sequence
+
+from core_ai.content import image_part_from_bytes, sniff_image_media_type
+from core_ai.types import Content
+from core_harness import EventSink, HumanInteraction
+
+
+def _write(frame: Mapping[str, Any]) -> None:
+    """Write through the package so ``stdio.write_frame`` stays patchable."""
+    from coding_agent.protocols import stdio
+
+    stdio.write_frame(frame)
+
+PROTOCOL_VERSION = 2
+CAPABILITIES = ["runs", "resume", "interrupt", "input", "steer", "models", "images", "subagents", "commands"]
+
+
+def write_frame(frame: Mapping[str, Any]) -> None:
+    sys.__stdout__.write(json.dumps(frame, default=str, ensure_ascii=False) + "\n")
+    sys.__stdout__.flush()
+
+
+def user_content(prompt: str, attachments: Sequence[str]) -> Content:
+    """Inline staged image bytes using the same canonical parts as the TUI."""
+    if not attachments:
+        return prompt
+    if len(attachments) > 8:
+        raise ValueError("at most eight images can be attached")
+    parts: list[dict[str, Any]] = [{"type": "text", "text": prompt}]
+    for raw in attachments:
+        path = Path(raw).expanduser().resolve(strict=True)
+        if not path.is_file() or path.stat().st_size > 20 * 1024 * 1024:
+            raise ValueError("attachment must be a regular image under 20 MiB")
+        payload = path.read_bytes()
+        media = sniff_image_media_type(payload, filename=path.name)
+        if media is None:
+            raise ValueError(f"unsupported image: {path.name}")
+        parts.append(image_part_from_bytes(payload, media_type=media, filename=path.name))
+    return parts
+
+
+class StdioSink(EventSink):
+    """Write each event as a frame.
+
+    A question is the ``question_asked`` event like in every other host.
+    Protocol 2 hosts read ``input_requested``, so that frame follows it.
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.interaction = HumanInteraction(self)
+
+    async def deliver(self, event_type: str, payload: Dict[str, Any]) -> None:
+        _write({"type": "event", "event": event_type, "payload": payload})
+        if event_type == "question_asked":
+            known = {"request_id", "question", "choices", "default", "kind"}
+            _write({
+                "type": "input_requested",
+                **{key: payload.get(key) for key in ("request_id", "question", "choices", "default", "kind")},
+                "metadata": {key: value for key, value in payload.items() if key not in known},
+            })
+
+
+__all__ = ["CAPABILITIES", "PROTOCOL_VERSION", "StdioSink", "user_content", "write_frame"]

coding_agent/resources/__init__.py

@@ -0,0 +1,5 @@
+"""Process resource snapshots used by the agent dashboard."""
+
+from coding_agent.resources.usage import AgentUsage, process_alive, sample_usage
+
+__all__ = ["AgentUsage", "process_alive", "sample_usage"]

coding_agent/resources/usage.py

@@ -0,0 +1,264 @@
+"""CPU, memory, and disk snapshots for a live agent process.
+
+The helpers stay in the standard library so the dashboard works on macOS,
+Linux, and Windows without an extra dependency. Each OS reads the numbers it
+publishes and leaves the rest unknown rather than guessing.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class AgentUsage:
+    """One sample of a process. ``None`` means the OS did not report it."""
+
+    pid: int
+    alive: bool
+    cpu_percent: float | None = None
+    rss_bytes: int | None = None
+    disk_bytes: int | None = None
+
+    def line(self) -> str:
+        """Single-row summary: ``cpu 12%  ram 48.0 MB  disk 1.2 KB``."""
+        return (
+            f"cpu {_percent(self.cpu_percent):>4}  "
+            f"ram {_bytes(self.rss_bytes):>8}  "
+            f"disk {_bytes(self.disk_bytes):>8}"
+        )
+
+
+def _percent(value: float | None) -> str:
+    if value is None:
+        return "n/a"
+    return f"{value:.0f}%"
+
+
+def _bytes(value: int | None) -> str:
+    if value is None:
+        return "n/a"
+    size = float(value)
+    for unit in ("B", "KB", "MB", "GB", "TB"):
+        if size < 1024 or unit == "TB":
+            return f"{size:.0f} {unit}" if unit == "B" else f"{size:.1f} {unit}"
+        size /= 1024
+    return f"{size:.1f} TB"
+
+
+def process_alive(pid: int) -> bool:
+    """True when ``pid`` is still a process. ``pid`` 0 and 1 are never ours."""
+    if pid <= 1:
+        return False
+    if sys.platform == "win32":
+        return _windows_alive(pid)
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+    except OSError:
+        return False
+    return True
+
+
+def _windows_alive(pid: int) -> bool:
+    import ctypes
+
+    process = ctypes.windll.kernel32.OpenProcess(0x1000, False, pid)  # PROCESS_QUERY_LIMITED_INFORMATION
+    if not process:
+        return False
+    ctypes.windll.kernel32.CloseHandle(process)
+    return True
+
+
+def sample_usage(
+    pid: int,
+    *,
+    workspace: str | Path | None = None,
+    previous_cpu_seconds: float | None = None,
+    previous_at: float | None = None,
+) -> tuple[AgentUsage, float | None, float]:
+    """Sample one process and return ``(usage, cpu_seconds, sampled_at)``.
+
+    CPU percent needs two samples. The first call returns ``cpu_percent=None``
+    and a ``cpu_seconds`` value the caller should pass back next time.
+    """
+    sampled_at = time.monotonic()
+    if not process_alive(pid):
+        return AgentUsage(pid=pid, alive=False), None, sampled_at
+    cpu_seconds, rss = _process_counters(pid)
+    cpu_percent = _cpu_percent(cpu_seconds, previous_cpu_seconds, sampled_at, previous_at)
+    disk = directory_size(workspace) if workspace else None
+    return (
+        AgentUsage(pid=pid, alive=True, cpu_percent=cpu_percent, rss_bytes=rss, disk_bytes=disk),
+        cpu_seconds,
+        sampled_at,
+    )
+
+
+def _cpu_percent(
+    cpu_seconds: float | None,
+    previous_cpu_seconds: float | None,
+    sampled_at: float,
+    previous_at: float | None,
+) -> float | None:
+    if (
+        cpu_seconds is None
+        or previous_cpu_seconds is None
+        or previous_at is None
+        or sampled_at <= previous_at
+    ):
+        return None
+    elapsed = sampled_at - previous_at
+    cores = os.cpu_count() or 1
+    used = max(0.0, cpu_seconds - previous_cpu_seconds)
+    return min(100.0 * cores, (used / elapsed) * 100.0)
+
+
+def directory_size(path: str | Path | None) -> int | None:
+    """Bytes used by ``path``. A file uses its size; a directory is walked."""
+    if path is None:
+        return None
+    target = Path(path)
+    try:
+        if target.is_file():
+            return target.stat().st_size
+        if not target.is_dir():
+            return None
+        total = 0
+        for root, _dirs, files in os.walk(target):
+            for name in files:
+                try:
+                    total += (Path(root) / name).stat().st_size
+                except OSError:
+                    continue
+        return total
+    except OSError:
+        return None
+
+
+def _process_counters(pid: int) -> tuple[float | None, int | None]:
+    if sys.platform == "linux":
+        return _linux_counters(pid)
+    if sys.platform == "darwin":
+        return _darwin_counters(pid)
+    if sys.platform == "win32":
+        return _windows_counters(pid)
+    return None, None
+
+
+def _linux_counters(pid: int) -> tuple[float | None, int | None]:
+    try:
+        text = Path(f"/proc/{pid}/stat").read_text(encoding="utf-8")
+    except OSError:
+        return None, None
+    # comm can contain spaces and parentheses; fields after the last ")".
+    tail = text.rsplit(")", 1)[-1].split()
+    cpu_seconds = None
+    if len(tail) >= 13:
+        # utime and stime are fields 14 and 15 of stat, indexes 11 and 12 here.
+        ticks = os.sysconf("SC_CLK_TCK") or 100
+        cpu_seconds = (int(tail[11]) + int(tail[12])) / ticks
+    rss = None
+    if len(tail) >= 22:
+        rss = int(tail[21]) * (os.sysconf("SC_PAGE_SIZE") or 4096)
+    return cpu_seconds, rss
+
+
+def _darwin_counters(pid: int) -> tuple[float | None, int | None]:
+    import subprocess
+
+    try:
+        completed = subprocess.run(
+            ["ps", "-o", "time=,rss=", "-p", str(pid)],
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=2,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None, None
+    parts = completed.stdout.split()
+    if len(parts) < 2:
+        return None, None
+    return _parse_ps_time(parts[0]), int(parts[1]) * 1024
+
+
+def _parse_ps_time(value: str) -> float | None:
+    """Parse ``ps`` TIME, which is ``[[dd-]hh:]mm:ss``."""
+    days = 0
+    clock = value
+    if "-" in value:
+        day_text, clock = value.split("-", 1)
+        try:
+            days = int(day_text)
+        except ValueError:
+            return None
+    pieces = clock.split(":")
+    try:
+        numbers = [int(piece) for piece in pieces]
+    except ValueError:
+        return None
+    if len(numbers) == 2:
+        minutes, seconds = numbers
+        hours = 0
+    elif len(numbers) == 3:
+        hours, minutes, seconds = numbers
+    else:
+        return None
+    return ((days * 24 + hours) * 60 + minutes) * 60 + seconds
+
+
+def _windows_counters(pid: int) -> tuple[float | None, int | None]:
+    import ctypes
+    from ctypes import wintypes
+
+    class ProcessMemoryCounters(ctypes.Structure):
+        _fields_ = [
+            ("cb", wintypes.DWORD),
+            ("PageFaultCount", wintypes.DWORD),
+            ("PeakWorkingSetSize", ctypes.c_size_t),
+            ("WorkingSetSize", ctypes.c_size_t),
+            ("QuotaPeakPagedPoolUsage", ctypes.c_size_t),
+            ("QuotaPagedPoolUsage", ctypes.c_size_t),
+            ("QuotaPeakNonPagedPoolUsage", ctypes.c_size_t),
+            ("QuotaNonPagedPoolUsage", ctypes.c_size_t),
+            ("PagefileUsage", ctypes.c_size_t),
+            ("PeakPagefileUsage", ctypes.c_size_t),
+        ]
+
+    kernel = ctypes.windll.kernel32
+    process = kernel.OpenProcess(0x1000 | 0x0400, False, pid)
+    if not process:
+        return None, None
+    rss = None
+    counters = ProcessMemoryCounters()
+    counters.cb = ctypes.sizeof(counters)
+    psapi = ctypes.windll.psapi
+    if psapi.GetProcessMemoryInfo(process, ctypes.byref(counters), counters.cb):
+        rss = int(counters.WorkingSetSize)
+    cpu_seconds = None
+    creation = wintypes.FILETIME()
+    exit_time = wintypes.FILETIME()
+    kernel_time = wintypes.FILETIME()
+    user_time = wintypes.FILETIME()
+    if kernel.GetProcessTimes(
+        process,
+        ctypes.byref(creation),
+        ctypes.byref(exit_time),
+        ctypes.byref(kernel_time),
+        ctypes.byref(user_time),
+    ):
+        cpu_seconds = (_filetime(kernel_time) + _filetime(user_time)) / 10_000_000
+    kernel.CloseHandle(process)
+    return cpu_seconds, rss
+
+
+def _filetime(value: object) -> int:
+    return (int(value.dwHighDateTime) << 32) + int(value.dwLowDateTime)  # type: ignore[attr-defined]

coding_agent/run/__init__.py

@@ -0,0 +1 @@
+"""Headless unattended runs: ``symphony run``, ``--detach``, and ``--resume --continue``."""

coding_agent/run/cli.py

@@ -0,0 +1,99 @@
+"""``symphony run --unattended [--detach] "<task>"`` and ``symphony --resume --continue``."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import sys
+from pathlib import Path
+from typing import Optional, Sequence
+
+from core_ai import has_configured_provider
+
+from coding_agent.agent import build_agent
+from coding_agent.config import ensure_spawn_settings
+from coding_agent.config.credentials import load_provider_env
+from coding_agent.addons.persistence import JsonlPersistence, register_active, release_active, sessions_dir
+from coding_agent.resources.usage import process_alive
+from coding_agent.run.detach import detach
+from coding_agent.run.interrupted import detached_run_pid, interrupted_session, resume_note, stop_orphaned_jobs
+from coding_agent.run.log_sink import LogLineSink
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="symphony run", description="Run one task headless, with no human.")
+    parser.add_argument("task", help="Task prompt")
+    parser.add_argument(
+        "--unattended",
+        action="store_true",
+        required=True,
+        help="Required: auto-approve tools (approvals.deny still applies) and auto-answer ask_user",
+    )
+    parser.add_argument("--detach", action="store_true", help="Run in the background; print pid, log, session id")
+    parser.add_argument("--model", default=None, help="provider:model id")
+    parser.add_argument("--workspace", default=".", help="Working directory (default: .)")
+    parser.add_argument("--session-id", default=None, help="Session id to write (default: new)")
+    return parser
+
+
+def run_task(workspace: Path, task: str, *, model: Optional[str] = None, session_id: Optional[str] = None) -> int:
+    """Headless unattended run with JSONL persistence and the user's ~/.symphony config and rules."""
+    load_provider_env(workspace)
+    if not has_configured_provider():
+        print("error: no provider credentials configured", file=sys.stderr)
+        return 1
+    agent = build_agent(
+        workspace=workspace,
+        sink=LogLineSink(),
+        model_id=model,
+        session_id=session_id,
+        config=ensure_spawn_settings(workspace, overrides={"unattended": True}),
+        client="run",
+    )
+    print(f"session {agent.session_id}", flush=True)
+    register_active(
+        agent.session_id,
+        workspace=workspace,
+        kind="run",
+        model_id=getattr(agent.harness, "model_id", "") or (model or ""),
+        label=task,
+    )
+
+    async def _run() -> str:
+        result = await agent.run(task)
+        await agent.wait_for_learning()
+        return result.output_text
+
+    try:
+        print(asyncio.run(_run()), flush=True)
+    except Exception as exc:
+        print(f"run failed: {type(exc).__name__}: {exc}", file=sys.stderr, flush=True)
+        return 1
+    finally:
+        release_active()
+    return 0
+
+
+def continue_interrupted(workspace: Path, *, model: Optional[str] = None) -> int:
+    persistence = JsonlPersistence(sessions_dir(workspace))
+    found = asyncio.run(interrupted_session(persistence))
+    if found is None:
+        print("nothing to continue: the most recent session was not interrupted mid-run")
+        return 0
+    summary, checkpoint = found
+    pid = detached_run_pid(persistence, summary.session_id)
+    if pid is not None and process_alive(pid):
+        print(f"refusing to continue: detached run pid {pid} is still alive", file=sys.stderr)
+        return 1
+    stopped = stop_orphaned_jobs(checkpoint.metadata.get("background_jobs"))
+    print(f"continuing interrupted session {summary.session_id} unattended", flush=True)
+    return run_task(workspace, resume_note(summary, checkpoint, stopped), model=model, session_id=summary.session_id)
+
+
+def main(argv: Sequence[str]) -> int:
+    argv = list(argv)
+    args = build_parser().parse_args(argv)
+    workspace = Path(args.workspace).expanduser().resolve()
+    if args.detach:
+        return detach([arg for arg in argv if arg != "--detach"], workspace)
+    return run_task(workspace, args.task, model=args.model, session_id=args.session_id)

coding_agent/run/detach.py

@@ -0,0 +1,37 @@
+"""Start ``symphony run`` in its own session and return at once (no daemon manager)."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+
+from coding_agent.addons.persistence import JsonlPersistence, sessions_dir
+from coding_agent.addons.persistence.artifacts import publish
+
+
+def detach(run_argv: list[str], workspace: Path) -> int:
+    """Re-exec ``run`` minus ``--detach`` with a pre-generated session id; write ``<sid>/run.json``."""
+    session_id = str(uuid.uuid4())
+    root = JsonlPersistence(sessions_dir(workspace)).session_dir(session_id)
+    root.mkdir(parents=True, exist_ok=True)
+    log_path = root / "run.log"
+    command = [sys.executable, "-m", "coding_agent.tui", "run", *run_argv, "--session-id", session_id]
+    with log_path.open("ab") as log:
+        proc = subprocess.Popen(
+            command, start_new_session=True, stdin=subprocess.DEVNULL, stdout=log, stderr=subprocess.STDOUT
+        )
+    info = {
+        "pid": proc.pid,
+        "session_id": session_id,
+        "log": str(log_path),
+        "workspace": str(workspace),
+        "argv": command,
+        "started_at": datetime.now(timezone.utc).isoformat(),
+    }
+    publish(root / "run.json", (json.dumps(info, indent=2) + "\n").encode("utf-8"))
+    print(f"pid {proc.pid}\nlog {log_path}\nsession {session_id}")
+    return 0