@heyamiko/amiko-cli 0.12.0-beta.1 → 0.12.0-beta.4

package/README.md

@@ -1,4 +1,4 @@
-# @heyamiko/amiko-cli (v0.11.0-beta.3)
+# @heyamiko/amiko-cli (v0.12.0-beta.4)
 
 Manage wallets, credits, swaps, MPP marketplace services, and your Amiko twin (identity, documents, voice, avatar, friends, feed) from the terminal. Works for both human users and AI agents running on OpenClaw.
 
@@ -182,9 +182,19 @@ Modes: `image`, `video`, `tts`, `music`, `sfx` (mirrors the platform Create Stud
 
 ### How it works (and getting the result)
 
-The CLI **submits the job, then blocks and polls until it finishes** (video can take several minutes), printing the asset URL, whether you were charged, and the charge tx on success. In non-TTY environments it prints a `…still generating (Ns elapsed)` tick to stderr. `--raw` prints the full job result as JSON.
+**By default the command returns immediately** with a **job id** and `status: PENDING` — it does **not** block for the whole generation. It prints how to check the result and a rough ETA. This keeps agents/scripts from being held for 60s–9min.
 
-If the poll window elapses (10 min for video, 5 min otherwise) the CLI does **not** treat it as failure — the generation may still complete server-side. It prints the **job id**; retrieve the finished asset with either:
+```
+$ amiko create image "a whale in space" --yes
+Submitted — job aX9k…
+Status: PENDING — generating in the background
+Check result: amiko create status aX9k…
+Usually ready in ~15–60s — charged only on success.
+```
+
+Rough ETAs: image ~15–60s, video ~2–9 min, music ~30–120s, tts/sfx ~5–20s.
+
+Retrieve the finished asset with:
 
 ```bash
 amiko create status <jobId>   # re-query that job (queryable ~24h)
@@ -192,12 +202,31 @@ amiko create media            # list your recent generations (permanent)
 amiko create media --service video --limit 5
 ```
 
-- **`amiko create status <jobId>`** — re-polls the job once and prints its status / asset. Jobs stay queryable for ~24h.
+- **`amiko create status <jobId>`** — re-polls the job once; prints `PROCESSING`, or the asset + charge when done. Jobs stay queryable for ~24h.
 - **`amiko create media`** — lists your recent Create Studio generations (URL, type, model, prompt, date). `--service <type>` filters, `--limit <n>` caps (max 50), `--raw` for JSON. Use this once a job id has expired, or just to browse.
 - **Web:** `https://platform.heyamiko.com/media`
 
+**`--wait`** — if you'd rather block until it finishes and print the asset inline (e.g. an interactive terminal), pass `--wait`. It polls (10 min cap for video, 5 min otherwise) with a `…still generating (Ns)` tick; on timeout it falls back to the job-id + retrieval hint above. `--raw` prints the full job result as JSON either way.
+
 > `amiko markets image` still exists and is unchanged — it's the direct MPP pay-per-call path (pre-pay in AMIKO). Use `amiko create` for the Create Studio experience (async, charge-on-success); use `amiko markets` for raw MPP endpoints.
 
+## Chat
+
+Your conversations — **DMs and group chats** — acting **as you (the owner)**. (This is distinct from the openhermit gateway's `session_*` tools, which act as the *agent* on the agent's own sessions.)
+
+```bash
+amiko chat list                                  # all conversations (DM + group): id, peer/title, last msg, unread
+amiko chat list --limit 50 --archived            # include archived
+amiko chat read @sophie                          # recent messages with a user (by @handle)
+amiko chat read <conversationId> --limit 40      # by conversation id (from `chat list`) — works for groups too
+amiko chat send @sophie "on my way!" --yes       # send as the owner
+amiko chat send <groupConversationId> "hi all" --yes   # send to a group chat
+```
+
+- **`<target>`** for `read`/`send` is a **conversation id** (from `chat list` — use this for groups), an **`@handle`**, or a **name** (resolved via user search; if ambiguous, the CLI lists candidates instead of guessing).
+- A DM target that doesn't exist yet is **created automatically** (find-or-create).
+- `chat send` messages a real person, so it's **gated on `--yes`** in non-interactive shells. Delivery is real-time. `--raw` prints raw JSON on any subcommand.
+
 ## Amazon
 
 ```bash

package/dist/index.js

@@ -28590,6 +28590,13 @@ function registerImageCommand(program2) {
 
 // src/commands/create.ts
 var POLL_INTERVAL_MS = 3000;
+var ETA = {
+  IMAGE: "~15–60s",
+  VIDEO: "~2–9 min",
+  MUSIC: "~30–120s",
+  TTS: "~5–20s",
+  SFX: "~5–20s"
+};
 function statusOf(err) {
   return err?.status;
 }
@@ -28679,6 +28686,23 @@ async function submitAndPoll(opts) {
     console.error(error(e5 instanceof Error ? e5.message : "Submit failed"));
     process.exit(1);
   }
+  if (!opts.wait) {
+    stop();
+    if (opts.raw) {
+      console.log(JSON.stringify({
+        jobId,
+        status: "PENDING",
+        check: `amiko create status ${jobId}`,
+        eta: ETA[opts.mode]
+      }, null, 2));
+      return;
+    }
+    console.log(success(`Submitted — job ${jobId}`));
+    console.log(label("Status", "PENDING — generating in the background"));
+    console.log(label("Check result", `amiko create status ${jobId}`));
+    console.log(dim(`Usually ready in ${ETA[opts.mode]} — charged only on success. (Also: amiko create media)`));
+    return;
+  }
   setStatus("Generating…");
   startTicker();
   const maxMs = opts.mode === "VIDEO" ? 600000 : 300000;
@@ -28717,12 +28741,13 @@ async function submitAndPoll(opts) {
   printCompleted(final, `${opts.mode[0]}${opts.mode.slice(1).toLowerCase()} created`);
 }
 function registerCreateCommand(create2) {
-  create2.command("image <prompt>").description("Generate an image (Create Studio)").option("--model <model>", "Image model", "gpt-image-2").option("--aspect <ratio>", "Aspect ratio: 1:1, 16:9, 9:16, 4:3, 3:4", "1:1").option("--token <symbol>", "Preferred charge token: AMIKO, USDC, USDT, SOL").option("--raw", "Output raw JSON").option("--yes", "Skip the pre-spend confirmation (required in non-interactive shells)").action(async (prompt, opts) => {
+  create2.command("image <prompt>").description("Generate an image (Create Studio)").option("--model <model>", "Image model", "gpt-image-2").option("--aspect <ratio>", "Aspect ratio: 1:1, 16:9, 9:16, 4:3, 3:4", "1:1").option("--token <symbol>", "Preferred charge token: AMIKO, USDC, USDT, SOL").option("--raw", "Output raw JSON").option("--yes", "Skip the pre-spend confirmation (required in non-interactive shells)").option("--wait", "Block until generation finishes and print the asset (default: return a job id immediately)").action(async (prompt, opts) => {
     await submitAndPoll({
       mode: "IMAGE",
       summary: `Create image: ${prompt.slice(0, 80)}${prompt.length > 80 ? "…" : ""}`,
       raw: opts.raw,
       yes: opts.yes,
+      wait: opts.wait,
       quoteBody: { mode: "IMAGE", model: opts.model, size: opts.aspect },
       jobBody: {
         mode: "IMAGE",
@@ -28733,7 +28758,7 @@ function registerCreateCommand(create2) {
       }
     });
   });
-  create2.command("video <prompt>").description("Generate a video (Create Studio)").option("--model <model>", "Video model", "MiniMax-Hailuo-2.3-Fast").option("--resolution <res>", "512P, 720P, 768P, 1080P", "768P").option("--seconds <n>", "Clip length: 6 or 10", "6").option("--aspect <ratio>", "Aspect ratio (provider-dependent)").option("--first-frame <url>", "Image-to-video: first frame URL/data URI").option("--token <symbol>", "Preferred charge token: AMIKO, USDC, USDT, SOL").option("--raw", "Output raw JSON").option("--yes", "Skip the pre-spend confirmation (required in non-interactive shells)").action(async (prompt, opts) => {
+  create2.command("video <prompt>").description("Generate a video (Create Studio)").option("--model <model>", "Video model", "MiniMax-Hailuo-2.3-Fast").option("--resolution <res>", "512P, 720P, 768P, 1080P", "768P").option("--seconds <n>", "Clip length: 6 or 10", "6").option("--aspect <ratio>", "Aspect ratio (provider-dependent)").option("--first-frame <url>", "Image-to-video: first frame URL/data URI").option("--token <symbol>", "Preferred charge token: AMIKO, USDC, USDT, SOL").option("--raw", "Output raw JSON").option("--yes", "Skip the pre-spend confirmation (required in non-interactive shells)").option("--wait", "Block until generation finishes and print the asset (default: return a job id immediately)").action(async (prompt, opts) => {
     const seconds = Number(opts.seconds);
     if (seconds !== 6 && seconds !== 10) {
       console.error(error("--seconds must be 6 or 10."));
@@ -28744,6 +28769,7 @@ function registerCreateCommand(create2) {
       summary: `Create video: ${prompt.slice(0, 80)}${prompt.length > 80 ? "…" : ""}`,
       raw: opts.raw,
       yes: opts.yes,
+      wait: opts.wait,
       quoteBody: {
         mode: "VIDEO",
         model: opts.model,
@@ -28762,12 +28788,13 @@ function registerCreateCommand(create2) {
       }
     });
   });
-  create2.command("tts <text>").description("Generate speech from text (Create Studio)").option("--model <model>", "TTS model id", "eleven_multilingual_v2").option("--voice <voiceId>", "Voice id", "21m00Tcm4TlvDq8ikWAM").option("--token <symbol>", "Preferred charge token: AMIKO, USDC, USDT, SOL").option("--raw", "Output raw JSON").option("--yes", "Skip the pre-spend confirmation (required in non-interactive shells)").action(async (text, opts) => {
+  create2.command("tts <text>").description("Generate speech from text (Create Studio)").option("--model <model>", "TTS model id", "eleven_multilingual_v2").option("--voice <voiceId>", "Voice id", "21m00Tcm4TlvDq8ikWAM").option("--token <symbol>", "Preferred charge token: AMIKO, USDC, USDT, SOL").option("--raw", "Output raw JSON").option("--yes", "Skip the pre-spend confirmation (required in non-interactive shells)").option("--wait", "Block until generation finishes and print the asset (default: return a job id immediately)").action(async (text, opts) => {
     await submitAndPoll({
       mode: "TTS",
       summary: `Create speech: ${text.slice(0, 80)}${text.length > 80 ? "…" : ""}`,
       raw: opts.raw,
       yes: opts.yes,
+      wait: opts.wait,
       quoteBody: { mode: "TTS", model: opts.model, prompt: text },
       jobBody: {
         mode: "TTS",
@@ -28778,7 +28805,7 @@ function registerCreateCommand(create2) {
       }
     });
   });
-  create2.command("music [prompt]").description("Generate music (Create Studio)").option("--model <model>", "music_v1, music-2.6, music-cover", "music-2.6").option("--lyrics <lyrics>", "Lyrics (optional)").option("--duration <ms>", "Length in ms").option("--instrumental", "Instrumental (no vocals)").option("--token <symbol>", "Preferred charge token: AMIKO, USDC, USDT, SOL").option("--raw", "Output raw JSON").option("--yes", "Skip the pre-spend confirmation (required in non-interactive shells)").action(async (prompt, opts) => {
+  create2.command("music [prompt]").description("Generate music (Create Studio)").option("--model <model>", "music_v1, music-2.6, music-cover", "music-2.6").option("--lyrics <lyrics>", "Lyrics (optional)").option("--duration <ms>", "Length in ms").option("--instrumental", "Instrumental (no vocals)").option("--token <symbol>", "Preferred charge token: AMIKO, USDC, USDT, SOL").option("--raw", "Output raw JSON").option("--yes", "Skip the pre-spend confirmation (required in non-interactive shells)").option("--wait", "Block until generation finishes and print the asset (default: return a job id immediately)").action(async (prompt, opts) => {
     if (!prompt && !opts.lyrics) {
       console.error(error("Provide a prompt or --lyrics."));
       process.exit(1);
@@ -28788,6 +28815,7 @@ function registerCreateCommand(create2) {
       summary: `Create music: ${(prompt ?? opts.lyrics ?? "").slice(0, 80)}`,
       raw: opts.raw,
       yes: opts.yes,
+      wait: opts.wait,
       quoteBody: { mode: "MUSIC", model: opts.model },
       jobBody: {
         mode: "MUSIC",
@@ -28800,12 +28828,13 @@ function registerCreateCommand(create2) {
       }
     });
   });
-  create2.command("sfx <text>").description("Generate a sound effect (Create Studio)").option("--duration <seconds>", "Clip length in seconds").option("--token <symbol>", "Preferred charge token: AMIKO, USDC, USDT, SOL").option("--raw", "Output raw JSON").option("--yes", "Skip the pre-spend confirmation (required in non-interactive shells)").action(async (text, opts) => {
+  create2.command("sfx <text>").description("Generate a sound effect (Create Studio)").option("--duration <seconds>", "Clip length in seconds").option("--token <symbol>", "Preferred charge token: AMIKO, USDC, USDT, SOL").option("--raw", "Output raw JSON").option("--yes", "Skip the pre-spend confirmation (required in non-interactive shells)").option("--wait", "Block until generation finishes and print the asset (default: return a job id immediately)").action(async (text, opts) => {
     await submitAndPoll({
       mode: "SFX",
       summary: `Create SFX: ${text.slice(0, 80)}${text.length > 80 ? "…" : ""}`,
       raw: opts.raw,
       yes: opts.yes,
+      wait: opts.wait,
       quoteBody: { mode: "SFX" },
       jobBody: {
         mode: "SFX",
@@ -28895,6 +28924,166 @@ More available — raise --limit to see more.`));
   });
 }
 
+// src/commands/chat.ts
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function authOrExit() {
+  try {
+    return requireAuth();
+  } catch (e5) {
+    console.error(error(e5 instanceof Error ? e5.message : "auth failed"));
+    process.exit(1);
+  }
+}
+function convLabel(conv, selfUserId) {
+  if (conv.title)
+    return conv.title;
+  const others = (conv.participants ?? []).filter((p) => !(p.participant_type === "user" && p.participant_id === selfUserId)).map((p) => p.user?.name ?? p.twin?.name ?? p.participant_id.slice(0, 8)).filter((n) => !!n);
+  return others.length ? others.join(", ") : "(conversation)";
+}
+async function findOrCreateDm(auth, userId) {
+  const data = await amikoWebFetch(auth, "/api/conversations", {
+    method: "POST",
+    body: {
+      participant_ids: [userId],
+      participant_types: ["user"],
+      conversation_type: "direct"
+    },
+    timeoutMs: 20000
+  });
+  const id = data.conversation?.id;
+  if (!id)
+    throw new Error("Could not open a conversation with that user.");
+  return id;
+}
+async function resolveConversation(auth, target) {
+  const t = target.trim();
+  if (UUID_RE.test(t))
+    return t;
+  if (t.startsWith("@")) {
+    const handle = t.slice(1);
+    const prof = await amikoWebFetch(auth, `/api/users/${encodeURIComponent(handle)}`, { timeoutMs: 15000 });
+    if (!prof.user?.id)
+      throw new Error(`No user @${handle}.`);
+    return findOrCreateDm(auth, prof.user.id);
+  }
+  const res = await amikoWebFetch(auth, "/api/search", {
+    query: { q: t, type: "people", limit: 8 },
+    timeoutMs: 15000
+  });
+  const users = res.users ?? [];
+  if (users.length === 0) {
+    throw new Error(`No user matching "${t}". Use an exact @handle, or a conversation id from \`amiko chat list\`.`);
+  }
+  if (users.length > 1) {
+    const names = users.map((u) => `${u.name ?? "?"} (@${u.handle ?? u.id.slice(0, 8)})`).join(", ");
+    throw new Error(`"${t}" is ambiguous — matches: ${names}. Use an exact @handle or a conversation id.`);
+  }
+  return findOrCreateDm(auth, users[0].id);
+}
+function registerChatCommand(chat) {
+  chat.command("list").description("List your conversations (DMs and group chats)").option("--limit <n>", "Max conversations", "30").option("--archived", "Include archived conversations").option("--raw", "Output raw JSON").action(async (opts) => {
+    const auth = authOrExit();
+    let data;
+    try {
+      data = await amikoWebFetch(auth, "/api/conversations", {
+        query: {
+          limit: opts.limit,
+          ...opts.archived ? { archived: "all" } : {}
+        },
+        timeoutMs: 20000
+      });
+    } catch (e5) {
+      console.error(error(e5 instanceof Error ? e5.message : "Failed to list conversations"));
+      process.exit(1);
+    }
+    if (opts.raw) {
+      console.log(JSON.stringify(data, null, 2));
+      return;
+    }
+    const convs = data.conversations ?? [];
+    if (convs.length === 0) {
+      console.log(dim("No conversations."));
+      return;
+    }
+    console.log(heading(`Conversations (${convs.length})
+`));
+    for (const c of convs) {
+      const kind = c.conversation_type === "direct" ? "DM" : c.conversation_type;
+      const unread = c.unread_count ? `  (${c.unread_count} unread)` : "";
+      console.log(label(`[${kind}] ${convLabel(c, auth.userId)}`, dim(c.id)));
+      if (c.last_message?.content) {
+        const who = c.last_message.name ? `${c.last_message.name}: ` : "";
+        console.log(dim(`  ${who}${c.last_message.content.slice(0, 80)}`));
+      }
+      if (unread)
+        console.log(dim(` ${unread.trim()}`));
+    }
+  });
+  chat.command("read <target>").description("Read recent messages in a conversation (conversation id, @handle, or name)").option("--limit <n>", "Max messages", "20").option("--raw", "Output raw JSON").action(async (target, opts) => {
+    const auth = authOrExit();
+    let convId;
+    try {
+      convId = await resolveConversation(auth, target);
+    } catch (e5) {
+      console.error(error(e5 instanceof Error ? e5.message : "Could not resolve target"));
+      process.exit(1);
+    }
+    let data;
+    try {
+      data = await amikoWebFetch(auth, `/api/conversations/${encodeURIComponent(convId)}/messages`, { query: { limit: opts.limit }, timeoutMs: 20000 });
+    } catch (e5) {
+      console.error(error(e5 instanceof Error ? e5.message : "Failed to read messages"));
+      process.exit(1);
+    }
+    if (opts.raw) {
+      console.log(JSON.stringify(data, null, 2));
+      return;
+    }
+    const msgs = (data.messages ?? []).slice().reverse();
+    if (msgs.length === 0) {
+      console.log(dim("No messages."));
+      return;
+    }
+    console.log(heading(`Messages (${msgs.length})
+`));
+    for (const m of msgs) {
+      const who = m.sender?.name ?? m.name ?? (m.sender_id ? m.sender_id.slice(0, 8) : "?");
+      const when = m.created_at ? m.created_at.slice(0, 19).replace("T", " ") : "";
+      console.log(label(who, m.content));
+      if (when)
+        console.log(dim(`  ${when}`));
+    }
+  });
+  chat.command("send <target> <message>").description("Send a message as yourself (the owner) to a conversation (id, @handle, or name)").option("--yes", "Skip the confirmation (required in non-interactive shells)").option("--raw", "Output raw JSON").action(async (target, message, opts) => {
+    const auth = authOrExit();
+    let convId;
+    try {
+      convId = await resolveConversation(auth, target);
+    } catch (e5) {
+      console.error(error(e5 instanceof Error ? e5.message : "Could not resolve target"));
+      process.exit(1);
+    }
+    await requireApproval({
+      cost: "no charge — sends a message as you (the owner)",
+      summary: `Send to ${target}: ${message.slice(0, 80)}${message.length > 80 ? "…" : ""}`,
+      yes: opts.yes,
+      commandExample: `amiko chat send ${JSON.stringify(target)} ${JSON.stringify(message)}`
+    });
+    let data;
+    try {
+      data = await amikoWebFetch(auth, `/api/conversations/${encodeURIComponent(convId)}/messages`, { method: "POST", body: { content: message }, timeoutMs: 20000 });
+    } catch (e5) {
+      console.error(error(e5 instanceof Error ? e5.message : "Send failed"));
+      process.exit(1);
+    }
+    if (opts.raw) {
+      console.log(JSON.stringify(data, null, 2));
+      return;
+    }
+    console.log(success("Message sent") + dim(` (conversation ${convId.slice(0, 8)}…)`));
+  });
+}
+
 // src/commands/amazon.ts
 var TREASURY3 = "FPiZAf3jEnNfCwfvbv46jdPfHbmSepD4Q6iHiLJDQXvb";
 async function payAmiko(auth, wallet, amount2) {
@@ -30963,7 +31152,7 @@ var MAX_IMAGE_BYTES = 5 * 1024 * 1024;
 async function uploadPostMedia(auth, source) {
   const file2 = await resolveFileInput(source);
   if (!ALLOWED_IMAGE_TYPES.includes(file2.mime)) {
-    throw new Error(`"${source}" is not a supported image (detected ${file2.mime}). Allowed: JPEG, PNG, WebP, GIF.`);
+    throw new Error(`"${source}" is not a supported image (detected ${file2.mime}). Local file upload allows only JPEG, PNG, WebP, GIF. For audio/video, pass an Amiko-hosted URL (e.g. from \`amiko create\`) instead of a local file — local audio/video upload isn't supported yet.`);
   }
   if (file2.size > MAX_IMAGE_BYTES) {
     throw new Error(`"${source}" is ${file2.size} bytes; exceeds the 5 MB post-image limit.`);
@@ -30976,12 +31165,12 @@ async function uploadPostMedia(auth, source) {
   }
   return res.url;
 }
-var POST_MEDIA_PATH = "/storage/v1/object/public/post-media/";
-function isPostMediaUrl(value) {
+var AMIKO_PUBLIC_STORAGE_PATH = "/storage/v1/object/public/";
+function isAmikoMediaUrl(value) {
   if (!URL.canParse(value))
     return false;
   const parsed = new URL(value);
-  return parsed.protocol === "https:" && parsed.pathname.startsWith(POST_MEDIA_PATH);
+  return parsed.protocol === "https:" && parsed.pathname.startsWith(AMIKO_PUBLIC_STORAGE_PATH);
 }
 async function resolveMediaUrls(auth, inputs) {
   const resolved = [];
@@ -30990,10 +31179,10 @@ async function resolveMediaUrls(auth, inputs) {
     if (trimmed.length === 0)
       continue;
     if (/^https?:\/\//i.test(trimmed)) {
-      if (isPostMediaUrl(trimmed)) {
+      if (isAmikoMediaUrl(trimmed)) {
         resolved.push(trimmed);
       } else {
-        throw new Error(`"${trimmed}" is not an Amiko post-image URL. To attach an image, pass its LOCAL FILE PATH to --media (it is uploaded to post storage automatically) — do not pass a drive/docs URL (private bucket → broken image) or any other link.`);
+        throw new Error(`"${trimmed}" is not an Amiko-hosted media URL. Attach either a local IMAGE file path, or an Amiko public storage URL — e.g. an image/music/video URL from \`amiko create\` (run \`amiko create status <jobId>\` to get it). Drive/docs URLs (private bucket → broken media) and other hosts are not accepted.`);
       }
     } else {
       resolved.push(await uploadPostMedia(auth, trimmed));
@@ -31049,7 +31238,7 @@ function registerFeedCommand(program2) {
   });
 }
 function registerPostCommand(program2) {
-  program2.command("create").description("Create a post on your feed").requiredOption("--content <text>", "Post body (required, non-empty)").option("--visibility <public|private>", "Post visibility", "public").option("--media <pathOrUrl...>", "One or more images: local file paths (uploaded to Amiko storage automatically) or https URLs").option("--json", "Output as JSON").action(async (opts) => {
+  program2.command("create").description("Create a post on your feed").requiredOption("--content <text>", "Post body (required, non-empty)").option("--visibility <public|private>", "Post visibility", "public").option("--media <pathOrUrl...>", "Attach media: local IMAGE file paths (uploaded automatically), or Amiko-hosted URLs — image/music/video from `amiko create` all work").option("--json", "Output as JSON").action(async (opts) => {
     const auth = resolveAuth();
     const visibility = opts.visibility === "private" ? "private" : "public";
     const spinner = opts.json ? null : ora("Publishing post...").start();
@@ -31121,7 +31310,7 @@ function registerPostCommand(program2) {
       process.exit(1);
     }
   });
-  program2.command("comment").description("Comment on a post").requiredOption("--id <postId>", "Target post id").requiredOption("--comment <text>", "Comment body").option("--media <pathOrUrl...>", "One or more images to attach: local file paths (uploaded to Amiko storage automatically) or https URLs").option("--twin <idOrName>", "Post as this twin (agent mode)").option("--json", "Output as JSON").action(async (opts) => {
+  program2.command("comment").description("Comment on a post").requiredOption("--id <postId>", "Target post id").requiredOption("--comment <text>", "Comment body").option("--media <pathOrUrl...>", "Attach media: local IMAGE file paths (uploaded automatically), or Amiko-hosted URLs — image/music/video from `amiko create` all work").option("--twin <idOrName>", "Post as this twin (agent mode)").option("--json", "Output as JSON").action(async (opts) => {
     const config2 = loadConfig();
     const auth = resolveAuth();
     let twinId;
@@ -31777,6 +31966,7 @@ var program2 = new Command;
 program2.name("amiko").description("Amiko CLI — swap tokens, manage credits, bridge cross-chain, and call marketplace services").version(PKG_VERSION);
 var markets = program2.command("markets").description("MPP marketplace — discover and call paid AMIKO services");
 var create2 = program2.command("create").description("Create Studio — generate images, video, speech, music, and SFX (charged on success)");
+var chat = program2.command("chat").description("Your conversations (DMs + group chats) as the owner — list, read, send");
 var wallets = program2.command("wallets").description("Manage twin wallets — list, swap, bridge");
 var twin = program2.command("twin").description("Update twin identity (name, description, visibility)");
 var drive = program2.command("drive").alias("docs").description("Manage twin drive — upload/download/search files, organise into folders");
@@ -31791,6 +31981,7 @@ registerCreditsCommand(program2);
 registerSearchCommand(markets);
 registerImageCommand(markets);
 registerCreateCommand(create2);
+registerChatCommand(chat);
 registerAmazonCommand(markets);
 registerWalletsCreateCommand(wallets);
 registerWalletsListCommand(wallets);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heyamiko/amiko-cli",
-  "version": "0.12.0-beta.1",
+  "version": "0.12.0-beta.4",
   "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 — read platform notifications (friend requests, mentions, system alerts), search and write **cross-agent memories** about the owner (what other agents already know — preferences, decisions, facts), 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 drive (files, folders, RAG), voice and avatar, and social graph (friends, posts, comments, feed). Auth is automatic when run from the agent's workspace folder; payments are platform-custodied (no keys on disk). DMs / chat sessions are NOT in this CLI — use the openhermit gateway's built-in session_list / session_read tools for both local sessions and platform DMs. Use this skill whenever the user asks about their Amiko notifications, drive, memory, social graph, wallets, credits, or marketplace services — 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 platform notifications (friend requests, mentions, system alerts), search and write **cross-agent memories** about the owner (what other agents already know — preferences, decisions, facts), manage Solana/Base wallets (create, swap via Jupiter, bridge USDC via Across, transfer tokens to external addresses), top up and spend credits, generate media — images, video, speech, music, and SFX — via Create Studio (`amiko create`, async and charged on success), call paid MPP marketplace services (X/Twitter search, Amazon product search, TTS/STT, AI chat), manage the twin's identity and drive (files, folders, RAG), voice and avatar, and social graph (friends, posts, comments, feed). Auth is automatic when run from the agent's workspace folder; payments are platform-custodied (no keys on disk). The owner's DMs and group chats are `amiko chat` (list / read / send AS the owner, 人对人); the agent's OWN sessions are the openhermit gateway's session_list / session_send (AS the agent) — different identities, different surfaces. Use this skill whenever the user asks about their Amiko notifications, chats/DMs, drive, memory, social graph, wallets, credits, or marketplace services — anything that would show up in their Amiko account or cost AMIKO/credits.
 homepage: https://platform.heyamiko.com
 metadata: {"openclaw":{"emoji":"🤖","requires":{"bins":["node"]}}}
 ---
@@ -22,6 +22,9 @@ Call your shell tool (your runtime calls it `bash`, `shell`, `run`, or similar)
 | "swap 1 SOL to USDC" | shell → `amiko wallets swap quote 1 SOL USDC` (then send with `--yes` after approval) |
 | "any notifications?" | shell → `amiko notifications list --unread` |
 | "any new posts I haven't seen?" | shell → `amiko feed --unread` |
+| "make an image of a whale in space" | shell → `amiko create image "a whale in space" --yes` (quote cost first) |
+| "generate a lo-fi track" | shell → `amiko create music "lo-fi chill beat" --yes` (quote cost first) |
+| "show my recent creations" | shell → `amiko create media` |
 | "upload report.pdf to my drive" | shell → `amiko drive upload ./report.pdf` |
 | "download the file with id X" | shell → `amiko drive download X` |
 | "find files about Q1 revenue" | shell → `amiko drive search "Q1 revenue"` |
@@ -38,13 +41,13 @@ The CLI is installed globally and is pre-authenticated when you're inside your w
 
 ## Command groups
 
-Discover everything via `amiko --help`. Groups: `markets` (paid MPP services), `create` (Create Studio — async media generation, charged on success), `wallets`, `credits`, `twin`, `drive` (files / folders / RAG; `docs` is an alias), `voice`, `avatar`, `friends`, `users`, `post`, `review`, `feed`, `notifications`, `memory`, plus the top-level `accounts`, `info`, `config`, `update`. All twin-scoped commands accept `--twin <id>`. Most commands support `--json`.
+Discover everything via `amiko --help`. Groups: `markets` (paid MPP services), `create` (Create Studio — async media generation, charged on success), `chat` (owner's DMs + group chats), `wallets`, `credits`, `twin`, `drive` (files / folders / RAG; `docs` is an alias), `voice`, `avatar`, `friends`, `users`, `post`, `review`, `feed`, `notifications`, `memory`, plus the top-level `accounts`, `info`, `config`, `update`. All twin-scoped commands accept `--twin <id>`. Most commands support `--json`.
 
-> **DMs / chat sessions are NOT in this CLI.** Use the openhermit gateway's built-in `session_list` / `session_read` tools for both the agent's local sessions and platform DMs with other users. The previous `amiko conversation` namespace was removed in 0.10.1-beta.4.
+> **Two chat surfaces — pick by identity.** `amiko chat` is the **owner's** DMs and group chats, acting **as the owner** (list / read / send). The openhermit gateway's `session_list` / `session_send` are the **agent's own** sessions, acting **as the agent**. "Send a message to Sophie for me" → `amiko chat send`; "have the twin reply as itself" → gateway. (The old `amiko conversation` namespace was removed in 0.10.1-beta.4; `amiko chat` is its owner-identity replacement.)
 
 ## Critical Rules
 
-1. **Every paid / value-moving command is hard-gated on `--yes` in a non-interactive shell.** The CLI refuses to run `markets *`, `create *`, `credits topup`, `wallets swap send`, `wallets bridge send`, `wallets transfer` (and destructive ops like `twin update --public`, `drive delete`, `friends remove`, `friends reports request`, `avatar update`, `voice reset`, `review reject`) unless `--yes` is passed. The refusal prints the cost and the re-run command. **Quote the cost, get explicit approval, THEN append `--yes`.**
+1. **Every paid / value-moving command is hard-gated on `--yes` in a non-interactive shell.** The CLI refuses to run `markets *`, `create *`, `chat send`, `credits topup`, `wallets swap send`, `wallets bridge send`, `wallets transfer` (and destructive ops like `twin update --public`, `drive delete`, `friends remove`, `friends reports request`, `avatar update`, `voice reset`, `review reject`) unless `--yes` is passed. The refusal prints the cost and the re-run command. **Quote the cost, get explicit approval, THEN append `--yes`.**
 2. **After every paid command, report the remaining balance.** The CLI prints a `Balance: N credits` line — include that figure in your reply.
 3. **Never retry a failed command.** Report and stop. Every paid call costs tokens even on failure.
 4. **Auth is automatic.** Never suggest `amiko login` / `amiko connect`. Run from the agent's workspace folder; if anything looks off, `amiko accounts` shows the resolved `userId` / `twinId`.
@@ -87,9 +90,20 @@ Supported: AMIKO, SOL, USDC, USDT. Balance can lag a few seconds after topup —
 
 All paid markets commands auto-select the twin's active Solana wallet (see `--wallet` default above). Audio and image endpoints return permanent Supabase Storage URLs. Use `markets service call <METHOD> <path> [body]` for any MPP endpoint not covered by a dedicated subcommand.
 
+**Prefer `amiko create` for anything it supports.** For media generation — image, video, speech (TTS), music, SFX — use `amiko create` (async, charge-on-success, never loses money on a timeout), NOT `markets`. Reach for `markets` **only for what `create` does not cover**: X/Twitter search, Amazon, AI chat, speech-to-text/transcription, and arbitrary MPP endpoints via `markets service call`.
+
 ## Create Studio — behavior notes
 
-`amiko create <image|video|tts|music|sfx>` is the CLI half of the platform Create Studio. It generates through Amiko's own authenticated endpoints (not raw MPP), runs **async**, and is **charged on success** from the twin's custodial wallet — a failed or timed-out generation is **never billed**, and there is no pre-pay. The CLI submits then polls until done (video can take minutes); on a poll timeout it prints the **job id** and does NOT fail — the asset may still finish server-side. Retrieve it with `amiko create status <jobId>` (re-query that job, ~24h) or `amiko create media` (list recent generations; `--service`/`--limit`/`--raw`). Result is a permanent Supabase Storage URL. `--token <AMIKO|USDC|USDT|SOL>` selects the charge token (default auto, AMIKO-first). Prefer `create` over `markets image` for media generation — it doesn't lose money on timeouts. `markets image` remains the raw MPP pre-pay path.
+`amiko create <image|video|tts|music|sfx>` is the CLI half of the platform Create Studio. It generates through Amiko's own authenticated endpoints (not raw MPP), runs **async**, and is **charged on success** from the twin's custodial wallet — a failed or timed-out generation is **never billed**, and there is no pre-pay. **The command returns immediately** with a `jobId` and `status: PENDING` — it does NOT block for the whole generation (so you're not held for 60s–9min). It prints how to check + a rough ETA. **Poll for the result** with `amiko create status <jobId>` (re-query that job, ~24h) — wait roughly: image ~15–60s, video ~2–9min, music ~30–120s, tts/sfx ~5–20s. Or `amiko create media` (list recent generations; `--service`/`--limit`/`--raw`). Result is a permanent Supabase Storage URL. (Pass `--wait` only if you deliberately want the command to block until done.) `--token <AMIKO|USDC|USDT|SOL>` selects the charge token (default auto, AMIKO-first). Prefer `create` over `markets image` for media generation — it doesn't lose money on timeouts. `markets image` remains the raw MPP pre-pay path.
+
+## Chat — behavior notes
+
+`amiko chat` is the **owner's** conversations, acting **as the owner** (人对人) — NOT the agent's own sessions (those are the gateway's `session_*`, as the agent).
+
+- `amiko chat list` — all conversations, **DMs and group chats** (id, type, peer/title, last message, unread).
+- `amiko chat read <target>` — recent messages. `<target>` = a conversation id (from `list`), an `@handle`, or a name.
+- `amiko chat send <target> "message"` — send **as the owner**. Delivered in real time. `--yes` required in non-interactive shells (it's an outward message to a real person). For **group chats**, use the conversation id from `list`; for a **DM**, an `@handle`/name resolves + finds-or-creates the DM.
+- Name resolution goes through user search; if ambiguous it lists candidates — don't blind-send. Server enforces who you're allowed to message (friend/participant rules); surface its error, don't retry.
 
 ## Drive (files & folders)
 
@@ -128,47 +142,10 @@ Workflow: start with `friends matches --limit 20 --json`; narrow with `--dimensi
 
 > **Default platform = Amiko.** When the owner asks about notifications **without naming a platform**, assume Amiko and answer with `amiko notifications`. Only ask if they explicitly mention a non-Amiko channel.
 >
-> **DMs / chat history are handled by the openhermit gateway**, not the CLI. For "did X message me?" / "check my chat with Y", use the built-in `session_list` / `session_read` tools — they cover both the agent's local sessions and platform DMs in the unified gateway view.
+> **Owner DMs / group chats: `amiko chat`.** For "did X message me?" / "what did Sophie and I say?" / "message Y for me", use `amiko chat list` / `amiko chat read <who>` / `amiko chat send <who> "…"` — these act **as the owner** (人对人). The gateway's `session_*` tools are the **agent's own** sessions (as the agent), a separate surface (see Chat behavior notes).
 
 Platform notifications cover friend requests, mentions, system alerts, and post-related events.
 
-## Memory (cross-agent) — READ THIS BEFORE ANSWERING ANYTHING ABOUT THE OWNER
-
-Memories are scoped to the **owner's `user_id`**, not your agent — every agent the owner runs reads and writes the same pool. Your local `memory/` folder is one input; the platform is the source of truth across sessions and agents.
-
-**Two non-negotiable habits:**
-
-1. **Search before you answer.** Run `amiko memory search "<query>"` **every time** the owner asks anything about themselves, their work, or their history — *before* composing a reply. Another agent may have written a memory you've never seen. A miss costs ~100ms; an amnesic answer costs trust.
-2. **Upload changed files.** If you keep memory in local files (e.g. `MEMORY.md`, `memory/*.md`), upload them with `amiko memory upload <file...>` after meaningful edits. The server extracts memories from each file; default path key is the basename. No bulk-walking — pass the exact files you want to push.
-
-### When to search — bias toward calling
-
-The single most common failure mode is NOT calling `memory search` on abstract self-referential questions. If the owner's message has any of these shapes, you MUST search — no judgment, no exceptions:
-
-1. **Preference / habit questions**, even without a specific entity. "what do I usually use for X", "what's my coding style".
-2. **Callbacks to prior context.** "as I mentioned", "like last time", "what was that X we set up".
-3. **Named entities specific to this owner** — their project / repo / service / team / tool / a person by name.
-4. **Past bugs, decisions, investigations, design choices.**
-5. **Start of a new session** where they reference anything about themselves or their work.
-
-Do NOT search for purely textbook programming questions, or things the current code / `git log` answers directly.
-
-**When unsure, search.** Empty results cost nothing. Missing context costs trust.
-
-### When to save (`amiko memory add`)
-
-- Fixing a non-obvious bug → `pattern` or `fact`
-- Architecture decision → `decision`
-- Useful pattern or workaround → `pattern`
-- "Remember this" / "save this" / "from now on..." → match category to content
-- Preference you'd otherwise re-ask ("I prefer rg", "I always use pnpm") → `preference`
-
-Write memories as **standalone sentences with full context** — include names, not pronouns. Bad: "He prefers it that way." Good: "William prefers terse PR descriptions in the Amiko-Layer repo."
-
-Categories: `fact` | `preference` | `pattern` | `decision` | `context`.
-
-Do NOT save trivial code-derivable facts, ephemeral `git log` state, or duplicates (search first; `rm` near-matches before adding).
-
 ## Where to run
 
 **Each agent must run `amiko` from inside its own workspace directory.** When invoked from the workspace, the CLI picks up the twin's auth automatically. Run from the wrong folder and you'll act on the wrong twin or fail auth. Before the first call in a session, `cd` into the workspace. `amiko accounts` confirms the resolved scope.