pi-onlyne 0.3.3 → 0.4.0

package/README.md

@@ -46,23 +46,21 @@ For a one-off run without installing:
 pi -e npm:pi-onlyne
 ```
 
-You also need an initialized Onlyne workspace and a running workspace-local daemon:
+You also need an initialized Onlyne workspace:
 
 ```bash
 onlyne init
-onlyne run
-# Optional, in another shell: refresh the workspace-local agent skill
+# Optional: refresh the workspace-local agent skill
 onlyne export-skill
 ```
 
-`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.
+`pi-onlyne` can manage a workspace-local daemon for the current Pi session. Prefer `/onlyne daemon start|stop|restart` or `/onlyne watch on` over shelling out `onlyne run` manually. Do not combine plugin-managed daemons with ad-hoc `nohup onlyne run`, `pkill -f 'onlyne run'`, or global launchd/systemd jobs for the same workspace.
 
 ## Typical workflow
 
 1. Initialize/configure Onlyne in your project.
-2. Start that workspace's daemon with `onlyne run`.
-3. Install this Pi extension.
-4. Start watching from pi:
+2. Install this Pi extension.
+3. Start the workspace daemon and watch from pi:
 
 ```text
 /onlyne watch on
@@ -74,14 +72,22 @@ When a normal user message arrives through Onlyne, pi receives it as a follow-up
 
 ```text
 /onlyne status
+/onlyne daemon start
+/onlyne daemon stop
+/onlyne daemon restart
 /onlyne watch on
 /onlyne watch off
 /onlyne config auto-start
 ```
 
+`/onlyne` supports argument completions for `status`, `daemon start|stop|restart`, `watch on`, `watch off`, and `config auto-start`.
+
 ## Agent tools
 
 ```text
+onlyne_daemon_start()
+onlyne_daemon_stop()
+onlyne_daemon_restart()
 onlyne_reply({ text })
 onlyne_send({ channelId, text, rawText? })
 onlyne_broadcast({ targets, text, rawText? })
@@ -116,7 +122,7 @@ onlyne_broadcast({
     { channelId: "telegram" },
     { channelId: "feishu" }
   ],
-  text: "# Release shipped\n\nVersion 0.3.2 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` 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.
+- `/onlyne` provides argument completions for its supported subcommands, including daemon lifecycle commands.
+- `watch on` connects to the workspace-local `.onlyne/run/onlyne.sock`; if unavailable, it starts a Pi-owned workspace daemon.
+- `/onlyne daemon start|stop|restart` is the preferred lifecycle surface. Agents must not use ad-hoc `nohup onlyne run`, `pkill -f 'onlyne run'`, or global launchd/systemd jobs when pi-onlyne owns the daemon.
 - 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, connectDaemon, loopback, markConsumed, sendWithRetry, stopProcess, subscribe } from "./onlyne.js";
+import { broadcast, connectDaemon, loopback, markConsumed, sendWithRetry, shutdownDaemon, 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" };
@@ -9,29 +9,97 @@ const currentConfig = () => loadConfig(state.cwd);
 function inboundText(data) { const msg = data?.data?.data ?? data?.data ?? data; const channelId = msg.channel_id ?? msg.channelId; const conversationId = msg.conversation_id ?? msg.conversationId; const messageId = msg.message_id ?? msg.messageId; const text = msg.text ?? msg.content ?? msg.body; return channelId && conversationId && typeof text === "string" ? { channelId, conversationId, messageId, text } : null; }
 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 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") {
-    if (mode === "auto-handle")
-        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; stopProcess(state.child); state.child = undefined; state.watching = false; state.owner = "stopped"; return "watch stopped"; }
+function clearReminder() { if (state.reminderTimer)
+    clearTimeout(state.reminderTimer); state.reminderTimer = undefined; }
+function needsReply(inbound = state.currentInbound) { return !!inbound && !inbound.replied && !inbound.noReply && !!state.workspace; }
+function scheduleReminder(pi, delayMs = 30_000) {
+    clearReminder();
+    const inbound = state.currentInbound;
+    if (!inbound || !needsReply(inbound))
+        return;
+    state.reminderTimer = setTimeout(() => {
+        state.reminderTimer = undefined;
+        if (!needsReply(inbound) || state.currentInbound !== inbound)
+            return;
+        const cfg = currentConfig();
+        if (cfg.outbound.defaultReplyMode === "explicit-only")
+            return;
+        if (cfg.outbound.defaultReplyMode === "guarded-explicit" && inbound.reminders < cfg.outbound.guardedExplicit.reminders) {
+            if (inbound.reminders === 0)
+                inbound.fallbackText = state.lastValidOutput;
+            inbound.reminders++;
+            pi.sendUserMessage(`Onlyne reminder ${inbound.reminders}/${cfg.outbound.guardedExplicit.reminders}: reply to ${inbound.channelId}/${inbound.conversationId} with onlyne_reply, or call onlyne_mark_no_reply.`, { deliverAs: "followUp" });
+            return;
+        }
+        void reply(inbound.fallbackText || state.lastValidOutput || cfg.outbound.guardedExplicit.noOutputFallbackText).catch(() => { });
+    }, delayMs);
+}
+function scheduleReconnect(pi) {
+    if (state.reconnectTimer || !state.watching || !state.workspace)
+        return;
+    state.reconnectTimer = setTimeout(async () => {
+        state.reconnectTimer = undefined;
+        if (!state.watching)
+            return;
+        try {
+            await startWatch(pi);
+        }
+        catch {
+            scheduleReconnect(pi);
+        }
+    }, 1000);
+}
+async function startWatch(pi) {
+    state.workspace = findWorkspace(state.cwd);
+    if (!state.workspace)
+        throw new Error("current workspace has no .onlyne configuration");
+    if (state.reconnectTimer)
+        clearTimeout(state.reconnectTimer);
+    state.reconnectTimer = undefined;
+    state.socket?.destroy();
+    state.socket = undefined;
+    const conn = await connectDaemon(state.workspace);
+    state.owner = conn.owner;
+    state.child = conn.process;
+    const 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") {
+        if (mode === "auto-handle")
+            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;
+    } clearReminder(); 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);
+    } }, () => { if (state.socket === socket)
+        scheduleReconnect(pi); });
+    state.socket = socket;
+    state.watching = true;
+    return `watching ${state.workspace.root} (${state.owner})`;
+}
+function stopWatch() { if (state.reconnectTimer)
+    clearTimeout(state.reconnectTimer); state.reconnectTimer = undefined; clearReminder(); state.socket?.destroy(); state.socket = undefined; stopProcess(state.child); state.child = undefined; state.watching = false; state.owner = "stopped"; return "watch stopped"; }
+async function startDaemon() { state.workspace = findWorkspace(state.cwd); if (!state.workspace)
+    throw new Error("current workspace has no .onlyne configuration"); const conn = await connectDaemon(state.workspace, true); state.owner = conn.owner; state.child = conn.process; return `daemon ${state.owner === "extension" ? "started" : "already running"} for ${state.workspace.root}`; }
+async function stopDaemon() { if (!state.workspace)
+    state.workspace = findWorkspace(state.cwd); if (!state.workspace)
+    throw new Error("current workspace has no .onlyne configuration"); clearReminder(); state.socket?.destroy(); state.socket = undefined; await shutdownDaemon(state.workspace, state.child); state.child = undefined; state.watching = false; state.owner = "stopped"; return `daemon stopped for ${state.workspace.root}`; }
+async function restartDaemon() { await stopDaemon().catch(() => { }); return startDaemon(); }
 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; }
+    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;
+    clearReminder();
+} return res; }
 export default function onlyne(pi) {
-    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) {
+    pi.on("session_start", async (_event, ctx) => { const resumeWatch = state.watching; if (state.owner === "extension")
+        await stopDaemon().catch(() => { });
+    else
+        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");
         }
@@ -39,46 +107,56 @@ export default function onlyne(pi) {
             ctx.ui.notify(String(e), "warning");
         }
     } });
-    pi.on("session_shutdown", async () => { stopWatch(); });
+    pi.on("session_shutdown", async () => { if (state.owner === "extension")
+        await stopDaemon().catch(() => { });
+    else
+        stopWatch(); });
     for (const sig of ["SIGINT", "SIGTERM", "SIGHUP"])
         process.once(sig, () => stopWatch());
     pi.on("message_end", async (event) => { const text = typeof event.content === "string" ? event.content.trim() : ""; if (text && !text.startsWith("{") && !text.startsWith("[onlyne-internal]"))
         state.lastValidOutput = text; });
-    pi.on("turn_end", async () => {
-        const inbound = state.currentInbound;
-        if (!inbound || inbound.replied || inbound.noReply || !state.workspace)
-            return;
-        const cfg = currentConfig();
-        if (cfg.outbound.defaultReplyMode === "explicit-only")
-            return;
-        if (cfg.outbound.defaultReplyMode === "guarded-explicit" && inbound.reminders < cfg.outbound.guardedExplicit.reminders) {
-            if (inbound.reminders === 0)
-                inbound.fallbackText = state.lastValidOutput;
-            inbound.reminders++;
-            pi.sendUserMessage(`Onlyne reminder ${inbound.reminders}/${cfg.outbound.guardedExplicit.reminders}: reply to ${inbound.channelId}/${inbound.conversationId} with onlyne_reply, or call onlyne_mark_no_reply.`, { deliverAs: "followUp" });
-            return;
-        }
-        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.on("agent_start", async () => clearReminder());
+    pi.on("agent_end", async () => scheduleReminder(pi));
+    pi.registerCommand("onlyne", {
+        description: "Onlyne watch/status/config commands",
+        getArgumentCompletions: (prefix) => {
+            const commands = ["status", "watch on", "watch off", "daemon start", "daemon stop", "daemon restart", "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 === "daemon" && sub === "start")
+                    ctx.ui.notify(await startDaemon(), "info");
+                else if (cmd === "daemon" && sub === "stop")
+                    ctx.ui.notify(await stopDaemon(), "info");
+                else if (cmd === "daemon" && sub === "restart")
+                    ctx.ui.notify(await restartDaemon(), "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 | daemon start|stop|restart | 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_daemon_start", label: "Onlyne daemon start", description: "Start or connect to the current workspace-local Onlyne daemon managed by pi-onlyne.", parameters: Type.Object({}), executionMode: "parallel", async execute() { const res = await startDaemon(); return textResult(res, { owner: state.owner, workspace: state.workspace?.root }); } }));
+    pi.registerTool(defineTool({ name: "onlyne_daemon_stop", label: "Onlyne daemon stop", description: "Stop the current workspace-local Onlyne daemon when pi-onlyne manages it, without shelling out to pkill/nohup.", parameters: Type.Object({}), executionMode: "parallel", async execute() { const res = await stopDaemon(); return textResult(res, { owner: state.owner, workspace: state.workspace?.root }); } }));
+    pi.registerTool(defineTool({ name: "onlyne_daemon_restart", label: "Onlyne daemon restart", description: "Restart the current workspace-local Onlyne daemon through pi-onlyne lifecycle management.", parameters: Type.Object({}), executionMode: "parallel", async execute() { const res = await restartDaemon(); return textResult(res, { owner: state.owner, workspace: state.workspace?.root }); } }));
     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); } }));
@@ -86,6 +164,8 @@ export default function onlyne(pi) {
             throw new Error("onlyne workspace not found"); const cfg = currentConfig(); const results = await broadcast(state.workspace.socketPath, params.targets, params.text, cfg.outbound.retry.attempts, cfg.outbound.retry.concurrency, params.rawText ?? false); return textResult(JSON.stringify({ ok: results.every((r) => r.ok), results }), results); } }));
     pi.registerTool(defineTool({ name: "onlyne_loopback", label: "Onlyne loopback", description: "Inject a local loopback activation message so scripts can wake the current Pi session. Set rawText=false for Markdown. FIFO alternative: write to .onlyne/channels/loopback/in.", parameters: Type.Object({ 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 loopback(state.workspace.socketPath, params.text, params.rawText ?? true); return textResult(JSON.stringify(res), res); } }));
-    pi.registerTool(defineTool({ name: "onlyne_mark_no_reply", label: "Onlyne no reply", description: "Mark the current Onlyne inbound message as intentionally not replied.", parameters: Type.Object({ reason: Type.Optional(Type.String()) }), executionMode: "parallel", async execute(_id, params) { if (state.currentInbound)
-            state.currentInbound.noReply = true; return textResult("marked no reply", params); } }));
+    pi.registerTool(defineTool({ name: "onlyne_mark_no_reply", label: "Onlyne no reply", description: "Mark the current Onlyne inbound message as intentionally not replied.", parameters: Type.Object({ reason: Type.Optional(Type.String()) }), executionMode: "parallel", async execute(_id, params) { if (state.currentInbound) {
+            state.currentInbound.noReply = true;
+            clearReminder();
+        } return textResult("marked no reply", params); } }));
 }

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 {
@@ -19,13 +19,14 @@ export interface SendResult extends SendTarget {
     error?: string;
 }
 export declare function request(socketPath: string, req: OnlyneRequest): Promise<any>;
-export declare function subscribe(socketPath: string, onLine: (line: any) => void): Socket;
+export declare function subscribe(socketPath: string, onLine: (line: any) => void, onDisconnect?: () => void): Socket;
 export declare function waitForSocket(socketPath: string, timeoutMs?: number): Promise<void>;
-export declare function connectDaemon(ws: Workspace): Promise<{
-    owner: "external";
+export declare function connectDaemon(ws: Workspace, startIfMissing?: boolean): Promise<{
+    owner: "external" | "extension";
     process?: ChildProcess;
 }>;
-export declare function stopProcess(_child?: ChildProcess): void;
+export declare function shutdownDaemon(ws: Workspace, child?: ChildProcess): Promise<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,3 +1,4 @@
+import { spawn } from "node:child_process";
 import { createConnection } from "node:net";
 export function request(socketPath, req) {
     return new Promise((resolve, reject) => {
@@ -17,11 +18,17 @@ export function request(socketPath, req) {
         } });
     });
 }
-export function subscribe(socketPath, onLine) {
+export function subscribe(socketPath, onLine, onDisconnect) {
     const socket = createConnection(socketPath);
     let buf = "";
+    let closed = false;
     socket.setEncoding("utf8");
-    socket.on("connect", () => socket.write('{"id":"sub","op":"subscribe_events"}\n'));
+    const disconnect = () => { if (closed)
+        return; closed = true; onDisconnect?.(); };
+    socket.on("error", disconnect);
+    socket.on("close", disconnect);
+    socket.on("connect", () => { if (!socket.destroyed)
+        socket.write('{"id":"sub","op":"subscribe_events"}\n', () => { }); });
     socket.on("data", (chunk) => { buf += chunk; for (;;) {
         const idx = buf.indexOf("\n");
         if (idx < 0)
@@ -52,16 +59,56 @@ export async function waitForSocket(socketPath, timeoutMs = 5000) {
     }
     throw last instanceof Error ? last : new Error("onlyne socket not ready");
 }
-export async function connectDaemon(ws) {
+function spawnManagedDaemon(ws) {
+    const bin = process.env.ONLYNE_BIN || "onlyne";
+    const script = `
+parent="$1"; shift
+"$@" &
+child=$!
+trap 'kill "$child" 2>/dev/null; wait "$child" 2>/dev/null' INT TERM HUP EXIT
+while kill -0 "$parent" 2>/dev/null; do
+  kill -0 "$child" 2>/dev/null || { wait "$child"; exit $?; }
+  sleep 1
+done
+kill "$child" 2>/dev/null
+wait "$child" 2>/dev/null
+`;
+    return spawn("sh", ["-c", script, "onlyne-supervisor", String(process.pid), bin, "--workspace", ws.root, "run"], { stdio: "ignore" });
+}
+export async function connectDaemon(ws, startIfMissing = true) {
     try {
         await request(ws.socketPath, { id: "ping", op: "ping" });
         return { owner: "external" };
     }
     catch (e) {
-        throw new Error(`onlyne daemon is not running for ${ws.root}; start it with: onlyne --workspace ${ws.root} run`, { cause: e });
+        if (!startIfMissing)
+            throw new Error(`onlyne daemon is not running for ${ws.root}; start it with /onlyne daemon start`, { cause: e });
+        const child = spawnManagedDaemon(ws);
+        try {
+            await waitForSocket(ws.socketPath);
+            // 自己 spawn 的 daemon 已退出:竞态中输给了其他启动方,socket 归对方所有,降级为 external(只订阅、不 shutdown)。
+            if (child.exitCode !== null || child.signalCode !== null)
+                return { owner: "external" };
+            return { owner: "extension", process: child };
+        }
+        catch (err) {
+            stopProcess(child);
+            throw err;
+        }
     }
 }
-export function stopProcess(_child) { }
+export async function shutdownDaemon(ws, child) {
+    try {
+        await request(ws.socketPath, { id: `shutdown-${Date.now()}`, op: "shutdown" });
+    }
+    catch { /* may already be down */ }
+    stopProcess(child);
+}
+export function stopProcess(child) { if (!child || child.killed)
+    return; try {
+    child.kill("SIGTERM");
+}
+catch { /* ignore */ } }
 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.3",
+  "version": "0.4.0",
   "description": "Pi extension tools for sending messages through Onlyne.",
   "type": "module",
   "main": "./dist/index.js",