@praxis-ai/praxis 0.1.4 → 0.1.6

package/raxode-tui/dist/raxode-cli/frontend/tui/config/raxode-config.d.ts

@@ -125,6 +125,34 @@ export interface RaxodeEmbeddingConfig {
     authProfileId?: string;
     dimensions?: number;
 }
+export type RaxodeMcpServerMode = "native" | "mcp-plus";
+export type RaxodeMcpServerConfig = {
+    serverId: string;
+    mode: RaxodeMcpServerMode;
+    title?: string;
+    summary?: string;
+    enabled: boolean;
+    timeoutMs?: number;
+    manifest?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+} & ({
+    transport: "stdio";
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    framing?: "content-length" | "line-json";
+} | {
+    transport: "http" | "sse";
+    url: string;
+    sseUrl?: string;
+    headers?: Record<string, string>;
+});
+export interface RaxodeMcpConfig {
+    servers: RaxodeMcpServerConfig[];
+    projectId?: string;
+    reprofileConsecutiveIndexedCalls?: number;
+}
 export interface RaxodeConfigFile {
     schemaVersion: number;
     providerSlots: Partial<Record<RaxodeProviderSlot, string>>;
@@ -134,6 +162,7 @@ export interface RaxodeConfigFile {
     workspace: RaxodeWorkspaceConfig;
     ui: RaxodeUiConfig;
     permissions: RaxodePermissionsConfig;
+    mcp: RaxodeMcpConfig;
 }
 export interface RaxodeRuntimeConfigSnapshot {
     modelPlan: RaxodeLiveChatModelPlan;
@@ -141,6 +170,7 @@ export interface RaxodeRuntimeConfigSnapshot {
     permissions: RaxodePermissionsConfig;
     embedding: RaxodeEmbeddingConfig;
     workspace: RaxodeWorkspaceConfig;
+    mcp: RaxodeMcpConfig;
 }
 export interface RaxodeResolvedProfile {
     slot: RaxodeProviderSlot;
@@ -190,6 +220,7 @@ export declare function loadRaxodeLiveChatModelPlan(fallbackDir?: string): Raxod
 export declare function loadRaxodeUiConfig(fallbackDir?: string): RaxodeUiConfig;
 export declare function loadRaxodePermissionsConfig(fallbackDir?: string): RaxodePermissionsConfig;
 export declare function loadRaxodeRuntimeConfigSnapshot(fallbackDir?: string): RaxodeRuntimeConfigSnapshot;
+export declare function loadRaxodeMcpConfig(fallbackDir?: string): RaxodeMcpConfig;
 export declare function loadResolvedProviderSlotConfig(slot: RaxodeProviderSlot, fallbackDir?: string): RaxodeResolvedProfile;
 export declare function loadResolvedProviderSlotConfigs(fallbackDir?: string): {
     openai: RaxodeResolvedProfile;

package/raxode-tui/dist/raxode-cli/frontend/tui/config/raxode-config.js

@@ -235,6 +235,9 @@ function createDefaultConfigFile(fallbackDir = process.cwd()) {
         permissions: {
             ...createDefaultRaxodePermissionsConfig(),
         },
+        mcp: {
+            servers: [],
+        },
     };
 }
 export function ensureRaxodeHomeScaffold(fallbackDir = process.cwd()) {
@@ -295,6 +298,121 @@ function asBoolean(value, defaultValue = true) {
 function asPositiveInteger(value) {
     return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : undefined;
 }
+function asStringArray(value, filePath, fieldPath) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value)) {
+        throw new RaxodeConfigError(`Raxode 配置字段无效: ${fieldPath}`, { filePath, fieldPath });
+    }
+    return value.map((entry, index) => asString(entry, filePath, `${fieldPath}[${index}]`));
+}
+function asStringRecord(value, filePath, fieldPath) {
+    if (value === undefined)
+        return undefined;
+    const record = asRecord(value, filePath, fieldPath);
+    return Object.fromEntries(Object.entries(record).map(([key, entry]) => [key, asString(entry, filePath, `${fieldPath}.${key}`)]));
+}
+function asObjectRecord(value, filePath, fieldPath) {
+    if (value === undefined)
+        return undefined;
+    return { ...asRecord(value, filePath, fieldPath) };
+}
+function asMcpServerMode(value, filePath, fieldPath) {
+    if (value === undefined)
+        return "mcp-plus";
+    if (value === "native" || value === "mcp-plus")
+        return value;
+    throw new RaxodeConfigError(`Raxode 配置字段无效: ${fieldPath}`, { filePath, fieldPath });
+}
+function asMcpStdioFraming(value, filePath, fieldPath) {
+    if (value === undefined)
+        return undefined;
+    if (value === "content-length" || value === "line-json")
+        return value;
+    throw new RaxodeConfigError(`Raxode 配置字段无效: ${fieldPath}`, { filePath, fieldPath });
+}
+function asMcpServerConfig(value, filePath, fieldPath) {
+    const record = asRecord(value, filePath, fieldPath);
+    const serverId = asString(record.serverId, filePath, `${fieldPath}.serverId`);
+    const transport = asString(record.transport, filePath, `${fieldPath}.transport`);
+    const common = {
+        serverId,
+        mode: asMcpServerMode(record.mode, filePath, `${fieldPath}.mode`),
+        title: asOptionalString(record.title),
+        summary: asOptionalString(record.summary),
+        enabled: asBoolean(record.enabled, true),
+        timeoutMs: asPositiveInteger(record.timeoutMs),
+        manifest: asObjectRecord(record.manifest, filePath, `${fieldPath}.manifest`),
+        metadata: asObjectRecord(record.metadata, filePath, `${fieldPath}.metadata`),
+    };
+    if (transport === "stdio") {
+        return {
+            ...common,
+            transport,
+            command: asString(record.command, filePath, `${fieldPath}.command`),
+            args: asStringArray(record.args, filePath, `${fieldPath}.args`),
+            cwd: asOptionalString(record.cwd),
+            env: asStringRecord(record.env, filePath, `${fieldPath}.env`),
+            framing: asMcpStdioFraming(record.framing, filePath, `${fieldPath}.framing`),
+        };
+    }
+    if (transport === "http" || transport === "sse") {
+        return {
+            ...common,
+            transport,
+            url: asString(record.url, filePath, `${fieldPath}.url`),
+            sseUrl: asOptionalString(record.sseUrl),
+            headers: asStringRecord(record.headers, filePath, `${fieldPath}.headers`),
+        };
+    }
+    throw new RaxodeConfigError(`Raxode 配置字段无效: ${fieldPath}.transport`, { filePath, fieldPath: `${fieldPath}.transport` });
+}
+function loadMcpConfig(value, filePath) {
+    const record = value === undefined ? {} : asRecord(value, filePath, "mcp");
+    const rawServers = record.servers;
+    const servers = rawServers === undefined
+        ? []
+        : Array.isArray(rawServers)
+            ? rawServers.map((entry, index) => asMcpServerConfig(entry, filePath, `mcp.servers[${index}]`))
+            : (() => {
+                throw new RaxodeConfigError("Raxode 配置字段无效: mcp.servers", { filePath, fieldPath: "mcp.servers" });
+            })();
+    return {
+        servers,
+        projectId: asOptionalString(record.projectId),
+        reprofileConsecutiveIndexedCalls: asPositiveInteger(record.reprofileConsecutiveIndexedCalls),
+    };
+}
+function cloneMcpServerConfig(server) {
+    const common = {
+        serverId: server.serverId,
+        mode: server.mode,
+        title: server.title,
+        summary: server.summary,
+        enabled: server.enabled,
+        timeoutMs: server.timeoutMs,
+        manifest: server.manifest ? { ...server.manifest } : undefined,
+        metadata: server.metadata ? { ...server.metadata } : undefined,
+    };
+    if (server.transport === "stdio") {
+        return {
+            ...common,
+            transport: "stdio",
+            command: server.command,
+            args: server.args ? [...server.args] : undefined,
+            cwd: server.cwd,
+            env: server.env ? { ...server.env } : undefined,
+            framing: server.framing,
+        };
+    }
+    return {
+        ...common,
+        transport: server.transport,
+        url: server.url,
+        sseUrl: server.sseUrl,
+        headers: server.headers ? { ...server.headers } : undefined,
+    };
+}
 function loadAuthProfiles(filePath) {
     const parsed = parseJsonFile(filePath);
     const authProfilesRaw = parsed.authProfiles;
@@ -407,6 +525,7 @@ function loadConfigFile(filePath) {
     const ui = asRecord(parsed.ui ?? {}, filePath, "ui");
     const permissions = asRecord(parsed.permissions ?? {}, filePath, "permissions");
     const providerSlots = asRecord(parsed.providerSlots ?? {}, filePath, "providerSlots");
+    const mcp = loadMcpConfig(parsed.mcp, filePath);
     const matrix = Array.isArray(permissions.shared15ViewMatrix)
         ? permissions.shared15ViewMatrix.map((entry, index) => ({
             ...asRecord(entry, filePath, `permissions.shared15ViewMatrix[${index}]`),
@@ -471,6 +590,7 @@ function loadConfigFile(filePath) {
             shared15ViewMatrix: matrix,
             persistedAllowRules,
         },
+        mcp,
     };
 }
 function migrateRaxodeConfigFile(config) {
@@ -488,6 +608,11 @@ function migrateRaxodeConfigFile(config) {
         embedding: { ...config.embedding },
         workspace: { ...config.workspace },
         ui: { ...config.ui },
+        mcp: {
+            projectId: config.mcp.projectId,
+            reprofileConsecutiveIndexedCalls: config.mcp.reprofileConsecutiveIndexedCalls,
+            servers: config.mcp.servers.map(cloneMcpServerConfig),
+        },
         permissions: {
             ...config.permissions,
             requireHumanOnRiskLevels: [...config.permissions.requireHumanOnRiskLevels],
@@ -640,8 +765,12 @@ export function loadRaxodeRuntimeConfigSnapshot(fallbackDir = process.cwd()) {
         permissions: config.permissions,
         embedding: config.embedding,
         workspace: config.workspace,
+        mcp: config.mcp,
     };
 }
+export function loadRaxodeMcpConfig(fallbackDir = process.cwd()) {
+    return loadRaxodeConfigFile(fallbackDir).mcp;
+}
 export function loadResolvedProviderSlotConfig(slot, fallbackDir = process.cwd()) {
     const authFile = loadRaxodeAuthFile(fallbackDir);
     const configFile = loadRaxodeConfigFile(fallbackDir);

package/raxode-tui/dist/raxode-cli/index.d.ts

@@ -6,6 +6,7 @@ export { createRaxodeReadinessEvent, inspectRaxodeBackendReadiness, inspectRaxod
 export { createRaxodeBackendModuleInventory, } from "./backend/application/backendModuleInventory.js";
 export { probeLocalRaxodeReadiness, } from "./backend/application/localReadinessProbe.js";
 export type { RaxodeBackendReadiness, RaxodeReadinessArea, RaxodeReadinessOwner, RaxodeReadinessPhase, RaxodeReadinessSeverity, RaxodeReadinessStatus, } from "./backend/application/runtimeReadiness.js";
+export type { RaxodeMcpReadinessSummary, } from "./backend/application/mcpReadinessSummary.js";
 export type { RaxodeBackendModuleId, RaxodeBackendModuleInventory, RaxodeBackendModuleInventoryItem, RaxodeBackendModuleStatus, } from "./backend/application/backendModuleInventory.js";
 export type { RaxodeDependencyProbe, RaxodeDependencyProbeStatus, RaxodeLocalReadinessProbe, RaxodeLocalReadinessProbeInput, RaxodeSandboxProbe, RaxodeSandboxProbeStatus, } from "./backend/application/localReadinessProbe.js";
 export type { RaxodeApplicationAttachment, RaxodeApplicationBackendResult, RaxodeApplicationCommand, RaxodeApplicationEvent, RaxodeApplicationInputEnvelope, RaxodeApplicationPermissionProfile, RaxodeApplicationReasoningEffort, RaxodeApplicationRunMode, RaxodeApplicationStatus, RaxodeApplicationViewModel, } from "./contracts.js";