pi-onlyne 0.3.1 → 0.3.4

package/README.md

@@ -46,25 +46,23 @@ 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
@@ -81,6 +79,8 @@ When a normal user message arrives through Onlyne, pi receives it as a follow-up
 /onlyne config auto-start
 ```
 
+`/onlyne` supports argument completions for `status`, `watch on`, `watch off`, and `config auto-start`.
+
 ## Agent tools
 
 ```text
@@ -118,7 +118,7 @@ onlyne_broadcast({
     { channelId: "telegram" },
     { channelId: "feishu" }
   ],
-  text: "# Release shipped\n\nVersion 0.3.1 is live."
+  text: "# Release shipped\n\nVersion 0.3.4 is live."
 })
 ```
 

package/SPEC.md

@@ -7,8 +7,9 @@ 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.
+- `/onlyne` provides argument completions for its supported subcommands.
+- `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.

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") {
@@ -25,8 +25,7 @@ async function startWatch(pi) { state.workspace = findWorkspace(state.cwd); if (
     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)
@@ -61,25 +60,37 @@ export default function onlyne(pi) {
         }
         await reply(inbound.fallbackText || state.lastValidOutput || cfg.outbound.guardedExplicit.noOutputFallbackText);
     });
-    pi.registerCommand("onlyne", { description: "Onlyne watch/status/config commands", handler: async (argLine, ctx) => { const [cmd, sub] = argLine.trim().split(/\s+/); try {
-            if (cmd === "watch" && sub === "on")
-                ctx.ui.notify(await startWatch(pi), "info");
-            else if (cmd === "watch" && sub === "off")
-                ctx.ui.notify(stopWatch(), "info");
-            else if (cmd === "status")
-                ctx.ui.notify(`onlyne ${state.watching ? "watching" : "stopped"}; owner=${state.owner}; workspace=${state.workspace?.root ?? "none"}`, "info");
-            else if (cmd === "config" && sub === "auto-start") {
-                const cfg = currentConfig();
-                cfg.watch.autoStart = !cfg.watch.autoStart;
-                saveConfig(state.cwd, cfg);
-                ctx.ui.notify(`autoStart=${cfg.watch.autoStart}`, "info");
+    pi.registerCommand("onlyne", {
+        description: "Onlyne watch/status/config commands",
+        getArgumentCompletions: (prefix) => {
+            const commands = ["status", "watch on", "watch off", "config auto-start"];
+            const p = prefix.trimStart();
+            const filtered = commands.filter((c) => c.startsWith(p));
+            return filtered.length ? filtered.map((value) => ({ value, label: value })) : null;
+        },
+        handler: async (argLine, ctx) => {
+            const [cmd, sub] = argLine.trim().split(/\s+/);
+            try {
+                if (cmd === "watch" && sub === "on")
+                    ctx.ui.notify(await startWatch(pi), "info");
+                else if (cmd === "watch" && sub === "off")
+                    ctx.ui.notify(stopWatch(), "info");
+                else if (cmd === "status")
+                    ctx.ui.notify(`onlyne ${state.watching ? "watching" : "stopped"}; owner=${state.owner}; workspace=${state.workspace?.root ?? "none"}`, "info");
+                else if (cmd === "config" && sub === "auto-start") {
+                    const cfg = currentConfig();
+                    cfg.watch.autoStart = !cfg.watch.autoStart;
+                    saveConfig(state.cwd, cfg);
+                    ctx.ui.notify(`autoStart=${cfg.watch.autoStart}`, "info");
+                }
+                else
+                    ctx.ui.notify("usage: /onlyne status | watch on|off | config auto-start", "info");
             }
-            else
-                ctx.ui.notify("usage: /onlyne status | watch on|off | config auto-start", "info");
-        }
-        catch (e) {
-            ctx.ui.notify(e instanceof Error ? e.message : String(e), "error");
-        } } });
+            catch (e) {
+                ctx.ui.notify(e instanceof Error ? e.message : String(e), "error");
+            }
+        },
+    });
     pi.registerTool(defineTool({ name: "onlyne_reply", label: "Onlyne reply", description: "Reply with plain text to the current Onlyne inbound message.", parameters: Type.Object({ text: Type.String() }), executionMode: "parallel", async execute(_id, params) { return textResult(JSON.stringify(await reply(params.text))); } }));
     pi.registerTool(defineTool({ name: "onlyne_send", label: "Onlyne send", description: "Send Markdown to the channel's configured Onlyne conversation. Set rawText=true only for literal plain text.", parameters: Type.Object({ channelId: Type.String(), text: Type.String(), rawText: Type.Optional(Type.Boolean()) }), executionMode: "parallel", async execute(_id, params) { if (!state.workspace)
             throw new Error("onlyne workspace not found"); const res = await sendWithRetry(state.workspace.socketPath, params, params.text, currentConfig().outbound.retry.attempts, params.rawText ?? false); return textResult(JSON.stringify(res), res); } }));

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.1",
+  "version": "0.3.4",
   "description": "Pi extension tools for sending messages through Onlyne.",
   "type": "module",
   "main": "./dist/index.js",