@aria-cli/cli 1.0.57 → 1.0.58

package/dist/config/aria-config.js

@@ -1,238 +0,0 @@
-/**
- * ARIA Display & Persistence Configuration
- *
- * Loads user preferences from ~/.aria/config.yaml and merges them with
- * MODE_PRESETS to produce the final display configuration. This implements
- * the 4-layer merge strategy:
- *
- *   MODE_PRESETS[mode] -> config file -> CLI flags -> hotkey toggles
- *
- * All config options control UI presentation density, NOT feature availability.
- * ObservabilityContext always captures everything regardless of display settings.
- */
-import { readFileSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-import { parse as parseYaml } from "yaml";
-import { MODE_PRESETS, } from "../ui/display-mode.js";
-import { log } from "@aria-cli/types";
-// ---------------------------------------------------------------------------
-// Defaults
-// ---------------------------------------------------------------------------
-const DEFAULT_PERSISTENCE = {
-    jsonlEnabled: true,
-    // SQLite SessionHistory is the authoritative session ledger.
-    // JSONL event logs remain observability and recovery aids only.
-    // Never auto-delete JSONL files — they are still the durable event journal.
-    jsonlRetentionDays: Infinity,
-    jsonlMaxSizeMb: Infinity,
-    otelEndpoint: null,
-};
-const DEFAULT_DISPLAY_EXTRAS = {
-    mode: "standard",
-    syntaxHighlighting: true,
-    maxToolOutputLines: 5,
-    maxThinkingPreview: 80,
-};
-function buildDefaultConfig() {
-    return {
-        display: {
-            ...MODE_PRESETS.standard,
-            ...DEFAULT_DISPLAY_EXTRAS,
-        },
-        persistence: { ...DEFAULT_PERSISTENCE },
-    };
-}
-// ---------------------------------------------------------------------------
-// Validation helpers (lightweight — no Zod)
-// ---------------------------------------------------------------------------
-const VALID_DISPLAY_MODES = new Set(["minimal", "standard", "debug"]);
-const VALID_TOOL_OUTPUT_MODES = new Set(["hidden", "collapsed", "standard", "expanded"]);
-const VALID_THEME_NAMES = new Set([
-    "dark",
-    "light",
-    "dark-accessible",
-    "light-accessible",
-    "claude-dark",
-    "claude-light",
-    "claude-dark-daltonized",
-    "claude-light-daltonized",
-]);
-function isDisplayMode(value) {
-    return typeof value === "string" && VALID_DISPLAY_MODES.has(value);
-}
-function isToolOutputMode(value) {
-    return typeof value === "string" && VALID_TOOL_OUTPUT_MODES.has(value);
-}
-function isThemeName(value) {
-    return typeof value === "string" && VALID_THEME_NAMES.has(value);
-}
-function isBool(value) {
-    return typeof value === "boolean";
-}
-function isPositiveInt(value) {
-    return typeof value === "number" && Number.isInteger(value) && value > 0;
-}
-function isNonNegativeInt(value) {
-    return typeof value === "number" && Number.isInteger(value) && value >= 0;
-}
-// ---------------------------------------------------------------------------
-// YAML Config File Parsing
-// ---------------------------------------------------------------------------
-/**
- * Attempt to read and parse the YAML config file.
- * Returns null if the file doesn't exist. Throws on I/O errors.
- * Returns the raw parsed object on success (even if malformed YAML structure).
- */
-function readYamlConfig(configPath) {
-    try {
-        const content = readFileSync(configPath, "utf-8");
-        const parsed = parseYaml(content);
-        if (parsed === null || parsed === undefined || typeof parsed !== "object") {
-            return null;
-        }
-        return parsed;
-    }
-    catch (error) {
-        if (error.code === "ENOENT") {
-            return null;
-        }
-        throw error;
-    }
-}
-/**
- * Extract validated display overrides from raw YAML.
- * Unknown fields are silently ignored (forward-compatible).
- */
-function parseDisplaySection(raw) {
-    const result = {};
-    if (isDisplayMode(raw.mode))
-        result.mode = raw.mode;
-    if (isThemeName(raw.theme))
-        result.theme = raw.theme;
-    if (isBool(raw.thinking))
-        result.showThinking = raw.thinking;
-    if (isBool(raw.costs))
-        result.showCosts = raw.costs;
-    if (isBool(raw.toolArgs))
-        result.showToolArgs = raw.toolArgs;
-    if (isToolOutputMode(raw.toolOutput))
-        result.toolOutput = raw.toolOutput;
-    if (isBool(raw.traces))
-        result.showTraces = raw.traces;
-    if (isBool(raw.pipelineTiming))
-        result.showPipelineTiming = raw.pipelineTiming;
-    if (isBool(raw.statusBar))
-        result.showStatusBar = raw.statusBar;
-    if (isBool(raw.syntaxHighlighting))
-        result.syntaxHighlighting = raw.syntaxHighlighting;
-    if (isPositiveInt(raw.maxToolOutputLines))
-        result.maxToolOutputLines = raw.maxToolOutputLines;
-    if (isNonNegativeInt(raw.maxThinkingPreview))
-        result.maxThinkingPreview = raw.maxThinkingPreview;
-    return result;
-}
-/**
- * Extract validated persistence overrides from raw YAML.
- */
-function parsePersistenceSection(raw) {
-    const result = {};
-    if (isBool(raw.jsonlEnabled))
-        result.jsonlEnabled = raw.jsonlEnabled;
-    if (isPositiveInt(raw.jsonlRetentionDays) || raw.jsonlRetentionDays === Infinity)
-        result.jsonlRetentionDays = raw.jsonlRetentionDays;
-    if (isPositiveInt(raw.jsonlMaxSizeMb) || raw.jsonlMaxSizeMb === Infinity)
-        result.jsonlMaxSizeMb = raw.jsonlMaxSizeMb;
-    if (raw.otelEndpoint === null) {
-        result.otelEndpoint = null;
-    }
-    else if (typeof raw.otelEndpoint === "string" && raw.otelEndpoint.length > 0) {
-        result.otelEndpoint = raw.otelEndpoint;
-    }
-    return result;
-}
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-/**
- * Merge display config layers: preset -> file -> overrides.
- *
- * Each layer is a partial DisplayConfig. Values from later layers
- * override earlier ones. Missing values fall through to the preset.
- */
-export function mergeDisplayConfig(preset, fileOverrides, cliOverrides) {
-    return {
-        ...preset,
-        ...(fileOverrides ? stripUndefined(fileOverrides) : {}),
-        ...(cliOverrides ? stripUndefined(cliOverrides) : {}),
-    };
-}
-/**
- * Load the full ARIA display/persistence config.
- *
- * Resolution order:
- *   1. Start with MODE_PRESETS[mode] (default: "standard")
- *   2. Overlay values from ~/.aria/config.yaml (if exists)
- *   3. Return merged AriaDisplayConfig
- *
- * If the file doesn't exist, returns defaults silently.
- * If the file is malformed YAML, logs a warning and returns defaults.
- */
-export function loadAriaDisplayConfig(configPath) {
-    const defaults = buildDefaultConfig();
-    const resolvedPath = configPath ?? join(homedir(), ".aria", "config.yaml");
-    let raw;
-    try {
-        raw = readYamlConfig(resolvedPath);
-    }
-    catch (error) {
-        log.warn(`[AriaConfig] Failed to parse ${resolvedPath}: ${error.message}. Using defaults.`);
-        return defaults;
-    }
-    if (raw === null) {
-        return defaults;
-    }
-    // Parse display section
-    const rawDisplay = typeof raw.display === "object" && raw.display !== null
-        ? raw.display
-        : {};
-    const displayOverrides = parseDisplaySection(rawDisplay);
-    // Determine the base mode — file may specify a different mode
-    const mode = displayOverrides.mode ?? defaults.display.mode;
-    const modePreset = MODE_PRESETS[mode];
-    // Build display config: preset -> file overrides
-    const mergedDisplay = mergeDisplayConfig(modePreset, displayOverrides);
-    // Parse persistence section
-    const rawPersistence = typeof raw.persistence === "object" && raw.persistence !== null
-        ? raw.persistence
-        : {};
-    const persistenceOverrides = parsePersistenceSection(rawPersistence);
-    return {
-        display: {
-            ...mergedDisplay,
-            mode,
-            theme: displayOverrides.theme,
-            syntaxHighlighting: displayOverrides.syntaxHighlighting ?? defaults.display.syntaxHighlighting,
-            maxToolOutputLines: displayOverrides.maxToolOutputLines ?? defaults.display.maxToolOutputLines,
-            maxThinkingPreview: displayOverrides.maxThinkingPreview ?? defaults.display.maxThinkingPreview,
-        },
-        persistence: {
-            ...defaults.persistence,
-            ...stripUndefined(persistenceOverrides),
-        },
-    };
-}
-// ---------------------------------------------------------------------------
-// Utility
-// ---------------------------------------------------------------------------
-/** Remove undefined values from an object so spread doesn't override with undefined */
-function stripUndefined(obj) {
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-        if (value !== undefined) {
-            result[key] = value;
-        }
-    }
-    return result;
-}
-//# sourceMappingURL=aria-config.js.map

package/dist/config/index.js

@@ -1,3 +0,0 @@
-export { loadAriaProjectConfig, loadAriaProjectConfig as loadAriaConfig } from "./loader.js";
-export { loadAriaDisplayConfig, mergeDisplayConfig } from "./aria-config.js";
-//# sourceMappingURL=index.js.map

package/dist/config/loader.js

@@ -1,97 +0,0 @@
-/**
- * ARIA CLI Configuration Loader
- *
- * Loads configuration from project and global locations.
- */
-import { readFile } from "fs/promises";
-import { join } from "path";
-import { homedir } from "os";
-const DEFAULT_CONFIG = {
-    mcp: { servers: [] },
-};
-/**
- * Load config from a file path
- */
-async function loadConfigFile(path) {
-    try {
-        const content = await readFile(path, "utf-8");
-        const config = JSON.parse(content);
-        // Expand environment variables in config
-        if (config.mcp?.servers) {
-            for (const server of config.mcp.servers) {
-                if (server.env) {
-                    for (const [key, value] of Object.entries(server.env)) {
-                        if (typeof value === "string" && value.startsWith("${") && value.endsWith("}")) {
-                            const envVar = value.slice(2, -1);
-                            server.env[key] = process.env[envVar] || "";
-                        }
-                    }
-                }
-            }
-        }
-        // Validate server configs
-        if (config.mcp?.servers) {
-            for (const server of config.mcp.servers) {
-                if (!server.name || typeof server.name !== "string") {
-                    throw new Error('Invalid MCP server config: missing "name" field');
-                }
-                if (!server.transport) {
-                    throw new Error(`MCP server "${server.name}": missing "transport" field`);
-                }
-                if (server.transport && !["stdio", "sse"].includes(server.transport)) {
-                    throw new Error(`MCP server "${server.name}": unknown transport "${server.transport}"`);
-                }
-                if (server.transport === "stdio" && !server.command) {
-                    throw new Error(`MCP server "${server.name}": stdio transport requires "command" field`);
-                }
-                if (server.transport === "sse" && !server.url) {
-                    throw new Error(`MCP server "${server.name}": sse transport requires "url" field`);
-                }
-            }
-        }
-        return config;
-    }
-    catch (error) {
-        if (error.code === "ENOENT") {
-            return null;
-        }
-        throw error;
-    }
-}
-/**
- * Merge two configs (later takes precedence)
- */
-function mergeConfigs(base, override) {
-    const baseServers = base.mcp?.servers || [];
-    const overrideServers = override.mcp?.servers || [];
-    const overrideNames = new Set(overrideServers.map((s) => s.name));
-    return {
-        mcp: {
-            servers: [...baseServers.filter((s) => !overrideNames.has(s.name)), ...overrideServers],
-        },
-    };
-}
-/**
- * Load configuration from all sources
- *
- * Precedence: project > global > defaults
- */
-export async function loadAriaProjectConfig(projectDir) {
-    let config = { ...DEFAULT_CONFIG };
-    // Load global config
-    const globalPath = join(homedir(), ".aria", "config.json");
-    const globalConfig = await loadConfigFile(globalPath);
-    if (globalConfig) {
-        config = mergeConfigs(config, globalConfig);
-    }
-    // Load project config
-    if (projectDir) {
-        const projectPath = join(projectDir, "aria.config.json");
-        const projectConfig = await loadConfigFile(projectPath);
-        if (projectConfig) {
-            config = mergeConfigs(config, projectConfig);
-        }
-    }
-    return config;
-}
-//# sourceMappingURL=loader.js.map

package/dist/config.js

@@ -1,142 +0,0 @@
-/**
- * Shared configuration utilities for ARIA CLI
- */
-import * as fs from "fs";
-import * as os from "os";
-import { resolveModelReference, isValidTier } from "@aria-cli/models";
-import { log } from "@aria-cli/types";
-import { clearStallPhase, setStallPhase } from "./event-loop-watchdog.js";
-/**
- * Get the ARIA home directory.
- * Respects ARIA_HOME env var for testing and custom deployments.
- */
-export function getAriaDir() {
-    if (process.env.ARIA_HOME) {
-        return process.env.ARIA_HOME;
-    }
-    const home = process.env.HOME || os.homedir();
-    return `${home}/.aria`;
-}
-/**
- * Get the config file path
- */
-export function getConfigPath() {
-    return `${getAriaDir()}/config.json`;
-}
-/**
- * Load configuration from ~/.aria/config.json
- * Automatically migrates legacy defaultModel to preferredTier.
- *
- * This is the canonical config loader — use this instead of inline
- * JSON.parse to ensure migration logic runs consistently.
- */
-export function loadAndMigrateConfig() {
-    setStallPhase("config:load");
-    try {
-        const configPath = getConfigPath();
-        if (!fs.existsSync(configPath)) {
-            const config = {};
-            if (persistAwsSelectorHintsFromEnv(config)) {
-                saveConfig(config);
-            }
-            return config;
-        }
-        if (fs.existsSync(configPath)) {
-            const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
-            // Migrate old defaultModel to preferredTier
-            try {
-                if (config.defaultModel && !config.preferredTier) {
-                    const model = resolveModelReference(config.defaultModel);
-                    if (!model) {
-                        log.warn(`Unknown model "${config.defaultModel}" migrated to balanced tier (Sonnet 4.5)`);
-                    }
-                    const tier = model?.tier || "balanced";
-                    config.preferredTier = isValidTier(tier) ? tier : "balanced";
-                    delete config.defaultModel;
-                    saveConfig(config);
-                }
-                // Validate existing preferredTier
-                if (config.preferredTier !== undefined && !isValidTier(config.preferredTier)) {
-                    log.warn(`Invalid tier "${config.preferredTier}" corrected to balanced tier`);
-                    config.preferredTier = "balanced";
-                    saveConfig(config);
-                }
-                // Persist non-secret AWS Bedrock selector config from env vars into config.json.
-                // These vars often exist only in one launch context (editor, login shell, etc.).
-                // Persisting them lets the daemon own Bedrock execution while still using
-                // AWS-native shared config / SSO cache as the real credential authority.
-                if (persistAwsSelectorHintsFromEnv(config)) {
-                    saveConfig(config);
-                }
-            }
-            catch (migrationError) {
-                log.warn("Config migration failed, using config as-is:", migrationError instanceof Error ? migrationError.message : migrationError);
-            }
-            return config;
-        }
-    }
-    catch (err) {
-        log.warn("[Config] Failed to load config file:", err);
-    }
-    finally {
-        clearStallPhase();
-    }
-    return {};
-}
-/** @deprecated Use loadAndMigrateConfig() */
-export const loadConfig = loadAndMigrateConfig;
-function readNonEmptyEnv(name) {
-    const value = process.env[name]?.trim();
-    return value ? value : undefined;
-}
-/**
- * Persist non-secret Bedrock selector hints from the current environment into config.
- *
- * This is intentionally limited to selectors and file locations, not credential material:
- * - AWS profile / region
- * - shared config / credentials file overrides
- *
- * The daemon remains the authority for execution; this only captures enough configuration
- * for the daemon to find the machine-local AWS auth state later.
- */
-export function persistAwsSelectorHintsFromEnv(config) {
-    let changed = false;
-    const envAwsRegion = readNonEmptyEnv("AWS_REGION") ?? readNonEmptyEnv("AWS_DEFAULT_REGION");
-    const envAwsProfile = readNonEmptyEnv("AWS_PROFILE");
-    const envAwsConfigFile = readNonEmptyEnv("AWS_CONFIG_FILE");
-    const envAwsSharedCredentialsFile = readNonEmptyEnv("AWS_SHARED_CREDENTIALS_FILE");
-    if (!config.awsRegion && envAwsRegion) {
-        config.awsRegion = envAwsRegion;
-        changed = true;
-    }
-    if (!config.awsProfile && envAwsProfile) {
-        config.awsProfile = envAwsProfile;
-        changed = true;
-    }
-    if (!config.awsConfigFile && envAwsConfigFile) {
-        config.awsConfigFile = envAwsConfigFile;
-        changed = true;
-    }
-    if (!config.awsSharedCredentialsFile && envAwsSharedCredentialsFile) {
-        config.awsSharedCredentialsFile = envAwsSharedCredentialsFile;
-        changed = true;
-    }
-    return changed;
-}
-/**
- * Save configuration to ~/.aria/config.json
- */
-export function saveConfig(config) {
-    setStallPhase("config:save");
-    const ariaDir = getAriaDir();
-    try {
-        if (!fs.existsSync(ariaDir)) {
-            fs.mkdirSync(ariaDir, { recursive: true });
-        }
-        fs.writeFileSync(getConfigPath(), JSON.stringify(config, null, 2), "utf-8");
-    }
-    finally {
-        clearStallPhase();
-    }
-}
-//# sourceMappingURL=config.js.map

package/dist/daemon-info.js

@@ -1,10 +0,0 @@
-/**
- * Legacy daemon-info / presence helpers.
- *
- * The runtime-owner architecture no longer allows attach/discovery through
- * daemon-info files or per-process presence files. Keep this module only to
- * document that these APIs were removed in favor of HostSupervisor and
- * local-control attach.
- */
-export const LEGACY_RUNTIME_DISCOVERY_REMOVED = "[daemon-info] Legacy daemon-info/presence attach is removed. Use HostSupervisor/runtime-owner records and local-control attach instead.";
-//# sourceMappingURL=daemon-info.js.map

package/dist/ensure-daemon.js

@@ -1,128 +0,0 @@
-/**
- * Universal daemon connection for all CLI subcommands.
- *
- * One function, one pattern:
- *   1. Find running daemon → verify PID alive → connect to socket
- *   2. Dead/missing daemon → clean stale records → spawn → connect
- *
- * Every CLI path (pairing, call, headless) uses this. No scoped runtimes,
- * no split-brain, no WG port conflicts. The daemon owns the runtime.
- */
-import path from "node:path";
-function isPidAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-const ATTACHABLE_PHASES = new Set(["control_ready", "network_ready", "mesh_ready"]);
-function tryConnectToSocket(ariaHome) {
-    return (async () => {
-        try {
-            const { resolveRuntimeRootDirectory, findRuntimeOwnerRecordByAriaHome, removeRuntimeOwnerRecord, } = await import("@aria-cli/server");
-            const runtimeRoot = resolveRuntimeRootDirectory();
-            const owner = findRuntimeOwnerRecordByAriaHome(runtimeRoot, ariaHome);
-            if (!owner?.runtimeSocket) {
-                return null;
-            }
-            // Verify the daemon process is actually alive.
-            // If not, clean the stale record so we spawn a fresh daemon.
-            if (!isPidAlive(owner.runtimePid)) {
-                removeRuntimeOwnerRecord(runtimeRoot, owner.nodeId);
-                return null;
-            }
-            // Use the resilient client — it owns lease, auth, reattach, backoff, and logging.
-            const { createResilientAttachedClient } = await import("./attached-local-control-client.js");
-            const resilient = await createResilientAttachedClient({
-                runtimeSocket: owner.runtimeSocket,
-                clientKind: "local-api",
-                logDir: path.join(ariaHome, "logs"),
-            });
-            // Verify the daemon is in an attachable phase (not shutting down).
-            // Without this check, ensureDaemon can return a connection to a daemon
-            // in "stopped" phase — the socket and PID are alive during shutdown,
-            // but the child TUI will fail to attach because it requires an
-            // attachable phase (control_ready/network_ready/mesh_ready).
-            try {
-                const bootstrap = await resilient.api.getRuntimeBootstrap();
-                if (!ATTACHABLE_PHASES.has(bootstrap.phase)) {
-                    await resilient.release();
-                    removeRuntimeOwnerRecord(runtimeRoot, owner.nodeId);
-                    return null;
-                }
-            }
-            catch {
-                await resilient.release();
-                return null;
-            }
-            return {
-                control: resilient.api,
-                release: () => resilient.release(),
-            };
-        }
-        catch {
-            return null;
-        }
-    })();
-}
-/**
- * Connect to a running daemon, or spawn one if none exists.
- * This is the ONLY way CLI subcommands should obtain a control client.
- */
-export async function ensureDaemon(ctx) {
-    // 1. Try existing daemon (verifies PID alive, cleans stale records)
-    const existing = await tryConnectToSocket(ctx.ariaDir);
-    if (existing) {
-        return existing;
-    }
-    // 2. No daemon (or dead daemon cleaned up) — spawn one
-    const { createDaemonService } = await import("./headless/daemon-service.js");
-    const arionName = ctx.config.activeArion ?? "ARIA";
-    const daemon = createDaemonService({
-        cli: ctx,
-        cwd: process.cwd(),
-        arionName,
-    });
-    await daemon.start({});
-    // 3. Wait for socket with adaptive polling — fast at first (50ms),
-    //    then backs off to 200ms. Uses fs.watch on the owner-records
-    //    directory so we react in <50ms when the daemon writes its record.
-    const { resolveRuntimeRootDirectory } = await import("@aria-cli/server");
-    const runtimeRoot = resolveRuntimeRootDirectory();
-    const ownersDir = path.join(runtimeRoot, "owners");
-    const deadline = Date.now() + 15_000;
-    let watcher = null;
-    let notifyResolve = null;
-    try {
-        const { watch, mkdirSync, existsSync } = await import("node:fs");
-        if (!existsSync(ownersDir))
-            mkdirSync(ownersDir, { recursive: true, mode: 0o700 });
-        try {
-            watcher = watch(ownersDir, () => notifyResolve?.());
-            watcher.on("error", () => { });
-        }
-        catch {
-            // fs.watch may fail on some platforms; polling still works
-        }
-        let pollMs = 50;
-        while (Date.now() < deadline) {
-            const conn = await tryConnectToSocket(ctx.ariaDir);
-            if (conn)
-                return conn;
-            await new Promise((resolve) => {
-                notifyResolve = resolve;
-                setTimeout(resolve, pollMs);
-            });
-            notifyResolve = null;
-            pollMs = Math.min(Math.round(pollMs * 1.5), 200);
-        }
-    }
-    finally {
-        watcher?.close();
-    }
-    throw new Error("Daemon started but socket not reachable. Check ARIA_HOME.");
-}
-//# sourceMappingURL=ensure-daemon.js.map

package/dist/entrypoints/command-mode.js

@@ -1,5 +0,0 @@
-import { program } from "../commands/index.js";
-export async function runCommandMode(argv = process.argv) {
-    await program.parseAsync(argv);
-}
-//# sourceMappingURL=command-mode.js.map

package/dist/entrypoints/daemon.js

@@ -1,50 +0,0 @@
-import { runServerDaemonLauncherFromCli } from "@aria-cli/server/daemon-launcher";
-function requireValue(argv, index, flag) {
-    const value = argv[index + 1];
-    if (!value)
-        throw new Error(`${flag} requires a value`);
-    return value;
-}
-function parseDaemonArgs(argv) {
-    const options = {};
-    for (let i = 0; i < argv.length; i += 1) {
-        const arg = argv[i];
-        switch (arg) {
-            case "--arion":
-                options.arion = requireValue(argv, i, arg);
-                i += 1;
-                break;
-            case "--port":
-                options.port = requireValue(argv, i, arg);
-                i += 1;
-                break;
-            case "--interval-ms":
-                options.intervalMs = requireValue(argv, i, arg);
-                i += 1;
-                break;
-            case "--allowed-tool-categories":
-                options.allowedToolCategories = requireValue(argv, i, arg);
-                i += 1;
-                break;
-            case "--allowed-shell-commands":
-                options.allowedShellCommands = requireValue(argv, i, arg);
-                i += 1;
-                break;
-            case "--max-write-ops-per-minute":
-                options.maxWriteOpsPerMinute = requireValue(argv, i, arg);
-                i += 1;
-                break;
-            case "--max-git-pushes-per-hour":
-                options.maxGitPushesPerHour = requireValue(argv, i, arg);
-                i += 1;
-                break;
-            default:
-                throw new Error(`[aria] Unknown internal daemon arg: ${arg}`);
-        }
-    }
-    return options;
-}
-export async function runDaemonEntrypoint(argv) {
-    await runServerDaemonLauncherFromCli(parseDaemonArgs(argv));
-}
-//# sourceMappingURL=daemon.js.map