@av-pi-studio/server 0.0.92 → 0.0.93

package/dist/agent/pi-home.d.ts

@@ -30,4 +30,20 @@ export declare function resolvePiAgentDir(config: PersistedConfig): string | und
  * single Pi-Studio setting redirects the bundled Pi CLI's entire `~/.pi/agent` tree (models.json,
  * auth.json, settings.json, sessions/, …) to a custom directory. */
 export declare function piHomeEnv(config: PersistedConfig): Record<string, string>;
+/** Resolved `auth.json`/`models.json` paths; `undefined` fields let Pi's own defaults decide.
+ *  Mirrors {@link PiAuthPaths} in `packages/cli/src/auth-runtime.ts` — this is the daemon-side
+ *  sibling, deliberately not a shared import (that module belongs to a different package). */
+export interface PiAuthPaths {
+    authPath?: string;
+    modelsPath?: string;
+}
+/**
+ * Derive `auth.json`/`models.json` from {@link resolvePiAgentDir} — the single intentional
+ * coupling point between the provider-auth RPC family and the spawn path
+ * (features/provider-auth-rpc.md § New/changed files). A credential written at this path MUST be
+ * the one a daemon-spawned `pi --mode rpc` child reads via `piHomeEnv()`'s
+ * `PI_CODING_AGENT_DIR`/`PI_CODING_AGENT_SESSION_DIR`, which is why this derives from the same
+ * `resolvePiAgentDir` rather than re-deriving the precedence independently.
+ */
+export declare function resolvePiAuthPaths(config: PersistedConfig): PiAuthPaths;
 //# sourceMappingURL=pi-home.d.ts.map

package/dist/agent/pi-home.js

@@ -46,4 +46,21 @@ export function piHomeEnv(config) {
         PI_CODING_AGENT_SESSION_DIR: join(agentDir, "sessions"),
     };
 }
+/**
+ * Derive `auth.json`/`models.json` from {@link resolvePiAgentDir} — the single intentional
+ * coupling point between the provider-auth RPC family and the spawn path
+ * (features/provider-auth-rpc.md § New/changed files). A credential written at this path MUST be
+ * the one a daemon-spawned `pi --mode rpc` child reads via `piHomeEnv()`'s
+ * `PI_CODING_AGENT_DIR`/`PI_CODING_AGENT_SESSION_DIR`, which is why this derives from the same
+ * `resolvePiAgentDir` rather than re-deriving the precedence independently.
+ */
+export function resolvePiAuthPaths(config) {
+    const agentDir = resolvePiAgentDir(config);
+    if (!agentDir)
+        return {};
+    return {
+        authPath: join(agentDir, "auth.json"),
+        modelsPath: join(agentDir, "models.json"),
+    };
+}
 //# sourceMappingURL=pi-home.js.map

package/dist/agent/provider-auth/pi-auth-runtime.d.ts

@@ -0,0 +1,123 @@
+import type { PiAuthPaths } from "../pi-home.js";
+/**
+ * Daemon-side seam onto Pi's `ModelRuntime` auth engine (swe/features/provider-auth-rpc.md § New/
+ * changed files, § Behavior & Algorithms — runtime bullet). This is the daemon's sibling of
+ * `packages/cli/src/auth-runtime.ts`'s `AuthRuntime` — deliberately not shared (different package,
+ * different owner this sprint) but structurally the same idea: hide `ModelRuntime` behind a small
+ * interface so the flow service (task-003) and its tests never import a Pi type directly.
+ *
+ * **Lazy `import()` here is not a startup optimization.** The daemon already statically imports
+ * `@earendil-works/pi-coding-agent` (`agent/providers/pi/session-hydration.ts` imports
+ * `SessionManager`), so the module graph is already paid for. It is lazy so a daemon whose Pi auth
+ * runtime cannot be constructed (e.g. a corrupt `auth.json`) still boots and serves every other
+ * RPC, failing only this family — and so construction is *retried* on the next call rather than
+ * poisoning the service for the daemon's lifetime.
+ */
+export interface AuthPromptTextLike {
+    signal?: AbortSignal;
+    type: "text";
+    message: string;
+    placeholder?: string;
+}
+export interface AuthPromptSecretLike {
+    signal?: AbortSignal;
+    type: "secret";
+    message: string;
+    placeholder?: string;
+}
+export interface AuthPromptSelectLike {
+    signal?: AbortSignal;
+    type: "select";
+    message: string;
+    options: readonly {
+        id: string;
+        label: string;
+        description?: string;
+    }[];
+}
+export interface AuthPromptManualCodeLike {
+    signal?: AbortSignal;
+    type: "manual_code";
+    message: string;
+    placeholder?: string;
+}
+export type AuthPromptLike = AuthPromptTextLike | AuthPromptSecretLike | AuthPromptSelectLike | AuthPromptManualCodeLike;
+export interface AuthEventInfoLike {
+    type: "info";
+    message: string;
+    links?: readonly {
+        url: string;
+        label?: string;
+    }[];
+}
+export interface AuthEventAuthUrlLike {
+    type: "auth_url";
+    url: string;
+    instructions?: string;
+}
+export interface AuthEventDeviceCodeLike {
+    type: "device_code";
+    userCode: string;
+    verificationUri: string;
+    intervalSeconds?: number;
+    expiresInSeconds?: number;
+}
+export interface AuthEventProgressLike {
+    type: "progress";
+    message: string;
+}
+export type AuthEventLike = AuthEventInfoLike | AuthEventAuthUrlLike | AuthEventDeviceCodeLike | AuthEventProgressLike;
+export interface AuthInteractionLike {
+    signal?: AbortSignal;
+    prompt(prompt: AuthPromptLike): Promise<string>;
+    notify(event: AuthEventLike): void;
+}
+/** A login-capable provider, before any auth-state check (that is {@link PiAuthCheckResult}, a
+ *  separate bounded call — `listProviders()` never blocks on it). */
+export interface PiAuthProviderInfo {
+    id: string;
+    name: string;
+    authTypes: ("api_key" | "oauth")[];
+    oauthLoginLabel?: string;
+    oauthIsSubscription?: boolean;
+}
+/** `configured: "unknown"` means the bounded probe exceeded its timeout (sprint-054's
+ *  `checkAuthBounded` precedent — some ambient checks, e.g. an AWS-profile or ADC-file probe, can
+ *  hang). Never conflate `"unknown"` with `false`: the caller must not report a credential absent
+ *  when it simply could not be confirmed in time. */
+export interface PiAuthCheckResult {
+    configured: boolean | "unknown";
+    type?: "api_key" | "oauth";
+    source?: string;
+}
+export interface PiAuthRuntime {
+    listProviders(): Promise<PiAuthProviderInfo[]>;
+    checkAuth(providerId: string): Promise<PiAuthCheckResult>;
+    /** `signal` is the caller's flow-wide `AbortController.signal` (task-003) — merged onto the
+     *  interaction so Pi's own `interaction.signal` race (login rejects with Pi's generic
+     *  `AbortError` on abort) works whether or not the caller-supplied `interaction` already carries
+     *  one. */
+    login(providerId: string, authType: "api_key" | "oauth", interaction: AuthInteractionLike, signal?: AbortSignal): Promise<{
+        type: "api_key" | "oauth";
+    }>;
+    /** Re-checks after removal so the caller can report an ambient credential (e.g. an env var)
+     *  surviving the logout, rather than silently claiming success. */
+    logout(providerId: string): Promise<{
+        stillConfigured: boolean;
+    }>;
+    /** Resolved `auth.json` path, for status/log messages — never the credential itself. */
+    authPathLabel(): string;
+}
+/** Bound for {@link PiAuthRuntime.checkAuth}; overridable per-instance for tests (fake timers). */
+export declare const DEFAULT_CHECK_AUTH_TIMEOUT_MS = 3000;
+export interface CreatePiAuthRuntimeOptions {
+    checkAuthTimeoutMs?: number;
+}
+/**
+ * Production `PiAuthRuntime`. Creates Pi's `ModelRuntime` once, lazily, on the first method call —
+ * never at module load or construction time — and caches the promise so repeated calls reuse the
+ * same instance. On a failed construction the cached promise is cleared so the *next* call retries
+ * rather than the daemon staying poisoned until restart.
+ */
+export declare function createPiAuthRuntime(paths: PiAuthPaths, opts?: CreatePiAuthRuntimeOptions): PiAuthRuntime;
+//# sourceMappingURL=pi-auth-runtime.d.ts.map

package/dist/agent/provider-auth/pi-auth-runtime.js

@@ -0,0 +1,103 @@
+/** Bound for {@link PiAuthRuntime.checkAuth}; overridable per-instance for tests (fake timers). */
+export const DEFAULT_CHECK_AUTH_TIMEOUT_MS = 3000;
+/**
+ * Production `PiAuthRuntime`. Creates Pi's `ModelRuntime` once, lazily, on the first method call —
+ * never at module load or construction time — and caches the promise so repeated calls reuse the
+ * same instance. On a failed construction the cached promise is cleared so the *next* call retries
+ * rather than the daemon staying poisoned until restart.
+ */
+export function createPiAuthRuntime(paths, opts) {
+    const checkAuthTimeoutMs = opts?.checkAuthTimeoutMs ?? DEFAULT_CHECK_AUTH_TIMEOUT_MS;
+    let runtimePromise = null;
+    // Deliberate `await import()`, not a static import — see the module-level doc comment.
+    function getRuntime() {
+        if (!runtimePromise) {
+            const promise = (async () => {
+                // Deliberate `await import()`, not a static import: deferring past module load lets a
+                // daemon whose Pi auth runtime cannot construct still boot and serve every other RPC (see
+                // the module-level doc comment) — the module specifier is fixed, but the *timing* is the
+                // point, not a runtime-selected path.
+                const { ModelRuntime: ModelRuntimeCtor } = await import("@earendil-works/pi-coding-agent");
+                return ModelRuntimeCtor.create({
+                    authPath: paths.authPath,
+                    modelsPath: paths.modelsPath,
+                    refreshOnCreate: false,
+                });
+            })();
+            runtimePromise = promise;
+            // A transient failure (e.g. a momentarily-locked auth.json) must not poison every later
+            // call — clear the cache so the next getRuntime() retries construction from scratch.
+            promise.catch(() => {
+                if (runtimePromise === promise)
+                    runtimePromise = null;
+            });
+        }
+        return runtimePromise;
+    }
+    async function checkAuth(providerId) {
+        const runtime = await getRuntime();
+        const { promise: timeout, resolve: resolveTimeout } = Promise.withResolvers();
+        const timer = setTimeout(() => resolveTimeout("unknown"), checkAuthTimeoutMs);
+        try {
+            const result = await Promise.race([runtime.checkAuth(providerId), timeout]);
+            if (result === "unknown")
+                return { configured: "unknown" };
+            if (!result)
+                return { configured: false };
+            return { configured: true, type: result.type, source: result.source };
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    return {
+        async listProviders() {
+            const runtime = await getRuntime();
+            const out = [];
+            for (const p of runtime.getProviders()) {
+                try {
+                    const canApiKeyLogin = p.auth?.apiKey?.login !== undefined;
+                    const canOAuthLogin = p.auth?.oauth !== undefined;
+                    if (!canApiKeyLogin && !canOAuthLogin)
+                        continue;
+                    const authTypes = [];
+                    if (canApiKeyLogin)
+                        authTypes.push("api_key");
+                    if (canOAuthLogin)
+                        authTypes.push("oauth");
+                    out.push({
+                        id: p.id,
+                        name: p.name,
+                        authTypes,
+                        oauthLoginLabel: p.auth?.oauth?.loginLabel,
+                        oauthIsSubscription: p.auth?.oauth?.isSubscription,
+                    });
+                }
+                catch {
+                    // Malformed provider entry (unexpected shape) — skip it, never let one bad provider
+                    // take down the whole listing.
+                }
+            }
+            return out;
+        },
+        checkAuth,
+        async login(providerId, authType, interaction, signal) {
+            const runtime = await getRuntime();
+            const credential = await runtime.login(providerId, authType, {
+                ...interaction,
+                signal: signal ?? interaction.signal,
+            });
+            return { type: credential.type };
+        },
+        async logout(providerId) {
+            const runtime = await getRuntime();
+            await runtime.logout(providerId);
+            const recheck = await checkAuth(providerId);
+            return { stillConfigured: recheck.configured === true };
+        },
+        authPathLabel() {
+            return paths.authPath ?? "<default Pi auth path>";
+        },
+    };
+}
+//# sourceMappingURL=pi-auth-runtime.js.map

package/dist/agent/provider-auth/provider-auth-rpc.d.ts

@@ -0,0 +1,29 @@
+import type { Logger } from "../../logging/logger.js";
+import type { HandlerRegistry } from "../../ws/router.js";
+import type { ProviderAuthService } from "./provider-auth-service.js";
+/**
+ * Wires the five `provider_auth_*` RPCs (swe/features/provider-auth-rpc.md § Public Contract) onto
+ * `ProviderAuthService`. Modelled directly on `registerFileWatchHandlers`/
+ * `registerGitCheckoutHandlers`: a thin adapter that stamps no policy of its own — ownership,
+ * idempotency, and every error code already live in the service (task-003). This module's only
+ * job is coercing wire input defensively, since the router never validates a session message's
+ * shape before dispatch (see `ws/router.ts`'s `routeTextFrame`).
+ *
+ * Unlike its two siblings, this module does **not** touch `SessionSubscriptions` itself —
+ * `ProviderAuthService` owns that entry directly (constructed with a `subscriptions` dep in
+ * `bootstrap.ts`). See `provider-auth-service.ts`'s class doc comment for why: the RPC layer
+ * deciding whether to `subscriptions.add()` based on the *result* of an awaited `login()` call has
+ * a real race against the fire-and-forget flow settling before that await returns, which can leave
+ * a stale disposer that's added after the flow it names already ended. Registering and clearing the
+ * subscription inside `login()`/`settleFlow()`'s own synchronous stretches removes that race by
+ * construction.
+ *
+ * Production-bootstrap only (`daemon/bootstrap.ts`) — `dev-bootstrap.ts` must never call this; the
+ * dev daemon's minimal handler set answers `unknown_message_type` for all five types instead.
+ */
+export interface ProviderAuthRpcDeps {
+    providerAuthService: ProviderAuthService;
+    logger?: Logger;
+}
+export declare function registerProviderAuthHandlers(registry: HandlerRegistry, deps: ProviderAuthRpcDeps): void;
+//# sourceMappingURL=provider-auth-rpc.d.ts.map

package/dist/agent/provider-auth/provider-auth-rpc.js

@@ -0,0 +1,43 @@
+function isProviderAuthType(value) {
+    return value === "api_key" || value === "oauth";
+}
+export function registerProviderAuthHandlers(registry, deps) {
+    const { providerAuthService, logger } = deps;
+    registry.register("provider_auth_list_request", async () => {
+        const payload = await providerAuthService.listProviders();
+        return { type: "provider_auth_list_response", payload };
+    });
+    registry.register("provider_auth_login_request", async (ctx) => {
+        const provider = String(ctx.message.provider ?? "");
+        const authType = ctx.message.authType;
+        if (!isProviderAuthType(authType)) {
+            logger?.debug({ provider, authType }, "provider-auth: login request with unsupported authType");
+            return {
+                type: "provider_auth_login_response",
+                payload: { ok: false, error: "unsupported_auth_type" },
+            };
+        }
+        // Provider existence is the service's own call (`unknown_provider`) — this handler adds no
+        // second opinion on top of it.
+        const payload = await providerAuthService.login(ctx.session, provider, authType);
+        return { type: "provider_auth_login_response", payload };
+    });
+    registry.register("provider_auth_respond_request", (ctx) => {
+        const flowId = String(ctx.message.flowId ?? "");
+        const promptId = String(ctx.message.promptId ?? "");
+        const value = typeof ctx.message.value === "string" ? ctx.message.value : "";
+        const payload = providerAuthService.respond(ctx.session, flowId, promptId, value);
+        return { type: "provider_auth_respond_response", payload };
+    });
+    registry.register("provider_auth_cancel_request", (ctx) => {
+        const flowId = String(ctx.message.flowId ?? "");
+        const payload = providerAuthService.cancel(ctx.session, flowId);
+        return { type: "provider_auth_cancel_response", payload };
+    });
+    registry.register("provider_auth_logout_request", async (ctx) => {
+        const provider = String(ctx.message.provider ?? "");
+        const payload = await providerAuthService.logout(provider);
+        return { type: "provider_auth_logout_response", payload };
+    });
+}
+//# sourceMappingURL=provider-auth-rpc.js.map

package/dist/agent/provider-auth/provider-auth-service.d.ts

@@ -0,0 +1,80 @@
+import type { ProviderAuthInfo, ProviderAuthType } from "@av-pi-studio/protocol";
+import type { Logger } from "../../logging/logger.js";
+import type { SessionSubscriptions } from "../../ws/session-subscriptions.js";
+import type { Session } from "../../ws/session.js";
+import type { PiAuthRuntime } from "./pi-auth-runtime.js";
+/** Namespaced like `file_watch:`/`checkout_status:` — `SessionSubscriptions` is domain-agnostic
+ *  and shared across families. */
+export declare const PROVIDER_AUTH_FLOW_KEY_PREFIX = "provider_auth_flow:";
+export interface ProviderAuthServiceDeps {
+    runtime: PiAuthRuntime;
+    logger?: Logger;
+    /** Flow time-to-live before an auto-cancel with `error: "timeout"`. Defaults to 10 minutes. */
+    ttlMs?: number;
+    /** Timer seams so tests use fake timers instead of wall-clock waits. */
+    setTimer?: (fn: () => void, ms: number) => ReturnType<typeof setTimeout>;
+    clearTimer?: (handle: ReturnType<typeof setTimeout>) => void;
+    /** Per-session subscription registry. When provided, `login` registers a
+     *  `provider_auth_flow:<flowId>` disposer (`() => this.cancel(session, flowId)`) synchronously
+     *  in the same tick the flow is created, and `settleFlow` removes it — see the class doc comment
+     *  for why both live here instead of split across this service and the RPC layer. Omit only in
+     *  tests that don't care about disconnect-cancellation or subscription bookkeeping. */
+    subscriptions?: SessionSubscriptions;
+}
+export declare class ProviderAuthService {
+    private readonly runtime;
+    private readonly logger;
+    private readonly ttlMs;
+    private readonly setTimer;
+    private readonly clearTimer;
+    private readonly subscriptions;
+    private readonly flows;
+    private readonly flowIdBySession;
+    constructor(deps: ProviderAuthServiceDeps);
+    /** `getProviders()` composed with a bounded per-provider `checkAuth()` (already bounded inside
+     *  `PiAuthRuntime` — one bound suffices). A hung/failed single provider degrades that row to
+     *  `configured: "unknown"`, never the whole list. */
+    listProviders(): Promise<{
+        ok: boolean;
+        providers: ProviderAuthInfo[];
+        error?: string;
+    }>;
+    login(session: Session, provider: string, authType: ProviderAuthType): Promise<{
+        ok: boolean;
+        flowId?: string;
+        error?: string;
+    }>;
+    respond(session: Session, flowId: string, promptId: string, value: string): {
+        ok: boolean;
+        error?: string;
+    };
+    /** Unconditionally idempotent — see the class doc comment on why this never reports `not_found`
+     *  the way `respond` does. */
+    cancel(session: Session, flowId: string): {
+        ok: true;
+    };
+    logout(provider: string): Promise<{
+        ok: boolean;
+        stillConfigured?: boolean;
+        error?: string;
+    }>;
+    private runFlow;
+    private buildInteraction;
+    private handlePrompt;
+    /** Abort the flow's controller and settle it with a terminal `done ok:false`. Used by explicit
+     *  `cancel`, TTL expiry, and — via the `SessionSubscriptions` disposer `login` registers, which
+     *  fires on socket disconnect — session close. A no-op if the flow already reached a terminal
+     *  state. */
+    private abortFlow;
+    /** The single place a flow ends: compare-and-set on `terminal` (so exactly one `done` is ever
+     *  emitted even when a cancel races the runtime settling), clears the TTL timer, rejects any
+     *  pending prompt, unregisters the flow, emits the terminal event, and drops the
+     *  `SessionSubscriptions` entry `login` registered. Removing it here — not just from an explicit
+     *  `cancel` — is what guarantees a flow that completes or times out on its own leaves no stale
+     *  disposer behind. `SessionSubscriptions.remove` re-invokes the disposer it finds (which calls
+     *  `cancel()` again); that's a harmless no-op re-entry by this point, since `this.flows` no
+     *  longer has an entry for `flow.flowId` (deleted a few lines above). */
+    private settleFlow;
+    private sendFlowEvent;
+}
+//# sourceMappingURL=provider-auth-service.d.ts.map

package/dist/agent/provider-auth/provider-auth-service.js

@@ -0,0 +1,259 @@
+import { randomUUID } from "node:crypto";
+/** Namespaced like `file_watch:`/`checkout_status:` — `SessionSubscriptions` is domain-agnostic
+ *  and shared across families. */
+export const PROVIDER_AUTH_FLOW_KEY_PREFIX = "provider_auth_flow:";
+const DEFAULT_FLOW_TTL_MS = 600_000;
+export class ProviderAuthService {
+    runtime;
+    logger;
+    ttlMs;
+    setTimer;
+    clearTimer;
+    subscriptions;
+    flows = new Map();
+    flowIdBySession = new WeakMap();
+    constructor(deps) {
+        this.runtime = deps.runtime;
+        this.logger = deps.logger;
+        this.ttlMs = deps.ttlMs ?? DEFAULT_FLOW_TTL_MS;
+        this.setTimer = deps.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+        this.clearTimer = deps.clearTimer ?? ((handle) => clearTimeout(handle));
+        this.subscriptions = deps.subscriptions;
+    }
+    /** `getProviders()` composed with a bounded per-provider `checkAuth()` (already bounded inside
+     *  `PiAuthRuntime` — one bound suffices). A hung/failed single provider degrades that row to
+     *  `configured: "unknown"`, never the whole list. */
+    async listProviders() {
+        let infos;
+        try {
+            infos = await this.runtime.listProviders();
+        }
+        catch {
+            return { ok: false, providers: [] };
+        }
+        const providers = await Promise.all(infos.map(async (info) => {
+            const check = await this.runtime
+                .checkAuth(info.id)
+                .catch(() => ({ configured: "unknown" }));
+            return {
+                id: info.id,
+                name: info.name,
+                authTypes: info.authTypes,
+                oauthLoginLabel: info.oauthLoginLabel,
+                oauthIsSubscription: info.oauthIsSubscription,
+                configured: check.configured,
+                configuredType: "type" in check ? check.type : undefined,
+                configuredSource: "source" in check ? check.source : undefined,
+            };
+        }));
+        return { ok: true, providers };
+    }
+    async login(session, provider, authType) {
+        let infos;
+        try {
+            infos = await this.runtime.listProviders();
+        }
+        catch {
+            return { ok: false, error: "provider_auth_unavailable" };
+        }
+        const info = infos.find((p) => p.id === provider);
+        if (!info)
+            return { ok: false, error: "unknown_provider" };
+        if (!info.authTypes.includes(authType))
+            return { ok: false, error: "unsupported_auth_type" };
+        // One active flow per session — a second login cancels the first (its own terminal `done`
+        // fires from `abortFlow` below).
+        const existingFlowId = this.flowIdBySession.get(session);
+        if (existingFlowId) {
+            const existing = this.flows.get(existingFlowId);
+            if (existing)
+                this.abortFlow(existing, "cancelled");
+        }
+        const flowId = randomUUID();
+        const abort = new AbortController();
+        const flow = {
+            flowId,
+            provider,
+            session,
+            abort,
+            timer: this.setTimer(() => this.abortFlow(flow, "timeout"), this.ttlMs),
+            terminal: false,
+        };
+        this.flows.set(flowId, flow);
+        this.flowIdBySession.set(session, flowId);
+        // Synchronous, same tick as flow creation — no window where `runFlow` (started right below)
+        // could settle before this entry exists. See the class doc comment for why this can't safely
+        // live one `await` away in the RPC layer instead.
+        this.subscriptions?.add(session, `${PROVIDER_AUTH_FLOW_KEY_PREFIX}${flowId}`, () => this.cancel(session, flowId));
+        this.logger?.debug({ flowId, provider, authType }, "provider-auth: flow started");
+        void this.runFlow(flow, authType);
+        return { ok: true, flowId };
+    }
+    respond(session, flowId, promptId, value) {
+        const flow = this.flows.get(flowId);
+        if (!flow ||
+            flow.session !== session ||
+            !flow.pendingPrompt ||
+            flow.pendingPrompt.promptId !== promptId) {
+            return { ok: false, error: "not_found" };
+        }
+        const pending = flow.pendingPrompt;
+        flow.pendingPrompt = undefined;
+        this.logger?.debug({ flowId, provider: flow.provider, promptId }, "provider-auth: prompt answered");
+        pending.resolve(value);
+        return { ok: true };
+    }
+    /** Unconditionally idempotent — see the class doc comment on why this never reports `not_found`
+     *  the way `respond` does. */
+    cancel(session, flowId) {
+        const flow = this.flows.get(flowId);
+        if (flow && flow.session === session)
+            this.abortFlow(flow, "cancelled");
+        return { ok: true };
+    }
+    async logout(provider) {
+        try {
+            const result = await this.runtime.logout(provider);
+            return { ok: true, stillConfigured: result.stillConfigured };
+        }
+        catch (err) {
+            return { ok: false, error: sanitizeError(err) };
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Internals
+    // ---------------------------------------------------------------------------
+    async runFlow(flow, authType) {
+        try {
+            await this.runtime.login(flow.provider, authType, this.buildInteraction(flow), flow.abort.signal);
+            this.settleFlow(flow, { ok: true });
+        }
+        catch (err) {
+            // Pi's own `runtime.login()` races `interaction.signal` and rejects with its own generic
+            // `AbortError` (sprint-054/task-004) — never infer cancellation from the error type. Our own
+            // `abort.signal.aborted` is authoritative; in practice `abortFlow` has usually already
+            // settled this flow by the time we get here (the compare-and-set in `settleFlow` makes this
+            // call a no-op), but the check stays correct even if `runtime.login()` settles first.
+            const error = flow.abort.signal.aborted ? "cancelled" : sanitizeError(err);
+            this.settleFlow(flow, { ok: false, error });
+        }
+    }
+    buildInteraction(flow) {
+        return {
+            signal: flow.abort.signal,
+            notify: (event) => {
+                // Must be synchronous and must never throw into Pi.
+                try {
+                    this.sendFlowEvent(flow, toFlowEventPayload(event));
+                }
+                catch (err) {
+                    this.logger?.warn({ flowId: flow.flowId, provider: flow.provider, err: errorMessage(err) }, "provider-auth: notify handler failed");
+                }
+            },
+            prompt: (p) => this.handlePrompt(flow, p),
+        };
+    }
+    handlePrompt(flow, p) {
+        if (flow.pendingPrompt) {
+            // Pi is sequential — a second concurrent prompt is a protocol violation, not something to
+            // silently drop. Fail the whole flow rather than guess which prompt the client meant.
+            const reason = "provider_auth: concurrent prompt (protocol violation)";
+            this.abortFlow(flow, "cancelled");
+            return Promise.reject(new Error(reason));
+        }
+        const promptId = randomUUID();
+        const { promise, resolve, reject } = Promise.withResolvers();
+        const onPromptAbort = () => {
+            if (flow.pendingPrompt?.promptId !== promptId)
+                return;
+            flow.pendingPrompt = undefined;
+            this.sendFlowEvent(flow, { kind: "prompt_cancelled", promptId });
+            reject(new Error("prompt_cancelled"));
+        };
+        p.signal?.addEventListener("abort", onPromptAbort, { once: true });
+        flow.pendingPrompt = {
+            promptId,
+            resolve: (value) => {
+                p.signal?.removeEventListener("abort", onPromptAbort);
+                resolve(value);
+            },
+            reject: (reason) => {
+                p.signal?.removeEventListener("abort", onPromptAbort);
+                reject(reason);
+            },
+        };
+        this.logger?.debug({ flowId: flow.flowId, provider: flow.provider, promptId, promptKind: p.type }, "provider-auth: prompt");
+        this.sendFlowEvent(flow, {
+            kind: "prompt",
+            promptId,
+            promptKind: p.type,
+            message: p.message,
+            placeholder: "placeholder" in p ? p.placeholder : undefined,
+            options: "options" in p ? p.options : undefined,
+        });
+        return promise;
+    }
+    /** Abort the flow's controller and settle it with a terminal `done ok:false`. Used by explicit
+     *  `cancel`, TTL expiry, and — via the `SessionSubscriptions` disposer `login` registers, which
+     *  fires on socket disconnect — session close. A no-op if the flow already reached a terminal
+     *  state. */
+    abortFlow(flow, reason) {
+        if (flow.terminal)
+            return;
+        flow.abort.abort();
+        this.settleFlow(flow, { ok: false, error: reason });
+    }
+    /** The single place a flow ends: compare-and-set on `terminal` (so exactly one `done` is ever
+     *  emitted even when a cancel races the runtime settling), clears the TTL timer, rejects any
+     *  pending prompt, unregisters the flow, emits the terminal event, and drops the
+     *  `SessionSubscriptions` entry `login` registered. Removing it here — not just from an explicit
+     *  `cancel` — is what guarantees a flow that completes or times out on its own leaves no stale
+     *  disposer behind. `SessionSubscriptions.remove` re-invokes the disposer it finds (which calls
+     *  `cancel()` again); that's a harmless no-op re-entry by this point, since `this.flows` no
+     *  longer has an entry for `flow.flowId` (deleted a few lines above). */
+    settleFlow(flow, result) {
+        if (flow.terminal)
+            return;
+        flow.terminal = true;
+        this.clearTimer(flow.timer);
+        if (flow.pendingPrompt) {
+            const pending = flow.pendingPrompt;
+            flow.pendingPrompt = undefined;
+            pending.reject(new Error(result.error ?? "flow_ended"));
+        }
+        this.flows.delete(flow.flowId);
+        if (this.flowIdBySession.get(flow.session) === flow.flowId) {
+            this.flowIdBySession.delete(flow.session);
+        }
+        this.logger?.debug({ flowId: flow.flowId, provider: flow.provider, ok: result.ok, error: result.error }, "provider-auth: flow ended");
+        this.sendFlowEvent(flow, { kind: "done", ok: result.ok, error: result.error });
+        this.subscriptions?.remove(flow.session, `${PROVIDER_AUTH_FLOW_KEY_PREFIX}${flow.flowId}`);
+    }
+    sendFlowEvent(flow, event) {
+        try {
+            flow.session.send({
+                type: "session",
+                message: { type: "provider_auth_flow_event", flowId: flow.flowId, event },
+            });
+        }
+        catch (err) {
+            this.logger?.warn({ flowId: flow.flowId, provider: flow.provider, err: errorMessage(err) }, "provider-auth: failed to send flow event");
+        }
+    }
+}
+/** `AuthEventLike`'s `type` discriminant maps 1:1 onto the flow event's `kind` — everything else
+ *  (message/links, url/instructions, userCode/verificationUri/expiresInSeconds, message) forwards
+ *  verbatim. Never a prompt value; events carry no secrets by construction. */
+function toFlowEventPayload(event) {
+    const { type, ...rest } = event;
+    return { kind: type, ...rest };
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+/** Provider messages are safe to relay verbatim; this exists so a future caller has one place to
+ *  redact from, never to interpolate a prompt value into an error (callers never pass one in). */
+function sanitizeError(err) {
+    return errorMessage(err);
+}
+//# sourceMappingURL=provider-auth-service.js.map

package/dist/daemon/bootstrap.js

@@ -32,6 +32,10 @@ import { SlashCommandOperationsService } from "../agent/slash-command-operations
 import { registerTimelineHandler } from "../agent/timeline-rpc.js";
 import { PermissionService } from "../agent/permissions.js";
 import { ProviderRegistry, resolveProviderClient } from "../agent/provider-registry.js";
+import { resolvePiAuthPaths } from "../agent/pi-home.js";
+import { createPiAuthRuntime } from "../agent/provider-auth/pi-auth-runtime.js";
+import { ProviderAuthService } from "../agent/provider-auth/provider-auth-service.js";
+import { registerProviderAuthHandlers } from "../agent/provider-auth/provider-auth-rpc.js";
 import { saveAgent, loadAllAgents } from "../persistence/entity-stores.js";
 import { FileExplorerService } from "../files/file-explorer.js";
 import { FileTransferService } from "../files/file-transfer.js";
@@ -393,6 +397,15 @@ export function startDaemon(opts) {
     const fileWatchService = new FileWatchService({ logger });
     registerFileWatchHandlers(registry, { fileWatchService, subscriptions, logger });
     registerExtensionsHandlers(registry, { service: extensionsService, logger: extensionsLogger });
+    // ── Provider auth: remote-driven Pi login flows (sprint-055) ─────────────────
+    const providerAuthLogger = logger.child({ component: "provider-auth" });
+    const providerAuthRuntime = createPiAuthRuntime(resolvePiAuthPaths(config));
+    const providerAuthService = new ProviderAuthService({
+        runtime: providerAuthRuntime,
+        logger: providerAuthLogger,
+        subscriptions,
+    });
+    registerProviderAuthHandlers(registry, { providerAuthService, logger: providerAuthLogger });
     // Simple file diff RPC for the POC UI (returns unified diff for a single file). Untracked
     // (brand-new) files have no git-tracked "before" state, so a plain `git diff` against them is
     // always empty — git only diffs a path once it's in the index or committed. Fall back to

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@av-pi-studio/server",
-  "version": "0.0.92",
+  "version": "0.0.93",
   "bin": {
     "pi-studio-daemon": "dist/daemon/main.js"
   },
@@ -24,9 +24,9 @@
     "clean": "rm -rf dist *.tsbuildinfo"
   },
   "dependencies": {
-    "@av-pi-studio/highlight": "^0.0.92",
-    "@av-pi-studio/protocol": "^0.0.92",
-    "@av-pi-studio/relay": "^0.0.92",
+    "@av-pi-studio/highlight": "^0.0.93",
+    "@av-pi-studio/protocol": "^0.0.93",
+    "@av-pi-studio/relay": "^0.0.93",
     "@earendil-works/pi-coding-agent": "^0.84.1",
     "@xterm/headless": "^6.0.0",
     "bcryptjs": "^3.0.3",