wyrm-mcp 7.3.2 → 7.3.3

package/README.md

@@ -3,14 +3,14 @@
 > Persistent memory is table stakes. The real problem is what agents *do* with it — Wyrm blocks the repeat, keeps decisions true, and learns as a fleet. Memory is the substrate; the judgment is the moat.
 
 [![npm version](https://img.shields.io/npm/v/wyrm-mcp?color=00B89F&label=npm)](https://www.npmjs.com/package/wyrm-mcp)
-[![License: AGPL-3.0](https://img.shields.io/badge/License-AGPL--3.0-00B89F.svg)](LICENSE)
+[![License: Proprietary](https://img.shields.io/badge/License-Proprietary-b91c1c.svg)](LICENSE)
 [![Tests](https://img.shields.io/badge/tests-1820%20passing-00B89F)](https://github.com/Ghosts-Protocol-Pvt-Ltd/Wyrm)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.9-3178C6?logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
 [![MCP](https://img.shields.io/badge/MCP-compatible-00B89F)](https://modelcontextprotocol.io)
 
 **[wyrm.ghosts.lk](https://wyrm.ghosts.lk)**  ·  **[npm](https://www.npmjs.com/package/wyrm-mcp)**  ·  **[GitHub](https://github.com/Ghosts-Protocol-Pvt-Ltd/Wyrm)**  ·  **[Ghost Protocol](https://ghosts.lk)**  ·  `npm i -g wyrm-mcp`
 
-Local-first persistent memory for AI agents over MCP — by [Ghost Protocol](https://ghosts.lk). Runs fully offline on your machine: no cloud, no account, no LLM required. The managed cloud tier lives at **[wyrm.ghosts.lk](https://wyrm.ghosts.lk)**.
+Local-first persistent memory for AI agents over MCP — by [Ghost Protocol](https://ghosts.lk). Runs fully offline on your machine: no cloud, no LLM required. The official build activates with a one-time free `wyrm login`; your memory stays local either way. The managed cloud tier lives at **[wyrm.ghosts.lk](https://wyrm.ghosts.lk)**.
 
 ---
 
@@ -263,7 +263,7 @@ Once connected, your AI has access to all Wyrm tools. Try:
 
 ## MCP Tools Reference
 
-Wyrm exposes 38 tools via the Model Context Protocol:
+Wyrm exposes a frozen 32-verb typed surface (137 tools callable) via the Model Context Protocol:
 
 ### Projects
 
@@ -485,15 +485,9 @@ Wyrm/
 
 ## Contributing
 
-Contributions are welcome! Here's how:
+Wyrm is a **proprietary repository** — free to use, but not open to external contributions. We do **not** accept forks or external pull requests.
 
-1. **Fork** the repository
-2. **Create** a feature branch (`git checkout -b feat/amazing-feature`)
-3. **Commit** your changes (`git commit -m 'feat: add amazing feature'`)
-4. **Push** to the branch (`git push origin feat/amazing-feature`)
-5. **Open** a Pull Request
-
-Please ensure tests pass (`npm test`) and the project builds (`npm run build`) before submitting.
+Issues and bug reports are welcome: please open an issue or email ryan@ghosts.lk.
 
 ---
 
@@ -504,7 +498,7 @@ Please ensure tests pass (`npm test`) and the project builds (`npm run build`) b
 - **Optional encryption** — AES-256-GCM for sensitive context data.
 - **Audited** — Security audits documented in [SECURITY_AUDIT.md](SECURITY_AUDIT.md) and [SECURITY_AUDIT_V2.md](SECURITY_AUDIT_V2.md).
 
-Found a vulnerability? Please open an issue or email security@ghosts.lk.
+Found a vulnerability? Please open an issue or email ryan@ghosts.lk.
 
 ---
 
@@ -513,9 +507,9 @@ Found a vulnerability? Please open an issue or email security@ghosts.lk.
 **Open standard + protected implementation:**
 
 - **The Wyrm Memory Protocol** ([`PROTOCOL.md`](../../PROTOCOL.md)) is an **open spec, freely implementable** by anyone (CC-BY-4.0) — build a WMP-compatible memory without touching Wyrm's code.
-- **This implementation** (`wyrm-mcp`) is **[AGPL-3.0-or-later](LICENSE)** — Copyright © 2024-2026 [Ghost Protocol (Pvt) Ltd](https://ghosts.lk).
+- **This implementation** (`wyrm-mcp`) is **[Proprietary Freeware](LICENSE)** — free to use, all rights reserved. Copyright © 2024-2026 [Ghost Protocol (Pvt) Ltd](https://ghosts.lk).
 
-For a **commercial license** (embedding Wyrm in a closed product, or running it as a managed service without AGPL's source-sharing obligations), contact [ghosts.lk@proton.me](mailto:ghosts.lk@proton.me).
+For a **commercial license** (embedding Wyrm in a closed product, or running it as a managed service), contact [ryan@ghosts.lk](mailto:ryan@ghosts.lk).
 
 ---
 

package/dist/activation.js

@@ -1 +1,59 @@
-import{getLicenseInfo as r,selfTestVerifier as n}from"./license.js";import{OFFICIAL_BUILD as e}from"./build-flags.js";const i=e||/^(1|true|yes|on)$/i.test(process.env.WYRM_REQUIRE_ACTIVATION??""),t=e?!n().ok:!1;if(t)try{console.error("Wyrm: integrity self-test FAILED \u2014 license verifier tampered; activation gate locked.")}catch{}function s(){return t?!1:!i||r().valid}function c(){return{content:[{type:"text",text:"\u{1F512} Wyrm requires a free account on this build.\n\nRun `wyrm login` in your terminal to sign in and activate (free). Your memory stays local \u2014 login just ties usage to an account so it can be managed.\n\nAlready logged in? Your activation may have expired \u2014 run `wyrm login` again to refresh."}],isError:!0}}export{i as REQUIRE_ACTIVATION,c as activationGateResult,s as activationSatisfied};
+/**
+ * Activation gate for account-required builds.
+ *
+ * OFF by default in source — the test suite and local dev builds are unaffected.
+ * The OFFICIAL distribution bakes `WYRM_REQUIRE_ACTIVATION=1`, so the free tier
+ * needs a (free) account: `wyrm login` fetches a short-lived, account-bound signed
+ * license that's validated locally by license.ts. A suspended account can't
+ * refresh, so access lapses at expiry. Memory is local either way — login only
+ * ties usage to a revocable identity. (Wyrm is proprietary; see LICENSE.)
+ *
+ * @copyright 2026 Ghost Protocol (Pvt) Ltd.
+ * @license Proprietary — (c) 2026 Ghost Protocol (Pvt) Ltd. All rights reserved. See LICENSE.
+ */
+import { getLicenseInfo, selfTestVerifier } from './license.js';
+import { OFFICIAL_BUILD } from './build-flags.js';
+/**
+ * Whether the account-required gate is enabled on this build. ON when this is the
+ * official published artifact (OFFICIAL_BUILD baked true at release), OR when the
+ * operator opts in via WYRM_REQUIRE_ACTIVATION. OFF in source + tests.
+ */
+export const REQUIRE_ACTIVATION = OFFICIAL_BUILD || /^(1|true|yes|on)$/i.test(process.env.WYRM_REQUIRE_ACTIVATION ?? '');
+/**
+ * Tamper-evidence: on the official build, verify at load that the license verifier
+ * still rejects a forged signature. If it doesn't, someone stubbed the verifier to
+ * bypass the gate — so we keep the gate CLOSED regardless of what getLicenseInfo()
+ * now claims. A determined forker can remove this too (patching the closed, minified dist) — a
+ * deterrent, not a guarantee.
+ */
+const TAMPERED = OFFICIAL_BUILD ? !selfTestVerifier().ok : false;
+if (TAMPERED) {
+    try {
+        console.error('Wyrm: integrity self-test FAILED — license verifier tampered; activation gate locked.');
+    }
+    catch { /* noop */ }
+}
+/**
+ * True when tool execution is permitted. Always true unless the build requires
+ * activation AND no valid (free or paid) account-bound license is loaded.
+ * Re-checked live so a mid-session `wyrm login` takes effect without a restart.
+ */
+export function activationSatisfied() {
+    if (TAMPERED)
+        return false; // verifier subverted → never satisfy the gate
+    return !REQUIRE_ACTIVATION || getLicenseInfo().valid;
+}
+/** The MCP error result returned for any tool call while activation is unmet. */
+export function activationGateResult() {
+    return {
+        content: [{
+                type: 'text',
+                text: '🔒 Wyrm requires a free account on this build.\n\n'
+                    + 'Run `wyrm login` in your terminal to sign in and activate (free). '
+                    + 'Your memory stays local — login just ties usage to an account so it can be managed.\n\n'
+                    + 'Already logged in? Your activation may have expired — run `wyrm login` again to refresh.',
+            }],
+        isError: true,
+    };
+}
+//# sourceMappingURL=activation.js.map

package/dist/agent-daemon.js

@@ -1,6 +1,283 @@
-import{spawn as E}from"child_process";import{existsSync as l,readFileSync as g,writeFileSync as I,statSync as w,openSync as M,closeSync as h,renameSync as v,unlinkSync as f,mkdirSync as O}from"fs";import{homedir as R}from"os";import{join as d,dirname as S,resolve as k}from"path";import{fileURLToPath as b}from"url";const m=d(R(),".wyrm"),i=d(m,"wyrm-loop.pid"),u=d(m,"wyrm-loop.log"),_=d(m,"wyrm-loop.log.1"),D=1e6;function T(){l(m)||O(m,{recursive:!0})}function C(){try{l(u)&&w(u).size>D&&(l(_)&&f(_),v(u,_))}catch{}}function L(){try{const p=g(i,"utf-8").trim(),t=parseInt(p,10);return Number.isFinite(t)&&t>0?t:null}catch{return null}}function y(p){try{return process.kill(p,0),!0}catch{return!1}}function F(){try{const t=b(import.meta.url),r=[k(S(t),"wyrm-loop.js"),k(S(t),"..","dist","wyrm-loop.js")];for(const n of r)if(l(n))return n}catch{}const p=(process.env.PATH??"").split(":");for(const t of p){const r=d(t,"wyrm-loop");if(l(r))return r}return null}class A{db;constructor(t){this.db=t}status(){const t=L(),r=t!=null&&y(t);let n,a;try{if(l(i)){const s=w(i);n=s.mtime.toISOString(),a=Math.round((Date.now()-s.mtime.getTime())/1e3)}}catch{}let e;try{const s=this.db.prepare(`
+/**
+ * Agent daemon process manager.
+ *
+ * Lets an AI client (Claude / Codex / Cursor / etc.) bootstrap, monitor,
+ * and tear down the `wyrm-loop` autonomous scheduler without the
+ * operator running shell commands. The MCP server can spawn the daemon
+ * as a detached background process, write a PID + log file under
+ * `~/.wyrm/`, and check liveness on demand.
+ *
+ * Files (all under `~/.wyrm/`):
+ *   wyrm-loop.pid    PID of the running daemon (single-line)
+ *   wyrm-loop.log    Stdout/stderr of the daemon (rotated at 1MB)
+ *
+ * Single-instance guarantee — if a PID file exists and the process is
+ * alive, `start()` refuses (no fork-bomb). `restart()` is provided as
+ * an explicit operation.
+ *
+ * @copyright 2026 Ghost Protocol (Pvt) Ltd.
+ * @license Proprietary — (c) 2026 Ghost Protocol (Pvt) Ltd. All rights reserved. See LICENSE.
+ */
+import { spawn } from 'child_process';
+import { existsSync, readFileSync, writeFileSync, statSync, openSync, closeSync, renameSync, unlinkSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { join, dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+const WYRM_DIR = join(homedir(), '.wyrm');
+const PID_FILE = join(WYRM_DIR, 'wyrm-loop.pid');
+const LOG_FILE = join(WYRM_DIR, 'wyrm-loop.log');
+const LOG_FILE_OLD = join(WYRM_DIR, 'wyrm-loop.log.1');
+const MAX_LOG_BYTES = 1_000_000;
+function ensureWyrmDir() {
+    if (!existsSync(WYRM_DIR))
+        mkdirSync(WYRM_DIR, { recursive: true });
+}
+function rotateLogIfLarge() {
+    try {
+        if (existsSync(LOG_FILE) && statSync(LOG_FILE).size > MAX_LOG_BYTES) {
+            if (existsSync(LOG_FILE_OLD))
+                unlinkSync(LOG_FILE_OLD);
+            renameSync(LOG_FILE, LOG_FILE_OLD);
+        }
+    }
+    catch { /* best-effort */ }
+}
+function readPid() {
+    try {
+        const raw = readFileSync(PID_FILE, 'utf-8').trim();
+        const pid = parseInt(raw, 10);
+        return Number.isFinite(pid) && pid > 0 ? pid : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isProcessAlive(pid) {
+    try {
+        // signal 0 doesn't kill; just checks existence + permission
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Find the bundled `wyrm-loop` script path. Resolves relative to this
+ * module so it works whether installed via npm, run from source, or
+ * invoked from a global symlink. */
+function locateLoopBinary() {
+    // 1. import.meta.url → packages/mcp-server/dist/agent-daemon.js
+    try {
+        const here = fileURLToPath(import.meta.url);
+        const candidates = [
+            // installed alongside (dist/wyrm-loop.js)
+            resolve(dirname(here), 'wyrm-loop.js'),
+            // source layout
+            resolve(dirname(here), '..', 'dist', 'wyrm-loop.js'),
+        ];
+        for (const p of candidates) {
+            if (existsSync(p))
+                return p;
+        }
+    }
+    catch { /* fall through */ }
+    // 2. Look in PATH for the `wyrm-loop` binary (set up by `npm install -g`)
+    const pathDirs = (process.env.PATH ?? '').split(':');
+    for (const dir of pathDirs) {
+        const cand = join(dir, 'wyrm-loop');
+        if (existsSync(cand))
+            return cand;
+    }
+    return null;
+}
+export class AgentDaemon {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    /** Current daemon status. Always safe to call. */
+    status() {
+        const pid = readPid();
+        const running = pid != null && isProcessAlive(pid);
+        let started_at;
+        let uptime_seconds;
+        try {
+            if (existsSync(PID_FILE)) {
+                const st = statSync(PID_FILE);
+                started_at = st.mtime.toISOString();
+                uptime_seconds = Math.round((Date.now() - st.mtime.getTime()) / 1000);
+            }
+        }
+        catch { /* best-effort */ }
+        // Read latest agent_actions row for "last action" summary
+        let last_action;
+        try {
+            const row = this.db.prepare(`
         SELECT actor, goal_id, action_kind, summary, result_status, ran_at
         FROM agent_actions ORDER BY id DESC LIMIT 1
-      `).get();s&&(e={ran_at:s.ran_at,actor:s.actor,goal_id:s.goal_id,summary:`${s.action_kind}: ${s.summary}`.slice(0,200),result_status:s.result_status})}catch{}let o=0,c=0;try{o=this.db.prepare("SELECT COUNT(*) as c FROM goals WHERE status = 'active'").get().c,c=this.db.prepare("SELECT COALESCE(SUM(iterations_count), 0) as c FROM goals").get().c}catch{}return{running:r,pid:r?t:null,pid_file:i,log_file:u,started_at:r?n:void 0,uptime_seconds:r?a:void 0,last_action:e,active_goals:o,total_iterations:c}}start(t={}){T(),C();const r=this.status();if(r.running)return{ok:!0,pid:r.pid??void 0,status:r};if(l(i))try{f(i)}catch{}const n=F();if(!n)return{ok:!1,error:"Could not locate wyrm-loop binary. Run `npm install -g wyrm-mcp` or `npm run build` in packages/mcp-server."};const a=["--interval",String(t.interval_seconds??600)];t.max_steps&&a.push("--max-steps",String(t.max_steps)),t.project_path&&a.push("--project",t.project_path),t.verbose&&a.push("--verbose");let e;try{e=M(u,"a")}catch(c){return{ok:!1,error:`Could not open log file ${u}: ${c.message}`}}let o;try{o=E("node",[n,...a],{detached:!0,stdio:["ignore",e,e],env:{...process.env,WYRM_LOOP_LOG:t.verbose?"1":"0"}})}catch(c){return{ok:!1,error:`spawn failed: ${c.message}`}}if(!o.pid){try{h(e)}catch{}return{ok:!1,error:"spawn returned no PID"}}try{I(i,String(o.pid),"utf-8")}catch(c){try{process.kill(o.pid,"SIGTERM")}catch{}try{h(e)}catch{}return{ok:!1,error:`Could not write PID file: ${c.message}`}}try{h(e)}catch{}return o.unref(),{ok:!0,pid:o.pid,status:this.status()}}async stop(t={}){const r=L();if(r==null)return{ok:!0,was_running:!1};if(!y(r)){try{f(i)}catch{}return{ok:!0,was_running:!1,pid:r}}try{process.kill(r,"SIGTERM")}catch(e){return{ok:!1,was_running:!0,pid:r,error:`SIGTERM failed: ${e.message}`}}const n=Math.max(100,Math.min(t.grace_ms??3e3,3e4)),a=Date.now();for(;Date.now()-a<n&&y(r);)await new Promise(e=>{setTimeout(e,100)});if(y(r))try{process.kill(r,"SIGKILL")}catch{}try{f(i)}catch{}return{ok:!0,was_running:!0,pid:r}}async restart(t={}){return await this.stop({grace_ms:3e3}),this.start(t)}recentLog(t=40){try{return l(u)?g(u,"utf-8").split(`
-`).slice(-Math.max(1,Math.min(t,1e3))).join(`
-`):"(log file does not exist)"}catch(r){return`(could not read log: ${r.message})`}}}export{A as AgentDaemon};
+      `).get();
+            if (row)
+                last_action = {
+                    ran_at: row.ran_at, actor: row.actor, goal_id: row.goal_id,
+                    summary: `${row.action_kind}: ${row.summary}`.slice(0, 200),
+                    result_status: row.result_status,
+                };
+        }
+        catch { /* table may not exist on pre-v5 DBs */ }
+        let active_goals = 0;
+        let total_iterations = 0;
+        try {
+            active_goals = this.db.prepare(`SELECT COUNT(*) as c FROM goals WHERE status = 'active'`).get().c;
+            total_iterations = this.db.prepare(`SELECT COALESCE(SUM(iterations_count), 0) as c FROM goals`).get().c;
+        }
+        catch { /* pre-v5 DB */ }
+        return {
+            running,
+            pid: running ? pid : null,
+            pid_file: PID_FILE,
+            log_file: LOG_FILE,
+            started_at: running ? started_at : undefined,
+            uptime_seconds: running ? uptime_seconds : undefined,
+            last_action,
+            active_goals,
+            total_iterations,
+        };
+    }
+    /** Start the daemon. No-op if already running. */
+    start(opts = {}) {
+        ensureWyrmDir();
+        rotateLogIfLarge();
+        const cur = this.status();
+        if (cur.running) {
+            return { ok: true, pid: cur.pid ?? undefined, status: cur };
+        }
+        // Clear stale PID file from a crashed prior run
+        if (existsSync(PID_FILE)) {
+            try {
+                unlinkSync(PID_FILE);
+            }
+            catch { /* ignore */ }
+        }
+        const binary = locateLoopBinary();
+        if (!binary) {
+            return { ok: false, error: 'Could not locate wyrm-loop binary. Run `npm install -g wyrm-mcp` or `npm run build` in packages/mcp-server.' };
+        }
+        const args = ['--interval', String(opts.interval_seconds ?? 600)];
+        if (opts.max_steps)
+            args.push('--max-steps', String(opts.max_steps));
+        if (opts.project_path)
+            args.push('--project', opts.project_path);
+        if (opts.verbose)
+            args.push('--verbose');
+        // Open the log file once, share fd with the child
+        let logFd;
+        try {
+            logFd = openSync(LOG_FILE, 'a');
+        }
+        catch (err) {
+            return { ok: false, error: `Could not open log file ${LOG_FILE}: ${err.message}` };
+        }
+        let child;
+        try {
+            child = spawn('node', [binary, ...args], {
+                detached: true,
+                stdio: ['ignore', logFd, logFd],
+                env: { ...process.env, WYRM_LOOP_LOG: opts.verbose ? '1' : '0' },
+            });
+        }
+        catch (err) {
+            return { ok: false, error: `spawn failed: ${err.message}` };
+        }
+        if (!child.pid) {
+            try {
+                closeSync(logFd);
+            }
+            catch { /* ignore */ }
+            return { ok: false, error: 'spawn returned no PID' };
+        }
+        try {
+            writeFileSync(PID_FILE, String(child.pid), 'utf-8');
+        }
+        catch (err) {
+            // Process is up but we can't track it — kill to keep state consistent
+            try {
+                process.kill(child.pid, 'SIGTERM');
+            }
+            catch { /* ignore */ }
+            try {
+                closeSync(logFd);
+            }
+            catch { /* ignore */ }
+            return { ok: false, error: `Could not write PID file: ${err.message}` };
+        }
+        // Close the parent's copy of the log fd — the child inherits its own
+        // dup via stdio. Without this, every successful spawn leaks one fd in
+        // the parent (the MCP server).
+        try {
+            closeSync(logFd);
+        }
+        catch { /* ignore */ }
+        // unref so this process doesn't wait on the child
+        child.unref();
+        // Brief settle delay so status() reflects the new state
+        return { ok: true, pid: child.pid, status: this.status() };
+    }
+    /** Stop the daemon. Sends SIGTERM, then SIGKILL after a grace period. */
+    async stop(opts = {}) {
+        const pid = readPid();
+        if (pid == null) {
+            return { ok: true, was_running: false };
+        }
+        if (!isProcessAlive(pid)) {
+            // Stale PID file
+            try {
+                unlinkSync(PID_FILE);
+            }
+            catch { /* ignore */ }
+            return { ok: true, was_running: false, pid };
+        }
+        try {
+            process.kill(pid, 'SIGTERM');
+        }
+        catch (err) {
+            return { ok: false, was_running: true, pid, error: `SIGTERM failed: ${err.message}` };
+        }
+        const grace = Math.max(100, Math.min(opts.grace_ms ?? 3000, 30_000));
+        const start = Date.now();
+        while (Date.now() - start < grace) {
+            if (!isProcessAlive(pid))
+                break;
+            await new Promise(r => { setTimeout(r, 100); });
+        }
+        if (isProcessAlive(pid)) {
+            try {
+                process.kill(pid, 'SIGKILL');
+            }
+            catch { /* may already be dead */ }
+        }
+        try {
+            unlinkSync(PID_FILE);
+        }
+        catch { /* ignore */ }
+        return { ok: true, was_running: true, pid };
+    }
+    /** Stop + Start in sequence. */
+    async restart(opts = {}) {
+        await this.stop({ grace_ms: 3000 });
+        return this.start(opts);
+    }
+    /** Read the last N lines of the daemon log. */
+    recentLog(lines = 40) {
+        try {
+            if (!existsSync(LOG_FILE))
+                return '(log file does not exist)';
+            const raw = readFileSync(LOG_FILE, 'utf-8');
+            const all = raw.split('\n');
+            return all.slice(-Math.max(1, Math.min(lines, 1000))).join('\n');
+        }
+        catch (err) {
+            return `(could not read log: ${err.message})`;
+        }
+    }
+}
+//# sourceMappingURL=agent-daemon.js.map