claudemesh-cli 1.2.1 → 1.3.0

package/dist/entrypoints/cli.js

@@ -88,7 +88,7 @@ __export(exports_urls, {
   VERSION: () => VERSION,
   URLS: () => URLS
 });
-var URLS, VERSION = "1.2.1", env;
+var URLS, VERSION = "1.3.0", env;
 var init_urls = __esm(() => {
   URLS = {
     BROKER: process.env.CLAUDEMESH_BROKER_URL ?? "wss://ic.claudemesh.com/ws",
@@ -9638,6 +9638,766 @@ var init_grants = __esm(() => {
   GRANT_FILE = join11(homedir10(), ".claudemesh", "grants.json");
 });
 
+// src/commands/platform-actions.ts
+var exports_platform_actions = {};
+__export(exports_platform_actions, {
+  runWebhookList: () => runWebhookList,
+  runWebhookDelete: () => runWebhookDelete,
+  runWatchList: () => runWatchList,
+  runVectorStore: () => runVectorStore,
+  runVectorSearch: () => runVectorSearch,
+  runVectorDelete: () => runVectorDelete,
+  runVectorCollections: () => runVectorCollections,
+  runVaultList: () => runVaultList,
+  runVaultDelete: () => runVaultDelete,
+  runUnwatch: () => runUnwatch,
+  runTaskList: () => runTaskList,
+  runTaskCreate: () => runTaskCreate,
+  runStreamPublish: () => runStreamPublish,
+  runStreamList: () => runStreamList,
+  runStreamCreate: () => runStreamCreate,
+  runSqlSchema: () => runSqlSchema,
+  runSqlQuery: () => runSqlQuery,
+  runSqlExecute: () => runSqlExecute,
+  runSkillRemove: () => runSkillRemove,
+  runSkillList: () => runSkillList,
+  runSkillGet: () => runSkillGet,
+  runMeshMcpList: () => runMeshMcpList,
+  runMeshMcpCatalog: () => runMeshMcpCatalog,
+  runMeshMcpCall: () => runMeshMcpCall,
+  runGraphQuery: () => runGraphQuery,
+  runGraphExecute: () => runGraphExecute,
+  runFileStatus: () => runFileStatus,
+  runFileList: () => runFileList,
+  runFileDelete: () => runFileDelete,
+  runContextShare: () => runContextShare,
+  runContextList: () => runContextList,
+  runContextGet: () => runContextGet,
+  runClockSet: () => runClockSet,
+  runClockResume: () => runClockResume,
+  runClockPause: () => runClockPause
+});
+function emitJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+async function runVectorStore(collection, text, opts) {
+  if (!collection || !text) {
+    render.err("Usage: claudemesh vector store <collection> <text> [--metadata <json>]");
+    return EXIT.INVALID_ARGS;
+  }
+  let metadata;
+  if (opts.metadata) {
+    try {
+      metadata = JSON.parse(opts.metadata);
+    } catch {
+      render.err("--metadata must be JSON");
+      return EXIT.INVALID_ARGS;
+    }
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const id = await client.vectorStore(collection, text, metadata);
+    if (!id) {
+      render.err("store failed");
+      return EXIT.INTERNAL_ERROR;
+    }
+    if (opts.json)
+      emitJson({ id, collection });
+    else
+      render.ok(`stored in ${clay(collection)}`, dim(id));
+    return EXIT.SUCCESS;
+  });
+}
+async function runVectorSearch(collection, query, opts) {
+  if (!collection || !query) {
+    render.err("Usage: claudemesh vector search <collection> <query> [--limit N]");
+    return EXIT.INVALID_ARGS;
+  }
+  const limit = opts.limit ? parseInt(opts.limit, 10) : undefined;
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const hits = await client.vectorSearch(collection, query, limit);
+    if (opts.json) {
+      emitJson(hits);
+      return EXIT.SUCCESS;
+    }
+    if (hits.length === 0) {
+      render.info(dim("(no matches)"));
+      return EXIT.SUCCESS;
+    }
+    render.section(`${hits.length} match${hits.length === 1 ? "" : "es"} in ${clay(collection)}`);
+    for (const h of hits) {
+      process.stdout.write(`  ${bold(h.score.toFixed(3))}  ${dim(h.id.slice(0, 8))}  ${h.text}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
+}
+async function runVectorDelete(collection, id, opts) {
+  if (!collection || !id) {
+    render.err("Usage: claudemesh vector delete <collection> <id>");
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    await client.vectorDelete(collection, id);
+    if (opts.json)
+      emitJson({ id, deleted: true });
+    else
+      render.ok(`deleted ${dim(id.slice(0, 8))}`);
+    return EXIT.SUCCESS;
+  });
+}
+async function runVectorCollections(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const cols = await client.listCollections();
+    if (opts.json) {
+      emitJson(cols);
+      return EXIT.SUCCESS;
+    }
+    if (cols.length === 0) {
+      render.info(dim("(no collections)"));
+      return EXIT.SUCCESS;
+    }
+    render.section(`vector collections (${cols.length})`);
+    for (const c of cols)
+      process.stdout.write(`  ${clay(c)}
+`);
+    return EXIT.SUCCESS;
+  });
+}
+async function runGraphQuery(cypher, opts) {
+  if (!cypher) {
+    render.err('Usage: claudemesh graph query "<cypher>"');
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const rows = await client.graphQuery(cypher);
+    if (opts.json) {
+      emitJson(rows);
+      return EXIT.SUCCESS;
+    }
+    if (rows.length === 0) {
+      render.info(dim("(no rows)"));
+      return EXIT.SUCCESS;
+    }
+    render.section(`${rows.length} row${rows.length === 1 ? "" : "s"}`);
+    for (const r of rows)
+      process.stdout.write(`  ${JSON.stringify(r)}
+`);
+    return EXIT.SUCCESS;
+  });
+}
+async function runGraphExecute(cypher, opts) {
+  if (!cypher) {
+    render.err('Usage: claudemesh graph execute "<cypher>"');
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const rows = await client.graphExecute(cypher);
+    if (opts.json) {
+      emitJson(rows);
+      return EXIT.SUCCESS;
+    }
+    render.ok("executed", `${rows.length} row${rows.length === 1 ? "" : "s"} affected`);
+    return EXIT.SUCCESS;
+  });
+}
+async function runContextShare(summary, opts) {
+  if (!summary) {
+    render.err('Usage: claudemesh context share "<summary>" [--files a,b] [--findings x,y] [--tags t1,t2]');
+    return EXIT.INVALID_ARGS;
+  }
+  const files = opts.files?.split(",").map((s) => s.trim()).filter(Boolean);
+  const findings = opts.findings?.split(",").map((s) => s.trim()).filter(Boolean);
+  const tags = opts.tags?.split(",").map((s) => s.trim()).filter(Boolean);
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    await client.shareContext(summary, files, findings, tags);
+    if (opts.json)
+      emitJson({ shared: true, summary });
+    else
+      render.ok("context shared");
+    return EXIT.SUCCESS;
+  });
+}
+async function runContextGet(query, opts) {
+  if (!query) {
+    render.err('Usage: claudemesh context get "<query>"');
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const ctxs = await client.getContext(query);
+    if (opts.json) {
+      emitJson(ctxs);
+      return EXIT.SUCCESS;
+    }
+    if (ctxs.length === 0) {
+      render.info(dim("(no matches)"));
+      return EXIT.SUCCESS;
+    }
+    render.section(`${ctxs.length} context${ctxs.length === 1 ? "" : "s"}`);
+    for (const c of ctxs) {
+      process.stdout.write(`  ${bold(c.peerName)} ${dim("·")} ${c.updatedAt}
+`);
+      process.stdout.write(`    ${c.summary}
+`);
+      if (c.tags.length)
+        process.stdout.write(`    ${dim("tags: " + c.tags.join(", "))}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
+}
+async function runContextList(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const ctxs = await client.listContexts();
+    if (opts.json) {
+      emitJson(ctxs);
+      return EXIT.SUCCESS;
+    }
+    if (ctxs.length === 0) {
+      render.info(dim("(no contexts)"));
+      return EXIT.SUCCESS;
+    }
+    render.section(`shared contexts (${ctxs.length})`);
+    for (const c of ctxs) {
+      process.stdout.write(`  ${bold(c.peerName)} ${dim("·")} ${c.updatedAt}
+`);
+      process.stdout.write(`    ${c.summary}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
+}
+async function runStreamCreate(name, opts) {
+  if (!name) {
+    render.err("Usage: claudemesh stream create <name>");
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const id = await client.createStream(name);
+    if (!id) {
+      render.err("create failed");
+      return EXIT.INTERNAL_ERROR;
+    }
+    if (opts.json)
+      emitJson({ id, name });
+    else
+      render.ok(`created ${clay(name)}`, dim(id));
+    return EXIT.SUCCESS;
+  });
+}
+async function runStreamPublish(name, dataRaw, opts) {
+  if (!name || dataRaw === undefined) {
+    render.err("Usage: claudemesh stream publish <name> <json-or-text>");
+    return EXIT.INVALID_ARGS;
+  }
+  let data;
+  try {
+    data = JSON.parse(dataRaw);
+  } catch {
+    data = dataRaw;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    await client.publish(name, data);
+    if (opts.json)
+      emitJson({ published: true, name });
+    else
+      render.ok(`published to ${clay(name)}`);
+    return EXIT.SUCCESS;
+  });
+}
+async function runStreamList(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const streams = await client.listStreams();
+    if (opts.json) {
+      emitJson(streams);
+      return EXIT.SUCCESS;
+    }
+    if (streams.length === 0) {
+      render.info(dim("(no streams)"));
+      return EXIT.SUCCESS;
+    }
+    render.section(`streams (${streams.length})`);
+    for (const s of streams) {
+      process.stdout.write(`  ${clay(s.name)} ${dim(`· ${s.subscriberCount} subscriber${s.subscriberCount === 1 ? "" : "s"} · by ${s.createdBy}`)}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
+}
+async function runSqlQuery(sql, opts) {
+  if (!sql) {
+    render.err('Usage: claudemesh sql query "<select>"');
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const result = await client.meshQuery(sql);
+    if (!result) {
+      render.err("query timed out");
+      return EXIT.INTERNAL_ERROR;
+    }
+    if (opts.json) {
+      emitJson(result);
+      return EXIT.SUCCESS;
+    }
+    render.section(`${result.rowCount} row${result.rowCount === 1 ? "" : "s"}`);
+    if (result.columns.length > 0) {
+      process.stdout.write(`  ${dim(result.columns.join("  "))}
+`);
+      for (const row of result.rows) {
+        process.stdout.write(`  ${result.columns.map((c) => String(row[c] ?? "")).join("  ")}
+`);
+      }
+    }
+    return EXIT.SUCCESS;
+  });
+}
+async function runSqlExecute(sql, opts) {
+  if (!sql) {
+    render.err('Usage: claudemesh sql execute "<statement>"');
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    await client.meshExecute(sql);
+    if (opts.json)
+      emitJson({ executed: true });
+    else
+      render.ok("executed");
+    return EXIT.SUCCESS;
+  });
+}
+async function runSqlSchema(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const tables = await client.meshSchema();
+    if (opts.json) {
+      emitJson(tables);
+      return EXIT.SUCCESS;
+    }
+    if (tables.length === 0) {
+      render.info(dim("(no tables)"));
+      return EXIT.SUCCESS;
+    }
+    render.section(`mesh tables (${tables.length})`);
+    for (const t of tables) {
+      process.stdout.write(`  ${bold(t.name)}
+`);
+      for (const c of t.columns) {
+        const nullable = c.nullable ? "" : " not null";
+        process.stdout.write(`    ${c.name} ${dim(c.type + nullable)}
+`);
+      }
+    }
+    return EXIT.SUCCESS;
+  });
+}
+async function runSkillList(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const skills = await client.listSkills(opts.query);
+    if (opts.json) {
+      emitJson(skills);
+      return EXIT.SUCCESS;
+    }
+    if (skills.length === 0) {
+      render.info(dim("(no skills)"));
+      return EXIT.SUCCESS;
+    }
+    render.section(`mesh skills (${skills.length})`);
+    for (const s of skills) {
+      process.stdout.write(`  ${bold(s.name)} ${dim("· by " + s.author)}
+`);
+      process.stdout.write(`    ${s.description}
+`);
+      if (s.tags.length)
+        process.stdout.write(`    ${dim("tags: " + s.tags.join(", "))}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
+}
+async function runSkillGet(name, opts) {
+  if (!name) {
+    render.err("Usage: claudemesh skill get <name>");
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const skill = await client.getSkill(name);
+    if (!skill) {
+      render.err(`skill "${name}" not found`);
+      return EXIT.NOT_FOUND;
+    }
+    if (opts.json) {
+      emitJson(skill);
+      return EXIT.SUCCESS;
+    }
+    render.section(skill.name);
+    render.kv([
+      ["author", skill.author],
+      ["created", skill.createdAt],
+      ["tags", skill.tags.join(", ") || dim("(none)")]
+    ]);
+    render.blank();
+    render.info(skill.description);
+    render.blank();
+    process.stdout.write(skill.instructions + `
+`);
+    return EXIT.SUCCESS;
+  });
+}
+async function runSkillRemove(name, opts) {
+  if (!name) {
+    render.err("Usage: claudemesh skill remove <name>");
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const removed = await client.removeSkill(name);
+    if (opts.json)
+      emitJson({ name, removed });
+    else if (removed)
+      render.ok(`removed ${bold(name)}`);
+    else
+      render.err(`skill "${name}" not found`);
+    return removed ? EXIT.SUCCESS : EXIT.NOT_FOUND;
+  });
+}
+async function runVaultList(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const entries = await client.vaultList();
+    if (opts.json) {
+      emitJson(entries);
+      return EXIT.SUCCESS;
+    }
+    if (!entries || entries.length === 0) {
+      render.info(dim("(vault empty)"));
+      return EXIT.SUCCESS;
+    }
+    render.section(`vault (${entries.length})`);
+    for (const e of entries) {
+      const k = String(e?.key ?? "?");
+      const t = String(e?.entry_type ?? "");
+      process.stdout.write(`  ${bold(k)} ${dim(t)}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
+}
+async function runVaultDelete(key, opts) {
+  if (!key) {
+    render.err("Usage: claudemesh vault delete <key>");
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const ok = await client.vaultDelete(key);
+    if (opts.json)
+      emitJson({ key, deleted: ok });
+    else if (ok)
+      render.ok(`deleted ${bold(key)}`);
+    else
+      render.err(`vault key "${key}" not found`);
+    return ok ? EXIT.SUCCESS : EXIT.NOT_FOUND;
+  });
+}
+async function runWatchList(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const watches = await client.watchList();
+    if (opts.json) {
+      emitJson(watches);
+      return EXIT.SUCCESS;
+    }
+    if (!watches || watches.length === 0) {
+      render.info(dim("(no watches)"));
+      return EXIT.SUCCESS;
+    }
+    render.section(`url watches (${watches.length})`);
+    for (const w of watches) {
+      const id = String(w.id ?? "?");
+      const url = String(w.url ?? "");
+      const label = w.label ? ` ${dim("(" + w.label + ")")}` : "";
+      process.stdout.write(`  ${dim(id.slice(0, 8))}  ${clay(url)}${label}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
+}
+async function runUnwatch(id, opts) {
+  if (!id) {
+    render.err("Usage: claudemesh watch remove <id>");
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const ok = await client.unwatch(id);
+    if (opts.json)
+      emitJson({ id, removed: ok });
+    else if (ok)
+      render.ok(`unwatched ${dim(id.slice(0, 8))}`);
+    else
+      render.err(`watch "${id}" not found`);
+    return ok ? EXIT.SUCCESS : EXIT.NOT_FOUND;
+  });
+}
+async function runWebhookList(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const hooks = await client.listWebhooks();
+    if (opts.json) {
+      emitJson(hooks);
+      return EXIT.SUCCESS;
+    }
+    if (hooks.length === 0) {
+      render.info(dim("(no webhooks)"));
+      return EXIT.SUCCESS;
+    }
+    render.section(`webhooks (${hooks.length})`);
+    for (const h of hooks) {
+      const dot = h.active ? "●" : dim("○");
+      process.stdout.write(`  ${dot} ${bold(h.name)} ${dim("· " + h.url)}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
+}
+async function runWebhookDelete(name, opts) {
+  if (!name) {
+    render.err("Usage: claudemesh webhook delete <name>");
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const ok = await client.deleteWebhook(name);
+    if (opts.json)
+      emitJson({ name, deleted: ok });
+    else if (ok)
+      render.ok(`deleted ${bold(name)}`);
+    else
+      render.err(`webhook "${name}" not found`);
+    return ok ? EXIT.SUCCESS : EXIT.NOT_FOUND;
+  });
+}
+async function runTaskList(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const tasks = await client.listTasks(opts.status, opts.assignee);
+    if (opts.json) {
+      emitJson(tasks);
+      return EXIT.SUCCESS;
+    }
+    if (tasks.length === 0) {
+      render.info(dim("(no tasks)"));
+      return EXIT.SUCCESS;
+    }
+    render.section(`tasks (${tasks.length})`);
+    for (const t of tasks) {
+      const dot = t.status === "done" ? "●" : t.status === "claimed" ? clay("●") : dim("○");
+      const assignee = t.assignee ? dim(` → ${t.assignee}`) : "";
+      process.stdout.write(`  ${dot} ${dim(t.id.slice(0, 8))} ${bold(t.title)}${assignee}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
+}
+async function runTaskCreate(title, opts) {
+  if (!title) {
+    render.err("Usage: claudemesh task create <title> [--assignee X] [--priority P]");
+    return EXIT.INVALID_ARGS;
+  }
+  const tags = opts.tags?.split(",").map((s) => s.trim()).filter(Boolean);
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const id = await client.createTask(title, opts.assignee, opts.priority, tags);
+    if (!id) {
+      render.err("create failed");
+      return EXIT.INTERNAL_ERROR;
+    }
+    if (opts.json)
+      emitJson({ id, title });
+    else
+      render.ok(`created ${dim(id.slice(0, 8))}`, title);
+    return EXIT.SUCCESS;
+  });
+}
+async function runClockSet(speed, opts) {
+  const s = parseFloat(speed);
+  if (!Number.isFinite(s) || s < 0) {
+    render.err("Usage: claudemesh clock set <speed>", "speed is a non-negative number, e.g. 1.0 = realtime, 0 = paused, 60 = 60× faster");
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const r = await client.setClock(s);
+    if (!r) {
+      render.err("clock set failed");
+      return EXIT.INTERNAL_ERROR;
+    }
+    if (opts.json)
+      emitJson(r);
+    else
+      render.ok(`clock set to ${bold("x" + r.speed)}`);
+    return EXIT.SUCCESS;
+  });
+}
+async function runClockPause(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const r = await client.pauseClock();
+    if (!r) {
+      render.err("pause failed");
+      return EXIT.INTERNAL_ERROR;
+    }
+    if (opts.json)
+      emitJson(r);
+    else
+      render.ok("clock paused");
+    return EXIT.SUCCESS;
+  });
+}
+async function runClockResume(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const r = await client.resumeClock();
+    if (!r) {
+      render.err("resume failed");
+      return EXIT.INTERNAL_ERROR;
+    }
+    if (opts.json)
+      emitJson(r);
+    else
+      render.ok("clock resumed");
+    return EXIT.SUCCESS;
+  });
+}
+async function runMeshMcpList(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const servers = await client.mcpList();
+    if (opts.json) {
+      emitJson(servers);
+      return EXIT.SUCCESS;
+    }
+    if (servers.length === 0) {
+      render.info(dim("(no mesh-MCP servers)"));
+      return EXIT.SUCCESS;
+    }
+    render.section(`mesh-MCP servers (${servers.length})`);
+    for (const s of servers) {
+      process.stdout.write(`  ${bold(s.name)} ${dim("· hosted by " + s.hostedBy)}
+`);
+      process.stdout.write(`    ${s.description}
+`);
+      if (s.tools.length)
+        process.stdout.write(`    ${dim("tools: " + s.tools.map((t) => t.name).join(", "))}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
+}
+async function runMeshMcpCall(serverName, toolName, argsRaw, opts) {
+  if (!serverName || !toolName) {
+    render.err("Usage: claudemesh mesh-mcp call <server> <tool> [json-args]");
+    return EXIT.INVALID_ARGS;
+  }
+  let args = {};
+  if (argsRaw) {
+    try {
+      args = JSON.parse(argsRaw);
+    } catch {
+      render.err("args must be JSON");
+      return EXIT.INVALID_ARGS;
+    }
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const r = await client.mcpCall(serverName, toolName, args);
+    if (r.error) {
+      if (opts.json)
+        emitJson({ ok: false, error: r.error });
+      else
+        render.err(r.error);
+      return EXIT.INTERNAL_ERROR;
+    }
+    if (opts.json)
+      emitJson({ ok: true, result: r.result });
+    else
+      process.stdout.write(JSON.stringify(r.result, null, 2) + `
+`);
+    return EXIT.SUCCESS;
+  });
+}
+async function runMeshMcpCatalog(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const cat = await client.mcpCatalog();
+    if (opts.json) {
+      emitJson(cat);
+      return EXIT.SUCCESS;
+    }
+    if (!cat || cat.length === 0) {
+      render.info(dim("(catalog empty)"));
+      return EXIT.SUCCESS;
+    }
+    render.section(`mesh-MCP catalog (${cat.length})`);
+    for (const c of cat) {
+      process.stdout.write(`  ${bold(String(c.name ?? "?"))} ${dim(String(c.status ?? ""))}
+`);
+      if (c.description)
+        process.stdout.write(`    ${String(c.description)}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
+}
+async function runFileList(opts) {
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const files = await client.listFiles(opts.query);
+    if (opts.json) {
+      emitJson(files);
+      return EXIT.SUCCESS;
+    }
+    if (files.length === 0) {
+      render.info(dim("(no files)"));
+      return EXIT.SUCCESS;
+    }
+    render.section(`mesh files (${files.length})`);
+    for (const f of files) {
+      const sizeKb = (f.size / 1024).toFixed(1);
+      process.stdout.write(`  ${bold(f.name)} ${dim(`· ${sizeKb} KB · by ${f.uploadedBy}`)}
+`);
+      if (f.tags.length)
+        process.stdout.write(`    ${dim("tags: " + f.tags.join(", "))}
+`);
+    }
+    return EXIT.SUCCESS;
+  });
+}
+async function runFileStatus(id, opts) {
+  if (!id) {
+    render.err("Usage: claudemesh file status <file-id>");
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    const accessors = await client.fileStatus(id);
+    if (opts.json) {
+      emitJson(accessors);
+      return EXIT.SUCCESS;
+    }
+    if (accessors.length === 0) {
+      render.info(dim("(no accesses recorded)"));
+      return EXIT.SUCCESS;
+    }
+    render.section(`accesses for ${id.slice(0, 8)}`);
+    for (const a of accessors)
+      process.stdout.write(`  ${bold(a.peerName)} ${dim("· " + a.accessedAt)}
+`);
+    return EXIT.SUCCESS;
+  });
+}
+async function runFileDelete(id, opts) {
+  if (!id) {
+    render.err("Usage: claudemesh file delete <file-id>");
+    return EXIT.INVALID_ARGS;
+  }
+  return await withMesh({ meshSlug: opts.mesh ?? null }, async (client) => {
+    await client.deleteFile(id);
+    if (opts.json)
+      emitJson({ id, deleted: true });
+    else
+      render.ok(`deleted ${dim(id.slice(0, 8))}`);
+    return EXIT.SUCCESS;
+  });
+}
+var init_platform_actions = __esm(() => {
+  init_connect();
+  init_render();
+  init_styles();
+  init_exit_codes();
+});
+
 // src/mcp/tools/definitions.ts
 var TOOLS;
 var init_definitions = __esm(() => {
@@ -13331,9 +14091,25 @@ Identity / presence
   claudemesh group leave @<name>   leave a group
 
 Tasks
+  claudemesh task create <title>   create a new task [--assignee --priority --tags]
+  claudemesh task list             list tasks [--status --assignee]
   claudemesh task claim <id>       claim an unclaimed task
   claudemesh task complete <id>    mark task done [result]
 
+Platform
+  claudemesh vector store|search|delete|collections    embedding store
+  claudemesh graph query|execute "<cypher>"            graph operations
+  claudemesh context share|get|list                    work-context summaries
+  claudemesh stream create|publish|list                pub/sub event bus
+  claudemesh sql query|execute|schema                  per-mesh SQL
+  claudemesh skill list|get|remove                     mesh-published skills
+  claudemesh vault list|delete                         encrypted secrets
+  claudemesh watch list|remove                         URL change watchers
+  claudemesh webhook list|delete                       outbound HTTP triggers
+  claudemesh file list|status|delete                   shared mesh files
+  claudemesh mesh-mcp list|call|catalog                deployed mesh-MCP servers
+  claudemesh clock set|pause|resume                    mesh logical clock
+
 Auth
   claudemesh login                 sign in (browser or paste token)
   claudemesh register              create account + sign in
@@ -13573,11 +14349,6 @@ async function main() {
       process.exit(await runMsgStatus2(positionals[0], { mesh: flags.mesh, json: !!flags.json }));
       break;
     }
-    case "clock": {
-      const { runClock: runClock2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
-      process.exit(await runClock2({ mesh: flags.mesh, json: !!flags.json }));
-      break;
-    }
     case "stats": {
       const { runStats: runStats2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
       process.exit(await runStats2({ mesh: flags.mesh, json: !!flags.json }));
@@ -13588,20 +14359,6 @@ async function main() {
       process.exit(await runPing2({ mesh: flags.mesh, json: !!flags.json }));
       break;
     }
-    case "task": {
-      const sub = positionals[0];
-      if (sub === "claim") {
-        const { runTaskClaim: runTaskClaim2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
-        process.exit(await runTaskClaim2(positionals[1], { mesh: flags.mesh, json: !!flags.json }));
-      } else if (sub === "complete") {
-        const { runTaskComplete: runTaskComplete2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
-        process.exit(await runTaskComplete2(positionals[1], positionals.slice(2).join(" ") || undefined, { mesh: flags.mesh, json: !!flags.json }));
-      } else {
-        console.error("Usage: claudemesh task <claim|complete> <id> [result]");
-        process.exit(EXIT.INVALID_ARGS);
-      }
-      break;
-    }
     case "login": {
       const { login: login2 } = await Promise.resolve().then(() => (init_login(), exports_login));
       process.exit(await login2());
@@ -13713,6 +14470,234 @@ async function main() {
       process.exit(await runGrants2({ mesh: flags.mesh, json: !!flags.json }));
       break;
     }
+    case "vector": {
+      const sub = positionals[0];
+      const f = { mesh: flags.mesh, json: !!flags.json };
+      if (sub === "store") {
+        const { runVectorStore: runVectorStore2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runVectorStore2(positionals[1] ?? "", positionals.slice(2).join(" "), { ...f, metadata: flags.metadata }));
+      } else if (sub === "search") {
+        const { runVectorSearch: runVectorSearch2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runVectorSearch2(positionals[1] ?? "", positionals.slice(2).join(" "), { ...f, limit: flags.limit }));
+      } else if (sub === "delete") {
+        const { runVectorDelete: runVectorDelete2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runVectorDelete2(positionals[1] ?? "", positionals[2] ?? "", f));
+      } else if (sub === "collections") {
+        const { runVectorCollections: runVectorCollections2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runVectorCollections2(f));
+      } else {
+        console.error("Usage: claudemesh vector <store|search|delete|collections>");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
+    case "graph": {
+      const sub = positionals[0];
+      const f = { mesh: flags.mesh, json: !!flags.json };
+      if (sub === "query") {
+        const { runGraphQuery: runGraphQuery2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runGraphQuery2(positionals.slice(1).join(" "), f));
+      } else if (sub === "execute") {
+        const { runGraphExecute: runGraphExecute2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runGraphExecute2(positionals.slice(1).join(" "), f));
+      } else {
+        console.error('Usage: claudemesh graph <query|execute> "<cypher>"');
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
+    case "context": {
+      const sub = positionals[0];
+      const f = { mesh: flags.mesh, json: !!flags.json };
+      if (sub === "share") {
+        const { runContextShare: runContextShare2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runContextShare2(positionals.slice(1).join(" "), { ...f, files: flags.files, findings: flags.findings, tags: flags.tags }));
+      } else if (sub === "get") {
+        const { runContextGet: runContextGet2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runContextGet2(positionals.slice(1).join(" "), f));
+      } else if (sub === "list") {
+        const { runContextList: runContextList2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runContextList2(f));
+      } else {
+        console.error("Usage: claudemesh context <share|get|list>");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
+    case "stream": {
+      const sub = positionals[0];
+      const f = { mesh: flags.mesh, json: !!flags.json };
+      if (sub === "create") {
+        const { runStreamCreate: runStreamCreate2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runStreamCreate2(positionals[1] ?? "", f));
+      } else if (sub === "publish") {
+        const { runStreamPublish: runStreamPublish2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runStreamPublish2(positionals[1] ?? "", positionals.slice(2).join(" "), f));
+      } else if (sub === "list") {
+        const { runStreamList: runStreamList2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runStreamList2(f));
+      } else {
+        console.error("Usage: claudemesh stream <create|publish|list>");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
+    case "sql": {
+      const sub = positionals[0];
+      const f = { mesh: flags.mesh, json: !!flags.json };
+      if (sub === "query") {
+        const { runSqlQuery: runSqlQuery2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runSqlQuery2(positionals.slice(1).join(" "), f));
+      } else if (sub === "execute") {
+        const { runSqlExecute: runSqlExecute2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runSqlExecute2(positionals.slice(1).join(" "), f));
+      } else if (sub === "schema") {
+        const { runSqlSchema: runSqlSchema2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runSqlSchema2(f));
+      } else {
+        console.error("Usage: claudemesh sql <query|execute|schema>");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
+    case "skill": {
+      const sub = positionals[0];
+      const f = { mesh: flags.mesh, json: !!flags.json };
+      if (sub === "list") {
+        const { runSkillList: runSkillList2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runSkillList2({ ...f, query: positionals[1] }));
+      } else if (sub === "get") {
+        const { runSkillGet: runSkillGet2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runSkillGet2(positionals[1] ?? "", f));
+      } else if (sub === "remove") {
+        const { runSkillRemove: runSkillRemove2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runSkillRemove2(positionals[1] ?? "", f));
+      } else {
+        console.error("Usage: claudemesh skill <list|get|remove>");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
+    case "vault": {
+      const sub = positionals[0];
+      const f = { mesh: flags.mesh, json: !!flags.json };
+      if (sub === "list") {
+        const { runVaultList: runVaultList2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runVaultList2(f));
+      } else if (sub === "delete") {
+        const { runVaultDelete: runVaultDelete2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runVaultDelete2(positionals[1] ?? "", f));
+      } else {
+        console.error("Usage: claudemesh vault <list|delete>  (set/get currently via MCP — needs crypto)");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
+    case "watch": {
+      const sub = positionals[0];
+      const f = { mesh: flags.mesh, json: !!flags.json };
+      if (sub === "list") {
+        const { runWatchList: runWatchList2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runWatchList2(f));
+      } else if (sub === "remove") {
+        const { runUnwatch: runUnwatch2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runUnwatch2(positionals[1] ?? "", f));
+      } else {
+        console.error("Usage: claudemesh watch <list|remove>");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
+    case "webhook": {
+      const sub = positionals[0];
+      const f = { mesh: flags.mesh, json: !!flags.json };
+      if (sub === "list") {
+        const { runWebhookList: runWebhookList2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runWebhookList2(f));
+      } else if (sub === "delete") {
+        const { runWebhookDelete: runWebhookDelete2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runWebhookDelete2(positionals[1] ?? "", f));
+      } else {
+        console.error("Usage: claudemesh webhook <list|delete>");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
+    case "file": {
+      const sub = positionals[0];
+      const f = { mesh: flags.mesh, json: !!flags.json };
+      if (sub === "list") {
+        const { runFileList: runFileList2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runFileList2({ ...f, query: positionals[1] }));
+      } else if (sub === "status") {
+        const { runFileStatus: runFileStatus2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runFileStatus2(positionals[1] ?? "", f));
+      } else if (sub === "delete") {
+        const { runFileDelete: runFileDelete2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runFileDelete2(positionals[1] ?? "", f));
+      } else {
+        console.error("Usage: claudemesh file <list|status|delete>");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
+    case "mesh-mcp": {
+      const sub = positionals[0];
+      const f = { mesh: flags.mesh, json: !!flags.json };
+      if (sub === "list") {
+        const { runMeshMcpList: runMeshMcpList2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runMeshMcpList2(f));
+      } else if (sub === "call") {
+        const { runMeshMcpCall: runMeshMcpCall2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runMeshMcpCall2(positionals[1] ?? "", positionals[2] ?? "", positionals.slice(3).join(" "), f));
+      } else if (sub === "catalog") {
+        const { runMeshMcpCatalog: runMeshMcpCatalog2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runMeshMcpCatalog2(f));
+      } else {
+        console.error("Usage: claudemesh mesh-mcp <list|call|catalog>");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
+    case "clock": {
+      const sub = positionals[0];
+      const f = { mesh: flags.mesh, json: !!flags.json };
+      if (sub === "set") {
+        const { runClockSet: runClockSet2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runClockSet2(positionals[1] ?? "", f));
+      } else if (sub === "pause") {
+        const { runClockPause: runClockPause2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runClockPause2(f));
+      } else if (sub === "resume") {
+        const { runClockResume: runClockResume2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runClockResume2(f));
+      } else {
+        const { runClock: runClock2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+        process.exit(await runClock2(f));
+      }
+      break;
+    }
+    case "task": {
+      const sub = positionals[0];
+      const f = { mesh: flags.mesh, json: !!flags.json };
+      if (sub === "claim") {
+        const { runTaskClaim: runTaskClaim2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+        process.exit(await runTaskClaim2(positionals[1], f));
+      } else if (sub === "complete") {
+        const { runTaskComplete: runTaskComplete2 } = await Promise.resolve().then(() => (init_broker_actions(), exports_broker_actions));
+        process.exit(await runTaskComplete2(positionals[1], positionals.slice(2).join(" ") || undefined, f));
+      } else if (sub === "list") {
+        const { runTaskList: runTaskList2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runTaskList2({ ...f, status: flags.status, assignee: flags.assignee }));
+      } else if (sub === "create") {
+        const { runTaskCreate: runTaskCreate2 } = await Promise.resolve().then(() => (init_platform_actions(), exports_platform_actions));
+        process.exit(await runTaskCreate2(positionals.slice(1).join(" "), { ...f, assignee: flags.assignee, priority: flags.priority, tags: flags.tags }));
+      } else {
+        console.error("Usage: claudemesh task <create|list|claim|complete>");
+        process.exit(EXIT.INVALID_ARGS);
+      }
+      break;
+    }
     case "mcp": {
       const { runMcp: runMcp2 } = await Promise.resolve().then(() => (init_mcp(), exports_mcp));
       await runMcp2();
@@ -13740,4 +14725,4 @@ main().catch((err) => {
   process.exit(EXIT.INTERNAL_ERROR);
 });
 
-//# debugId=E126BD4968D2FCDF64756E2164756E21
+//# debugId=B4AA59318D3B1FB264756E2164756E21