@shardflux/cli 0.24.0 → 0.24.1

package/dist/conversation-transcript.d.ts

@@ -0,0 +1,44 @@
+/**
+ * `shard conversations transcript` and `shard conversations events` (0.25.0+): a conversation's stored transcript (the
+ * harness's own JSONL, byte for byte) and its event stream, read through the API without the conversation's computer.
+ */
+import type { ConversationEvent, ConversationTranscript, Shardflux } from '@shardflux/sdk';
+import type { Handler } from './commands.js';
+type ConversationsApi = Shardflux['conversations'];
+/** A stretch of transcript: the bytes [offset, next_offset) of a session's file. */
+export type TranscriptPiece = Pick<ConversationTranscript, 'session_id' | 'file' | 'offset' | 'next_offset' | 'size' | 'data'>;
+/**
+ * Reads pages from `offset` of a session (the latest when `sessionId` is undefined) until its stored end, or until
+ * `until` (a line boundary). Every page goes to `emit`; returns the last one.
+ */
+export declare function readTranscript(api: Pick<ConversationsApi, 'transcript'>, id: string, o: {
+    offset: number;
+    sessionId?: string | undefined;
+    until?: number;
+    signal: AbortSignal;
+}, emit: (page: ConversationTranscript) => void): Promise<ConversationTranscript>;
+/**
+ * Prints a followed transcript once: each event's lines after what was printed, the stored lines a reconnect or a new
+ * harness session would otherwise skip read from the API first.
+ */
+export declare class TranscriptFollower {
+    #private;
+    session: string | null;
+    offset: number;
+    constructor(api: Pick<ConversationsApi, 'transcript'>, id: string, at: {
+        session: string | null;
+        offset: number;
+    }, signal: AbortSignal, write: (p: TranscriptPiece) => void);
+    take(t: TranscriptPiece): Promise<void>;
+}
+/**
+ * The readable form of `shard conversations events`: a line per state change, transcript lines and tool call, the
+ * reply text as it streams. `end()` closes a reply still on its line.
+ */
+export declare class EventLines {
+    #private;
+    render(ev: ConversationEvent): string;
+    end(): string;
+}
+export declare const TRANSCRIPT_HANDLERS: Record<string, Handler>;
+export {};

package/dist/conversation-transcript.js

@@ -0,0 +1,206 @@
+import { out, str } from "./commands.js";
+import { conversationClient, questionLine } from "./conversation-commands.js";
+import { EXIT, UsageError } from "./errors.js";
+function byteOffset(text) {
+    if (text === undefined)
+        return 0;
+    if (!/^\d+$/.test(text) || !Number.isSafeInteger(Number(text)))
+        throw new UsageError('--offset must be a nonnegative safe integer');
+    return Number(text);
+}
+const piece = (p) => ({ session_id: p.session_id, file: p.file, offset: p.offset, next_offset: p.next_offset, size: p.size, data: p.data });
+/**
+ * Reads pages from `offset` of a session (the latest when `sessionId` is undefined) until its stored end, or until
+ * `until` (a line boundary). Every page goes to `emit`; returns the last one.
+ */
+export async function readTranscript(api, id, o, emit) {
+    const limit = (at) => (o.until === undefined ? {} : { limitBytes: o.until - at });
+    let page = await api.transcript(id, { offset: o.offset, ...(o.sessionId === undefined ? {} : { sessionId: o.sessionId }), ...limit(o.offset), signal: o.signal });
+    emit(page);
+    for (;;) {
+        const end = o.until === undefined ? page.size : Math.min(o.until, page.size);
+        if (page.next_offset >= end)
+            return page;
+        const at = page.next_offset;
+        page = await api.transcript(id, { offset: at, sessionId: page.session_id ?? o.sessionId, ...limit(at), signal: o.signal });
+        // A page that does not move on would repeat forever.
+        if (page.next_offset <= at)
+            return page;
+        emit(page);
+    }
+}
+/**
+ * Prints a followed transcript once: each event's lines after what was printed, the stored lines a reconnect or a new
+ * harness session would otherwise skip read from the API first.
+ */
+export class TranscriptFollower {
+    session;
+    offset;
+    #api;
+    #id;
+    #signal;
+    #write;
+    constructor(api, id, at, signal, write) {
+        this.#api = api;
+        this.#id = id;
+        this.session = at.session;
+        this.offset = at.offset;
+        this.#signal = signal;
+        this.#write = write;
+    }
+    #print(p) {
+        if (p.session_id !== this.session || p.next_offset <= this.offset)
+            return;
+        const bytes = Buffer.from(p.data, 'utf8');
+        const skip = Math.max(0, this.offset - p.offset);
+        const data = skip === 0 ? p.data : bytes.subarray(skip).toString('utf8');
+        this.offset = p.next_offset;
+        if (data)
+            this.#write({ ...piece(p), offset: p.offset + skip, data });
+    }
+    async take(t) {
+        if (t.session_id === null)
+            return;
+        if (t.session_id !== this.session) {
+            // A new harness session (Claude Code /clear, a new Codex thread): the rest of the earlier one, then this one.
+            if (this.session !== null)
+                await readTranscript(this.#api, this.#id, { offset: this.offset, sessionId: this.session, signal: this.#signal }, (p) => this.#print(p));
+            this.session = t.session_id;
+            this.offset = 0;
+        }
+        if (t.offset > this.offset)
+            await readTranscript(this.#api, this.#id, { offset: this.offset, sessionId: t.session_id, until: t.offset, signal: this.#signal }, (p) => this.#print(p));
+        this.#print(t);
+    }
+}
+const lineCount = (text) => text.split('\n').length - 1;
+const oneLine = (text) => text.replace(/\s+/g, ' ').trim();
+/**
+ * The readable form of `shard conversations events`: a line per state change, transcript lines and tool call, the
+ * reply text as it streams. `end()` closes a reply still on its line.
+ */
+export class EventLines {
+    #state;
+    #midLine = false;
+    #tools = new Map();
+    render(ev) {
+        if (ev.type === 'conversation') {
+            const c = ev.conversation;
+            if (c.state === this.#state)
+                return '';
+            this.#state = c.state;
+            const q = questionLine(c);
+            return this.#line(`state: ${c.state}${q ? ` — ${q}` : ''}`);
+        }
+        if (ev.type === 'transcript') {
+            const n = lineCount(ev.transcript.data);
+            return n ? this.#line(`transcript: +${n} line${n === 1 ? '' : 's'}`) : '';
+        }
+        return ev.delta.updates.map((u) => this.#update(u)).join('');
+    }
+    end() {
+        const close = this.#midLine ? '\n' : '';
+        this.#midLine = false;
+        return close;
+    }
+    #update(u) {
+        if (u.sessionUpdate === 'agent_message_chunk') {
+            const c = u.content;
+            if (c?.type !== 'text' || typeof c.text !== 'string' || !c.text)
+                return '';
+            this.#midLine = !c.text.endsWith('\n');
+            return c.text;
+        }
+        if (u.sessionUpdate !== 'tool_call' && u.sessionUpdate !== 'tool_call_update')
+            return '';
+        const id = typeof u.toolCallId === 'string' ? u.toolCallId : '';
+        const title = (typeof u.title === 'string' && oneLine(u.title)) || this.#tools.get(id) || 'tool';
+        if (id) {
+            this.#tools.delete(id);
+            this.#tools.set(id, title);
+            if (this.#tools.size > 1000)
+                this.#tools.delete(this.#tools.keys().next().value);
+        }
+        const status = typeof u.status === 'string' && u.status ? u.status : undefined;
+        // An update that only adds output to a call says nothing new on its line.
+        if (u.sessionUpdate === 'tool_call_update' && !status)
+            return '';
+        return this.#line(`tool: ${title}${status ? ` (${status})` : ''}`);
+    }
+    #line(text) {
+        const lead = this.#midLine ? '\n' : '';
+        this.#midLine = false;
+        return `${lead}${text}\n`;
+    }
+}
+const interrupted = (signal, err) => {
+    if (signal.aborted)
+        return EXIT.interrupted;
+    throw err;
+};
+export const TRANSCRIPT_HANDLERS = {
+    async 'conversations transcript'(ctx, values, [id]) {
+        const offset = byteOffset(str(values.offset));
+        const sessionId = str(values.session);
+        if (sessionId !== undefined && !sessionId.trim())
+            throw new UsageError('--session needs a session id');
+        const follow = values.follow === true;
+        const api = conversationClient(ctx).conversations;
+        // Stdout carries the transcript itself; with --json, one object (with --follow, one object per line).
+        const ndjson = ctx.json && follow;
+        const write = (p) => {
+            if (ndjson)
+                ctx.io.stdout.write(`${JSON.stringify(piece(p))}\n`);
+            else if (!ctx.json && p.data)
+                ctx.io.stdout.write(p.data);
+        };
+        const parts = [];
+        let last;
+        try {
+            last = await readTranscript(api, id, { offset, sessionId, signal: ctx.signal }, (p) => {
+                if (ctx.json && !follow)
+                    parts.push(p.data);
+                else if (p.data)
+                    write(p);
+            });
+        }
+        catch (err) {
+            return interrupted(ctx.signal, err);
+        }
+        if (!follow) {
+            if (ctx.json)
+                out(ctx, '', { ...last, offset, data: parts.join('') });
+            return EXIT.ok;
+        }
+        const follower = new TranscriptFollower(api, id, { session: last.session_id ?? sessionId ?? null, offset: last.next_offset }, ctx.signal, write);
+        try {
+            const events = api.events(id, { transcriptOffset: follower.offset, ...(sessionId === undefined ? {} : { sessionId }), signal: ctx.signal });
+            for await (const ev of events)
+                if (ev.type === 'transcript')
+                    await follower.take(ev.transcript);
+        }
+        catch (err) {
+            return interrupted(ctx.signal, err);
+        }
+        return ctx.signal.aborted ? EXIT.interrupted : EXIT.ok;
+    },
+    async 'conversations events'(ctx, _values, [id]) {
+        const lines = new EventLines();
+        let code = EXIT.ok;
+        try {
+            for await (const ev of conversationClient(ctx).conversations.events(id, { signal: ctx.signal })) {
+                const text = ctx.json ? `${JSON.stringify(ev)}\n` : lines.render(ev);
+                if (text)
+                    ctx.io.stdout.write(text);
+            }
+        }
+        catch (err) {
+            code = interrupted(ctx.signal, err);
+        }
+        finally {
+            if (!ctx.json)
+                ctx.io.stdout.write(lines.end());
+        }
+        return ctx.signal.aborted ? EXIT.interrupted : code;
+    },
+};

package/dist/conversations.d.ts

@@ -39,6 +39,9 @@ export interface Conversation {
     base_branch?: string | null;
     role?: string;
     join_mode?: string | null;
+    /** A conversation on the machine's home, without a repository (0.25.0+, APIs that return it): its `repo_remote`,
+     * `branch` and `base_commit` are empty and its agent runs in `/home/user`. */
+    home?: boolean;
     /** The model and effort its harness starts with; null is the agent's own default (0.17.0+, APIs that keep them). */
     model?: string | null;
     effort?: string | null;
@@ -118,8 +121,8 @@ export declare function resolveConversation(ctx: Ctx, ref: string, folder?: stri
 /** Re-resolve the binding on every attach: a move changes the VM, never the conversation identity. */
 export declare function conversationWorkspace(ctx: Ctx, c: Conversation): Promise<Workspace>;
 /**
- * A thread on an existing computer (a join) is prepared by that computer's guest: its worktree, then its harness. Waits
- * until the guest confirms it (the conversation no longer carries restore instructions), within the wake timeout.
+ * A start its guest prepares (GUEST_PREPARED): its worktree, then its harness. Waits until the guest confirms it (the
+ * conversation no longer carries those restore instructions), within the wake timeout.
  */
 export declare function waitThreadReady(ctx: Ctx, c: Conversation, pollMs?: number): Promise<Conversation>;
 export declare function restoreConversationBinding(ctx: Ctx, c: Conversation, ws: Workspace): Promise<void>;

package/dist/conversations.js

@@ -24,7 +24,8 @@ import { recordSetupIntent } from "./project-template-setup.js";
 export const conversationEnded = (c) => !!c.ended_at || c.state === 'archived' || c.landed?.how === 'discarded' || (c.route === 'codex-cloud' && c.state === 'done');
 export const conversationName = (c) => {
     const name = c.key.split('/').at(-1);
-    if (!/^[a-z0-9][a-z0-9-]{0,47}$/.test(name) || c.branch !== `shard/${name}`)
+    // A home conversation has no repository, so no branch.
+    if (!/^[a-z0-9][a-z0-9-]{0,47}$/.test(name) || c.branch !== (c.home === true ? '' : `shard/${name}`))
         throw new Error('Conversation returned an invalid branch or name');
     return name;
 };
@@ -60,7 +61,8 @@ export async function conversationPtyId(cell, c, signal) {
     return typeof recorded === 'string' && MANAGED_PTY.test(recorded) && recorded.endsWith(`-${c.harness}`) ? recorded : derived;
 }
 export function validateConversation(c) {
-    if (!c || !/^conv_[a-z0-9]{26}$/.test(c.id) || !c.project_id || !c.workspace_id || !c.worktree_path?.startsWith('/home/user/') || /[\0\r\n]/.test(c.worktree_path) || !['claude', 'codex'].includes(c.harness))
+    const worktree = c?.home === true ? c.worktree_path === '/home/user' : c?.worktree_path?.startsWith('/home/user/');
+    if (!c || !/^conv_[a-z0-9]{26}$/.test(c.id) || !c.project_id || !c.workspace_id || !worktree || /[\0\r\n]/.test(c.worktree_path) || !['claude', 'codex'].includes(c.harness))
         throw new Error('Conversation response omitted its identity or binding');
     conversationName(c);
     return c;
@@ -156,14 +158,19 @@ export async function conversationWorkspace(ctx, c) {
     return ws;
 }
 /**
- * A thread on an existing computer (a join) is prepared by that computer's guest: its worktree, then its harness. Waits
- * until the guest confirms it (the conversation no longer carries restore instructions), within the wake timeout.
+ * Starts its computer's guest prepares by itself, never this command: a thread on an existing computer (a join), a
+ * conversation started from the project hub (0.25.0+) and one on the machine's home (0.25.0+).
+ */
+const GUEST_PREPARED = new Set(['join', 'hub', 'home']);
+/**
+ * A start its guest prepares (GUEST_PREPARED): its worktree, then its harness. Waits until the guest confirms it (the
+ * conversation no longer carries those restore instructions), within the wake timeout.
  */
 export async function waitThreadReady(ctx, c, pollMs = 1000) {
     const deadline = Date.now() + ctx.wakeTimeoutMs;
     for (;;) {
         const current = await getConversation(ctx, c.id);
-        if (!current.restore || current.restore.kind !== 'join')
+        if (!current.restore || !GUEST_PREPARED.has(current.restore.kind))
             return current;
         if (current.state === 'done' || current.state === 'archived' || current.ended_at)
             throw new UsageError('This thread ended before it started.');
@@ -181,7 +188,7 @@ export async function restoreConversationBinding(ctx, c, ws) {
     if (!c.restore || c.restore.kind === 'new')
         return;
     // Threads on an existing computer (0.16.0+): its guest prepares them, never this command.
-    if (c.restore.kind === 'join') {
+    if (GUEST_PREPARED.has(c.restore.kind)) {
         await waitThreadReady(ctx, c);
         return;
     }
@@ -192,10 +199,13 @@ export async function restoreConversationBinding(ctx, c, ws) {
             throw new Error(`Reviewer restore failed: ${review.stderr.trim()}`);
         return;
     }
-    await cell.files.mkdir(c.worktree_path, { parents: true });
-    const init = await cell.exec.run(['git', '-C', c.worktree_path, 'init'], { timeoutMs: 30_000, signal: ctx.signal });
-    if (init.exitCode !== 0)
-        throw new Error(`Conversation restore could not initialize its repository: ${init.stderr.trim()}`);
+    // A home conversation runs in /home/user without a repository: its guest restores only its transcript.
+    if (c.home !== true && c.restore.home !== true) {
+        await cell.files.mkdir(c.worktree_path, { parents: true });
+        const init = await cell.exec.run(['git', '-C', c.worktree_path, 'init'], { timeoutMs: 30_000, signal: ctx.signal });
+        if (init.exitCode !== 0)
+            throw new Error(`Conversation restore could not initialize its repository: ${init.stderr.trim()}`);
+    }
     const result = await cell.exec.run(['sf-agent', 'conversation', 'restore', '--args', '{"start":false}'], { cwd: c.worktree_path, env: { SF_CONVERSATION_ID: c.id }, timeoutMs: 120_000, signal: ctx.signal });
     if (result.exitCode !== 0)
         throw new Error(`Conversation restore failed: ${result.stderr.trim()}`);

package/dist/device-approvals.js

@@ -34,7 +34,8 @@ export function answerDeviceApproval(dir, id, choice) {
     const pending = pendingDeviceApprovals(dir).find(p => p.request_id === id);
     if (!pending)
         throw new UsageError('That request is no longer waiting for approval. Run shard device requests.');
-    if (choice === 'always' && pending.outside)
+    // A folder request's Always is that folder's grant (device-folders.ts); other access outside the conversation folder is once only.
+    if (choice === 'always' && pending.outside && pending.scope !== 'folder')
         throw new UsageError('Access outside the conversation folder must be approved once.');
     writePrivateFile(join(dir, 'device-answers'), paths(dir, id).answer, JSON.stringify({ nonce: pending.nonce, choice }));
 }
@@ -64,12 +65,12 @@ export async function askLocalDeviceApproval(ctx, approval) {
 export const DEVICE_HANDLERS = {
     'device requests'(ctx) {
         const requests = pendingDeviceApprovals(ctx.store.dir);
-        ctx.io.stdout.write(ctx.json ? json({ requests }) : requests.length ? requests.map(r => `${r.request_id}: ${r.summary}\n  Project: ${r.project_name ?? r.project_id}; conversation: ${r.conversation_title ?? r.conversation_id}\n  Local: ${r.local_path ?? '(none)'}; remote: ${r.remote_path ?? '(none)'}${r.argv ? `\n  Command: ${JSON.stringify(r.argv)}` : ''}${r.local_port ? `\n  Ports: ${r.local_port} → ${r.remote_port}` : ''}\n  shard device approve ${r.request_id} | shard device deny ${r.request_id}\n`).join('') : 'No device requests waiting for approval.\n');
+        ctx.io.stdout.write(ctx.json ? json({ requests }) : requests.length ? requests.map(r => `${r.request_id}: ${r.summary}\n  Project: ${r.project_name ?? r.project_id}; conversation: ${r.conversation_title ?? r.conversation_id}\n  Local: ${r.local_path ?? '(none)'}; remote: ${r.remote_path ?? '(none)'}${r.argv ? `\n  Command: ${JSON.stringify(r.argv)}` : ''}${r.local_port ? `\n  Ports: ${r.local_port} → ${r.remote_port}` : ''}${r.repo_remote ? `\n  Repository: ${r.repo_remote}` : ''}${r.brief ? `\n  First message: ${r.brief.split('\n')[0].slice(0, 200)}` : ''}\n  shard device approve ${r.request_id}${r.scope === 'folder' ? ` [--always: for ${r.folder}]` : ''} | shard device deny ${r.request_id}\n`).join('') : 'No device requests waiting for approval.\n');
         return Promise.resolve(0);
     },
     ...Object.fromEntries(['approve', 'deny'].map(action => [`device ${action}`, (ctx, values, [id]) => {
             answerDeviceApproval(ctx.store.dir, id, action === 'approve' ? values.always === true ? 'always' : 'once' : 'deny');
-            ctx.io.stdout.write(ctx.json ? json({ request_id: id, choice: action === 'approve' && values.always ? 'always' : action }) : `Device request ${id}: ${action === 'approve' ? values.always ? 'allowed for project' : 'approved once' : 'denied'}.\n`);
+            ctx.io.stdout.write(ctx.json ? json({ request_id: id, choice: action === 'approve' && values.always ? 'always' : action }) : `Device request ${id}: ${action === 'approve' ? values.always ? 'always allowed' : 'approved once' : 'denied'}.\n`);
             return Promise.resolve(0);
         }])),
 };

package/dist/device-bridge.d.ts

@@ -1,6 +1,7 @@
 import type { CellClient, Workspace } from '@shardflux/sdk';
 import type { Ctx } from './commands.js';
 import type { Conversation } from './conversations.js';
+import type { DirListing, LinkedProject } from './device-folders.js';
 export type DeviceChoice = 'once' | 'always' | 'deny';
 export interface DeviceRequest {
     id: string;
@@ -8,7 +9,7 @@ export interface DeviceRequest {
     conversation_id: string;
     state: string;
     device_id: string | null;
-    kind: 'exec' | 'files_pull' | 'files_push' | 'port_forward' | 'port_reverse' | 'try_locally';
+    kind: 'exec' | 'files_pull' | 'files_push' | 'port_forward' | 'port_reverse' | 'try_locally' | 'dir_list' | 'project_link';
     exec?: {
         argv: string[];
         cwd_relative?: string;
@@ -23,6 +24,17 @@ export interface DeviceRequest {
         remote_port: number;
         local_port: number;
     };
+    dir?: {
+        path: string;
+        depth?: number;
+        max_entries?: number;
+        include_hidden?: boolean;
+    };
+    link?: {
+        path: string;
+        brief?: string;
+        harness?: 'claude' | 'codex';
+    };
 }
 export interface DeviceApproval {
     type: 'approval';
@@ -39,6 +51,17 @@ export interface DeviceApproval {
     conversation_title?: string;
     local_port?: number;
     remote_port?: number;
+    /**
+     * 'folder' (0.25.0+): Always is offered and covers `folder` and everything inside it for this kind (device-folders.ts).
+     * `outside` stays true, so a surface that predates folder grants offers Allow once only.
+     */
+    scope?: 'folder';
+    folder?: string;
+    /** project_link: the repository the folder's Git origin names (null without one) and the first prompt, when one starts. */
+    repo_remote?: string | null;
+    brief?: string;
+    /** dir_list: how many levels below the folder are listed. */
+    depth?: number;
 }
 type Result = {
     state: 'approved' | 'denied' | 'running' | 'done' | 'failed';
@@ -46,6 +69,8 @@ type Result = {
     stdout_b64?: string;
     stderr_b64?: string;
     files_artifact?: string;
+    dir?: DirListing;
+    project?: LinkedProject;
 };
 /** Resolve existing ancestors even before the conversation worktree is created. */
 export declare function devicePath(root: string, requested?: string): {
@@ -61,6 +86,10 @@ export declare class DeviceGrants {
         kinds: string[];
     }>;
     allows(api: string, project: string, root: string, kind: string, outside: boolean): boolean;
+    /** A folder grant (0.25.0+): Always for `root` and everything inside it, for one kind of request. */
+    folderKey(api: string, root: string): string;
+    allowsFolder(api: string, target: string, kind: string): boolean;
+    saveFolder(api: string, root: string, kind: string): Promise<void>;
     save(api: string, project: string, root: string, kind: string): Promise<void>;
 }
 export declare function deviceSummary(r: DeviceRequest, platform?: NodeJS.Platform): string;
@@ -69,6 +98,10 @@ export declare function deviceApproval(r: DeviceRequest, c: Conversation, target
     path: string;
     outside: boolean;
 }, folder: string): DeviceApproval;
+/** A request on a folder anywhere on this device: the folder kinds, and file moves named by an absolute or ~/ path. */
+export declare function folderRequest(r: DeviceRequest): boolean;
+/** What a folder request's approval shows: the canonical path, the folder Always would cover, and what will happen. */
+export declare function folderApproval(r: DeviceRequest, c: Conversation, target: string, folder: string, home: string, remote?: string | null, platform?: NodeJS.Platform): DeviceApproval;
 export declare function tryLocallyAction(r: DeviceRequest): 'start' | 'stop' | null;
 export declare function ensureConversationWorktree(ctx: Ctx, c: Conversation, folder: string, ws?: Workspace): Promise<string>;
 export declare function deviceExec(argv: string[], cwd: string, timeoutSeconds?: number, signal?: AbortSignal): Promise<Result>;
@@ -90,4 +123,12 @@ export declare function serveAcpDeviceApprovals(dir: string, id: string, ask: (a
     stop(): Promise<void>;
 }>;
 export declare function askConnectedAcp(dir: string, approval: DeviceApproval, signal: AbortSignal): Promise<DeviceChoice | null>;
+/**
+ * The desktop app's approval hop (0.25.0+): while it runs it serves `<config dir>/device-approver.sock` (or, when that
+ * path is too long for a socket, `/tmp/sf-device-<uid>/<hash>-approver.sock`) and shows each approval as a Needs-you
+ * item. One line in (the DeviceApproval JSON), one line out (`{"choice":"once|always|deny"}`). No app, a socket that is
+ * not this user's own, or one that closes without an answer: null, and the next surface asks.
+ */
+export declare function approverSocket(dir: string): string;
+export declare function askDeviceApprover(dir: string, approval: DeviceApproval, signal: AbortSignal): Promise<DeviceChoice | null>;
 export {};