@wrongstack/cli 0.295.1 → 0.296.3

package/dist/chunk-TGDHN4LM.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/boot/auto-discover-providers.ts"],
+  "sourcesContent": ["import * as fs from 'node:fs/promises';\nimport * as path from 'node:path';\nimport type { Config, Logger, ModelsDevProvider, ProviderConfig } from '@wrongstack/core/types';\nimport type { DefaultModelsRegistry } from '@wrongstack/core/models';\nimport { COMPATIBLE_PRESETS, discoverOpenAICompatibleModels } from '@wrongstack/providers';\n\ninterface DiscoverCacheEntry {\n  fetchedAt: string;\n  provider: ModelsDevProvider;\n}\ntype DiscoverCache = Record<string, DiscoverCacheEntry>;\n\n/** Active API key from a ProviderConfig (mirrors the provider factory's resolver). */\nfunction resolveKey(cfg: ProviderConfig): string | undefined {\n  if (Array.isArray(cfg.apiKeys) && cfg.apiKeys.length > 0) {\n    const active = cfg.activeKey\n      ? cfg.apiKeys.find((k) => k.label === cfg.activeKey)\n      : undefined;\n    return (active ?? cfg.apiKeys[0])?.apiKey;\n  }\n  return cfg.apiKey && cfg.apiKey.length > 0 ? cfg.apiKey : undefined;\n}\n\n/** Providers eligible for `/v1/models` auto-discovery and their resolved base URL. */\nfunction eligibleProviders(\n  config: Config,\n): Array<{ id: string; cfg: ProviderConfig; baseUrl: string; apiKey?: string | undefined }> {\n  const out: Array<{\n    id: string;\n    cfg: ProviderConfig;\n    baseUrl: string;\n    apiKey?: string | undefined;\n  }> = [];\n  for (const [id, cfg] of Object.entries(config.providers ?? {})) {\n    const preset = COMPATIBLE_PRESETS[id];\n    const enabled = cfg.autoDiscoverModels ?? preset?.autoDiscover ?? false;\n    if (!enabled) continue;\n    const baseUrl = cfg.baseUrl ?? preset?.defaultBaseUrl;\n    if (!baseUrl) continue;\n    out.push({ id, cfg, baseUrl, apiKey: resolveKey(cfg) });\n  }\n  return out;\n}\n\nasync function readCache(file: string): Promise<DiscoverCache> {\n  try {\n    return JSON.parse(await fs.readFile(file, 'utf8')) as DiscoverCache;\n  } catch {\n    return {};\n  }\n}\n\n/**\n * Fetch model lists for every auto-discovery provider in the config and merge\n * them into the catalog. Best-effort end to end: a down server or missing key\n * falls back to the last cached list (any age \u2014 a local proxy being offline at\n * boot shouldn't wipe its models), and any failure is a logged no-op so boot\n * never breaks.\n *\n * Caches the most recent successful fetch per provider+baseUrl so the models\n * survive a restart while the server is briefly unavailable.\n */\nexport async function discoverAndMergeProviders(opts: {\n  config: Config;\n  registry: DefaultModelsRegistry;\n  cacheDir: string;\n  logger?: Logger | undefined;\n  fetchImpl?: typeof fetch | undefined;\n}): Promise<void> {\n  const targets = eligibleProviders(opts.config);\n  if (targets.length === 0) return;\n\n  const cacheFile = path.join(opts.cacheDir, 'discovered-models-cache.json');\n  const cache = await readCache(cacheFile);\n  let cacheDirty = false;\n\n  await Promise.all(\n    targets.map(async ({ id, cfg, baseUrl, apiKey }) => {\n      const cacheKey = `${id}\u0000${baseUrl}`;\n      const provider = await discoverOpenAICompatibleModels(id, {\n        baseUrl,\n        apiKey,\n        headers: cfg.headers,\n        providerName: id,\n        fetchImpl: opts.fetchImpl,\n      });\n      if (provider) {\n        cache[cacheKey] = { fetchedAt: new Date().toISOString(), provider };\n        cacheDirty = true;\n        opts.registry.mergeOverlay({ [id]: provider });\n        opts.logger?.info(\n          `auto-discovered ${Object.keys(provider.models).length} models for \"${id}\" from ${baseUrl}`,\n        );\n        return;\n      }\n      // Fetch failed \u2014 fall back to the last cached list, if any.\n      const cached = cache[cacheKey];\n      if (cached) {\n        opts.registry.mergeOverlay({ [id]: cached.provider });\n        opts.logger?.warn(\n          `auto-discovery for \"${id}\" failed; using ${\n            Object.keys(cached.provider.models).length\n          } cached models from ${cached.fetchedAt}`,\n        );\n      } else {\n        opts.logger?.warn(\n          `auto-discovery for \"${id}\" failed and no cache available (server at ${baseUrl} unreachable?)`,\n        );\n      }\n    }),\n  );\n\n  if (cacheDirty) {\n    try {\n      await fs.writeFile(cacheFile, JSON.stringify(cache), 'utf8');\n    } catch {\n      // best-effort cache write\n    }\n  }\n}\n"],
+  "mappings": ";;;AAAA,YAAY,QAAQ;AACpB,YAAY,UAAU;AAGtB,SAAS,oBAAoB,sCAAsC;AASnE,SAAS,WAAW,KAAyC;AAC3D,MAAI,MAAM,QAAQ,IAAI,OAAO,KAAK,IAAI,QAAQ,SAAS,GAAG;AACxD,UAAM,SAAS,IAAI,YACf,IAAI,QAAQ,KAAK,CAAC,MAAM,EAAE,UAAU,IAAI,SAAS,IACjD;AACJ,YAAQ,UAAU,IAAI,QAAQ,CAAC,IAAI;AAAA,EACrC;AACA,SAAO,IAAI,UAAU,IAAI,OAAO,SAAS,IAAI,IAAI,SAAS;AAC5D;AAGA,SAAS,kBACP,QAC0F;AAC1F,QAAM,MAKD,CAAC;AACN,aAAW,CAAC,IAAI,GAAG,KAAK,OAAO,QAAQ,OAAO,aAAa,CAAC,CAAC,GAAG;AAC9D,UAAM,SAAS,mBAAmB,EAAE;AACpC,UAAM,UAAU,IAAI,sBAAsB,QAAQ,gBAAgB;AAClE,QAAI,CAAC,QAAS;AACd,UAAM,UAAU,IAAI,WAAW,QAAQ;AACvC,QAAI,CAAC,QAAS;AACd,QAAI,KAAK,EAAE,IAAI,KAAK,SAAS,QAAQ,WAAW,GAAG,EAAE,CAAC;AAAA,EACxD;AACA,SAAO;AACT;AAEA,eAAe,UAAU,MAAsC;AAC7D,MAAI;AACF,WAAO,KAAK,MAAM,MAAS,YAAS,MAAM,MAAM,CAAC;AAAA,EACnD,QAAQ;AACN,WAAO,CAAC;AAAA,EACV;AACF;AAYA,eAAsB,0BAA0B,MAM9B;AAChB,QAAM,UAAU,kBAAkB,KAAK,MAAM;AAC7C,MAAI,QAAQ,WAAW,EAAG;AAE1B,QAAM,YAAiB,UAAK,KAAK,UAAU,8BAA8B;AACzE,QAAM,QAAQ,MAAM,UAAU,SAAS;AACvC,MAAI,aAAa;AAEjB,QAAM,QAAQ;AAAA,IACZ,QAAQ,IAAI,OAAO,EAAE,IAAI,KAAK,SAAS,OAAO,MAAM;AAClD,YAAM,WAAW,GAAG,EAAE,KAAI,OAAO;AACjC,YAAM,WAAW,MAAM,+BAA+B,IAAI;AAAA,QACxD;AAAA,QACA;AAAA,QACA,SAAS,IAAI;AAAA,QACb,cAAc;AAAA,QACd,WAAW,KAAK;AAAA,MAClB,CAAC;AACD,UAAI,UAAU;AACZ,cAAM,QAAQ,IAAI,EAAE,YAAW,oBAAI,KAAK,GAAE,YAAY,GAAG,SAAS;AAClE,qBAAa;AACb,aAAK,SAAS,aAAa,EAAE,CAAC,EAAE,GAAG,SAAS,CAAC;AAC7C,aAAK,QAAQ;AAAA,UACX,mBAAmB,OAAO,KAAK,SAAS,MAAM,EAAE,MAAM,gBAAgB,EAAE,UAAU,OAAO;AAAA,QAC3F;AACA;AAAA,MACF;AAEA,YAAM,SAAS,MAAM,QAAQ;AAC7B,UAAI,QAAQ;AACV,aAAK,SAAS,aAAa,EAAE,CAAC,EAAE,GAAG,OAAO,SAAS,CAAC;AACpD,aAAK,QAAQ;AAAA,UACX,uBAAuB,EAAE,mBACvB,OAAO,KAAK,OAAO,SAAS,MAAM,EAAE,MACtC,uBAAuB,OAAO,SAAS;AAAA,QACzC;AAAA,MACF,OAAO;AACL,aAAK,QAAQ;AAAA,UACX,uBAAuB,EAAE,8CAA8C,OAAO;AAAA,QAChF;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH;AAEA,MAAI,YAAY;AACd,QAAI;AACF,YAAS,aAAU,WAAW,KAAK,UAAU,KAAK,GAAG,MAAM;AAAA,IAC7D,QAAQ;AAAA,IAER;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/chunk-TYO2OVAD.js

@@ -0,0 +1,50 @@
+
+// src/utils.ts
+function fmtTok(n) {
+  if (n < 1e3) return String(n);
+  if (n < 1e6) return `${(n / 1e3).toFixed(n < 1e4 ? 1 : 0)}k`;
+  return `${(n / 1e6).toFixed(1)}M`;
+}
+function patchConfig(base, patch) {
+  return Object.freeze({ ...base, ...patch });
+}
+function fmtDuration(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  const s = ms / 1e3;
+  if (s < 60) return `${s.toFixed(s < 10 ? 1 : 0)}s`;
+  const m = Math.floor(s / 60);
+  const remSec = Math.round(s - m * 60);
+  if (m < 60) return remSec === 0 ? `${m}m` : `${m}m${remSec}s`;
+  const h = Math.floor(m / 60);
+  const remMin = m - h * 60;
+  return `${h}h${remMin}m`;
+}
+function fmtTaskResultLine(r, color) {
+  const stats = `${r.iterations}it ${r.toolCalls}tc ${fmtDuration(r.durationMs)}`;
+  const errMsg = typeof r.error === "string" ? r.error : r.error?.message;
+  const errKind = typeof r.error === "object" ? r.error?.kind : void 0;
+  const errTail = errMsg ? ` \u2014 ${errMsg.replace(/\s+/g, " ").slice(0, 80)}${errMsg.length > 80 ? "\u2026" : ""}` : "";
+  const errKindChip = errKind ? color.dim(` [${errKind}]`) : "";
+  const errSnip = errMsg || errKind ? `${errKindChip}${color.dim(errTail)}` : "";
+  switch (r.status) {
+    case "success":
+      return { mark: color.green("\u2713"), stats, tail: "" };
+    case "timeout":
+      return {
+        mark: color.yellow("\u23F1"),
+        stats: `${color.yellow("timeout")} ${stats}`,
+        tail: errSnip
+      };
+    case "stopped":
+      return { mark: color.dim("\u2298"), stats: `${color.dim("stopped")} ${stats}`, tail: errSnip };
+    case "failed":
+      return { mark: color.red("\u2717"), stats: `${color.red("failed")} ${stats}`, tail: errSnip };
+  }
+}
+
+export {
+  fmtTok,
+  patchConfig,
+  fmtTaskResultLine
+};
+//# sourceMappingURL=chunk-TYO2OVAD.js.map

package/dist/chunk-TYO2OVAD.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/utils.ts"],
+  "sourcesContent": ["/**\n * Format a token count for human-readable display.\n *   999 \u2192 \"999\"\n *   1_200 \u2192 \"1.2k\"\n *   12_000 \u2192 \"12k\"\n *   1_500_000 \u2192 \"1.5M\"\n */\nexport function fmtTok(n: number): string {\n  if (n < 1000) return String(n);\n  if (n < 1_000_000) return `${(n / 1000).toFixed(n < 10_000 ? 1 : 0)}k`;\n  return `${(n / 1_000_000).toFixed(1)}M`;\n}\n\n/**\n * Return a new frozen config object with the given patch applied.\n * Config objects are frozen by the config loader \u2014 direct mutation\n * silently fails at runtime. This helper spreads + re-freezes safely.\n */\nexport function patchConfig<T extends object>(base: T, patch: Partial<T>): T {\n  return Object.freeze({ ...base, ...patch }) as T;\n}\n\n/**\n * Human-readable duration: 999 \u2192 \"999ms\", 12_500 \u2192 \"12.5s\",\n * 160_016 \u2192 \"2m40s\", 7_200_000 \u2192 \"2h0m\". Used by `/agents` and\n * `/fleet status` so users don't have to read \"160016ms\" and do the\n * conversion in their head.\n */\nexport function fmtDuration(ms: number): string {\n  if (ms < 1000) return `${ms}ms`;\n  const s = ms / 1000;\n  if (s < 60) return `${s.toFixed(s < 10 ? 1 : 0)}s`;\n  const m = Math.floor(s / 60);\n  const remSec = Math.round(s - m * 60);\n  if (m < 60) return remSec === 0 ? `${m}m` : `${m}m${remSec}s`;\n  const h = Math.floor(m / 60);\n  const remMin = m - h * 60;\n  return `${h}h${remMin}m`;\n}\n\n/**\n * Render a completed TaskResult into a single line for `/agents` and\n * `/fleet status`. Distinguishes all four terminal statuses with\n * separate icons + colors so users can tell a timeout from a real\n * failure at a glance, and surfaces both the failure kind (e.g.\n * `provider_rate_limit`, `tool_failed`) and a truncated error tail\n * (previously dropped on the floor).\n *\n * Accepts either the structured `SubagentError` envelope (current) or\n * a legacy string error \u2014 the field shape is widened to keep older\n * callers compiling while migrations roll through.\n *\n * The caller passes the color helper (it lives in @wrongstack/core)\n * to avoid a circular import from this utility module.\n */\nexport function fmtTaskResultLine(\n  r: {\n    status: 'success' | 'failed' | 'timeout' | 'stopped';\n    error?:\n      | string\n      | {\n          kind?: string | undefined;\n          message?: string | undefined;\n          retryable?: boolean | undefined;\n          backoffMs?: number | undefined;\n        }\n      | undefined;\n    iterations: number;\n    toolCalls: number;\n    durationMs: number;\n  },\n  color: {\n    green(s: string): string;\n    red(s: string): string;\n    yellow(s: string): string;\n    dim(s: string): string;\n  },\n): { mark: string; stats: string; tail: string } {\n  const stats = `${r.iterations}it ${r.toolCalls}tc ${fmtDuration(r.durationMs)}`;\n  // Error tails are unbounded provider strings \u2014 collapse whitespace and\n  // truncate so a 2KB stack trace can't blow up the chat line. Lift the\n  // structured `kind` chip in front of the tail so the user reads\n  // `\u2717 failed [provider_rate_limit] \u2014 server overloaded` instead of\n  // raw verbose body.\n  const errMsg = typeof r.error === 'string' ? r.error : r.error?.message;\n  const errKind = typeof r.error === 'object' ? r.error?.kind : undefined;\n  const errTail = errMsg\n    ? ` \u2014 ${errMsg.replace(/\\s+/g, ' ').slice(0, 80)}${errMsg.length > 80 ? '\u2026' : ''}`\n    : '';\n  const errKindChip = errKind ? color.dim(` [${errKind}]`) : '';\n  const errSnip = errMsg || errKind ? `${errKindChip}${color.dim(errTail)}` : '';\n  switch (r.status) {\n    case 'success':\n      return { mark: color.green('\u2713'), stats, tail: '' };\n    case 'timeout':\n      return {\n        mark: color.yellow('\u23F1'),\n        stats: `${color.yellow('timeout')} ${stats}`,\n        tail: errSnip,\n      };\n    case 'stopped':\n      return { mark: color.dim('\u2298'), stats: `${color.dim('stopped')} ${stats}`, tail: errSnip };\n    case 'failed':\n      return { mark: color.red('\u2717'), stats: `${color.red('failed')} ${stats}`, tail: errSnip };\n  }\n}\n"],
+  "mappings": ";;;AAOO,SAAS,OAAO,GAAmB;AACxC,MAAI,IAAI,IAAM,QAAO,OAAO,CAAC;AAC7B,MAAI,IAAI,IAAW,QAAO,IAAI,IAAI,KAAM,QAAQ,IAAI,MAAS,IAAI,CAAC,CAAC;AACnE,SAAO,IAAI,IAAI,KAAW,QAAQ,CAAC,CAAC;AACtC;AAOO,SAAS,YAA8B,MAAS,OAAsB;AAC3E,SAAO,OAAO,OAAO,EAAE,GAAG,MAAM,GAAG,MAAM,CAAC;AAC5C;AAQO,SAAS,YAAY,IAAoB;AAC9C,MAAI,KAAK,IAAM,QAAO,GAAG,EAAE;AAC3B,QAAM,IAAI,KAAK;AACf,MAAI,IAAI,GAAI,QAAO,GAAG,EAAE,QAAQ,IAAI,KAAK,IAAI,CAAC,CAAC;AAC/C,QAAM,IAAI,KAAK,MAAM,IAAI,EAAE;AAC3B,QAAM,SAAS,KAAK,MAAM,IAAI,IAAI,EAAE;AACpC,MAAI,IAAI,GAAI,QAAO,WAAW,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC,IAAI,MAAM;AAC1D,QAAM,IAAI,KAAK,MAAM,IAAI,EAAE;AAC3B,QAAM,SAAS,IAAI,IAAI;AACvB,SAAO,GAAG,CAAC,IAAI,MAAM;AACvB;AAiBO,SAAS,kBACd,GAeA,OAM+C;AAC/C,QAAM,QAAQ,GAAG,EAAE,UAAU,MAAM,EAAE,SAAS,MAAM,YAAY,EAAE,UAAU,CAAC;AAM7E,QAAM,SAAS,OAAO,EAAE,UAAU,WAAW,EAAE,QAAQ,EAAE,OAAO;AAChE,QAAM,UAAU,OAAO,EAAE,UAAU,WAAW,EAAE,OAAO,OAAO;AAC9D,QAAM,UAAU,SACZ,WAAM,OAAO,QAAQ,QAAQ,GAAG,EAAE,MAAM,GAAG,EAAE,CAAC,GAAG,OAAO,SAAS,KAAK,WAAM,EAAE,KAC9E;AACJ,QAAM,cAAc,UAAU,MAAM,IAAI,KAAK,OAAO,GAAG,IAAI;AAC3D,QAAM,UAAU,UAAU,UAAU,GAAG,WAAW,GAAG,MAAM,IAAI,OAAO,CAAC,KAAK;AAC5E,UAAQ,EAAE,QAAQ;AAAA,IAChB,KAAK;AACH,aAAO,EAAE,MAAM,MAAM,MAAM,QAAG,GAAG,OAAO,MAAM,GAAG;AAAA,IACnD,KAAK;AACH,aAAO;AAAA,QACL,MAAM,MAAM,OAAO,QAAG;AAAA,QACtB,OAAO,GAAG,MAAM,OAAO,SAAS,CAAC,IAAI,KAAK;AAAA,QAC1C,MAAM;AAAA,MACR;AAAA,IACF,KAAK;AACH,aAAO,EAAE,MAAM,MAAM,IAAI,QAAG,GAAG,OAAO,GAAG,MAAM,IAAI,SAAS,CAAC,IAAI,KAAK,IAAI,MAAM,QAAQ;AAAA,IAC1F,KAAK;AACH,aAAO,EAAE,MAAM,MAAM,IAAI,QAAG,GAAG,OAAO,GAAG,MAAM,IAAI,QAAQ,CAAC,IAAI,KAAK,IAAI,MAAM,QAAQ;AAAA,EAC3F;AACF;",
+  "names": []
+}

package/dist/chunk-VCYZ3WZV.js

@@ -0,0 +1,14 @@
+
+// src/webui-server/kanban-run-mirror.ts
+import {
+  buildTaskGraphFromGoalPhase,
+  buildTaskGraphFromSddSnapshot,
+  createKanbanRunMirror
+} from "@wrongstack/webui-server";
+
+export {
+  buildTaskGraphFromGoalPhase,
+  buildTaskGraphFromSddSnapshot,
+  createKanbanRunMirror
+};
+//# sourceMappingURL=chunk-VCYZ3WZV.js.map

package/dist/chunk-VCYZ3WZV.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/webui-server/kanban-run-mirror.ts"],
+  "sourcesContent": ["export {\n  buildTaskGraphFromGoalPhase,\n  buildTaskGraphFromSddSnapshot,\n  createKanbanRunMirror,\n  type KanbanRunMirror,\n  type KanbanRunMirrorDeps,\n} from '@wrongstack/webui-server';\n"],
+  "mappings": ";;;AAAA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAGK;",
+  "names": []
+}

package/dist/chunk-VJUEZZYB.js

@@ -0,0 +1,29 @@
+
+// src/utils/win32-cmd.ts
+var WIN32_CMD_META = /[&|<>"\r\n\0]/;
+function buildWin32CmdShimInvocation(command, args = []) {
+  assertSafeWin32CmdArgs([command, ...args]);
+  const line = ["call", quoteWin32CmdArg(command), ...args.map(quoteWin32CmdArg)].join(" ");
+  return {
+    command: process.env["COMSPEC"] ?? "cmd.exe",
+    args: ["/d", "/c", line],
+    windowsVerbatimArguments: true
+  };
+}
+function assertSafeWin32CmdArgs(args) {
+  for (const arg of args) {
+    if (typeof arg === "string" && WIN32_CMD_META.test(arg)) {
+      throw new Error(
+        'win32 cmd shim spawn: argument contains a shell metacharacter (one of & | < > ", or a newline) that could enable command injection through the .cmd/.bat wrapper - refusing to run. Offending argument: ' + JSON.stringify(arg)
+      );
+    }
+  }
+}
+function quoteWin32CmdArg(arg) {
+  return `"${arg}"`;
+}
+
+export {
+  buildWin32CmdShimInvocation
+};
+//# sourceMappingURL=chunk-VJUEZZYB.js.map

package/dist/chunk-VJUEZZYB.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/utils/win32-cmd.ts"],
+  "sourcesContent": ["const WIN32_CMD_META = /[&|<>\"\\r\\n\\0]/;\n\nexport interface Win32CmdShimInvocation {\n  command: string;\n  args: string[];\n  windowsVerbatimArguments: true;\n}\n\nexport function buildWin32CmdShimInvocation(\n  command: string,\n  args: readonly string[] = [],\n): Win32CmdShimInvocation {\n  assertSafeWin32CmdArgs([command, ...args]);\n  const line = ['call', quoteWin32CmdArg(command), ...args.map(quoteWin32CmdArg)].join(' ');\n  return {\n    command: process.env['COMSPEC'] ?? 'cmd.exe',\n    args: ['/d', '/c', line],\n    windowsVerbatimArguments: true,\n  };\n}\n\nfunction assertSafeWin32CmdArgs(args: readonly unknown[]): void {\n  for (const arg of args) {\n    if (typeof arg === 'string' && WIN32_CMD_META.test(arg)) {\n      throw new Error(\n        'win32 cmd shim spawn: argument contains a shell metacharacter ' +\n          '(one of & | < > \", or a newline) that could enable command injection ' +\n          'through the .cmd/.bat wrapper - refusing to run. Offending argument: ' +\n          JSON.stringify(arg),\n      );\n    }\n  }\n}\n\nfunction quoteWin32CmdArg(arg: string): string {\n  return `\"${arg}\"`;\n}\n"],
+  "mappings": ";;;AAAA,IAAM,iBAAiB;AAQhB,SAAS,4BACd,SACA,OAA0B,CAAC,GACH;AACxB,yBAAuB,CAAC,SAAS,GAAG,IAAI,CAAC;AACzC,QAAM,OAAO,CAAC,QAAQ,iBAAiB,OAAO,GAAG,GAAG,KAAK,IAAI,gBAAgB,CAAC,EAAE,KAAK,GAAG;AACxF,SAAO;AAAA,IACL,SAAS,QAAQ,IAAI,SAAS,KAAK;AAAA,IACnC,MAAM,CAAC,MAAM,MAAM,IAAI;AAAA,IACvB,0BAA0B;AAAA,EAC5B;AACF;AAEA,SAAS,uBAAuB,MAAgC;AAC9D,aAAW,OAAO,MAAM;AACtB,QAAI,OAAO,QAAQ,YAAY,eAAe,KAAK,GAAG,GAAG;AACvD,YAAM,IAAI;AAAA,QACR,6MAGE,KAAK,UAAU,GAAG;AAAA,MACtB;AAAA,IACF;AAAA,EACF;AACF;AAEA,SAAS,iBAAiB,KAAqB;AAC7C,SAAO,IAAI,GAAG;AAChB;",
+  "names": []
+}

package/dist/chunk-WHOIR577.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-WHOIR577.js.map

package/dist/chunk-WHOIR577.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/chunk-WY7KKOUK.js

@@ -0,0 +1,460 @@
+
+// src/hq-publisher.ts
+import { createHqPublisherFromEnv, resolveHqConfig } from "@wrongstack/core/hq";
+import { WebSocket } from "ws";
+
+// src/kanban-hq-sync.ts
+import { deriveHqProjectId } from "@wrongstack/core/hq";
+import {
+  bridgeKanbanSupervisor,
+  deleteBoard,
+  listBoardIds,
+  readBoard,
+  readKanbanMetadata,
+  writeBoard,
+  writeKanbanMetadata
+} from "@wrongstack/kanban";
+var SYNC_STATE_KEY = "hq-sync-state-v1";
+var MAX_KANBAN_SNAPSHOT_PAYLOAD_BYTES = 512 * 1024;
+var KANBAN_TOMBSTONE_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
+var MAX_BOARDS_PER_PUBLISH = 50;
+function warnSyncFailure(error) {
+  process.emitWarning(
+    `WrongStack kanban HQ sync failed (best-effort, will retry on next change): ${error instanceof Error ? error.message : String(error)}`,
+    { code: "WRONGSTACK_HQ_KANBAN_SYNC_FAILED" }
+  );
+}
+function createKanbanHqSync(projectRoot, projectId = deriveHqProjectId(projectRoot)) {
+  let publisher;
+  let unsubscribeDaemon;
+  let daemonConnectionCount = 0;
+  let timer;
+  const pendingBoardIds = /* @__PURE__ */ new Set();
+  let fullRescanPending = false;
+  let applyingRemote = false;
+  let stopped = false;
+  let operationChain = Promise.resolve();
+  let pendingRemote = null;
+  let remoteApplyQueued = false;
+  const runExclusive = (operation) => {
+    let resolveResult;
+    let rejectResult;
+    const result = new Promise((resolve, reject) => {
+      resolveResult = resolve;
+      rejectResult = reject;
+    });
+    operationChain = operationChain.then(async () => {
+      try {
+        resolveResult(await operation());
+      } catch (error) {
+        rejectResult(error);
+      }
+    });
+    return result;
+  };
+  const scheduleNext = () => {
+    if (stopped || timer !== void 0 || applyingRemote) return;
+    timer = setTimeout(() => {
+      timer = void 0;
+      const rescan = fullRescanPending;
+      const dirtyBoardIds = [...pendingBoardIds];
+      fullRescanPending = false;
+      pendingBoardIds.clear();
+      runExclusive(() => publishLocal(false, rescan ? void 0 : dirtyBoardIds)).catch(
+        warnSyncFailure
+      );
+    }, 100);
+    timer.unref?.();
+  };
+  const schedulePublish = (boardId) => {
+    if (stopped || applyingRemote || publisher === void 0) return;
+    if (boardId === null) fullRescanPending = true;
+    else pendingBoardIds.add(boardId);
+    if (timer !== void 0) clearTimeout(timer);
+    timer = void 0;
+    scheduleNext();
+  };
+  const publishLocal = async (fullSnapshot, dirtyBoardIds) => {
+    const target = publisher;
+    if (target === void 0 || stopped) return;
+    const state = await readState(projectRoot);
+    const prunedTombstones = pruneExpiredTombstones(state, Date.now());
+    let stateChanged = fullSnapshot || prunedTombstones;
+    const boards = [];
+    const tombstones = [];
+    const fullScan = fullSnapshot || dirtyBoardIds === void 0;
+    const allBoardIds = fullScan ? await listBoardIds(projectRoot) : dirtyBoardIds;
+    let boardIds = allBoardIds;
+    if (!fullScan && boardIds.length > MAX_BOARDS_PER_PUBLISH) {
+      for (const id of boardIds.slice(MAX_BOARDS_PER_PUBLISH)) {
+        pendingBoardIds.add(id);
+      }
+      scheduleNext();
+      boardIds = boardIds.slice(0, MAX_BOARDS_PER_PUBLISH);
+    }
+    const present = /* @__PURE__ */ new Set();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const boardId of boardIds) {
+      const board = await readBoard(projectRoot, boardId);
+      if (board === null) {
+        const known2 = state.boards[boardId];
+        if (known2 !== void 0 && state.tombstones[boardId] === void 0) {
+          const tombstone = {
+            boardId,
+            revision: known2.revision + 1,
+            deletedAt: now
+          };
+          state.tombstones[boardId] = tombstone;
+          tombstones.push(tombstone);
+          stateChanged = true;
+        }
+        continue;
+      }
+      present.add(boardId);
+      const record = boardRecord(board);
+      const known = state.boards[boardId];
+      const hadTombstone = state.tombstones[boardId] !== void 0;
+      if (fullSnapshot || hadTombstone || known === void 0 || compareVersions(known.revision, known.updatedAt, record.revision, record.updatedAt) !== 0) {
+        boards.push(record);
+      }
+      if (known === void 0 || known.revision !== record.revision || known.updatedAt !== record.updatedAt || hadTombstone) {
+        stateChanged = true;
+      }
+      state.boards[boardId] = { revision: record.revision, updatedAt: record.updatedAt };
+      delete state.tombstones[boardId];
+    }
+    if (fullScan) {
+      for (const [boardId, known] of Object.entries(state.boards)) {
+        if (present.has(boardId) || state.tombstones[boardId] !== void 0 || isExpiredVersion(known.updatedAt, Date.now())) {
+          continue;
+        }
+        const tombstone = {
+          boardId,
+          revision: known.revision + 1,
+          deletedAt: now
+        };
+        state.tombstones[boardId] = tombstone;
+        tombstones.push(tombstone);
+        stateChanged = true;
+      }
+    }
+    if (stateChanged) await writeState(projectRoot, state);
+    if (!fullSnapshot && boards.length === 0 && tombstones.length === 0) return;
+    for (const payload of chunkSnapshotPayload(
+      projectId,
+      now,
+      boards,
+      fullSnapshot ? Object.values(state.tombstones) : tombstones
+    )) {
+      target.publishEvent({
+        type: "kanban.snapshot",
+        payload,
+        maxSummaryLength: 1e5
+      });
+    }
+  };
+  const attachPublisher = (next) => {
+    publisher = next;
+    return runExclusive(async () => {
+      if (unsubscribeDaemon === void 0 && (process.env["NODE_ENV"] !== "test" || process.env["WRONGSTACK_KANBAN_FORCE_IPC"] === "1")) {
+        unsubscribeDaemon = bridgeKanbanSupervisor(
+          projectRoot,
+          (event) => {
+            const data = event.data;
+            schedulePublish(data?.boardId ?? null);
+          },
+          {
+            autoReconnect: true,
+            reconnectDelayMs: 1e3,
+            // Events emitted while the daemon was down cannot be replayed.
+            // Reconcile the authoritative snapshot after every connection.
+            onConnected: () => {
+              daemonConnectionCount++;
+              if (daemonConnectionCount > 1) schedulePublish(null);
+            }
+          }
+        );
+      }
+      await publishLocal(true);
+    });
+  };
+  const applyRemote = async (snapshot) => {
+    if (snapshot.projectId !== projectId || stopped) return;
+    applyingRemote = true;
+    try {
+      const state = await readState(projectRoot);
+      for (const remote of snapshot.boards) {
+        const local = await readBoard(projectRoot, remote.boardId);
+        if (local !== null && compareVersions(
+          local.revision ?? 0,
+          local.updatedAt,
+          remote.revision,
+          remote.updatedAt
+        ) >= 0) {
+          continue;
+        }
+        await writeBoard(projectRoot, remote.board);
+        state.boards[remote.boardId] = {
+          revision: remote.revision,
+          updatedAt: remote.updatedAt
+        };
+        delete state.tombstones[remote.boardId];
+      }
+      for (const tombstone of snapshot.tombstones) {
+        const local = await readBoard(projectRoot, tombstone.boardId);
+        if (local !== null && compareVersions(
+          local.revision ?? 0,
+          local.updatedAt,
+          tombstone.revision,
+          tombstone.deletedAt
+        ) >= 0) {
+          continue;
+        }
+        if (local !== null) await deleteBoard(projectRoot, tombstone.boardId);
+        state.boards[tombstone.boardId] = {
+          revision: Math.max(0, tombstone.revision - 1),
+          updatedAt: tombstone.deletedAt
+        };
+        state.tombstones[tombstone.boardId] = tombstone;
+      }
+      await writeState(projectRoot, state);
+    } finally {
+      applyingRemote = false;
+    }
+  };
+  const handleRemote = (snapshot) => {
+    if (snapshot.projectId !== projectId || stopped) return Promise.resolve();
+    pendingRemote = pendingRemote === null ? snapshot : coalesceRemoteSnapshots(pendingRemote, snapshot);
+    if (remoteApplyQueued) return Promise.resolve();
+    remoteApplyQueued = true;
+    return runExclusive(async () => {
+      remoteApplyQueued = false;
+      const batch = pendingRemote;
+      pendingRemote = null;
+      if (batch !== null) await applyRemote(batch);
+    }).catch(warnSyncFailure);
+  };
+  return {
+    attachPublisher,
+    handleRemote,
+    refresh: (boardId) => schedulePublish(boardId ?? null),
+    stop: () => {
+      stopped = true;
+      if (timer !== void 0) clearTimeout(timer);
+      pendingBoardIds.clear();
+      fullRescanPending = false;
+      pendingRemote = null;
+      unsubscribeDaemon?.();
+      unsubscribeDaemon = void 0;
+      publisher = void 0;
+    }
+  };
+}
+function boardRecord(board) {
+  return {
+    boardId: board.id,
+    revision: board.revision ?? 0,
+    updatedAt: board.updatedAt,
+    board: structuredClone(board)
+  };
+}
+function chunkSnapshotPayload(projectId, generatedAt, boards, tombstones) {
+  const chunks = [];
+  const emptyPayload = () => ({
+    projectId,
+    generatedAt,
+    boards: [],
+    tombstones: []
+  });
+  const emptyPayloadBytes = Buffer.byteLength(JSON.stringify(emptyPayload()), "utf8");
+  let currentBoards = [];
+  let currentTombstones = [];
+  let currentBytes = emptyPayloadBytes;
+  const pushCurrent = () => {
+    if (currentBoards.length === 0 && currentTombstones.length === 0) return;
+    chunks.push({
+      projectId,
+      generatedAt,
+      boards: currentBoards,
+      tombstones: currentTombstones
+    });
+    currentBoards = [];
+    currentTombstones = [];
+    currentBytes = emptyPayloadBytes;
+  };
+  const append = (kind, item) => {
+    const itemBytes = Buffer.byteLength(JSON.stringify(item), "utf8");
+    const itemCount = kind === "boards" ? currentBoards.length : currentTombstones.length;
+    const additionalBytes = itemBytes + (itemCount > 0 ? 1 : 0);
+    if (emptyPayloadBytes + itemBytes > MAX_KANBAN_SNAPSHOT_PAYLOAD_BYTES) {
+      process.emitWarning(
+        `Kanban ${kind === "boards" ? "board" : "tombstone"} ${item.boardId} exceeds the ${MAX_KANBAN_SNAPSHOT_PAYLOAD_BYTES}-byte snapshot chunk target`,
+        { code: "WRONGSTACK_HQ_KANBAN_OVERSIZED_RECORD" }
+      );
+    }
+    if ((currentBoards.length > 0 || currentTombstones.length > 0) && currentBytes + additionalBytes > MAX_KANBAN_SNAPSHOT_PAYLOAD_BYTES) {
+      pushCurrent();
+    }
+    if (kind === "boards") {
+      currentBoards.push(item);
+    } else {
+      currentTombstones.push(item);
+    }
+    currentBytes += itemBytes + (kind === "boards" ? currentBoards.length > 1 ? 1 : 0 : currentTombstones.length > 1 ? 1 : 0);
+  };
+  for (const board of boards) append("boards", board);
+  for (const tombstone of tombstones) append("tombstones", tombstone);
+  pushCurrent();
+  return chunks.length > 0 ? chunks : [emptyPayload()];
+}
+function coalesceRemoteSnapshots(older, newer) {
+  const byBoardId = /* @__PURE__ */ new Map();
+  const put = (candidate, boardId) => {
+    const existing = byBoardId.get(boardId);
+    if (existing === void 0 || compareVersions(existing.revision, existing.time, candidate.revision, candidate.time) <= 0) {
+      byBoardId.set(boardId, candidate);
+    }
+  };
+  for (const snapshot of [older, newer]) {
+    for (const record of snapshot.boards) {
+      put(
+        { kind: "board", revision: record.revision, time: record.updatedAt, record },
+        record.boardId
+      );
+    }
+    for (const record of snapshot.tombstones) {
+      put(
+        { kind: "tombstone", revision: record.revision, time: record.deletedAt, record },
+        record.boardId
+      );
+    }
+  }
+  const merged = {
+    projectId: newer.projectId,
+    generatedAt: newer.generatedAt,
+    boards: [],
+    tombstones: []
+  };
+  for (const entry of byBoardId.values()) {
+    if (entry.kind === "board") merged.boards.push(entry.record);
+    else merged.tombstones.push(entry.record);
+  }
+  return merged;
+}
+function compareVersions(aRevision, aTime, bRevision, bTime) {
+  if (aRevision !== bRevision) return aRevision - bRevision;
+  return aTime.localeCompare(bTime);
+}
+function isExpiredVersion(timestamp, now) {
+  const parsed = Date.parse(timestamp);
+  return !Number.isNaN(parsed) && parsed <= now - KANBAN_TOMBSTONE_RETENTION_MS;
+}
+function pruneExpiredTombstones(state, now) {
+  let changed = false;
+  for (const [boardId, tombstone] of Object.entries(state.tombstones)) {
+    if (!isExpiredVersion(tombstone.deletedAt, now)) continue;
+    delete state.tombstones[boardId];
+    delete state.boards[boardId];
+    changed = true;
+  }
+  return changed;
+}
+async function readState(projectRoot) {
+  try {
+    const raw = await readKanbanMetadata(projectRoot, SYNC_STATE_KEY);
+    if (raw === null) return { boards: {}, tombstones: {} };
+    const parsed = JSON.parse(raw);
+    return { boards: parsed.boards ?? {}, tombstones: parsed.tombstones ?? {} };
+  } catch {
+    return { boards: {}, tombstones: {} };
+  }
+}
+async function writeState(projectRoot, state) {
+  await writeKanbanMetadata(projectRoot, SYNC_STATE_KEY, JSON.stringify(state));
+}
+
+// src/hq-publisher.ts
+function nodeWsSocketFactory(url) {
+  return new WebSocket(url);
+}
+function createCliHqPublisher(options) {
+  return createHqPublisherFromEnv({
+    ...options,
+    socketFactory: options.socketFactory ?? nodeWsSocketFactory
+  });
+}
+function hqExplicitlyDisabled(options) {
+  const envEnabled = process.env["WRONGSTACK_HQ_ENABLED"]?.trim();
+  if (envEnabled !== void 0 && envEnabled.length > 0) return envEnabled === "0";
+  if (options.config?.enabled !== void 0) return options.config.enabled === false;
+  return options.appConfig?.hq?.enabled === false;
+}
+function resolvedHqConnectionKey(options) {
+  if (options.config !== void 0) {
+    return options.config.enabled === false ? void 0 : `${options.config.url}
+${options.config.token ?? ""}`;
+  }
+  const config = resolveHqConfig({ config: options.appConfig?.hq });
+  return config === void 0 ? void 0 : `${config.url}
+${config.token ?? ""}`;
+}
+function startCliHqConnection(options) {
+  const shouldOwnKanbanSync = options.onKanbanSnapshot === void 0;
+  let kanbanSync;
+  const publisherOptions = shouldOwnKanbanSync ? {
+    ...options,
+    onKanbanSnapshot: (snapshot) => kanbanSync?.handleRemote(snapshot)
+  } : options;
+  let publisher;
+  let publisherKey;
+  let timer;
+  const tryConnect = () => {
+    const nextKey = resolvedHqConnectionKey(options);
+    if (nextKey === void 0) return;
+    if (publisher !== void 0 && publisherKey === nextKey) return;
+    publisher?.close();
+    publisher = void 0;
+    publisherKey = void 0;
+    const next = createCliHqPublisher(publisherOptions);
+    if (next === void 0) return;
+    publisher = next;
+    publisherKey = nextKey;
+    if (shouldOwnKanbanSync) {
+      kanbanSync?.stop();
+      kanbanSync = createKanbanHqSync(options.projectRoot, next.project.projectId);
+    }
+    next.connect();
+    if (kanbanSync !== void 0) {
+      kanbanSync.attachPublisher(next).catch((error) => {
+        process.emitWarning(
+          `WrongStack kanban HQ sync attach failed (best-effort, retried on reconnect): ${error instanceof Error ? error.message : String(error)}`,
+          { code: "WRONGSTACK_HQ_KANBAN_SYNC_FAILED" }
+        );
+      });
+    }
+    options.onConnect?.(next);
+  };
+  tryConnect();
+  if (!hqExplicitlyDisabled(options)) {
+    timer = setInterval(tryConnect, options.retryIntervalMs ?? 2500);
+    timer.unref?.();
+  }
+  return {
+    getPublisher: () => publisher,
+    stop: () => {
+      if (timer !== void 0) {
+        clearInterval(timer);
+        timer = void 0;
+      }
+      kanbanSync?.stop();
+      publisher?.close();
+      publisher = void 0;
+      publisherKey = void 0;
+    }
+  };
+}
+
+export {
+  startCliHqConnection
+};
+//# sourceMappingURL=chunk-WY7KKOUK.js.map