@nanhara/hara 0.114.0 → 0.115.0

package/CHANGELOG.md

@@ -5,6 +5,13 @@ All notable changes to `@nanhara/hara`.
 > Versioning (pre-1.0, SemVer-style): the **minor** (middle) number bumps for a **new feature**; the
 > **patch** (last) number bumps for **optimizations/fixes of existing features**.
 
+## 0.115.0 — serve exposes plugins & skills (desktop plugin panel)
+
+- **`hara serve` protocol grows a plugin surface**: `plugins.list` (installed plugins with enabled state +
+  contribution counts), `plugins.set` (enable/disable by name — applies to future sessions/turns), and
+  `skills.list` (the skill index for a cwd). This powers the hara desktop app's plugin manager panel;
+  any WS client gets it for free.
+
 ## 0.114.0 — long files read in slices · repeat-guard anti-spinning · `hara serve` (the desktop/IDE backbone)
 
 - **Long files no longer flood the context.** `read_file` now returns cat-n numbered lines with

package/dist/cron/deliver.js

@@ -1,12 +1,3 @@
-// Cron result delivery — push a finished job's output to a chat channel (openclaw/hermes parity),
-// WITHOUT needing the gateway process: adapters are constructed one-shot from the same env vars the
-// gateway uses, send once, and are dropped. Spec format: "<target>:<id>" —
-//   telegram:<chatId>   (HARA_TELEGRAM_TOKEN)
-//   feishu:<chatId>     (HARA_FEISHU_APP_ID + HARA_FEISHU_APP_SECRET)
-//   webhook:<url>       (plain POST {name,status,text} JSON — for anything else)
-// WeChat is intentionally absent: its transport needs the long-lived gateway session, so a one-shot
-// cron process can't speak it — use feishu/telegram/webhook for cron delivery.
-// Adapters are imported LAZILY so the (heavy) SDKs never load unless a job actually delivers.
 /** Parse a `--deliver` spec; error string on anything unsupported (listing what IS supported). */
 export function parseDeliver(spec) {
     const i = spec.indexOf(":");

package/dist/gateway/flows.js

@@ -0,0 +1,89 @@
+// hara gateway flows — user-configured rules that intercept inbound gateway messages and route matching
+// ones to an agent task + a delivery target, instead of the gateway's default DM-driver reply. This turns
+// any chat gateway (Telegram / WeChat / Feishu / Slack / …) into an automation trigger: "when a message
+// matching <trigger> arrives, run <agent task> and deliver the result to <target>".
+//
+// Opt-in: config lives in the user's ~/.hara/flows.json — no file, no flows (zero behaviour change).
+// Platform-agnostic: matching only reads the generic InboundMsg fields each adapter populates (chatType,
+// mentions), so a flow works on whatever platform surfaces the data it asks for.
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { deliverResult } from "../cron/deliver.js";
+const asArray = (v) => (v == null ? [] : Array.isArray(v) ? v : [v]);
+/** Load ~/.hara/flows.json — accepts a bare array or `{ "flows": [...] }`. Missing/malformed → [] (never throws). */
+export function loadFlows() {
+    try {
+        const parsed = JSON.parse(readFileSync(join(homedir(), ".hara", "flows.json"), "utf8"));
+        const flows = Array.isArray(parsed) ? parsed : parsed?.flows;
+        return Array.isArray(flows) ? flows.filter((f) => f && f.enabled !== false && f.name && f.do) : [];
+    }
+    catch {
+        return [];
+    }
+}
+/** Pure predicate: does message `m` on `platform` satisfy rule `r`'s trigger? */
+export function matchFlow(r, m, platform) {
+    const on = r.on ?? {};
+    if (on.platform && on.platform.toLowerCase() !== platform.toLowerCase())
+        return false;
+    const chats = asArray(on.chat);
+    if (chats.length && !chats.includes(String(m.chatId)))
+        return false;
+    if (on.chatType && on.chatType !== "any") {
+        if (!m.chatType || m.chatType !== on.chatType)
+            return false; // rule wants a specific kind the adapter didn't confirm
+    }
+    if (on.mention && on.mention !== "any") {
+        const ms = m.mentions ?? [];
+        if (on.mention === "self") {
+            if (!ms.some((x) => x.isSelf))
+                return false;
+        }
+        else {
+            const want = asArray(on.mention);
+            if (!ms.some((x) => x.id && want.includes(x.id)))
+                return false;
+        }
+    }
+    const kws = asArray(on.keyword);
+    if (kws.length && !kws.some((k) => (m.text ?? "").includes(k)))
+        return false;
+    return true;
+}
+/** Compose the agent prompt for a matched flow (English scaffolding; the user's do/guard carry the intent). */
+export function buildFlowPrompt(r, m) {
+    return (r.do +
+        (r.guard ? `\n\nConstraint: ${r.guard}` : "") +
+        `\n\n--- Triggering message ---\nchat ${m.chatId}${m.chatType ? ` (${m.chatType})` : ""} · from ${m.userName || m.userId}\n${m.text}`);
+}
+/** Try to handle `m` via configured flows. Returns true if ≥1 rule matched (caller should STOP default routing).
+ *  The agent run + delivery are fire-and-forget so a slow LLM call never blocks the gateway's event loop.
+ *  `runAgent` runs the prompt (injected by the gateway so we reuse its session/env plumbing); `reply` (optional)
+ *  sends text back to the originating chat. */
+export async function dispatchFlows(m, platform, runAgent, reply) {
+    const matched = loadFlows().filter((r) => matchFlow(r, m, platform));
+    if (!matched.length)
+        return false;
+    for (const r of matched) {
+        console.error(`hara flow: "${r.name}" matched · ${platform} ${m.chatType ?? "?"} ${m.chatId}`);
+        void (async () => {
+            try {
+                const output = (await runAgent(buildFlowPrompt(r, m))).trim();
+                if (!output)
+                    return;
+                if (r.deliver) {
+                    const err = await deliverResult(r.deliver, output);
+                    if (err)
+                        console.error(`hara flow "${r.name}": deliver failed — ${err}`);
+                }
+                if (r.reply && reply)
+                    await reply(output).catch(() => { });
+            }
+            catch (e) {
+                console.error(`hara flow "${r.name}": ${e instanceof Error ? e.message : String(e)}`);
+            }
+        })();
+    }
+    return true;
+}

package/dist/serve/protocol.js

@@ -10,6 +10,9 @@
 //   session.send      {sessionId,text}           → (streams events, then) {reply,usage}
 //   session.interrupt {sessionId}                → {}
 //   approval.reply    {approvalId,allow,always?}  → {}
+//   plugins.list      {}                          → {plugins:[{name,version,description,enabled,skills,agents,mcpServers}]}
+//   plugins.set       {name,enabled}              → {name,enabled}   (applies to future sessions/turns)
+//   skills.list       {cwd?}                      → {skills:[{id,description,source}]}
 // Server → client notifications (all carry sessionId):
 //   event.text / event.reasoning {delta} · event.tool {name,preview} · event.diff {text}
 //   event.notice {text} · event.turn_end {reply,usage,error?} · approval.request {approvalId,question}

package/dist/serve/server.js

@@ -12,6 +12,8 @@ import "../tools/all.js"; // register the full built-in toolset — serve must w
 import { runAgent } from "../agent/loop.js";
 import { loadAgentsMd } from "../context/agents-md.js";
 import { memoryDigest } from "../memory/store.js";
+import { listInstalled, enabledPlugins, setPluginEnabled } from "../plugins/plugins.js";
+import { loadSkillIndex } from "../skills/skills.js";
 import { SessionHub, realStore } from "./sessions.js";
 import { parseFrame, rpcResult, rpcError, rpcNotify, ERR, PROTOCOL_VERSION } from "./protocol.js";
 const APPROVAL_TIMEOUT_MS = 300_000; // an unanswered approval denies after 5 min (never hangs a turn)
@@ -191,6 +193,22 @@ export async function startServe(opts, deps) {
                             resolve(p.always === true ? "always" : p.allow === true);
                         return reply(rpcResult(id, {})); // idempotent — a late/duplicate reply is a no-op
                     }
+                    case "plugins.list": {
+                        const on = new Set(enabledPlugins().map((pl) => pl.name));
+                        return reply(rpcResult(id, { plugins: listInstalled().map((pl) => ({ name: pl.name, version: pl.version, description: pl.manifest.description ?? "", enabled: on.has(pl.name), skills: (pl.manifest.skills ?? []).length, agents: (pl.manifest.agents ?? []).length, mcpServers: Object.keys(pl.manifest.mcpServers ?? {}).length })) }));
+                    }
+                    case "plugins.set": {
+                        if (typeof p.name !== "string" || typeof p.enabled !== "boolean")
+                            return reply(rpcError(id, ERR.PARAMS, "name + enabled required"));
+                        if (!listInstalled().some((pl) => pl.name === p.name))
+                            return reply(rpcError(id, ERR.PARAMS, `no installed plugin "${p.name}"`));
+                        setPluginEnabled(p.name, p.enabled);
+                        return reply(rpcResult(id, { name: p.name, enabled: p.enabled })); // takes effect on the next session/turn (loaders re-read)
+                    }
+                    case "skills.list": {
+                        const cwd = typeof p.cwd === "string" && p.cwd ? p.cwd : opts.cwd;
+                        return reply(rpcResult(id, { skills: loadSkillIndex(cwd).map((s) => ({ id: s.id, description: s.description, source: s.source })) }));
+                    }
                     default:
                         return reply(rpcError(id, ERR.METHOD, `unknown method ${req.method}`));
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanhara/hara",
-  "version": "0.114.0",
+  "version": "0.115.0",
   "description": "hara — a coding agent CLI that runs like an engineering org.",
   "bin": {
     "hara": "dist/index.js"