@mterminal/mtx 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 mTerminal contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/mtx.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import('../dist/index.js').then((m) => m.run(process.argv.slice(2))).catch((err) => {
+  console.error(err?.stack ?? String(err))
+  process.exit(1)
+})

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+declare function run(argv: string[]): Promise<void>;
+
+export { run };

package/dist/index.js

@@ -0,0 +1,508 @@
+// src/index.ts
+import { cac } from "cac";
+
+// src/commands/init.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+import { fileURLToPath } from "url";
+import prompts from "prompts";
+import pc from "picocolors";
+
+// src/lib/config.ts
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+function configDir() {
+  return process.env.MTX_HOME ?? path.join(os.homedir(), ".mtx");
+}
+function configPath() {
+  return path.join(configDir(), "config.json");
+}
+function defaultEndpoint() {
+  return process.env.MTX_ENDPOINT ?? "https://marketplace.mterminal.dev";
+}
+async function loadConfig() {
+  const file = configPath();
+  try {
+    const raw = await fs.readFile(file, "utf8");
+    const parsed = JSON.parse(raw);
+    return {
+      endpoint: parsed.endpoint ?? defaultEndpoint(),
+      authorId: parsed.authorId,
+      apiKey: parsed.apiKey,
+      githubLogin: parsed.githubLogin,
+      activeKeyId: parsed.activeKeyId
+    };
+  } catch {
+    return { endpoint: defaultEndpoint() };
+  }
+}
+async function saveConfig(cfg) {
+  const dir = configDir();
+  await fs.mkdir(dir, { recursive: true, mode: 448 });
+  const file = configPath();
+  await fs.writeFile(file, JSON.stringify(cfg, null, 2), { mode: 384 });
+}
+async function updateConfig(patch) {
+  const cfg = await loadConfig();
+  const next = { ...cfg, ...patch };
+  await saveConfig(next);
+  return next;
+}
+
+// src/commands/init.ts
+var CATEGORIES = ["productivity", "language", "theme", "remote", "ai", "git", "other"];
+function templatesDir() {
+  const here = path2.dirname(fileURLToPath(import.meta.url));
+  return path2.resolve(here, "..", "templates", "minimal");
+}
+async function copyDir(src, dest) {
+  await fs2.mkdir(dest, { recursive: true });
+  const items = await fs2.readdir(src, { withFileTypes: true });
+  for (const item of items) {
+    const s = path2.join(src, item.name);
+    const d = path2.join(dest, item.name);
+    if (item.isDirectory()) await copyDir(s, d);
+    else await fs2.copyFile(s, d);
+  }
+}
+async function initCommand(suggestedName) {
+  const cfg = await loadConfig();
+  const answers = await prompts([
+    {
+      type: "text",
+      name: "id",
+      message: "extension id (kebab-case)",
+      initial: suggestedName ?? "",
+      validate: (v) => /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/.test(v) ? true : "must be kebab-case"
+    },
+    {
+      type: "text",
+      name: "displayName",
+      message: "display name",
+      initial: (prev) => prev
+    },
+    {
+      type: "select",
+      name: "category",
+      message: "category",
+      choices: CATEGORIES.map((c) => ({ title: c, value: c })),
+      initial: 6
+    },
+    {
+      type: "text",
+      name: "dir",
+      message: "directory",
+      initial: (_p, all) => `./${all.id}`
+    }
+  ]);
+  if (!answers.id) {
+    console.log(pc.yellow("aborted"));
+    return;
+  }
+  const target = path2.resolve(answers.dir);
+  await copyDir(templatesDir(), target);
+  const pkgPath = path2.join(target, "package.json");
+  const raw = await fs2.readFile(pkgPath, "utf8");
+  const pkg = JSON.parse(raw);
+  pkg.name = `mterminal-plugin-${answers.id}`;
+  const mt = pkg.mterminal ?? {};
+  mt.id = answers.id;
+  mt.displayName = answers.displayName || answers.id;
+  mt.category = answers.category;
+  if (cfg.authorId && cfg.activeKeyId) {
+    mt.publisher = { authorId: cfg.authorId, keyId: cfg.activeKeyId };
+  }
+  pkg.mterminal = mt;
+  await fs2.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  console.log(pc.green(`created ${path2.relative(process.cwd(), target)}`));
+  console.log("next:");
+  console.log("  cd", path2.relative(process.cwd(), target));
+  console.log("  npm i");
+  console.log("  npm run build");
+  console.log("  mtx pack");
+  console.log("  mtx publish");
+}
+
+// src/commands/login.ts
+import pc2 from "picocolors";
+
+// src/lib/api.ts
+async function expectJson(res) {
+  const text = await res.text();
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch {
+    throw new Error(`expected json response, got: ${text.slice(0, 200)}`);
+  }
+  if (!res.ok) {
+    const body = json;
+    throw new Error(`HTTP ${res.status}: ${body.error ?? JSON.stringify(json)}`);
+  }
+  return json;
+}
+async function deviceStart(opts) {
+  const r = await fetch(`${opts.endpoint}/v1/auth/device/start`, { method: "POST" });
+  return expectJson(r);
+}
+async function devicePoll(opts, deviceCode) {
+  const r = await fetch(`${opts.endpoint}/v1/auth/device/poll`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ deviceCode })
+  });
+  return expectJson(r);
+}
+async function registerKey(opts, body) {
+  if (!opts.apiKey) throw new Error("apiKey required");
+  const r = await fetch(`${opts.endpoint}/v1/keys`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${opts.apiKey}`
+    },
+    body: JSON.stringify(body)
+  });
+  return expectJson(r);
+}
+async function publishPackage(opts, data) {
+  if (!opts.apiKey) throw new Error("apiKey required");
+  const fd = new FormData();
+  fd.append("package", new Blob([data], { type: "application/zip" }), "package.mtx");
+  const r = await fetch(`${opts.endpoint}/v1/publish`, {
+    method: "POST",
+    headers: { authorization: `Bearer ${opts.apiKey}` },
+    body: fd
+  });
+  const text = await r.text();
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch {
+    throw new Error(`unexpected response: ${text.slice(0, 200)}`);
+  }
+  return json;
+}
+async function yankVersion(opts, id, version) {
+  if (!opts.apiKey) throw new Error("apiKey required");
+  const r = await fetch(`${opts.endpoint}/v1/extensions/${id}/yank/${version}`, {
+    method: "POST",
+    headers: { authorization: `Bearer ${opts.apiKey}` }
+  });
+  await expectJson(r);
+}
+
+// src/commands/login.ts
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function loginCommand() {
+  const cfg = await loadConfig();
+  console.log(pc2.cyan(`endpoint: ${cfg.endpoint}`));
+  const start = await deviceStart({ endpoint: cfg.endpoint });
+  console.log();
+  console.log(`open ${pc2.bold(start.verificationUri)} and enter code:`);
+  console.log(pc2.bold(pc2.yellow(start.userCode)));
+  console.log();
+  const deadline = Date.now() + start.expiresIn * 1e3;
+  let interval = Math.max(start.interval, 2);
+  while (Date.now() < deadline) {
+    await sleep(interval * 1e3);
+    const poll = await devicePoll({ endpoint: cfg.endpoint }, start.deviceCode);
+    if (poll.status === "authorized" && poll.apiKey) {
+      await updateConfig({
+        apiKey: poll.apiKey,
+        authorId: poll.authorId,
+        githubLogin: poll.githubLogin
+      });
+      console.log(pc2.green(`logged in as ${poll.githubLogin} (${poll.authorId})`));
+      return;
+    }
+    if (poll.status === "denied") {
+      console.log(pc2.red("access denied"));
+      return;
+    }
+    if (poll.status === "expired") {
+      console.log(pc2.red("device flow expired, try again"));
+      return;
+    }
+  }
+  console.log(pc2.red("timed out waiting for authorization"));
+}
+
+// src/commands/keygen.ts
+import pc3 from "picocolors";
+
+// src/lib/sign.ts
+import * as ed from "@noble/ed25519";
+import { sha256, sha512 } from "@noble/hashes/sha2";
+import { bytesToHex } from "@noble/hashes/utils";
+ed.etc.sha512Sync = (...m) => sha512(ed.etc.concatBytes(...m));
+function deterministicHashHex(entries) {
+  const sorted = entries.filter((e) => e.path !== "signature.sig").map((e) => ({ path: e.path, hash: bytesToHex(sha256(e.content)) })).sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+  const lines = sorted.map((e) => `${e.path} ${e.hash}
+`).join("");
+  return bytesToHex(sha256(new TextEncoder().encode(lines)));
+}
+async function signEntries(entries, privKey) {
+  const hashHex = deterministicHashHex(entries);
+  const message = new TextEncoder().encode(hashHex);
+  const sig = await ed.signAsync(message, privKey);
+  return Buffer.from(sig).toString("base64");
+}
+async function generateKeyPair() {
+  const priv = ed.utils.randomPrivateKey();
+  const pub = await ed.getPublicKeyAsync(priv);
+  return { priv, pubB64: Buffer.from(pub).toString("base64") };
+}
+
+// src/lib/keystore.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+function keysDir() {
+  return path3.join(configDir(), "keys");
+}
+function keyPaths(keyId) {
+  const safe = keyId.replace(/[^a-zA-Z0-9_:.-]/g, "_");
+  return {
+    privPath: path3.join(keysDir(), `${safe}.priv`),
+    pubPath: path3.join(keysDir(), `${safe}.pub`)
+  };
+}
+async function writeKey(keyId, priv, pubB64) {
+  const dir = keysDir();
+  await fs3.mkdir(dir, { recursive: true, mode: 448 });
+  const paths = keyPaths(keyId);
+  await fs3.writeFile(paths.privPath, Buffer.from(priv).toString("base64"), {
+    mode: 384
+  });
+  await fs3.writeFile(paths.pubPath, pubB64, { mode: 384 });
+  return paths;
+}
+async function readPrivKey(keyId) {
+  const { privPath } = keyPaths(keyId);
+  const raw = await fs3.readFile(privPath, "utf8");
+  return new Uint8Array(Buffer.from(raw.trim(), "base64"));
+}
+
+// src/commands/keygen.ts
+async function keygenCommand(opts = {}) {
+  const cfg = await loadConfig();
+  if (!cfg.apiKey) {
+    console.log(pc3.red("not logged in. run `mtx login` first."));
+    process.exit(1);
+  }
+  const { priv, pubB64 } = await generateKeyPair();
+  const res = await registerKey(
+    { endpoint: cfg.endpoint, apiKey: cfg.apiKey },
+    { pubkeyB64: pubB64, name: opts.name }
+  );
+  await writeKey(res.keyId, priv, pubB64);
+  if (opts.setActive !== false) {
+    await updateConfig({ activeKeyId: res.keyId });
+  }
+  console.log(pc3.green(`registered key ${res.keyId}`));
+  console.log(`active key: ${res.keyId}`);
+}
+
+// src/commands/pack.ts
+import fs5 from "fs/promises";
+import path5 from "path";
+import pc4 from "picocolors";
+
+// src/lib/pack.ts
+import fs4 from "fs/promises";
+import path4 from "path";
+import { zipSync, strToU8 } from "fflate";
+import { validateManifest } from "@mterminal/manifest-validator";
+var INCLUDED_DIRS = ["dist", "themes"];
+var INCLUDED_FILES = ["package.json", "README.md", "readme.md", "icon.png"];
+async function walk(root, prefix = "") {
+  const out = [];
+  let stat;
+  try {
+    stat = await fs4.stat(root);
+  } catch {
+    return out;
+  }
+  if (!stat.isDirectory()) return out;
+  const entries = await fs4.readdir(root, { withFileTypes: true });
+  for (const e of entries) {
+    const abs = path4.join(root, e.name);
+    const rel = prefix ? `${prefix}/${e.name}` : e.name;
+    if (e.isDirectory()) {
+      out.push(...await walk(abs, rel));
+    } else if (e.isFile()) {
+      const content = await fs4.readFile(abs);
+      out.push({ path: rel, content: new Uint8Array(content) });
+    }
+  }
+  return out;
+}
+async function pack(opts) {
+  const pkgPath = path4.join(opts.cwd, "package.json");
+  const raw = await fs4.readFile(pkgPath, "utf8");
+  const pkg = JSON.parse(raw);
+  const mt = pkg.mterminal ?? {};
+  const publisher = mt.publisher ?? {};
+  if (publisher.authorId !== opts.authorId || publisher.keyId !== opts.keyId) {
+    mt.publisher = { authorId: opts.authorId, keyId: opts.keyId };
+    pkg.mterminal = mt;
+    await fs4.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  }
+  const validation = validateManifest(pkg);
+  if (!validation.ok) {
+    throw new Error(`manifest invalid:
+  - ${validation.errors.join("\n  - ")}`);
+  }
+  const entries = [];
+  entries.push({
+    path: "package.json",
+    content: new Uint8Array(await fs4.readFile(pkgPath))
+  });
+  for (const dir of INCLUDED_DIRS) {
+    entries.push(...await walk(path4.join(opts.cwd, dir), dir));
+  }
+  for (const file of INCLUDED_FILES) {
+    if (file === "package.json") continue;
+    const abs = path4.join(opts.cwd, file);
+    try {
+      const buf2 = await fs4.readFile(abs);
+      entries.push({ path: file, content: new Uint8Array(buf2) });
+    } catch {
+    }
+  }
+  const sigB64 = await signEntries(entries, opts.privKey);
+  entries.push({ path: "signature.sig", content: strToU8(sigB64) });
+  const zipMap = {};
+  for (const e of entries) zipMap[e.path] = e.content;
+  const buf = zipSync(zipMap);
+  return {
+    buf,
+    manifestId: validation.manifest.id,
+    version: validation.manifest.version
+  };
+}
+
+// src/commands/pack.ts
+import { spawn } from "child_process";
+function runNpmBuild(cwd) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("npm", ["run", "build"], { cwd, stdio: "inherit" });
+    child.on("exit", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`npm run build exited with ${code}`));
+    });
+    child.on("error", reject);
+  });
+}
+async function packCommand(opts = {}) {
+  const cwd = path5.resolve(opts.cwd ?? process.cwd());
+  const cfg = await loadConfig();
+  if (!cfg.authorId || !cfg.activeKeyId) {
+    console.log(pc4.red("not configured. run `mtx login` and `mtx keygen` first."));
+    process.exit(1);
+  }
+  if (opts.build !== false) {
+    const pkgPath = path5.join(cwd, "package.json");
+    const pkg = JSON.parse(await fs5.readFile(pkgPath, "utf8"));
+    if (pkg.scripts?.build) await runNpmBuild(cwd);
+  }
+  const priv = await readPrivKey(cfg.activeKeyId);
+  const result = await pack({
+    cwd,
+    authorId: cfg.authorId,
+    keyId: cfg.activeKeyId,
+    privKey: priv
+  });
+  const out = path5.resolve(opts.out ?? `${result.manifestId}-${result.version}.mtx`);
+  await fs5.writeFile(out, result.buf);
+  console.log(pc4.green(`packed ${result.manifestId}@${result.version} \u2192 ${out} (${result.buf.length} bytes)`));
+  return out;
+}
+
+// src/commands/publish.ts
+import fs6 from "fs/promises";
+import path6 from "path";
+import pc5 from "picocolors";
+async function publishCommand(opts = {}) {
+  const cfg = await loadConfig();
+  if (!cfg.apiKey) {
+    console.log(pc5.red("not logged in. run `mtx login` first."));
+    process.exit(1);
+  }
+  let file;
+  if (opts.file) {
+    file = path6.resolve(opts.file);
+  } else {
+    file = await packCommand({ cwd: opts.cwd, build: opts.build });
+  }
+  const buf = new Uint8Array(await fs6.readFile(file));
+  console.log(pc5.cyan(`uploading ${path6.basename(file)} (${buf.length} bytes)...`));
+  const result = await publishPackage(
+    { endpoint: cfg.endpoint, apiKey: cfg.apiKey },
+    buf
+  );
+  if (result.ok) {
+    console.log(pc5.green(`published ${result.id}@${result.version}`));
+    return;
+  }
+  console.log(pc5.red("publish failed:"));
+  for (const e of result.errors ?? []) {
+    console.log(pc5.red(`  [${e.code}]`));
+    for (const issue of e.issues) {
+      const loc = issue.path ? ` (${issue.path}${issue.line ? `:${issue.line}` : ""}${issue.col ? `:${issue.col}` : ""})` : "";
+      console.log(`    - ${issue.message}${loc}`);
+    }
+  }
+  process.exit(1);
+}
+
+// src/commands/yank.ts
+import pc6 from "picocolors";
+async function yankCommand(id, version) {
+  const cfg = await loadConfig();
+  if (!cfg.apiKey) {
+    console.log(pc6.red("not logged in"));
+    process.exit(1);
+  }
+  await yankVersion({ endpoint: cfg.endpoint, apiKey: cfg.apiKey }, id, version);
+  console.log(pc6.green(`yanked ${id}@${version}`));
+}
+
+// src/commands/whoami.ts
+import pc7 from "picocolors";
+async function whoamiCommand() {
+  const cfg = await loadConfig();
+  if (!cfg.apiKey) {
+    console.log(pc7.yellow("not logged in"));
+    return;
+  }
+  console.log(`author : ${cfg.authorId ?? "(unknown)"}`);
+  console.log(`login  : ${cfg.githubLogin ?? "(unknown)"}`);
+  console.log(`key    : ${cfg.activeKeyId ?? "(none)"}`);
+  console.log(`server : ${cfg.endpoint}`);
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+async function run(argv) {
+  const cli = cac("mtx");
+  cli.command("init [name]", "scaffold a new extension").action(async (name) => initCommand(name));
+  cli.command("login", "authenticate via github device flow").action(async () => loginCommand());
+  cli.command("keygen", "generate and register a new ed25519 keypair").option("--name <name>", "human-readable name for the key").action(async (opts) => keygenCommand({ name: opts.name }));
+  cli.command("pack", "build and bundle the extension into a .mtx file").option("--out <file>", "output file path").option("--no-build", "skip npm run build").action(
+    async (opts) => packCommand({ out: opts.out, build: opts.build })
+  );
+  cli.command("publish", "pack and upload to the marketplace").option("--file <file>", "use an existing .mtx file instead of packing").option("--no-build", "skip npm run build when packing").action(
+    async (opts) => publishCommand({ file: opts.file, build: opts.build })
+  );
+  cli.command("yank <id> <version>", "mark a published version as yanked").action(async (id, version) => yankCommand(id, version));
+  cli.command("whoami", "show current login info").action(async () => whoamiCommand());
+  cli.help();
+  cli.version(VERSION);
+  cli.parse(["node", "mtx", ...argv], { run: false });
+  await cli.runMatchedCommand();
+}
+export {
+  run
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@mterminal/mtx",
+  "version": "0.1.0",
+  "description": "command-line interface for publishing mterminal extensions to the marketplace",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "mtx": "./bin/mtx.mjs"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "bin",
+    "dist",
+    "templates",
+    "src"
+  ],
+  "dependencies": {
+    "@noble/ed25519": "^2.1.0",
+    "@noble/hashes": "^1.5.0",
+    "cac": "^6.7.14",
+    "fflate": "^0.8.2",
+    "picocolors": "^1.1.1",
+    "prompts": "^2.4.2",
+    "@mterminal/marketplace-types": "0.1.0",
+    "@mterminal/manifest-validator": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.9.0",
+    "@types/prompts": "^2.4.9",
+    "tsup": "^8.3.5",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.5"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}

package/src/commands/init.ts

@@ -0,0 +1,94 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import prompts from 'prompts'
+import pc from 'picocolors'
+import { loadConfig } from '../lib/config'
+
+interface InitAnswers {
+  id: string
+  displayName: string
+  category: string
+  dir: string
+}
+
+const CATEGORIES = ['productivity', 'language', 'theme', 'remote', 'ai', 'git', 'other']
+
+function templatesDir(): string {
+  const here = path.dirname(fileURLToPath(import.meta.url))
+  return path.resolve(here, '..', 'templates', 'minimal')
+}
+
+async function copyDir(src: string, dest: string): Promise<void> {
+  await fs.mkdir(dest, { recursive: true })
+  const items = await fs.readdir(src, { withFileTypes: true })
+  for (const item of items) {
+    const s = path.join(src, item.name)
+    const d = path.join(dest, item.name)
+    if (item.isDirectory()) await copyDir(s, d)
+    else await fs.copyFile(s, d)
+  }
+}
+
+export async function initCommand(suggestedName?: string): Promise<void> {
+  const cfg = await loadConfig()
+  const answers = (await prompts([
+    {
+      type: 'text',
+      name: 'id',
+      message: 'extension id (kebab-case)',
+      initial: suggestedName ?? '',
+      validate: (v: string) =>
+        /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/.test(v) ? true : 'must be kebab-case',
+    },
+    {
+      type: 'text',
+      name: 'displayName',
+      message: 'display name',
+      initial: (prev: string) => prev,
+    },
+    {
+      type: 'select',
+      name: 'category',
+      message: 'category',
+      choices: CATEGORIES.map((c) => ({ title: c, value: c })),
+      initial: 6,
+    },
+    {
+      type: 'text',
+      name: 'dir',
+      message: 'directory',
+      initial: (_p: unknown, all: { id: string }) => `./${all.id}`,
+    },
+  ])) as InitAnswers
+
+  if (!answers.id) {
+    console.log(pc.yellow('aborted'))
+    return
+  }
+
+  const target = path.resolve(answers.dir)
+  await copyDir(templatesDir(), target)
+
+  const pkgPath = path.join(target, 'package.json')
+  const raw = await fs.readFile(pkgPath, 'utf8')
+  const pkg = JSON.parse(raw) as Record<string, unknown>
+  pkg.name = `mterminal-plugin-${answers.id}`
+  const mt = (pkg.mterminal ?? {}) as Record<string, unknown>
+  mt.id = answers.id
+  mt.displayName = answers.displayName || answers.id
+  mt.category = answers.category
+  if (cfg.authorId && cfg.activeKeyId) {
+    mt.publisher = { authorId: cfg.authorId, keyId: cfg.activeKeyId }
+  }
+  pkg.mterminal = mt
+  await fs.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + '\n')
+
+  console.log(pc.green(`created ${path.relative(process.cwd(), target)}`))
+  console.log('next:')
+  console.log('  cd', path.relative(process.cwd(), target))
+  console.log('  npm i')
+  console.log('  npm run build')
+  console.log('  mtx pack')
+  console.log('  mtx publish')
+}