@wirecat/cli-template 0.9.0 → 0.11.0

package/dist/bundle/chunk-RUKDZEID.js

@@ -0,0 +1,73 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  alive
+} from "./chunk-VYSUKHKL.js";
+import {
+  resolvePaths,
+  writeSecurely
+} from "./chunk-EFHLQXG6.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.495.0_@wirecat+cli-base@0.65.0_commander@15.0.0_esbuild@0.28.2_type_24cca5e5c8b0984f2f26e7d1ba6b6d47/node_modules/@wirecat/cli-core/dist/background/lock.js
+import { existsSync, linkSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+var lockPath = /* @__PURE__ */ __name((app, profile, env) => join(resolvePaths({ appName: app.appName, prefix: app.envPrefix, env }).state, "serve", `${profile}.lock`), "lockPath");
+var readLock = /* @__PURE__ */ __name((path) => {
+  try {
+    const lock = JSON.parse(readFileSync(path, "utf8"));
+    return typeof lock.pid === "number" && typeof lock.startedAt === "string" ? lock : void 0;
+  } catch {
+    return void 0;
+  }
+}, "readLock");
+var holdLock = /* @__PURE__ */ __name((path, lock) => writeSecurely(path, `${JSON.stringify(lock)}
+`, 384), "holdLock");
+var takeLock = /* @__PURE__ */ __name((path, lock) => {
+  mkdirSync(dirname(path), { recursive: true, mode: 448 });
+  const draft = `${path}.${lock.pid}.tmp`;
+  writeFileSync(draft, `${JSON.stringify(lock)}
+`, { mode: 384 });
+  try {
+    for (let attempt = 0; attempt < 5; attempt++) {
+      try {
+        linkSync(draft, path);
+        return void 0;
+      } catch (error) {
+        if (error.code !== "EEXIST")
+          throw error;
+      }
+      const held = readLock(path);
+      if (held && held.pid !== lock.pid && alive(held.pid))
+        return held;
+      rmSync(path, { force: true });
+    }
+    throw new Error(`could not take the lock ${path}: it keeps changing`);
+  } finally {
+    rmSync(draft, { force: true });
+  }
+}, "takeLock");
+var releaseLock = /* @__PURE__ */ __name((path, pid = process.pid) => {
+  if (readLock(path)?.pid === pid)
+    rmSync(path, { force: true });
+}, "releaseLock");
+var servingProfiles = /* @__PURE__ */ __name((app, env) => {
+  const dir = dirname(lockPath(app, "default", env));
+  if (!existsSync(dir))
+    return [];
+  return readdirSync(dir).filter((name) => name.endsWith(".lock")).map((name) => name.slice(0, -".lock".length)).filter((profile) => {
+    const lock = readLock(lockPath(app, profile, env));
+    return lock !== void 0 && alive(lock.pid);
+  });
+}, "servingProfiles");
+
+export {
+  lockPath,
+  readLock,
+  holdLock,
+  takeLock,
+  releaseLock,
+  servingProfiles
+};

package/dist/bundle/chunk-SVDF6NJF.js

@@ -0,0 +1,215 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  installerOf,
+  updateCommand
+} from "./chunk-E42W72PQ.js";
+import {
+  DEFAULT_STEMMERS,
+  LANGUAGES
+} from "./chunk-PBN4RBHS.js";
+import {
+  QUESTIONS,
+  readSetupAnswers,
+  unanswered,
+  writeSetupAnswers
+} from "./chunk-O3UXNU3S.js";
+import {
+  sharedConfigPath
+} from "./chunk-FDBINRWA.js";
+import {
+  storePath
+} from "./chunk-IDWW4TU2.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.495.0_@wirecat+cli-base@0.65.0_commander@15.0.0_esbuild@0.28.2_type_24cca5e5c8b0984f2f26e7d1ba6b6d47/node_modules/@wirecat/cli-core/dist/cli/first-run.js
+import { spawnSync } from "node:child_process";
+import { accessSync, constants, realpathSync } from "node:fs";
+import { delimiter, join } from "node:path";
+var SKIPPED = /* @__PURE__ */ new Set(["help", "guide", "completion", "mcp", "serve", "server", "update", "store"]);
+var asksAtStart = /* @__PURE__ */ __name((start) => !start.headless && start.terminal && !start.env.AI_AGENT && !start.env.CLAUDECODE && start.readOnlyLock === void 0 && !SKIPPED.has(start.path[0] ?? ""), "asksAtStart");
+var systemLanguage = /* @__PURE__ */ __name((env) => {
+  const named = [env.LC_ALL, env.LC_MESSAGES, env.LANG, ...(env.LANGUAGE ?? "").split(":")].map((value) => value?.trim()).find((value) => value && value !== "C" && value !== "POSIX" && !value.startsWith("C."));
+  return (named ?? Intl.DateTimeFormat().resolvedOptions().locale).slice(0, 2).toLowerCase();
+}, "systemLanguage");
+var stemmersOf = /* @__PURE__ */ __name((languages) => {
+  const latin = LANGUAGES.filter(({ name, script }) => script === "latin" && languages.includes(name));
+  return {
+    cyrillic: languages.includes("russian") ? "russian" : "none",
+    latin: latin.length ? latin.map(({ name }) => name).join(",") : "none"
+  };
+}, "stemmersOf");
+var languagesOf = /* @__PURE__ */ __name((stemmers) => LANGUAGES.filter(({ name }) => stemmers.cyrillic === name || stemmers.latin.split(",").includes(name)).map(({ name }) => name), "languagesOf");
+var choose = /* @__PURE__ */ __name(async (io, prompt, count, chosen) => {
+  for (let attempt = 0; attempt < 3; attempt++) {
+    const answer = (await io.ask(prompt)).trim();
+    if (!answer)
+      return chosen;
+    if (/^(none|-)$/i.test(answer))
+      return [];
+    const numbers = answer.split(/[\s,]+/).filter(Boolean).map(Number);
+    if (numbers.every((number) => Number.isInteger(number) && number >= 1 && number <= count))
+      return [...new Set(numbers)].sort((a, b) => a - b);
+    io.say(`Choose numbers from 1 to ${count}, separated by commas.`);
+  }
+  return chosen;
+}, "choose");
+var yes = /* @__PURE__ */ __name(async (io, prompt) => /^y(es)?$/i.test((await io.ask(prompt)).trim()), "yes");
+var onPath = /* @__PURE__ */ __name((command, env) => {
+  const names = process.platform === "win32" ? [".cmd", ".exe", ""].map((ending) => command + ending) : [command];
+  return (env.PATH ?? env.Path ?? "").split(delimiter).some((folder) => names.some((name) => {
+    try {
+      accessSync(join(folder, name), process.platform === "win32" ? constants.F_OK : constants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }));
+}, "onPath");
+var installWith = /* @__PURE__ */ __name((argv) => spawnSync(argv[0], argv.slice(1), { stdio: ["inherit", 2, 2] }).status === 0, "installWith");
+var installerHere = /* @__PURE__ */ __name(() => {
+  try {
+    return installerOf(realpathSync(process.argv[1] ?? ""));
+  } catch {
+    return "unknown";
+  }
+}, "installerHere");
+var suggested = /* @__PURE__ */ __name((env, contentLanguages) => {
+  const own = LANGUAGES.filter(({ code }) => contentLanguages?.includes(code));
+  const system = systemLanguage(env);
+  return (own.length ? own : LANGUAGES.filter(({ code }) => code === "en" || code === system)).map(({ name }) => name);
+}, "suggested");
+var askLanguages = /* @__PURE__ */ __name(async ({ command, env, io, contentLanguages }) => {
+  const { openStore } = await import("./store-AH6WZMCF.js");
+  const store = await openStore({ env });
+  let rebuild = false;
+  try {
+    const saved = await store.searchIndex.stemmers() ?? void 0;
+    const inUse = saved !== void 0 || (await store.accounts.accounts()).length > 0;
+    const ticked = inUse ? languagesOf(saved ?? DEFAULT_STEMMERS) : suggested(env, contentLanguages);
+    const numbers = ticked.map((name) => LANGUAGES.findIndex((one) => one.name === name) + 1);
+    io.say("Languages you write and speak \u2014 search finds every form of their words, and spellings speech mangles:");
+    LANGUAGES.forEach(({ name, label }, at) => {
+      io.say(`  ${at + 1}. ${label}${ticked.includes(name) ? " \u2713" : ""}`);
+    });
+    const chosen = await choose(io, `Numbers (${numbers.join(",")}): `, LANGUAGES.length, numbers);
+    const next = stemmersOf(chosen.map((number) => LANGUAGES[number - 1].name));
+    const before = saved ?? DEFAULT_STEMMERS;
+    if (inUse && before.cyrillic === next.cyrillic && before.latin === next.latin)
+      return;
+    if (inUse && !await yes(io, "Rebuild the word forms of every stored message now? Word search waits for it; a large store takes minutes. [y/N] ")) {
+      io.say(`Languages kept as they were; \`${command} setup\` asks again.`);
+      return;
+    }
+    await store.searchIndex.saveStemmers(next);
+    rebuild = inUse;
+  } finally {
+    await store.close();
+  }
+  if (!rebuild)
+    return;
+  const [{ openCache }, { buildStems }] = await Promise.all([
+    import("./open-BR47R5UE.js"),
+    import("./store-maintenance-command-PBXX3IEV.js")
+  ]);
+  const database = await openCache(storePath(env));
+  try {
+    buildStems(database, (note) => io.say(`  ${note}`), { force: true });
+  } finally {
+    database.close();
+  }
+}, "askLanguages");
+var askTools = /* @__PURE__ */ __name(async (run) => {
+  const { command, env, io } = run;
+  const installed = run.installed ?? ((name) => onPath(name, env));
+  const { WIRECAT_TOOLS } = await import("./first-screen-X5IJKBSU.js");
+  const others = WIRECAT_TOOLS.filter((tool) => tool.command !== command);
+  const missing = others.filter((tool) => !installed(tool.command));
+  io.say("Other WireCat tools \u2014 they share this store, so one search finds everything:");
+  for (const tool of others) {
+    const at = missing.indexOf(tool);
+    io.say(`  ${at < 0 ? "\u2713 " : `${at + 1}.`} ${tool.command} \u2014 ${tool.does}`);
+  }
+  if (!missing.length)
+    return;
+  const chosen = await choose(io, "Numbers to install (none): ", missing.length, []);
+  const installer = run.installer ?? installerHere();
+  for (const number of chosen) {
+    const tool = missing[number - 1];
+    const argv = updateCommand(installer, tool.package);
+    if (!argv) {
+      io.say(`Install ${tool.command} with \`npm install -g ${tool.package}\`.`);
+      continue;
+    }
+    io.say(`Installing ${tool.command}: ${argv.join(" ")}`);
+    if (!(run.install ?? installWith)(argv))
+      io.say(`${tool.command} was not installed; run \`${argv.join(" ")}\`.`);
+  }
+}, "askTools");
+var PERMISSION_CHOICES = [
+  { answer: "readonly", text: "read only \u2014 search and read; nothing sends or changes" },
+  { answer: "allow", text: "read and write \u2014 as each profile's permissions allow" }
+];
+var askPermissions = /* @__PURE__ */ __name(async ({ io }, answers) => {
+  const now = answers.permissions ?? "allow";
+  const current = Math.max(1, PERMISSION_CHOICES.findIndex(({ answer }) => answer === now) + 1);
+  io.say("Read only, or read and write? The same for you, scripts and agents over MCP, in every WireCat tool:");
+  PERMISSION_CHOICES.forEach(({ text }, at) => {
+    io.say(`  ${at + 1}. ${text}`);
+  });
+  const [chosen = current] = await choose(io, `Number (${current}): `, PERMISSION_CHOICES.length, [current]);
+  return PERMISSION_CHOICES[chosen - 1].answer;
+}, "askPermissions");
+var answersAt = /* @__PURE__ */ __name((path) => {
+  try {
+    return readSetupAnswers(path);
+  } catch {
+    return {};
+  }
+}, "answersAt");
+var askSetupQuestions = /* @__PURE__ */ __name(async (run) => {
+  const path = sharedConfigPath(storePath(run.env), run.env);
+  const answers = answersAt(path);
+  const asking = run.all ? [...QUESTIONS] : unanswered(answers);
+  for (const question of asking) {
+    run.io.say("");
+    if (question === "languages") {
+      await askLanguages(run);
+      writeSetupAnswers(path, { languages: true });
+    } else if (question === "tools") {
+      await askTools(run);
+      writeSetupAnswers(path, { tools: true });
+    } else
+      writeSetupAnswers(path, { permissions: await askPermissions(run, answers) });
+  }
+  return asking;
+}, "askSetupQuestions");
+var setupAtStart = /* @__PURE__ */ __name(async (start) => {
+  const input = start.input ?? process.stdin;
+  const terminal = start.terminal ?? (input.isTTY === true && process.stderr.isTTY === true);
+  if (!asksAtStart({ ...start, terminal, readOnlyLock: start.readOnlyLock }))
+    return;
+  await askSetupQuestions({
+    command: start.command,
+    env: start.env,
+    contentLanguages: start.contentLanguages,
+    all: start.path[0] === "setup",
+    io: {
+      ask: /* @__PURE__ */ __name(async (prompt) => (await import("./prompt-NE5JJ7UP.js")).readSecret(prompt, { input, echo: true }), "ask"),
+      say: /* @__PURE__ */ __name((text) => process.stderr.write(`${text}
+`), "say")
+    }
+  }).catch((error) => {
+    process.stderr.write(`setup questions skipped: ${error instanceof Error ? error.message : String(error)} \u2014 \`${start.command} setup\` asks them again
+`);
+  });
+}, "setupAtStart");
+
+export {
+  asksAtStart,
+  systemLanguage,
+  askSetupQuestions,
+  setupAtStart
+};

package/dist/bundle/chunk-TAYOKLGF.js

@@ -0,0 +1,193 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  listen
+} from "./chunk-JRK73FOW.js";
+import {
+  ownerLogin
+} from "./chunk-TGB5F7NC.js";
+import {
+  WebStandardStreamableHTTPServerTransport,
+  createMcpHandler,
+  getOAuthProtectedResourceMetadataUrl,
+  hostHeaderValidationResponse,
+  isLegacyRequest,
+  oauthMetadataResponse,
+  requireBearerAuth
+} from "./chunk-5D4AEUVA.js";
+import {
+  activityRecorder,
+  calledTools,
+  httpActivityFile,
+  httpLock
+} from "./chunk-V3ZTQ24B.js";
+import {
+  CliError
+} from "./chunk-EFHLQXG6.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.495.0_@wirecat+cli-base@0.65.0_commander@15.0.0_esbuild@0.28.2_type_24cca5e5c8b0984f2f26e7d1ba6b6d47/node_modules/@wirecat/cli-core/dist/mcp/http/serve.js
+import { randomUUID } from "node:crypto";
+var MCP_PATH = "/mcp";
+var AS_METADATA = "/.well-known/oauth-authorization-server";
+var LOCAL = ["localhost", "127.0.0.1"];
+var MAX_SESSIONS = 20;
+var MAX_LOGIN_BODY = 64 * 1024;
+var SESSION_IDLE_MS = 60 * 60 * 1e3;
+var sessionMissing = /* @__PURE__ */ __name(() => new Response(JSON.stringify({ jsonrpc: "2.0", error: { code: -32001, message: "Session not found" }, id: null }), {
+  status: 404,
+  headers: { "content-type": "application/json" }
+}), "sessionMissing");
+var legacySessions = /* @__PURE__ */ __name((build, now) => {
+  const sessions = /* @__PURE__ */ new Map();
+  const drop = /* @__PURE__ */ __name(async (id) => {
+    const one = sessions.get(id);
+    sessions.delete(id);
+    await one?.close();
+  }, "drop");
+  const handle = /* @__PURE__ */ __name(async (request, auth) => {
+    for (const [id2, one] of sessions)
+      if (now() - one.seen > SESSION_IDLE_MS)
+        await drop(id2);
+    const id = request.headers.get("mcp-session-id");
+    if (id) {
+      const known = sessions.get(id);
+      if (!known || known.clientId !== auth.clientId)
+        return sessionMissing();
+      known.seen = now();
+      return known.transport.handleRequest(request, { authInfo: auth });
+    }
+    const server = build();
+    const transport = new WebStandardStreamableHTTPServerTransport({
+      sessionIdGenerator: /* @__PURE__ */ __name(() => randomUUID(), "sessionIdGenerator"),
+      onsessionclosed: /* @__PURE__ */ __name((closed) => void sessions.delete(closed), "onsessionclosed")
+    });
+    await server.connect(transport);
+    const response = await transport.handleRequest(request, { authInfo: auth });
+    if (!transport.sessionId) {
+      await server.close();
+      return response;
+    }
+    sessions.set(transport.sessionId, { transport, close: /* @__PURE__ */ __name(() => server.close(), "close"), clientId: auth.clientId, seen: now() });
+    while (sessions.size > MAX_SESSIONS)
+      await drop(sessions.keys().next().value);
+    return response;
+  }, "handle");
+  return {
+    handle,
+    close: /* @__PURE__ */ __name(async () => {
+      for (const id of [...sessions.keys()])
+        await drop(id);
+    }, "close")
+  };
+}, "legacySessions");
+var metadataRequest = /* @__PURE__ */ __name((request, path, base) => {
+  const url = new URL(request.url);
+  const inserted = base && path === `${AS_METADATA}${base}`;
+  if (!inserted && url.pathname === path)
+    return request;
+  url.pathname = inserted ? AS_METADATA : path;
+  return new Request(url, { method: request.method, headers: request.headers });
+}, "metadataRequest");
+var toolsIn = /* @__PURE__ */ __name(async (request) => {
+  if (request.method !== "POST")
+    return [];
+  try {
+    return calledTools(await request.clone().json());
+  } catch {
+    return [];
+  }
+}, "toolsIn");
+var serveOverHttp = /* @__PURE__ */ __name(async (build, options) => {
+  const { publicUrl, port, tokenFile, appName, onCode, onError, now, lockFile, version } = options;
+  const lock = lockFile ? httpLock(lockFile, {
+    pid: process.pid,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    port,
+    publicUrl: publicUrl.href,
+    ...version ? { version } : {}
+  }) : void 0;
+  if (lock?.held)
+    throw new CliError("validation_error", `${appName} already serves MCP over HTTP for this profile on port ${lock.held.port} (PID ${lock.held.pid}, since ${lock.held.startedAt})`);
+  const base = publicUrl.pathname === "/" ? "" : publicUrl.pathname.replace(/\/+$/, "");
+  const issuer = new URL(`${publicUrl.origin}${base}`);
+  const resource = new URL(`${base}${MCP_PATH}`, publicUrl.origin);
+  const mcpPath = resource.pathname;
+  const publicPath = /* @__PURE__ */ __name((path) => base && path !== base && !path.startsWith(`${base}/`) && !path.startsWith("/.well-known/") ? `${base}${path}` : path, "publicPath");
+  const login = ownerLogin({
+    issuer,
+    resource,
+    file: tokenFile,
+    appName,
+    onCode: /* @__PURE__ */ __name((code, expires) => {
+      lock?.update({ loginCode: code, loginCodeExpiresAt: expires.toISOString() });
+      onCode(code, expires);
+    }, "onCode"),
+    ...now ? { now } : {}
+  });
+  const insecure = issuer.protocol === "http:" && LOCAL.includes(issuer.hostname);
+  const mcp = createMcpHandler(build, { legacy: "reject", ...onError ? { onerror: onError } : {} });
+  const legacy = legacySessions(build, now ?? Date.now);
+  const bearer = requireBearerAuth({
+    verifier: login.verifier,
+    resourceMetadataUrl: getOAuthProtectedResourceMetadataUrl(resource)
+  });
+  const activity = activityRecorder(httpActivityFile(tokenFile), now);
+  const allowedHosts = [.../* @__PURE__ */ new Set([publicUrl.hostname, ...LOCAL])];
+  const allowedOrigins = [publicUrl.origin];
+  const listening = await listen(async (request) => {
+    const refused = hostHeaderValidationResponse(request, allowedHosts);
+    if (refused)
+      return refused;
+    const path = publicPath(new URL(request.url).pathname);
+    const discovery = oauthMetadataResponse(metadataRequest(request, path, base), {
+      oauthMetadata: login.metadata,
+      resourceServerUrl: resource,
+      resourceName: appName,
+      ...insecure ? { dangerouslyAllowInsecureIssuerUrl: true } : {}
+    });
+    if (discovery)
+      return discovery;
+    if (Number(request.headers.get("content-length") ?? 0) > MAX_LOGIN_BODY && path !== mcpPath)
+      return new Response("Request too large", { status: 413 });
+    const origin = request.headers.get("origin");
+    if (origin && !allowedOrigins.includes(origin))
+      return new Response("Origin not allowed", { status: 403 });
+    const answered = await login.handle(request, path);
+    if (answered)
+      return answered;
+    if (path !== mcpPath)
+      return new Response("Not found", { status: 404 });
+    const auth = await bearer(request);
+    if (auth instanceof Response)
+      return auth;
+    activity.record(auth.clientId, await toolsIn(request));
+    return await isLegacyRequest(request) ? legacy.handle(request, auth) : mcp.fetch(request, { authInfo: auth });
+  }, { host: "127.0.0.1", port }).catch((error) => {
+    login.close();
+    lock?.release();
+    throw error;
+  });
+  lock?.update({ listeningAt: (/* @__PURE__ */ new Date()).toISOString() });
+  return {
+    url: listening.url,
+    close: /* @__PURE__ */ __name(async () => {
+      login.close();
+      activity.flush();
+      try {
+        await listening.close();
+        await legacy.close();
+        await mcp.close();
+      } finally {
+        lock?.release();
+      }
+    }, "close")
+  };
+}, "serveOverHttp");
+
+export {
+  MCP_PATH,
+  serveOverHttp
+};