@leuria/cli 0.1.2 → 0.1.3

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

@@ -654,13 +654,13 @@ function compareVersions(a, b) {
 }
 
 // src/version.ts
-var VERSION = true ? "0.1.2" : "0.0.0-dev";
+var VERSION = true ? "0.1.3" : "0.0.0-dev";
 
 // src/auth.ts
 import crossSpawn3 from "cross-spawn";
-import { mkdtempSync as mkdtempSync2, rmSync as rmSync3 } from "fs";
-import { tmpdir as tmpdir2 } from "os";
-import { join as join5 } from "path";
+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";
@@ -710,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() {
@@ -778,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" };
@@ -919,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)
@@ -949,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 {
@@ -966,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;
@@ -978,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;
     }
@@ -1071,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({
@@ -1085,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 };
 }
@@ -1114,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(() => {
@@ -1132,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;
@@ -1190,13 +1314,30 @@ async function signIn(id, options = {}) {
     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) => {
@@ -1582,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";
@@ -1658,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"}`, {
@@ -1678,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();
 }
@@ -1701,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("/");
@@ -2432,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 {
@@ -2919,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;
   }
@@ -2931,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-JOCM56MT.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;
     }

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-JOCM56MT.js";
+} from "./chunk-JBVFUXX5.js";
 export {
   DEFAULT_PORT,
   GrantStore,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leuria/cli",
-  "version": "0.1.2",
+  "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",