@heyamiko/amiko-cli 0.9.7 → 0.9.9-beta.1

package/dist/index.js

@@ -5,43 +5,25 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toESMCache_node;
-var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
-  var canCache = mod != null && typeof mod === "object";
-  if (canCache) {
-    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
-    var cached = cache.get(mod);
-    if (cached)
-      return cached;
-  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: __accessProp.bind(mod, key),
+        get: () => mod[key],
         enumerable: true
       });
-  if (canCache)
-    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: __exportSetter.bind(all, name)
+      set: (newValue) => all[name] = () => newValue
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -3533,36 +3515,11 @@ var require_emoji_regex = __commonJS((exports, module) => {
   };
 });
 
-// node_modules/mppx/dist/Method.js
-var exports_Method = {};
-__export(exports_Method, {
-  toServer: () => toServer,
-  toClient: () => toClient,
-  from: () => from
-});
-function from(method) {
-  return method;
-}
-function toClient(method, options) {
-  const { context, createCredential } = options;
-  return {
-    ...method,
-    context,
-    createCredential
-  };
-}
-function toServer(method, options) {
-  const { defaults, html, request, respond, transport, verify } = options;
-  return {
-    ...method,
-    defaults,
-    html,
-    request,
-    respond,
-    transport,
-    verify
-  };
-}
+// node_modules/mppx/dist/BodyDigest.js
+var init_BodyDigest = () => {};
+
+// node_modules/mppx/dist/PaymentRequest.js
+var init_PaymentRequest = () => {};
 
 // node_modules/mppx/node_modules/zod/v4/core/core.js
 function $constructor(name, initializer, params) {
@@ -16647,8 +16604,89 @@ var init_zod = __esm(() => {
   init_mini();
 });
 
+// node_modules/mppx/dist/Challenge.js
+var Schema;
+var init_Challenge = __esm(() => {
+  init_zod();
+  Schema = object({
+    description: optional(string2()),
+    digest: optional(string2().check(_regex(/^sha-256=/, "Invalid digest format"))),
+    expires: optional(datetime3()),
+    id: string2(),
+    intent: string2(),
+    method: string2(),
+    opaque: optional(record(string2(), string2())),
+    realm: string2(),
+    request: record(string2(), unknown())
+  });
+});
+
+// node_modules/mppx/dist/Credential.js
+var init_Credential = () => {};
+
+// node_modules/mppx/dist/Errors.js
+var init_Errors = () => {};
+
+// node_modules/mppx/dist/Expires.js
+var init_Expires = () => {};
+
+// node_modules/mppx/dist/Method.js
+var exports_Method = {};
+__export(exports_Method, {
+  toServer: () => toServer,
+  toClient: () => toClient,
+  from: () => from
+});
+function from(method) {
+  return method;
+}
+function toClient(method, options) {
+  const { context, createCredential } = options;
+  return {
+    ...method,
+    context,
+    createCredential
+  };
+}
+function toServer(method, options) {
+  const { defaults, html, request, respond, transport, verify } = options;
+  return {
+    ...method,
+    defaults,
+    html,
+    request,
+    respond,
+    transport,
+    verify
+  };
+}
+
+// node_modules/mppx/dist/Receipt.js
+var Schema2;
+var init_Receipt = __esm(() => {
+  init_zod();
+  Schema2 = object({
+    method: string2(),
+    reference: string2(),
+    externalId: optional(string2()),
+    status: literal("success"),
+    timestamp: datetime3()
+  });
+});
+
+// node_modules/mppx/dist/Store.js
+var init_Store = () => {};
+
 // node_modules/mppx/dist/index.js
 var init_dist = __esm(() => {
+  init_BodyDigest();
+  init_Challenge();
+  init_Credential();
+  init_Errors();
+  init_Expires();
+  init_PaymentRequest();
+  init_Receipt();
+  init_Store();
   init_zod();
 });
 
@@ -21974,6 +22012,347 @@ function registerNotificationsCommand(program2) {
   });
 }
 
+// src/commands/memory.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2, statSync } from "node:fs";
+import { dirname, isAbsolute, normalize, resolve as resolve2 } from "node:path";
+var VALID_CATEGORIES = ["fact", "preference", "pattern", "decision", "context"];
+var VALID_SOURCES = ["chat", "file", "manual"];
+var DEFAULT_WORKSPACE = "/data/.openclaw/workspace";
+var SYNC_BATCH_SIZE = 100;
+function fail(msg) {
+  console.error(error(msg));
+  process.exit(1);
+}
+function parseTags(raw) {
+  if (!raw)
+    return;
+  const tags = raw.split(",").map((t) => t.trim()).filter(Boolean);
+  return tags.length ? tags : undefined;
+}
+function fmtMemory(m) {
+  console.log("");
+  console.log(label("ID", m.id));
+  console.log(label("Category", m.category));
+  console.log(label("Source", m.source));
+  if (m.tags && m.tags.length)
+    console.log(label("Tags", m.tags.join(", ")));
+  if (typeof m.score === "number")
+    console.log(label("Score", m.score.toFixed(3)));
+  if (m.created_at)
+    console.log(label("Created", m.created_at.slice(0, 19)));
+  console.log(m.content);
+}
+function registerMemoryCommand(program2) {
+  const memory = program2.command("memory").description("Manage cross-agent memories — add, list, search, remove, sync local files");
+  memory.command("add <content>").description("Add a single memory directly").option("--category <cat>", `Category (${VALID_CATEGORIES.join("|")})`, "fact").option("--tags <list>", "Comma-separated tags (max 10)").option("--source <src>", `Source (${VALID_SOURCES.join("|")})`, "manual").option("--twin <twinId>", "Override twin_id (defaults to scopedTwinId)").option("--json", "Output as JSON").action(async (content, opts) => {
+    if (!content || !content.trim())
+      fail("Content is required and cannot be empty.");
+    if (opts.category && !VALID_CATEGORIES.includes(opts.category)) {
+      fail(`Invalid category. Must be one of: ${VALID_CATEGORIES.join(", ")}`);
+    }
+    if (opts.source && !VALID_SOURCES.includes(opts.source)) {
+      fail(`Invalid source. Must be one of: ${VALID_SOURCES.join(", ")}`);
+    }
+    const tags = parseTags(opts.tags);
+    if (tags && tags.length > 10)
+      fail("Max 10 tags.");
+    const auth = resolveAuth();
+    const spinner = opts.json ? null : ora("Saving memory...").start();
+    try {
+      const data = await amikoWebFetch(auth, "/api/memories", {
+        method: "POST",
+        body: {
+          content: content.trim(),
+          category: opts.category,
+          tags,
+          source: opts.source,
+          twin_id: opts.twin
+        }
+      });
+      spinner?.stop();
+      renderOutput(data, (d) => {
+        console.log(success("Memory saved"));
+        fmtMemory(d.memory);
+      }, { json: opts.json });
+    } catch (e) {
+      spinner?.stop();
+      fail(e instanceof Error ? e.message : String(e));
+    }
+  });
+  memory.command("list").description("List the caller's memories (newest first)").option("--limit <n>", "Max results (1–100)", "25").option("--offset <n>", "Pagination offset", "0").option("--category <cat>", `Filter (${VALID_CATEGORIES.join("|")})`).option("--source <src>", `Filter (${VALID_SOURCES.join("|")})`).option("--json", "Output as JSON").action(async (opts) => {
+    if (opts.category && !VALID_CATEGORIES.includes(opts.category)) {
+      fail(`Invalid category. Must be one of: ${VALID_CATEGORIES.join(", ")}`);
+    }
+    if (opts.source && !VALID_SOURCES.includes(opts.source)) {
+      fail(`Invalid source. Must be one of: ${VALID_SOURCES.join(", ")}`);
+    }
+    const auth = resolveAuth();
+    const spinner = opts.json ? null : ora("Loading memories...").start();
+    try {
+      const data = await amikoWebFetch(auth, "/api/memories", {
+        query: {
+          limit: opts.limit,
+          offset: opts.offset,
+          category: opts.category,
+          source: opts.source
+        }
+      });
+      spinner?.stop();
+      renderOutput(data, (d) => {
+        if (!d.items.length) {
+          console.log(dim("No memories."));
+          return;
+        }
+        console.log(heading(`Memories — ${d.items.length} of ${d.total}`));
+        for (const m of d.items)
+          fmtMemory(m);
+        if (d.has_more) {
+          const next = Number(opts.offset || "0") + d.items.length;
+          console.log("");
+          console.log(dim(`More available — pass --offset ${next}`));
+        }
+      }, { json: opts.json });
+    } catch (e) {
+      spinner?.stop();
+      fail(e instanceof Error ? e.message : String(e));
+    }
+  });
+  memory.command("search <query>").description("Hybrid search across the caller's memories").option("--limit <n>", "Max results (1–100)", "25").option("--category <cat>", `Filter (${VALID_CATEGORIES.join("|")})`).option("--json", "Output as JSON").action(async (query, opts) => {
+    if (!query || !query.trim())
+      fail("Query is required.");
+    if (opts.category && !VALID_CATEGORIES.includes(opts.category)) {
+      fail(`Invalid category. Must be one of: ${VALID_CATEGORIES.join(", ")}`);
+    }
+    const auth = resolveAuth();
+    const spinner = opts.json ? null : ora("Searching...").start();
+    try {
+      const data = await amikoWebFetch(auth, "/api/memories", {
+        query: {
+          q: query,
+          limit: opts.limit,
+          category: opts.category
+        }
+      });
+      spinner?.stop();
+      renderOutput(data, (d) => {
+        if (!d.items.length) {
+          console.log(dim("No matches."));
+          return;
+        }
+        console.log(heading(`Matches — ${d.items.length} of ${d.total}`));
+        for (const m of d.items)
+          fmtMemory(m);
+      }, { json: opts.json });
+    } catch (e) {
+      spinner?.stop();
+      fail(e instanceof Error ? e.message : String(e));
+    }
+  });
+  memory.command("rm <id>").description("Soft-delete a memory by id").option("--json", "Output as JSON").action(async (id, opts) => {
+    if (!id)
+      fail("Memory id is required.");
+    const auth = resolveAuth();
+    const spinner = opts.json ? null : ora("Deleting...").start();
+    try {
+      const data = await amikoWebFetch(auth, `/api/memories/${encodeURIComponent(id)}`, { method: "DELETE" });
+      spinner?.stop();
+      renderOutput(data, () => console.log(success(`Deleted memory ${id}`)), { json: opts.json });
+    } catch (e) {
+      spinner?.stop();
+      fail(e instanceof Error ? e.message : String(e));
+    }
+  });
+  memory.command("status").description("Show counts of memories and synced memory files").option("--json", "Output as JSON").action(async (opts) => {
+    const auth = resolveAuth();
+    const spinner = opts.json ? null : ora("Loading status...").start();
+    try {
+      const [memories, files] = await Promise.all([
+        amikoWebFetch(auth, "/api/memories", {
+          query: { limit: "1" }
+        }),
+        amikoWebFetch(auth, "/api/memory-files", { query: { limit: "1" } })
+      ]);
+      spinner?.stop();
+      const fileTotal = files.total ?? files.items?.length ?? 0;
+      renderOutput({ memories: memories.total, memory_files: fileTotal }, (d) => {
+        console.log(heading("Memory status"));
+        console.log(label("Memories", String(d.memories)));
+        console.log(label("Memory files", String(d.memory_files)));
+      }, { json: opts.json });
+    } catch (e) {
+      spinner?.stop();
+      fail(e instanceof Error ? e.message : String(e));
+    }
+  });
+  memory.command("sync").description("Sync MEMORY.md and referenced files to the platform (one-way: local → server)").option("--path <dir>", `Workspace dir containing MEMORY.md (default ${DEFAULT_WORKSPACE})`).option("--dry-run", "Print what would be synced without uploading").option("--prune", "Delete server-side memory files that no longer exist locally").option("--json", "Output as JSON").action(async (opts) => {
+    const root = resolve2(opts.path || DEFAULT_WORKSPACE);
+    const indexPath = resolve2(root, "MEMORY.md");
+    if (!existsSync3(indexPath)) {
+      fail(`MEMORY.md not found at ${indexPath}`);
+    }
+    const collected = collectMemoryFiles(root, indexPath);
+    if (collected.errors.length && !opts.json) {
+      for (const e of collected.errors)
+        console.error(error(e));
+    }
+    const files = collected.files;
+    if (opts.dryRun) {
+      renderOutput({ root, files: files.map((f) => f.path), prune: !!opts.prune }, (d) => {
+        console.log(heading(`Dry run — ${d.files.length} file(s)`));
+        for (const p of d.files)
+          console.log(`  ${p}`);
+        if (d.prune)
+          console.log(dim("--prune would remove server files not listed above."));
+      }, { json: opts.json });
+      return;
+    }
+    if (!files.length) {
+      renderOutput({ synced: 0, changed: 0, errors: 0, extracted: 0 }, () => console.log(dim("Nothing to sync.")), { json: opts.json });
+      return;
+    }
+    const auth = resolveAuth();
+    const spinner = opts.json ? null : ora(`Syncing ${files.length} file(s)...`).start();
+    try {
+      const allResults = [];
+      for (let i = 0;i < files.length; i += SYNC_BATCH_SIZE) {
+        const chunk = files.slice(i, i + SYNC_BATCH_SIZE);
+        const data = await amikoWebFetch(auth, "/api/memory-files/bulk", {
+          method: "POST",
+          body: { files: chunk }
+        });
+        allResults.push(...data.results);
+      }
+      let pruned = 0;
+      const pruneErrors = [];
+      if (opts.prune) {
+        const localPaths = new Set(files.map((f) => f.path));
+        const remote = await fetchAllMemoryFiles(auth);
+        const stale = remote.filter((f) => !localPaths.has(f.path));
+        for (const f of stale) {
+          try {
+            await amikoWebFetch(auth, `/api/memory-files/${encodeURIComponent(f.id)}`, { method: "DELETE" });
+            pruned++;
+          } catch (e) {
+            pruneErrors.push(`${f.path}: ${e instanceof Error ? e.message : String(e)}`);
+          }
+        }
+      }
+      spinner?.stop();
+      const changed = allResults.filter((r) => r.changed).length;
+      const errors2 = allResults.filter((r) => r.error).length;
+      const extracted = allResults.reduce((acc, r) => acc + (r.extracted ?? 0), 0);
+      renderOutput({
+        synced: allResults.length,
+        changed,
+        errors: errors2,
+        extracted,
+        pruned,
+        prune_errors: pruneErrors,
+        results: allResults
+      }, (d) => {
+        console.log(success(`${d.synced} file(s) synced (${d.changed} changed, ${d.errors} errors), ${d.extracted} memories extracted`));
+        for (const r of allResults) {
+          if (r.error) {
+            console.log(error(`${r.path}: ${r.error}`));
+          } else if (r.changed) {
+            console.log(`  ${r.path} ${dim(`→ ${r.extracted ?? 0} extracted`)}`);
+          } else {
+            console.log(`  ${r.path} ${dim("(unchanged)")}`);
+          }
+        }
+        if (opts.prune) {
+          console.log("");
+          console.log(label("Pruned", String(d.pruned)));
+          for (const e of pruneErrors)
+            console.log(error(e));
+        }
+      }, { json: opts.json });
+    } catch (e) {
+      spinner?.stop();
+      fail(e instanceof Error ? e.message : String(e));
+    }
+  });
+}
+function collectMemoryFiles(root, indexPath) {
+  const errors2 = [];
+  const seen = new Set;
+  const files = [];
+  const indexContent = safeRead(indexPath, errors2);
+  if (indexContent === null)
+    return { files, errors: errors2 };
+  pushFile(files, seen, indexPath, indexContent, root);
+  const indexDir = dirname(indexPath);
+  for (const ref of extractMarkdownLinks(indexContent)) {
+    if (isExternal(ref))
+      continue;
+    const abs = normalize(isAbsolute(ref) ? ref : resolve2(indexDir, ref));
+    if (!abs.startsWith(root)) {
+      errors2.push(`Skipping ${ref}: outside workspace ${root}`);
+      continue;
+    }
+    if (!existsSync3(abs)) {
+      errors2.push(`Referenced file missing: ${ref}`);
+      continue;
+    }
+    const st = statSync(abs);
+    if (!st.isFile())
+      continue;
+    const content = safeRead(abs, errors2);
+    if (content === null)
+      continue;
+    pushFile(files, seen, abs, content, root);
+  }
+  return { files, errors: errors2 };
+}
+function pushFile(files, seen, abs, content, root) {
+  const key = relativeKey(abs, root);
+  if (seen.has(key))
+    return;
+  seen.add(key);
+  files.push({ path: key, content });
+}
+function relativeKey(abs, root) {
+  const rel = abs.startsWith(root) ? abs.slice(root.length) : abs;
+  return rel.replace(/^\/+/, "");
+}
+function safeRead(path2, errors2) {
+  try {
+    return readFileSync2(path2, "utf-8");
+  } catch (e) {
+    errors2.push(`Failed to read ${path2}: ${e instanceof Error ? e.message : String(e)}`);
+    return null;
+  }
+}
+function extractMarkdownLinks(md) {
+  const out = [];
+  const re = /\[[^\]]*\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g;
+  let m;
+  while ((m = re.exec(md)) !== null) {
+    const target = m[1].split("#")[0];
+    if (target)
+      out.push(target);
+  }
+  return out;
+}
+function isExternal(ref) {
+  return /^[a-z][a-z0-9+.-]*:/i.test(ref) || ref.startsWith("//");
+}
+async function fetchAllMemoryFiles(auth) {
+  const all = [];
+  let offset = 0;
+  const limit = 100;
+  for (;; ) {
+    const data = await amikoWebFetch(auth, "/api/memory-files", {
+      query: { limit: String(limit), offset: String(offset) }
+    });
+    all.push(...data.items ?? []);
+    if (!data.has_more || !data.items?.length)
+      break;
+    offset += data.items.length;
+  }
+  return all;
+}
+
 // src/commands/wallets.ts
 function formatBalance(b) {
   const n = Number(b.amount) / 10 ** b.decimals;
@@ -22217,4 +22596,5 @@ registerReviewCommand(review);
 registerComposioCommand(composio);
 registerConversationCommand(conversation);
 registerNotificationsCommand(notifications);
+registerMemoryCommand(program2);
 program2.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heyamiko/amiko-cli",
-  "version": "0.9.7",
+  "version": "0.9.9-beta.1",
   "description": "Amiko CLI — swap tokens, manage credits, bridge cross-chain, and call marketplace agents",
   "type": "module",
   "bin": {

package/skills/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: amiko-cli
-description: The Amiko CLI lets an agent act on the Amiko platform end-to-end — manage Solana/Base wallets (create, swap via Jupiter, bridge USDC via Across, transfer tokens to external addresses), top up and spend credits, call paid MPP marketplace services (X/Twitter search, image generation, Amazon product search, TTS/STT, AI chat, SFX/music), manage the twin's identity and RAG documents, voice and avatar, social graph (friends, posts, comments, feed), and Composio OAuth connections. Auth is automatic when run from the agent's workspace folder; payments are platform-custodied (no keys on disk). Use this skill whenever the user asks to do anything that would show up in their Amiko account or cost AMIKO/credits.
+description: The Amiko CLI lets an agent act on the Amiko platform end-to-end — read and send platform DMs with other users (conversations list/find/read/send, the right tool when the owner asks "did X message me?" or "check my chat history with Y" — NOT the built-in sessions_list/sessions_history, which only see the agent's own local sessions), read platform notifications (friend requests, mentions, system alerts), manage Solana/Base wallets (create, swap via Jupiter, bridge USDC via Across, transfer tokens to external addresses), top up and spend credits, call paid MPP marketplace services (X/Twitter search, image generation, Amazon product search, TTS/STT, AI chat, SFX/music), manage the twin's identity and RAG documents, voice and avatar, social graph (friends, posts, comments, feed), and Composio OAuth connections. Auth is automatic when run from the agent's workspace folder; payments are platform-custodied (no keys on disk). Use this skill whenever the user asks about their Amiko inbox/DMs/notifications or to do anything that would show up in their Amiko account or cost AMIKO/credits.
 homepage: https://platform.heyamiko.com
 metadata: {"openclaw":{"emoji":"🤖","requires":{"bins":["node"]}}}
 ---
@@ -264,6 +264,10 @@ amiko review reject <commentId> --yes           # destructive — delete a draft
 
 ## Conversations
 
+> **Default platform = Amiko.** When the owner asks about messages, DMs, chats, notifications, or "anything new" **without naming a platform** (no "on WeChat", "on Telegram", "on Slack", etc.), assume they mean the Amiko platform and answer with `amiko conversation` / `amiko notifications`. Do **not** ask "which platform?" — just use the Amiko CLI. Only ask for clarification if the owner explicitly mentions a non-Amiko channel or the question is genuinely ambiguous across multiple connected channels.
+>
+> **When the owner asks about chat history with another person** ("did X message me?", "check my chat with Y", "anyone DM me this week?"), use `amiko conversation` — these are platform DMs between the owner and other Amiko users, stored in amiko-web's database. Do **not** use the built-in `sessions_list` / `sessions_history` tools for this: those read the agent's *own* past chat sessions with the owner (local openclaw memory), not platform DMs with third parties, and will return nothing useful. Typical flow: `amiko users search "<name>"` → `amiko conversation find --user-id <id>` → `amiko conversation read --id <conversationId>`. To scan everyone who messaged recently, start with `amiko conversation list` (sorted by last activity) or `amiko notifications list --unread`.
+
 ```bash
 amiko conversation list                                 # all your conversations (default: active)
 amiko conversation list --archived all --limit 100      # include archived