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 Anthropic from "@anthropic-ai/sdk";
import {
DEFAULT_PROVIDER,
hostCredentialStore,
readConfig,
readOAuthBundle,
resolveModelRef,
safeProviderId,
selectedCustomConn,
writeOAuthBundle,
type OAuthBundle,
} from "@/lib/config/store";
import { resolveModel } from "@/lib/models";
import { safeProviderFetch } from "@/lib/host/ssrf";
import { ensureFreshCodex } from "@/lib/ai/oauth/codex";
import { streamCodex } from "@/lib/ai/codex-stream";
import { streamOpenAI, type OaMsg, type OaTool } from "@/lib/ai/openai-stream";
import { anthropicDonePayload } from "@/lib/ai/usage";
import { boundedProviderFetch, PROVIDER_TIMEOUT_MS } from "./provider-response";
export type SelectedModelEvent = "delta" | "tool_use" | "done";
export type SelectedModelEmit = (
event: SelectedModelEvent,
data: unknown,
) => void;
type ResolvedModel = Awaited<ReturnType<typeof resolveModel>>;
export type PreparedSelectedModel =
| { kind: "codex"; provider: string; model: string; bundle: OAuthBundle }
| {
kind: "anthropic";
provider: string;
model: string;
resolved: ResolvedModel;
customProvider: boolean;
}
| {
kind: "openai";
provider: string;
model: string;
resolved: ResolvedModel;
customProvider: boolean;
};
export class SelectedModelConfigError extends Error {
constructor(
public readonly code: string,
public readonly status: number,
) {
super(code);
this.name = "SelectedModelConfigError";
}
}
export async function prepareSelectedModel(binding?: { provider: string; model: string }): Promise<PreparedSelectedModel> {
const cfg = await readConfig();
const provider = binding ? safeProviderId(binding.provider) : cfg.provider || DEFAULT_PROVIDER;
const model = binding?.model ?? cfg.model;
if (binding && (!model || model.length > 200 || /\s|\0/.test(model))) throw new SelectedModelConfigError("invalid_model_binding", 400);
if (provider === "openai-codex") {
const existing = await readOAuthBundle("openai-codex");
if (!existing)
throw new SelectedModelConfigError(`no_api_key:${provider}`, 501);
try {
const bundle = await ensureFreshCodex(existing);
if (bundle !== existing) await writeOAuthBundle("openai-codex", bundle);
if (!model)
throw new SelectedModelConfigError("model_not_selected", 400);
return { kind: "codex", provider, model, bundle };
} catch (error) {
if (error instanceof SelectedModelConfigError) throw error;
throw new SelectedModelConfigError("oauth_refresh_failed", 502);
}
}
try {
const custom = binding ? Object.entries(cfg.customProviders ?? {}).find(([id]) => id === provider)?.[1] ?? null : await selectedCustomConn();
const resolved = await resolveModel(binding ? `${provider}/${model}` : await resolveModelRef(), {
store: hostCredentialStore(),
baseUrl: custom?.baseUrl,
protocol: custom?.protocol,
});
return {
kind: resolved.protocol === "anthropic" ? "anthropic" : "openai",
provider,
model: resolved.model,
resolved,
customProvider: Boolean(custom),
} as PreparedSelectedModel;
} catch (error) {
if (error instanceof SelectedModelConfigError) throw error;
throw new SelectedModelConfigError(`no_api_key:${provider}`, 501);
}
}
function toAnthropic(messages: OaMsg[]): Anthropic.MessageParam[] {
const out: Anthropic.MessageParam[] = [];
for (const message of messages) {
if (message.role === "user") {
if (message.text?.trim())
out.push({ role: "user", content: message.text });
continue;
}
if (message.role === "assistant") {
const content: Anthropic.ContentBlockParam[] = [];
if (message.text?.trim())
content.push({ type: "text", text: message.text });
for (const tool of message.toolUses ?? [])
content.push({
type: "tool_use",
id: tool.id,
name: tool.name,
input: tool.input,
});
if (content.length) out.push({ role: "assistant", content });
continue;
}
out.push({
role: "user",
content: message.results.map((result) => ({
type: "tool_result" as const,
tool_use_id: result.id,
content: result.content,
is_error: result.isError,
})),
});
}
return out;
}
export async function streamPreparedSelectedModel(opts: {
prepared: PreparedSelectedModel;
messages: OaMsg[];
tools?: OaTool[];
system: string;
signal: AbortSignal;
emit: SelectedModelEmit;
}): Promise<void> {
const { prepared, messages, tools, system, emit } = opts;
const signal = AbortSignal.any([opts.signal, AbortSignal.timeout(PROVIDER_TIMEOUT_MS)]);
if (prepared.kind === "codex") {
await streamCodex({
bundle: prepared.bundle,
model: prepared.model,
messages,
tools,
system,
signal,
emit,
});
return;
}
if (prepared.kind === "openai") {
await streamOpenAI({
resolved: prepared.resolved,
messages,
tools,
system,
signal,
emit,
...(prepared.customProvider ? { fetchImpl: safeProviderFetch } : {}),
});
return;
}
const anthropic = new Anthropic({
apiKey: prepared.resolved.apiKey,
baseURL: prepared.resolved.baseUrl,
fetch: boundedProviderFetch(prepared.customProvider ? safeProviderFetch : fetch),
});
const ai = anthropic.messages.stream(
{
model: prepared.resolved.model,
max_tokens: 4096,
system: [
{ type: "text", text: system, cache_control: { type: "ephemeral" } },
],
messages: toAnthropic(messages),
...(tools?.length ? { tools: tools as Anthropic.Tool[] } : {}),
},
{ signal },
);
for await (const event of ai) {
if (signal.aborted) break;
if (
event.type === "content_block_delta" &&
event.delta.type === "text_delta"
)
emit("delta", event.delta.text);
}
if (signal.aborted) {
ai.abort();
return;
}
const final = await ai.finalMessage();
for (const use of final.content.filter(
(block): block is Anthropic.ToolUseBlock => block.type === "tool_use",
)) {
emit("tool_use", { id: use.id, name: use.name, input: use.input });
}
emit("done", anthropicDonePayload(final));
}