@noimosai/platform-mcp 0.1.3 → 0.1.4

package/dist/client/local-input.js

@@ -1,28 +1,49 @@
 import { open } from "node:fs/promises";
 import { constants } from "node:fs";
-import { extname } from "node:path";
-import { platformInputMimeSchema, PLATFORM_INPUT_MAX_BYTES } from "./index.js";
-const extensions = { ".mp3": "audio/mpeg", ".wav": "audio/wav", ".mp4": "video/mp4", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".png": "image/png", ".webp": "image/webp" };
-export async function uploadLocalInput(client, path) {
-    const mimeType = platformInputMimeSchema.safeParse(extensions[extname(path).toLowerCase()]);
+import { basename, extname } from "node:path";
+import { platformInputMimeSchema, platformInputFileMimeSchema, PLATFORM_INPUT_MAX_BYTES } from "./index.js";
+const sensitiveDirectories = new Set([
+    ".ssh", ".aws", ".gcloud", ".kube", ".config", ".git", ".docker", ".gnupg", ".azure", ".password-store",
+    ".claude", ".agents", ".codex", ".cursor", "_sessions",
+]);
+const sensitiveNames = new Set([
+    ".env", ".npmrc", ".netrc", ".git-credentials", ".pgpass", ".pypirc",
+    "credentials.json", "application_default_credentials.json", "id_rsa", "id_ed25519", "logins.json", "secrets.json",
+]);
+const sensitiveExtensions = new Set([".key", ".pem", ".p12", ".pfx", ".kdbx", ".db"]);
+export function isSensitiveLocalPath(path) {
+    const name = basename(path).toLowerCase();
+    return path.split(/[\\/]/).some((part) => sensitiveDirectories.has(part.toLowerCase()))
+        || sensitiveNames.has(name) || name.startsWith(".env") || sensitiveExtensions.has(extname(name));
+}
+const extensions = { ".mp3": "audio/mpeg", ".wav": "audio/wav", ".mp4": "video/mp4", ".mov": "video/quicktime", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".png": "image/png", ".webp": "image/webp",
+    ".gif": "image/gif", ".bmp": "image/bmp", ".pdf": "application/pdf", ".csv": "text/csv", ".tsv": "text/tab-separated-values", ".txt": "text/plain", ".json": "application/json", ".xml": "application/xml",
+    ".zip": "application/zip", ".gz": "application/gzip", ".glb": "model/gltf-binary", ".gltf": "model/gltf+json", ".srt": "application/x-subrip", ".vtt": "text/vtt", ".bin": "application/octet-stream" };
+export async function uploadLocalInput(client, path, options = {}) {
+    const mimeType = platformInputFileMimeSchema.safeParse(options.mimeType ?? extensions[extname(path).toLowerCase()]);
     if (!mimeType.success)
-        throw new Error("Supported input files: JPG, PNG, WebP, WAV, MP3, MP4.");
+        throw new Error(`Supported input files end in ${Object.keys(extensions).join(", ")}. Copy another file under the one that matches its content, such as .txt for text; only the SDK takes a mimeType.`);
+    const range = options.byteRange;
+    if (range && (!Number.isSafeInteger(range.start) || !Number.isSafeInteger(range.end) || range.start < 0 || range.end < range.start || range.end - range.start >= PLATFORM_INPUT_MAX_BYTES))
+        throw new Error("Input byte range must be nonnegative and at most 12 MiB.");
+    const purpose = options.purpose ?? (range || !platformInputMimeSchema.safeParse(mimeType.data).success ? "file" : undefined);
     let data;
     try {
         const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
         try {
             const stat = await file.stat();
-            if (!stat.isFile() || stat.size < 1 || stat.size > PLATFORM_INPUT_MAX_BYTES)
+            if (!stat.isFile() || stat.size < 1 || (range ? range.end >= stat.size : stat.size > PLATFORM_INPUT_MAX_BYTES))
                 throw new Error("Invalid file");
-            const buffer = Buffer.alloc(stat.size + 1);
+            const size = range ? range.end - range.start + 1 : stat.size;
+            const buffer = Buffer.alloc(size + (range ? 0 : 1));
             let offset = 0;
             while (offset < buffer.length) {
-                const { bytesRead } = await file.read(buffer, offset, buffer.length - offset, null);
+                const { bytesRead } = await file.read(buffer, offset, buffer.length - offset, range ? range.start + offset : null);
                 if (!bytesRead)
                     break;
                 offset += bytesRead;
             }
-            if (offset !== stat.size)
+            if (offset !== size)
                 throw new Error("File changed");
             data = buffer.subarray(0, offset).toString("base64");
         }
@@ -31,7 +52,7 @@ export async function uploadLocalInput(client, path) {
         }
     }
     catch {
-        throw new Error("Input must be an existing regular file, at most 12 MiB. Symlinks are not accepted.");
+        throw new Error("Input must be an existing regular file or a selected chunk, at most 12 MiB. Symlinks are not accepted.");
     }
-    return client.uploadInput({ mimeType: mimeType.data, data });
+    return client.uploadInput({ mimeType: mimeType.data, data, ...(purpose ? { purpose } : {}) });
 }

package/dist/client/local-profile-lock.js

@@ -0,0 +1,52 @@
+import { constants } from "node:fs";
+import { lstat, open, unlink } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { z } from "zod";
+import { profileDirectory, readPrivateJson } from "./local-profile.js";
+const lockSchema = z.object({ managedBy: z.literal("relvo-cli"), pid: z.number().int().positive() }).strict();
+export async function withLocalProfileLock(path, operation) {
+    await profileDirectory(path, true);
+    const lock = join(dirname(path), "setup.lock");
+    for (let attempt = 0; attempt < 3; attempt++) {
+        let handle;
+        try {
+            handle = await open(lock, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+        }
+        catch (error) {
+            if (!(error instanceof Error && "code" in error && error.code === "EEXIST"))
+                throw new Error("Relvo local storage could not be locked safely.");
+            try {
+                const before = await lstat(lock), previous = lockSchema.parse(await readPrivateJson(lock));
+                try {
+                    process.kill(previous.pid, 0);
+                }
+                catch (failure) {
+                    if (failure instanceof Error && "code" in failure && failure.code === "ESRCH") {
+                        const after = await lstat(lock);
+                        if (before.ino === after.ino && before.dev === after.dev) {
+                            await unlink(lock);
+                            continue;
+                        }
+                    }
+                }
+            }
+            catch {
+                throw new Error("Relvo setup lock is unsafe or invalid. No local configuration was changed.");
+            }
+            throw new Error("Another Relvo setup, project selection or update is using this profile. Wait for it to finish.");
+        }
+        const identity = await handle.stat();
+        try {
+            await handle.writeFile(JSON.stringify({ managedBy: "relvo-cli", pid: process.pid }));
+            await handle.sync();
+            return await operation();
+        }
+        finally {
+            await handle.close();
+            const current = await lstat(lock).catch(() => null);
+            if (current?.ino === identity.ino && current.dev === identity.dev)
+                await unlink(lock);
+        }
+    }
+    throw new Error("Relvo local storage is busy. Rerun the command.");
+}

package/dist/client/local-profile.js

@@ -0,0 +1,181 @@
+import { constants } from "node:fs";
+import { lstat, mkdir, open, realpath, rename, unlink } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+import { platformLocalSetupClientSchema, platformLocalSetupStartSchema, platformLocalSetupProofSchema, platformLocalSetupPollSchema } from "./local-setup.js";
+import { configFromEnvironment, hasRelvoEnvironment } from "./index.js";
+const registeredSchema = z.object({ client: z.enum(["claude", "codex"]), name: z.string().regex(/^relvo-[a-f0-9]{24}$/), command: z.string().min(1), args: z.array(z.string()).min(1) }).strict();
+const common = { managedBy: z.literal("relvo-cli"), version: z.literal(1), apiUrl: z.string().url(), consoleUrl: z.string().url(), local: z.boolean(),
+    installationId: z.string().regex(/^[a-f0-9]{24}$/), registrations: z.array(registeredSchema).max(2).default([]) };
+export const localProfileSchema = z.discriminatedUnion("state", [
+    z.object({ ...common, state: z.literal("pending"), client: platformLocalSetupClientSchema, request: platformLocalSetupStartSchema }).strict(),
+    z.object({ ...common, state: z.literal("ready"), grant: platformLocalSetupPollSchema.options[1], pendingAck: platformLocalSetupProofSchema.optional() }).strict(),
+]);
+const installationSchema = z.object({ managedBy: z.literal("relvo-cli"), version: z.literal(1),
+    installationId: common.installationId, registrations: common.registrations }).strict();
+export const localProfilePath = (home = homedir()) => join(home, ".config", "relvo", "profile.json");
+function owned(mode, uid, privateMode) {
+    if (typeof process.getuid === "function" && uid !== process.getuid() || mode & (privateMode ? 0o077 : 0o022))
+        throw new Error("Relvo local storage has unsafe ownership or permissions.");
+}
+export async function safeDirectory(path, create = false, privateMode = false) {
+    if (!isAbsolute(path) || resolve(path) !== path)
+        throw new Error("Relvo local paths must be canonical absolute paths.");
+    try {
+        const info = await lstat(path);
+        if (!info.isDirectory() || info.isSymbolicLink())
+            throw new Error("Relvo local directories must not be symlinks.");
+        owned(info.mode, info.uid, privateMode);
+    }
+    catch (error) {
+        if (!(error instanceof Error && "code" in error && error.code === "ENOENT") || !create)
+            throw error;
+        await mkdir(path, { mode: privateMode ? 0o700 : 0o755 });
+        await safeDirectory(path, false, privateMode);
+    }
+}
+export async function profileDirectory(path = localProfilePath(), create = false) {
+    if (process.platform === "win32")
+        throw new Error("Relvo private local profiles currently require POSIX file permissions.");
+    if (!isAbsolute(path) || resolve(path) !== path || !/\/\.config\/relvo\/profile\.json$/.test(path))
+        throw new Error("Use the canonical managed Relvo profile path.");
+    const root = dirname(dirname(dirname(path)));
+    if (await realpath(root) !== root)
+        throw new Error("Relvo profile home must be a canonical directory.");
+    await safeDirectory(root);
+    await safeDirectory(join(root, ".config"), create);
+    await safeDirectory(dirname(path), create, true);
+    return dirname(path);
+}
+export async function readPrivateBytes(path, maximumBytes = 65536) {
+    const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        const info = await handle.stat();
+        owned(info.mode, info.uid, true);
+        if (!info.isFile() || info.size > maximumBytes || info.nlink !== 1)
+            throw new Error("Relvo private file is invalid.");
+        return await handle.readFile();
+    }
+    finally {
+        await handle.close();
+    }
+}
+export async function readPrivateText(path, maximumBytes = 65536) { return (await readPrivateBytes(path, maximumBytes)).toString("utf8"); }
+export async function readPrivateJson(path, maximumBytes = 65536) { return JSON.parse(await readPrivateText(path, maximumBytes)); }
+export async function writePrivateBytes(path, value, privateParent = true, maximumBytes = 65536) {
+    const directory = dirname(path);
+    await safeDirectory(directory, false, privateParent);
+    if (value.byteLength > maximumBytes)
+        throw new Error("Relvo private file exceeds its size limit.");
+    try {
+        await readPrivateBytes(path, maximumBytes);
+    }
+    catch (error) {
+        if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+            throw error;
+    }
+    const temporary = join(directory, `.relvo-${randomUUID()}.tmp`);
+    const handle = await open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+    let closed = false;
+    try {
+        await handle.writeFile(value);
+        await handle.sync();
+        await handle.close();
+        closed = true;
+        await rename(temporary, path);
+        const parent = await open(directory, constants.O_RDONLY);
+        try {
+            await parent.sync();
+        }
+        finally {
+            await parent.close();
+        }
+    }
+    catch (error) {
+        await unlink(temporary).catch(() => { });
+        throw error;
+    }
+    finally {
+        if (!closed)
+            await handle.close();
+    }
+}
+export async function writePrivateText(path, value, privateParent = true, maximumBytes = 65536) { await writePrivateBytes(path, Buffer.from(value, "utf8"), privateParent, maximumBytes); }
+export async function writePrivateJson(path, value, privateParent = true, maximumBytes = 65536) { await writePrivateText(path, JSON.stringify(value) + "\n", privateParent, maximumBytes); }
+export class LocalProfileError extends Error {
+    reason;
+    name = "LocalProfileError";
+    constructor(reason, message) {
+        super(message);
+        this.reason = reason;
+    }
+}
+export const windowsLocalSetupRefusal = "Relvo's saved login and automatic setup need macOS or Linux. On Windows, connect your agent to the MCP URL shown under Getting started in the Relvo console.";
+export async function readLocalProfile(path = localProfilePath()) {
+    try {
+        await profileDirectory(path);
+        const raw = await readPrivateJson(path), parsed = localProfileSchema.safeParse(raw);
+        if (parsed.success)
+            return parsed.data;
+        if (raw === null || typeof raw !== "object" || !("managedBy" in raw) || raw.managedBy !== "relvo-cli")
+            throw new Error("Foreign profile");
+        throw new SyntaxError("Invalid profile");
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return null;
+        if (process.platform === "win32")
+            throw new LocalProfileError("unsupported", windowsLocalSetupRefusal);
+        if (error instanceof SyntaxError)
+            throw new LocalProfileError("unreadable", `Relvo's saved login at ${path} is unreadable. Run relvo logout to remove it, then relvo setup. No credentials were changed.`);
+        throw new LocalProfileError("unsafe", `Relvo's saved login at ${path} is unsafe to use: it or a folder above it is a link, belongs to another user, is writable by others, or is not Relvo's file. Keep your home and .config folders writable only by you, then run chmod 700 ${dirname(path)} and chmod 600 ${path}. No credentials were changed.`);
+    }
+}
+export async function removeUnreadableProfile(path) {
+    await profileDirectory(path);
+    const info = await lstat(path);
+    if (!info.isFile() || info.isSymbolicLink())
+        throw new LocalProfileError("unsafe", `Relvo's saved login at ${path} is not a regular file, so it was left in place.`);
+    await unlink(path);
+}
+export async function writeLocalProfile(path, profile) {
+    await profileDirectory(path, true);
+    await readLocalProfile(path);
+    await writePrivateJson(path, localProfileSchema.parse({ ...profile, managedBy: "relvo-cli" }));
+}
+export async function readLocalInstallation(path = localProfilePath()) {
+    try {
+        const directory = await profileDirectory(path);
+        return installationSchema.parse(await readPrivateJson(join(directory, "installation.json")));
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return null;
+        throw new Error("Relvo installation ownership is unsafe or invalid. No registrations were changed.");
+    }
+}
+export async function removeLocalProfile(path) {
+    const profile = await readLocalProfile(path);
+    if (profile) {
+        const installation = await readLocalInstallation(path);
+        if (installation && installation.installationId !== profile.installationId)
+            throw new Error("Relvo installation ownership changed. The login was preserved.");
+        await writePrivateJson(join(dirname(path), "installation.json"), installationSchema.parse({ managedBy: "relvo-cli", version: 1,
+            installationId: profile.installationId, registrations: profile.registrations }));
+        await unlink(path);
+    }
+}
+export async function runtimeConfig(env, source, profile, requireProfileMatch = false) {
+    const hasEnvironment = hasRelvoEnvironment(env) || ["NOIMOS_PLATFORM_API_URL", "NOIMOS_PLATFORM_API_KEY"].some((name) => env[name] !== undefined);
+    const environment = hasEnvironment || !profile ? configFromEnvironment(env, source) : null;
+    if (environment && (!profile || !requireProfileMatch))
+        return environment;
+    const saved = await readLocalProfile(profile);
+    if (!saved || saved.state !== "ready" || saved.pendingAck || Date.parse(saved.grant.expiresAt) <= Date.now())
+        throw new LocalProfileError("missing", "Relvo login is missing, incomplete or expired. Run npx --yes @relvo/cli setup to resume.");
+    if (environment && (environment.apiUrl.replace(/\/$/, "") !== saved.apiUrl || environment.apiKey !== saved.grant.apiKey || Boolean(environment.local) !== saved.local))
+        throw new Error("Ambient Relvo credentials conflict with the explicitly selected managed profile. No project was selected.");
+    return { apiUrl: saved.apiUrl, apiKey: saved.grant.apiKey, local: saved.local, source };
+}

package/dist/client/local-projects.js

@@ -0,0 +1,131 @@
+import { unlink } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { z } from "zod";
+import { configFromEnvironment, hasRelvoEnvironment, PlatformClient } from "./index.js";
+import { platformLocalSetupPollSchema } from "./local-setup.js";
+import { profileDirectory, readLocalProfile, readPrivateJson, writeLocalProfile, writePrivateJson } from "./local-profile.js";
+import { withLocalProfileLock } from "./local-profile-lock.js";
+export { withLocalProfileLock } from "./local-profile-lock.js";
+const entrySchema = z.object({ grant: platformLocalSetupPollSchema.options[1].refine(grant => grant.expiresAt === grant.approvedExpiresAt, "Only acknowledged approvals may be saved"),
+    name: z.string().max(512).optional() }).strict();
+const storeSchema = z.object({ managedBy: z.literal("relvo-cli"), version: z.literal(1), installationId: z.string().regex(/^[a-f0-9]{24}$/),
+    apiUrl: z.string().url(), consoleUrl: z.string().url(), local: z.boolean(), projects: z.array(entrySchema).max(1000),
+    projectSetup: z.object({ apiKeyId: z.string().min(1).max(256) }).strict().optional() }).strict();
+const maximumBytes = 1024 * 1024;
+const storePath = (path) => join(dirname(path), "projects.json");
+async function readStore(path) {
+    await profileDirectory(path);
+    try {
+        return storeSchema.parse(await readPrivateJson(storePath(path), maximumBytes));
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return null;
+        throw new Error("Relvo's saved project approvals are unsafe or unreadable. No credentials were changed.");
+    }
+}
+async function entries(path, profile) {
+    const store = await readStore(path);
+    const sameApi = !store || store.apiUrl === profile.apiUrl || !store.local && !profile.local && /(^|\.)relvo\.si$/.test(new URL(profile.apiUrl).hostname);
+    if (store && (store.installationId !== profile.installationId || !sameApi || store.consoleUrl !== profile.consoleUrl || store.local !== profile.local)) {
+        throw new Error("Relvo's saved project approvals belong to another installation or server. No credentials were changed.");
+    }
+    const saved = store?.projects ?? [];
+    if (profile.state !== "ready" || profile.pendingAck)
+        return saved;
+    const previous = saved.find(entry => entry.grant.developerProjectId === profile.grant.developerProjectId);
+    return [...saved.filter(entry => entry.grant.developerProjectId !== profile.grant.developerProjectId), { ...previous, grant: profile.grant }];
+}
+export async function rememberLocalProject(path, profile, name) {
+    if (profile.pendingAck)
+        throw new Error("Complete the pending approval before saving this project.");
+    const projects = await entries(path, profile);
+    const current = projects.find(entry => entry.grant.developerProjectId === profile.grant.developerProjectId);
+    const projectSetup = (await readStore(path))?.projectSetup;
+    await writePrivateJson(storePath(path), storeSchema.parse({ managedBy: "relvo-cli", version: 1, installationId: profile.installationId,
+        apiUrl: profile.apiUrl, consoleUrl: profile.consoleUrl, local: profile.local,
+        ...(projectSetup ? { projectSetup } : {}),
+        projects: [...projects.filter(entry => entry !== current), { ...current, grant: profile.grant, ...(name === undefined ? {} : { name }) }] }), true, maximumBytes);
+}
+export async function projectSetupInProgress(path, profile) {
+    await entries(path, profile);
+    return profile.state === "ready" && (await readStore(path))?.projectSetup?.apiKeyId === profile.grant.apiKeyId;
+}
+export async function markProjectSetup(path, profile, apiKeyId) {
+    const projects = await entries(path, profile);
+    await writePrivateJson(storePath(path), storeSchema.parse({ managedBy: "relvo-cli", version: 1, installationId: profile.installationId,
+        apiUrl: profile.apiUrl, consoleUrl: profile.consoleUrl, local: profile.local, projects, projectSetup: { apiKeyId } }), true, maximumBytes);
+}
+export async function completeProjectSetup(path, profile) {
+    await entries(path, profile);
+    const store = await readStore(path);
+    if (!store || store.projectSetup?.apiKeyId !== profile.grant.apiKeyId)
+        return;
+    const { projectSetup, ...complete } = store;
+    void projectSetup;
+    await writePrivateJson(storePath(path), complete, true, maximumBytes);
+}
+export async function listLocalProjects(path, now = Date.now()) {
+    const profile = await readLocalProfile(path);
+    if (!profile)
+        throw new Error("Run relvo setup to create the local login.");
+    return (await entries(path, profile)).map(({ grant, name }) => ({ id: grant.developerProjectId, organizationId: grant.developerOrganizationId,
+        ...(name === undefined ? {} : { name }), current: profile.state === "ready" && !profile.pendingAck && profile.grant.developerProjectId === grant.developerProjectId && profile.grant.apiKeyId === grant.apiKeyId,
+        expiresAt: grant.expiresAt, expired: Date.parse(grant.expiresAt) <= now }));
+}
+async function approvedProject(path, id, env, source, transport, now) {
+    const profile = await readLocalProfile(path);
+    if (!profile || profile.state !== "ready" || profile.pendingAck)
+        throw new Error("Run relvo setup to complete the local login before selecting a project.");
+    const entry = (await entries(path, profile)).find(item => item.grant.developerProjectId === id);
+    if (!entry)
+        throw new Error(`This login has no approved access to another project with that ID. Run relvo project add --project ${id} and approve it in your browser.`);
+    if (Date.parse(entry.grant.expiresAt) <= now)
+        throw new Error(`This project's saved approval expired. Run relvo project add --project ${id} to approve it again.`);
+    const config = { apiUrl: profile.apiUrl, apiKey: entry.grant.apiKey, local: profile.local, source };
+    if (hasRelvoEnvironment(env) || ["NOIMOS_PLATFORM_API_URL", "NOIMOS_PLATFORM_API_KEY"].some(name => env[name] !== undefined)) {
+        const ambient = configFromEnvironment(env, source);
+        if (ambient.apiUrl.replace(/\/$/, "") !== config.apiUrl || ambient.apiKey !== config.apiKey || Boolean(ambient.local) !== config.local)
+            throw new Error("Ambient Relvo credentials conflict with the explicitly selected project. No project was selected.");
+    }
+    const { data } = await new PlatformClient(config, transport).project();
+    if (data.developerProjectId !== id || data.developerOrganizationId !== entry.grant.developerOrganizationId)
+        throw new Error("The saved approval does not match the requested project. No project was selected.");
+    return { profile, entry, config, name: data.name };
+}
+export async function localProjectConfig(path, id, env, source, transport = fetch, now = Date.now()) {
+    return (await approvedProject(path, id, env, source, transport, now)).config;
+}
+export async function localProjectProfile(path, id, env, transport = fetch, now = Date.now()) {
+    const { profile, entry } = await approvedProject(path, id, env, "cli", transport, now);
+    return { ...profile, grant: entry.grant };
+}
+export async function useLocalProject(path, id, env, source, transport = fetch, now = Date.now(), beforeSelect) {
+    return withLocalProfileLock(path, async () => {
+        const { profile, entry, name } = await approvedProject(path, id, env, source, transport, now);
+        const deactivated = await beforeSelect?.(id);
+        await rememberLocalProject(path, profile);
+        const selected = { ...profile, grant: entry.grant };
+        await rememberLocalProject(path, selected, name);
+        await writeLocalProfile(path, selected);
+        return { id, organizationId: entry.grant.developerOrganizationId, name, ...(deactivated ? { deactivated } : {}) };
+    });
+}
+export async function assertLocalProjectConnection(path, config, pinnedProjectId) {
+    const profile = await readLocalProfile(path);
+    if (!profile || profile.state !== "ready" || profile.pendingAck || profile.apiUrl !== config.apiUrl || profile.local !== Boolean(config.local))
+        throw new Error("The Relvo login changed. Reconnect Relvo MCP before continuing. Accepted executions remain in their original project.");
+    const matches = pinnedProjectId
+        ? (await entries(path, profile)).some(entry => entry.grant.developerProjectId === pinnedProjectId && entry.grant.apiKey === config.apiKey)
+        : profile.grant.apiKey === config.apiKey;
+    if (!matches)
+        throw new Error("The selected Relvo project changed. Reconnect Relvo MCP to load its tools and permissions before continuing. Accepted executions remain in their original project.");
+}
+export async function removeLocalProjects(path, installationId) {
+    const store = await readStore(path);
+    if (!store)
+        return;
+    if (installationId && store.installationId !== installationId)
+        throw new Error("Relvo's saved projects belong to another installation and were preserved.");
+    await unlink(storePath(path));
+}

package/dist/client/local-setup.js

@@ -0,0 +1,93 @@
+import { z } from "zod";
+import { PLATFORM_CLIENT_HEADERS } from "../schema/platformApiKey.js";
+import { platformLocalSetupStartInputSchema, platformLocalSetupStartSchema, platformLocalSetupProofSchema, platformLocalSetupPollSchema, platformLocalSetupAcknowledgedSchema } from "../schema/platformLocalSetup.js";
+export { platformLocalSetupClientSchema, platformLocalSetupStartInputSchema, platformLocalSetupStartSchema, platformLocalSetupProofSchema, platformLocalSetupPollSchema, platformLocalSetupAcknowledgedSchema } from "../schema/platformLocalSetup.js";
+export function relvoApiUrl(value, local = false) {
+    const url = new URL(value);
+    if (url.username || url.password || url.search || url.hash || (url.protocol !== "https:" && !(local && url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname))))
+        throw new Error("Relvo URLs must use HTTPS; --local permits loopback HTTP only.");
+    return url.href.replace(/\/$/, "");
+}
+export function verificationUrl(value, consoleUrl, authorizationRequest, local = false, projectId) {
+    const trusted = new URL(relvoApiUrl(consoleUrl, local));
+    if (trusted.pathname !== "/")
+        throw new Error("Provide the Relvo console origin without a path.");
+    const url = new URL(value);
+    if (url.origin !== trusted.origin || url.pathname !== "/local-setup" || url.username || url.password || url.hash ||
+        [...url.searchParams.keys()].length !== 1 || url.searchParams.get("request") !== authorizationRequest)
+        throw new Error("Relvo returned an unexpected verification URL. No browser was opened.");
+    if (projectId)
+        url.searchParams.set("project", projectId);
+    return url.href;
+}
+const publicSetupErrors = {
+    platform_local_setup_unavailable: "Local setup is unavailable on this Relvo server.",
+    platform_local_setup_invalid: "The local setup proof is invalid. No credentials were replaced.",
+    platform_local_setup_expired: "The local setup request expired. Run setup again after checking its saved state.",
+    platform_local_setup_conflict: "This setup request was already used for a different approval.",
+    platform_local_setup_rate_exceeded: "The local setup request limit was reached. Wait before trying again.",
+};
+export class LocalSetupClient {
+    transport;
+    baseUrl;
+    constructor(apiUrl, local = false, transport = fetch) {
+        this.transport = transport;
+        this.baseUrl = relvoApiUrl(apiUrl, local);
+    }
+    async request(operation, body, schema) {
+        let response;
+        try {
+            response = await this.transport(`${this.baseUrl}/tools/setup/${operation}`, { method: "POST", redirect: "error", signal: AbortSignal.timeout(20000),
+                headers: { "content-type": "application/json", [PLATFORM_CLIENT_HEADERS.relvo]: "cli" }, body: JSON.stringify(body) });
+        }
+        catch {
+            throw new Error("Relvo setup could not be reached. Rerun setup to resume its saved request; do not create another key manually.");
+        }
+        let payload;
+        try {
+            const reader = response.body?.getReader();
+            if (!reader)
+                throw new Error("Missing body");
+            const chunks = [];
+            let size = 0;
+            try {
+                for (;;) {
+                    const { value, done } = await reader.read();
+                    if (done)
+                        break;
+                    size += value.byteLength;
+                    if (size > 32768) {
+                        await reader.cancel();
+                        throw new Error("Response too large");
+                    }
+                    chunks.push(value);
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+            const bytes = new Uint8Array(size);
+            let offset = 0;
+            for (const chunk of chunks) {
+                bytes.set(chunk, offset);
+                offset += chunk.byteLength;
+            }
+            payload = JSON.parse(new TextDecoder().decode(bytes));
+        }
+        catch {
+            throw new Error("Relvo setup returned an invalid response. Rerun setup to resume the saved request.");
+        }
+        if (!response.ok) {
+            const error = z.object({ error: z.object({ message: z.string() }) }).safeParse(payload);
+            throw new Error(error.success && Object.hasOwn(publicSetupErrors, error.data.error.message) ? publicSetupErrors[error.data.error.message] : `Relvo setup request failed (${response.status}). No server details were printed.`);
+        }
+        const envelope = z.object({ data: z.unknown() }).safeParse(payload);
+        const result = schema.safeParse(envelope.success ? envelope.data.data : undefined);
+        if (!result.success)
+            throw new Error("Relvo setup returned an unexpected response. Rerun setup to resume the saved request.");
+        return result.data;
+    }
+    start(input) { return this.request("start", platformLocalSetupStartInputSchema.parse(input), platformLocalSetupStartSchema); }
+    poll(input) { return this.request("poll", platformLocalSetupProofSchema.parse(input), platformLocalSetupPollSchema); }
+    acknowledge(input) { return this.request("ack", platformLocalSetupProofSchema.parse(input), platformLocalSetupAcknowledgedSchema); }
+}