@cueai/omni-reader-mcp 1.0.0

package/dist/cli/agent-config.d.ts

@@ -0,0 +1,28 @@
+export type AgentTarget = "cursor" | "claude-desktop" | "generic";
+export interface AgentConfigEnvironment {
+    readonly homeDirectory: string;
+    readonly platform: NodeJS.Platform;
+    readonly env?: Readonly<Record<string, string | undefined>>;
+}
+export type AgentConfigStatus = "configured" | "not configured" | "invalid or unreadable";
+export interface PreparedAgentConfig {
+    readonly target: AgentTarget;
+    readonly configPath?: string;
+    readonly displayPath: string;
+    readonly existed: boolean;
+    readonly before: Record<string, unknown>;
+    readonly after: Record<string, unknown>;
+    readonly entry: Record<string, unknown>;
+    readonly sourceFingerprint?: string;
+    readonly environment?: AgentConfigEnvironment;
+}
+export declare function parseAgentTarget(value: string): AgentTarget;
+export declare function agentConfigPath(target: AgentTarget, environment: AgentConfigEnvironment): string | undefined;
+export declare function displayConfigPath(configPath: string, environment: AgentConfigEnvironment): string;
+export declare function buildAgentEntry(extraRoots: readonly string[], platform: NodeJS.Platform): Record<string, unknown>;
+export declare function prepareAgentConfig(target: AgentTarget, extraRoots: readonly string[], environment: AgentConfigEnvironment): Promise<PreparedAgentConfig>;
+export declare function verifyPreparedAgentConfig(prepared: PreparedAgentConfig): Promise<void>;
+export declare function writePreparedAgentConfig(prepared: PreparedAgentConfig): Promise<void>;
+export declare function inspectAgentConfig(configPath: string, environment?: AgentConfigEnvironment): Promise<AgentConfigStatus>;
+export declare function detectAgentTargets(environment: AgentConfigEnvironment): Promise<Array<Exclude<AgentTarget, "generic">>>;
+export declare function configContainsOmni(configPath: string): Promise<boolean>;

package/dist/cli/agent-config.js

@@ -0,0 +1,335 @@
+import { createHash, randomBytes } from "node:crypto";
+import { constants as fsConstants } from "node:fs";
+import { chmod, lstat, mkdir, open, rename, } from "node:fs/promises";
+import path from "node:path";
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function fileError(message) {
+    const error = new Error(message);
+    error.name = "AgentConfigError";
+    return error;
+}
+function pathModule(platform) {
+    return platform === "win32" ? path.win32 : path.posix;
+}
+export function parseAgentTarget(value) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "cursor")
+        return "cursor";
+    if (normalized === "claude desktop" || normalized === "claude" || normalized === "claude-desktop") {
+        return "claude-desktop";
+    }
+    return "generic";
+}
+export function agentConfigPath(target, environment) {
+    const paths = pathModule(environment.platform);
+    if (target === "cursor") {
+        return paths.join(environment.homeDirectory, ".cursor", "mcp.json");
+    }
+    if (target === "claude-desktop") {
+        if (environment.platform === "darwin") {
+            return paths.join(environment.homeDirectory, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+        }
+        if (environment.platform === "win32") {
+            const appData = environment.env?.APPDATA?.trim()
+                || paths.join(environment.homeDirectory, "AppData", "Roaming");
+            return paths.join(appData, "Claude", "claude_desktop_config.json");
+        }
+        return undefined;
+    }
+    return undefined;
+}
+export function displayConfigPath(configPath, environment) {
+    const paths = pathModule(environment.platform);
+    const relative = paths.relative(environment.homeDirectory, configPath);
+    if (relative !== "" && relative !== ".." && !relative.startsWith(`..${paths.sep}`)) {
+        return `~/${relative.split(paths.sep).join("/")}`;
+    }
+    return configPath;
+}
+export function buildAgentEntry(extraRoots, platform) {
+    const entry = {
+        command: "npx",
+        args: ["-y", "@cue/omni-reader-mcp"],
+    };
+    if (extraRoots.length > 0) {
+        entry.env = {
+            OMNI_ALLOWED_ROOTS: extraRoots.join(platform === "win32" ? ";" : ":"),
+        };
+    }
+    return entry;
+}
+function containsPath(parent, child, paths) {
+    const relative = paths.relative(parent, child);
+    return relative === "" || (relative !== ".." && !relative.startsWith(`..${paths.sep}`));
+}
+async function validateUserConfigPath(configPath, environment) {
+    const paths = pathModule(environment.platform);
+    const homeDirectory = paths.resolve(environment.homeDirectory);
+    const userRoots = [homeDirectory];
+    if (environment.platform === "win32" && environment.env?.APPDATA?.trim()) {
+        userRoots.push(paths.resolve(environment.env.APPDATA));
+    }
+    const resolvedConfigPath = paths.resolve(configPath);
+    const userRoot = userRoots.find((root) => containsPath(root, resolvedConfigPath, paths));
+    if (userRoot === undefined) {
+        throw fileError("The Agent configuration path is outside the user profile; no changes were written.");
+    }
+    const relativeParent = paths.relative(userRoot, paths.dirname(resolvedConfigPath));
+    const components = relativeParent === "" ? [] : relativeParent.split(paths.sep);
+    let current = userRoot;
+    for (const component of ["", ...components]) {
+        if (component !== "")
+            current = paths.join(current, component);
+        try {
+            const details = await lstat(current);
+            if (!details.isDirectory() || details.isSymbolicLink()) {
+                throw fileError("The Agent configuration path contains an unsafe directory; no changes were written.");
+            }
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                break;
+            throw error;
+        }
+    }
+    try {
+        const details = await lstat(resolvedConfigPath);
+        if (!details.isFile() || details.isSymbolicLink()) {
+            throw fileError("The existing Agent configuration is unsafe; no changes were written.");
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+}
+function configFingerprint(loaded) {
+    if (!loaded.existed || loaded.serialized === undefined)
+        return "missing";
+    return `sha256:${createHash("sha256").update(loaded.serialized).digest("hex")}`;
+}
+async function readConfig(configPath) {
+    let handle;
+    try {
+        handle = await open(configPath, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT")
+            return { existed: false, value: {} };
+        if (code === "ELOOP" || code === "EMLINK") {
+            throw fileError("The existing Agent configuration is unsafe; no changes were written.");
+        }
+        throw fileError("The existing Agent configuration could not be read.");
+    }
+    let serialized;
+    try {
+        const details = await handle.stat();
+        if (!details.isFile()) {
+            throw fileError("The existing Agent configuration is unsafe; no changes were written.");
+        }
+        serialized = await handle.readFile("utf8");
+    }
+    finally {
+        await handle.close();
+    }
+    try {
+        const parsed = JSON.parse(serialized);
+        if (!isRecord(parsed))
+            throw new Error("configuration is not an object");
+        return { existed: true, value: parsed, serialized };
+    }
+    catch {
+        throw fileError("The existing Agent configuration is malformed JSON; no changes were written.");
+    }
+}
+export async function prepareAgentConfig(target, extraRoots, environment) {
+    const configPath = agentConfigPath(target, environment);
+    const entry = buildAgentEntry(extraRoots, environment.platform);
+    if (configPath === undefined) {
+        return {
+            target: "generic",
+            displayPath: "Generic user-scope configuration",
+            existed: false,
+            before: {},
+            after: { mcpServers: { "omni-reader": entry } },
+            entry,
+        };
+    }
+    await validateUserConfigPath(configPath, environment);
+    const loaded = await readConfig(configPath);
+    const existingServers = loaded.value.mcpServers;
+    if (existingServers !== undefined && !isRecord(existingServers)) {
+        throw fileError("The existing mcpServers setting is not an object; no changes were written.");
+    }
+    const after = {
+        ...loaded.value,
+        mcpServers: {
+            ...(existingServers ?? {}),
+            "omni-reader": entry,
+        },
+    };
+    return {
+        target,
+        configPath,
+        displayPath: displayConfigPath(configPath, environment),
+        existed: loaded.existed,
+        before: loaded.value,
+        after,
+        entry,
+        sourceFingerprint: configFingerprint(loaded),
+        environment,
+    };
+}
+async function syncDirectory(directory) {
+    let handle;
+    try {
+        handle = await open(directory, "r");
+        await handle.sync();
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== "EINVAL" && code !== "ENOTSUP" && code !== "EISDIR")
+            throw error;
+    }
+    finally {
+        await handle?.close();
+    }
+}
+async function atomicReplace(filePath, content) {
+    const directory = path.dirname(filePath);
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    await chmod(directory, 0o700);
+    const temporaryPath = path.join(directory, `.${path.basename(filePath)}.${randomBytes(18).toString("base64url")}.tmp`);
+    let handle;
+    try {
+        handle = await open(temporaryPath, "wx", 0o600);
+        await handle.writeFile(content, "utf8");
+        await handle.sync();
+        await handle.close();
+        handle = undefined;
+        await rename(temporaryPath, filePath);
+        await chmod(filePath, 0o600);
+        await syncDirectory(directory);
+    }
+    finally {
+        await handle?.close();
+        await import("node:fs/promises").then(({ unlink }) => unlink(temporaryPath).catch(() => undefined));
+    }
+}
+async function withConfigLock(configPath, action) {
+    const directory = path.dirname(configPath);
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    await chmod(directory, 0o700);
+    const lockPath = `${configPath}.omni-reader.lock`;
+    let handle;
+    try {
+        handle = await open(lockPath, "wx", 0o600);
+    }
+    catch (error) {
+        if (error.code === "EEXIST") {
+            throw fileError("Another Omni setup is updating this Agent configuration; retry after it finishes.");
+        }
+        throw error;
+    }
+    try {
+        await handle.writeFile(`${process.pid}\n`, "utf8");
+        await handle.sync();
+        return await action();
+    }
+    finally {
+        await handle.close();
+        await import("node:fs/promises").then(({ unlink }) => unlink(lockPath).catch(() => undefined));
+        await syncDirectory(directory);
+    }
+}
+export async function verifyPreparedAgentConfig(prepared) {
+    if (prepared.configPath === undefined
+        || prepared.environment === undefined
+        || prepared.sourceFingerprint === undefined)
+        return;
+    await validateUserConfigPath(prepared.configPath, prepared.environment);
+    const current = await readConfig(prepared.configPath);
+    if (configFingerprint(current) !== prepared.sourceFingerprint) {
+        throw fileError("The Agent configuration changed after preview; no changes were written.");
+    }
+}
+export async function writePreparedAgentConfig(prepared) {
+    if (prepared.configPath === undefined)
+        return;
+    await withConfigLock(prepared.configPath, async () => {
+        await verifyPreparedAgentConfig(prepared);
+        const current = await readConfig(prepared.configPath);
+        if (prepared.existed && current.serialized !== undefined) {
+            await atomicReplace(`${prepared.configPath}.bak`, current.serialized);
+        }
+        await atomicReplace(prepared.configPath, `${JSON.stringify(prepared.after, null, 2)}\n`);
+    });
+}
+function isExpectedOmniEntry(value) {
+    if (!isRecord(value))
+        return false;
+    const keys = Object.keys(value).sort();
+    const args = value.args;
+    if (value.command !== "npx"
+        || !Array.isArray(args)
+        || args.length !== 2
+        || args[0] !== "-y"
+        || args[1] !== "@cue/omni-reader-mcp")
+        return false;
+    if (value.env === undefined) {
+        return keys.length === 2 && keys[0] === "args" && keys[1] === "command";
+    }
+    if (!isRecord(value.env))
+        return false;
+    const envKeys = Object.keys(value.env);
+    return keys.length === 3
+        && keys[0] === "args"
+        && keys[1] === "command"
+        && keys[2] === "env"
+        && envKeys.length === 1
+        && envKeys[0] === "OMNI_ALLOWED_ROOTS"
+        && typeof value.env.OMNI_ALLOWED_ROOTS === "string"
+        && value.env.OMNI_ALLOWED_ROOTS.length > 0;
+}
+export async function inspectAgentConfig(configPath, environment) {
+    try {
+        if (environment !== undefined)
+            await validateUserConfigPath(configPath, environment);
+        const loaded = await readConfig(configPath);
+        if (!loaded.existed)
+            return "not configured";
+        if (!isRecord(loaded.value.mcpServers))
+            return "not configured";
+        const entry = loaded.value.mcpServers["omni-reader"];
+        if (entry === undefined)
+            return "not configured";
+        return isExpectedOmniEntry(entry) ? "configured" : "invalid or unreadable";
+    }
+    catch {
+        return "invalid or unreadable";
+    }
+}
+export async function detectAgentTargets(environment) {
+    const detected = [];
+    for (const target of ["cursor", "claude-desktop"]) {
+        const configPath = agentConfigPath(target, environment);
+        if (configPath === undefined)
+            continue;
+        try {
+            await validateUserConfigPath(configPath, environment);
+            const details = await lstat(configPath);
+            if (details.isFile() && !details.isSymbolicLink())
+                detected.push(target);
+        }
+        catch {
+            // Unsafe or absent candidates are not advertised as detected.
+        }
+    }
+    return detected;
+}
+export async function configContainsOmni(configPath) {
+    return await inspectAgentConfig(configPath) === "configured";
+}

package/dist/cli/clean.d.ts

@@ -0,0 +1,9 @@
+export interface CleanOptions {
+    readonly artifactRoot: string;
+    readonly projectDirectory: string;
+    readonly now?: () => Date;
+}
+export interface CleanResult {
+    readonly removed: number;
+}
+export declare function runClean(options: CleanOptions): Promise<CleanResult>;

package/dist/cli/clean.js

@@ -0,0 +1,93 @@
+import { lstat, mkdir, readFile, readdir, realpath, unlink, } from "node:fs/promises";
+import path from "node:path";
+import { ARTIFACT_TTL_MS } from "../constants.js";
+function containsPath(parent, child) {
+    const relative = path.relative(parent, child);
+    return relative === "" || (relative !== ".." && !relative.startsWith(`..${path.sep}`));
+}
+async function remove(filePath) {
+    try {
+        await unlink(filePath);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export async function runClean(options) {
+    const requestedRoot = path.resolve(options.artifactRoot);
+    const project = await realpath(options.projectDirectory);
+    await mkdir(requestedRoot, { recursive: true, mode: 0o700 });
+    const rootDetails = await lstat(requestedRoot);
+    if (!rootDetails.isDirectory() || rootDetails.isSymbolicLink()) {
+        throw new Error("The Bridge cache root is unsafe; nothing was deleted.");
+    }
+    const root = await realpath(requestedRoot);
+    if (containsPath(project, root) || containsPath(root, project)) {
+        throw new Error("The Bridge cache root overlaps the project; nothing was deleted.");
+    }
+    let removed = 0;
+    const now = (options.now ?? (() => new Date()))().getTime();
+    const results = path.join(root, "results");
+    try {
+        const resultDetails = await lstat(results);
+        if (!resultDetails.isDirectory() || resultDetails.isSymbolicLink()) {
+            throw new Error("The Bridge results directory is unsafe; nothing was deleted.");
+        }
+        for (const entry of await readdir(results, { withFileTypes: true })) {
+            if (!entry.isFile() && !entry.isSymbolicLink())
+                continue;
+            const entryPath = path.join(results, entry.name);
+            if (/^result_[A-Za-z0-9_-]{16,64}\.(?:data|json)$/u.test(entry.name)) {
+                if (await remove(entryPath))
+                    removed += 1;
+                continue;
+            }
+            if (/^\.tmp-[A-Za-z0-9_-]+$/u.test(entry.name)) {
+                const details = await lstat(entryPath);
+                if (details.mtimeMs + ARTIFACT_TTL_MS <= now && await remove(entryPath))
+                    removed += 1;
+            }
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    for (const entry of await readdir(root, { withFileTypes: true })) {
+        if (!entry.isFile() && !entry.isSymbolicLink())
+            continue;
+        const entryPath = path.join(root, entry.name);
+        if (/^\..+\.tmp$/u.test(entry.name)) {
+            const details = await lstat(entryPath);
+            if (details.mtimeMs + ARTIFACT_TTL_MS <= now && await remove(entryPath))
+                removed += 1;
+            continue;
+        }
+        const match = /^([0-9a-f]{64})\.issued\.json$/u.exec(entry.name);
+        if (match === null || entry.isSymbolicLink())
+            continue;
+        try {
+            const value = JSON.parse(await readFile(entryPath, "utf8"));
+            if (!isRecord(value) || value.state !== "GRANT_ISSUED" || typeof value.expiresAt !== "string") {
+                continue;
+            }
+            const expiresAt = Date.parse(value.expiresAt);
+            if (Number.isFinite(expiresAt) && expiresAt + ARTIFACT_TTL_MS <= now) {
+                if (await remove(entryPath))
+                    removed += 1;
+                if (await remove(path.join(root, `${match[1]}.json`)))
+                    removed += 1;
+            }
+        }
+        catch {
+            // Preserve malformed or unreadable journals for explicit diagnosis.
+        }
+    }
+    return { removed };
+}

package/dist/cli/doctor.d.ts

@@ -0,0 +1,17 @@
+import { type AgentConfigEnvironment } from "./agent-config.js";
+export interface HealthResult {
+    readonly cubeProtocol: string;
+    readonly iiisProtocol: string;
+}
+export interface DoctorOptions extends AgentConfigEnvironment {
+    readonly env: NodeJS.ProcessEnv;
+    readonly artifactRoot: string;
+    readonly fetchImpl: typeof fetch;
+    readonly nodeVersion?: string;
+    readonly npmVersion?: string;
+    readonly packageVersion?: string;
+}
+export declare function checkCubeHealth(fetchImpl: typeof fetch, apiKey: string): Promise<string>;
+export declare function checkIiisHealth(fetchImpl: typeof fetch): Promise<string>;
+export declare function checkHealth(fetchImpl: typeof fetch, apiKey: string): Promise<HealthResult>;
+export declare function runDoctor(options: DoctorOptions): Promise<string[]>;

package/dist/cli/doctor.js

@@ -0,0 +1,157 @@
+import { constants as fsConstants } from "node:fs";
+import { lstat, open, readdir } from "node:fs/promises";
+import path from "node:path";
+import { DEFAULT_CUBE_BASE_URL, GRANTED_STREAM_PROTOCOL_VERSION, MAX_FILE_BYTES, PROTOCOL_VERSION, } from "../constants.js";
+import { agentConfigPath, inspectAgentConfig, } from "./agent-config.js";
+const CUBE_HEALTH_PATH = "/api/omni-reader/direct-upload/v1/health";
+const IIIS_HEALTH_URL = "https://cubefile.ai.iiis.co:9443/omni/granted/health";
+function isHealthBody(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const record = value;
+    return typeof record.enabled === "boolean"
+        && typeof record.protocol_version === "string"
+        && record.max_bytes === MAX_FILE_BYTES;
+}
+async function fetchHealth(fetchImpl, url, authorization) {
+    const response = await fetchImpl(url, {
+        method: "GET",
+        headers: authorization === undefined ? undefined : { authorization },
+    });
+    if (!response.ok)
+        throw new Error(`health endpoint returned ${response.status}`);
+    const body = await response.json();
+    if (!isHealthBody(body))
+        throw new Error("health endpoint returned an invalid response");
+    return body;
+}
+export async function checkCubeHealth(fetchImpl, apiKey) {
+    const cubeUrl = new URL(CUBE_HEALTH_PATH, DEFAULT_CUBE_BASE_URL).toString();
+    const cube = await fetchHealth(fetchImpl, cubeUrl, `Bearer ${apiKey}`);
+    if (!cube.enabled || cube.protocol_version !== PROTOCOL_VERSION) {
+        throw new Error("Cube direct upload is disabled or incompatible");
+    }
+    return cube.protocol_version;
+}
+export async function checkIiisHealth(fetchImpl) {
+    const iiis = await fetchHealth(fetchImpl, IIIS_HEALTH_URL);
+    if (!iiis.enabled || iiis.protocol_version !== GRANTED_STREAM_PROTOCOL_VERSION) {
+        throw new Error("IIIS granted upload is disabled or incompatible");
+    }
+    return iiis.protocol_version;
+}
+export async function checkHealth(fetchImpl, apiKey) {
+    const [cubeProtocol, iiisProtocol] = await Promise.all([
+        checkCubeHealth(fetchImpl, apiKey),
+        checkIiisHealth(fetchImpl),
+    ]);
+    return { cubeProtocol, iiisProtocol };
+}
+async function artifactExpiry(metadataPath, resultId) {
+    let handle;
+    try {
+        handle = await open(metadataPath, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        const details = await handle.stat();
+        if (!details.isFile())
+            return undefined;
+        const value = JSON.parse(await handle.readFile("utf8"));
+        if (value === null || typeof value !== "object" || Array.isArray(value))
+            return undefined;
+        const metadata = value;
+        if (metadata.resultId !== resultId || typeof metadata.expiresAt !== "string")
+            return undefined;
+        const expiresAt = Date.parse(metadata.expiresAt);
+        return Number.isFinite(expiresAt) ? expiresAt : undefined;
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function artifactFacts(artifactRoot) {
+    const resultsDirectory = path.join(artifactRoot, "results");
+    let entries;
+    try {
+        entries = await readdir(resultsDirectory, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return { count: 0, bytes: 0, expiry: "none" };
+        }
+        throw error;
+    }
+    let count = 0;
+    let bytes = 0;
+    let earliestExpiry;
+    let unknownExpiry = false;
+    for (const entry of entries) {
+        const match = /^(result_[A-Za-z0-9_-]{16,64})\.data$/u.exec(entry.name);
+        if (!entry.isFile() || match === null)
+            continue;
+        const details = await lstat(path.join(resultsDirectory, entry.name));
+        if (!details.isFile() || details.isSymbolicLink())
+            continue;
+        count += 1;
+        bytes += details.size;
+        const expiresAt = await artifactExpiry(path.join(resultsDirectory, `${match[1]}.json`), match[1]);
+        if (expiresAt === undefined) {
+            unknownExpiry = true;
+        }
+        else if (earliestExpiry === undefined || expiresAt < earliestExpiry) {
+            earliestExpiry = expiresAt;
+        }
+    }
+    const expiry = count === 0
+        ? "none"
+        : unknownExpiry || earliestExpiry === undefined
+            ? "unknown"
+            : new Date(earliestExpiry).toISOString();
+    return { count, bytes, expiry };
+}
+export async function runDoctor(options) {
+    const lines = [
+        `Node: ${options.nodeVersion ?? process.version}`,
+        `npm: ${options.npmVersion ?? "unavailable"}`,
+        `Package: ${options.packageVersion ?? "unknown"}`,
+        `Cue API Key: ${options.env.CUE_API_KEY ? "present" : "absent"}`,
+        `Allowed roots: ${options.env.OMNI_ALLOWED_ROOTS || "none"}`,
+    ];
+    for (const [label, target] of [
+        ["Cursor", "cursor"],
+        ["Claude Desktop", "claude-desktop"],
+    ]) {
+        const configPath = agentConfigPath(target, options);
+        const status = configPath === undefined
+            ? "not configured"
+            : await inspectAgentConfig(configPath, options);
+        lines.push(`${label} config: ${status}`);
+    }
+    if (options.env.CUE_API_KEY) {
+        try {
+            lines.push(`Cube protocol: ${await checkCubeHealth(options.fetchImpl, options.env.CUE_API_KEY)}`);
+        }
+        catch {
+            lines.push("Cube health: unavailable or incompatible");
+        }
+    }
+    else {
+        lines.push("Cube health: skipped (Cue API Key absent)");
+    }
+    try {
+        lines.push(`IIIS protocol: ${await checkIiisHealth(options.fetchImpl)}`);
+    }
+    catch {
+        lines.push("IIIS health: unavailable or incompatible");
+    }
+    const artifacts = await artifactFacts(options.artifactRoot);
+    lines.push(`Artifacts: ${artifacts.count} file(s), ${artifacts.bytes} byte(s)`);
+    lines.push(`Artifact expiry: ${artifacts.expiry}`);
+    return lines;
+}

package/dist/cli/setup.d.ts

@@ -0,0 +1,8 @@
+import { type AgentConfigEnvironment } from "./agent-config.js";
+export interface SetupOptions extends AgentConfigEnvironment {
+    readonly env: NodeJS.ProcessEnv;
+    readonly fetchImpl: typeof fetch;
+    readonly ask: (question: string) => Promise<string>;
+    readonly write: (text: string) => void;
+}
+export declare function runSetup(options: SetupOptions): Promise<void>;