@leuria/cli 0.1.1 → 0.1.3

package/dist/{chunk-ES2YTJPL.js → chunk-JBVFUXX5.js}

@@ -343,6 +343,7 @@ import { createHash } from "crypto";
 import { chmodSync as chmodSync2, existsSync as existsSync3, mkdirSync as mkdirSync4, readdirSync, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync3 } from "fs";
 import { dirname, join as join3 } from "path";
 import { promisify as promisify2 } from "util";
+import crossSpawn from "cross-spawn";
 
 // src/codex.ts
 import { execFile } from "child_process";
@@ -374,7 +375,11 @@ async function prepareCodexHome(agent) {
     "",
     "[features]",
     ...features.map((name) => `${name} = ${ENABLED_FEATURES.has(name)}`),
-    ""
+    "",
+    // Windows: the sandbox that needs no administrator rights (a restricted token).
+    // The other one asks for them the first time: out of the blue, and a dead end
+    // on a work computer without them.
+    ...process.platform === "win32" ? ["[windows]", 'sandbox = "unelevated"', ""] : []
   ];
   writeFileSync2(join2(home, "config.toml"), lines.join("\n"), { mode: 384 });
   writeFileSync2(stamp, agent.version);
@@ -576,12 +581,7 @@ async function installPackage(dir, spec, args, env) {
   if (process.versions.bun) {
     await execFileAsync2(process.execPath, ["add", spec], { cwd: dir, env: { ...process.env, BUN_BE_BUN: "1" }, timeout: 5 * 6e4 });
   } else {
-    const npm = process.platform === "win32" ? "npm.cmd" : "npm";
-    await execFileAsync2(npm, ["install", "--no-audit", "--no-fund", "--omit=dev", "--loglevel=error", spec], {
-      cwd: dir,
-      timeout: 5 * 6e4,
-      shell: process.platform === "win32"
-    });
+    await run("npm", ["install", "--no-audit", "--no-fund", "--omit=dev", "--loglevel=error", spec], { cwd: dir, timeout: 5 * 6e4 });
   }
   const name = spec.lastIndexOf("@") > 0 ? spec.slice(0, spec.lastIndexOf("@")) : spec;
   const pkgDir = join3(dir, "node_modules", ...name.split("/"));
@@ -593,6 +593,25 @@ async function installPackage(dir, spec, args, env) {
   const isScript = /\.[cm]?js$/.test(entry) || /^#!.*\b(node|bun)\b/.test(readFileSync3(entry, "utf-8").slice(0, 100));
   return isScript ? { command: process.execPath, launchArgs: [entry], args, env } : { command: entry, launchArgs: [], args, env };
 }
+function run(command, args, options) {
+  return new Promise((resolve, reject) => {
+    const child = crossSpawn(command, args, { cwd: options.cwd, stdio: ["ignore", "ignore", "pipe"], windowsHide: true });
+    let stderr = "";
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf-8");
+    });
+    const timer = setTimeout(() => child.kill(), options.timeout);
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (code === 0) resolve();
+      else reject(new Error(`${command} ${args.join(" ")} failed (${code ?? "stopped"})${stderr.trim() ? `: ${stderr.trim()}` : ""}`));
+    });
+  });
+}
 async function installBinary(dir, target) {
   const res = await fetch(target.archive, { signal: AbortSignal.timeout(5 * 6e4) });
   if (!res.ok) throw new Error(`Download failed (${res.status}): ${target.archive}`);
@@ -635,16 +654,17 @@ function compareVersions(a, b) {
 }
 
 // src/version.ts
-var VERSION = true ? "0.1.0" : "0.0.0-dev";
+var VERSION = true ? "0.1.3" : "0.0.0-dev";
 
 // src/auth.ts
-import { spawn as spawn2 } from "child_process";
-import { mkdtempSync as mkdtempSync2, rmSync as rmSync3 } from "fs";
-import { tmpdir as tmpdir2 } from "os";
-import { join as join5 } from "path";
+import crossSpawn3 from "cross-spawn";
+import { mkdtempSync as mkdtempSync3 } from "fs";
+import { tmpdir as tmpdir3 } from "os";
+import { join as join6 } from "path";
 
 // src/acp/acp-client.ts
 import { spawn } from "child_process";
+import crossSpawn2 from "cross-spawn";
 import { Readable, Writable } from "stream";
 var rawParams = {
   // biome-ignore lint/suspicious/noExplicitAny: ACP payloads are untyped here
@@ -690,6 +710,9 @@ var AcpLiveSession = class {
   imagesSupported = false;
   /** `initialize` result, once connected. */
   info = null;
+  /** The sign-in the agent says it uses, from `_auth/status_update` (Claude): "account", "api_key", "none"… */
+  authKind;
+  authWaiters = [];
   /** Models the agent offers, from `session/new` (and later updates). */
   models = null;
   get isAlive() {
@@ -707,11 +730,11 @@ var AcpLiveSession = class {
     const env = { ...process.env, ...this.options.envVars };
     for (const key of REMOVED_ENV_VARS) delete env[key];
     if (process.versions.bun) env.BUN_BE_BUN = "1";
-    const child = spawn(this.options.command, this.options.args, {
+    const child = crossSpawn2(this.options.command, this.options.args, {
       stdio: ["pipe", "pipe", "pipe"],
       env,
       cwd: this.options.cwd,
-      shell: process.platform === "win32",
+      windowsHide: true,
       // Its own process group, so close() also stops what the agent starts
       // (Gemini relaunches itself as a child process).
       detached: process.platform !== "win32"
@@ -758,6 +781,27 @@ var AcpLiveSession = class {
       return { error: error instanceof Error ? error.message : String(error) };
     }
   }
+  /**
+   * The sign-in the agent reports (see `authKind`), waiting up to `ms` for its first
+   * report. Undefined when the agent doesn't report one, or not in time. Some agents
+   * (Claude) open a session while signed out and refuse only the first prompt, so a
+   * session alone doesn't prove a sign-in.
+   */
+  async authStatus(ms) {
+    if (this.authKind !== void 0) return this.authKind;
+    if (!this.info?.agentCapabilities._meta?.authStatus) return void 0;
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this.authWaiters = this.authWaiters.filter((w) => w !== waiter);
+        resolve(void 0);
+      }, ms);
+      const waiter = (kind) => {
+        clearTimeout(timer);
+        resolve(kind);
+      };
+      this.authWaiters.push(waiter);
+    });
+  }
   /** ACP `authenticate` with one of the advertised methods (the agent runs its own flow). */
   async authenticate(methodId) {
     if (!this.connection) return { error: "Not connected" };
@@ -899,7 +943,12 @@ ${file.text}
         });
       }
     };
-    return sdk.client({ name: "leuria" }).onNotification(
+    return sdk.client({ name: "leuria" }).onNotification("_auth/status_update", rawParams, (ctx) => {
+      const kind = ctx.params?.authStatus?.kind;
+      if (typeof kind !== "string") return;
+      this.authKind = kind;
+      for (const waiter of this.authWaiters.splice(0)) waiter(kind);
+    }).onNotification(
       "session/update",
       rawParams,
       (ctx) => handleSessionUpdate(ctx.params)
@@ -915,7 +964,7 @@ ${file.text}
 function killTree(child) {
   try {
     if (process.platform === "win32" && child.pid) {
-      spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore" });
+      spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
     } else if (child.pid) {
       process.kill(-child.pid, "SIGTERM");
     } else {
@@ -929,13 +978,105 @@ function killTree(child) {
   }
 }
 
+// src/scratch.ts
+import { rm } from "fs/promises";
+function removeScratch(dir, onFailure) {
+  rm(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 500 }).catch((error) => onFailure?.(error));
+}
+
+// src/terminal-window.ts
+import { spawn as spawn2 } from "child_process";
+import { chmodSync as chmodSync3, existsSync as existsSync4, mkdtempSync, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { tmpdir } from "os";
+import { join as join4 } from "path";
+function canOpenTerminalWindow() {
+  return process.platform === "win32" || process.platform === "darwin";
+}
+async function runInTerminalWindow(options) {
+  if (!canOpenTerminalWindow()) throw new Error("Leuria can't open a terminal window on this system");
+  const dir = mkdtempSync(join4(tmpdir(), "leuria-window-"));
+  const done = join4(dir, "exit-code");
+  try {
+    if (process.platform === "win32") {
+      const script = join4(dir, "sign-in.cmd");
+      writeFileSync4(script, windowsScript(options, done), "utf-8");
+      spawn2("cmd.exe", ["/d", "/c", `start "${options.title.replaceAll('"', "")}" "${script}"`], {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: false,
+        windowsVerbatimArguments: true
+      }).unref();
+    } else {
+      const script = join4(dir, "sign-in.command");
+      writeFileSync4(script, macScript(options, done), "utf-8");
+      chmodSync3(script, 448);
+      spawn2("open", ["-a", "Terminal", script], { detached: true, stdio: "ignore" }).unref();
+    }
+    return await waitFor(done, options.signal, options.timeoutMs ?? 15 * 6e4);
+  } finally {
+    removeScratch(dir);
+  }
+}
+function waitFor(file, signal, timeoutMs) {
+  return new Promise((resolve) => {
+    const finish = (code) => {
+      clearInterval(poll);
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      resolve(code);
+    };
+    const onAbort = () => finish(null);
+    const poll = setInterval(() => {
+      if (!existsSync4(file)) return;
+      const code = Number.parseInt(readFileSync4(file, "utf-8").trim(), 10);
+      finish(Number.isNaN(code) ? null : code);
+    }, 1e3);
+    const timer = setTimeout(() => finish(null), timeoutMs);
+    if (signal?.aborted) onAbort();
+    else signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function windowsScript(options, done) {
+  const text = (value) => value.replaceAll("%", "%%");
+  const quote = (value) => `"${text(value).replaceAll('"', '""')}"`;
+  return [
+    "@echo off",
+    "chcp 65001 >nul",
+    `title ${text(options.title).replace(/[&|<>^]/g, "")}`,
+    `echo ${text(options.title).replace(/[&|<>^]/g, "")}`,
+    "echo Leuria opened this window. Follow the steps below: it closes by itself when you're done.",
+    "echo.",
+    `cd /d ${quote(options.cwd)}`,
+    ...Object.entries(options.env).map(([key, value]) => `set "${key}=${text(value)}"`),
+    [options.command, ...options.args].map(quote).join(" "),
+    `echo %errorlevel%> ${quote(done)}`,
+    ""
+  ].join("\r\n");
+}
+function macScript(options, done) {
+  const quote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+  return [
+    "#!/bin/bash",
+    "clear",
+    `echo ${quote(options.title)}`,
+    `echo ${quote("Leuria opened this window. Follow the steps below, then close it.")}`,
+    "echo",
+    `cd ${quote(options.cwd)}`,
+    ...Object.entries(options.env).map(([key, value]) => `export ${key}=${quote(value)}`),
+    [options.command, ...options.args].map(quote).join(" "),
+    `echo $? > ${quote(done)}`,
+    `echo; echo ${quote("Done. You can close this window.")}`,
+    ""
+  ].join("\n");
+}
+
 // src/browser-link.ts
 import { execFileSync } from "child_process";
-import { chmodSync as chmodSync3, existsSync as existsSync4, mkdirSync as mkdirSync5, mkdtempSync, readFileSync as readFileSync4, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "fs";
-import { tmpdir } from "os";
-import { delimiter, join as join4 } from "path";
+import { chmodSync as chmodSync4, existsSync as existsSync5, mkdirSync as mkdirSync5, mkdtempSync as mkdtempSync2, readFileSync as readFileSync5, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { delimiter, join as join5 } from "path";
 function realCommand(name) {
-  if (name === "open" && existsSync4("/usr/bin/open")) return "/usr/bin/open";
+  if (name === "open" && existsSync5("/usr/bin/open")) return "/usr/bin/open";
   try {
     return execFileSync("/bin/sh", ["-c", `command -v ${name}`], { encoding: "utf-8" }).trim() || null;
   } catch {
@@ -946,11 +1087,11 @@ function catchBrowserLinks(onUrl, options = {}) {
   if (process.platform === "win32") return null;
   const basePath = options.basePath ?? process.env.PATH ?? "";
   const findReal = options.real ?? realCommand;
-  const dir = mkdtempSync(join4(tmpdir(), "leuria-open-"));
-  const bin = join4(dir, "bin");
-  const log = join4(dir, "opened.txt");
+  const dir = mkdtempSync2(join5(tmpdir2(), "leuria-open-"));
+  const bin = join5(dir, "bin");
+  const log = join5(dir, "opened.txt");
   mkdirSync5(bin);
-  writeFileSync4(log, "");
+  writeFileSync5(log, "");
   for (const name of ["open", "xdg-open"]) {
     const real = findReal(name);
     if (!real) continue;
@@ -958,14 +1099,14 @@ function catchBrowserLinks(onUrl, options = {}) {
 for arg in "$@"; do printf '%s\\n' "$arg" >> '${log}'; done
 exec '${real}' "$@"
 `;
-    writeFileSync4(join4(bin, name), script);
-    chmodSync3(join4(bin, name), 493);
+    writeFileSync5(join5(bin, name), script);
+    chmodSync4(join5(bin, name), 493);
   }
   const seen = /* @__PURE__ */ new Set();
   const timer = setInterval(() => {
     let lines;
     try {
-      lines = readFileSync4(log, "utf-8").split("\n");
+      lines = readFileSync5(log, "utf-8").split("\n");
     } catch {
       return;
     }
@@ -1051,7 +1192,7 @@ function preferredMethod(methods, options = {}) {
 }
 async function open(id, onProgress, terminalAuth = false, extraEnv = {}) {
   const agent = await ensureAgent(id, { onProgress });
-  const sandbox = mkdtempSync2(join5(tmpdir2(), "leuria-auth-"));
+  const sandbox = mkdtempSync3(join6(tmpdir3(), "leuria-auth-"));
   const custom = profileFor(id)?.configure?.({ sandbox, mcpUrl: "http://127.0.0.1:9/unused", mcpToken: "unused" });
   const env = { ...agent.env, ...custom?.env, ...extraEnv };
   const session = new AcpLiveSession({
@@ -1065,7 +1206,7 @@ async function open(id, onProgress, terminalAuth = false, extraEnv = {}) {
   });
   const close = () => {
     session.close();
-    rmSync3(sandbox, { recursive: true, force: true });
+    removeScratch(sandbox);
   };
   return { agent, session, close, env, sandbox };
 }
@@ -1094,7 +1235,7 @@ function signInStallMs() {
 }
 async function checkSignIn(id, onProgress, options = {}) {
   if (isLlmId(id)) return checkLlm(id);
-  const { session, close } = await open(id, onProgress);
+  const { session, close } = await open(id, onProgress, true);
   let timer;
   const timedOut = new Promise((resolve) => {
     timer = setTimeout(() => {
@@ -1112,22 +1253,25 @@ async function checkSignIn(id, onProgress, options = {}) {
   async function check() {
     const connected = await session.connect();
     if (connected.error) return { ok: false, detail: `the agent did not start: ${connected.error}`, methods: [] };
-    const methods = agentMethods(session.info?.authMethods ?? []);
+    const all = session.info?.authMethods ?? [];
+    const methods = agentMethods(all);
+    const window = canOpenTerminalWindow() && methods.length === 0 && all.some(isTerminal) ? { window: true } : {};
     const created = await session.newSession();
-    if (!created.error) return { ok: true, detail: "ready", methods, ...withChoice(id, session.models) };
-    return { ok: false, detail: created.authRequired ? "not signed in" : created.error, methods };
+    if (created.error) return { ok: false, detail: created.authRequired ? "not signed in" : created.error, methods, ...window };
+    if (await session.authStatus(5e3) === "none") return { ok: false, detail: "not signed in", methods, ...window };
+    return { ok: true, detail: "ready", methods, ...withChoice(id, session.models) };
   }
 }
 async function signIn(id, options = {}) {
   if (isLlmId(id)) return checkLlm(id);
   let pageOpened = false;
-  const link = options.onUrl && !options.terminal ? catchBrowserLinks((url) => {
+  const link = options.onUrl && !options.terminal && !options.window ? catchBrowserLinks((url) => {
     pageOpened = true;
     options.onUrl?.(url);
   }) : null;
   let opened;
   try {
-    opened = await open(id, options.onProgress, options.terminal, link?.env);
+    opened = await open(id, options.onProgress, options.terminal || options.window, link?.env);
   } catch (error) {
     link?.stop();
     throw error;
@@ -1161,26 +1305,43 @@ async function signIn(id, options = {}) {
     else options.signal?.addEventListener("abort", onAbort, { once: true });
   });
   try {
-    return await Promise.race([cancelled, run()]);
+    return await Promise.race([cancelled, run2()]);
   } finally {
     close();
   }
-  async function run() {
+  async function run2() {
     let session = opened.session;
     const connected = await session.connect();
     if (connected.error) return { ok: false, detail: `the agent did not start: ${connected.error}`, methods: [] };
     const all = session.info?.authMethods ?? [];
-    const methods = options.terminal ? all : agentMethods(all);
+    const terminal = options.terminal || options.window;
+    const methods = terminal ? all : agentMethods(all);
     if (methods.length === 0) {
       return { ok: false, detail: `${agent.name} offers no sign-in method Leuria can run; sign in with its own tool.`, methods };
     }
-    const method = options.methodId ? methods.find((m) => m.id === options.methodId) : preferredMethod(methods, { terminal: options.terminal });
+    const method = options.methodId ? methods.find((m) => m.id === options.methodId) : preferredMethod(methods, { terminal });
     if (!method) return { ok: false, detail: `Unknown method. Available: ${methods.map((m) => m.id).join(", ")}`, methods };
     options.onProgress?.(`Signing in to ${agent.name} with ${method.name}${method.description ? ` (${method.description})` : ""}\u2026`);
+    if (isTerminal(method) && options.window) {
+      session.close();
+      const code = await runInTerminalWindow({
+        title: `Sign in to ${agentName(id)}`,
+        command: agent.command,
+        args: [...agent.launchArgs, ...method.args ?? []],
+        // A compiled engine runs JavaScript agents as plain Bun, as sessions do.
+        env: { ...env, ...method.env ?? {}, ...process.versions.bun ? { BUN_BE_BUN: "1" } : {} },
+        cwd: sandbox,
+        signal: options.signal
+      });
+      if (options.signal?.aborted) return { ok: false, detail: "cancelled", methods };
+      if (code === null) return { ok: false, detail: "the sign-in window didn't finish", methods, window: true };
+      if (code !== 0) return { ok: false, detail: `the sign-in ended with code ${code}`, methods, window: true };
+      return checkSignIn(id, options.onProgress);
+    }
     if (isTerminal(method)) {
       session.close();
       const code = await new Promise((resolve, reject) => {
-        const child = spawn2(agent.command, [...agent.launchArgs, ...method.args ?? []], {
+        const child = crossSpawn3(agent.command, [...agent.launchArgs, ...method.args ?? []], {
           stdio: "inherit",
           cwd: sandbox,
           env: { ...process.env, ...env, ...method.env ?? {} }
@@ -1562,9 +1723,9 @@ import cacache from "cacache";
 // src/skill-sources.ts
 import { createHash as createHash3 } from "crypto";
 import { lookup } from "dns/promises";
-import { mkdtemp, readdir, readFile, rm, stat } from "fs/promises";
-import { tmpdir as tmpdir3 } from "os";
-import { extname, join as join6, relative, sep } from "path";
+import { mkdtemp, readdir, readFile, rm as rm2, stat } from "fs/promises";
+import { tmpdir as tmpdir4 } from "os";
+import { extname, join as join7, relative, sep } from "path";
 import { downloadTemplate } from "giget";
 import ipaddr from "ipaddr.js";
 import { parse as parseYaml } from "yaml";
@@ -1638,7 +1799,7 @@ function parseSkillMd(text, files = {}) {
   return { name, description: description.slice(0, MAX_DESCRIPTION), body: match[2].trim(), files };
 }
 async function fromGithub(source) {
-  const dir = await mkdtemp(join6(tmpdir3(), "leuria-skills-"));
+  const dir = await mkdtemp(join7(tmpdir4(), "leuria-skills-"));
   try {
     const path2 = source.subpath ? `/${source.subpath}` : "";
     await downloadTemplate(`gh:${source.repo}${path2}#${source.ref ?? "HEAD"}`, {
@@ -1658,21 +1819,21 @@ async function fromGithub(source) {
         continue;
       }
       if (source.skill && skill.name !== source.skill) continue;
-      skill.files = await readTextFiles(join6(skillFile, ".."));
+      skill.files = await readTextFiles(join7(skillFile, ".."));
       found.push(skill);
     }
     return found;
   } finally {
-    await rm(dir, { recursive: true, force: true });
+    await rm2(dir, { recursive: true, force: true });
   }
 }
 async function findSkillFiles(dir, depth) {
   const entries = await readdir(dir, { withFileTypes: true });
   const own = entries.find((e) => e.isFile() && e.name.toLowerCase() === "skill.md");
-  if (own) return [join6(dir, own.name)];
+  if (own) return [join7(dir, own.name)];
   if (depth >= MAX_DEPTH) return [];
   const nested = await Promise.all(
-    entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => findSkillFiles(join6(dir, e.name), depth + 1))
+    entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => findSkillFiles(join7(dir, e.name), depth + 1))
   );
   return nested.flat();
 }
@@ -1681,7 +1842,7 @@ async function readTextFiles(dir) {
   let total = 0;
   const walk = async (at, depth) => {
     for (const entry of await readdir(at, { withFileTypes: true })) {
-      const full = join6(at, entry.name);
+      const full = join7(at, entry.name);
       if (entry.isDirectory() && depth < MAX_DEPTH) await walk(full, depth + 1);
       if (!entry.isFile() || !TEXT_FILES.has(extname(entry.name).toLowerCase())) continue;
       const path2 = relative(dir, full).split(sep).join("/");
@@ -2412,9 +2573,9 @@ function handleStream(req, res, sm, sessionId) {
 
 // src/session-manager.ts
 import { randomUUID } from "crypto";
-import { mkdirSync as mkdirSync6, rmSync as rmSync4 } from "fs";
-import { tmpdir as tmpdir4 } from "os";
-import { join as join7 } from "path";
+import { mkdirSync as mkdirSync6 } from "fs";
+import { tmpdir as tmpdir5 } from "os";
+import { join as join8 } from "path";
 
 // src/llm/llm-session.ts
 var LlmSession = class {
@@ -2899,7 +3060,7 @@ var SessionManager = class {
    * files (CLAUDE.md, repo) to act on.
    */
   allocateSandbox(sessionId) {
-    const dir = join7(tmpdir4(), `leuria-${sessionId}`);
+    const dir = join8(tmpdir5(), `leuria-${sessionId}`);
     mkdirSync6(dir, { recursive: true });
     return dir;
   }
@@ -2911,14 +3072,13 @@ var SessionManager = class {
     session.live = void 0;
     this.options.webMcpServer.removeChannel(session.id);
     setTimeout(() => this.sessions.delete(session.id), FORGET_AFTER_MS).unref();
-    try {
-      rmSync4(session.cwd, { recursive: true, force: true });
-    } catch (err) {
-      this.options.logger.warn("failed to remove sandbox", {
+    removeScratch(
+      session.cwd,
+      (err) => this.options.logger.warn("failed to remove sandbox", {
         cwd: session.cwd,
         err: err instanceof Error ? err.message : String(err)
-      });
-    }
+      })
+    );
   }
   notify(session, event, data) {
     for (const listener of session.listeners) {

package/dist/cli.js

@@ -40,7 +40,7 @@ import {
   signIn,
   startEngine,
   updateAgents
-} from "./chunk-ES2YTJPL.js";
+} from "./chunk-JBVFUXX5.js";
 
 // src/cli.ts
 import { spawn } from "child_process";
@@ -551,8 +551,10 @@ function createAdminHandler(ctx) {
       const result = await signIn(signingInAgent, {
         signal: controller.signal,
         methodId: typeof body.methodId === "string" ? body.methodId : void 0,
-        // The app has no terminal: only agent methods (the agent runs its own flow).
+        // The app has no terminal: agent methods (the agent runs its own flow), or
+        // a terminal-only sign-in (Claude) in a window Leuria opens.
         terminal: false,
+        window: body.window === true,
         // Offered in the app too, in case the browser did not come up.
         onUrl: (url) => ctx.emit({ event: "signin_url", url }),
         onProgress: (message) => ctx.emit({ event: "progress", stage: "signin", message })
@@ -717,6 +719,7 @@ function createAdminHandler(ctx) {
         // `message` is for the CLI; the app words each stage itself (no jargon for visitors).
         onStep: (message) => ctx.emit({ event: "progress", stage: "check", step: ++checkStep, message })
       });
+      if (!result.ok) ctx.logger.warn("check failed", { agent, steps: result.steps.filter((step) => !step.ok) });
       sendJson(res, 200, result);
       return true;
     }
@@ -1086,7 +1089,10 @@ function sites(args) {
   }
 }
 function openInBrowser(url) {
-  const [command, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
+  const [command, args] = process.platform === "darwin" ? ["open", [url]] : (
+    // Not `cmd /c start`: cmd would read the & between query parameters as a new command.
+    process.platform === "win32" ? ["rundll32", ["url.dll,FileProtocolHandler", url]] : ["xdg-open", [url]]
+  );
   try {
     const child = spawn(command, args, { stdio: "ignore", detached: true });
     child.on("error", () => void 0);
@@ -1226,13 +1232,19 @@ async function startForApp(config, verbose, devPairing) {
   });
   setTimeout(updateAis, AI_UPDATE_DELAY_MS).unref();
   setInterval(updateAis, AI_UPDATE_EVERY_MS).unref();
+  let stopping = false;
   const shutdown = async () => {
+    if (stopping) return;
+    stopping = true;
     await engine.close();
     process.exit(0);
   };
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
   process.stdin.on("end", shutdown);
+  process.stdin.on("data", (chunk) => {
+    if (chunk.toString("utf-8").split(/\r?\n/).includes("quit")) void shutdown();
+  });
   process.stdin.resume();
 }
 function out(text) {

package/dist/index.d.ts

@@ -921,6 +921,11 @@ interface SignInStatus {
     methods: AgentInfo["authMethods"];
     /** Models the agent offers once signed in (from `session/new`), with the visitor's choice as `current`. */
     models?: AgentModels;
+    /**
+     * The agent signs in only on the command line (Claude): Leuria can open a
+     * terminal window for it (`signIn(id, { window: true })`).
+     */
+    window?: boolean;
 }
 /**
  * Is the visitor signed in to this agent? Opens (and closes) a real ACP session, within a time limit.
@@ -934,6 +939,8 @@ declare function signIn(id: string, options?: {
     methodId?: string;
     /** The caller can run an interactive terminal method (a TTY). */
     terminal?: boolean;
+    /** Run the agent's terminal sign-in in a new terminal window (the desktop app has no terminal). */
+    window?: boolean;
     onProgress?: (message: string) => void;
     /** Cancel a sign-in in progress: the agent is stopped (which frees its login callback). */
     signal?: AbortSignal;

package/dist/index.js

@@ -18,7 +18,7 @@ import {
   resolveAgentCommand,
   signIn,
   startEngine
-} from "./chunk-ES2YTJPL.js";
+} from "./chunk-JBVFUXX5.js";
 export {
   DEFAULT_PORT,
   GrantStore,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leuria/cli",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Bring your own AI to the web: the Leuria engine. Lets websites you approve use the AI on your machine, through tools the page provides.",
   "license": "Apache-2.0",
   "type": "module",
@@ -30,6 +30,7 @@
   "dependencies": {
     "@agentclientprotocol/sdk": "^1.5.0",
     "cacache": "^21.0.1",
+    "cross-spawn": "^7.0.6",
     "giget": "^3.3.1",
     "ipaddr.js": "^2.5.0",
     "ws": "^8.18.0",
@@ -37,6 +38,7 @@
   },
   "devDependencies": {
     "@types/cacache": "^20.0.1",
+    "@types/cross-spawn": "^6.0.6",
     "@types/node": "^22.0.0",
     "@types/ws": "^8.5.0",
     "tsup": "^8.4.0",