@wrongstack/cli 1.0.24 → 1.0.26

package/dist/chunk-HLSHFXTO.js

@@ -0,0 +1,97 @@
+
+// src/boot/mcp-config-flag.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringRecord(value, where) {
+  if (value === void 0) return void 0;
+  if (!isRecord(value) || Object.values(value).some((v) => typeof v !== "string")) {
+    throw new Error(`${where} must be an object of strings`);
+  }
+  return value;
+}
+function normalizeMcpServerEntry(name, raw) {
+  if (!isRecord(raw)) throw new Error(`server "${name}" must be an object`);
+  const where = `server "${name}"`;
+  const { type, transport: rawTransport, ...rest } = raw;
+  let transport;
+  if (rawTransport !== void 0) {
+    if (rawTransport !== "stdio" && rawTransport !== "sse" && rawTransport !== "streamable-http") {
+      throw new Error(`${where}: unknown transport "${String(rawTransport)}"`);
+    }
+    transport = rawTransport;
+  } else if (type !== void 0) {
+    if (type === "http") transport = "streamable-http";
+    else if (type === "sse" || type === "stdio") transport = type;
+    else throw new Error(`${where}: unknown type "${String(type)}"`);
+  } else if (typeof rest["command"] === "string") {
+    transport = "stdio";
+  }
+  if (transport === "stdio" && typeof rest["command"] !== "string") {
+    throw new Error(`${where}: stdio needs a "command"`);
+  }
+  if ((transport === "sse" || transport === "streamable-http") && typeof rest["url"] !== "string") {
+    throw new Error(`${where}: ${transport} needs a "url"`);
+  }
+  if (rest["args"] !== void 0 && !Array.isArray(rest["args"])) {
+    throw new Error(`${where}: "args" must be an array`);
+  }
+  const env = stringRecord(rest["env"], `${where} "env"`);
+  const headers = stringRecord(rest["headers"], `${where} "headers"`);
+  return {
+    ...rest,
+    ...transport ? { transport } : {},
+    ...env ? { env } : {},
+    ...headers ? { headers } : {}
+  };
+}
+function parseLaunchMcpServers(text, source) {
+  let doc;
+  try {
+    doc = JSON.parse(text);
+  } catch (err) {
+    throw new Error(`--mcp-config: ${source} is not valid JSON (${err.message})`);
+  }
+  if (!isRecord(doc)) throw new Error(`--mcp-config: ${source} must be a JSON object`);
+  const servers = isRecord(doc["mcpServers"]) ? doc["mcpServers"] : doc;
+  const out = {};
+  for (const [name, raw] of Object.entries(servers)) {
+    try {
+      out[name] = { ...normalizeMcpServerEntry(name, raw), enabled: true };
+    } catch (err) {
+      throw new Error(`--mcp-config: ${source}: ${err.message}`);
+    }
+  }
+  return out;
+}
+async function resolveLaunchMcpServers(flags, cwd) {
+  const value = flags["mcp-config"];
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error("--mcp-config needs a JSON file path or an inline JSON object");
+  }
+  const trimmed = value.trim();
+  if (trimmed.startsWith("{")) return parseLaunchMcpServers(trimmed, "inline JSON");
+  const file = path.resolve(cwd, trimmed);
+  let text;
+  try {
+    text = await fs.readFile(file, "utf8");
+  } catch (err) {
+    const reason = err.code ?? String(err);
+    throw new Error(`--mcp-config: cannot read ${file} (${reason})`);
+  }
+  return parseLaunchMcpServers(text, file);
+}
+function effectiveMcpServers(configured, launch, strict) {
+  return { ...strict ? {} : configured ?? {}, ...launch ?? {} };
+}
+
+export {
+  normalizeMcpServerEntry,
+  parseLaunchMcpServers,
+  resolveLaunchMcpServers,
+  effectiveMcpServers
+};
+//# sourceMappingURL=chunk-HLSHFXTO.js.map

package/dist/{chunk-BLD5DSVA.js → chunk-KJS5543T.js}

@@ -1,6 +1,6 @@
 import {
   CLI_VERSION
-} from "./chunk-YBUCXXYZ.js";
+} from "./chunk-F5DCFAKI.js";
 
 // src/hq-publisher.ts
 import { createHqPublisherFromEnv, resolveHqConfig } from "@wrongstack/core/hq";
@@ -518,4 +518,4 @@ function startCliHqConnection(options) {
 export {
   startCliHqConnection
 };
-//# sourceMappingURL=chunk-BLD5DSVA.js.map
+//# sourceMappingURL=chunk-KJS5543T.js.map

package/dist/{chunk-QFPQXKCG.js → chunk-KOEO4CJG.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-U3SS4NRH.js";
 import {
   checkForUpdate
-} from "./chunk-ZZRSG7VK.js";
+} from "./chunk-RZ4ZDRYA.js";
 
 // src/subcommands/handlers/update.ts
 import { spawn } from "node:child_process";
@@ -21,6 +21,8 @@ async function runUpdateCommand(args, deps) {
     (flag) => ![
       "check-only",
       "c",
+      // `-c` after the top-level parser's expansion; see mergeUpdateArgs.
+      "continue",
       "pm",
       "package-manager",
       "allow-scripts",
@@ -77,11 +79,24 @@ async function runUpdateCommand(args, deps) {
     return 0;
   }
   if (isStandaloneBinary()) {
-    const { updateStandaloneBinary } = await import("./standalone-update-MW47J3AK.js");
-    return updateStandaloneBinary({
+    const [{ updateStandaloneBinary }, { standaloneUpdater }, { STANDALONE_TARGET }] = await Promise.all([
+      import("./standalone-update-LZO3MNLH.js"),
+      import("./standalone-auto-update-TOTRGCSA.js"),
+      import("./version-JB2UAV2A.js")
+    ]);
+    const updater = standaloneUpdater({
+      executable: realpathSync(process.execPath),
+      target: STANDALONE_TARGET ?? "",
+      current: info.current
+    });
+    const code = await updateStandaloneBinary({
       current: info.current,
-      renderer: deps.renderer
+      renderer: deps.renderer,
+      // A build the background updater already downloaded and verified.
+      staged: updater.pending()
     });
+    if (code === 0) updater.clear();
+    return code;
   }
   const packageManager = parsed.packageManager ?? detectUpdatePackageManager();
   let updateCommand;
@@ -184,7 +199,7 @@ function mergeUpdateArgs(args, flags) {
     if (flags[name] === true || flags[name] === "true") merged.push(`--${alias}`);
   };
   addBoolean("check-only");
-  if (flags["c"] === true || flags["c"] === "true") merged.push("-c");
+  if (flags["continue"] === true || flags["c"] === true || flags["c"] === "true") merged.push("-c");
   addBoolean("allow-scripts");
   addBoolean("lifecycle-scripts");
   for (const pm of ["npm", "pnpm", "yarn", "bun"]) addBoolean(pm);
@@ -391,4 +406,4 @@ export {
   detectUpdatePackageManager,
   detectUpdatePackageName
 };
-//# sourceMappingURL=chunk-QFPQXKCG.js.map
+//# sourceMappingURL=chunk-KOEO4CJG.js.map

package/dist/chunk-LBPLTTZ6.js

@@ -0,0 +1,105 @@
+
+// src/preflight.ts
+import { ensureSessionShell } from "@wrongstack/tools/session-shell";
+
+// src/cli-update-notice.ts
+import { realpathSync } from "node:fs";
+import { isStandaloneBinary, writeErr } from "@wrongstack/core/utils";
+var NOTICE_FMT = `
+  \x1B[33m\u2191 Update available: v%s \u2192 v%s\x1B[0m  Run \`wrongstack update\` to upgrade.
+
+`;
+var READY_FMT = `
+  \x1B[33m\u2191 v%s is downloaded\x1B[0m  It replaces this executable when this session exits.
+
+`;
+var READY_MANUAL_FMT = `
+  \x1B[33m\u2191 v%s is downloaded\x1B[0m  Run \`wrongstack update\` to install it.
+
+`;
+var APPLIED_FMT = `
+  \x1B[32m\u2713 Updated wrongstack v%s \u2192 v%s\x1B[0m
+
+`;
+async function printStandaloneUpdateNotice(info, config) {
+  const [{ autoUpdateEnabled, standaloneUpdater, takeAppliedUpdate }, { isNewer }, version] = await Promise.all([
+    import("./standalone-auto-update-TOTRGCSA.js"),
+    import("./update-check-J5ZVKS73.js"),
+    import("./version-JB2UAV2A.js")
+  ]);
+  const applied = takeAppliedUpdate();
+  if (applied) writeErr(APPLIED_FMT.replace("%s", applied.from).replace("%s", applied.to));
+  const pending = standaloneUpdater({
+    executable: realpathSync(process.execPath),
+    target: version.STANDALONE_TARGET ?? "",
+    current: version.CLI_VERSION
+  }).pending();
+  if (pending && info && isNewer(pending.version, info.current) && pending.version === info.latest) {
+    const fmt = autoUpdateEnabled(config) ? READY_FMT : READY_MANUAL_FMT;
+    writeErr(fmt.replace("%s", pending.version));
+    return true;
+  }
+  return false;
+}
+async function printUpdateNotice(initialUpdateInfo, config) {
+  let info = initialUpdateInfo;
+  if (!info?.outdated) {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), 2e3);
+    try {
+      const { checkForUpdate } = await import("./update-check-J5ZVKS73.js");
+      info = await checkForUpdate(ac.signal);
+    } catch {
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  let reported = false;
+  if (isStandaloneBinary()) {
+    try {
+      reported = await printStandaloneUpdateNotice(info, config);
+    } catch {
+    }
+  }
+  if (info?.outdated && !reported) {
+    writeErr(NOTICE_FMT.replace("%s", info.current).replace("%s", info.latest));
+  }
+  return info;
+}
+
+// src/preflight.ts
+function applyNodeEnvDefault() {
+  if (process.env["NODE_ENV"] === void 0) {
+    process.env["NODE_ENV"] = "production";
+    process.env["WRONGSTACK_NODE_ENV_DEFAULTED"] = "1";
+  }
+}
+function applySessionShellDefault() {
+  ensureSessionShell();
+}
+async function applyPrintUpdateNotice(initialUpdateInfo, config) {
+  return await printUpdateNotice(initialUpdateInfo, config);
+}
+async function applyDebugStreamSeed(config) {
+  const { setDebugStreamEnabled } = await import("@wrongstack/providers");
+  if (config.debugStream) {
+    setDebugStreamEnabled(true);
+  }
+}
+async function runPreflight(config, initialUpdateInfo) {
+  applyNodeEnvDefault();
+  applySessionShellDefault();
+  const updateInfo = await applyPrintUpdateNotice(initialUpdateInfo, config);
+  await applyDebugStreamSeed(config);
+  return {
+    updateInfo,
+    debugStreamEnabled: Boolean(config.debugStream)
+  };
+}
+
+export {
+  applyNodeEnvDefault,
+  applySessionShellDefault,
+  runPreflight
+};
+//# sourceMappingURL=chunk-LBPLTTZ6.js.map

package/dist/{chunk-3OCUS3VN.js → chunk-LDCGZJTC.js}

@@ -1,9 +1,9 @@
-import {
-  activeProfileConfigPath
-} from "./chunk-YMXXOOFN.js";
 import {
   mutateConfigProviders
 } from "./chunk-LUMETJFO.js";
+import {
+  activeProfileConfigPath
+} from "./chunk-YMXXOOFN.js";
 
 // src/wiring/provider-persisters.ts
 import {
@@ -43,4 +43,4 @@ export {
   installProviderPersisters,
   applyProviderOAuthRefresh2 as applyProviderOAuthRefresh
 };
-//# sourceMappingURL=chunk-3OCUS3VN.js.map
+//# sourceMappingURL=chunk-LDCGZJTC.js.map

package/dist/chunk-LKPEBZBE.js

@@ -0,0 +1,143 @@
+
+// src/boot/stream-json.ts
+function parseOutputFormat(value) {
+  if (value === void 0) return void 0;
+  if (value === "text" || value === "json" || value === "stream-json") return value;
+  throw new Error(
+    `--output-format must be text, json or stream-json (got ${value === true ? "nothing" : `"${value}"`})`
+  );
+}
+var LEADER = "leader";
+function isLeader(agentId) {
+  return agentId === void 0 || agentId === LEADER;
+}
+function simplifyBlocks(content) {
+  const out = [];
+  for (const block of content ?? []) {
+    if (block.type === "text") out.push({ type: "text", text: block.text });
+    else if (block.type === "tool_use") {
+      out.push({ type: "tool_use", id: block.id, name: block.name, input: block.input });
+    }
+  }
+  return out;
+}
+function startStreamJson(opts) {
+  const emit = (payload) => {
+    opts.write(`${JSON.stringify(payload)}
+`);
+  };
+  const offs = [];
+  if (opts.includePartialMessages) {
+    offs.push(
+      opts.events.on("provider.text_delta", (e) => {
+        if (isLeader(e.ctx?.agentId)) emit({ type: "text_delta", text: e.text });
+      })
+    );
+  }
+  offs.push(
+    opts.events.on("provider.response", (e) => {
+      if (!isLeader(e.ctx?.agentId)) return;
+      emit({
+        type: "assistant",
+        model: e.model,
+        content: simplifyBlocks(e.content),
+        stopReason: e.stopReason,
+        usage: e.usage
+      });
+    })
+  );
+  offs.push(
+    opts.events.on("tool.executed", (e) => {
+      if (!isLeader(e.agentId)) return;
+      emit({
+        type: "tool_result",
+        id: e.id ?? null,
+        name: e.name,
+        ok: e.ok,
+        durationMs: e.durationMs,
+        output: e.output ?? null,
+        outputBytes: e.outputBytes ?? null
+      });
+    })
+  );
+  return () => {
+    for (const off of offs) off();
+  };
+}
+function streamJsonInit(info) {
+  return `${JSON.stringify({ type: "init", ...info })}
+`;
+}
+
+// src/boot/structured-output.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { validateAgainstSchema } from "@wrongstack/core/utils";
+async function resolveJsonSchemaFlag(value, cwd) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error("--json-schema needs a JSON Schema file path or an inline JSON object");
+  }
+  const trimmed = value.trim();
+  let text = trimmed;
+  let source = "inline JSON";
+  if (!trimmed.startsWith("{")) {
+    const file = path.resolve(cwd, trimmed);
+    source = file;
+    try {
+      text = await fs.readFile(file, "utf8");
+    } catch (err) {
+      const reason = err.code ?? String(err);
+      throw new Error(`--json-schema: cannot read ${file} (${reason})`);
+    }
+  }
+  let schema;
+  try {
+    schema = JSON.parse(text);
+  } catch (err) {
+    throw new Error(`--json-schema: ${source} is not valid JSON (${err.message})`);
+  }
+  if (typeof schema !== "object" || schema === null || Array.isArray(schema)) {
+    throw new Error(`--json-schema: ${source} must be a JSON Schema object`);
+  }
+  return schema;
+}
+function withSchemaInstruction(query, schema) {
+  return `${query}
+
+When you are done, reply with ONLY a JSON value that validates against this JSON Schema \u2014 no prose, no code fence:
+${JSON.stringify(schema)}`;
+}
+function checkStructuredAnswer(text, schema) {
+  if (!text?.trim()) return { ok: false, errors: ["the answer was empty"] };
+  const fenced = text.trim().match(/^```(?:json)?\s*\n([\s\S]*?)\n?```$/);
+  const body = (fenced?.[1] ?? text).trim();
+  let value;
+  try {
+    value = JSON.parse(body);
+  } catch (err) {
+    return { ok: false, errors: [`not valid JSON (${err.message})`] };
+  }
+  const result = validateAgainstSchema(value, schema);
+  if (result.ok) return { ok: true, value };
+  return {
+    ok: false,
+    errors: result.errors.map((e) => `${e.path || "(root)"}: ${e.message}`)
+  };
+}
+function repairPrompt(errors) {
+  return `Your last answer did not validate against the JSON Schema:
+${errors.map((e) => `- ${e}`).join("\n")}
+Reply with ONLY the corrected JSON value.`;
+}
+
+export {
+  parseOutputFormat,
+  startStreamJson,
+  streamJsonInit,
+  resolveJsonSchemaFlag,
+  withSchemaInstruction,
+  checkStructuredAnswer,
+  repairPrompt
+};
+//# sourceMappingURL=chunk-LKPEBZBE.js.map

package/dist/{chunk-DRM7PSW7.js → chunk-OAVBM55Q.js}

@@ -2847,8 +2847,8 @@ async function handleApiAgentMessages(req, res, match, agentMessages) {
 // src/hq-server/routes/system-handlers.ts
 async function handleApiSystemUpdate(res) {
   const [{ checkForUpdate }, { detectUpdatePackageName }] = await Promise.all([
-    import("./update-check-2POMBHFB.js"),
-    import("./update-7XIOEXTD.js")
+    import("./update-check-J5ZVKS73.js"),
+    import("./update-TDZX4IL2.js")
   ]);
   const packageName = detectUpdatePackageName();
   const info = await checkForUpdate({ packageName });
@@ -5150,4 +5150,4 @@ export {
   startHqServer,
   HqInsecureExposureError2 as HqInsecureExposureError
 };
-//# sourceMappingURL=chunk-DRM7PSW7.js.map
+//# sourceMappingURL=chunk-OAVBM55Q.js.map

package/dist/chunk-PZQBGUVZ.js

@@ -0,0 +1,18 @@
+
+// src/boot/ascii-mode.ts
+import { installAsciiOutput, isAsciiMode } from "@wrongstack/core/utils";
+var installed = false;
+function applyAsciiMode(flags, env = process.env, streams = [process.stdout, process.stderr]) {
+  if (flags["ascii"] === true) env["WRONGSTACK_TUI_ICON_STYLE"] = "ascii";
+  if (!isAsciiMode(env)) return false;
+  if (!installed) {
+    installed = true;
+    for (const stream of streams) installAsciiOutput(stream);
+  }
+  return true;
+}
+
+export {
+  applyAsciiMode
+};
+//# sourceMappingURL=chunk-PZQBGUVZ.js.map

package/dist/{chunk-MHEBWVXL.js → chunk-Q4INH2DG.js}

@@ -20,6 +20,34 @@ var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   // Both are boolean so they cannot swallow the next positional token.
   "no-recovery",
   "recover",
+  // `--continue` / `-c`: resume the most recent session (same pick as a bare
+  // `--resume`). Boolean so `wstack -c "next step"` keeps the prompt.
+  "continue",
+  // `--fork-session` (with --resume/--continue/--recover): branch instead of reopening.
+  "fork-session",
+  // `--strict-mcp-config`: start only the `--mcp-config` servers.
+  "strict-mcp-config",
+  // `--include-partial-messages`: add text_delta events to stream-json output.
+  "include-partial-messages",
+  // `--safe-mode`: start with plugins/hooks/MCP/skills/instruction overrides off.
+  "safe-mode",
+  // `--restricted`: no code-running/network tools, project-root lock, no YOLO.
+  "restricted",
+  // `--record` is read as `=== true`; as a value flag it swallowed the task
+  // (`wstack --record "fix it"` recorded nothing and ran nothing).
+  "record",
+  // Same class: switches read only as `=== true` that would otherwise take the
+  // next token (`--vector-sync "task"`, `typesafe lint-conventions --staged x`).
+  "vector-sync",
+  "allow-all",
+  "no-llm",
+  "staged",
+  "sweep",
+  "n",
+  // `wstack import-claude-code` switches.
+  "apply",
+  "overwrite",
+  "enable-project-servers",
   "output-json",
   "metrics",
   "webui",
@@ -28,6 +56,8 @@ var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "full-auto",
   "desktop",
   "open",
+  // `wstack remote --keep`: leave the remote host running after disconnecting.
+  "keep",
   "webui-require-token",
   "require-token",
   "no-check",
@@ -39,6 +69,7 @@ var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "skip",
   "skip-index",
   "mouse",
+  "ascii",
   "no-interactive",
   "token-saving-mode",
   "system-lite",
@@ -139,7 +170,13 @@ function parseArgs(argv) {
       }
     } else if (a.startsWith("-") && a.length === 2) {
       const short = a.slice(1);
-      const expand = { v: "verbose", y: "yes", h: "help" };
+      const expand = {
+        v: "verbose",
+        y: "yes",
+        h: "help",
+        c: "continue",
+        r: "resume"
+      };
       const name = expand[short] ?? short;
       if (!BOOLEAN_FLAGS.has(name) && i + 1 < argv.length && !(argv[i + 1] ?? "").startsWith("-")) {
         flags[name] = argv[++i] ?? "";
@@ -151,6 +188,13 @@ function parseArgs(argv) {
     }
   }
   normalizeSurfaceAliases(flags, positional);
+  for (const [camel, kebab] of [
+    ["disallowedTools", "disallowed-tools"],
+    ["allowedTools", "allowed-tools"]
+  ]) {
+    if (flags[camel] !== void 0 && flags[kebab] === void 0) flags[kebab] = flags[camel];
+    delete flags[camel];
+  }
   return { flags, positional };
 }
 function normalizeSurfaceAliases(flags, positional) {
@@ -262,4 +306,4 @@ export {
   parseAuthFlags,
   parseSpawnFlags
 };
-//# sourceMappingURL=chunk-MHEBWVXL.js.map
+//# sourceMappingURL=chunk-Q4INH2DG.js.map

package/dist/{chunk-ZZRSG7VK.js → chunk-RZ4ZDRYA.js}

@@ -1,6 +1,6 @@
 import {
   CLI_VERSION
-} from "./chunk-YBUCXXYZ.js";
+} from "./chunk-F5DCFAKI.js";
 
 // src/update-check.ts
 import * as fs from "node:fs/promises";
@@ -144,7 +144,7 @@ async function checkForUpdate(signalOrOptions, legacyHomeFn) {
     };
   }
   try {
-    const latest = packageName === "standalone-binary" ? await (await import("./standalone-update-MW47J3AK.js")).fetchLatestStandaloneVersion(3e3, signal) : await fetchLatestFromNpm(packageName, 3e3, signal);
+    const latest = packageName === "standalone-binary" ? await (await import("./standalone-update-LZO3MNLH.js")).fetchLatestStandaloneVersion(3e3, signal) : await fetchLatestFromNpm(packageName, 3e3, signal);
     await writeCache({ timestamp: Date.now(), latestVersion: latest, packageName }, hf);
     return {
       current,
@@ -183,4 +183,4 @@ export {
   checkForUpdate,
   getUpdateNotification
 };
-//# sourceMappingURL=chunk-ZZRSG7VK.js.map
+//# sourceMappingURL=chunk-RZ4ZDRYA.js.map