Browser-based graphical shell and control plane for a Linux server you own — real terminal, file manager, live metrics and BYOK AI in one mobile-first workspace. Next.js 16 · React 19 · node-pty · Tailwind v4 · shadcn/ui. Public alpha, self-hosted.
TypeScript browser-shellcontrol-planefile-managerhomelabmobile-firstnextjsptyreactself-hostedserver-managementshadcn-uisysadmintailwindcssterminaltypescriptvpsweb-desktopweb-terminal
import { expandOwnerStorePath } from "@/lib/owner-store-path.js";
import { withSecurityStoreLock } from "@/lib/security-store-lock";
import { constants, promises as fs } from "node:fs";
import os from "node:os";
import path from "node:path";
import type { McpStore } from "./store-types";
const STORE_PATH = expandOwnerStorePath(process.env.OS_MCP_STORE ?? path.join(os.homedir(), ".mso", "mcp.json"));
const MAX_CLIENTS = 64;
const MAX_STORE_BYTES = 4 * 1024 * 1024;
const empty = (): McpStore => ({ clients: {}, codes: {}, tokens: {}, refreshTokens: {}, spentRefreshTokens: {} });
export async function readMcpStore(): Promise<McpStore> {
let raw: string;
let handle: Awaited<ReturnType<typeof fs.open>> | undefined;
try {
handle = await fs.open(STORE_PATH, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
const before = await handle.stat();
if (!before.isFile() || before.size > MAX_STORE_BYTES) throw new Error("MCP credential store size limit reached");
const bytes = Buffer.alloc(before.size + 1);
let used = 0;
while (used < bytes.length) {
const { bytesRead } = await handle.read(bytes, used, bytes.length - used, used);
if (!bytesRead) break;
used += bytesRead;
}
const after = await handle.stat();
if (used !== before.size || after.size !== before.size || after.mtimeMs !== before.mtimeMs) throw new Error("MCP credential store changed while reading");
raw = bytes.subarray(0, used).toString("utf8");
} catch (error) {
if ((error as NodeJS.ErrnoException).code === "ENOENT") return empty();
throw error;
} finally { await handle?.close(); }
const parsed = JSON.parse(raw) as Partial<McpStore>;
return {
clients: parsed.clients ?? {},
codes: parsed.codes ?? {},
tokens: parsed.tokens ?? {},
refreshTokens: parsed.refreshTokens ?? {},
spentRefreshTokens: parsed.spentRefreshTokens ?? {},
};
}
async function writeMcpStore(store: McpStore): Promise<void> {
sweepMcpStore(store);
const limits = { clients: MAX_CLIENTS, codes: 256, tokens: 2048, refreshTokens: 256, spentRefreshTokens: 4096 };
for (const [key, limit] of Object.entries(limits)) if (Object.keys(store[key as keyof McpStore]).length > limit) throw new Error("MCP credential store capacity reached");
for (const clientId of new Set(Object.values(store.tokens).map((token) => token.clientId))) {
if (Object.values(store.tokens).filter((token) => token.clientId === clientId).length > 256 || Object.values(store.refreshTokens).filter((token) => token.clientId === clientId).length > 16) throw new Error("MCP client credential capacity reached");
}
const serialized = JSON.stringify(store, null, 2);
if (Buffer.byteLength(serialized) > MAX_STORE_BYTES) throw new Error("MCP credential store size limit reached");
await fs.mkdir(path.dirname(STORE_PATH), { recursive: true, mode: 0o700 });
const tmp = `${STORE_PATH}.${process.pid}.tmp`;
await fs.writeFile(tmp, serialized, { encoding: "utf8", mode: 0o600 });
await fs.rename(tmp, STORE_PATH);
}
let mutationChain: Promise<unknown> = Promise.resolve();
export function mutateMcpStore<T>(fn: () => Promise<T>): Promise<T> {
const locked = () => withSecurityStoreLock(STORE_PATH, fn);
const run = mutationChain.then(locked, locked);
mutationChain = run.then(() => undefined, () => undefined);
return run;
}
export function sweepMcpStore(store: McpStore): McpStore {
const now = Date.now();
for (const [key, value] of Object.entries(store.codes)) {
if (value.expiresAt < now) delete store.codes[key];
}
for (const [key, value] of Object.entries(store.tokens)) {
if (value.expiresAt > 0 && value.expiresAt < now) delete store.tokens[key];
}
const revoked = Object.entries(store.tokens).filter(([, token]) => token.revokedAt).sort((a, b) => (b[1].revokedAt ?? 0) - (a[1].revokedAt ?? 0));
for (const [key] of revoked.slice(256)) delete store.tokens[key];
for (const [key, value] of Object.entries(store.refreshTokens)) {
if (value.expiresAt < now || value.revokedAt) delete store.refreshTokens[key];
}
for (const [key, value] of Object.entries(store.spentRefreshTokens)) {
if (value.expiresAt < now) delete store.spentRefreshTokens[key];
}
// Recent replay detection is retained; older hashes still cannot mint tokens.
const families = new Map<string, string[]>();
for (const [key, token] of Object.entries(store.spentRefreshTokens)) {
const keys = families.get(token.grantId) ?? []; keys.push(key); families.set(token.grantId, keys);
if (keys.length > 256) delete store.spentRefreshTokens[keys.shift()!];
}
const referenced = referencedClientIds(store);
for (const [id, client] of Object.entries(store.clients)) {
if (!referenced.has(id) && client.createdAt + 3_600_000 < now) delete store.clients[id];
}
return store;
}
function referencedClientIds(store: McpStore): Set<string> {
const now = Date.now();
return new Set([
...Object.values(store.codes).filter((row) => row.expiresAt >= now).map((row) => row.clientId),
...Object.values(store.tokens).filter((row) => !row.revokedAt && (row.expiresAt === 0 || row.expiresAt >= now)).map((row) => row.clientId),
...Object.values(store.refreshTokens).filter((row) => !row.revokedAt && (row.expiresAt === 0 || row.expiresAt >= now)).map((row) => row.clientId),
].filter(Boolean));
}
export function assertMcpClientCapacity(store: McpStore): void {
if (Object.keys(store.clients).length >= MAX_CLIENTS) throw new Error("MCP client registration capacity reached");
}
export async function commitMcpStore(store: McpStore): Promise<void> {
await writeMcpStore(store);
}