wyrm-mcp 7.3.2 → 7.3.3

package/dist/handlers/causality.js

@@ -1,9 +1,119 @@
-import{TOOL_ANNOTATIONS as u}from"../tool-annotations.js";import{staleFoundationWarning as f}from"../causality.js";const $=[{name:"wyrm_decided_because",description:"Use to link a choice or decision to the assumption or evidence it was based on - records a causal edge (truth/quest/artifact/session) so stale foundations invalidate downstream.",inputSchema:{type:"object",properties:{projectPath:{type:"string"},from_kind:{type:"string",enum:["truth","artifact","quest","session","data"]},from_id:{type:"number"},to_kind:{type:"string",enum:["truth","artifact","quest","session","data"]},to_id:{type:"number"},relation:{type:"string",enum:["because_of","supersedes","refutes","verifies"],description:"Default because_of"},rationale:{type:"string",description:"Why"},confidence:{type:"number",description:"0-1, default 1.0"}},required:["projectPath","from_kind","from_id","to_kind","to_id"]},annotations:u.wyrm_decided_because,aliases:[],handler:async(a,d)=>{const{causality:r,db:o}=d,{projectPath:i,from_kind:e,from_id:s,to_kind:t,to_id:c,relation:n,rationale:m,confidence:y}=a,p=o.getProject(i);if(!p)return{content:[{type:"text",text:"Project not found"}],isError:!0};const l=r.link({project_id:p.id,from_kind:e,from_id:s,to_kind:t,to_id:c,relation:n,rationale:m,confidence:y});return{content:[{type:"text",text:`\u{F115D} Edge #${l.id} \u2014 ${e}#${s} ${l.relation} ${t}#${c}`}]}}},{name:"wyrm_decision_downstream",description:"List all decisions that depend on the given source. Use before invalidating a truth to see the blast radius.",inputSchema:{type:"object",properties:{kind:{type:"string",enum:["truth","artifact","quest","session","data"]},id:{type:"number"}},required:["kind","id"]},annotations:u.wyrm_decision_downstream,aliases:[],handler:async(a,d)=>{const{causality:r}=d,{kind:o,id:i}=a,e=r.downstreamOf(o,i);if(e.length===0)return{content:[{type:"text",text:`\u{F115D} No active dependents on ${o}#${i}.`}]};const s=e.map(t=>`\u2022 ${t.from_kind}#${t.from_id} (${t.relation}, conf ${t.confidence})${t.rationale?` \u2014 ${t.rationale}`:""}`).join(`
-`);return{content:[{type:"text",text:`\u{F115D} ${e.length} dependent(s):
-${s}`}]}}},{name:"wyrm_decision_upstream",description:"List all sources a decision was based on (incoming edges). Walks the 'why did we choose this?' chain.",inputSchema:{type:"object",properties:{kind:{type:"string",enum:["truth","artifact","quest","session","data"]},id:{type:"number"}},required:["kind","id"]},annotations:u.wyrm_decision_upstream,aliases:[],handler:async(a,d)=>{const{causality:r}=d,{kind:o,id:i}=a,e=r.upstreamOf(o,i),s=f(r.staleFoundations(o,i)),t=s?`${s}
-
-`:"";if(e.length===0)return{content:[{type:"text",text:`${t}\u{F115D} No recorded basis for ${o}#${i}.`}]};const c=e.map(n=>`\u2022 ${n.to_kind}#${n.to_id} (${n.relation}, conf ${n.confidence})${n.rationale?` \u2014 ${n.rationale}`:""}`).join(`
-`);return{content:[{type:"text",text:`${t}\u{F115D} ${e.length} basis edge(s):
-${c}`}]}}},{name:"wyrm_decision_invalidate",description:"Cascade-invalidate all decisions downstream of a source (recursive). Use when a foundational truth turns out to be wrong. Returns the set of affected (kind, id) pairs.",inputSchema:{type:"object",properties:{kind:{type:"string",enum:["truth","artifact","quest","session","data"]},id:{type:"number"},reason:{type:"string",description:"Why the source was invalidated"}},required:["kind","id"]},annotations:u.wyrm_decision_invalidate,aliases:[],handler:async(a,d)=>{const{causality:r}=d,o=a||{},{kind:i,id:e,reason:s}=a,t=r.invalidateDownstream(i,e,s);if(t.invalidated===0)return{content:[{type:"text",text:`\u{F115D} No dependents to invalidate from ${i}#${e}.`}]};const c=t.affected.map(n=>`\u2022 ${n.kind}#${n.id} (edge #${n.edge_id})`).join(`
-`);return{content:[{type:"text",text:`\u{F115D} Invalidated ${t.invalidated} downstream decision(s):
-${c}`}]}}}];export{$ as causalityToolSpecs};
+/**
+ * @copyright 2026 Ghost Protocol (Pvt) Ltd.
+ * @license Proprietary — (c) 2026 Ghost Protocol (Pvt) Ltd. All rights reserved. See LICENSE.
+ */
+import { TOOL_ANNOTATIONS } from "../tool-annotations.js";
+import { staleFoundationWarning } from "../causality.js";
+export const causalityToolSpecs = [
+    {
+        name: "wyrm_decided_because",
+        description: "Use to link a choice or decision to the assumption or evidence it was based on - records a causal edge (truth/quest/artifact/session) so stale foundations invalidate downstream.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                projectPath: { type: "string" },
+                from_kind: { type: "string", enum: ["truth", "artifact", "quest", "session", "data"] },
+                from_id: { type: "number" },
+                to_kind: { type: "string", enum: ["truth", "artifact", "quest", "session", "data"] },
+                to_id: { type: "number" },
+                relation: { type: "string", enum: ["because_of", "supersedes", "refutes", "verifies"], description: "Default because_of" },
+                rationale: { type: "string", description: "Why" },
+                confidence: { type: "number", description: "0-1, default 1.0" },
+            },
+            required: ["projectPath", "from_kind", "from_id", "to_kind", "to_id"],
+        },
+        annotations: TOOL_ANNOTATIONS["wyrm_decided_because"],
+        aliases: [],
+        handler: async (args, ctx) => {
+            const { causality, db } = ctx;
+            const { projectPath, from_kind, from_id, to_kind, to_id, relation, rationale, confidence, } = args;
+            const project = db.getProject(projectPath);
+            if (!project)
+                return { content: [{ type: "text", text: "Project not found" }], isError: true };
+            const edge = causality.link({
+                project_id: project.id,
+                from_kind, from_id, to_kind, to_id, relation, rationale, confidence,
+            });
+            return { content: [{ type: "text", text: `󱅝 Edge #${edge.id} — ${from_kind}#${from_id} ${edge.relation} ${to_kind}#${to_id}` }] };
+        },
+    },
+    {
+        name: "wyrm_decision_downstream",
+        description: "List all decisions that depend on the given source. Use before invalidating a truth to see the blast radius.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                kind: { type: "string", enum: ["truth", "artifact", "quest", "session", "data"] },
+                id: { type: "number" },
+            },
+            required: ["kind", "id"],
+        },
+        annotations: TOOL_ANNOTATIONS["wyrm_decision_downstream"],
+        aliases: [],
+        handler: async (args, ctx) => {
+            const { causality } = ctx;
+            const { kind, id } = args;
+            const edges = causality.downstreamOf(kind, id);
+            if (edges.length === 0) {
+                return { content: [{ type: "text", text: `󱅝 No active dependents on ${kind}#${id}.` }] };
+            }
+            const text = edges.map(e => `• ${e.from_kind}#${e.from_id} (${e.relation}, conf ${e.confidence})${e.rationale ? ` — ${e.rationale}` : ''}`).join('\n');
+            return { content: [{ type: "text", text: `󱅝 ${edges.length} dependent(s):\n${text}` }] };
+        },
+    },
+    {
+        name: "wyrm_decision_upstream",
+        description: "List all sources a decision was based on (incoming edges). Walks the 'why did we choose this?' chain.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                kind: { type: "string", enum: ["truth", "artifact", "quest", "session", "data"] },
+                id: { type: "number" },
+            },
+            required: ["kind", "id"],
+        },
+        annotations: TOOL_ANNOTATIONS["wyrm_decision_upstream"],
+        aliases: [],
+        handler: async (args, ctx) => {
+            const { causality } = ctx;
+            const { kind, id } = args;
+            const edges = causality.upstreamOf(kind, id);
+            // Warn-at-recall: surface any foundation that has gone stale (superseded
+            // / refuted) so the agent RE-EVALUATES before relying on this decision.
+            const warn = staleFoundationWarning(causality.staleFoundations(kind, id));
+            const banner = warn ? `${warn}\n\n` : '';
+            if (edges.length === 0) {
+                return { content: [{ type: "text", text: `${banner}󱅝 No recorded basis for ${kind}#${id}.` }] };
+            }
+            const text = edges.map(e => `• ${e.to_kind}#${e.to_id} (${e.relation}, conf ${e.confidence})${e.rationale ? ` — ${e.rationale}` : ''}`).join('\n');
+            return { content: [{ type: "text", text: `${banner}󱅝 ${edges.length} basis edge(s):\n${text}` }] };
+        },
+    },
+    {
+        name: "wyrm_decision_invalidate",
+        description: "Cascade-invalidate all decisions downstream of a source (recursive). Use when a foundational truth turns out to be wrong. Returns the set of affected (kind, id) pairs.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                kind: { type: "string", enum: ["truth", "artifact", "quest", "session", "data"] },
+                id: { type: "number" },
+                reason: { type: "string", description: "Why the source was invalidated" },
+            },
+            required: ["kind", "id"],
+        },
+        annotations: TOOL_ANNOTATIONS["wyrm_decision_invalidate"],
+        aliases: [],
+        handler: async (args, ctx) => {
+            const { causality } = ctx;
+            const a = args || {};
+            const { kind, id, reason } = args;
+            const result = causality.invalidateDownstream(kind, id, reason);
+            if (result.invalidated === 0) {
+                return { content: [{ type: "text", text: `󱅝 No dependents to invalidate from ${kind}#${id}.` }] };
+            }
+            const text = result.affected.map(a => `• ${a.kind}#${a.id} (edge #${a.edge_id})`).join('\n');
+            return { content: [{ type: "text", text: `󱅝 Invalidated ${result.invalidated} downstream decision(s):\n${text}` }] };
+        },
+    },
+];
+//# sourceMappingURL=causality.js.map

package/dist/handlers/cloud.js

@@ -1,85 +1,382 @@
-import{TOOL_ANNOTATIONS as u}from"../tool-annotations.js";import{CloudSyncDaemon as m}from"../cloud-sync.js";import{getCrypto as h,initializeCrypto as k}from"../crypto.js";import{activateLicense as f,getLicenseInfo as b,getTier as x,hasFeature as d}from"../license.js";const S=[{name:"wyrm_license",description:"View current license status, tier, and available features",inputSchema:{type:"object",properties:{}},annotations:u.wyrm_license,aliases:[],handler:async(o,i)=>{const{cachedResponse:a,sync:r}=i,c=o||{},n=b(),e=x();let t=`\u{F115D} **Wyrm License Status**
-
-`;if(t+=`- **Tier:** ${e.charAt(0).toUpperCase()+e.slice(1)}
-`,n.valid&&n.key){t+=`- **Key:** ${n.key}
-`,t+=`- **Issued To:** ${n.issuedTo||"Unknown"}
-`,t+=`- **Expires:** ${n.expiresAt?new Date(n.expiresAt).toLocaleDateString():"Never"}
-`,t+=`- **Status:** \u2713 Valid
-
-`,t+=`### Features
-`;for(const l of n.features)t+=`- \u2713 ${l}
-`}else t+=`- **Status:** Free tier (no license key)
-
-`,t+=`### Free Features
-`,t+=`- \u2713 Local SQLite storage
-`,t+=`- \u2713 32 MCP tools
-`,t+=`- \u2713 FTS5 search
-`,t+=`- \u2713 File-based sync
-
-`,t+=`### Upgrade to Pro
-`,t+=`- Analytics dashboard & cost tracking
-`,t+=`- Cloud backup to R2
-`,t+=`- Encryption at rest
-`,t+=`- Priority support
-
-`,t+=`### Already have a license?
-`,t+="Activate it \u2014 paste the license JSON into the `wyrm_activate` tool, or save it to `~/.wyrm/license.json` and restart Wyrm.\n",t+="Manage or download your license at https://account.ghosts.lk \xB7 buy one at https://ghosts.lk/wyrm.";return a(t)}},{name:"wyrm_activate",description:"Activate a license key to unlock Pro/Team/Enterprise features",inputSchema:{type:"object",properties:{license:{type:"string",description:"License JSON string (signed license from Ghost Protocol)"}},required:["license"]},annotations:u.wyrm_activate,aliases:[],handler:async(o,i)=>{const a=o?.license;if(!a)throw new Error("License JSON string required");try{const r=f(a);return r.valid?{content:[{type:"text",text:`\u{F115D} \u2713 License activated!
-
-- **Tier:** ${r.tier}
-- **Features:** ${r.features.join(", ")}
-
-Restart Wyrm to apply all features.`}]}:{content:[{type:"text",text:`\u{F115D} \u2717 License activation failed: ${r.error||"unknown error"}`}],isError:!0}}catch{return{content:[{type:"text",text:"\u{F115D} \u2717 Invalid license format. Please verify your license key."}],isError:!0}}}},{name:"wyrm_analytics_dashboard",description:"View usage analytics dashboard \u2014 tool calls, tokens, costs, cache efficiency (Pro+)",inputSchema:{type:"object",properties:{days:{type:"number",description:"Number of days to analyze (default: 30)"}}},annotations:u.wyrm_analytics_dashboard,aliases:[],handler:async(o,i)=>{const{analytics:a}=i,r=o||{};if(!d("analytics"))return{content:[{type:"text",text:`\u{F115D} Analytics requires a Pro license or higher.
-Visit https://ghosts.lk/wyrm to upgrade.`}]};const c=o?.days||30,n=a.dashboard(c);let e=`\u{F115D} **Usage Analytics** (last ${c} days)
-
-`;if(e+=`### Overview
-`,e+=`- **Total Tool Calls:** ${n.summary.total_calls.toLocaleString()}
-`,e+=`- **Unique Tools Used:** ${n.summary.unique_tools}
-`,e+=`- **Total Tokens (In):** ${n.summary.total_tokens_in.toLocaleString()}
-`,e+=`- **Total Tokens (Out):** ${n.summary.total_tokens_out.toLocaleString()}
-`,e+=`- **Cache Hit Rate:** ${(n.summary.cache_hit_rate*100).toFixed(1)}%
-`,e+=`- **Estimated Cost:** $${n.summary.estimated_cost_usd.toFixed(4)}
-
-`,n.top_tools.length>0){e+=`### Top Tools
-`;for(const t of n.top_tools.slice(0,10))e+=`- **${t.tool}** \u2014 ${t.calls} calls, ${t.tokens.toLocaleString()} tokens
-`;e+=`
-`}if(n.daily.length>0){e+=`### Recent Activity
-`;for(const t of n.daily.slice(-7))e+=`- ${t.date}: ${t.calls} calls, ${t.tokens.toLocaleString()} tokens
-`}return{content:[{type:"text",text:e}]}}},{name:"wyrm_cost_report",description:"View estimated API cost report for current billing period (Pro+)",inputSchema:{type:"object",properties:{period:{type:"string",description:"Period in YYYY-MM format (default: current month)"}}},annotations:u.wyrm_cost_report,aliases:[],handler:async(o,i)=>{const{analytics:a}=i,r=o||{};if(!d("analytics"))return{content:[{type:"text",text:`\u{F115D} Cost reports require a Pro license or higher.
-Visit https://ghosts.lk/wyrm to upgrade.`}]};const c=o?.period,n=a.costReport(c);let e=`\u{F115D} **Cost Report** \u2014 ${n.period}
-
-`;if(e+=`- **Total Cost:** $${n.total_cost_usd.toFixed(4)}
-`,e+=`- **Projected Monthly:** $${n.projected_monthly_usd.toFixed(2)}
-
-`,n.tools.length>0){e+=`### By Tool
-`;for(const t of n.tools.slice(0,10))e+=`- **${t.tool}** \u2014 ${t.calls} calls, $${t.cost_usd.toFixed(4)}
-`}return{content:[{type:"text",text:e}]}}},{name:"wyrm_cloud_backup",description:"Backup Wyrm database to encrypted cloud storage (Pro+)",inputSchema:{type:"object",properties:{action:{type:"string",description:"Action: backup, restore, list, prune",enum:["backup","restore","list","prune"]},backupKey:{type:"string",description:"Backup key for restore (from list)"},keepCount:{type:"number",description:"Number of backups to keep when pruning (default: 10)"}},required:["action"]},annotations:u.wyrm_cloud_backup,aliases:[],handler:async(o,i)=>{const{cloudBackup:a,db:r}=i,c=o||{};if(!d("cloud_backup"))return{content:[{type:"text",text:`\u{F115D} Cloud backup requires a Pro license or higher.
-Visit https://ghosts.lk/wyrm to upgrade.`}]};const n=o?.action;switch(n){case"backup":{const e=await a.backup(r.getDatabasePath()),t=e.metadata;return{content:[{type:"text",text:`\u{F115D} \u2713 Backup complete!
-
-- **Key:** ${e.key}
-- **Size:** ${(t.db_size/1024).toFixed(1)} KB \u2192 ${(t.compressed_size/1024).toFixed(1)} KB compressed
-- **Encrypted:** ${t.encrypted?"Yes":"No"}
-- **Checksum:** ${t.checksum.slice(0,16)}...`}]}}case"restore":{const e=o?.backupKey;if(!e)throw new Error("backupKey required for restore");const t=await a.restore(e,r.getDatabasePath());return{content:[{type:"text",text:`\u{F115D} \u2713 Restore complete!
-
-- **Restored:** ${t.restored?"Yes":"No"}
-- **Size:** ${(t.size/1024).toFixed(1)} KB
-- **Previous DB backed up to:** ${r.getDatabasePath()}.bak
-
-\u26A0\uFE0F Restart Wyrm to use the restored database.`}]}}case"list":{const e=await a.listBackups();if(e.length===0)return{content:[{type:"text",text:"\u{F115D} No backups found."}]};let t=`\u{F115D} **Cloud Backups** (${e.length} found)
-
-`;for(const l of e)t+=`- **${l.timestamp}** \u2014 ${(l.db_size/1024).toFixed(1)} KB, encrypted: ${l.encrypted}, machine: ${l.machine_id.slice(0,8)}...
-`;return{content:[{type:"text",text:t}]}}case"prune":{const e=o?.keepCount||10;return{content:[{type:"text",text:`\u{F115D} \u2713 Pruned ${(await a.pruneBackups(e)).deleted} old backup(s). Kept ${e} most recent.`}]}}default:return{content:[{type:"text",text:`Unknown backup action: ${n}. Use: backup, restore, list, prune`}],isError:!0}}}},{name:"wyrm_cloud_sync",description:"Start, stop, or check the cloud-sync daemon \u2014 Phase 2 multi-device sync. Periodically backs up the DB to R2 and restores on startup if a newer snapshot exists. Last-write-wins by mtime.",inputSchema:{type:"object",properties:{action:{type:"string",description:"Action: start, stop, restart, status, force-sync",enum:["start","stop","restart","status","force-sync"]},interval_minutes:{type:"number",description:"Sync interval (default: 10)"},keep_count:{type:"number",description:"Snapshots to retain after pruning (default: 20)"}},required:["action"]},annotations:u.wyrm_cloud_sync,aliases:[],handler:async(o,i)=>{const{cloudBackup:a,cloudSyncManager:r,db:c,sync:n}=i,e=o||{};if(!d("cloud_backup"))return{content:[{type:"text",text:`\u{F115D} Cloud sync requires a Pro license or higher.
-Visit https://ghosts.lk/wyrm to upgrade.`}]};const t=o?.action,l=o?.interval_minutes,y=o?.keep_count;switch(t){case"start":{const s=r.start({interval_minutes:l,keep_count:y});return s.ok?{content:[{type:"text",text:`\u{F115D} \u2713 cloud-sync daemon started (pid ${s.pid}). Logs: ~/.wyrm/wyrm-cloud-sync.log`}]}:{content:[{type:"text",text:`\u{F115D} cloud-sync: ${s.reason??"failed to start"}${s.pid?` (pid ${s.pid})`:""}`}],isError:!s.pid}}case"stop":{const s=r.stop();return{content:[{type:"text",text:s.ok?"\u{F115D} \u2713 cloud-sync daemon stopped":`\u{F115D} cloud-sync: ${s.reason??"failed to stop"}`}],isError:!s.ok}}case"restart":{r.stop(),await new Promise(p=>{setTimeout(p,500)});const s=r.start({interval_minutes:l,keep_count:y});return{content:[{type:"text",text:s.ok?`\u{F115D} \u2713 cloud-sync daemon restarted (pid ${s.pid})`:`\u{F115D} cloud-sync restart failed: ${s.reason??"unknown"}`}],isError:!s.ok}}case"status":{const s=r.status(),p=["\u{F115D} **Cloud Sync Status**"];return p.push(`- Running: ${s.running?"\u2713 yes":"\u2717 no"}`),s.pid&&p.push(`- PID: ${s.pid}`),s.state&&(s.state.last_uploaded_ts&&p.push(`- Last upload: ${new Date(s.state.last_uploaded_ts).toISOString()}${s.state.last_uploaded_key?` (${s.state.last_uploaded_key})`:""}`),s.state.last_restored_key&&p.push(`- Last restore: ${s.state.last_restored_key}`),s.state.last_check_ts&&p.push(`- Last check: ${new Date(s.state.last_check_ts).toISOString()}`),p.push(`- Machine: ${s.state.machine}`)),{content:[{type:"text",text:p.join(`
-`)}]}}case"force-sync":{const p=await new m(a,c.getDatabasePath()).tick();return{content:[{type:"text",text:`\u{F115D} force-sync: ${JSON.stringify(p,null,2)}`}]}}default:return{content:[{type:"text",text:`Unknown cloud-sync action: ${t}. Use: start, stop, restart, status, force-sync`}],isError:!0}}}},{name:"wyrm_encrypt_setup",description:"Set up or check encryption status for sensitive data (Pro+)",inputSchema:{type:"object",properties:{action:{type:"string",description:"Action: status, enable, test",enum:["status","enable","test"]},password:{type:"string",description:"Encryption password (min 8 chars, required for enable)"}},required:["action"]},annotations:u.wyrm_encrypt_setup,aliases:[],handler:async(o,i)=>{const a=o||{};if(!d("encryption"))return{content:[{type:"text",text:`\u{F115D} Encryption setup requires a Pro license or higher.
-Visit https://ghosts.lk/wyrm to upgrade.`}]};const r=o?.action,c=h();switch(r){case"status":{const n=c.isEnabled();let e=`\u{F115D} **Encryption Status**
-
-`;return e+=`- **Enabled:** ${n?"\u2713 Yes":"\u2717 No"}
-`,e+=`- **Algorithm:** AES-256-GCM
-`,n?e+=`- **Status:** Active \u2014 new data is encrypted at rest
-`:e+='\nTo enable, run: `wyrm_encrypt_setup` with action "enable" and a strong password.\n',{content:[{type:"text",text:e}]}}case"enable":{const n=o?.password;return!n||n.length<8?{content:[{type:"text",text:"\u{F115D} Password must be at least 8 characters."}],isError:!0}:(k(n),{content:[{type:"text",text:`\u{F115D} \u2713 Encryption enabled!
-
-- **Algorithm:** AES-256-GCM
-- **Key derived from:** your password (PBKDF2)
-
-\u26A0\uFE0F **Store your password safely.** Lost passwords cannot be recovered.
-New data lake entries will be encrypted at rest.`}]})}case"test":{if(!c.isEnabled())return{content:[{type:"text",text:'\u{F115D} Encryption not enabled. Run with action "enable" first.'}]};const n="Wyrm encryption test "+Date.now(),e=c.encrypt(n),t=c.decrypt(e);return{content:[{type:"text",text:`\u{F115D} Encryption test: ${t===n?"\u2713 PASSED":"\u2717 FAILED"}
-- Encrypted ${n.length} chars \u2192 decrypted back to ${t.length} chars`}]}}default:return{content:[{type:"text",text:`Unknown encrypt action: ${r}. Use: status, enable, test`}],isError:!0}}}}];export{S as cloudToolSpecs};
+/**
+ * @copyright 2026 Ghost Protocol (Pvt) Ltd.
+ * @license Proprietary — (c) 2026 Ghost Protocol (Pvt) Ltd. All rights reserved. See LICENSE.
+ */
+import { TOOL_ANNOTATIONS } from "../tool-annotations.js";
+import { CloudSyncDaemon } from "../cloud-sync.js";
+import { getCrypto, initializeCrypto } from "../crypto.js";
+import { activateLicense, getLicenseInfo, getTier, hasFeature } from "../license.js";
+export const cloudToolSpecs = [
+    {
+        name: "wyrm_license",
+        description: "View current license status, tier, and available features",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+        annotations: TOOL_ANNOTATIONS["wyrm_license"],
+        aliases: [],
+        handler: async (args, ctx) => {
+            const { cachedResponse, sync } = ctx;
+            const a = args || {};
+            const license = getLicenseInfo();
+            const tier = getTier();
+            let text = `󱅝 **Wyrm License Status**\n\n`;
+            text += `- **Tier:** ${tier.charAt(0).toUpperCase() + tier.slice(1)}\n`;
+            if (license.valid && license.key) {
+                text += `- **Key:** ${license.key}\n`;
+                text += `- **Issued To:** ${license.issuedTo || 'Unknown'}\n`;
+                text += `- **Expires:** ${license.expiresAt ? new Date(license.expiresAt).toLocaleDateString() : 'Never'}\n`;
+                text += `- **Status:** ✓ Valid\n\n`;
+                text += `### Features\n`;
+                for (const f of license.features) {
+                    text += `- ✓ ${f}\n`;
+                }
+            }
+            else {
+                text += `- **Status:** Free tier (no license key)\n\n`;
+                text += `### Free Features\n`;
+                text += `- ✓ Local SQLite storage\n`;
+                text += `- ✓ 32 MCP tools\n`;
+                text += `- ✓ FTS5 search\n`;
+                text += `- ✓ File-based sync\n\n`;
+                text += `### Upgrade to Pro\n`;
+                text += `- Analytics dashboard & cost tracking\n`;
+                text += `- Cloud backup to R2\n`;
+                text += `- Encryption at rest\n`;
+                text += `- Priority support\n\n`;
+                text += `### Already have a license?\n`;
+                text += `Activate it — paste the license JSON into the \`wyrm_activate\` tool, or save it to \`~/.wyrm/license.json\` and restart Wyrm.\n`;
+                text += `Manage or download your license at https://account.ghosts.lk · buy one at https://ghosts.lk/wyrm.`;
+            }
+            return cachedResponse(text);
+        },
+    },
+    {
+        name: "wyrm_activate",
+        description: "Activate a license key to unlock Pro/Team/Enterprise features",
+        inputSchema: {
+            type: "object",
+            properties: {
+                license: { type: "string", description: "License JSON string (signed license from Ghost Protocol)" },
+            },
+            required: ["license"],
+        },
+        annotations: TOOL_ANNOTATIONS["wyrm_activate"],
+        aliases: [],
+        handler: async (args, ctx) => {
+            const licenseStr = args?.license;
+            if (!licenseStr)
+                throw new Error("License JSON string required");
+            try {
+                const result = activateLicense(licenseStr);
+                if (result.valid) {
+                    return {
+                        content: [{ type: "text", text: `󱅝 ✓ License activated!\n\n- **Tier:** ${result.tier}\n- **Features:** ${result.features.join(', ')}\n\nRestart Wyrm to apply all features.` }],
+                    };
+                }
+                else {
+                    return {
+                        content: [{ type: "text", text: `󱅝 ✗ License activation failed: ${result.error || 'unknown error'}` }],
+                        isError: true,
+                    };
+                }
+            }
+            catch (e) {
+                return {
+                    content: [{ type: "text", text: `󱅝 ✗ Invalid license format. Please verify your license key.` }],
+                    isError: true,
+                };
+            }
+        },
+    },
+    {
+        name: "wyrm_analytics_dashboard",
+        description: "View usage analytics dashboard — tool calls, tokens, costs, cache efficiency (Pro+)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                days: { type: "number", description: "Number of days to analyze (default: 30)" },
+            },
+        },
+        annotations: TOOL_ANNOTATIONS["wyrm_analytics_dashboard"],
+        aliases: [],
+        handler: async (args, ctx) => {
+            const { analytics } = ctx;
+            const a = args || {};
+            if (!hasFeature('analytics')) {
+                return {
+                    content: [{ type: "text", text: `󱅝 Analytics requires a Pro license or higher.\nVisit https://ghosts.lk/wyrm to upgrade.` }],
+                };
+            }
+            const days = args?.days || 30;
+            const dashboard = analytics.dashboard(days);
+            let text = `󱅝 **Usage Analytics** (last ${days} days)\n\n`;
+            text += `### Overview\n`;
+            text += `- **Total Tool Calls:** ${dashboard.summary.total_calls.toLocaleString()}\n`;
+            text += `- **Unique Tools Used:** ${dashboard.summary.unique_tools}\n`;
+            text += `- **Total Tokens (In):** ${dashboard.summary.total_tokens_in.toLocaleString()}\n`;
+            text += `- **Total Tokens (Out):** ${dashboard.summary.total_tokens_out.toLocaleString()}\n`;
+            text += `- **Cache Hit Rate:** ${(dashboard.summary.cache_hit_rate * 100).toFixed(1)}%\n`;
+            text += `- **Estimated Cost:** $${dashboard.summary.estimated_cost_usd.toFixed(4)}\n\n`;
+            if (dashboard.top_tools.length > 0) {
+                text += `### Top Tools\n`;
+                for (const t of dashboard.top_tools.slice(0, 10)) {
+                    text += `- **${t.tool}** — ${t.calls} calls, ${t.tokens.toLocaleString()} tokens\n`;
+                }
+                text += `\n`;
+            }
+            if (dashboard.daily.length > 0) {
+                text += `### Recent Activity\n`;
+                for (const d of dashboard.daily.slice(-7)) {
+                    text += `- ${d.date}: ${d.calls} calls, ${d.tokens.toLocaleString()} tokens\n`;
+                }
+            }
+            return { content: [{ type: "text", text }] };
+        },
+    },
+    {
+        name: "wyrm_cost_report",
+        description: "View estimated API cost report for current billing period (Pro+)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                period: { type: "string", description: "Period in YYYY-MM format (default: current month)" },
+            },
+        },
+        annotations: TOOL_ANNOTATIONS["wyrm_cost_report"],
+        aliases: [],
+        handler: async (args, ctx) => {
+            const { analytics } = ctx;
+            const a = args || {};
+            if (!hasFeature('analytics')) {
+                return {
+                    content: [{ type: "text", text: `󱅝 Cost reports require a Pro license or higher.\nVisit https://ghosts.lk/wyrm to upgrade.` }],
+                };
+            }
+            const period = args?.period;
+            const report = analytics.costReport(period);
+            let text = `󱅝 **Cost Report** — ${report.period}\n\n`;
+            text += `- **Total Cost:** $${report.total_cost_usd.toFixed(4)}\n`;
+            text += `- **Projected Monthly:** $${report.projected_monthly_usd.toFixed(2)}\n\n`;
+            if (report.tools.length > 0) {
+                text += `### By Tool\n`;
+                for (const t of report.tools.slice(0, 10)) {
+                    text += `- **${t.tool}** — ${t.calls} calls, $${t.cost_usd.toFixed(4)}\n`;
+                }
+            }
+            return { content: [{ type: "text", text }] };
+        },
+    },
+    {
+        name: "wyrm_cloud_backup",
+        description: "Backup Wyrm database to encrypted cloud storage (Pro+)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                action: { type: "string", description: "Action: backup, restore, list, prune", enum: ["backup", "restore", "list", "prune"] },
+                backupKey: { type: "string", description: "Backup key for restore (from list)" },
+                keepCount: { type: "number", description: "Number of backups to keep when pruning (default: 10)" },
+            },
+            required: ["action"],
+        },
+        annotations: TOOL_ANNOTATIONS["wyrm_cloud_backup"],
+        aliases: [],
+        handler: async (args, ctx) => {
+            const { cloudBackup, db } = ctx;
+            const a = args || {};
+            if (!hasFeature('cloud_backup')) {
+                return {
+                    content: [{ type: "text", text: `󱅝 Cloud backup requires a Pro license or higher.\nVisit https://ghosts.lk/wyrm to upgrade.` }],
+                };
+            }
+            const action = args?.action;
+            switch (action) {
+                case "backup": {
+                    const result = await cloudBackup.backup(db.getDatabasePath());
+                    const meta = result.metadata;
+                    return {
+                        content: [{ type: "text", text: `󱅝 ✓ Backup complete!\n\n- **Key:** ${result.key}\n- **Size:** ${(meta.db_size / 1024).toFixed(1)} KB → ${(meta.compressed_size / 1024).toFixed(1)} KB compressed\n- **Encrypted:** ${meta.encrypted ? 'Yes' : 'No'}\n- **Checksum:** ${meta.checksum.slice(0, 16)}...` }],
+                    };
+                }
+                case "restore": {
+                    const backupKey = args?.backupKey;
+                    if (!backupKey)
+                        throw new Error("backupKey required for restore");
+                    const result = await cloudBackup.restore(backupKey, db.getDatabasePath());
+                    return {
+                        content: [{ type: "text", text: `󱅝 ✓ Restore complete!\n\n- **Restored:** ${result.restored ? 'Yes' : 'No'}\n- **Size:** ${(result.size / 1024).toFixed(1)} KB\n- **Previous DB backed up to:** ${db.getDatabasePath()}.bak\n\n⚠️ Restart Wyrm to use the restored database.` }],
+                    };
+                }
+                case "list": {
+                    const backups = await cloudBackup.listBackups();
+                    if (backups.length === 0) {
+                        return { content: [{ type: "text", text: `󱅝 No backups found.` }] };
+                    }
+                    let text = `󱅝 **Cloud Backups** (${backups.length} found)\n\n`;
+                    for (const b of backups) {
+                        text += `- **${b.timestamp}** — ${(b.db_size / 1024).toFixed(1)} KB, encrypted: ${b.encrypted}, machine: ${b.machine_id.slice(0, 8)}...\n`;
+                    }
+                    return { content: [{ type: "text", text }] };
+                }
+                case "prune": {
+                    const keepCount = args?.keepCount || 10;
+                    const result = await cloudBackup.pruneBackups(keepCount);
+                    return {
+                        content: [{ type: "text", text: `󱅝 ✓ Pruned ${result.deleted} old backup(s). Kept ${keepCount} most recent.` }],
+                    };
+                }
+                default:
+                    return { content: [{ type: "text", text: `Unknown backup action: ${action}. Use: backup, restore, list, prune` }], isError: true };
+            }
+        },
+    },
+    {
+        name: "wyrm_cloud_sync",
+        description: "Start, stop, or check the cloud-sync daemon — Phase 2 multi-device sync. Periodically backs up the DB to R2 and restores on startup if a newer snapshot exists. Last-write-wins by mtime.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                action: { type: "string", description: "Action: start, stop, restart, status, force-sync", enum: ["start", "stop", "restart", "status", "force-sync"] },
+                interval_minutes: { type: "number", description: "Sync interval (default: 10)" },
+                keep_count: { type: "number", description: "Snapshots to retain after pruning (default: 20)" },
+            },
+            required: ["action"],
+        },
+        annotations: TOOL_ANNOTATIONS["wyrm_cloud_sync"],
+        aliases: [],
+        handler: async (args, ctx) => {
+            const { cloudBackup, cloudSyncManager, db, sync } = ctx;
+            const a = args || {};
+            if (!hasFeature('cloud_backup')) {
+                return {
+                    content: [{ type: "text", text: `󱅝 Cloud sync requires a Pro license or higher.\nVisit https://ghosts.lk/wyrm to upgrade.` }],
+                };
+            }
+            const action = args?.action;
+            const interval_minutes = args?.interval_minutes;
+            const keep_count = args?.keep_count;
+            switch (action) {
+                case "start": {
+                    const r = cloudSyncManager.start({ interval_minutes, keep_count });
+                    if (!r.ok) {
+                        return { content: [{ type: "text", text: `󱅝 cloud-sync: ${r.reason ?? 'failed to start'}${r.pid ? ` (pid ${r.pid})` : ''}` }], isError: !r.pid };
+                    }
+                    return { content: [{ type: "text", text: `󱅝 ✓ cloud-sync daemon started (pid ${r.pid}). Logs: ~/.wyrm/wyrm-cloud-sync.log` }] };
+                }
+                case "stop": {
+                    const r = cloudSyncManager.stop();
+                    return {
+                        content: [{ type: "text", text: r.ok
+                                    ? `󱅝 ✓ cloud-sync daemon stopped`
+                                    : `󱅝 cloud-sync: ${r.reason ?? 'failed to stop'}` }],
+                        isError: !r.ok,
+                    };
+                }
+                case "restart": {
+                    cloudSyncManager.stop();
+                    // Brief grace period for the daemon's final tick before re-spawning
+                    await new Promise((res) => { setTimeout(res, 500); });
+                    const r = cloudSyncManager.start({ interval_minutes, keep_count });
+                    return {
+                        content: [{ type: "text", text: r.ok
+                                    ? `󱅝 ✓ cloud-sync daemon restarted (pid ${r.pid})`
+                                    : `󱅝 cloud-sync restart failed: ${r.reason ?? 'unknown'}` }],
+                        isError: !r.ok,
+                    };
+                }
+                case "status": {
+                    const s = cloudSyncManager.status();
+                    const lines = [`󱅝 **Cloud Sync Status**`];
+                    lines.push(`- Running: ${s.running ? '✓ yes' : '✗ no'}`);
+                    if (s.pid)
+                        lines.push(`- PID: ${s.pid}`);
+                    if (s.state) {
+                        if (s.state.last_uploaded_ts) {
+                            lines.push(`- Last upload: ${new Date(s.state.last_uploaded_ts).toISOString()}${s.state.last_uploaded_key ? ` (${s.state.last_uploaded_key})` : ''}`);
+                        }
+                        if (s.state.last_restored_key)
+                            lines.push(`- Last restore: ${s.state.last_restored_key}`);
+                        if (s.state.last_check_ts)
+                            lines.push(`- Last check: ${new Date(s.state.last_check_ts).toISOString()}`);
+                        lines.push(`- Machine: ${s.state.machine}`);
+                    }
+                    return { content: [{ type: "text", text: lines.join('\n') }] };
+                }
+                case "force-sync": {
+                    // One-shot tick without the long-running daemon. Uses the in-process
+                    // cloudBackup client, so works even when the daemon is stopped.
+                    const daemon = new CloudSyncDaemon(cloudBackup, db.getDatabasePath());
+                    const result = await daemon.tick();
+                    return { content: [{ type: "text", text: `󱅝 force-sync: ${JSON.stringify(result, null, 2)}` }] };
+                }
+                default:
+                    return { content: [{ type: "text", text: `Unknown cloud-sync action: ${action}. Use: start, stop, restart, status, force-sync` }], isError: true };
+            }
+        },
+    },
+    {
+        name: "wyrm_encrypt_setup",
+        description: "Set up or check encryption status for sensitive data (Pro+)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                action: { type: "string", description: "Action: status, enable, test", enum: ["status", "enable", "test"] },
+                password: { type: "string", description: "Encryption password (min 8 chars, required for enable)" },
+            },
+            required: ["action"],
+        },
+        annotations: TOOL_ANNOTATIONS["wyrm_encrypt_setup"],
+        aliases: [],
+        handler: async (args, ctx) => {
+            const a = args || {};
+            if (!hasFeature('encryption')) {
+                return {
+                    content: [{ type: "text", text: `󱅝 Encryption setup requires a Pro license or higher.\nVisit https://ghosts.lk/wyrm to upgrade.` }],
+                };
+            }
+            const encAction = args?.action;
+            const cryptoInstance = getCrypto();
+            switch (encAction) {
+                case "status": {
+                    const enabled = cryptoInstance.isEnabled();
+                    let text = `󱅝 **Encryption Status**\n\n`;
+                    text += `- **Enabled:** ${enabled ? '✓ Yes' : '✗ No'}\n`;
+                    text += `- **Algorithm:** AES-256-GCM\n`;
+                    if (enabled) {
+                        text += `- **Status:** Active — new data is encrypted at rest\n`;
+                    }
+                    else {
+                        text += `\nTo enable, run: \`wyrm_encrypt_setup\` with action "enable" and a strong password.\n`;
+                    }
+                    return { content: [{ type: "text", text }] };
+                }
+                case "enable": {
+                    const password = args?.password;
+                    if (!password || password.length < 8) {
+                        return { content: [{ type: "text", text: `󱅝 Password must be at least 8 characters.` }], isError: true };
+                    }
+                    initializeCrypto(password);
+                    return {
+                        content: [{ type: "text", text: `󱅝 ✓ Encryption enabled!\n\n- **Algorithm:** AES-256-GCM\n- **Key derived from:** your password (PBKDF2)\n\n⚠️ **Store your password safely.** Lost passwords cannot be recovered.\nNew data lake entries will be encrypted at rest.` }],
+                    };
+                }
+                case "test": {
+                    if (!cryptoInstance.isEnabled()) {
+                        return { content: [{ type: "text", text: `󱅝 Encryption not enabled. Run with action "enable" first.` }] };
+                    }
+                    const testData = "Wyrm encryption test " + Date.now();
+                    const encrypted = cryptoInstance.encrypt(testData);
+                    const decrypted = cryptoInstance.decrypt(encrypted);
+                    const ok = decrypted === testData;
+                    return {
+                        content: [{ type: "text", text: `󱅝 Encryption test: ${ok ? '✓ PASSED' : '✗ FAILED'}\n- Encrypted ${testData.length} chars → decrypted back to ${decrypted.length} chars` }],
+                    };
+                }
+                default:
+                    return { content: [{ type: "text", text: `Unknown encrypt action: ${encAction}. Use: status, enable, test` }], isError: true };
+            }
+        },
+    },
+];
+//# sourceMappingURL=cloud.js.map