create-academic-research 0.1.13 → 0.1.15

package/dist/src/mcp-env.d.ts

@@ -7,10 +7,14 @@ export interface McpEnvironmentEntry {
 export declare function listMcpEnvironmentEntries(servers: string[], options?: {
     requiredOnly?: boolean;
     recommendedOnly?: boolean;
+    mode?: string;
+    modes?: Record<string, string | undefined>;
 }): McpEnvironmentEntry[];
 export declare function formatMcpDotenv(servers: string[], options?: {
     requiredOnly?: boolean;
     recommendedOnly?: boolean;
+    mode?: string;
+    modes?: Record<string, string | undefined>;
 }): string;
 export declare function readMcpEnvironmentFile(path: string): Promise<Record<string, string>>;
 export declare function mergeMcpEnvironment(baseEnv?: NodeJS.ProcessEnv, fileEnv?: Record<string, string>): NodeJS.ProcessEnv;

package/dist/src/mcp-env.js

@@ -1,10 +1,10 @@
 import { readFile } from "node:fs/promises";
-import { AGENT_STACK } from "./stack.js";
+import { AGENT_STACK, resolveMcpServer } from "./stack.js";
 export function listMcpEnvironmentEntries(servers, options = {}) {
     assertKnownMcpServers(servers);
     const entries = [];
     for (const serverName of servers) {
-        const server = AGENT_STACK.mcp_servers[serverName];
+        const server = resolveMcpServer(serverName, options.mode ?? options.modes?.[serverName]);
         if (!options.recommendedOnly) {
             for (const envName of server.required_env) {
                 entries.push({ server: serverName, kind: "required", name: envName, value: "" });

package/dist/src/mcp-probe.d.ts

@@ -1,4 +1,5 @@
-export type McpProbeStatus = "ok" | "manual" | "missing-env" | "runtime-missing" | "startup-failed" | "protocol-error" | "timeout";
+import { type ResolvedMcpServer } from "./stack.js";
+export type McpProbeStatus = "ok" | "manual" | "remote-configured" | "missing-remote-url" | "missing-env" | "runtime-missing" | "startup-failed" | "protocol-error" | "timeout";
 export interface McpProbeServerResult {
     server: string;
     status: McpProbeStatus;
@@ -8,4 +9,4 @@ export interface McpProbeResult {
     ok: boolean;
     results: McpProbeServerResult[];
 }
-export declare function probeMcpServerList(root: string, servers: string[], env: NodeJS.ProcessEnv, timeoutMs: number, clientVersion?: string): Promise<McpProbeResult>;
+export declare function probeMcpServerList(root: string, servers: string[], env: NodeJS.ProcessEnv, timeoutMs: number, clientVersion?: string, modes?: Record<string, string>, resolvedServers?: Record<string, ResolvedMcpServer>): Promise<McpProbeResult>;

package/dist/src/mcp-probe.js

@@ -1,28 +1,46 @@
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
-import { delimiter, join } from "node:path";
-import { AGENT_STACK } from "./stack.js";
-export async function probeMcpServerList(root, servers, env, timeoutMs, clientVersion = "unknown") {
+import { delimiter, isAbsolute, join } from "node:path";
+import { AGENT_STACK, resolveMcpServer } from "./stack.js";
+export async function probeMcpServerList(root, servers, env, timeoutMs, clientVersion = "unknown", modes = {}, resolvedServers = {}) {
     assertKnownMcpServers(servers);
     const results = [];
     for (const name of servers) {
-        const server = AGENT_STACK.mcp_servers[name];
+        const server = resolvedServers[name] ?? resolveMcpServer(name, modes[name]);
         const missingRequired = server.required_env.filter((envName) => !envHasValue(env, envName));
         if (missingRequired.length > 0) {
             results.push({ server: name, status: "missing-env", detail: missingRequired.join(",") });
             continue;
         }
+        if (server.connection_mode === "remote-custom" && !server.remote_configured) {
+            results.push({ server: name, status: "missing-remote-url", detail: "custom remote endpoint not configured" });
+            continue;
+        }
+        if (server.connection_mode === "remote-curated" || server.connection_mode === "remote-custom") {
+            results.push({ server: name, status: "remote-configured", detail: remoteProbeDetail(server) });
+            continue;
+        }
         if (!server.command) {
-            results.push({ server: name, status: "manual", detail: server.local_service || "manual setup only" });
+            results.push({ server: name, status: "manual", detail: server.hosted_url || server.local_service || "manual setup only" });
             continue;
         }
-        if (!commandExists(server.command, env)) {
+        const command = resolveCommand(root, server.command);
+        if (!commandExists(command, env)) {
             results.push({ server: name, status: "runtime-missing", detail: server.command });
             continue;
         }
-        results.push(await probeMcpServerProcess(root, name, server.command, server.args, { ...server.env, ...env }, timeoutMs, clientVersion));
+        results.push(await probeMcpServerProcess(root, name, command, server.args, { ...server.env, ...env }, timeoutMs, clientVersion));
     }
-    return { ok: results.every((result) => result.status === "ok"), results };
+    return { ok: results.every((result) => result.status === "ok" || result.status === "remote-configured"), results };
+}
+function remoteProbeDetail(server) {
+    const urlEnv = server.connection_mode === "remote-custom" ? server.remote_url_env : undefined;
+    const source = urlEnv
+        ? `custom remote endpoint from ${urlEnv}`
+        : server.connection_mode === "remote-custom"
+            ? "custom remote endpoint configured"
+            : "remote endpoint configured";
+    return `${source}; remote probe does not perform a stdio handshake`;
 }
 function assertKnownMcpServers(servers) {
     const unknown = servers.filter((server) => !AGENT_STACK.mcp_servers[server]);
@@ -52,6 +70,11 @@ function commandExists(command, env = process.env) {
     }
     return false;
 }
+function resolveCommand(root, command) {
+    if (!command.includes("/") && !command.includes("\\"))
+        return command;
+    return isAbsolute(command) ? command : join(root, command);
+}
 async function probeMcpServerProcess(root, server, command, args, env, timeoutMs, clientVersion) {
     return new Promise((resolve) => {
         let settled = false;
@@ -96,7 +119,7 @@ async function probeMcpServerProcess(root, server, command, args, env, timeoutMs
             }
         });
         try {
-            child.stdin.write(encodeMcpMessage({
+            child.stdin.write(encodeMcpLineMessage({
                 jsonrpc: "2.0",
                 id: 1,
                 method: "initialize",
@@ -116,12 +139,12 @@ async function probeMcpServerProcess(root, server, command, args, env, timeoutMs
                     finish("protocol-error", formatJsonRpcError(message.error));
                     return;
                 }
-                child.stdin.write(encodeMcpMessage({
+                child.stdin.write(encodeMcpLineMessage({
                     jsonrpc: "2.0",
                     method: "notifications/initialized",
                     params: {}
                 }));
-                child.stdin.write(encodeMcpMessage({
+                child.stdin.write(encodeMcpLineMessage({
                     jsonrpc: "2.0",
                     id: 2,
                     method: "tools/list",
@@ -143,31 +166,65 @@ async function probeMcpServerProcess(root, server, command, args, env, timeoutMs
         function drainMcpMessages() {
             const messages = [];
             while (true) {
-                const separator = stdout.indexOf("\r\n\r\n");
-                if (separator === -1)
+                stdout = trimLeadingMcpWhitespace(stdout);
+                if (stdout.length === 0)
                     return messages;
-                const header = stdout.slice(0, separator).toString("utf8");
-                const match = /Content-Length:\s*(\d+)/i.exec(header);
-                if (!match)
-                    throw new Error("missing Content-Length header");
-                const length = Number(match[1]);
-                const bodyStart = separator + 4;
-                const bodyEnd = bodyStart + length;
-                if (stdout.length < bodyEnd)
+                if (startsWithContentLength(stdout)) {
+                    const framed = drainContentLengthMessage(stdout);
+                    if (!framed)
+                        return messages;
+                    stdout = framed.remaining;
+                    messages.push(parseMcpMessage(framed.body));
+                    continue;
+                }
+                const newline = stdout.indexOf("\n");
+                if (newline === -1)
                     return messages;
-                const body = stdout.slice(bodyStart, bodyEnd).toString("utf8");
-                stdout = stdout.slice(bodyEnd);
-                const parsed = JSON.parse(body);
-                if (typeof parsed !== "object" || parsed === null)
-                    throw new Error("MCP response is not an object");
-                messages.push(parsed);
+                const line = stdout.slice(0, newline).toString("utf8").trim();
+                stdout = stdout.slice(newline + 1);
+                if (!line)
+                    continue;
+                messages.push(parseMcpMessage(line));
             }
         }
     });
 }
-function encodeMcpMessage(message) {
-    const body = JSON.stringify(message);
-    return `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`;
+function encodeMcpLineMessage(message) {
+    return `${JSON.stringify(message)}\n`;
+}
+function trimLeadingMcpWhitespace(buffer) {
+    let offset = 0;
+    while (offset < buffer.length && (buffer[offset] === 0x0a || buffer[offset] === 0x0d)) {
+        offset += 1;
+    }
+    return offset === 0 ? buffer : buffer.slice(offset);
+}
+function startsWithContentLength(buffer) {
+    return buffer.slice(0, "Content-Length:".length).toString("utf8").toLowerCase() === "content-length:";
+}
+function drainContentLengthMessage(buffer) {
+    const separator = buffer.indexOf("\r\n\r\n");
+    if (separator === -1)
+        return undefined;
+    const header = buffer.slice(0, separator).toString("utf8");
+    const match = /Content-Length:\s*(\d+)/i.exec(header);
+    if (!match)
+        throw new Error("missing Content-Length header");
+    const length = Number(match[1]);
+    const bodyStart = separator + 4;
+    const bodyEnd = bodyStart + length;
+    if (buffer.length < bodyEnd)
+        return undefined;
+    return {
+        body: buffer.slice(bodyStart, bodyEnd).toString("utf8"),
+        remaining: buffer.slice(bodyEnd)
+    };
+}
+function parseMcpMessage(raw) {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null)
+        throw new Error("MCP response is not an object");
+    return parsed;
 }
 function formatJsonRpcError(error) {
     if (typeof error === "object" && error !== null && "message" in error) {

package/dist/src/project.d.ts

@@ -13,6 +13,11 @@ export interface RenameProjectOptions {
     slug?: string;
     packageName?: string;
 }
+export interface InitProjectOptions extends CreateProjectOptions {
+}
+export interface UpdateProjectOptions {
+    apply?: boolean;
+}
 export interface ProjectResult {
     root: string;
     title: string;
@@ -22,7 +27,20 @@ export interface ProjectResult {
 export interface DoctorResult {
     ok: boolean;
     errors: string[];
+    warnings: string[];
+}
+export interface ProjectFileChange {
+    path: string;
+    action: "create" | "update" | "skip";
+    reason?: string;
+}
+export interface UpdateProjectResult {
+    root: string;
+    applied: boolean;
+    changes: ProjectFileChange[];
 }
 export declare function createProject(options: CreateProjectOptions): Promise<ProjectResult>;
+export declare function initProject(options: InitProjectOptions): Promise<ProjectResult>;
 export declare function renameProject(root: string, options: RenameProjectOptions): Promise<ProjectResult>;
+export declare function updateProject(root: string, options?: UpdateProjectOptions): Promise<UpdateProjectResult>;
 export declare function doctorProject(root: string): Promise<DoctorResult>;