moshcode 0.25.1 → 0.27.0

package/src/integrations.mjs

@@ -8,8 +8,12 @@ import {
 import {
   SKILL_ENGINES, planSkillInstall, runSkillInstall, skillName,
 } from "./skills.mjs";
+import {
+  MARKETPLACE_NAME, PLUGINS, PLUGIN_ENGINES, marketplaceSource, planPluginCommand,
+  pluginId, resolvePlugin, runPluginCommand,
+} from "./plugins.mjs";
 import { catalogList, resolveCatalog } from "./mcp-catalog.mjs";
-import { MCP_VERBS, SKILL_VERBS } from "./cli-schema.mjs";
+import { MCP_VERBS, PLUGIN_VERBS, SKILL_VERBS } from "./cli-schema.mjs";
 import { acid, ash, bone, ok, err, info } from "./ui.mjs";
 
 function splitKV(pair) {
@@ -180,7 +184,7 @@ export function printSkillTargets(json = false) {
 
 function summarize(results) {
   for (const r of results) {
-    if (r.status === "added" || r.status === "installed") console.log(line(r.key, ok(r.status)));
+    if (r.status === "added" || r.status === "installed" || r.status === "removed") console.log(line(r.key, ok(r.status)));
     else if (r.status === "failed") console.log(line(r.key, err(`failed${r.code != null ? ` (code ${r.code})` : r.signal ? ` (${r.signal})` : ""}`)));
     else if (r.status === "not-installed") console.log(line(r.key, ash("not installed — /install " + r.key)));
     else console.log(line(r.key, ash(`skipped — ${r.reason}`)));
@@ -263,3 +267,73 @@ export async function skillCommand(tokens, { run, installedSet } = {}) {
   summarize(results);
   return anyFailed(results) ? 1 : 0;
 }
+
+/**
+ * `/plugin list` — what this marketplace ships, and which engines can take it.
+ *
+ * Two tables rather than one: the plugin list is a property of moshcode, the
+ * engine support is a property of this machine, and merging them into a single
+ * list is how "installed" and "installable" get confused.
+ */
+export function printPluginTargets(json = false, { installedSet } = {}) {
+  const targets = integrationTargetStatus(PLUGIN_ENGINES, { installedSet }).map((t) => ({
+    ...t, supported: PLUGIN_ENGINES.includes(t.name),
+  }));
+  if (json) {
+    console.log(JSON.stringify({
+      marketplace: { name: MARKETPLACE_NAME, source: marketplaceSource() },
+      plugins: PLUGINS,
+      engines: targets,
+    }, null, 2));
+    return;
+  }
+  console.log(bone("  plugins") + ash("  — install moshcode's slash commands with ") + acid("/plugin install"));
+  for (const plugin of PLUGINS) {
+    console.log(`   ${acid(pluginId(plugin.name).padEnd(18))}${ash(plugin.description)}`);
+    console.log(`   ${" ".repeat(18)}${ash(plugin.commands.join("  "))}`);
+  }
+  console.log("");
+  for (const target of targets) {
+    const dot = target.supported && target.installed ? DOT.installed : DOT.missing;
+    console.log(`   ${dot} ${bone(target.name.padEnd(9))} ${ash(target.supported ? "plugins supported" : "no plugin primitive")}`);
+  }
+}
+
+/** Run `/plugin …`. `tokens` are the words after `plugin`. */
+export async function pluginCommand(tokens, { run, installedSet } = {}) {
+  const verb = tokens[0];
+  if (!verb || verb === "list") {
+    printPluginTargets(tokens.slice(1).includes("--json"), { installedSet });
+    return 0;
+  }
+  if (verb !== "install" && verb !== "remove") {
+    console.log(err(`unknown plugin verb "${verb}" — try ${PLUGIN_VERBS.map(({ name }) => name).join(", ")}`));
+    return 1;
+  }
+
+  const rest = tokens.slice(1).filter((t) => t !== "--json");
+  const stray = rest.find((t) => String(t).startsWith("-"));
+  if (stray) { console.log(err(`unknown plugin flag "${stray}"`)); return 1; }
+
+  const plugin = resolvePlugin(rest[0]);
+  if (!plugin) {
+    console.log(err(`unknown plugin "${rest[0]}" — this marketplace ships ${PLUGINS.map((p) => p.name).join(", ")}`));
+    return 1;
+  }
+
+  const source = marketplaceSource();
+  console.log(verb === "install"
+    ? info(`installing ${bone(pluginId(plugin.name))} ${ash(`from ${source}`)} across plugin engines…`)
+    : info(`removing ${bone(pluginId(plugin.name))} from plugin engines…`));
+
+  const plan = planPluginCommand({ plugin, source }, { installedSet, verb });
+  const results = await runPluginCommand(plan, { verb, ...(run ? { run } : {}) });
+  summarize(results);
+
+  // A newly installed plugin is not live in an already-running engine, and the
+  // first thing anyone does is type the slash command and conclude it failed.
+  if (!anyFailed(results) && verb === "install" && results.some((r) => r.status === "installed")) {
+    console.log(info(`restart the engine, then try ${acid(`${plugin.commands[0]} NVDA`)}`));
+  }
+  return anyFailed(results) ? 1 : 0;
+}

package/src/plugins.mjs

@@ -0,0 +1,126 @@
+// `moshcode plugin` — install moshcode's own slash commands into an engine.
+//
+// The same shape as src/skills.mjs, for the same reason: one source, a plan of
+// per-engine actions, and a summary that names the engines it *skipped* as well
+// as the ones it touched. An engine silently missing from the summary reads as
+// "installed everywhere", which is exactly the confusion prd/0003 R8 exists to
+// prevent.
+//
+// Claude Code is currently the only engine with a plugin primitive. That is a
+// fact about the engines, not an assumption baked into the fan-out — adding a
+// second one means adding a case to pluginInstallActions, nothing else.
+import { ENGINES, isInstalled, ranOk, runCmd } from "./engines.mjs";
+
+/** Engines with a plugin primitive. */
+export const PLUGIN_ENGINES = ["claude"];
+
+/** The marketplace this repo publishes (see .claude-plugin/marketplace.json). */
+export const MARKETPLACE_NAME = "moshcode";
+
+/**
+ * Where the marketplace is fetched from. A GitHub `owner/repo` by default;
+ * point it at a checkout to test an unreleased plugin:
+ *   MOSHCODE_PLUGIN_SOURCE=. moshcode plugin install
+ */
+export function marketplaceSource(env = process.env) {
+  return String(env.MOSHCODE_PLUGIN_SOURCE || "moshcoder/moshcode").trim() || "moshcoder/moshcode";
+}
+
+/** The plugins this marketplace ships. Mirrors .claude-plugin/marketplace.json. */
+export const PLUGINS = [
+  {
+    name: "ticker",
+    description: "equity research slash commands backed by advis0r.com",
+    commands: ["/ticker", "/signals", "/research", "/lookup", "/reports", "/discover"],
+  },
+  {
+    name: "crypto",
+    description: "crypto market data slash commands backed by advis0r.com",
+    commands: ["/crypto", "/quote", "/book", "/bars", "/spark", "/pairs", "/coin"],
+  },
+];
+
+export const DEFAULT_PLUGIN = PLUGINS[0].name;
+
+export function resolvePlugin(name) {
+  if (!name) return PLUGINS.find((p) => p.name === DEFAULT_PLUGIN) ?? null;
+  const key = String(name).toLowerCase().replace(/@.*$/, "");
+  return PLUGINS.find((p) => p.name === key) ?? null;
+}
+
+/** Fully-qualified plugin id, the form `claude plugin install` disambiguates with. */
+export function pluginId(name) {
+  return `${name}@${MARKETPLACE_NAME}`;
+}
+
+/**
+ * The commands one engine needs to install a plugin.
+ *
+ * Adding the marketplace is idempotent and separate from installing, so it runs
+ * every time: a machine that added the marketplace before this plugin existed
+ * would otherwise fail the install with "not found in any marketplace".
+ */
+export function pluginInstallActions(key, { plugin, source, scope }) {
+  switch (key) {
+    case "claude":
+      return [
+        { cmd: "claude", args: ["plugin", "marketplace", "add", source, ...(scope ? ["--scope", scope] : [])] },
+        { cmd: "claude", args: ["plugin", "install", pluginId(plugin.name), ...(scope ? ["--scope", scope] : [])] },
+      ];
+    default:
+      return { skip: "no plugin primitive" };
+  }
+}
+
+export function pluginRemoveActions(key, { plugin }) {
+  switch (key) {
+    case "claude":
+      return [{ cmd: "claude", args: ["plugin", "uninstall", pluginId(plugin.name)] }];
+    default:
+      return { skip: "no plugin primitive" };
+  }
+}
+
+/**
+ * Plan the fan-out: one entry per engine, with its actions or its skip reason.
+ * Derived from ENGINES so an engine added later cannot fall out of the summary.
+ */
+export function planPluginCommand(spec, { installedSet, verb = "install" } = {}) {
+  const build = verb === "remove" ? pluginRemoveActions : pluginInstallActions;
+  const rest = Object.keys(ENGINES).filter((key) => !PLUGIN_ENGINES.includes(key));
+  return [...PLUGIN_ENGINES, ...rest].map((key) => {
+    const bin = ENGINES[key].bin;
+    const installed = installedSet ? installedSet.has(key) : isInstalled(bin, ENGINES[key].binDirs);
+    const actions = build(key, spec);
+    return Array.isArray(actions)
+      ? { key, bin, installed, actions }
+      : { key, bin, installed, ...actions };
+  });
+}
+
+/**
+ * Execute a plan. Returns [{ key, status, reason?, code? }] with
+ * status one of installed | removed | skipped | failed | not-installed.
+ * `run` is injectable for tests.
+ */
+export async function runPluginCommand(plan, { run = runCmd, verb = "install" } = {}) {
+  const done = verb === "remove" ? "removed" : "installed";
+  const results = [];
+  for (const item of plan) {
+    if (item.skip) { results.push({ key: item.key, status: "skipped", reason: item.skip }); continue; }
+    if (!item.installed) { results.push({ key: item.key, status: "not-installed" }); continue; }
+    let last = null;
+    let failed = false;
+    for (const action of item.actions) {
+      last = await run(action.cmd, action.args);
+      if (!ranOk(last)) { failed = true; break; }
+    }
+    results.push({
+      key: item.key,
+      status: failed ? "failed" : done,
+      code: last?.code ?? null,
+      signal: last?.signal ?? null,
+    });
+  }
+  return results;
+}

package/src/socials.mjs

@@ -0,0 +1,72 @@
+import { canOpenBrowser, openBrowser } from "./open-url.mjs";
+
+const DEFAULT_APP = "https://app.moshcode.sh";
+
+export const SOCIALS = [
+  {
+    name: "bluesky",
+    aliases: ["bsky"],
+    description: "official Bluesky browser composer",
+  },
+  {
+    name: "nostr",
+    aliases: [],
+    description: "NIP-07/NIP-46 browser signer + relay publish",
+  },
+];
+
+export function resolveSocial(name) {
+  const wanted = String(name ?? "").trim().toLowerCase();
+  return SOCIALS.find((social) =>
+    social.name === wanted || social.aliases.includes(wanted)) ?? null;
+}
+
+function appOrigin(env = process.env) {
+  return String(env.MOSHCODE_API || DEFAULT_APP).replace(/\/+$/, "");
+}
+
+/**
+ * Build the browser hand-off without opening anything. Nostr keeps the draft
+ * in the fragment so it never reaches app.moshcode.sh access logs or Referer
+ * headers; the composer reads it entirely in the browser.
+ */
+export function socialPostUrl(name, message, { env = process.env } = {}) {
+  const social = resolveSocial(name);
+  if (!social) return null;
+  const text = String(message ?? "");
+  if (social.name === "bluesky") {
+    return `https://bsky.app/intent/compose?${new URLSearchParams({ text })}`;
+  }
+  return `${appOrigin(env)}/socials/nostr#${new URLSearchParams({ text })}`;
+}
+
+export function socialRoster() {
+  return SOCIALS.map((social) => ({ ...social, aliases: [...social.aliases] }));
+}
+
+/**
+ * Open a provider composer. Posting remains an explicit browser confirmation:
+ * Bluesky requires it, and Nostr asks the browser signer before relay publish.
+ */
+export function postSocial(args, {
+  env = process.env,
+  canOpen = canOpenBrowser,
+  open = openBrowser,
+} = {}) {
+  const [requested, ...words] = Array.isArray(args) ? args : [];
+  const social = resolveSocial(requested);
+  if (!requested) return { ok: false, error: 'usage: /post <social> "message"' };
+  if (!social) {
+    return {
+      ok: false,
+      error: `unknown social "${requested}". try: ${SOCIALS.map((entry) => entry.name).join(", ")}`,
+    };
+  }
+
+  const message = words.join(" ").trim();
+  if (!message) return { ok: false, error: 'usage: /post <social> "message"' };
+
+  const url = socialPostUrl(social.name, message, { env });
+  const opened = Boolean(canOpen() && open(url));
+  return { ok: true, social: social.name, message, url, opened };
+}

package/src/tui.mjs

@@ -10,6 +10,7 @@ import path from "node:path";
 import { ENGINES, agentLaunchArgs, resolveEngine, engineStatus, openSession } from "./engines.mjs";
 import { TOOLS, resolveTool, toolStatus, openTool } from "./tools.mjs";
 import { tradeArgs, tradeUsage } from "./trade.mjs";
+import { postSocial, socialRoster } from "./socials.mjs";
 import { runUpgrade } from "./upgrade.mjs";
 import { locate, tilde } from "./pwd.mjs";
 import { createPrd, listPrds, authoringPrompt } from "./prd.mjs";
@@ -18,7 +19,10 @@ import { createMirror, teeOutput } from "./mirror.mjs";
 import { fetchMotdAd } from "./ads.mjs";
 import { runScript } from "./runtime.mjs";
 import { moshVocabulary } from "./commands.mjs";
-import { mcpCommand, skillCommand } from "./integrations.mjs";
+import { mcpCommand, pluginCommand, skillCommand } from "./integrations.mjs";
+import { tickerCommand } from "./advisor.mjs";
+import { cryptoCommand } from "./crypto.mjs";
+import { canOpenBrowser, openBrowser } from "./open-url.mjs";
 import { banner, hr, acid, ash, bone, dim, ok, err, warn, info, moshcodeVersion } from "./ui.mjs";
 import { CORE_CLI_COMMAND_NAMES } from "./cli-schema.mjs";
 import { findPitCommand, pitHelpModel, renderPitCommand, suggest, wantsHelp } from "./help.mjs";
@@ -156,6 +160,15 @@ function printTools() {
   console.log(ash("   → ") + acid("https://dev.profullstack.com/"));
 }
 
+function printSocials() {
+  console.log(bone("  socials") + ash("  — compose with ") + acid('/post <social> "message"'));
+  for (const social of socialRoster()) {
+    const aliases = social.aliases.length ? ` (${social.aliases.join(", ")})` : "";
+    console.log(`   ${acid("●")} ${bone(social.name.padEnd(9))} ${ash(social.description + aliases)}`);
+  }
+  console.log(ash("   the browser always asks you to confirm before anything is published"));
+}
+
 /**
  * The moshscript vocabulary, split the way the CLI's help splits it.
  *
@@ -660,6 +673,37 @@ export async function tui() {
       rl = mkrl();
       continue;
     }
+    // `/ticker` renders in the pit rather than handing the terminal to a tool:
+    // there is no advis0r binary to launch, only a public read-only API.
+    if (cmd === "ticker" || cmd === "advisor") {
+      await tickerCommand(rest, { openUrl: (url) => canOpenBrowser() && openBrowser(url) });
+      continue;
+    }
+    // `/crypto` renders in the pit for the same reason `/ticker` does: there is
+    // no crypto binary to hand the terminal to, only a public read-only API.
+    if (cmd === "crypto" || cmd === "coins") {
+      await cryptoCommand(rest, { openUrl: (url) => canOpenBrowser() && openBrowser(url) });
+      continue;
+    }
+    if (cmd === "plugin" || cmd === "plugins") {
+      await pluginCommand(rest);
+      continue;
+    }
+    if (cmd === "socials" || cmd === "social") {
+      printSocials();
+      continue;
+    }
+    if (cmd === "post") {
+      const result = postSocial(rest);
+      if (!result.ok) { console.log(err(result.error)); continue; }
+      if (result.opened) {
+        console.log(ok(`opened the ${result.social} composer — confirm the post in your browser 🤘`));
+      } else {
+        console.log(info(`open this ${result.social} composer in a browser:`));
+        console.log(`  ${result.url}`);
+      }
+      continue;
+    }
     // Bare engine name → open it.
     const resolved = resolveEngine(cmd);
     if (resolved) {