pi-onlyne 0.3.0 → 0.3.3

package/README.md

@@ -46,31 +46,29 @@ For a one-off run without installing:
 pi -e npm:pi-onlyne
 ```
 
-You also need the `onlyne` CLI installed and an initialized workspace:
+You also need an initialized Onlyne workspace and a running workspace-local daemon:
 
 ```bash
 onlyne init
-# Optional: refresh the workspace-local agent skill
+onlyne run
+# Optional, in another shell: refresh the workspace-local agent skill
 onlyne export-skill
 ```
 
-If `onlyne` is not on `PATH`, set:
-
-```bash
-export ONLYNE_BIN=/path/to/onlyne
-```
+`pi-onlyne` does not install launchd/systemd jobs and does not spawn a global daemon. If you want background supervision, wrap `onlyne --workspace /path/to/project run` yourself per workspace.
 
 ## Typical workflow
 
 1. Initialize/configure Onlyne in your project.
-2. Install this Pi extension.
-3. Start watching from pi:
+2. Start that workspace's daemon with `onlyne run`.
+3. Install this Pi extension.
+4. Start watching from pi:
 
 ```text
 /onlyne watch on
 ```
 
-When a message arrives through Onlyne, pi receives it as a follow-up message. The agent can then call `onlyne_reply`, or deliberately call `onlyne_mark_no_reply`.
+When a normal user message arrives through Onlyne, pi receives it as a follow-up message. Onlyne control messages such as `/handshake` are consumed silently. The agent can then call `onlyne_reply`, or deliberately call `onlyne_mark_no_reply`.
 
 ## Commands
 
@@ -118,7 +116,7 @@ onlyne_broadcast({
     { channelId: "telegram" },
     { channelId: "feishu" }
   ],
-  text: "# Release shipped\n\nVersion 0.3.0 is live."
+  text: "# Release shipped\n\nVersion 0.3.2 is live."
 })
 ```
 

package/SPEC.md

@@ -7,14 +7,15 @@ Pi extension for Onlyne. Onlyne remains a workspace-local IM broker; this extens
 ## v1 Decisions
 
 - Watch is configurable; default manual.
-- `watch on` first connects to existing `.onlyne/run/onlyne.sock`; if unavailable, spawns `onlyne --workspace <root> run`.
-- Extension-owned daemon is killed on `watch off`, `session_shutdown`, or process signal.
+- `watch on` connects only to the workspace-local `.onlyne/run/onlyne.sock`; if unavailable, it tells the user to start `onlyne --workspace <root> run`.
+- pi-onlyne never owns or launches the daemon. Users handle launchd/systemd/background scripts outside the extension, per workspace.
 - Inbound events come from Onlyne `subscribe_events`; no polling.
 - Inbound mode is rule-based: `auto-handle`, `queue-only`, or `muted`.
 - Outbound defaults to `guarded-explicit`: prefer tool reply, fallback to final text, else send configured error text.
 - Send tools default to Markdown and may pass `raw_text: true` to Onlyne for literal text.
 - Broadcast sends concurrently with per-target retry and per-target results.
 - Loopback inbound messages wake Pi without creating a reply obligation.
+- `/handshake` inbound messages are Onlyne control messages and must not be surfaced to Pi as agent work.
 - After pi surfaces an inbound follow-up, it calls `mark_io_consumed` so Onlyne FIFO `out_cursor = "consume"` stays synchronized with pi notifications.
 - FIFO IO itself remains owned by the Onlyne daemon; pi-onlyne does not open `.onlyne/channels/*/in|out` directly.
 

package/dist/index.js

@@ -1,6 +1,6 @@
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { broadcast, connectOrSpawn, loopback, markConsumed, sendWithRetry, stopProcess, subscribe } from "./onlyne.js";
+import { broadcast, connectDaemon, loopback, markConsumed, sendWithRetry, stopProcess, subscribe } from "./onlyne.js";
 import { inboundModeFor, loadConfig, saveConfig } from "./config.js";
 import { findWorkspace } from "./workspace.js";
 const state = { cwd: process.cwd(), workspace: null, watching: false, owner: "stopped" };
@@ -10,7 +10,7 @@ function inboundText(data) { const msg = data?.data?.data ?? data?.data ?? data;
 function consumeIfNotified(inbound) { if (state.workspace && inbound.messageId)
     void markConsumed(state.workspace.socketPath, inbound.messageId).catch(() => { }); }
 async function startWatch(pi) { state.workspace = findWorkspace(state.cwd); if (!state.workspace)
-    throw new Error("current workspace has no .onlyne configuration"); const conn = await connectOrSpawn(state.workspace); state.owner = conn.owner; state.child = conn.process; state.socket = subscribe(state.workspace.socketPath, (line) => { if (!line?.event || line.type !== "inbound_message")
+    throw new Error("current workspace has no .onlyne configuration"); const conn = await connectDaemon(state.workspace); state.owner = conn.owner; state.child = conn.process; state.socket = subscribe(state.workspace.socketPath, (line) => { if (!line?.event || line.type !== "inbound_message")
     return; const inbound = inboundText(line); if (!inbound)
     return; const mode = inboundModeFor(currentConfig(), inbound.channelId, inbound.conversationId); if (mode === "muted")
     return; if (inbound.channelId === "loopback") {
@@ -18,18 +18,20 @@ async function startWatch(pi) { state.workspace = findWorkspace(state.cwd); if (
         pi.sendUserMessage(`Onlyne loopback activation${inbound.conversationId ? ` (${inbound.conversationId})` : ""}:\n\n${inbound.text}`, { deliverAs: "followUp" });
     consumeIfNotified(inbound);
     return;
+} if (inbound.text.trim() === "/handshake") {
+    consumeIfNotified(inbound);
+    return;
 } state.currentInbound = { ...inbound, replied: false, noReply: false, reminders: 0 }; if (mode === "auto-handle") {
     pi.sendUserMessage(`Onlyne inbound message from ${inbound.channelId}/${inbound.conversationId}:\n\n${inbound.text}\n\nReply with onlyne_reply, or call onlyne_mark_no_reply if no reply is needed.`, { deliverAs: "followUp" });
     consumeIfNotified(inbound);
 } }); state.watching = true; return `watching ${state.workspace.root} (${state.owner})`; }
-function stopWatch() { state.socket?.destroy(); state.socket = undefined; if (state.owner === "extension")
-    stopProcess(state.child); state.child = undefined; state.watching = false; state.owner = "stopped"; return "watch stopped"; }
+function stopWatch() { state.socket?.destroy(); state.socket = undefined; stopProcess(state.child); state.child = undefined; state.watching = false; state.owner = "stopped"; return "watch stopped"; }
 async function reply(text) { if (!state.workspace)
     throw new Error("onlyne workspace not found"); const inbound = state.currentInbound; if (!inbound)
     throw new Error("no active inbound message"); const res = await sendWithRetry(state.workspace.socketPath, { channelId: inbound.channelId }, text, currentConfig().outbound.retry.attempts); if (res.ok)
     inbound.replied = true; return res; }
 export default function onlyne(pi) {
-    pi.on("session_start", async (_event, ctx) => { state.cwd = ctx.cwd; state.workspace = findWorkspace(ctx.cwd); ctx.ui.setStatus("onlyne", state.workspace ? "onlyne: ready" : "onlyne: no .onlyne"); if (currentConfig().watch.autoStart && state.workspace) {
+    pi.on("session_start", async (_event, ctx) => { const resumeWatch = state.watching; stopWatch(); state.cwd = ctx.cwd; state.workspace = findWorkspace(ctx.cwd); state.currentInbound = undefined; state.lastValidOutput = undefined; ctx.ui.setStatus("onlyne", state.workspace ? "onlyne: ready" : "onlyne: no .onlyne"); if ((currentConfig().watch.autoStart || resumeWatch) && state.workspace) {
         try {
             ctx.ui.notify(await startWatch(pi), "info");
         }

package/dist/onlyne.d.ts

@@ -1,4 +1,4 @@
-import { type ChildProcess } from "node:child_process";
+import type { ChildProcess } from "node:child_process";
 import { type Socket } from "node:net";
 import type { Workspace } from "./workspace.js";
 export interface OnlyneRequest {
@@ -20,13 +20,12 @@ export interface SendResult extends SendTarget {
 }
 export declare function request(socketPath: string, req: OnlyneRequest): Promise<any>;
 export declare function subscribe(socketPath: string, onLine: (line: any) => void): Socket;
-export declare function spawnDaemon(ws: Workspace, onlyneBin?: string): ChildProcess;
 export declare function waitForSocket(socketPath: string, timeoutMs?: number): Promise<void>;
-export declare function connectOrSpawn(ws: Workspace): Promise<{
-    owner: "external" | "extension";
+export declare function connectDaemon(ws: Workspace): Promise<{
+    owner: "external";
     process?: ChildProcess;
 }>;
-export declare function stopProcess(child?: ChildProcess): void;
+export declare function stopProcess(_child?: ChildProcess): void;
 export declare function loopback(socketPath: string, text: string, rawText?: boolean): Promise<any>;
 export declare function markConsumed(socketPath: string, messageId: string): Promise<any>;
 export declare function sendWithRetry(socketPath: string, target: SendTarget, text: string, attempts: number, rawText?: boolean): Promise<SendResult>;

package/dist/onlyne.js

@@ -1,4 +1,3 @@
-import { spawn } from "node:child_process";
 import { createConnection } from "node:net";
 export function request(socketPath, req) {
     return new Promise((resolve, reject) => {
@@ -38,20 +37,6 @@ export function subscribe(socketPath, onLine) {
     } });
     return socket;
 }
-export function spawnDaemon(ws, onlyneBin = process.env.ONLYNE_BIN ?? "onlyne") {
-    const script = `
-set -eu
-parent="$1"
-shift
-"$@" &
-child=$!
-cleanup() { kill "$child" 2>/dev/null || true; wait "$child" 2>/dev/null || true; }
-trap cleanup INT TERM HUP EXIT
-while kill -0 "$parent" 2>/dev/null && kill -0 "$child" 2>/dev/null; do sleep 1; done
-cleanup
-`;
-    return spawn("sh", ["-c", script, "onlyne-supervisor", String(process.pid), onlyneBin, "--workspace", ws.root, "run"], { cwd: ws.root, stdio: "ignore" });
-}
 export async function waitForSocket(socketPath, timeoutMs = 5000) {
     const deadline = Date.now() + timeoutMs;
     let last;
@@ -67,19 +52,16 @@ export async function waitForSocket(socketPath, timeoutMs = 5000) {
     }
     throw last instanceof Error ? last : new Error("onlyne socket not ready");
 }
-export async function connectOrSpawn(ws) {
+export async function connectDaemon(ws) {
     try {
         await request(ws.socketPath, { id: "ping", op: "ping" });
         return { owner: "external" };
     }
-    catch { /* spawn */ }
-    const process = spawnDaemon(ws);
-    await waitForSocket(ws.socketPath);
-    return { owner: "extension", process };
+    catch (e) {
+        throw new Error(`onlyne daemon is not running for ${ws.root}; start it with: onlyne --workspace ${ws.root} run`, { cause: e });
+    }
 }
-export function stopProcess(child) { if (!child || child.killed)
-    return; child.kill("SIGTERM"); setTimeout(() => { if (!child.killed)
-    child.kill("SIGKILL"); }, 1500).unref(); }
+export function stopProcess(_child) { }
 export async function loopback(socketPath, text, rawText = true) {
     return request(socketPath, { id: `loopback-${Date.now()}`, op: "loopback", text, raw_text: rawText });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-onlyne",
-  "version": "0.3.0",
+  "version": "0.3.3",
   "description": "Pi extension tools for sending messages through Onlyne.",
   "type": "module",
   "main": "./dist/index.js",