@wrongstack/cli 1.0.24 → 1.0.27

package/dist/remote-GB5VXCCT.js

@@ -0,0 +1,576 @@
+import {
+  MAX_BINARY_BYTES,
+  downloadReleaseAssetToFile,
+  findStandaloneRelease,
+  verifyStandaloneDigest
+} from "./chunk-X756ZS72.js";
+import {
+  CLI_VERSION,
+  STANDALONE_TARGET
+} from "./chunk-F5DCFAKI.js";
+import {
+  openBrowser
+} from "./chunk-DAKVBMD4.js";
+
+// src/subcommands/handlers/remote.ts
+import * as fsp2 from "node:fs/promises";
+import * as path2 from "node:path";
+import { isStandaloneBinary, toErrorMessage as toErrorMessage2, wstackGlobalRoot } from "@wrongstack/core/utils";
+
+// src/remote/remote-session.ts
+import { spawn } from "node:child_process";
+import { createHash, randomBytes } from "node:crypto";
+import { createReadStream, existsSync } from "node:fs";
+import * as fsp from "node:fs/promises";
+import * as net from "node:net";
+import * as path from "node:path";
+import { buildChildEnv, toErrorMessage } from "@wrongstack/core/utils";
+
+// src/remote/remote-target.ts
+function parseRemoteTarget(input) {
+  const target = parseRemoteTargetText(input);
+  if (target.destination.startsWith("-")) {
+    throw new Error(`A remote host cannot start with "-" (got ${target.destination})`);
+  }
+  return target;
+}
+function parseRemoteTargetText(input) {
+  const text = input.trim();
+  if (text.startsWith("ssh://")) {
+    let url;
+    try {
+      url = new URL(text);
+    } catch {
+      throw new Error(`Not a valid ssh:// address: ${text}`);
+    }
+    const user = url.username ? `${decodeURIComponent(url.username)}@` : "";
+    const path4 = decodeURIComponent(url.pathname);
+    if (!url.hostname || !path4 || path4 === "/") {
+      throw new Error(`Give the remote project directory: ssh://user@host/path (got ${text})`);
+    }
+    return {
+      destination: `${user}${url.hostname}`,
+      ...url.port ? { port: Number(url.port) } : {},
+      path: path4
+    };
+  }
+  const colon = text.indexOf(":");
+  const destination = colon > 0 ? text.slice(0, colon) : "";
+  const path3 = colon > 0 ? text.slice(colon + 1) : "";
+  if (!destination || !path3 || /\s/.test(destination)) {
+    throw new Error(`Give the remote as user@host:/path/to/project (got ${text || "nothing"})`);
+  }
+  return { destination, path: path3 };
+}
+function shQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function shPath(path3) {
+  if (path3 === "~") return '"$HOME"';
+  if (path3.startsWith("~/")) return `"$HOME"/${shQuote(path3.slice(2))}`;
+  return shQuote(path3);
+}
+function buildTargetFor(os, arch, musl) {
+  const system = os.trim().toLowerCase();
+  const machine = arch.trim().toLowerCase();
+  const cpu = machine === "x86_64" || machine === "amd64" ? "x64" : machine === "aarch64" || machine === "arm64" ? "arm64" : void 0;
+  if (!cpu) throw new Error(`No WrongStack build for a ${arch} remote machine.`);
+  if (system === "linux") return `bun-linux-${cpu}${musl ? "-musl" : ""}`;
+  if (system === "darwin") return `bun-darwin-${cpu}`;
+  throw new Error(`Remote machines running ${os} are not supported (Linux and macOS are).`);
+}
+var REMOTE_BIN_DIR = '"$HOME"/.wrongstack/remote';
+function stateScript(path3) {
+  return `dir=${shPath(path3)}
+abs=$(cd "$dir" 2>/dev/null && pwd -P) || abs=
+key=$(printf '%s' "$abs" | cksum | tr ' ' '-')
+state_dir=${REMOTE_BIN_DIR}/servers
+state="$state_dir/$key.json"
+token_file="$state_dir/$key.token"
+log="$state_dir/$key.log"`;
+}
+function probeScript(path3) {
+  return `set -u
+printf 'os=%s\\n' "$(uname -s 2>/dev/null)"
+printf 'arch=%s\\n' "$(uname -m 2>/dev/null)"
+if ls /lib/ld-musl-* >/dev/null 2>&1; then echo musl=1; else echo musl=0; fi
+${stateScript(path3)}
+if [ -d "$dir" ]; then echo path=1; else echo path=0; fi
+for f in ${REMOTE_BIN_DIR}/wstack-*; do
+  [ -x "$f" ] && printf 'version=%s\\n' "\${f##*/wstack-}"
+done
+if [ -n "$abs" ] && [ -f "$state" ] && [ -f "$token_file" ]; then
+  pid=$(sed -n 's/.*"pid":\\([0-9]*\\).*/\\1/p' "$state")
+  if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+    printf 'server=%s\\n' "$(tr -d '\\n' < "$state")"
+    printf 'token=%s\\n' "$(cat "$token_file")"
+  fi
+fi
+`;
+}
+function parseProbe(output) {
+  const values = /* @__PURE__ */ new Map();
+  for (const line of output.split(/\r?\n/)) {
+    const eq = line.indexOf("=");
+    if (eq <= 0) continue;
+    const key = line.slice(0, eq);
+    values.set(key, [...values.get(key) ?? [], line.slice(eq + 1)]);
+  }
+  const one = (key) => values.get(key)?.[0] ?? "";
+  let server;
+  try {
+    const state = JSON.parse(one("server") || "null");
+    const token = one("token");
+    if (state && typeof state.pid === "number" && typeof state.port === "number" && typeof state.version === "string" && token) {
+      server = { pid: state.pid, port: state.port, version: state.version, token };
+    }
+  } catch {
+    server = void 0;
+  }
+  return {
+    os: one("os"),
+    arch: one("arch"),
+    musl: one("musl") === "1",
+    pathExists: one("path") === "1",
+    versions: values.get("version") ?? [],
+    ...server ? { server } : {}
+  };
+}
+function remoteBinaryPath(version) {
+  return `${REMOTE_BIN_DIR}/${shQuote(`wstack-${version}`)}`;
+}
+function installScript(version) {
+  const target = remoteBinaryPath(version);
+  return `set -eu
+mkdir -p ${REMOTE_BIN_DIR}
+chmod 700 ${REMOTE_BIN_DIR}
+part=${REMOTE_BIN_DIR}/.upload-$$
+cat > "$part"
+chmod 700 "$part"
+sum=$( (sha256sum "$part" 2>/dev/null || shasum -a 256 "$part") | cut -d' ' -f1)
+mv -f "$part" ${target}
+echo "sha256=$sum"
+`;
+}
+var NO_PROVIDER = ["No provider or model configured", "Saved provider/model is no longer usable"];
+function startScript(options) {
+  const bin = remoteBinaryPath(options.version);
+  return `set -u
+umask 077
+${stateScript(options.path)}
+cd "$dir" || { echo error=path; exit 3; }
+mkdir -p "$state_dir"
+chmod 700 "$state_dir"
+printf '%s' ${shQuote(options.token)} > "$token_file"
+export WEBUI_TOKEN=${shQuote(options.token)}
+launch() {
+  : > "$log"
+  if command -v setsid >/dev/null 2>&1; then
+    nohup setsid ${bin} --webui --host 127.0.0.1 --port ${options.preferredPort} "$@" > "$log" 2>&1 < /dev/null &
+  else
+    nohup ${bin} --webui --host 127.0.0.1 --port ${options.preferredPort} "$@" > "$log" 2>&1 < /dev/null &
+  fi
+  pid=$!
+}
+# 0: running and "port" is set, 1: the host exited, 2: no port in time.
+await_port() {
+  i=0
+  while [ "$i" -lt 240 ]; do
+    port=$(sed -n 's/.*WebUI running.*127\\.0\\.0\\.1:\\([0-9][0-9]*\\).*/\\1/p' "$log" | head -n 1)
+    [ -n "$port" ] && return 0
+    kill -0 "$pid" 2>/dev/null || return 1
+    sleep 0.5
+    i=$((i + 1))
+  done
+  return 2
+}
+launch
+await_port
+status=$?
+if [ "$status" -eq 1 ] && grep -q ${NO_PROVIDER.map((line) => `-e ${shQuote(line)}`).join(" ")} "$log"; then
+  echo setup=1
+  launch --provider wrongstack-setup --model no-api-key
+  await_port
+  status=$?
+fi
+if [ "$status" -eq 0 ]; then
+  printf '{"pid":%s,"port":%s,"version":"%s"}\\n' "$pid" "$port" ${shQuote(options.version)} > "$state"
+  echo "port=$port"
+  echo "pid=$pid"
+  exit 0
+fi
+rm -f "$token_file"
+if [ "$status" -eq 1 ]; then
+  echo error=exited
+  tail -n 30 "$log" | sed 's/^/log=/'
+  exit 4
+fi
+kill "$pid" 2>/dev/null
+echo error=timeout
+exit 5
+`;
+}
+function stopScript(path3) {
+  return `set -u
+${stateScript(path3)}
+[ -n "$abs" ] && [ -f "$state" ] || exit 0
+pid=$(sed -n 's/.*"pid":\\([0-9]*\\).*/\\1/p' "$state")
+[ -n "$pid" ] && kill "$pid" 2>/dev/null
+rm -f "$state" "$token_file"
+echo stopped=1
+`;
+}
+
+// src/remote/remote-session.ts
+var RECONNECT_DELAYS_MS = [1e3, 2e3, 4e3, 8e3, 15e3, 3e4];
+var READY_TIMEOUT_MS = 3e4;
+async function sha256File(file) {
+  const hash = createHash("sha256");
+  for await (const chunk of createReadStream(file)) hash.update(chunk);
+  return hash.digest("hex");
+}
+async function freeLocalPort(start) {
+  for (let port = start; port < start + 200; port++) {
+    const free = await new Promise((resolve2) => {
+      const server = net.createServer();
+      server.once("error", () => resolve2(false));
+      server.listen(port, "127.0.0.1", () => server.close(() => resolve2(true)));
+    });
+    if (free) return port;
+  }
+  throw new Error(`No free local port from ${start} to ${start + 199}.`);
+}
+var REMOTE_ERRORS = {
+  path: "cannot enter the project directory",
+  exited: "the WrongStack host exited",
+  timeout: "the WrongStack host did not report its port within two minutes"
+};
+function sshError(step, result) {
+  const lines = result.stdout.split(/\r?\n/);
+  const code = lines.find((line) => line.startsWith("error="))?.slice("error=".length);
+  const log = lines.filter((line) => line.startsWith("log=")).map((line) => line.slice(4));
+  const reason = code ? REMOTE_ERRORS[code] ?? code : `ssh exited with ${result.code}`;
+  const detail = log.length > 0 ? `:
+${log.join("\n")}` : code ? "." : ". See the ssh message above.";
+  return new Error(`Remote ${step} failed: ${reason}${detail}`);
+}
+async function ensureBinary(opts, probe) {
+  const buildTarget = buildTargetFor(probe.os, probe.arch, probe.musl);
+  const binary = await opts.resolveBinary(buildTarget, probe.versions);
+  if (probe.versions.includes(binary.version)) return binary;
+  opts.log(
+    `Uploading WrongStack ${binary.version} (${buildTarget}) to ${opts.target.destination}\u2026`
+  );
+  const sent = await sha256File(binary.file);
+  const result = await opts.ssh(
+    `sh -c ${shQuote(installScript(binary.version))}`,
+    createReadStream(binary.file)
+  );
+  const received = /^sha256=([a-f0-9]{64})$/m.exec(result.stdout)?.[1];
+  if (result.code !== 0 || !received) throw sshError("upload", result);
+  if (received !== sent) {
+    throw new Error("The build that arrived on the remote machine does not match the one sent.");
+  }
+  return binary;
+}
+async function ensureServer(opts, probe, binary) {
+  if (probe.server && probe.server.version === binary.version) {
+    opts.log(`Reusing the WrongStack host already running on ${opts.target.destination}.`);
+    return { port: probe.server.port, token: probe.server.token };
+  }
+  if (probe.server) await opts.ssh("sh -s", stopScript(opts.target.path));
+  const token = randomBytes(24).toString("base64url");
+  opts.log(`Starting WrongStack on ${opts.target.destination}:${opts.target.path}\u2026`);
+  const result = await opts.ssh(
+    "sh -s",
+    startScript({ path: opts.target.path, version: binary.version, token, preferredPort: 3456 })
+  );
+  if (/^setup=1$/m.test(result.stdout)) {
+    opts.log("No usable provider is set up there yet; choose one in the WebUI.");
+  }
+  const port = Number(/^port=(\d+)$/m.exec(result.stdout)?.[1]);
+  if (result.code !== 0 || !Number.isInteger(port) || port <= 0) {
+    throw sshError("start", result);
+  }
+  return { port, token };
+}
+async function probeRemote(opts) {
+  const result = await opts.ssh("sh -s", probeScript(opts.target.path));
+  if (result.code !== 0) throw sshError("connection", result);
+  const probe = parseProbe(result.stdout);
+  if (!probe.pathExists) {
+    throw new Error(`${opts.target.path} does not exist on ${opts.target.destination}.`);
+  }
+  return probe;
+}
+async function waitForWebui(localPort, token, tunnel, signal, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline && tunnel.exitCode === null && !signal.aborted) {
+    try {
+      const res = await fetch(`http://127.0.0.1:${localPort}/ws-auth`, {
+        headers: { "X-WS-Token": token },
+        signal: AbortSignal.timeout(3e3)
+      });
+      if (res.ok) return true;
+    } catch {
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, 400));
+  }
+  return false;
+}
+function exited(child) {
+  return child.exitCode !== null ? Promise.resolve(child.exitCode) : new Promise((resolve2) => child.once("exit", (code) => resolve2(code ?? 1)));
+}
+async function runRemoteSession(opts) {
+  const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  let probe = await probeRemote(opts);
+  const binary = await ensureBinary(opts, probe);
+  let server = await ensureServer(opts, probe, binary);
+  const localPort = await freeLocalPort(opts.localPort);
+  let announced = "";
+  let failures = 0;
+  try {
+    while (!opts.signal.aborted) {
+      const tunnel = opts.tunnel(localPort, server.port);
+      const stopTunnel = () => tunnel.kill();
+      opts.signal.addEventListener("abort", stopTunnel, { once: true });
+      const ready = await waitForWebui(
+        localPort,
+        server.token,
+        tunnel,
+        opts.signal,
+        opts.readyTimeoutMs ?? READY_TIMEOUT_MS
+      );
+      if (!ready && !opts.signal.aborted) {
+        tunnel.kill();
+        if (!announced) {
+          await exited(tunnel);
+          opts.signal.removeEventListener("abort", stopTunnel);
+          throw new Error(
+            `The WebUI on ${opts.target.destination} did not answer through the SSH tunnel. Check that its sshd allows port forwarding (AllowTcpForwarding) and see the host log under ~/.wrongstack/remote/servers/ there.`
+          );
+        }
+      }
+      if (ready) {
+        failures = 0;
+        const url = `http://127.0.0.1:${localPort}/?token=${server.token}`;
+        if (url !== announced) {
+          opts.log(`WebUI for ${opts.target.destination}:${opts.target.path} \u2192 ${url}`);
+          opts.log("Press Ctrl+C to disconnect.");
+          if (opts.open && !announced) opts.openUrl?.(url);
+          announced = url;
+        } else {
+          opts.log("Reconnected.");
+        }
+      }
+      await exited(tunnel);
+      opts.signal.removeEventListener("abort", stopTunnel);
+      if (opts.signal.aborted) break;
+      const delay = RECONNECT_DELAYS_MS[Math.min(failures, RECONNECT_DELAYS_MS.length - 1)] ?? 3e4;
+      failures += 1;
+      opts.log(
+        `The connection to ${opts.target.destination} dropped; reconnecting in ${delay / 1e3}s\u2026`
+      );
+      await sleep(delay);
+      if (opts.signal.aborted) break;
+      try {
+        probe = await probeRemote(opts);
+        server = await ensureServer(opts, probe, binary);
+      } catch (err) {
+        opts.log(toErrorMessage(err));
+      }
+    }
+  } finally {
+    if (!opts.keep) {
+      await opts.ssh("sh -s", stopScript(opts.target.path)).then(() => opts.log(`Stopped WrongStack on ${opts.target.destination}.`)).catch(() => opts.log("Could not stop the remote WrongStack host; it keeps running."));
+    } else {
+      opts.log(`WrongStack keeps running on ${opts.target.destination} (--keep).`);
+    }
+  }
+  return 0;
+}
+function sshAgentEnv() {
+  const env = {};
+  for (const key of [
+    "SSH_AUTH_SOCK",
+    "SSH_AGENT_PID",
+    "SSH_ASKPASS",
+    "SSH_ASKPASS_REQUIRE",
+    "DISPLAY"
+  ]) {
+    const value = process.env[key];
+    if (value !== void 0) env[key] = value;
+  }
+  return env;
+}
+function sshCommandLine(target, options) {
+  return [
+    ...options.sshConfig ? ["-F", options.sshConfig] : [],
+    ...target.port ? ["-p", String(target.port)] : [],
+    // Without a terminal (or an askpass helper) a password prompt would hang.
+    ...options.batch ? ["-o", "BatchMode=yes"] : [],
+    "-o",
+    "ConnectTimeout=20",
+    "-o",
+    "ServerAliveInterval=15",
+    "-o",
+    "ServerAliveCountMax=3"
+  ];
+}
+function systemSsh(target, options) {
+  const base = sshCommandLine(target, options);
+  const run = (remoteCommand, input) => new Promise((resolve2) => {
+    const child = spawn("ssh", [...base, "--", target.destination, remoteCommand], {
+      stdio: ["pipe", "pipe", "inherit"],
+      env: { ...buildChildEnv(), ...sshAgentEnv() },
+      windowsHide: true
+    });
+    let stdout = "";
+    child.stdout?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+      if (stdout.length < 1e6) stdout += chunk;
+    });
+    child.on("error", (err) => resolve2({ code: 127, stdout: `error=${err.message}` }));
+    child.on("close", (code) => resolve2({ code: code ?? 1, stdout }));
+    child.stdin?.on("error", () => void 0);
+    if (typeof input === "string") child.stdin?.end(input);
+    else input.pipe(child.stdin);
+  });
+  const tunnel = (localPort, remotePort) => spawn(
+    "ssh",
+    [
+      ...base,
+      "-N",
+      "-o",
+      "ExitOnForwardFailure=yes",
+      "-L",
+      `127.0.0.1:${localPort}:127.0.0.1:${remotePort}`,
+      "--",
+      target.destination
+    ],
+    {
+      stdio: ["ignore", "ignore", "inherit"],
+      env: { ...buildChildEnv(), ...sshAgentEnv() },
+      windowsHide: true
+    }
+  );
+  return { run, tunnel };
+}
+function releaseCacheFile(root, version, assetName) {
+  return path.join(root, "remote-builds", `${version}-${assetName}`);
+}
+async function cachedFile(file) {
+  if (!existsSync(file)) return void 0;
+  const stat2 = await fsp.stat(file);
+  return stat2.size > 0 ? file : void 0;
+}
+
+// src/subcommands/handlers/remote.ts
+var USAGE = `Usage: wstack remote <user@host:/path | ssh://user@host:port/path> [options]
+
+Runs WrongStack on the remote machine, in that project directory, and opens its
+WebUI here through an SSH tunnel. The agent, its tools and its daemons run
+remotely. The system ssh is used, so ~/.ssh/config, your agent and known_hosts
+apply. Nothing from your local configuration is copied; set up a provider in the
+remote WebUI the first time.
+
+Options:
+  --port <n>            Local port for the WebUI (default 3456, next free one)
+  --open                Open the WebUI in your browser
+  --keep                Leave WrongStack running remotely when you disconnect
+  --ssh-config <file>   Use this ssh config file (ssh -F)
+  --remote-binary <f>   Upload this WrongStack build instead of the release one
+`;
+function flagString(flags, name) {
+  const value = flags[name];
+  return typeof value === "string" && value ? value : void 0;
+}
+async function resolveBinary(buildTarget, installed, explicit, log) {
+  if (explicit) {
+    const file2 = path2.resolve(explicit);
+    const sha2 = await sha256File(file2);
+    return { file: file2, version: `build-${sha2.slice(0, 16)}` };
+  }
+  if (isStandaloneBinary() && STANDALONE_TARGET === buildTarget) {
+    return { file: process.execPath, version: CLI_VERSION };
+  }
+  const release = await findStandaloneRelease(buildTarget);
+  if (installed.includes(release.version)) return { file: "", version: release.version };
+  const file = releaseCacheFile(wstackGlobalRoot(), release.version, release.assetName);
+  const cached = await cachedFile(file);
+  if (cached) {
+    await verifyStandaloneDigest(release, await sha256File(cached));
+    return { file: cached, version: release.version };
+  }
+  log(`Downloading WrongStack ${release.version} for ${buildTarget}\u2026`);
+  await fsp2.mkdir(path2.dirname(file), { recursive: true });
+  await fsp2.rm(file, { force: true });
+  const sha = await downloadReleaseAssetToFile(release.asset.browser_download_url, file, {
+    timeoutMs: 10 * 6e4,
+    maxBytes: MAX_BINARY_BYTES
+  });
+  try {
+    await verifyStandaloneDigest(release, sha);
+  } catch (err) {
+    await fsp2.rm(file, { force: true });
+    throw err;
+  }
+  return { file, version: release.version };
+}
+async function runRemoteCommand(args, flags, renderer) {
+  const write = (line) => renderer.writeLine(line);
+  const targetText = flagString(flags, "remote") ?? args[0];
+  if (flags["help"] === true || !targetText) {
+    write(USAGE);
+    return flags["help"] === true ? 0 : 2;
+  }
+  let target;
+  try {
+    target = parseRemoteTarget(targetText);
+  } catch (err) {
+    write(toErrorMessage2(err));
+    return 2;
+  }
+  const portText = flagString(flags, "port");
+  const localPort = portText ? Number(portText) : 3456;
+  if (!Number.isInteger(localPort) || localPort < 1 || localPort > 65535) {
+    write(`--port must be a TCP port, got ${portText}`);
+    return 2;
+  }
+  const sshConfig = flagString(flags, "ssh-config");
+  const explicitBinary = flagString(flags, "remote-binary");
+  const ssh = systemSsh(target, {
+    ...sshConfig ? { sshConfig } : {},
+    batch: !process.stdin.isTTY && !process.env["SSH_ASKPASS"]
+  });
+  const controller = new AbortController();
+  const onInterrupt = () => controller.abort();
+  process.once("SIGINT", onInterrupt);
+  process.once("SIGTERM", onInterrupt);
+  try {
+    return await runRemoteSession({
+      target,
+      localPort,
+      keep: flags["keep"] === true,
+      open: flags["open"] === true,
+      signal: controller.signal,
+      log: write,
+      ssh: ssh.run,
+      tunnel: ssh.tunnel,
+      resolveBinary: (buildTarget, installed) => resolveBinary(buildTarget, installed, explicitBinary, write),
+      openUrl: openBrowser
+    });
+  } catch (err) {
+    write(toErrorMessage2(err));
+    return 1;
+  } finally {
+    process.off("SIGINT", onInterrupt);
+    process.off("SIGTERM", onInterrupt);
+  }
+}
+var remoteCmd = (args, deps) => runRemoteCommand(args, deps.flags ?? {}, deps.renderer);
+export {
+  remoteCmd,
+  runRemoteCommand
+};
+//# sourceMappingURL=remote-GB5VXCCT.js.map

package/dist/{replay-Z3FTJEMM.js → replay-DEI566CW.js}

@@ -25,9 +25,9 @@ function bindReplayToContainer(opts) {
       warn: (m) => logger.warn?.(m)
     } : void 0
   });
-  container.bind(TOKENS.ProviderRunner, () => wrapped);
+  container.override(TOKENS.ProviderRunner, () => wrapped);
 }
 export {
   bindReplayToContainer
 };
-//# sourceMappingURL=replay-Z3FTJEMM.js.map
+//# sourceMappingURL=replay-DEI566CW.js.map

package/dist/services/commit-message.d.ts

@@ -16,7 +16,8 @@ export interface CommitLLMProvider {
                 text: string;
             }[];
         }[];
-        maxTokens: number;
+        /** Unset = the model's own output ceiling. */
+        maxTokens?: number | undefined;
         temperature?: number | undefined;
     }, opts: {
         signal: AbortSignal;

package/dist/session-move-P2EC2COA.js

@@ -0,0 +1,44 @@
+
+// src/session-move.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { DefaultSessionStore } from "@wrongstack/core/storage";
+import { resolveWstackPaths } from "@wrongstack/core/utils";
+async function moveSessionTo(opts) {
+  const { store } = opts;
+  if (!store.move || store.sessionsDir === void 0) {
+    throw new Error("This session store cannot move sessions.");
+  }
+  const checkout = path.resolve(opts.targetPath);
+  const stat2 = await fs.stat(checkout).catch(() => null);
+  if (!stat2?.isDirectory()) throw new Error(`Not a directory: ${checkout}`);
+  const targetDir = resolveWstackPaths({
+    projectRoot: checkout,
+    ...opts.globalRoot ? { globalRoot: opts.globalRoot } : {}
+  }).projectSessions;
+  const adopt = store.adoptMovedSession?.bind(store);
+  if (path.resolve(targetDir) === path.resolve(store.sessionsDir) && adopt) {
+    return store.move(opts.sessionId, {
+      store: { sessionsDir: store.sessionsDir, adoptMovedSession: adopt },
+      checkout
+    });
+  }
+  await fs.mkdir(targetDir, { recursive: true });
+  const targetStore = new DefaultSessionStore({ dir: targetDir, projectRoot: checkout });
+  try {
+    return await store.move(opts.sessionId, { store: targetStore, checkout });
+  } finally {
+    await targetStore.dispose().catch(() => void 0);
+  }
+}
+function describeSessionMove(result) {
+  if (result.kind === "worktree") {
+    return `Moved ${result.id} to the worktree at ${result.checkout}; /resume lists it there.`;
+  }
+  return `Moved ${result.id} to the project at ${result.checkout}${result.fromProject ? ` (from ${result.fromProject})` : ""}. Open it there with: cd "${result.checkout}" && wstack resume ${result.id}`;
+}
+export {
+  describeSessionMove,
+  moveSessionTo
+};
+//# sourceMappingURL=session-move-P2EC2COA.js.map

package/dist/session-move.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `sessions move` for the CLI subcommand and the `/sessions move` slash
+ * command: resolve where a session goes and hand both stores to
+ * `SessionStore.move`.
+ *
+ * A path inside another git worktree of this repository resolves to this
+ * store (all worktrees share one), so the move only re-stamps the session's
+ * checkout. Any other path is a project of its own: its store is opened here,
+ * which connects to that project's session catalog.
+ */
+import type { SessionMoveResult, SessionStore } from '@wrongstack/core/types';
+export declare function moveSessionTo(opts: {
+    store: SessionStore;
+    sessionId: string;
+    targetPath: string;
+    globalRoot?: string | undefined;
+}): Promise<SessionMoveResult>;
+/** One line for the user: where the session went and how to open it there. */
+export declare function describeSessionMove(result: SessionMoveResult): string;
+//# sourceMappingURL=session-move.d.ts.map

package/dist/session-stats.d.ts

@@ -21,6 +21,16 @@ export declare class SessionStats {
     private bytesWritten;
     private bashCommands;
     private fetches;
+    /**
+     * First token after submit: from a leader turn's start to its first
+     * streamed text, thinking or tool call — what the user actually waits for,
+     * the provider's latency plus everything the agent does before the request.
+     * The leader is the context of the first run; subagent runs are not turns
+     * anyone typed.
+     */
+    private leaderCtx;
+    private turnStartedAt;
+    private readonly firstTokenMs;
     private readonly _handlers;
     constructor(events: EventBus, tokenCounter: TokenCounter);
     /** Remove all event listeners. Call this when the session ends. */