@leuria/cli 0.1.0 → 0.1.2

package/dist/cli.js

@@ -27,6 +27,7 @@ import {
   parseBody,
   parseLlmId,
   parseNeeds,
+  pruneAgentVersions,
   rememberAgentState,
   removeProvider,
   resetAgent,
@@ -37,8 +38,9 @@ import {
   seenAgentModels,
   sendJson,
   signIn,
-  startEngine
-} from "./chunk-BXSAYWR3.js";
+  startEngine,
+  updateAgents
+} from "./chunk-JOCM56MT.js";
 
 // src/cli.ts
 import { spawn } from "child_process";
@@ -119,7 +121,14 @@ function addAi(id) {
 }
 function removeAi(id) {
   const config = loadConfig();
-  saveConfig({ ...config, ais: (config.ais ?? []).filter((a) => a !== id) });
+  const { [id]: _model, ...models } = config.models ?? {};
+  const { [id]: _ready, ...ready } = config.ready ?? {};
+  saveConfig({ ...config, ais: (config.ais ?? []).filter((a) => a !== id), models, ready });
+}
+function providerInUse(providerId, defaultAgent) {
+  const config = loadConfig();
+  const uses = (id) => parseLlmId(id)?.providerId === providerId;
+  return uses(defaultAgent) || (config.ais ?? []).some(uses) || typeof config.embed === "object" && config.embed.provider === providerId;
 }
 function convertServiceAis(grants) {
   const toService = (id) => {
@@ -352,6 +361,7 @@ function freePort() {
 // src/admin.ts
 function createAdminHandler(ctx) {
   let signingIn = null;
+  let signingInAgent = "";
   return async (req, res, pathname, pairing, sessions) => {
     const siteAi = (origin) => ctx.grants.get(origin)?.agent ?? ctx.config.agent;
     const method = req.method ?? "GET";
@@ -506,7 +516,20 @@ function createAdminHandler(ctx) {
         return true;
       }
       removeAi(id);
-      for (const grant of ctx.grants.list()) if (grant.agent === id) ctx.grants.setAgent(grant.origin, void 0);
+      for (const grant of ctx.grants.list()) {
+        if (grant.agent === id) ctx.grants.setAgent(grant.origin, void 0);
+        if (grant.model?.agent === id) ctx.grants.setModel(grant.origin, void 0);
+      }
+      if (isLlmId(id)) {
+        const provider = parseLlmId(id)?.providerId;
+        if (provider && !providerInUse(provider, ctx.config.agent)) removeProvider(provider);
+      } else {
+        if (signingInAgent === id) {
+          signingIn?.abort();
+          signingIn = null;
+        }
+        resetAgent(id);
+      }
       sendJson(res, 200, { removed: id });
       return true;
     }
@@ -524,7 +547,8 @@ function createAdminHandler(ctx) {
       signingIn?.abort();
       const controller = new AbortController();
       signingIn = controller;
-      const result = await signIn(typeof body.agent === "string" && body.agent ? body.agent : ctx.config.agent, {
+      signingInAgent = typeof body.agent === "string" && body.agent ? body.agent : ctx.config.agent;
+      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).
@@ -544,8 +568,17 @@ function createAdminHandler(ctx) {
       return true;
     }
     if (route === "GET /models") {
-      const agent = new URL(req.url ?? "", "http://127.0.0.1").searchParams.get("agent") ?? ctx.config.agent;
-      sendJson(res, 200, { agent, models: isAvailable(agent) ? await agentModels(agent) : null });
+      const params = new URL(req.url ?? "", "http://127.0.0.1").searchParams;
+      const agent = params.get("agent") ?? ctx.config.agent;
+      if (!isAvailable(agent)) {
+        sendJson(res, 200, { agent, models: null });
+        return true;
+      }
+      const refresh = params.get("refresh") === "1";
+      const answered = refresh && !isLlmId(agent) ? (await checkSignIn(agent)).ok : true;
+      const models = await agentModels(agent);
+      const stale = refresh && (!answered || isLlmId(agent) && !models);
+      sendJson(res, 200, { agent, models, ...stale ? { stale: true } : {} });
       return true;
     }
     if (route === "POST /agent/model") {
@@ -1053,7 +1086,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);
@@ -1139,6 +1175,8 @@ function stdioMcpSelf() {
   const compiled = !script || script.startsWith("/$bunfs") || /^[A-Z]:[\\/]~BUN/i.test(script);
   return compiled ? { command: process.execPath, args: ["mcp-stdio"] } : { command: process.execPath, args: [...process.execArgv, script, "mcp-stdio"] };
 }
+var AI_UPDATE_DELAY_MS = 3e4;
+var AI_UPDATE_EVERY_MS = 24 * 60 * 60 * 1e3;
 async function startForApp(config, verbose, devPairing) {
   const token = process.env.LEURIA_ADMIN_TOKEN;
   if (!token || token.length < 32) throw new Error("LEURIA_ADMIN_TOKEN (32+ characters) is required with --app");
@@ -1148,6 +1186,11 @@ async function startForApp(config, verbose, devPairing) {
   const grants = new GrantStore();
   convertServiceAis(grants);
   config.agent = loadConfig().agent;
+  try {
+    pruneAgentVersions();
+  } catch (err) {
+    logger.warn("could not remove old AI versions", { err: err instanceof Error ? err.message : String(err) });
+  }
   let port = config.port;
   const engine = await startEngine({
     port: config.port,
@@ -1179,13 +1222,26 @@ async function startForApp(config, verbose, devPairing) {
   });
   port = engine.port;
   emit({ event: "ready", port, version: VERSION, agent: config.agent });
+  const updateAis = () => void updateAgents(async (agent, from) => {
+    logger.info("AI updated", { id: agent.id, from, to: agent.version });
+    await checkSignIn(agent.id, void 0, { quiet: true }).catch(() => void 0);
+    emit({ event: "agent_updated", id: agent.id });
+  });
+  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

@@ -21,6 +21,230 @@ interface SiteNeeds {
     context?: number;
 }
 
+interface Logger {
+    info: (msg: string, meta?: Record<string, unknown>) => void;
+    warn: (msg: string, meta?: Record<string, unknown>) => void;
+    error: (msg: string, meta?: Record<string, unknown>) => void;
+}
+/** Line-per-event logger on stderr, so stdout stays free. */
+declare function createLogger(verbose?: boolean): Logger;
+
+/**
+ * Where a site's skills come from, and fetching them. A skill is a
+ * `SKILL.md` (YAML front matter with `name` and `description`, then
+ * instructions) and the text files beside it; see https://agentskills.io.
+ *
+ * Sources use the `npx skills` syntax, so developers paste the refs they
+ * already use:
+ *
+ *   owner/repo                       every skill in a GitHub repository
+ *   owner/repo@skill                 one skill, by name
+ *   owner/repo/path/to/skills        the skills under a folder
+ *   …#ref                            at a branch, tag or commit (pin it)
+ *   https://github.com/o/r/tree/ref/path
+ *   /  or  https://site.example/…    the site's own: `.well-known/agent-skills`
+ *                                    (agentskills.io discovery) or a `SKILL.md` URL
+ *
+ * Only GitHub and the site's own origin: the engine never fetches an
+ * address a site picks elsewhere, so a page can't point it at the visitor's
+ * network. Only text is kept; scripts and binaries are dropped (the agent
+ * has no shell to run them anyway).
+ */
+/** A skill as fetched: its instructions and text files. */
+interface SkillContent {
+    name: string;
+    description: string;
+    /** `SKILL.md` without its front matter. */
+    body: string;
+    /** Other text files of the skill, by path relative to its folder. */
+    files: Record<string, string>;
+}
+
+/**
+ * In-process WebMCP relay for the bridge daemon.
+ *
+ * Two surfaces, one server:
+ *
+ *   - **Browser → bridge (WebSocket)**: the browser console connects to
+ *     `ws://127.0.0.1:<port>/webmcp/register`, exchanges its registration
+ *     token for a channel WS at `/webmcp/channel/:id?token=…`, then
+ *     declares the tools / resources / prompts it wants to expose.
+ *
+ *   - **Agent → bridge (HTTP MCP)**: the spawned ACP agent calls JSON-RPC
+ *     2.0 against `POST /webmcp/mcp` with `Authorization: Bearer
+ *     <channelToken>`. `tools/list` and friends read the channel's
+ *     registry; `tools/call` etc. forward the request to the browser via
+ *     the channel WS and await the response.
+ *
+ * Long-blocking calls (`tools/call`, `resources/read`, `prompts/get`)
+ * switch to chunked HTTP encoding and emit periodic newline keep-alives
+ * so the agent's HTTP client doesn't abort while the user is interacting
+ * in the browser.
+ *
+ * Origin checks happen in `server.ts` before requests reach this class.
+ */
+
+interface ToolDescriptor {
+    name: string;
+    description?: string;
+    inputSchema: Record<string, unknown>;
+    annotations?: Record<string, unknown>;
+}
+interface WebMcpChannelSummary {
+    id: string;
+    sessionId: string;
+    connected: boolean;
+    tools: Array<{
+        name: string;
+        description?: string;
+    }>;
+    resources: Array<{
+        uri: string;
+        name: string;
+        description?: string;
+    }>;
+    prompts: Array<{
+        name: string;
+        description?: string;
+    }>;
+}
+interface WebMcpLogger {
+    info: (msg: string, meta?: Record<string, unknown>) => void;
+    warn: (msg: string, meta?: Record<string, unknown>) => void;
+    error: (msg: string, meta?: Record<string, unknown>) => void;
+}
+declare class WebMcpServer {
+    private readonly logger;
+    private readonly port;
+    private readonly channels;
+    private readonly registrationTokens;
+    private readonly sessionChannels;
+    private readonly tokenToChannel;
+    private readonly registerWss;
+    private readonly channelWss;
+    constructor(logger: WebMcpLogger, port: number);
+    /**
+     * Allocate a channel for an ACP session. Returns:
+     *   - `registrationToken` — base64-encoded `{ server, token }` blob the
+     *     browser presents on the `/webmcp/register` WS to claim the channel.
+     *   - `channelToken` — Bearer credential the agent presents on the
+     *     `/webmcp/mcp` HTTP endpoint.
+     *   - `channelId` — server-side handle (used in the channel WS path).
+     */
+    createChannel(sessionId: string): {
+        registrationToken: string;
+        channelToken: string;
+        channelId: string;
+    };
+    getChannelSummaries(): WebMcpChannelSummary[];
+    /**
+     * Tear everything down — close the two WebSocketServers, kill every
+     * ping timer, reject every pending request, force-close every browser
+     * channel WS. Called from `daemon.ts`'s `shutdown` so the process can
+     * exit on Ctrl-C; without it the WS servers keep the event loop alive
+     * indefinitely.
+     */
+    close(): void;
+    removeChannel(sessionId: string): void;
+    /** Give a session its site's skills: the agent then also gets `read_skill`. */
+    setSkills(sessionId: string, skills: SkillContent[]): void;
+    /** The tools a session's agent gets: the page's, and `read_skill` when the site has skills. */
+    listTools(sessionId: string): ToolDescriptor[];
+    /** Run a page tool in the browser (or `read_skill` here); resolves with its JSON result. Throws on tool errors. */
+    callTool(sessionId: string, name: string, args: Record<string, unknown>): Promise<unknown>;
+    /** The page's tools, and the engine's `read_skill` in place of a page tool of that name. */
+    private toolsOf;
+    /** Returns true when the request path belongs to WebMCP. */
+    matches(pathname: string): boolean;
+    handleUpgrade(req: IncomingMessage, socket: Duplex, head: Buffer): void;
+    handleHttp(req: IncomingMessage, res: ServerResponse): Promise<void>;
+    private handleRegistrationConnection;
+    private handleChannelConnection;
+    private handleChannelMessage;
+    private parseTool;
+    private parseResource;
+    private parsePrompt;
+    private sendAck;
+    private resolveRequest;
+    private dispatch;
+    private forwardToBrowser;
+    private parseBody;
+    private sendJsonRpcResult;
+    private sendJsonRpcError;
+}
+
+/**
+ * Skills a site gives the visitor's AI: instructions for tasks on that
+ * site, in the Agent Skills format. The site names them (see
+ * `skill-sources.ts`); the engine fetches them when the site connects or
+ * changes its list, never while a conversation starts.
+ *
+ * One cache for every site, by content (a community skill two sites use is
+ * stored once), in `~/.leuria/skills` with cacache. Each site's grant keeps
+ * which skills it uses, so a skill is only ever offered in that site's
+ * sessions: the agent gets their names and descriptions, and reads one
+ * with the `read_skill` tool when a task calls for it.
+ *
+ * Skills don't widen what the AI can do: it still has only the page's
+ * tools. So there is no approval step, but Leuria shows them to the
+ * visitor, in the approval window and in the site's details.
+ */
+
+/** A skill a site uses, as its grant keeps it. */
+interface SiteSkill {
+    name: string;
+    description: string;
+    /** Where it comes from, for the visitor: the site's host, or `owner/repo`. */
+    source: string;
+    /** From the site itself, or shared from a public repository. */
+    shared: boolean;
+    /** Content address in the cache. */
+    integrity: string;
+    /** Set when the site added it after it was connected. */
+    addedAt?: string;
+}
+/** A site's skills: the refs it declared, and what they resolved to. */
+interface SiteSkills {
+    refs: string[];
+    list: SiteSkill[];
+}
+interface SkillServiceOptions {
+    grants: GrantStore;
+    logger: Logger;
+    /** cacache folder; `null` keeps skills in memory (tests). */
+    cache?: string | null;
+    /** Fetches a ref's skills; tests replace it. */
+    fetch?: (ref: string, origin: string) => Promise<{
+        skills: SkillContent[];
+        source: string;
+        shared: boolean;
+    }>;
+}
+declare class SkillService {
+    private readonly options;
+    private readonly cache;
+    private readonly memory;
+    private readonly refreshing;
+    constructor(options: SkillServiceOptions);
+    /**
+     * Fetch and cache the skills `refs` name for `origin`. A ref that fails
+     * is logged and skipped; the first skill of a name wins.
+     */
+    resolve(origin: string, refs: string[]): Promise<SiteSkill[]>;
+    /**
+     * A connected site sent its skill refs with a session: when they changed,
+     * fetch them in the background and update its grant. Sessions starting
+     * meanwhile keep the skills it had.
+     */
+    refresh(origin: string, refs: string[] | undefined): void;
+    /** The skills a session of `origin` gets, from the cache. */
+    forSession(origin: string): Promise<SkillContent[]>;
+    /** Wait for background refreshes (tests). */
+    settled(): Promise<void>;
+    private put;
+    private get;
+}
+
 /**
  * Sites the visitor approved. One grant per origin; the site holds the
  * token, the engine keeps only its SHA-256. Revoking a grant makes the
@@ -43,6 +267,8 @@ interface Grant {
     };
     /** What the site said its features need, when it connected (guidance for choosing its AI). */
     needs?: SiteNeeds;
+    /** The skills the site gives its AI: the refs it declared and what they resolved to. */
+    skills?: SiteSkills;
 }
 declare class GrantStore {
     private readonly path;
@@ -66,8 +292,10 @@ declare class GrantStore {
         agent: string;
         id: string;
     } | undefined): boolean;
-    /** Create or replace the origin's grant; returns the new token. Keeps the site's AI and model choice; `needs` replaces what it declared. */
-    create(origin: string, app?: string, needs?: SiteNeeds): string;
+    /** Replace the site's skills (it changed its list). Its open conversations keep the skills they started with. */
+    setSkills(origin: string, skills: SiteSkills | undefined): boolean;
+    /** Create or replace the origin's grant; returns the new token. Keeps the site's AI and model choice; `needs` and `skills` replace what it declared. */
+    create(origin: string, app?: string, needs?: SiteNeeds, skills?: SiteSkills): string;
     /** True when `token` is the origin's current token. */
     verify(origin: string, token: string | undefined): boolean;
     revoke(origin: string): boolean;
@@ -132,14 +360,6 @@ interface Embeddings {
     }>;
 }
 
-interface Logger {
-    info: (msg: string, meta?: Record<string, unknown>) => void;
-    warn: (msg: string, meta?: Record<string, unknown>) => void;
-    error: (msg: string, meta?: Record<string, unknown>) => void;
-}
-/** Line-per-event logger on stderr, so stdout stays free. */
-declare function createLogger(verbose?: boolean): Logger;
-
 /**
  * Pairing: how a site gets a grant, without the engine ever answering a
  * site that the visitor didn't ask about.
@@ -177,7 +397,9 @@ interface PairingOptions {
     linksOnly: boolean;
     /** Plain-language name of the configured agent, shown on the page. */
     agentName: () => string;
-    /** Called when a request is created (or a link repeated), e.g. to open the approval page or show the app. */
+    /** Fetch the skills a site names, to show them before the visitor answers. Without it, skills are ignored. */
+    resolveSkills?: (origin: string, refs: string[]) => Promise<SiteSkill[]>;
+    /** Called when a request is created (or a link repeated, or its skills are fetched), e.g. to open the approval page or show the app. */
     onRequest?: (request: PairingRequestInfo) => void;
     /** Called when the visitor decided, wherever they clicked. */
     onDecided?: (request: {
@@ -191,6 +413,11 @@ interface PairingRequestInfo {
     origin: string;
     app?: string;
     needs?: SiteNeeds;
+    /** The skills the site gives its AI; `loading` until they are fetched. */
+    skills?: {
+        loading: boolean;
+        list: Array<Pick<SiteSkill, "name" | "description" | "source" | "shared">>;
+    };
     approveUrl: string;
 }
 declare class Pairing {
@@ -210,6 +437,7 @@ declare class Pairing {
         app?: unknown;
         nonce?: unknown;
         needs?: unknown;
+        skills?: unknown;
     }): {
         requestId: string;
     } | {
@@ -221,6 +449,11 @@ declare class Pairing {
     private claim;
     /** Ask the visitor about `origin`, or update the question already asked. */
     private open;
+    /**
+     * Fetch the skills the site names, then show them: the question is asked
+     * again with them. Answered meanwhile: they go to the site's grant.
+     */
+    private fetchSkills;
     private info;
     /** Requests waiting for the visitor, e.g. for the desktop app. */
     pending(): PairingRequestInfo[];
@@ -324,115 +557,6 @@ interface AgentModels {
     configId?: string;
 }
 
-/**
- * In-process WebMCP relay for the bridge daemon.
- *
- * Two surfaces, one server:
- *
- *   - **Browser → bridge (WebSocket)**: the browser console connects to
- *     `ws://127.0.0.1:<port>/webmcp/register`, exchanges its registration
- *     token for a channel WS at `/webmcp/channel/:id?token=…`, then
- *     declares the tools / resources / prompts it wants to expose.
- *
- *   - **Agent → bridge (HTTP MCP)**: the spawned ACP agent calls JSON-RPC
- *     2.0 against `POST /webmcp/mcp` with `Authorization: Bearer
- *     <channelToken>`. `tools/list` and friends read the channel's
- *     registry; `tools/call` etc. forward the request to the browser via
- *     the channel WS and await the response.
- *
- * Long-blocking calls (`tools/call`, `resources/read`, `prompts/get`)
- * switch to chunked HTTP encoding and emit periodic newline keep-alives
- * so the agent's HTTP client doesn't abort while the user is interacting
- * in the browser.
- *
- * Origin checks happen in `server.ts` before requests reach this class.
- */
-
-interface ToolDescriptor {
-    name: string;
-    description?: string;
-    inputSchema: Record<string, unknown>;
-    annotations?: Record<string, unknown>;
-}
-interface WebMcpChannelSummary {
-    id: string;
-    sessionId: string;
-    connected: boolean;
-    tools: Array<{
-        name: string;
-        description?: string;
-    }>;
-    resources: Array<{
-        uri: string;
-        name: string;
-        description?: string;
-    }>;
-    prompts: Array<{
-        name: string;
-        description?: string;
-    }>;
-}
-interface WebMcpLogger {
-    info: (msg: string, meta?: Record<string, unknown>) => void;
-    warn: (msg: string, meta?: Record<string, unknown>) => void;
-    error: (msg: string, meta?: Record<string, unknown>) => void;
-}
-declare class WebMcpServer {
-    private readonly logger;
-    private readonly port;
-    private readonly channels;
-    private readonly registrationTokens;
-    private readonly sessionChannels;
-    private readonly tokenToChannel;
-    private readonly registerWss;
-    private readonly channelWss;
-    constructor(logger: WebMcpLogger, port: number);
-    /**
-     * Allocate a channel for an ACP session. Returns:
-     *   - `registrationToken` — base64-encoded `{ server, token }` blob the
-     *     browser presents on the `/webmcp/register` WS to claim the channel.
-     *   - `channelToken` — Bearer credential the agent presents on the
-     *     `/webmcp/mcp` HTTP endpoint.
-     *   - `channelId` — server-side handle (used in the channel WS path).
-     */
-    createChannel(sessionId: string): {
-        registrationToken: string;
-        channelToken: string;
-        channelId: string;
-    };
-    getChannelSummaries(): WebMcpChannelSummary[];
-    /**
-     * Tear everything down — close the two WebSocketServers, kill every
-     * ping timer, reject every pending request, force-close every browser
-     * channel WS. Called from `daemon.ts`'s `shutdown` so the process can
-     * exit on Ctrl-C; without it the WS servers keep the event loop alive
-     * indefinitely.
-     */
-    close(): void;
-    removeChannel(sessionId: string): void;
-    /** The page tools a session's browser has declared. */
-    listTools(sessionId: string): ToolDescriptor[];
-    /** Run a page tool in the browser; resolves with its JSON result. Throws on tool errors. */
-    callTool(sessionId: string, name: string, args: Record<string, unknown>): Promise<unknown>;
-    /** Returns true when the request path belongs to WebMCP. */
-    matches(pathname: string): boolean;
-    handleUpgrade(req: IncomingMessage, socket: Duplex, head: Buffer): void;
-    handleHttp(req: IncomingMessage, res: ServerResponse): Promise<void>;
-    private handleRegistrationConnection;
-    private handleChannelConnection;
-    private handleChannelMessage;
-    private parseTool;
-    private parseResource;
-    private parsePrompt;
-    private sendAck;
-    private resolveRequest;
-    private dispatch;
-    private forwardToBrowser;
-    private parseBody;
-    private sendJsonRpcResult;
-    private sendJsonRpcError;
-}
-
 /**
  * Agent sessions opened by websites.
  *
@@ -548,6 +672,8 @@ interface SessionManagerOptions {
     logger: Logger;
     /** Command for the agent serving `origin`: its own choice, or the default AI. */
     resolveAgent: (origin: string) => Promise<AgentLaunch>;
+    /** The skills `origin` gives its AI, already fetched: the agent gets their list and `read_skill`. */
+    loadSkills?: (origin: string) => Promise<SkillContent[]>;
     /** ACP handshake timeout. */
     startTimeoutMs?: number;
     /**
@@ -672,6 +798,8 @@ interface EngineOptions {
     onAgentState?: SessionManagerOptions["onAgentState"];
     /** Embeddings for connected sites. Default: an embedding model in LM Studio or Ollama on this computer. */
     embeddings?: Embeddings;
+    /** The skills sites give their AI. Default: fetched from GitHub or the site, cached in `~/.leuria/skills`. */
+    skills?: SkillService;
 }
 interface EngineHandle {
     port: number;
@@ -794,8 +922,13 @@ interface SignInStatus {
     /** Models the agent offers once signed in (from `session/new`), with the visitor's choice as `current`. */
     models?: AgentModels;
 }
-/** Is the visitor signed in to this agent? Opens (and closes) a real ACP session, within a time limit. */
-declare function checkSignIn(id: string, onProgress?: (message: string) => void): Promise<SignInStatus>;
+/**
+ * Is the visitor signed in to this agent? Opens (and closes) a real ACP session, within a time limit.
+ * `quiet`: a background look for its models; the answer is not remembered as the agent's state.
+ */
+declare function checkSignIn(id: string, onProgress?: (message: string) => void, options?: {
+    quiet?: boolean;
+}): Promise<SignInStatus>;
 /** Sign in with an advertised method, then confirm with `session/new`. */
 declare function signIn(id: string, options?: {
     methodId?: string;

package/dist/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leuria/cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "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",
@@ -29,9 +29,16 @@
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "^1.5.0",
-    "ws": "^8.18.0"
+    "cacache": "^21.0.1",
+    "cross-spawn": "^7.0.6",
+    "giget": "^3.3.1",
+    "ipaddr.js": "^2.5.0",
+    "ws": "^8.18.0",
+    "yaml": "^2.9.1"
   },
   "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",