@cueai/omni-reader-mcp 1.0.2 → 1.1.1

package/dist/index.js

@@ -1,27 +1,33 @@
 #!/usr/bin/env node
 import { execFile as execFileCallback } from "node:child_process";
 import { readFile, realpath } from "node:fs/promises";
+import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { createInterface } from "node:readline/promises";
 import { stdin, stdout as processStdout } from "node:process";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { ArtifactStore, defaultArtifactRoot } from "./artifact-store.js";
+import { ArtifactStore, selectArtifactRoot, } from "./artifact-store.js";
+import { CliUsageError, parseCliArguments } from "./cli/arguments.js";
 import { runClean } from "./cli/clean.js";
-import { runDoctor } from "./cli/doctor.js";
+import { renderDoctor, runDoctor } from "./cli/doctor.js";
 import { runSetup } from "./cli/setup.js";
+import { runUninstall } from "./cli/uninstall.js";
 import { CubeGrantClient } from "./cube-client.js";
 import { IiisClient } from "./iiis-client.js";
+import { createLocalParseOperationManager } from "./operation-manager.js";
 import { OperationJournal } from "./operation-journal.js";
 import { splitAllowedRoots } from "./path-security.js";
+import { HttpRemoteOmniClient } from "./remote-client.js";
 import { createOmniMcpServer } from "./server.js";
 function helpText() {
     return [
-        "Usage: omni-reader-mcp [setup|doctor|clean|--help|--version]",
+        "Usage: omni-reader-mcp [setup|doctor|clean|uninstall|--help|--version]",
         "",
         "No arguments start the stdio MCP server.",
         "setup   Configure a supported user-scope Agent",
         "doctor  Check local configuration and protocol health",
         "clean   Delete Bridge-created local artifacts and expired records",
+        "uninstall Restore a trusted URL-only Agent entry without deleting artifacts",
         "",
     ].join("\n");
 }
@@ -60,16 +66,26 @@ async function installedNpmVersion(env) {
         });
     });
 }
+async function artifactSelectionFor(options, env, homeDirectory, cwd, platform) {
+    if (options.artifactRoot !== undefined) {
+        return { mode: "default", rootDirectory: options.artifactRoot };
+    }
+    return await selectArtifactRoot({
+        platform,
+        homeDirectory,
+        env,
+        projectDirectory: cwd,
+        temporaryDirectory: options.temporaryDirectory ?? tmpdir(),
+    });
+}
 export async function startStdioServer(options = {}) {
     const env = options.env ?? process.env;
+    const homeDirectory = options.homeDirectory ?? (await import("node:os")).homedir();
     const cwd = options.cwd ?? process.cwd();
-    const artifactRoot = options.artifactRoot ?? defaultArtifactRoot({
-        platform: options.platform,
-        homeDirectory: options.homeDirectory,
-        env,
-    });
+    const platform = options.platform ?? process.platform;
+    const artifactSelection = await artifactSelectionFor(options, env, homeDirectory, cwd, platform);
     const artifactStore = await ArtifactStore.open({
-        rootDirectory: artifactRoot,
+        rootDirectory: artifactSelection.rootDirectory,
         projectDirectory: cwd,
         now: options.now,
     });
@@ -79,12 +95,33 @@ export async function startStdioServer(options = {}) {
         environment: { CUE_API_KEY: env.CUE_API_KEY },
         fetchImpl: options.fetchImpl,
     });
+    const iiisClient = new IiisClient({
+        fetchImpl: options.fetchImpl,
+        operationBaseUrl: options.iiisOperationBaseUrl,
+    });
+    const extraRoots = splitAllowedRoots(env.OMNI_ALLOWED_ROOTS);
+    const remoteClient = new HttpRemoteOmniClient({
+        apiKey: env.CUE_API_KEY,
+        fetchImpl: options.fetchImpl,
+    });
+    const operationManager = createLocalParseOperationManager({
+        journal,
+        workspace: cwd,
+        extraRoots,
+        cubeClient,
+        iiisClient,
+        artifactStore,
+        remoteClient,
+        now: options.now,
+    });
     const server = createOmniMcpServer({
         workspace: cwd,
-        extraRoots: splitAllowedRoots(env.OMNI_ALLOWED_ROOTS),
+        extraRoots,
         cubeClient,
-        iiisClient: new IiisClient({ fetchImpl: options.fetchImpl }),
+        iiisClient,
         artifactStore,
+        operationManager,
+        remoteClient,
     });
     const close = async () => {
         await server.close().catch(() => undefined);
@@ -99,7 +136,6 @@ export async function runCli(args, options = {}) {
     const homeDirectory = options.homeDirectory ?? (await import("node:os")).homedir();
     const cwd = options.cwd ?? process.cwd();
     const platform = options.platform ?? process.platform;
-    const artifactRoot = options.artifactRoot ?? defaultArtifactRoot({ platform, homeDirectory, env });
     const fetchImpl = options.fetchImpl ?? fetch;
     const output = options.stdout ?? process.stdout;
     const errorOutput = options.stderr ?? process.stderr;
@@ -107,57 +143,82 @@ export async function runCli(args, options = {}) {
     const write = (text) => { output.write(text); };
     const packageVersion = options.packageVersion ?? await installedPackageVersion();
     try {
-        if (args.length === 0) {
+        const parsed = parseCliArguments(args, platform);
+        if (parsed.command === "server") {
             await (options.startServer ?? (() => startStdioServer({
                 ...options,
                 env,
                 homeDirectory,
                 cwd,
                 platform,
-                artifactRoot,
                 fetchImpl,
             })))();
             return 0;
         }
-        const command = args[0];
-        if (command === "--help" || command === "-h" || command === "help") {
+        if (parsed.command === "help") {
             write(helpText());
             return 0;
         }
-        if (command === "--version" || command === "-v") {
+        if (parsed.command === "version") {
             write(`${packageVersion}\n`);
             return 0;
         }
-        if (command === "setup") {
-            await runSetup({ env, homeDirectory, platform, fetchImpl, ask, write });
+        if (parsed.command === "setup") {
+            await runSetup({
+                env,
+                homeDirectory,
+                platform,
+                fetchImpl,
+                ask,
+                write,
+                stdinIsTTY: options.stdinIsTTY ?? stdin.isTTY === true,
+                arguments: parsed.arguments,
+            });
+            return 0;
+        }
+        if (parsed.command === "uninstall") {
+            await runUninstall({
+                args: [
+                    ...(parsed.yes ? ["--yes"] : []),
+                    ...(parsed.json ? ["--json"] : []),
+                ],
+                env,
+                homeDirectory,
+                platform,
+                write,
+            });
             return 0;
         }
-        if (command === "doctor") {
-            const lines = await runDoctor({
+        if (parsed.command === "doctor") {
+            const artifactSelection = await artifactSelectionFor(options, env, homeDirectory, cwd, platform);
+            const report = await runDoctor({
                 env,
                 homeDirectory,
                 platform,
-                artifactRoot,
+                artifactRoot: artifactSelection.rootDirectory,
+                cacheMode: artifactSelection.mode,
                 fetchImpl,
                 npmVersion: options.npmVersion ?? await installedNpmVersion(env),
                 packageVersion,
             });
-            write(`${lines.join("\n")}\n`);
-            return 0;
-        }
-        if (command === "clean") {
-            const result = await runClean({ artifactRoot, projectDirectory: cwd, now: options.now });
-            write(`Removed ${result.removed} Bridge cache item(s).\n`);
+            write(parsed.json
+                ? `${JSON.stringify(report)}\n`
+                : `${renderDoctor(report).join("\n")}\n`);
             return 0;
         }
-        errorOutput.write(`Unknown command: ${command}\n`);
-        errorOutput.write(helpText());
-        return 1;
+        const artifactSelection = await artifactSelectionFor(options, env, homeDirectory, cwd, platform);
+        const result = await runClean({
+            artifactRoot: artifactSelection.rootDirectory,
+            projectDirectory: cwd,
+            now: options.now,
+        });
+        write(`Removed ${result.removed} Bridge cache item(s).\n`);
+        return 0;
     }
     catch (error) {
         const message = error instanceof Error ? error.message : "The Bridge command failed.";
         errorOutput.write(`Error: ${message}\n`);
-        return 1;
+        return error instanceof CliUsageError ? error.exitCode : 1;
     }
 }
 async function main() {

package/dist/multipart-body.js

@@ -4,7 +4,9 @@ function bridgeError(code, message, retryable) {
     return new OmniBridgeError({
         code,
         message,
+        operationCreated: true,
         fileUploaded: false,
+        parserStarted: false,
         billed: false,
         contentReleased: false,
         retryable,

package/dist/onboarding-policy.d.ts

@@ -0,0 +1,10 @@
+export declare const ONBOARDING_POLICY_URL = "https://cuecue.cn/api/v1/billing/public/onboarding-policy";
+export declare const API_KEY_URL = "https://cuecue.cn/api-key";
+export interface OnboardingPolicy {
+    readonly apiKeyUrl: typeof API_KEY_URL;
+    readonly firstRegistrationCredits: number;
+    readonly freeDailyCredits: number;
+}
+export declare function getOnboardingPolicy(fetchImpl: typeof fetch, signal: AbortSignal): Promise<OnboardingPolicy | undefined>;
+export declare function onboardingGuidance(policy: OnboardingPolicy | undefined): string;
+export declare function getOnboardingPolicyWithTimeout(fetchImpl: typeof fetch, timeoutMs?: number): Promise<OnboardingPolicy | undefined>;

package/dist/onboarding-policy.js

@@ -0,0 +1,58 @@
+export const ONBOARDING_POLICY_URL = "https://cuecue.cn/api/v1/billing/public/onboarding-policy";
+export const API_KEY_URL = "https://cuecue.cn/api-key";
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function boundedCredits(value) {
+    return Number.isInteger(value) && Number(value) > 0 && Number(value) <= 1_000_000;
+}
+function normalizeOnboardingPolicy(value) {
+    if (!isRecord(value))
+        return undefined;
+    if (value.api_key_url !== API_KEY_URL ||
+        !boundedCredits(value.first_registration) ||
+        !boundedCredits(value.free_daily))
+        return undefined;
+    return {
+        apiKeyUrl: API_KEY_URL,
+        firstRegistrationCredits: value.first_registration,
+        freeDailyCredits: value.free_daily,
+    };
+}
+export async function getOnboardingPolicy(fetchImpl, signal) {
+    try {
+        const response = await fetchImpl(ONBOARDING_POLICY_URL, {
+            method: "GET",
+            headers: { accept: "application/json" },
+            signal,
+        });
+        if (!response.ok)
+            return undefined;
+        return normalizeOnboardingPolicy(await response.json());
+    }
+    catch {
+        return undefined;
+    }
+}
+export function onboardingGuidance(policy) {
+    const creditLine = policy === undefined
+        ? `新账号有免费积分可体验，请前往 ${API_KEY_URL} 注册并创建 API Key。`
+        : `新账号首次注册赠送 ${policy.firstRegistrationCredits} 积分，免费账号每日有 ${policy.freeDailyCredits} 积分免费额度，可先体验 Omni，无需预先充值。`;
+    return [
+        "使用 Omni 需要配置 Cue API Key。",
+        `获取 API Key：${API_KEY_URL}`,
+        creditLine,
+        "创建后，请在 Agent 的安全密钥或环境设置中配置 CUE_API_KEY。请勿把 API Key 粘贴到对话中。",
+    ].join("\n");
+}
+export async function getOnboardingPolicyWithTimeout(fetchImpl, timeoutMs = 3_000) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    timer.unref?.();
+    try {
+        return await getOnboardingPolicy(fetchImpl, controller.signal);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/operation-journal.d.ts

@@ -1,13 +1,55 @@
-export type JournalState = "GRANT_PENDING" | "GRANT_ISSUED";
+export type JournalState = "CREATED" | "GRANT_PENDING" | "GRANT_ISSUED" | "UPLOADING" | "PROCESSING" | "RESULT_READY" | "ACK_PENDING" | "CLEANUP_PENDING" | "COMPLETED" | "FAILED" | "CANCELED" | "EXPIRED";
+export type JournalProgressUnit = "page" | "sheet" | "slide" | "frame" | "segment";
+export type JournalCleanupState = "not_created" | "in_use" | "pending" | "deleted";
+export type JournalDeliveryState = "not_created" | "pending" | "deleted_after_ack";
+export interface JournalProgress {
+    readonly unit: JournalProgressUnit;
+    readonly completed: number;
+    readonly total: number;
+}
 export interface JournalRecord {
     readonly clientRequestId: string;
     readonly requestHash: string;
+    readonly sourceLocatorHash: string | null;
+    readonly sourceKind: "local" | "url";
     readonly operationId: string | null;
     readonly operationToken: string | null;
     readonly uploadUrl: string | null;
     readonly state: JournalState;
     readonly createdAt: string;
+    readonly updatedAt: string;
     readonly expiresAt: string | null;
+    readonly stage: string | null;
+    readonly progressPercent: number;
+    readonly progress: JournalProgress | null;
+    readonly fileUploaded: boolean;
+    readonly parserStarted: boolean;
+    readonly billed: boolean;
+    readonly contentReleased: boolean;
+    readonly processingCopy: JournalCleanupState;
+    readonly temporaryData: JournalCleanupState;
+    readonly deliveryResult: JournalDeliveryState;
+    readonly resultId: string | null;
+    readonly resultExpiresAt: string | null;
+    readonly errorCode: string | null;
+}
+export interface JournalPatch {
+    readonly operationId?: string | null;
+    readonly operationToken?: string | null;
+    readonly expiresAt?: string | null;
+    readonly stage?: string | null;
+    readonly progressPercent?: number;
+    readonly progress?: JournalProgress | null;
+    readonly fileUploaded?: boolean;
+    readonly parserStarted?: boolean;
+    readonly billed?: boolean;
+    readonly contentReleased?: boolean;
+    readonly processingCopy?: JournalCleanupState;
+    readonly temporaryData?: JournalCleanupState;
+    readonly deliveryResult?: JournalDeliveryState;
+    readonly resultId?: string | null;
+    readonly resultExpiresAt?: string | null;
+    readonly errorCode?: string | null;
 }
 export interface IssuedGrantJournalFields {
     readonly operationId: string;
@@ -22,6 +64,13 @@ export interface OperationJournalOptions {
 export declare class OperationJournal {
     #private;
     constructor(options?: OperationJournalOptions);
+    beginIntent(clientRequestId: string, requestHash: string, sourceKind?: "local" | "url", sourceLocatorHash?: string | null): Promise<JournalRecord>;
+    transition(clientRequestId: string, expectedState: JournalState, nextState: JournalState, patch: JournalPatch): Promise<JournalRecord>;
+    loadByRequestId(clientRequestId: string): Promise<JournalRecord | null>;
+    loadByOperationId(operationId: string): Promise<JournalRecord | null>;
+    loadLatestByRequestHash(requestHash: string): Promise<JournalRecord | null>;
+    loadLatestBySourceLocatorHash(sourceLocatorHash: string): Promise<JournalRecord | null>;
+    listRecoverable(): Promise<JournalRecord[]>;
     begin(clientRequestId: string, requestHash: string): Promise<JournalRecord>;
     markGrantIssued(clientRequestId: string, fields: IssuedGrantJournalFields): Promise<JournalRecord>;
     load(clientRequestId: string): Promise<JournalRecord | null>;