@aiden-ade/sandbox-agent 0.1.19 → 0.1.21

package/dist/daemon.js

@@ -1,836 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, rmSync, statfsSync, writeFileSync } from "node:fs";
-import http from "node:http";
-import { randomBytes } from "node:crypto";
-import { arch, cpus, freemem, homedir, hostname, platform, release, totalmem } from "node:os";
-import { dirname, join } from "node:path";
-import { io } from "socket.io-client";
-import { collectLocalAgentProviderLimits } from "@aiden/shared/node/provider-limits";
-import { DISCOVERABLE_PROVIDER_KINDS, getDaemonCliEnvironment, resolveBackendRuntimeCommand, resolveCliExecutable, resolveProviderCliCommand, } from "./cli-executable.js";
-import { AGENT_VERSION } from "./version.js";
-import { CoreAgent } from "./core-agent.js";
-import { extractGeneratedImagesFromToolResult } from "./generated-images.js";
-const PRODUCTION_API_URL = "https://api.aiden-platform.com";
-const PRODUCTION_WS_URL = "wss://ws.aiden-platform.com";
-const LOCAL_API_URL = "http://localhost:8400";
-const LOCAL_WS_URL = "ws://localhost:8401";
-async function probeLocalDaemonEndpoint(port, token, timeoutMs = 750) {
-    try {
-        const headers = {};
-        if (token)
-            headers.authorization = `Bearer ${token}`;
-        const response = await fetch(`http://127.0.0.1:${port}/status`, {
-            headers,
-            signal: AbortSignal.timeout(timeoutMs),
-        });
-        if (response.status === 401)
-            return { state: "listening_unauthorized" };
-        if (!response.ok)
-            return { state: "absent" };
-        const body = await response.json();
-        if (!body.runtimeId)
-            return { state: "absent" };
-        return { state: "running", status: body };
-    }
-    catch {
-        return { state: "absent" };
-    }
-}
-export async function probeLocalDaemon(port, token, timeoutMs = 750) {
-    const probe = await probeLocalDaemonEndpoint(port, token, timeoutMs);
-    return probe.state === "running" ? probe.status : null;
-}
-export async function isLocalDaemonListening(port, token) {
-    const probe = await probeLocalDaemonEndpoint(port, token);
-    return probe.state !== "absent";
-}
-function describeOccupiedLocalDaemon(port) {
-    return `local daemon API port ${port} is already in use. `
-        + "If Aiden desktop is open, it manages the daemon automatically. "
-        + "Quit Aiden desktop or stop the existing daemon before starting another.";
-}
-function getConfigPath() {
-    return process.env.AIDEN_AGENT_CONFIG_PATH ??
-        join(homedir(), ".aiden", "agent", "config.json");
-}
-function getEndpointDefaultsPath() {
-    return process.env.AIDEN_AGENT_ENDPOINTS_PATH ??
-        join(dirname(getConfigPath()), "endpoints.json");
-}
-function readConfig() {
-    const configPath = getConfigPath();
-    if (!existsSync(configPath))
-        return {};
-    return JSON.parse(readFileSync(configPath, "utf8"));
-}
-function readEndpointDefaults() {
-    const endpointsPath = getEndpointDefaultsPath();
-    if (!existsSync(endpointsPath))
-        return {};
-    try {
-        return JSON.parse(readFileSync(endpointsPath, "utf8"));
-    }
-    catch {
-        return {};
-    }
-}
-function writeConfig(config) {
-    const configPath = getConfigPath();
-    mkdirSync(dirname(configPath), { recursive: true, mode: 0o700 });
-    writeFileSync(configPath, JSON.stringify(config, null, 2), { mode: 0o600 });
-}
-function removeConfig() {
-    const configPath = getConfigPath();
-    if (existsSync(configPath))
-        rmSync(configPath, { force: true });
-}
-function argValue(args, name) {
-    const index = args.indexOf(name);
-    if (index === -1)
-        return undefined;
-    return args[index + 1];
-}
-function resolveEndpointProfile(args) {
-    const profile = argValue(args, "--profile") ?? process.env.AIDEN_AGENT_PROFILE;
-    if (!profile)
-        return "production";
-    if (profile === "production" || profile === "prod")
-        return "production";
-    if (profile === "local" || profile === "dev")
-        return "local";
-    throw new Error("Unsupported endpoint profile. Use --profile production or --profile local.");
-}
-function resolveEndpoints(args, stored = {}) {
-    const requestedProfile = resolveEndpointProfile(args);
-    const profileApiUrl = requestedProfile === "local" ? LOCAL_API_URL : PRODUCTION_API_URL;
-    const profileWsUrl = requestedProfile === "local" ? LOCAL_WS_URL : PRODUCTION_WS_URL;
-    const endpointDefaults = readEndpointDefaults();
-    const apiUrl = argValue(args, "--api-url") ?? process.env.AIDEN_API_URL ?? stored.apiUrl ?? endpointDefaults.apiUrl ?? profileApiUrl;
-    const wsUrl = argValue(args, "--ws-url") ?? process.env.AIDEN_WS_URL ?? stored.wsUrl ?? endpointDefaults.wsUrl ?? profileWsUrl;
-    const endpointProfile = apiUrl === profileApiUrl && wsUrl === profileWsUrl
-        ? requestedProfile
-        : apiUrl === endpointDefaults.apiUrl && wsUrl === endpointDefaults.wsUrl && endpointDefaults.endpointProfile
-            ? endpointDefaults.endpointProfile
-            : "custom";
-    return { apiUrl, wsUrl, endpointProfile };
-}
-function isLocalEndpoint(url) {
-    return Boolean(url && /^(https?|wss?):\/\/(localhost|127\.0\.0\.1)(:\d+)?(\/|$)/.test(url));
-}
-function getLocalApiPort(args, stored) {
-    const raw = argValue(args, "--local-api-port") ?? process.env.AIDEN_AGENT_LOCAL_API_PORT;
-    if (raw)
-        return Number.parseInt(raw, 10);
-    const storedPort = stored.localApiPort;
-    if (storedPort && storedPort > 0)
-        return storedPort;
-    return 47831;
-}
-function sleep(ms) {
-    if (ms <= 0)
-        return Promise.resolve();
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function normalizeBackendKind(backendKind) {
-    if (backendKind === "codex")
-        return "codex_app_server";
-    return backendKind;
-}
-export function discoverCapabilities() {
-    const now = new Date().toISOString();
-    const env = getDaemonCliEnvironment();
-    return {
-        agents: DISCOVERABLE_PROVIDER_KINDS.map((provider) => {
-            const executable = resolveProviderCliCommand(provider, env);
-            return {
-                provider,
-                available: Boolean(executable),
-                models: [],
-                lastCheckedAt: now,
-            };
-        }),
-        hasGit: Boolean(resolveCliExecutable("git", env)),
-        hasTerminal: true,
-        supportsFilesystem: true,
-    };
-}
-const USER_INTERRUPTED_RESULT = {
-    success: false,
-    summary: "Interrupted by user",
-    filesModified: [],
-    planFilesCreated: [],
-    iterations: 0,
-    error: "Interrupted by user",
-};
-function abortActiveAgent(entry) {
-    entry.presenter.onComplete(USER_INTERRUPTED_RESULT);
-    entry.agent.kill();
-}
-function collectRuntimeMetadata() {
-    const cpuList = cpus();
-    const metadata = {
-        platform: platform(),
-        arch: arch(),
-        osVersion: release(),
-        agentVersion: AGENT_VERSION,
-        memoryBytes: totalmem(),
-        memoryFreeBytes: freemem(),
-    };
-    if (cpuList.length > 0) {
-        metadata.cpuModel = cpuList[0]?.model;
-        metadata.cpuCores = cpuList.length;
-    }
-    try {
-        const disk = statfsSync(homedir());
-        metadata.diskFreeBytes = disk.bavail * disk.bsize;
-        metadata.diskTotalBytes = disk.blocks * disk.bsize;
-    }
-    catch {
-        // Disk stats are best-effort and may be unavailable in restricted runtimes.
-    }
-    return metadata;
-}
-async function collectRuntimeMetadataWithProviderLimits() {
-    const metadata = collectRuntimeMetadata();
-    try {
-        const agentProviderLimits = await collectLocalAgentProviderLimits(getDaemonCliEnvironment());
-        if (Object.keys(agentProviderLimits).length > 0) {
-            metadata.agentProviderLimits = agentProviderLimits;
-        }
-    }
-    catch {
-        // Best-effort only. Missing or expired provider credentials should not affect runtime presence.
-    }
-    return metadata;
-}
-class RuntimePresenter {
-    socket;
-    conversationId;
-    runId;
-    cwd;
-    emittedGeneratedImageKeys = new Set();
-    constructor(socket, conversationId, runId, cwd) {
-        this.socket = socket;
-        this.conversationId = conversationId;
-        this.runId = runId;
-        this.cwd = cwd;
-    }
-    emitEvent(event) {
-        this.socket.emit("agent.event", {
-            conversationId: this.conversationId,
-            runId: this.runId,
-            event,
-        });
-    }
-    onStart(config) {
-        this.emitEvent({ type: "start", task: config.task, ts: Date.now() });
-    }
-    onLog(message) {
-        console.error(message);
-    }
-    onAssistantText(text) {
-        this.emitEvent({ type: "text", text, ts: Date.now() });
-    }
-    onThinking(text) {
-        this.emitEvent({ type: "thinking", text, ts: Date.now() });
-    }
-    onToolUse(tool, input, toolId) {
-        this.emitEvent({ type: "tool_use", id: toolId, name: tool, input, ts: Date.now() });
-    }
-    onToolResult(toolId, content, isError) {
-        this.emitEvent({
-            type: "tool_result",
-            id: toolId,
-            content,
-            ts: Date.now(),
-            ...(isError ? { is_error: true } : {}),
-        });
-        if (isError)
-            return;
-        for (const image of extractGeneratedImagesFromToolResult(toolId, content, this.cwd)) {
-            this.emitGeneratedImage(image);
-        }
-    }
-    onGeneratedImage(image) {
-        this.emitGeneratedImage(image);
-    }
-    emitGeneratedImage(image) {
-        const key = image.sourceHash ?? `${image.sourcePath ?? image.id}:${image.size}`;
-        if (this.emittedGeneratedImageKeys.has(key))
-            return;
-        this.emittedGeneratedImageKeys.add(key);
-        this.emitEvent(image);
-    }
-    onTurnComplete(content) {
-        this.emitEvent({ type: "turn_complete", content, ts: Date.now() });
-    }
-    onUsageUpdate(usage) {
-        this.emitEvent({ type: "usage", usage });
-    }
-    onAskUser(id, questions) {
-        this.emitEvent({ type: "ask_user", id, questions });
-    }
-    onTodoWrite(todos) {
-        this.emitEvent({ type: "todo_write", todos });
-    }
-    onExitPlanMode(id, input, planFilePath) {
-        this.emitEvent({ type: "exit_plan_mode", id, input, ...(planFilePath ? { planFilePath } : {}) });
-    }
-    onCheckpoint(id) {
-        this.emitEvent({ type: "checkpoint", id });
-    }
-    onActivity(status) {
-        this.emitEvent({ type: "activity", status, ts: Date.now() });
-    }
-    onOpenBrowserTab(browserId, url) {
-        this.emitEvent({ type: "open_browser_tab", browserId, ...(url ? { url } : {}) });
-    }
-    recordRawTranscript() {
-        // Durable daemon transcripts stay with the underlying CLI runtime.
-    }
-    onError(message) {
-        this.emitEvent({ type: "session_error", error: message });
-    }
-    onComplete(result) {
-        this.emitEvent({ type: "query_complete", result, ts: Date.now() });
-    }
-}
-export async function setupDaemon(args) {
-    const { apiUrl, wsUrl, endpointProfile } = resolveEndpoints(args);
-    const teamId = argValue(args, "--team") ?? process.env.AIDEN_TEAM_ID;
-    const setupToken = argValue(args, "--setup-token") ?? process.env.AIDEN_RUNTIME_SETUP_TOKEN;
-    const token = argValue(args, "--token") ?? process.env.AIDEN_SETUP_TOKEN;
-    const displayName = argValue(args, "--name") ?? hostname();
-    const legacyLocalMachineId = argValue(args, "--legacy-local-machine-id") ?? process.env.AIDEN_LEGACY_LOCAL_MACHINE_ID;
-    const scope = argValue(args, "--scope") ?? process.env.AIDEN_RUNTIME_SCOPE ?? "team";
-    if (scope !== "team" && scope !== "user") {
-        throw new Error("setup --scope must be either 'team' or 'user'");
-    }
-    if (!setupToken && (!teamId || !token)) {
-        throw new Error("setup requires --setup-token <token> or --team <team-id> and --token <aiden PAT>.\n"
-            + "For normal setup, copy the setup token from Aiden and run: aiden-agent setup --setup-token <token>\n"
-            + "For browser authorization, run: aiden-agent login");
-    }
-    const response = await fetch(`${apiUrl}/public/runtimes${setupToken ? "/register-with-setup-token" : ""}`, {
-        method: "POST",
-        headers: {
-            "content-type": "application/json",
-            ...(setupToken ? {} : { authorization: `Bearer ${token}` }),
-        },
-        body: JSON.stringify({
-            ...(teamId ? { teamId } : {}),
-            ...(setupToken ? { setupToken } : {}),
-            displayName,
-            hostname: hostname(),
-            ...(legacyLocalMachineId ? { legacyLocalMachineId } : {}),
-            runtimeKind: "machine",
-            managementKind: "user_managed",
-            hostKind: "daemon",
-            lifecycle: "durable",
-            ownerType: scope,
-            visibility: scope,
-            capabilities: discoverCapabilities(),
-            metadata: await collectRuntimeMetadataWithProviderLimits(),
-        }),
-    });
-    if (!response.ok) {
-        throw new Error(`runtime registration failed: ${response.status} ${await response.text()}`);
-    }
-    const body = await response.json();
-    writeConfig({
-        apiUrl,
-        wsUrl,
-        endpointProfile,
-        teamId,
-        runtimeId: body.runtime.id,
-        runtimeToken: body.runtimeToken,
-        localApiPort: getLocalApiPort(args, {}),
-        localApiToken: randomBytes(24).toString("hex"),
-        displayName: body.runtime.displayName ?? displayName,
-    });
-    console.info("[aiden-agent] Runtime registered", { runtimeId: body.runtime.id, configPath: getConfigPath() });
-}
-export async function loginWithDeviceCode(args) {
-    const { apiUrl, wsUrl, endpointProfile } = resolveEndpoints(args);
-    const displayName = argValue(args, "--name") ?? hostname();
-    const maxPolls = Number.parseInt(argValue(args, "--max-polls") ?? "300", 10);
-    const start = await fetch(`${apiUrl}/public/runtimes/device-authorizations`, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({
-            displayName,
-            hostname: hostname(),
-            capabilities: discoverCapabilities(),
-            metadata: await collectRuntimeMetadataWithProviderLimits(),
-        }),
-    });
-    if (!start.ok) {
-        throw new Error(`device authorization failed: ${start.status} ${await start.text()}`);
-    }
-    const authorization = await start.json();
-    const intervalMs = Math.max(0, (authorization.intervalSeconds ?? 2) * 1000);
-    console.info(`[aiden-agent] Open ${authorization.verificationUri}`);
-    console.info(`[aiden-agent] Enter code ${authorization.userCode}`);
-    for (let attempt = 0; attempt < maxPolls; attempt += 1) {
-        if (attempt > 0)
-            await sleep(intervalMs);
-        const token = await fetch(`${apiUrl}/public/runtimes/device-authorizations/token`, {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify({ deviceCode: authorization.deviceCode }),
-        });
-        if (token.status === 428)
-            continue;
-        if (!token.ok) {
-            throw new Error(`device authorization token exchange failed: ${token.status} ${await token.text()}`);
-        }
-        const body = await token.json();
-        writeConfig({
-            apiUrl,
-            wsUrl,
-            endpointProfile,
-            teamId: body.runtime.teamId ?? undefined,
-            runtimeId: body.runtime.id,
-            runtimeToken: body.runtimeToken,
-            localApiPort: getLocalApiPort(args, {}),
-            localApiToken: randomBytes(24).toString("hex"),
-            displayName: body.runtime.displayName ?? displayName,
-        });
-        console.info("[aiden-agent] Runtime registered", { runtimeId: body.runtime.id, configPath: getConfigPath() });
-        return;
-    }
-    throw new Error("device authorization timed out before approval");
-}
-export async function startDaemon(args) {
-    const stored = readConfig();
-    const runtimeId = argValue(args, "--runtime-id") ?? process.env.AIDEN_RUNTIME_ID ?? stored.runtimeId;
-    const runtimeToken = argValue(args, "--token") ?? process.env.AIDEN_RUNTIME_TOKEN ?? stored.runtimeToken;
-    const wsUrl = argValue(args, "--ws-url") ?? process.env.AIDEN_WS_URL ?? stored.wsUrl;
-    let localApiPort = getLocalApiPort(args, stored);
-    const localApiToken = stored.localApiToken ?? randomBytes(24).toString("hex");
-    if (!runtimeId || !runtimeToken || !wsUrl) {
-        throw new Error("daemon requires runtimeId, runtime token, and wsUrl. Run setup first or pass --runtime-id/--token/--ws-url.");
-    }
-    const activeAgents = new Map();
-    const currentCapabilities = () => discoverCapabilities();
-    const currentMetadata = () => collectRuntimeMetadataWithProviderLimits();
-    const recentLogs = [];
-    const pushLog = (message) => {
-        recentLogs.push(`${new Date().toISOString()} ${message}`);
-        if (recentLogs.length > 200)
-            recentLogs.splice(0, recentLogs.length - 200);
-    };
-    if (stored.localApiPort !== localApiPort || stored.localApiToken !== localApiToken) {
-        writeConfig({ ...stored, runtimeId, runtimeToken, wsUrl, localApiPort, localApiToken });
-    }
-    const socket = io(wsUrl, {
-        query: { type: "runtime", runtimeId, hostKind: "daemon", agentVersion: AGENT_VERSION },
-        auth: { token: runtimeToken },
-        transports: ["websocket"],
-        reconnection: true,
-        reconnectionAttempts: Infinity,
-        reconnectionDelay: 1000,
-        reconnectionDelayMax: 5000,
-        timeout: 20_000,
-        upgrade: false,
-        extraHeaders: { "ngrok-skip-browser-warning": "1" },
-    });
-    const heartbeat = setInterval(() => {
-        if (!socket.connected)
-            return;
-        void currentMetadata().then((metadata) => {
-            socket.emit("runtime.heartbeat", { capabilities: currentCapabilities(), metadata });
-        });
-    }, 15_000);
-    socket.on("connect", () => {
-        pushLog(`connected runtime=${runtimeId}`);
-        console.info("[aiden-agent] Daemon connected", { runtimeId, wsUrl, version: AGENT_VERSION });
-        void currentMetadata().then((metadata) => {
-            socket.emit("runtime.hello", { capabilities: currentCapabilities(), metadata });
-        });
-    });
-    let lastConnectErrorLogAt = 0;
-    socket.on("connect_error", (error) => {
-        pushLog(`connect_error ${error.message}`);
-        const now = Date.now();
-        if (now - lastConnectErrorLogAt < 5000)
-            return;
-        lastConnectErrorLogAt = now;
-        const wsHint = isLocalEndpoint(wsUrl)
-            ? ` Nothing is listening at ${wsUrl}. For local dev run setup with --profile local and start the stack (WS on ws://localhost:8401).`
-            : ` Verify wsUrl in ${getConfigPath()} and that you can reach ${wsUrl}.`;
-        console.warn("[aiden-agent] Daemon connection error:", `${error.message}.${wsHint}`);
-    });
-    socket.on("disconnect", (reason) => {
-        pushLog(`disconnected ${reason}`);
-        console.info("[aiden-agent] Daemon disconnected:", reason);
-    });
-    socket.on("agent.execute", (payload) => {
-        if (!payload?.runId || !payload.conversationId || typeof payload.content !== "string") {
-            return;
-        }
-        if (activeAgents.has(payload.runId)) {
-            socket.emit("agent.rejected", { runId: payload.runId, message: "Run is already active" });
-            return;
-        }
-        const backendKind = normalizeBackendKind(payload.backendKind);
-        const runtimeCommand = resolveBackendRuntimeCommand(backendKind ?? payload.backendKind);
-        if (!runtimeCommand && backendKind) {
-            socket.emit("agent.rejected", {
-                runId: payload.runId,
-                message: `CLI command not found for ${backendKind}. Install the provider CLI and restart the daemon.`,
-            });
-            return;
-        }
-        socket.emit("agent.accepted", { runId: payload.runId });
-        pushLog(`accepted run=${payload.runId}`);
-        const cwd = payload.projectPath ?? process.cwd();
-        const presenter = new RuntimePresenter(socket, payload.conversationId, payload.runId, cwd);
-        const agent = new CoreAgent(presenter, {
-            backendKind,
-            runtimeCommand,
-            providerApiKey: payload.providerApiKey,
-        });
-        activeAgents.set(payload.runId, { agent, presenter });
-        void agent.run({
-            task: payload.content,
-            maxIterations: payload.maxIterations ?? 50,
-            teamPath: cwd,
-            cwd,
-            backendKind,
-            runtimeCommand,
-            agentId: payload.agentId,
-            agentPrompt: payload.agentPrompt,
-            mode: (payload.mode ?? "agent"),
-            selectedModel: payload.model,
-            selectedContextWindow: payload.selectedContextWindow ?? null,
-            selectedEffortLevel: payload.selectedEffortLevel ?? null,
-            providerSessionId: payload.providerSessionId,
-            taskMeta: payload.taskMeta,
-            prMeta: payload.prMeta,
-            conversationId: payload.conversationId,
-            taskId: payload.taskMeta?.id,
-            teamId: payload.teamId,
-            currentUser: payload.currentUser,
-            workflowTools: payload.workflowTools,
-            images: payload.images,
-        }).catch((error) => {
-            const message = error instanceof Error ? error.message : String(error);
-            pushLog(`failed run=${payload.runId} ${message}`);
-            socket.emit("agent.event", {
-                conversationId: payload.conversationId,
-                runId: payload.runId,
-                event: { type: "session_error", error: message },
-            });
-        }).finally(() => {
-            activeAgents.delete(payload.runId);
-        });
-    });
-    socket.on("agent.abort", (payload) => {
-        if (!payload?.runId)
-            return;
-        const entry = activeAgents.get(payload.runId);
-        if (!entry)
-            return;
-        abortActiveAgent(entry);
-        activeAgents.delete(payload.runId);
-        pushLog(`aborted run=${payload.runId}`);
-    });
-    socket.on("agent.tool_response", (payload) => {
-        if (!payload?.toolId || typeof payload.response !== "string")
-            return;
-        const agents = payload.runId
-            ? [activeAgents.get(payload.runId)?.agent]
-            : [...activeAgents.values()].map((entry) => entry.agent);
-        const delivered = agents.some((agent) => agent?.sendToolResponse(payload.toolId, payload.response) === true);
-        if (!delivered)
-            pushLog(`tool_response missed tool=${payload.toolId}`);
-    });
-    socket.on("agent.append_message", (payload) => {
-        if (!payload?.runId || typeof payload.text !== "string")
-            return;
-        const agent = activeAgents.get(payload.runId)?.agent;
-        const delivered = agent?.sendUserMessage(payload.text) === true;
-        socket.emit(delivered ? "agent.accepted" : "agent.rejected", {
-            runId: payload.runId,
-            ...(delivered ? {} : { message: "No active agent for appended message" }),
-        });
-    });
-    const localServer = http.createServer((req, res) => {
-        const auth = req.headers.authorization;
-        if (auth !== `Bearer ${localApiToken}`) {
-            res.writeHead(401, { "content-type": "application/json" }).end(JSON.stringify({ error: "Unauthorized" }));
-            return;
-        }
-        if (req.method === "GET" && req.url === "/status") {
-            res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify({
-                configured: true,
-                runtimeId,
-                wsUrl,
-                connected: socket.connected,
-                activeRunIds: [...activeAgents.keys()],
-                localApiPort,
-                version: AGENT_VERSION,
-            }));
-            return;
-        }
-        if (req.method === "GET" && req.url === "/capabilities") {
-            res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify(discoverCapabilities()));
-            return;
-        }
-        if (req.method === "GET" && req.url === "/logs") {
-            res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify({ lines: recentLogs }));
-            return;
-        }
-        if (req.method === "POST" && req.url === "/stop") {
-            for (const entry of activeAgents.values())
-                abortActiveAgent(entry);
-            activeAgents.clear();
-            res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify({ ok: true }));
-            return;
-        }
-        if (req.method === "POST" && req.url === "/shutdown") {
-            res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify({ ok: true }));
-            setImmediate(queueFullShutdown);
-            return;
-        }
-        res.writeHead(404, { "content-type": "application/json" }).end(JSON.stringify({ error: "Not found" }));
-    });
-    const occupiedProbe = await probeLocalDaemonEndpoint(localApiPort, localApiToken);
-    if (occupiedProbe.state === "running") {
-        clearInterval(heartbeat);
-        socket.disconnect();
-        throw new Error(`${describeOccupiedLocalDaemon(localApiPort)} (runtime ${occupiedProbe.status.runtimeId})`);
-    }
-    if (occupiedProbe.state === "listening_unauthorized") {
-        clearInterval(heartbeat);
-        socket.disconnect();
-        throw new Error(`${describeOccupiedLocalDaemon(localApiPort)} The token in ${getConfigPath()} no longer matches the running daemon; quit Aiden desktop or run setup again.`);
-    }
-    await new Promise((resolve, reject) => {
-        const onError = (error) => {
-            clearInterval(heartbeat);
-            socket.disconnect();
-            if (error.code === "EADDRINUSE") {
-                void probeLocalDaemonEndpoint(localApiPort).then((probe) => {
-                    if (probe.state !== "absent") {
-                        reject(new Error(describeOccupiedLocalDaemon(localApiPort)));
-                        return;
-                    }
-                    reject(new Error(`local daemon API port ${localApiPort} is already in use by another process. `
-                        + "Otherwise free the port or pass `--local-api-port` with a different value."));
-                });
-                return;
-            }
-            reject(error);
-        };
-        localServer.once("error", onError);
-        localServer.listen(localApiPort, "127.0.0.1", () => {
-            localServer.off("error", onError);
-            const address = localServer.address();
-            if (address && typeof address === "object")
-                localApiPort = address.port;
-            pushLog(`local_api listening port=${localApiPort}`);
-            console.info("[aiden-agent] Local daemon API listening", { port: localApiPort });
-            resolve();
-        });
-    });
-    let stopped = false;
-    const stop = async () => {
-        if (stopped)
-            return;
-        stopped = true;
-        clearInterval(heartbeat);
-        for (const entry of activeAgents.values()) {
-            abortActiveAgent(entry);
-        }
-        activeAgents.clear();
-        socket.disconnect();
-        await new Promise((resolve) => {
-            localServer.close(() => resolve());
-        });
-    };
-    const controller = {
-        runtimeId,
-        wsUrl,
-        localApiPort,
-        localApiToken,
-        stop,
-    };
-    const queueFullShutdown = () => {
-        void stop().then(() => controller.whenExternallyStopped?.());
-    };
-    return controller;
-}
-export async function stopDaemon(args) {
-    const stored = readConfig();
-    const localApiPort = getLocalApiPort(args, stored);
-    const localApiToken = stored.localApiToken;
-    if (!localApiToken) {
-        throw new Error("No local API token in config. Run setup or login first.");
-    }
-    const probe = await probeLocalDaemonEndpoint(localApiPort, localApiToken);
-    if (probe.state === "listening_unauthorized") {
-        throw new Error(`Daemon is listening on port ${localApiPort} but rejected this config token. `
-            + "Quit Aiden desktop or rerun setup/login to refresh config.");
-    }
-    if (probe.state === "absent") {
-        console.info("[aiden-agent] No daemon listening", { port: localApiPort });
-        return;
-    }
-    const response = await fetch(`http://127.0.0.1:${localApiPort}/shutdown`, {
-        method: "POST",
-        headers: { authorization: `Bearer ${localApiToken}` },
-        signal: AbortSignal.timeout(5000),
-    });
-    if (!response.ok) {
-        throw new Error(`Failed to stop daemon: HTTP ${response.status}`);
-    }
-    console.info("[aiden-agent] Daemon stopped", {
-        port: localApiPort,
-        runtimeId: probe.status.runtimeId,
-    });
-}
-export async function runDaemon(args) {
-    const stored = readConfig();
-    const localApiPort = getLocalApiPort(args, stored);
-    const localApiToken = stored.localApiToken;
-    const existingProbe = await probeLocalDaemonEndpoint(localApiPort, localApiToken);
-    if (existingProbe.state === "running") {
-        console.info("[aiden-agent] Daemon already running", {
-            port: localApiPort,
-            runtimeId: existingProbe.status.runtimeId,
-            connected: existingProbe.status.connected,
-            hint: "If Aiden desktop is open, it manages the daemon automatically.",
-        });
-        return;
-    }
-    if (existingProbe.state === "listening_unauthorized") {
-        console.info("[aiden-agent] Daemon already running", {
-            port: localApiPort,
-            hint: "Aiden desktop is using a different local API token than config.json. Quit the desktop app or rerun setup if you need a fresh daemon.",
-        });
-        return;
-    }
-    const controller = await startDaemon(args);
-    const shutdown = () => {
-        void controller.stop().finally(() => process.exit(0));
-    };
-    controller.whenExternallyStopped = shutdown;
-    process.once("SIGINT", shutdown);
-    process.once("SIGTERM", shutdown);
-    await new Promise(() => { });
-}
-export async function rotateRuntimeToken(args) {
-    const stored = readConfig();
-    const apiUrl = argValue(args, "--api-url") ?? process.env.AIDEN_API_URL ?? stored.apiUrl;
-    const runtimeId = argValue(args, "--runtime-id") ?? process.env.AIDEN_RUNTIME_ID ?? stored.runtimeId;
-    const token = argValue(args, "--token") ?? process.env.AIDEN_SETUP_TOKEN;
-    if (!apiUrl || !runtimeId || !token) {
-        throw new Error("token rotate requires configured api/runtime plus --token <aiden PAT>");
-    }
-    const response = await fetch(`${apiUrl}/public/runtimes/${runtimeId}/tokens/rotate`, {
-        method: "POST",
-        headers: { authorization: `Bearer ${token}` },
-    });
-    if (!response.ok) {
-        throw new Error(`runtime token rotation failed: ${response.status} ${await response.text()}`);
-    }
-    const body = await response.json();
-    writeConfig({ ...stored, apiUrl, runtimeId, runtimeToken: body.runtimeToken });
-    console.info("[aiden-agent] Runtime token rotated", { runtimeId });
-}
-export async function revokeRuntimeToken(args) {
-    const stored = readConfig();
-    const apiUrl = argValue(args, "--api-url") ?? process.env.AIDEN_API_URL ?? stored.apiUrl;
-    const runtimeId = argValue(args, "--runtime-id") ?? process.env.AIDEN_RUNTIME_ID ?? stored.runtimeId;
-    const token = argValue(args, "--token") ?? process.env.AIDEN_SETUP_TOKEN;
-    if (!apiUrl || !runtimeId || !token) {
-        throw new Error("token revoke requires configured api/runtime plus --token <aiden PAT>");
-    }
-    const response = await fetch(`${apiUrl}/public/runtimes/${runtimeId}/tokens/revoke`, {
-        method: "POST",
-        headers: { authorization: `Bearer ${token}` },
-    });
-    if (!response.ok) {
-        throw new Error(`runtime token revoke failed: ${response.status} ${await response.text()}`);
-    }
-    removeConfig();
-    console.info("[aiden-agent] Runtime token revoked", { runtimeId });
-}
-export function logoutDaemon() {
-    removeConfig();
-    console.info("[aiden-agent] Runtime config removed", { configPath: getConfigPath() });
-}
-export async function printStatus() {
-    const config = readConfig();
-    const configured = Boolean(config.runtimeId && config.runtimeToken && config.wsUrl);
-    const warnings = [];
-    if ((isLocalEndpoint(config.apiUrl) || isLocalEndpoint(config.wsUrl)) && config.endpointProfile !== "local") {
-        warnings.push("Configured endpoint points at localhost. Use --profile local only for local development.");
-    }
-    const localApiPort = config.localApiPort && config.localApiPort > 0
-        ? config.localApiPort
-        : getLocalApiPort([], config);
-    const localDaemonProbe = config.localApiToken
-        ? await probeLocalDaemonEndpoint(localApiPort, config.localApiToken)
-        : { state: "absent" };
-    const localDaemonRunning = localDaemonProbe.state === "running";
-    console.info(JSON.stringify({
-        mode: "runtime",
-        configured,
-        runtimeId: config.runtimeId ?? null,
-        apiUrl: config.apiUrl ?? null,
-        wsUrl: config.wsUrl ?? null,
-        endpointProfile: config.endpointProfile ?? null,
-        localApiPort: config.localApiPort ?? null,
-        localDaemonRunning,
-        hasLocalApiToken: Boolean(config.localApiToken),
-        configPath: getConfigPath(),
-        note: configured
-            ? (localDaemonRunning
-                ? "Local daemon is running. Stop it with: aiden-agent stop"
-                : "Durable runtime config is present. Start it with: aiden-agent daemon")
-            : "No durable runtime configured. Cloud sandbox sessions are launched by Aiden with session env vars and do not appear in this local config.",
-        warnings,
-    }, null, 2));
-}
-export async function printDoctor(args = []) {
-    const config = readConfig();
-    const capabilities = discoverCapabilities();
-    let synced = false;
-    let syncError = null;
-    if (args.includes("--sync")) {
-        if (!config.apiUrl || !config.runtimeId || !config.runtimeToken) {
-            throw new Error("doctor --sync requires configured apiUrl, runtimeId, and runtimeToken. Run setup first.");
-        }
-        const response = await fetch(`${config.apiUrl}/public/runtimes/${config.runtimeId}/capabilities/self`, {
-            method: "PATCH",
-            headers: {
-                authorization: `Bearer ${config.runtimeToken}`,
-                "content-type": "application/json",
-            },
-            body: JSON.stringify({ capabilities, metadata: await collectRuntimeMetadataWithProviderLimits() }),
-        });
-        if (!response.ok) {
-            syncError = `${response.status} ${await response.text()}`;
-            throw new Error(`doctor sync failed: ${syncError}`);
-        }
-        synced = true;
-    }
-    console.info(JSON.stringify({
-        version: AGENT_VERSION,
-        configPath: getConfigPath(),
-        configured: Boolean(config.runtimeId && config.runtimeToken && config.wsUrl),
-        runtimeId: config.runtimeId ?? null,
-        apiUrl: config.apiUrl ?? null,
-        wsUrl: config.wsUrl ?? null,
-        endpointProfile: config.endpointProfile ?? null,
-        warnings: (isLocalEndpoint(config.apiUrl) || isLocalEndpoint(config.wsUrl)) && config.endpointProfile !== "local"
-            ? ["Configured endpoint points at localhost. Use --profile local only for local development."]
-            : [],
-        synced,
-        syncError,
-        capabilities,
-    }, null, 2));
-}
-//# sourceMappingURL=daemon.js.map