@wirecat/zoom-cli 0.56.0 → 0.57.0

package/README.md

@@ -94,7 +94,7 @@ More: [the local archive][docs/archive.md] · [search and evidence][docs/search.
 - **Command line + skill.** `zm skill install` adds the packaged guide for Claude Code, Codex and
   Gemini CLI. Every command speaks `--json` or `--jsonl`, and `zm commands --json` describes them all.
 - **MCP.** `zm personal mcp serve` serves zm's commands to Claude Desktop, Cursor and other MCP clients, as
-  far as the profile's permissions allow.
+  far as the profile's permissions allow; `zm mcp serve --profiles all` serves every profile from one server.
   [Connecting a client][docs/mcp.md].
 
 Your agent. Your meetings. Your rules.

package/dist/bin/zm.js

@@ -1,6 +1,36 @@
 #!/usr/bin/env node
-import { enableCompileCache } from "node:module";
-// Static imports would compile before this call; loading the program after it lets later runs reuse the cache.
-enableCompileCache();
-await import("./main.js");
-//# sourceMappingURL=zm.js.map
+// cli-dev bundle loader
+import * as module from "node:module"
+
+const words = process.argv.slice(2)
+// As the CLI answers it, unless a test records the argv: then the CLI writes the record too.
+if (
+  words.length === 1 &&
+  (words[0] === "--version" || words[0] === "-V") &&
+  !Object.keys(process.env).some((key) => key.endsWith("_TEST_ARGV_LOG"))
+) {
+  process.stdout.write("0.57.0\n")
+} else {
+  // Before the bundle compiles: the bundle's own call comes after its chunks.
+  module.enableCompileCache()
+  const serves = ((words) => {
+    const plain = words.filter((word) => !word.startsWith("-"));
+    return plain
+        .slice(0, 4)
+        .some((word, at) => word === "serve" || word === "watch" || (word === "mcp" && plain[at + 1] === undefined));
+})(words)
+  if (serves && module.registerHooks) {
+    const bundle = new URL("../bundle/", import.meta.url).href
+    module.registerHooks({
+      resolve: (specifier, context, next) =>
+        specifier.startsWith("./") && context.parentURL?.startsWith(bundle)
+          ? { url: new URL(specifier, context.parentURL).href, format: "module", shortCircuit: true }
+          : next(specifier, context),
+    })
+  }
+  const running = import("../bundle/zm.js")
+  const chunks = ["../bundle/all-profiles-EKHWTGOY.js","../bundle/answer-policy-KH2IFXPN.js","../bundle/anthropic-VL54IUGF.js","../bundle/bun-ADJVI4HY.js","../bundle/bun-sqlite-2SDA3YOT.js","../bundle/cli-72EQATJF.js","../bundle/command-contract-4MHSZUN3.js","../bundle/config-GFIJK6G2.js","../bundle/dist-IBNHCQXT.js","../bundle/dist-XUFQCJXW.js","../bundle/echarts-RFTK737T.js","../bundle/embed-7QYA2ZZE.js","../bundle/embedder-YNN6PCHG.js","../bundle/first-run-EVSRQKZJ.js","../bundle/first-screen-RG4GUKW7.js","../bundle/folders-JEPOMYM4.js","../bundle/instructions-FHNL7CMW.js","../bundle/main-NYGJXPH7.js","../bundle/mcp-IXFC2VVR.js","../bundle/mcp-VGSZDCKK.js","../bundle/mcp-XKP2PXLS.js","../bundle/meetings-IBPI4MM4.js","../bundle/node-P4E63KXA.js","../bundle/node-TLZSIHIJ.js","../bundle/node-ZMCACJVS.js","../bundle/node-sqlite-ZNGOBA5Q.js","../bundle/oauth-Q6LKF7DB.js","../bundle/open-LJ332Y5O.js","../bundle/output-file-RYQZ3RTE.js","../bundle/process-ZPTLNVQS.js","../bundle/program-IBRQBQ6W.js","../bundle/prompt-RT7GUUXH.js","../bundle/recognize-QXGE7YJH.js","../bundle/remote-FD4MZQV3.js","../bundle/rerank-V6AVV755.js","../bundle/run-log-RE2EI3UU.js","../bundle/serve-HIJTFAW7.js","../bundle/server-3QOXOYYL.js","../bundle/server-WLJCU7KK.js","../bundle/services-KC5KQFBS.js","../bundle/speech-5JOXLYDA.js","../bundle/state-PPGRB3T6.js","../bundle/store-LODVDPK3.js","../bundle/store-WB5BICTG.js","../bundle/store-connection-EG6Z5ITP.js","../bundle/store-maintenance-command-Q5WMFUZ2.js","../bundle/streaming-UGFFNOXL.js","../bundle/tokens-AF5CPY2F.js"]
+  // After the server answers its first request, so it starts no later.
+  if (serves) setTimeout(() => void Promise.allSettled(chunks.map((chunk) => import(chunk))), 2000).unref()
+  await running
+}

package/dist/bundle/all-profiles-EKHWTGOY.js

@@ -0,0 +1,25 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  CHILD_IDLE_MS,
+  allProfilesServer,
+  serveAllProfilesOverHttp,
+  serveAllProfilesOverStdio,
+  withProfile
+} from "./chunk-5F7IOESV.js";
+import "./chunk-AN3GVZTU.js";
+import "./chunk-VPPYYWOH.js";
+import "./chunk-5D4AEUVA.js";
+import "./chunk-2WOGZDZG.js";
+import "./chunk-NO7CJEYV.js";
+import "./chunk-IVQ6342B.js";
+import "./chunk-AE4BOXH7.js";
+import "./chunk-Y5E2WNWB.js";
+import "./chunk-ZVVMGPBJ.js";
+export {
+  CHILD_IDLE_MS,
+  allProfilesServer,
+  serveAllProfilesOverHttp,
+  serveAllProfilesOverStdio,
+  withProfile
+};

package/dist/bundle/answer-policy-KH2IFXPN.js

@@ -0,0 +1,96 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  VERSION
+} from "./chunk-2IKY7VBH.js";
+import "./chunk-NTDWAAGL.js";
+import "./chunk-UI5UTMSZ.js";
+import "./chunk-IP4OK7RQ.js";
+import "./chunk-UC44ZMQV.js";
+import "./chunk-SB6WOSHG.js";
+import "./chunk-O66V2WHK.js";
+import "./chunk-4VCA7QU3.js";
+import "./chunk-G4VZDINN.js";
+import "./chunk-OVSWVPXL.js";
+import "./chunk-GKMGS7G5.js";
+import "./chunk-QLIB3PEC.js";
+import "./chunk-4R7HYNZS.js";
+import "./chunk-ICSKEDPI.js";
+import "./chunk-RRRBMQ2E.js";
+import "./chunk-7JZJMHQY.js";
+import "./chunk-BW2WPOXP.js";
+import "./chunk-G4R4ZIGD.js";
+import {
+  judgedEffects,
+  judgedTargets
+} from "./chunk-MAEFLDHG.js";
+import "./chunk-OCGPZHXW.js";
+import "./chunk-PIN5RZ3D.js";
+import "./chunk-2WOGZDZG.js";
+import "./chunk-EOQFWJJD.js";
+import "./chunk-NO7CJEYV.js";
+import "./chunk-YB4DMKYX.js";
+import "./chunk-BAYNCCNM.js";
+import "./chunk-OIHDCGV4.js";
+import "./chunk-LW2G4U6W.js";
+import "./chunk-S4S7E54J.js";
+import "./chunk-HG5KRV55.js";
+import {
+  failureContext
+} from "./chunk-WQ24UC44.js";
+import "./chunk-LPTIQLDW.js";
+import "./chunk-RMV4C2YL.js";
+import "./chunk-HTQTIKWP.js";
+import "./chunk-LQ3T2ZIX.js";
+import "./chunk-TKCHUT2H.js";
+import "./chunk-HKYLSIZ2.js";
+import "./chunk-HCNMFFG3.js";
+import "./chunk-SE75DPBY.js";
+import "./chunk-MZH4GDR4.js";
+import "./chunk-5QESMCQK.js";
+import "./chunk-CLMXBW53.js";
+import "./chunk-NW3X3G5X.js";
+import "./chunk-WJHK5D7Z.js";
+import "./chunk-6M6FJV5D.js";
+import "./chunk-QUJPQMHJ.js";
+import "./chunk-7GUG6UZS.js";
+import "./chunk-GARCOIB6.js";
+import "./chunk-4YLS4YLS.js";
+import "./chunk-CB5UTASG.js";
+import "./chunk-TZ2MKETI.js";
+import "./chunk-LXB6ONWC.js";
+import "./chunk-LSVI3A5X.js";
+import "./chunk-IVQ6342B.js";
+import {
+  errorObjectOf,
+  errorRecordOf,
+  exitCodeOfError,
+  renderError
+} from "./chunk-AE4BOXH7.js";
+import "./chunk-Y5E2WNWB.js";
+import "./chunk-LY26NW3I.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// dist/answer-policy.js
+var hostFailureContext = /* @__PURE__ */ __name((registry, effects) => ({
+  ...failureContext(),
+  ...effects ? { effects: judgedEffects(effects) } : {},
+  ...registry ? { targets: judgedTargets(registry) } : {}
+}), "hostFailureContext");
+var reportFailure = /* @__PURE__ */ __name((failure, args, deps, command = "zm", context = hostFailureContext()) => {
+  const end = args.indexOf("--");
+  const flags = args.slice(0, end < 0 ? void 0 : end);
+  const machine = flags.some((word) => word === "--json" || word === "--jsonl");
+  const object = errorObjectOf(failure, context);
+  const record = flags.includes("--debug") ? errorRecordOf(failure, object, { command, service: "zm", version: VERSION }) : void 0;
+  const interactive = deps.outputIsTTY === true && !machine;
+  deps.diagnostic(`${renderError(object, { cli: "zm", interactive, ...record ? { record } : {} })}
+`);
+  return exitCodeOfError(object);
+}, "reportFailure");
+export {
+  hostFailureContext,
+  reportFailure
+};

package/dist/bundle/anthropic-VL54IUGF.js

@@ -0,0 +1,70 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  checkedOptions
+} from "./chunk-SE75DPBY.js";
+import {
+  messagesFor,
+  systemFor
+} from "./chunk-MZH4GDR4.js";
+import {
+  Anthropic
+} from "./chunk-ADLS6FVG.js";
+import {
+  array,
+  optional,
+  strictObject,
+  string
+} from "./chunk-AE4BOXH7.js";
+import "./chunk-Y5E2WNWB.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/models/anthropic.js
+var options = strictObject({
+  stop_sequences: optional(array(string()))
+});
+var anthropic = {
+  images: true,
+  baseUrl: "https://api.anthropic.com",
+  validate: /* @__PURE__ */ __name((given) => checkedOptions("anthropic", options, given), "validate"),
+  complete: /* @__PURE__ */ __name(async (target, request, checked, apiKey, fetcher) => {
+    const client = new Anthropic({
+      apiKey: apiKey ?? "",
+      authToken: null,
+      fetch: /* @__PURE__ */ __name((input, init) => fetcher(input, { ...init, redirect: "error" }), "fetch"),
+      baseURL: target.baseUrl,
+      maxRetries: 0,
+      logLevel: "off",
+      timeout: 12e4
+    });
+    const response = await client.messages.stream({
+      ...checked,
+      model: target.model,
+      system: systemFor(request),
+      messages: [
+        ...messagesFor(request),
+        ...request.images === void 0 ? [] : [
+          {
+            role: "user",
+            content: request.images.map((image) => ({
+              type: "image",
+              source: { type: "base64", media_type: image.mimeType, data: image.data }
+            }))
+          }
+        ]
+      ],
+      max_tokens: request.maxTokens
+    }).finalMessage();
+    if (response.stop_reason !== "end_turn")
+      throw new Error("incomplete response");
+    return {
+      text: response.content.filter((block) => block.type === "text").map((block) => block.text).join(""),
+      tokens: response.usage.input_tokens + response.usage.output_tokens + (response.usage.cache_creation_input_tokens ?? 0) + (response.usage.cache_read_input_tokens ?? 0)
+    };
+  }, "complete")
+};
+export {
+  anthropic
+};

package/dist/bundle/bun-ADJVI4HY.js

@@ -0,0 +1,169 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  DefaultLogger,
+  DrizzleQueryError,
+  NoopLogger,
+  SQLiteAsyncDatabase,
+  SQLiteAsyncPreparedQuery,
+  SQLiteAsyncSession,
+  SQLiteAsyncTransaction,
+  SQLiteDialect,
+  booleanFromInteger,
+  bufferFromBytes,
+  castToText,
+  dateFromStoredMilliseconds,
+  dateFromStoredSeconds,
+  entityKind,
+  jitCompatCheck,
+  refineSqliteCodecs,
+  sql
+} from "./chunk-LY26NW3I.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/store/sqlite/drizzle/bun.js
+import { Database } from "bun:sqlite";
+var bunSQLiteCodecs = refineSqliteCodecs({
+  "integer:boolean": { normalize: booleanFromInteger },
+  "integer:timestamp": { normalize: dateFromStoredSeconds },
+  "integer:timestamp_ms": { normalize: dateFromStoredMilliseconds },
+  "text:json": { normalize: JSON.parse },
+  blob: { normalize: bufferFromBytes },
+  "blob:json": {
+    cast: castToText,
+    normalize: JSON.parse
+  },
+  "blob:bigint": {
+    cast: castToText,
+    normalize: BigInt
+  },
+  numeric: {
+    cast: castToText,
+    normalize: String
+  },
+  "numeric:number": { normalize: Number },
+  "numeric:bigint": {
+    cast: castToText,
+    normalize: BigInt
+  }
+});
+var SQLiteBunSession = class extends SQLiteAsyncSession {
+  static {
+    __name(this, "SQLiteBunSession");
+  }
+  client;
+  relations;
+  options;
+  static [entityKind] = "SQLiteBunSession";
+  logger;
+  constructor(client, dialect, relations, options = {}) {
+    super(dialect, "sync");
+    this.client = client;
+    this.relations = relations;
+    this.options = options;
+    this.logger = options.logger ?? new NoopLogger();
+  }
+  exec(query) {
+    this.client.exec(query);
+  }
+  prepareQuery(query, mode, _prepare, executeMethod, mapper, queryMetadata) {
+    let stmt;
+    try {
+      stmt = this.client.query(query.sql);
+    } catch (e) {
+      throw new DrizzleQueryError(query.sql, this.options.paramsInErrors ? query.params : void 0, e);
+    }
+    return new SQLiteAsyncPreparedQuery("sync", executeMethod, {
+      all: /* @__PURE__ */ __name((params) => {
+        if (mode === "arrays") return stmt.values(...params);
+        return stmt.all(...params);
+      }, "all"),
+      get: /* @__PURE__ */ __name((params) => {
+        if (mode === "arrays") return stmt.values(...params)[0];
+        return stmt.get(...params);
+      }, "get"),
+      run: /* @__PURE__ */ __name((params) => {
+        return stmt.run(...params);
+      }, "run")
+    }, query, mapper, mode, this.logger, void 0, queryMetadata, void 0, this.options.paramsInErrors);
+  }
+  transaction(transaction, config = {}) {
+    const tx = new SQLiteBunTransaction("sync", this.dialect, this, this.relations);
+    let result;
+    const nativeTx = this.client.transaction(() => {
+      result = transaction(tx);
+    });
+    if (config.behavior === "concurrent") throw new Error("Concurrent transactions are not supported by driver");
+    nativeTx[config.behavior ?? "deferred"]();
+    return result;
+  }
+};
+var SQLiteBunTransaction = class SQLiteBunTransaction2 extends SQLiteAsyncTransaction {
+  static {
+    __name(this, "SQLiteBunTransaction2");
+  }
+  static [entityKind] = "SQLiteBunTransaction";
+  transaction(transaction) {
+    const savepointName = `sp${this.nestedIndex}`;
+    const tx = new SQLiteBunTransaction2("sync", this.dialect, this.session, this._.relations, this.nestedIndex + 1);
+    this.session.run(sql.raw(`savepoint ${savepointName}`));
+    try {
+      const result = transaction(tx);
+      this.session.run(sql.raw(`release savepoint ${savepointName}`));
+      return result;
+    } catch (err) {
+      try {
+        this.session.run(sql.raw(`rollback to savepoint ${savepointName}`));
+      } catch {
+      }
+      throw err;
+    }
+  }
+};
+var SQLiteBunDatabase = class extends SQLiteAsyncDatabase {
+  static {
+    __name(this, "SQLiteBunDatabase");
+  }
+  static [entityKind] = "SQLiteBunDatabase";
+};
+function construct(client, config = {}) {
+  const dialect = new SQLiteDialect({
+    codecs: config.codecs ?? bunSQLiteCodecs,
+    useJitMappers: jitCompatCheck(config.jit)
+  });
+  let logger;
+  if (config.logger === true) logger = new DefaultLogger();
+  else if (config.logger !== false) logger = config.logger;
+  const relations = config.relations ?? {};
+  const db = new SQLiteBunDatabase("sync", dialect, new SQLiteBunSession(client, dialect, relations, {
+    logger,
+    paramsInErrors: config.paramsInErrors
+  }), relations);
+  db.$client = client;
+  return db;
+}
+__name(construct, "construct");
+function drizzle(...params) {
+  if (params[0] === void 0 || typeof params[0] === "string") return construct(params[0] === void 0 ? new Database() : new Database(params[0]), params[1]);
+  const { connection, client, ...DrizzleSQLiteConfig } = params[0];
+  if (client) return construct(client, DrizzleSQLiteConfig);
+  if (typeof connection === "object") {
+    const { source, ...opts } = connection;
+    const options = Object.values(opts).filter((v) => v !== void 0).length ? opts : void 0;
+    return construct(new Database(source, options), DrizzleSQLiteConfig);
+  }
+  return construct(new Database(connection), DrizzleSQLiteConfig);
+}
+__name(drizzle, "drizzle");
+(function(_drizzle) {
+  function mock(config) {
+    return construct({}, config);
+  }
+  __name(mock, "mock");
+  _drizzle.mock = mock;
+})(drizzle || (drizzle = {}));
+export {
+  drizzle
+};

package/dist/bundle/bun-sqlite-2SDA3YOT.js

@@ -0,0 +1,69 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  loadVectorExtension,
+  vectorExtension
+} from "./chunk-QTR6D5HT.js";
+import "./chunk-AE4BOXH7.js";
+import {
+  importFrom
+} from "./chunk-Y5E2WNWB.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/store/drivers/bun-sqlite.js
+var customised = false;
+var ownLibrary = /* @__PURE__ */ __name(async () => {
+  try {
+    const { libraryFor } = await importFrom(new URL("store/drivers/bun-sqlite.js", import.meta.resolve("@wirecat/cli-core")).href, "@wirecat/cli-core-sqlite");
+    return libraryFor();
+  } catch {
+    return void 0;
+  }
+}, "ownLibrary");
+var bunDatabase = /* @__PURE__ */ __name(async () => {
+  const specifier = "bun:sqlite";
+  const { Database } = await importFrom(new URL("store/drivers/bun-sqlite.js", import.meta.resolve("@wirecat/cli-core")).href, specifier);
+  if (process.platform === "darwin" && !customised) {
+    customised = true;
+    const library = await ownLibrary();
+    if (library)
+      Database.setCustomSQLite(library);
+  }
+  return Database;
+}, "bunDatabase");
+var openWithBunSqlite = /* @__PURE__ */ __name(async (path) => cacheOverBunSqlite(await bunClient(path)), "openWithBunSqlite");
+var bunClient = /* @__PURE__ */ __name(async (path, options) => {
+  const Database = await bunDatabase();
+  const extension = await vectorExtension();
+  const client = options ? new Database(path, options) : new Database(path);
+  try {
+    loadVectorExtension(client, extension);
+    return client;
+  } catch (error) {
+    client.close();
+    throw error;
+  }
+}, "bunClient");
+var cacheOverBunSqlite = /* @__PURE__ */ __name((database) => {
+  return {
+    exec: /* @__PURE__ */ __name((sql) => database.exec(sql), "exec"),
+    prepare: /* @__PURE__ */ __name((sql) => {
+      const statement = database.query(sql);
+      return {
+        run: /* @__PURE__ */ __name((...parameters) => ({ changes: Number(statement.run(...parameters).changes) }), "run"),
+        // Bun answers null for no row; the seam promises undefined, and `!== undefined` checks rely on it.
+        get: /* @__PURE__ */ __name((...parameters) => statement.get(...parameters) ?? void 0, "get"),
+        all: /* @__PURE__ */ __name((...parameters) => statement.all(...parameters), "all")
+      };
+    }, "prepare"),
+    close: /* @__PURE__ */ __name(() => database.close(), "close")
+  };
+}, "cacheOverBunSqlite");
+export {
+  bunClient,
+  bunDatabase,
+  cacheOverBunSqlite,
+  openWithBunSqlite
+};

package/dist/bundle/chunk-2IKY7VBH.js

@@ -0,0 +1,9 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+
+// dist/version.js
+var VERSION = "0.57.0";
+
+export {
+  VERSION
+};