@cueai/omni-reader-mcp 1.0.2 → 1.1.1

package/dist/cli/arguments.d.ts

@@ -0,0 +1,32 @@
+import { type AgentTarget } from "./agent-config.js";
+export interface SetupArguments {
+    readonly client?: AgentTarget;
+    readonly allowedRoots: readonly string[];
+    readonly addRoots: readonly string[];
+    readonly yes: boolean;
+    readonly json: boolean;
+}
+export type ParsedCommand = {
+    readonly command: "server";
+} | {
+    readonly command: "help";
+} | {
+    readonly command: "version";
+} | {
+    readonly command: "setup";
+    readonly arguments: SetupArguments;
+} | {
+    readonly command: "doctor";
+    readonly json: boolean;
+} | {
+    readonly command: "clean";
+} | {
+    readonly command: "uninstall";
+    readonly yes: boolean;
+    readonly json: boolean;
+};
+export declare class CliUsageError extends Error {
+    readonly exitCode = 2;
+    constructor(message: string);
+}
+export declare function parseCliArguments(argv: readonly string[], platform?: NodeJS.Platform): ParsedCommand;

package/dist/cli/arguments.js

@@ -0,0 +1,120 @@
+import path from "node:path";
+import { parseAgentTarget } from "./agent-config.js";
+export class CliUsageError extends Error {
+    exitCode = 2;
+    constructor(message) {
+        super(message);
+        this.name = "CliUsageError";
+    }
+}
+function pathsFor(platform) {
+    return platform === "win32" ? path.win32 : path.posix;
+}
+function requireNoArguments(command, values) {
+    if (values.length > 0)
+        throw new CliUsageError(`${command} does not accept arguments.`);
+}
+function parseBooleanFlags(command, values, supported) {
+    const seen = new Set();
+    for (const value of values) {
+        if (!supported.has(value)) {
+            throw new CliUsageError(`Unknown ${command} flag: ${value}`);
+        }
+        if (seen.has(value)) {
+            throw new CliUsageError(`Duplicate ${command} flag: ${value}`);
+        }
+        seen.add(value);
+    }
+    return seen;
+}
+function parseSetupArguments(values, platform) {
+    let client;
+    let allowedRoot;
+    let addRoot;
+    let yes = false;
+    let json = false;
+    const seen = new Set();
+    const paths = pathsFor(platform);
+    for (let index = 0; index < values.length; index += 1) {
+        const flag = values[index];
+        if (!["--client", "--allowed-root", "--add-root", "--yes", "--json"].includes(flag)) {
+            throw new CliUsageError(`Unknown setup flag: ${flag}`);
+        }
+        if (seen.has(flag))
+            throw new CliUsageError(`Duplicate setup flag: ${flag}`);
+        seen.add(flag);
+        if (flag === "--yes") {
+            yes = true;
+            continue;
+        }
+        if (flag === "--json") {
+            json = true;
+            continue;
+        }
+        const raw = values[index + 1];
+        if (raw === undefined || raw.startsWith("--")) {
+            throw new CliUsageError(`${flag} requires a value.`);
+        }
+        index += 1;
+        if (flag === "--client") {
+            const parsed = parseAgentTarget(raw);
+            const normalized = raw.trim().toLowerCase();
+            if (parsed === "generic" &&
+                normalized !== "generic" &&
+                normalized !== "other")
+                throw new CliUsageError(`Unsupported Agent client: ${raw}`);
+            client = parsed;
+            continue;
+        }
+        if (!paths.isAbsolute(raw)) {
+            throw new CliUsageError(`${flag} requires an absolute path.`);
+        }
+        const normalized = paths.normalize(raw);
+        if (flag === "--allowed-root")
+            allowedRoot = normalized;
+        if (flag === "--add-root")
+            addRoot = normalized;
+    }
+    if (allowedRoot !== undefined && addRoot !== undefined) {
+        throw new CliUsageError("--allowed-root and --add-root cannot be combined.");
+    }
+    return {
+        ...(client === undefined ? {} : { client }),
+        allowedRoots: allowedRoot === undefined ? [] : [allowedRoot],
+        addRoots: addRoot === undefined ? [] : [addRoot],
+        yes,
+        json,
+    };
+}
+export function parseCliArguments(argv, platform = process.platform) {
+    if (argv.length === 0)
+        return { command: "server" };
+    const [command, ...values] = argv;
+    if (command === "--help" || command === "-h" || command === "help") {
+        requireNoArguments("help", values);
+        return { command: "help" };
+    }
+    if (command === "--version" || command === "-v") {
+        requireNoArguments("version", values);
+        return { command: "version" };
+    }
+    if (command === "setup") {
+        return { command: "setup", arguments: parseSetupArguments(values, platform) };
+    }
+    if (command === "doctor") {
+        const flags = parseBooleanFlags("doctor", values, new Set(["--json"]));
+        return { command: "doctor", json: flags.has("--json") };
+    }
+    if (command === "clean") {
+        requireNoArguments("clean", values);
+        return { command: "clean" };
+    }
+    if (command === "uninstall") {
+        const flags = parseBooleanFlags("uninstall", values, new Set(["--yes", "--json"]));
+        if (!flags.has("--yes") || !flags.has("--json")) {
+            throw new CliUsageError("Uninstall requires: uninstall --yes --json");
+        }
+        return { command: "uninstall", yes: true, json: true };
+    }
+    throw new CliUsageError(`Unknown command: ${command}`);
+}

package/dist/cli/doctor.d.ts

@@ -6,12 +6,53 @@ export interface HealthResult {
 export interface DoctorOptions extends AgentConfigEnvironment {
     readonly env: NodeJS.ProcessEnv;
     readonly artifactRoot: string;
+    readonly cacheMode: "default" | "fallback";
     readonly fetchImpl: typeof fetch;
     readonly nodeVersion?: string;
     readonly npmVersion?: string;
     readonly packageVersion?: string;
 }
+export interface DoctorReport {
+    readonly package_version: string;
+    readonly node_version: string;
+    readonly npm_version: string;
+    readonly client_adapters: Record<string, {
+        readonly status: AgentConfigStatusForReport;
+        readonly version?: string;
+    }>;
+    readonly api_key: {
+        readonly status: "present" | "absent";
+    };
+    readonly allowed_roots: {
+        readonly count: number;
+        readonly safe: boolean;
+    };
+    readonly endpoints: {
+        readonly url_control: string;
+        readonly direct_upload: string;
+    };
+    readonly artifacts: {
+        readonly count: number;
+        readonly bytes: number;
+        readonly earliest_expiry?: string;
+    };
+    readonly cache: {
+        readonly mode: "default" | "fallback";
+        readonly safe: true;
+    };
+    readonly onboarding: {
+        readonly status: "current";
+        readonly first_registration_credits: number;
+        readonly free_daily_credits: number;
+    } | {
+        readonly status: "unavailable";
+    };
+    readonly reload_required: boolean;
+}
+type AgentConfigStatusForReport = "configured" | "not configured" | "invalid or unreadable";
 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[]>;
+export declare function runDoctor(options: DoctorOptions): Promise<DoctorReport>;
+export declare function renderDoctor(report: DoctorReport): string[];
+export {};

package/dist/cli/doctor.js

@@ -1,10 +1,11 @@
 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, CUBE_GRANT_PROTOCOL_VERSION, } from "../constants.js";
+import { BRIDGE_RELEASE_VERSION, DEFAULT_CUBE_BASE_URL, GRANTED_STREAM_PROTOCOL_VERSION, MAX_FILE_BYTES, CUBE_GRANT_PROTOCOL_VERSION, } from "../constants.js";
+import { API_KEY_URL, getOnboardingPolicyWithTimeout, onboardingGuidance, } from "../onboarding-policy.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";
+const GRANTED_UPLOAD_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;
@@ -29,16 +30,16 @@ 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 !== CUBE_GRANT_PROTOCOL_VERSION) {
-        throw new Error("Cube direct upload is disabled or incompatible");
+        throw new Error("Omni URL control 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");
+    const granted = await fetchHealth(fetchImpl, GRANTED_UPLOAD_HEALTH_URL);
+    if (!granted.enabled || granted.protocol_version !== GRANTED_STREAM_PROTOCOL_VERSION) {
+        throw new Error("Omni direct upload is disabled or incompatible");
     }
-    return iiis.protocol_version;
+    return granted.protocol_version;
 }
 export async function checkHealth(fetchImpl, apiKey) {
     const [cubeProtocol, iiisProtocol] = await Promise.all([
@@ -83,7 +84,7 @@ async function artifactFacts(artifactRoot) {
     }
     catch (error) {
         if (error.code === "ENOENT") {
-            return { count: 0, bytes: 0, expiry: "none" };
+            return { count: 0, bytes: 0 };
         }
         throw error;
     }
@@ -108,50 +109,122 @@ async function artifactFacts(artifactRoot) {
             earliestExpiry = expiresAt;
         }
     }
-    const expiry = count === 0
-        ? "none"
-        : unknownExpiry || earliestExpiry === undefined
-            ? "unknown"
-            : new Date(earliestExpiry).toISOString();
-    return { count, bytes, expiry };
+    return {
+        count,
+        bytes,
+        ...(count > 0 && !unknownExpiry && earliestExpiry !== undefined
+            ? { expiry: new Date(earliestExpiry).toISOString() }
+            : {}),
+    };
 }
-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"}`,
-    ];
+function allowedRootFacts(options) {
+    const value = options.env.OMNI_ALLOWED_ROOTS?.trim() ?? "";
+    if (value === "")
+        return { count: 0, safe: true };
+    const paths = options.platform === "win32" ? path.win32 : path.posix;
+    const separator = options.platform === "win32" ? ";" : ":";
+    const roots = value.split(separator).filter((root) => root.length > 0);
+    return {
+        count: roots.length,
+        safe: roots.length > 0 && roots.every((root) => paths.isAbsolute(root)),
+    };
+}
+async function clientAdapterFacts(options) {
+    const result = {};
     for (const [label, target] of [
-        ["Cursor", "cursor"],
-        ["Claude Desktop", "claude-desktop"],
+        ["hermes", "hermes"],
+        ["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}`);
+            : await inspectAgentConfig(configPath, options, target);
+        result[label] = {
+            status,
+            ...(status === "configured" ? { version: BRIDGE_RELEASE_VERSION } : {}),
+        };
     }
+    return result;
+}
+export async function runDoctor(options) {
+    const [clientAdapters, artifacts, onboarding] = await Promise.all([
+        clientAdapterFacts(options),
+        artifactFacts(options.artifactRoot),
+        getOnboardingPolicyWithTimeout(options.fetchImpl),
+    ]);
+    let urlControl = "skipped (Cue API Key absent)";
     if (options.env.CUE_API_KEY) {
         try {
-            lines.push(`Cube protocol: ${await checkCubeHealth(options.fetchImpl, options.env.CUE_API_KEY)}`);
+            urlControl = await checkCubeHealth(options.fetchImpl, options.env.CUE_API_KEY);
         }
         catch {
-            lines.push("Cube health: unavailable or incompatible");
+            urlControl = "unavailable or incompatible";
         }
     }
-    else {
-        lines.push("Cube health: skipped (Cue API Key absent)");
-    }
+    let directUpload;
     try {
-        lines.push(`IIIS protocol: ${await checkIiisHealth(options.fetchImpl)}`);
+        directUpload = await checkIiisHealth(options.fetchImpl);
     }
     catch {
-        lines.push("IIIS health: unavailable or incompatible");
+        directUpload = "unavailable or incompatible";
+    }
+    return {
+        package_version: options.packageVersion ?? "unknown",
+        node_version: options.nodeVersion ?? process.version,
+        npm_version: options.npmVersion ?? "unavailable",
+        client_adapters: clientAdapters,
+        api_key: { status: options.env.CUE_API_KEY ? "present" : "absent" },
+        allowed_roots: allowedRootFacts(options),
+        endpoints: {
+            url_control: urlControl,
+            direct_upload: directUpload,
+        },
+        artifacts: {
+            count: artifacts.count,
+            bytes: artifacts.bytes,
+            ...(artifacts.expiry === undefined ? {} : { earliest_expiry: artifacts.expiry }),
+        },
+        cache: { mode: options.cacheMode, safe: true },
+        onboarding: onboarding === undefined
+            ? { status: "unavailable" }
+            : {
+                status: "current",
+                first_registration_credits: onboarding.firstRegistrationCredits,
+                free_daily_credits: onboarding.freeDailyCredits,
+            },
+        reload_required: false,
+    };
+}
+export function renderDoctor(report) {
+    const lines = [
+        `Node: ${report.node_version}`,
+        `npm: ${report.npm_version}`,
+        `Package: ${report.package_version}`,
+        `Cue API Key: ${report.api_key.status}`,
+        `Allowed roots: ${report.allowed_roots.count} (${report.allowed_roots.safe ? "safe" : "invalid"})`,
+    ];
+    for (const [label, key] of [
+        ["Hermes", "hermes"],
+        ["Cursor", "cursor"],
+        ["Claude Desktop", "claude_desktop"],
+    ]) {
+        lines.push(`${label} config: ${report.client_adapters[key].status}`);
+    }
+    lines.push(`Omni control protocol: ${report.endpoints.url_control}`);
+    lines.push(`Omni direct upload protocol: ${report.endpoints.direct_upload}`);
+    lines.push(`Artifacts: ${report.artifacts.count} file(s), ${report.artifacts.bytes} byte(s)`);
+    lines.push(`Artifact expiry: ${report.artifacts.earliest_expiry ?? (report.artifacts.count === 0 ? "none" : "unknown")}`);
+    lines.push(`Cache: ${report.cache.mode}`);
+    if (report.api_key.status === "absent") {
+        const policy = report.onboarding.status === "current"
+            ? {
+                apiKeyUrl: API_KEY_URL,
+                firstRegistrationCredits: report.onboarding.first_registration_credits,
+                freeDailyCredits: report.onboarding.free_daily_credits,
+            }
+            : undefined;
+        lines.push(...onboardingGuidance(policy).split("\n"));
     }
-    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

@@ -1,8 +1,11 @@
+import { type SetupArguments } from "./arguments.js";
 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;
+    readonly stdinIsTTY: boolean;
+    readonly arguments: SetupArguments;
 }
 export declare function runSetup(options: SetupOptions): Promise<void>;

package/dist/cli/setup.js

@@ -1,5 +1,8 @@
 import path from "node:path";
-import { detectAgentTargets, parseAgentTarget, prepareAgentConfig, verifyPreparedAgentConfig, writePreparedAgentConfig, } from "./agent-config.js";
+import { BRIDGE_RELEASE_VERSION } from "../constants.js";
+import { getOnboardingPolicyWithTimeout, onboardingGuidance, } from "../onboarding-policy.js";
+import { CliUsageError } from "./arguments.js";
+import { configuredAllowedRoots, detectAgentTargets, parseAgentTarget, prepareAgentConfig, rollbackPreparedAgentConfig, verifyPreparedAgentConfig, writePreparedAgentConfig, } from "./agent-config.js";
 import { checkHealth } from "./doctor.js";
 function parseExtraRoots(input, environment) {
     const separator = environment.platform === "win32" ? ";" : ":";
@@ -14,46 +17,128 @@ function parseExtraRoots(input, environment) {
                 ? paths.join(environment.homeDirectory, value.slice(2))
                 : value;
         if (!paths.isAbsolute(expanded)) {
-            throw new Error("Every additional allowed root must be an absolute path.");
+            throw new CliUsageError("Every additional allowed root must be an absolute path.");
         }
         return paths.normalize(expanded);
     });
 }
-export async function runSetup(options) {
-    const labels = { cursor: "Cursor", "claude-desktop": "Claude Desktop" };
+async function interactiveArguments(options) {
+    const labels = {
+        hermes: "Hermes",
+        cursor: "Cursor",
+        "claude-desktop": "Claude Desktop",
+    };
     const detected = await detectAgentTargets(options);
     const detectedLabel = detected.length === 0
         ? "none"
         : detected.map((target) => labels[target]).join(", ");
-    const selected = await options.ask(`Agent (Cursor / Claude Desktop / Other; Detected: ${detectedLabel}): `);
+    const selected = await options.ask(`Agent (Hermes / Cursor / Claude Desktop / Other; Detected: ${detectedLabel}): `);
     const target = parseAgentTarget(selected);
-    const extraRootInput = await options.ask("Additional allowed roots (optional): ");
-    const extraRoots = parseExtraRoots(extraRootInput, options);
-    const prepared = await prepareAgentConfig(target, extraRoots, options);
+    const rootInput = await options.ask("Additional allowed roots (optional): ");
+    return { target, roots: parseExtraRoots(rootInput, options) };
+}
+async function selectedTargetAndRoots(options) {
+    const requested = options.arguments;
+    if (requested.client === undefined) {
+        if (!options.stdinIsTTY) {
+            throw new CliUsageError("Non-interactive setup requires: setup --client hermes --allowed-root <absolute-path> --yes --json");
+        }
+        const selected = await interactiveArguments(options);
+        return { ...selected, interactive: true };
+    }
+    if (!options.stdinIsTTY && !requested.yes) {
+        throw new CliUsageError("Non-interactive setup requires --yes.");
+    }
+    const existing = await configuredAllowedRoots(requested.client, options);
+    const roots = requested.allowedRoots.length > 0
+        ? requested.allowedRoots
+        : requested.addRoots.length > 0
+            ? [...new Set([...existing, ...requested.addRoots])]
+            : existing;
+    return { target: requested.client, roots, interactive: !requested.yes };
+}
+function writePreview(options, prepared) {
     options.write(`Target: ${prepared.displayPath}\n`);
     options.write("Before:\n");
     options.write(`${JSON.stringify(prepared.before, null, 2)}\n`);
     options.write("After:\n");
     options.write(`${JSON.stringify(prepared.after, null, 2)}\n`);
+}
+async function confirmSetup(options, prepared, interactive) {
+    if (!interactive)
+        return true;
+    writePreview(options, prepared);
     const confirmation = (await options.ask("Apply this user-scope configuration? Type yes: ")).trim().toLowerCase();
-    if (confirmation !== "yes") {
-        options.write("No changes written.\n");
-        return;
-    }
-    await verifyPreparedAgentConfig(prepared);
+    if (confirmation === "yes")
+        return true;
+    options.write("No changes written.\n");
+    return false;
+}
+async function requireApiKey(options) {
     const apiKey = options.env.CUE_API_KEY ?? "";
-    if (apiKey.length === 0) {
-        throw new Error("CUE_API_KEY is absent. Create one at https://cuecue.cn/hub/api-key and retry.");
+    if (apiKey.length > 0)
+        return apiKey;
+    const policy = await getOnboardingPolicyWithTimeout(options.fetchImpl);
+    throw new Error(onboardingGuidance(policy));
+}
+async function validateConfiguredEnvironment(options, prepared, apiKey) {
+    try {
+        await checkHealth(options.fetchImpl, apiKey);
+    }
+    catch {
+        try {
+            await rollbackPreparedAgentConfig(prepared);
+        }
+        catch {
+            throw new Error("Omni 安全解析环境验证失败，且无法确认 Agent 配置已自动恢复；请停止重试并检查 user-scope 配置。");
+        }
+        throw new Error("Omni 安全解析环境验证失败；原 Agent 配置已自动恢复。");
+    }
+}
+function writeSuccess(options, prepared, roots) {
+    if (options.arguments.json) {
+        options.write(`${JSON.stringify({
+            status: prepared.configPath === undefined ? "manual_configuration" : "configured",
+            target: prepared.target,
+            package: "@cueai/omni-reader-mcp",
+            version: BRIDGE_RELEASE_VERSION,
+            config_path: prepared.displayPath,
+            allowed_roots: roots.length,
+            reload: prepared.reload,
+        })}\n`);
+        return;
     }
     options.write("Cue API Key: present\n");
-    await checkHealth(options.fetchImpl, apiKey);
     if (prepared.configPath === undefined) {
         options.write("Generic user-scope configuration:\n");
-        options.write(`${JSON.stringify({ mcpServers: { "omni-reader": prepared.entry } }, null, 2)}\n`);
+        options.write(`${JSON.stringify({
+            mcpServers: { "omni-reader": prepared.entry },
+        }, null, 2)}\n`);
     }
     else {
-        await writePreparedAgentConfig(prepared);
         options.write(`Wrote ${prepared.displayPath}\n`);
+        options.write(`${prepared.reload}\n`);
     }
     options.write("用 Omni 解析 ./report.pdf\n");
 }
+export async function runSetup(options) {
+    const selected = await selectedTargetAndRoots(options);
+    const prepared = await prepareAgentConfig(selected.target, selected.roots, options);
+    if (!await confirmSetup(options, prepared, selected.interactive))
+        return;
+    await verifyPreparedAgentConfig(prepared);
+    const apiKey = await requireApiKey(options);
+    if (prepared.configPath === undefined) {
+        try {
+            await checkHealth(options.fetchImpl, apiKey);
+        }
+        catch {
+            throw new Error("Omni 安全解析环境验证失败；未写入 Agent 配置。");
+        }
+    }
+    else {
+        await writePreparedAgentConfig(prepared);
+        await validateConfiguredEnvironment(options, prepared, apiKey);
+    }
+    writeSuccess(options, prepared, selected.roots);
+}

package/dist/cli/uninstall.d.ts

@@ -0,0 +1,6 @@
+import { type AgentConfigEnvironment } from "./agent-config.js";
+export interface UninstallOptions extends AgentConfigEnvironment {
+    readonly args: readonly string[];
+    readonly write: (text: string) => void;
+}
+export declare function runUninstall(options: UninstallOptions): Promise<void>;

package/dist/cli/uninstall.js

@@ -0,0 +1,37 @@
+import { uninstallAgentConfig, } from "./agent-config.js";
+export async function runUninstall(options) {
+    const flags = [...options.args].sort();
+    if (flags.length !== 2 ||
+        flags[0] !== "--json" ||
+        flags[1] !== "--yes") {
+        throw new Error("Uninstall requires: uninstall --yes --json");
+    }
+    const results = [];
+    for (const target of ["hermes", "cursor", "claude-desktop"]) {
+        const result = await uninstallAgentConfig(target, options);
+        if (result !== undefined)
+            results.push(result);
+    }
+    if (results.length === 0) {
+        options.write(`${JSON.stringify({
+            status: "not_installed",
+            restored_remote: false,
+            artifacts_preserved: true,
+            source_files_unchanged: true,
+        })}\n`);
+        return;
+    }
+    const response = {
+        status: "uninstalled",
+        restored_remote: results.every((result) => result.restoredRemote),
+        artifacts_preserved: true,
+        source_files_unchanged: true,
+    };
+    if (results.length === 1) {
+        response.target = results[0].target;
+    }
+    else {
+        response.targets = results.map((result) => result.target);
+    }
+    options.write(`${JSON.stringify(response)}\n`);
+}

package/dist/constants.d.ts

@@ -5,3 +5,10 @@ export declare const RESULT_CHUNK_MAX_BYTES = 65536;
 export declare const CUBE_GRANT_PROTOCOL_VERSION = "omni.parse_grant.v1";
 export declare const GRANTED_STREAM_PROTOCOL_VERSION = "omni.granted_parse_stream.v1";
 export declare const DEFAULT_CUBE_BASE_URL = "https://mcp.cuecue.cn";
+export declare const DEFAULT_IIIS_GRANTED_BASE_URL = "https://cubefile.ai.iiis.co:9443/omni/granted/";
+export declare const BRIDGE_RELEASE_VERSION = "1.1.1";
+export declare const REMOTE_OMNI_MCP_URL = "https://mcp.cuecue.cn/api/omni-reader/mcp/";
+export declare const FOREGROUND_BUDGET_MS = 15000;
+export declare const STATUS_LONG_POLL_MAX_MS = 20000;
+export declare const STATUS_POLL_AFTER_SECONDS = 5;
+export declare const DELIVERY_TTL_SECONDS = 600;

package/dist/constants.js

@@ -5,3 +5,10 @@ export const RESULT_CHUNK_MAX_BYTES = 65536;
 export const CUBE_GRANT_PROTOCOL_VERSION = "omni.parse_grant.v1";
 export const GRANTED_STREAM_PROTOCOL_VERSION = "omni.granted_parse_stream.v1";
 export const DEFAULT_CUBE_BASE_URL = "https://mcp.cuecue.cn";
+export const DEFAULT_IIIS_GRANTED_BASE_URL = "https://cubefile.ai.iiis.co:9443/omni/granted/";
+export const BRIDGE_RELEASE_VERSION = "1.1.1";
+export const REMOTE_OMNI_MCP_URL = "https://mcp.cuecue.cn/api/omni-reader/mcp/";
+export const FOREGROUND_BUDGET_MS = 15_000;
+export const STATUS_LONG_POLL_MAX_MS = 20_000;
+export const STATUS_POLL_AFTER_SECONDS = 5;
+export const DELIVERY_TTL_SECONDS = 600;

package/dist/cube-client.d.ts

@@ -1,6 +1,6 @@
+import { BRIDGE_RELEASE_VERSION } from "./constants.js";
 import { OperationJournal } from "./operation-journal.js";
 declare const BRIDGE_PACKAGE = "@cueai/omni-reader-mcp";
-declare const BRIDGE_VERSION = "1.0.2";
 export interface GrantRequestInput {
     readonly contentLength: number;
     readonly contentType: string;
@@ -35,7 +35,7 @@ interface GrantRequestBody {
     readonly output: "markdown";
     readonly bridge: {
         readonly package: typeof BRIDGE_PACKAGE;
-        readonly version: typeof BRIDGE_VERSION;
+        readonly version: typeof BRIDGE_RELEASE_VERSION;
     };
 }
 export declare function grantRequestHash(body: GrantRequestBody): string;
@@ -43,6 +43,8 @@ export declare function createClientRequestId(): string;
 export declare class CubeGrantClient {
     #private;
     constructor(options: CubeGrantClientOptions);
-    createGrant(input: GrantRequestInput, clientRequestId: string, signal?: AbortSignal): Promise<GrantedOperation>;
+    createGrant(input: GrantRequestInput, clientRequestId: string, signal?: AbortSignal, options?: {
+        journal?: boolean;
+    }): Promise<GrantedOperation>;
 }
 export {};