magic-spells 0.0.0-stage → 0.1.0

package/dist/main.js

@@ -0,0 +1,557 @@
+import {
+  MagicError,
+  buildContext,
+  cell,
+  configFilePath,
+  contextFor,
+  createCredentialStore,
+  createMcpServer,
+  exitCodeFor,
+  forgetProductKey,
+  jsonMode,
+  manualItem,
+  maskKey,
+  parseGlobals,
+  processIO,
+  productConfig,
+  productEnvVar,
+  readConfigFile,
+  readPackageVersion,
+  render,
+  renderError,
+  resolveCredential,
+  runDoctorChecks,
+  runProductCli,
+  saveProductKey,
+  toMagicError,
+  usage
+} from "./chunk-YT2Z756Z.js";
+
+// src/version.ts
+var cached;
+function version() {
+  return cached ??= readPackageVersion(import.meta.url);
+}
+
+// src/shell.ts
+function chooseEntries(shell, ids) {
+  const known = shell.entries.map((e) => e.id);
+  for (const id of ids ?? []) {
+    if (!known.includes(id)) {
+      throw usage(`unknown product "${id}"`, `Products: ${known.join(", ")}.`);
+    }
+  }
+  return ids ? shell.entries.filter((e) => ids.includes(e.id)) : shell.entries;
+}
+async function loadProducts(shell, ids) {
+  return Promise.all(chooseEntries(shell, ids).map((e) => e.load()));
+}
+function takeValue(args, name) {
+  for (let i = 0; i < args.length; i++) {
+    const tok = args[i];
+    if (tok === `--${name}`) {
+      const v = args[i + 1];
+      if (v === void 0 || v.startsWith("--")) throw usage(`flag --${name} expects a value`);
+      args.splice(i, 2);
+      return v;
+    }
+    if (tok.startsWith(`--${name}=`)) {
+      args.splice(i, 1);
+      return tok.slice(name.length + 3);
+    }
+  }
+  return void 0;
+}
+function wantsHelp(args) {
+  return args.includes("--help") || args.includes("-h");
+}
+function takeSwitch(args, name) {
+  const i = args.indexOf(`--${name}`);
+  if (i < 0) return false;
+  args.splice(i, 1);
+  return true;
+}
+function noMoreArgs(command, args) {
+  if (args.length > 0) throw usage(`${command}: unexpected argument "${args[0]}"`);
+}
+function rejectWorkspace(command, opts) {
+  if (opts.workspace) throw usage(`--workspace is not supported by ${command}`);
+}
+function storeLabel(where) {
+  return where === "keyring" ? "keychain" : where ?? "none";
+}
+function cancelled() {
+  return new MagicError("usage", "Cancelled.");
+}
+
+// src/commands/doctor.ts
+var REACH_TIMEOUT_MS = 5e3;
+async function doctor(shell, argv) {
+  if (wantsHelp(argv)) {
+    shell.io.err("Usage: magic doctor [--json]\n\nCheck the install, the keys and each product.\n");
+    return 0;
+  }
+  rejectWorkspace("doctor", shell.opts);
+  noMoreArgs("doctor", argv);
+  const checks = [...shellChecks(shell)];
+  for (const product of await loadProducts(shell))
+    checks.push(...await productChecks(shell, product));
+  const ok = checks.every((c) => c.ok);
+  if (jsonMode(shell.opts, shell.io)) render({ ok, checks }, shell.opts, shell.io);
+  else printHuman(shell, checks);
+  const failed = checks.find((c) => !c.ok);
+  return failed ? exitCodeFor(failed.code ?? "unknown") : 0;
+}
+function shellChecks(shell) {
+  const fileChosen = shell.env.MAGIC_CREDENTIALS_FILE === "1";
+  return [
+    {
+      name: "cli",
+      product: "magic",
+      ok: true,
+      detail: `magic ${version()}`,
+      data: { version: version() }
+    },
+    // Information only: bin/magic.js exits before this runs on Node < 24.
+    { name: "node", product: "magic", ok: true, detail: `Node ${process.versions.node}` },
+    shell.store.backend === "keyring" ? { name: "credential store", product: "magic", ok: true, detail: "OS keychain" } : {
+      name: "credential store",
+      product: "magic",
+      ok: true,
+      ...fileChosen ? {} : { warn: true },
+      detail: fileChosen ? "file (MAGIC_CREDENTIALS_FILE=1), mode 0600" : "file, mode 0600 \u2014 no OS keychain on this machine"
+    }
+  ];
+}
+async function productChecks(shell, product) {
+  const id = product.id;
+  const networkHint = `Check ${productEnvVar(id, "URL")} and your network connection.`;
+  const fail = (name, err) => {
+    const e = toMagicError(err, { product: id, networkHint });
+    return {
+      name,
+      product: id,
+      ok: false,
+      code: e.code,
+      detail: e.hint ? `${e.message} \u2014 ${e.hint}` : e.message
+    };
+  };
+  let config;
+  try {
+    config = productConfig(product, shell);
+  } catch (err) {
+    return [fail(`${id} config`, err)];
+  }
+  const apiUrl = config.products[id].apiUrl;
+  const results = [];
+  try {
+    const res = await fetch(apiUrl, {
+      method: "HEAD",
+      signal: AbortSignal.timeout(REACH_TIMEOUT_MS)
+    });
+    results.push({
+      name: `${id} api`,
+      product: id,
+      ok: true,
+      detail: `${apiUrl} answers (HTTP ${res.status})`
+    });
+  } catch (err) {
+    results.push(fail(`${id} api`, networkish(err)));
+  }
+  let session;
+  try {
+    session = await resolveCredential(product, { env: shell.env, store: shell.store });
+  } catch (err) {
+    results.push(fail(`${id} key`, err));
+    return results;
+  }
+  results.push({
+    name: `${id} key`,
+    product: id,
+    ok: true,
+    detail: `${maskKey(session.key, product.credential)} from ${session.source === "env" ? "the environment" : "the store"}`
+  });
+  results.push(
+    ...await runDoctorChecks(product.doctor ?? [], contextFor(product, config, session), id)
+  );
+  return results;
+}
+function networkish(err) {
+  if (err instanceof Error && err.cause instanceof Error) {
+    return new Error(`${err.message}: ${err.cause.message}`);
+  }
+  return err;
+}
+function printHuman(shell, checks) {
+  const width = Math.max(...checks.map((c) => c.name.length));
+  const lines = checks.map((c) => {
+    const mark = !c.ok ? "FAIL" : c.warn ? "warn" : "ok  ";
+    return `${mark}  ${c.name.padEnd(width)}  ${c.detail}`;
+  });
+  shell.io.out(`${lines.join("\n")}
+`);
+}
+
+// src/commands/login.ts
+var LOGIN_HELP = `Usage: magic login --product-key [<product>]
+
+Stores a product key (from a hidden prompt, or stdin when piped) in the OS keychain,
+or a 0600 file where there is none. Without <product>, the key's prefix picks it.
+Account sign-in (\`magic login\` alone) arrives in a later release.
+`;
+var LOGOUT_HELP = `Usage: magic logout [--product <product>]
+
+Forgets the stored key of every product, or of one.
+`;
+async function login(shell, argv) {
+  const args = [...argv];
+  if (wantsHelp(args)) {
+    shell.io.err(LOGIN_HELP);
+    return 0;
+  }
+  rejectWorkspace("login", shell.opts);
+  if (!takeSwitch(args, "product-key")) {
+    throw usage(
+      "Account login is not available yet.",
+      "Run `magic login --product-key [<product>]` to store a product key."
+    );
+  }
+  if (args.some((a) => a.includes("_"))) {
+    throw usage(
+      "Keys are never read from arguments.",
+      "Run `magic login --product-key` and paste the key at the prompt, or pipe it on stdin."
+    );
+  }
+  const named = args.length > 0 && !args[0].startsWith("--") ? args.shift() : void 0;
+  if (args.length > 0) {
+    throw usage("login: unexpected arguments.", "Usage: magic login --product-key [<product>]");
+  }
+  const products = await loadProducts(shell, named ? [named] : void 0);
+  const label = named ? `${products[0].title} key` : "Product key";
+  const key = await shell.readSecret(`${label} (input hidden): `);
+  if (!key) throw usage("No key given.", "Paste the key at the prompt, or pipe it on stdin.");
+  const product = named ? products[0] : byPrefix(products, key);
+  await saveProductKey(product, shell.store, key);
+  const where = storeLabel(await shell.store.locate(manualItem(product.id)));
+  envShadowNote(shell, product);
+  render(
+    { product: product.id, key: maskKey(key, product.credential), stored_in: where },
+    shell.opts,
+    shell.io
+  );
+  return 0;
+}
+async function logout(shell, argv) {
+  const args = [...argv];
+  if (wantsHelp(args)) {
+    shell.io.err(LOGOUT_HELP);
+    return 0;
+  }
+  rejectWorkspace("logout", shell.opts);
+  const one = takeValue(args, "product");
+  noMoreArgs("logout", args);
+  const removed = [];
+  for (const product of await loadProducts(shell, one ? [one] : void 0)) {
+    if (await shell.store.locate(manualItem(product.id)) !== null) removed.push(product.id);
+    await forgetProductKey(product, shell.store);
+    envShadowNote(shell, product);
+  }
+  render({ removed }, shell.opts, shell.io);
+  return 0;
+}
+function byPrefix(products, key) {
+  const match = products.find((p) => key.startsWith(p.credential));
+  if (match) return match;
+  throw usage(
+    "The key prefix matches no product.",
+    `Known prefixes: ${products.map((p) => `${p.credential} (${p.id})`).join(", ")}.`
+  );
+}
+function envShadowNote(shell, product) {
+  const envVar = productEnvVar(product.id, "KEY");
+  if (shell.env[envVar]?.trim() && !shell.opts.quiet) {
+    shell.io.err(`note: ${envVar} is set and takes precedence over the stored key.
+`);
+  }
+}
+
+// src/commands/mcp.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+var PREAMBLE = "Magic MCP \u2014 tools for Magic Spells services. Every tool, resource and prompt is prefixed with its product (`pyramid_\u2026`); each product\u2019s rules follow under its own heading. Errors come back as `{ error: { code, message, hint, product } }`: act on `code`.";
+async function buildMcp(shell, argv, signal) {
+  const args = [...argv];
+  rejectWorkspace("mcp", shell.opts);
+  const list = takeValue(args, "products");
+  noMoreArgs("mcp", args);
+  const ids = list?.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  const skipped = /* @__PURE__ */ new Set();
+  const skip = (id, err) => {
+    skipped.add(id);
+    shell.io.err(`magic mcp: ${id}: left out (${toMagicError(err, { product: id }).message})
+`);
+  };
+  const products = [];
+  for (const entry of chooseEntries(shell, ids)) {
+    try {
+      const module = await entry.load();
+      const operations = await module.load();
+      products.push({ module, operations, context: contextSource(shell, module, signal) });
+    } catch (err) {
+      skip(entry.id, err);
+    }
+  }
+  const server = createMcpServer({
+    name: "magic",
+    version: version(),
+    preamble: PREAMBLE,
+    products,
+    onSkip: skip
+  });
+  return { server, products: products.filter((p) => !skipped.has(p.module.id)) };
+}
+function contextSource(shell, module, signal) {
+  return async () => buildContext(module, productConfig(module, shell), {
+    env: shell.env,
+    store: shell.store,
+    signal
+  });
+}
+async function serveMcp(shell, argv) {
+  if (wantsHelp(argv)) {
+    shell.io.err(
+      "Usage: magic mcp [--products a,b]\n\nServe every product\u2019s tools to an MCP host over stdio.\n"
+    );
+    return 0;
+  }
+  guardStdout();
+  const err = (line) => shell.io.err(`magic mcp: ${line}
+`);
+  const controller = new AbortController();
+  const built = await buildMcp(shell, argv, controller.signal);
+  const transport = new StdioServerTransport();
+  let closing = false;
+  const shutdown = async (reason) => {
+    if (closing) return;
+    closing = true;
+    err(`shutting down (${reason}).`);
+    controller.abort();
+    try {
+      await built.server.close();
+    } catch (e) {
+      err(`error during shutdown: ${toMagicError(e).message}`);
+    }
+    process.exit(0);
+  };
+  process.on("SIGINT", () => void shutdown("SIGINT"));
+  process.on("SIGTERM", () => void shutdown("SIGTERM"));
+  process.stdin.on("close", () => void shutdown("stdin closed"));
+  process.stdin.on("end", () => void shutdown("stdin end"));
+  await built.server.connect(transport);
+  const summary = built.products.map((p) => `${p.module.id} (${p.operations.length} tools)`);
+  err(`ready on stdio \xB7 ${summary.join(", ")}`);
+  for (const { module } of built.products) {
+    try {
+      await resolveCredential(module, { env: shell.env, store: shell.store });
+    } catch (e) {
+      const why = toMagicError(e, { product: module.id });
+      err(
+        `${module.id}: ${why.message} Its tools answer ${why.code} until that is fixed. ${why.hint ?? ""}`.trim()
+      );
+    }
+  }
+  return 0;
+}
+function guardStdout() {
+  const toErr = (...args) => {
+    process.stderr.write(`${args.map((a) => typeof a === "string" ? a : String(a)).join(" ")}
+`);
+  };
+  console.log = toErr;
+  console.info = toErr;
+  console.debug = toErr;
+}
+
+// src/commands/whoami.ts
+async function whoami(shell, argv) {
+  if (wantsHelp(argv)) {
+    shell.io.err("Usage: magic whoami [--json]\n\nWho each product key belongs to.\n");
+    return 0;
+  }
+  rejectWorkspace("whoami", shell.opts);
+  noMoreArgs("whoami", argv);
+  const result = { account: null, products: {} };
+  let firstError;
+  for (const product of await loadProducts(shell)) {
+    const entry = await identify(shell, product);
+    result.products[product.id] = entry.identity;
+    firstError ??= entry.error;
+  }
+  if (jsonMode(shell.opts, shell.io)) render(result, shell.opts, shell.io);
+  else printHuman2(shell, result);
+  if (firstError) return exitCodeFor(firstError.code);
+  if (Object.values(result.products).every((p) => p.source === "none")) {
+    if (!shell.opts.quiet) shell.io.err("No product keys. Run `magic login --product-key`.\n");
+    return exitCodeFor("not_logged_in");
+  }
+  return 0;
+}
+async function identify(shell, product) {
+  const source = shell.env[productEnvVar(product.id, "KEY")]?.trim() ? "env" : storeLabel(await shell.store.locate(manualItem(product.id)));
+  if (source === "none") return { identity: { source, key: null, identity: null } };
+  let key = null;
+  try {
+    const session = await resolveCredential(product, { env: shell.env, store: shell.store });
+    key = maskKey(session.key, product.credential);
+    const op = (await product.load()).find((o) => o.name === `${product.id}.whoami`);
+    if (!op) return { identity: { source, key, identity: null } };
+    const config = productConfig(product, shell);
+    const identity = await op.run(op.input.parse({}), contextFor(product, config, session));
+    return { identity: { source, key, identity } };
+  } catch (err) {
+    const error = toMagicError(err, { product: product.id });
+    return { identity: { source, key, identity: null, error: error.toJSON() }, error };
+  }
+}
+function printHuman2(shell, result) {
+  const lines = [];
+  for (const [id, p] of Object.entries(result.products)) {
+    const rows = [
+      ["source", p.source],
+      ...p.key ? [["key", p.key]] : []
+    ];
+    if (p.identity && typeof p.identity === "object") {
+      for (const [k, v] of Object.entries(p.identity)) rows.push([k, cell(v)]);
+    }
+    if (p.error) rows.push(["error", `[${p.error.code}] ${p.error.message}`]);
+    const width = Math.max(...rows.map(([k]) => k.length));
+    lines.push(id, ...rows.map(([k, v]) => `  ${k.padEnd(width)}  ${v}`), "");
+  }
+  shell.io.out(lines.join("\n"));
+}
+
+// src/products.ts
+var PRODUCTS = [
+  {
+    id: "pyramid",
+    title: "Pyramid \u2014 projects and tasks",
+    load: async () => (await import("./src-4S3XHPWY.js")).default
+  }
+];
+
+// src/secret.ts
+async function readSecret(prompt) {
+  const stdin = process.stdin;
+  if (!stdin.isTTY) {
+    process.stderr.write("reading key from stdin\u2026\n");
+    return (await readAll(stdin)).trim();
+  }
+  process.stderr.write(prompt);
+  stdin.setRawMode(true);
+  stdin.setEncoding("utf8");
+  stdin.resume();
+  return new Promise((resolve, reject) => {
+    let value = "";
+    const finish = () => {
+      stdin.off("data", onData);
+      stdin.setRawMode(false);
+      stdin.pause();
+      process.stderr.write("\n");
+    };
+    const onData = (chunk) => {
+      for (const ch of chunk) {
+        if (ch === "\r" || ch === "\n" || ch === "") {
+          finish();
+          resolve(value.trim());
+          return;
+        }
+        if (ch === "") {
+          finish();
+          reject(cancelled());
+          return;
+        }
+        if (ch === "\x7F" || ch === "\b") value = value.slice(0, -1);
+        else value += ch;
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+async function readAll(stream) {
+  let text = "";
+  for await (const chunk of stream) text += String(chunk);
+  return text;
+}
+
+// src/main.ts
+var COMMANDS = {
+  login: { summary: "store a product key: login --product-key [<product>]", run: login },
+  logout: { summary: "forget stored keys: logout [--product <product>]", run: logout },
+  whoami: { summary: "who each product key belongs to", run: whoami },
+  doctor: { summary: "check the install, the keys and each product", run: doctor },
+  mcp: { summary: "serve every product\u2019s tools over stdio: mcp [--products a,b]", run: serveMcp }
+};
+function help(products) {
+  const lines = [
+    "magic \u2014 the command line for Magic Spells services",
+    "",
+    "Usage: magic <command> [args] [--flags]",
+    "       magic <product> <noun> <verb> [args] [--flags]",
+    "",
+    "Commands:",
+    ...Object.entries(COMMANDS).map(([name, c]) => `  ${name.padEnd(21)}${c.summary}`),
+    `  ${"version".padEnd(21)}print the version`,
+    "",
+    "Products:",
+    ...products.map((p) => `  ${p.id.padEnd(21)}${p.title}`),
+    "",
+    "Global flags: --json --yes/-y --no-color --quiet/-q --workspace <handle> --version --help",
+    "Run `magic <product> --help` for a product\u2019s commands.",
+    ""
+  ];
+  return lines.join("\n");
+}
+async function run(argv, deps = {}) {
+  const io = deps.io ?? processIO;
+  const env = deps.env ?? process.env;
+  const products = deps.products ?? PRODUCTS;
+  const [cmd, ...rest] = argv;
+  if (cmd === "version" || cmd === "--version" || cmd === "-v") {
+    io.out(`magic ${version()}
+`);
+    return 0;
+  }
+  if (cmd === void 0 || cmd === "help" || cmd === "--help" || cmd === "-h") {
+    io.err(help(products));
+    return 0;
+  }
+  const store = () => deps.store ?? createCredentialStore({ env });
+  const readConfig = () => readConfigFile(configFilePath({ env }));
+  const entry = products.find((p) => p.id === cmd);
+  if (entry) {
+    const product = await entry.load();
+    return runProductCli(product, rest, { io, env, store: store(), readConfig });
+  }
+  let opts = { json: argv.includes("--json"), yes: false, quiet: false };
+  try {
+    const command = COMMANDS[cmd];
+    if (!command) throw usage(`unknown command "${cmd}"`, "Run `magic --help` for usage.");
+    const parsed = parseGlobals(rest, [], env);
+    opts = parsed.opts;
+    const shell = {
+      io,
+      env,
+      store: store(),
+      entries: products,
+      opts,
+      readConfig,
+      readSecret: deps.readSecret ?? readSecret
+    };
+    return await command.run(shell, parsed.rest);
+  } catch (err) {
+    return renderError(toMagicError(err), opts, io);
+  }
+}
+export {
+  run,
+  version
+};

package/dist/operations-P3DUAVPP.js

@@ -0,0 +1,9 @@
+import {
+  operations,
+  operationsByName
+} from "./chunk-S5IUP7G2.js";
+import "./chunk-YT2Z756Z.js";
+export {
+  operations,
+  operationsByName
+};