mirror of
https://github.com/DayuanJiang/next-ai-draw-io.git
synced 2026-10-06 01:37:48 +08:00
dayuan.jiang
c75f74a5a0
MCP preview after the server lost a session (it expired, or the MCP process restarted): - Every server state has an id, made when the state is created. The tab notices a new id even when the version numbers happen to match, and every push names the state it was based on, so one based on a lost state is refused, also when it comes before the tab's first poll (the server recovers the saved file first). - The tab keeps the newest canvas XML, saved or not. When the server knows nothing (no file) or exactly what the tab last saved, the canvas wins and is saved, so edits made while the server was down are kept. Otherwise the server's diagram (an AI write the tab missed, a cleared document that was saved) is shown and the tab's copy goes to History. - Late answers to an old state's push or poll are dropped; a failed push says the server is unreachable; Download as .drawio saves the canvas. Settings and server: - Saved providers this version does not know stay in storage with their keys, and sending no longer trips over them. - The desktop "Ollama (Local)" preset with a key goes to local Ollama again; a server model's Ollama URL variable is read; the admin panel writes Ollama Cloud's URL for a key without one. - Provider error texts show again in the desktop app and for EdgeOne. - .env: a quoted value followed by a comment ending in a quote is read as dotenv reads it; unquoted values are unchanged. - Desktop app: the next launch opens the port where a chat was last saved; a launch elsewhere that saves nothing does not move it, and a page with no chats lets the next launch try the other port once. - The Test button no longer stays busy after another tab changed the key. - A completed append_diagram is no longer undone by an earlier failed edit's preview; a file read once in vain is saved again once it is read or gone. From the first batch's review: - The admin panel's Test of an entry without a URL now tests the server's <P>_BASE_URL, where chat sends the entry's key; chat is unchanged (the first fix rerouted working setups). - The model list ends downloads that are too large, accepts answers without a body, and keeps the "redirects are not allowed" explanation. - A test covers the preview's History rendering.
470 lines
16 KiB
TypeScript
470 lines
16 KiB
TypeScript
import fs from "fs"
|
|
import os from "os"
|
|
import path from "path"
|
|
import { afterEach, beforeEach, describe, expect, it } from "vitest"
|
|
import {
|
|
ADMIN_PROVIDERS_KEY,
|
|
adminProvidersToConfig,
|
|
deriveEnvUpdates,
|
|
loadAdminProviders,
|
|
maskAdminProviders,
|
|
mergeSecrets,
|
|
type StoredAdminProvider,
|
|
validateAdminProviders,
|
|
} from "@/lib/admin/providers"
|
|
import { _resetForTests, saveSettings } from "@/lib/admin/settings"
|
|
import { loadRawServerModelsConfig } from "@/lib/server-model-config"
|
|
|
|
let tmpDir: string
|
|
|
|
beforeEach(() => {
|
|
tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "admin-providers-"))
|
|
process.env.SETTINGS_FILE = path.join(tmpDir, "settings.json")
|
|
_resetForTests()
|
|
})
|
|
|
|
afterEach(() => {
|
|
_resetForTests()
|
|
delete process.env.SETTINGS_FILE
|
|
delete process.env.AI_MODELS_CONFIG
|
|
fs.rmSync(tmpDir, { recursive: true, force: true })
|
|
})
|
|
|
|
function provider(
|
|
overrides: Partial<StoredAdminProvider> = {},
|
|
): StoredAdminProvider {
|
|
return {
|
|
id: "p1",
|
|
provider: "openai",
|
|
apiKey: "sk-test",
|
|
models: ["gpt-5.2"],
|
|
...overrides,
|
|
}
|
|
}
|
|
|
|
describe("deriveEnvUpdates", () => {
|
|
it("writes credentials to ADMIN_-prefixed env vars (never shadows standard vars)", () => {
|
|
const updates = deriveEnvUpdates([provider()], [])
|
|
expect(updates.ADMIN_OPENAI_API_KEY).toBe("sk-test")
|
|
expect(updates.OPENAI_API_KEY).toBeUndefined()
|
|
expect(JSON.parse(updates.ADMIN_PROVIDERS as string)).toHaveLength(1)
|
|
// AI_MODELS_CONFIG is no longer written (merged at read time)
|
|
expect(updates.AI_MODELS_CONFIG).toBeNull()
|
|
})
|
|
|
|
it("suffixes env vars for a second instance of the same provider", () => {
|
|
const updates = deriveEnvUpdates(
|
|
[
|
|
provider({ id: "p1", name: "First" }),
|
|
provider({
|
|
id: "p2",
|
|
name: "Second",
|
|
apiKey: "sk-second",
|
|
models: ["gpt-5-mini"],
|
|
}),
|
|
],
|
|
[],
|
|
)
|
|
expect(updates.ADMIN_OPENAI_API_KEY).toBe("sk-test")
|
|
expect(updates.ADMIN_OPENAI_API_KEY_2).toBe("sk-second")
|
|
})
|
|
|
|
it("sends an Ollama key without a URL to Ollama Cloud, like its Test", () => {
|
|
// Chat sends a server Ollama key to OLLAMA_BASE_URL, or to local
|
|
// Ollama without one; the Test sends it to Ollama Cloud
|
|
const cloud = deriveEnvUpdates(
|
|
[provider({ provider: "ollama", apiKey: "ollama-key" })],
|
|
[],
|
|
)
|
|
expect(cloud.OLLAMA_API_KEY).toBe("ollama-key")
|
|
expect(cloud.OLLAMA_BASE_URL).toBe("https://ollama.com/api")
|
|
const own = deriveEnvUpdates(
|
|
[
|
|
provider({
|
|
provider: "ollama",
|
|
apiKey: "k",
|
|
baseUrl: "https://ollama.internal/api",
|
|
}),
|
|
],
|
|
[],
|
|
)
|
|
expect(own.OLLAMA_BASE_URL).toBe("https://ollama.internal/api")
|
|
// No key: local Ollama, nothing to write
|
|
const local = deriveEnvUpdates(
|
|
[provider({ provider: "ollama", apiKey: undefined })],
|
|
[],
|
|
)
|
|
expect(local.OLLAMA_BASE_URL ?? null).toBeNull()
|
|
})
|
|
|
|
it("maps bedrock credentials to ADMIN_AWS_* env vars", () => {
|
|
const updates = deriveEnvUpdates(
|
|
[
|
|
provider({
|
|
provider: "bedrock",
|
|
apiKey: undefined,
|
|
awsAccessKeyId: "AKIA123",
|
|
awsSecretAccessKey: "secret",
|
|
awsRegion: "us-west-2",
|
|
models: ["claude-x"],
|
|
}),
|
|
],
|
|
[],
|
|
)
|
|
expect(updates.ADMIN_AWS_ACCESS_KEY_ID).toBe("AKIA123")
|
|
expect(updates.ADMIN_AWS_SECRET_ACCESS_KEY).toBe("secret")
|
|
expect(updates.ADMIN_AWS_REGION).toBe("us-west-2")
|
|
// Standard AWS vars are left to the environment
|
|
expect(updates.AWS_ACCESS_KEY_ID).toBeUndefined()
|
|
})
|
|
|
|
it("clears AWS_* bedrock keys written by older versions", () => {
|
|
const bedrock = provider({
|
|
provider: "bedrock",
|
|
apiKey: undefined,
|
|
awsAccessKeyId: "AKIA123",
|
|
awsSecretAccessKey: "secret",
|
|
models: ["claude-x"],
|
|
})
|
|
const updates = deriveEnvUpdates([bedrock], [bedrock])
|
|
expect(updates.AWS_ACCESS_KEY_ID).toBeNull()
|
|
expect(updates.AWS_SECRET_ACCESS_KEY).toBeNull()
|
|
expect(updates.AWS_REGION).toBeNull()
|
|
expect(updates.ADMIN_AWS_ACCESS_KEY_ID).toBe("AKIA123")
|
|
})
|
|
|
|
it("clears keys owned by the previous list when providers are removed", () => {
|
|
const prev = [provider()]
|
|
const updates = deriveEnvUpdates([], prev)
|
|
expect(updates.ADMIN_OPENAI_API_KEY).toBeNull()
|
|
expect(updates.AI_MODELS_CONFIG).toBeNull()
|
|
expect(updates.ADMIN_PROVIDERS).toBeNull()
|
|
})
|
|
|
|
it("sets AI_PROVIDER/AI_MODEL only when a default is flagged", () => {
|
|
const noDefault = deriveEnvUpdates([provider()], [])
|
|
expect(noDefault.AI_PROVIDER).toBeNull()
|
|
expect(noDefault.AI_MODEL).toBeNull()
|
|
|
|
const updates = deriveEnvUpdates(
|
|
[
|
|
provider({ id: "p1" }),
|
|
provider({
|
|
id: "p2",
|
|
provider: "deepseek",
|
|
models: ["deepseek-chat"],
|
|
isDefault: true,
|
|
}),
|
|
],
|
|
[],
|
|
)
|
|
expect(updates.AI_PROVIDER).toBe("deepseek")
|
|
expect(updates.AI_MODEL).toBe("deepseek-chat")
|
|
})
|
|
})
|
|
|
|
describe("adminProvidersToConfig", () => {
|
|
it("builds a config with ADMIN_-prefixed apiKeyEnv wiring", () => {
|
|
const config = adminProvidersToConfig([provider()])
|
|
expect(config.providers).toHaveLength(1)
|
|
expect(config.providers[0].models).toEqual(["gpt-5.2"])
|
|
expect(config.providers[0].apiKeyEnv).toBe("ADMIN_OPENAI_API_KEY")
|
|
})
|
|
|
|
it("wires suffixed env vars for a second instance", () => {
|
|
const config = adminProvidersToConfig([
|
|
provider({ id: "p1", name: "First" }),
|
|
provider({
|
|
id: "p2",
|
|
name: "Second",
|
|
apiKey: "sk-second",
|
|
models: ["gpt-5-mini"],
|
|
}),
|
|
])
|
|
expect(config.providers[1].apiKeyEnv).toBe("ADMIN_OPENAI_API_KEY_2")
|
|
})
|
|
|
|
it("skips providers without models and carries the default flag", () => {
|
|
const config = adminProvidersToConfig([
|
|
provider({ id: "p1", models: [] }),
|
|
provider({ id: "p2", name: "D", isDefault: true }),
|
|
])
|
|
expect(config.providers).toHaveLength(1)
|
|
expect(config.providers[0].default).toBe(true)
|
|
})
|
|
})
|
|
|
|
describe("mergeSecrets", () => {
|
|
it("keeps stored secret when client sends an isSet marker", () => {
|
|
const stored = [provider({ apiKey: "sk-original" })]
|
|
const merged = mergeSecrets(
|
|
[
|
|
{
|
|
...provider(),
|
|
apiKey: { isSet: true, hint: "…test" },
|
|
},
|
|
],
|
|
stored,
|
|
)
|
|
expect(merged[0].apiKey).toBe("sk-original")
|
|
})
|
|
|
|
it("replaces secret when client sends a plaintext string", () => {
|
|
const stored = [provider({ apiKey: "sk-original" })]
|
|
const merged = mergeSecrets(
|
|
[{ ...provider(), apiKey: "sk-new" }],
|
|
stored,
|
|
)
|
|
expect(merged[0].apiKey).toBe("sk-new")
|
|
})
|
|
|
|
it("clears secret when client sends undefined", () => {
|
|
const stored = [provider({ apiKey: "sk-original" })]
|
|
const merged = mergeSecrets(
|
|
[{ ...provider(), apiKey: undefined }],
|
|
stored,
|
|
)
|
|
expect(merged[0].apiKey).toBeUndefined()
|
|
})
|
|
})
|
|
|
|
describe("loadRawServerModelsConfig merge", () => {
|
|
it("combines env AI_MODELS_CONFIG with panel providers", async () => {
|
|
process.env.AI_MODELS_CONFIG = JSON.stringify({
|
|
providers: [
|
|
{
|
|
name: "Env OpenAI",
|
|
provider: "openai",
|
|
models: ["gpt-from-env"],
|
|
default: true,
|
|
},
|
|
],
|
|
})
|
|
saveSettings(deriveEnvUpdates([provider({ name: "Panel" })], []))
|
|
|
|
const merged = await loadRawServerModelsConfig()
|
|
expect(merged?.providers.map((p) => p.name)).toEqual([
|
|
"Env OpenAI",
|
|
"Panel",
|
|
])
|
|
// Env default kept because panel set none
|
|
expect(merged?.providers[0].default).toBe(true)
|
|
})
|
|
|
|
it("panel default overrides the env default", async () => {
|
|
process.env.AI_MODELS_CONFIG = JSON.stringify({
|
|
providers: [
|
|
{
|
|
name: "Env OpenAI",
|
|
provider: "openai",
|
|
models: ["gpt-from-env"],
|
|
default: true,
|
|
},
|
|
],
|
|
})
|
|
saveSettings(
|
|
deriveEnvUpdates(
|
|
[provider({ name: "Panel", isDefault: true })],
|
|
[],
|
|
),
|
|
)
|
|
|
|
const merged = await loadRawServerModelsConfig()
|
|
expect(merged?.providers[0].default).toBeFalsy()
|
|
expect(merged?.providers[1].default).toBe(true)
|
|
})
|
|
|
|
it("returns only env config when the panel has no providers", async () => {
|
|
process.env.AI_MODELS_CONFIG = JSON.stringify({
|
|
providers: [
|
|
{
|
|
name: "Env Only",
|
|
provider: "openai",
|
|
models: ["gpt-from-env"],
|
|
},
|
|
],
|
|
})
|
|
const merged = await loadRawServerModelsConfig()
|
|
expect(merged?.providers.map((p) => p.name)).toEqual(["Env Only"])
|
|
})
|
|
})
|
|
|
|
describe("validateAdminProviders", () => {
|
|
it("rejects names clashing with env-configured providers", () => {
|
|
expect(
|
|
validateAdminProviders([provider({ name: "Env OpenAI" })], {
|
|
providers: [
|
|
{
|
|
name: "Env OpenAI",
|
|
provider: "openai",
|
|
models: ["gpt-x"],
|
|
},
|
|
],
|
|
}),
|
|
).toMatch(/already defined/)
|
|
})
|
|
|
|
it("rejects a global-credential provider already in the env config", () => {
|
|
expect(
|
|
validateAdminProviders(
|
|
[
|
|
provider({
|
|
provider: "bedrock",
|
|
apiKey: undefined,
|
|
awsAccessKeyId: "AKIA-panel",
|
|
awsSecretAccessKey: "panel-secret",
|
|
awsRegion: "us-east-1",
|
|
models: ["claude-x"],
|
|
}),
|
|
],
|
|
{
|
|
providers: [
|
|
{
|
|
name: "Env Bedrock",
|
|
provider: "bedrock",
|
|
models: ["claude-env"],
|
|
},
|
|
],
|
|
},
|
|
),
|
|
).toMatch(/shares global credentials/)
|
|
})
|
|
|
|
it("allows a normal provider type alongside the same env type", () => {
|
|
expect(
|
|
validateAdminProviders([provider({ name: "Panel OpenAI" })], {
|
|
providers: [
|
|
{
|
|
name: "Env OpenAI",
|
|
provider: "openai",
|
|
models: ["gpt-x"],
|
|
},
|
|
],
|
|
}),
|
|
).toBeNull()
|
|
})
|
|
|
|
it("rejects two bedrock instances", () => {
|
|
const list = [
|
|
provider({ id: "p1", provider: "bedrock" }),
|
|
provider({ id: "p2", provider: "bedrock" }),
|
|
]
|
|
expect(validateAdminProviders(list)).toMatch(/Only one/)
|
|
})
|
|
|
|
it("rejects duplicate display names", () => {
|
|
const list = [
|
|
provider({ id: "p1", name: "Same" }),
|
|
provider({ id: "p2", name: "Same" }),
|
|
]
|
|
expect(validateAdminProviders(list)).toMatch(/unique/)
|
|
})
|
|
|
|
it("rejects names that differ only in case or punctuation", () => {
|
|
const list = [
|
|
provider({ id: "p1", name: "Open AI" }),
|
|
provider({ id: "p2", name: "open-ai" }),
|
|
]
|
|
expect(validateAdminProviders(list)).toMatch(/unique/)
|
|
})
|
|
|
|
it("rejects a case-only clash with an env-configured name", () => {
|
|
expect(
|
|
validateAdminProviders([provider({ name: "openai" })], {
|
|
providers: [
|
|
{ name: "OpenAI", provider: "openai", models: ["gpt-x"] },
|
|
],
|
|
}),
|
|
).toMatch(/already defined/)
|
|
})
|
|
|
|
it("accepts distinct CJK names", () => {
|
|
const list = [
|
|
provider({ id: "p1", provider: "deepseek", name: "主力" }),
|
|
provider({ id: "p2", provider: "deepseek", name: "备用" }),
|
|
]
|
|
expect(validateAdminProviders(list)).toBeNull()
|
|
})
|
|
|
|
it("rejects multiple defaults", () => {
|
|
const list = [
|
|
provider({ id: "p1", isDefault: true }),
|
|
provider({ id: "p2", name: "Other", isDefault: true }),
|
|
]
|
|
expect(validateAdminProviders(list)).toMatch(/default/)
|
|
})
|
|
|
|
it("accepts a valid list", () => {
|
|
const list = [
|
|
provider({ id: "p1", isDefault: true }),
|
|
provider({ id: "p2", name: "Backup" }),
|
|
]
|
|
expect(validateAdminProviders(list)).toBeNull()
|
|
})
|
|
})
|
|
|
|
describe("loadAdminProviders", () => {
|
|
it("returns [] when nothing is stored", () => {
|
|
expect(loadAdminProviders()).toEqual([])
|
|
})
|
|
|
|
it("loads valid stored providers", () => {
|
|
saveSettings({ [ADMIN_PROVIDERS_KEY]: JSON.stringify([provider()]) })
|
|
expect(loadAdminProviders()).toHaveLength(1)
|
|
})
|
|
|
|
it("round-trips a bedrock provider with multiple string secrets", () => {
|
|
const bedrock = provider({
|
|
provider: "bedrock",
|
|
apiKey: undefined,
|
|
awsAccessKeyId: "AKIA123",
|
|
awsSecretAccessKey: "secret",
|
|
awsRegion: "us-west-2",
|
|
models: ["claude-x"],
|
|
})
|
|
saveSettings({ [ADMIN_PROVIDERS_KEY]: JSON.stringify([bedrock]) })
|
|
const loaded = loadAdminProviders()
|
|
expect(loaded).toHaveLength(1)
|
|
expect(loaded[0].awsAccessKeyId).toBe("AKIA123")
|
|
expect(loaded[0].awsSecretAccessKey).toBe("secret")
|
|
})
|
|
|
|
it("drops malformed entries and keeps valid ones", () => {
|
|
saveSettings({
|
|
[ADMIN_PROVIDERS_KEY]: JSON.stringify([
|
|
provider({ id: "good" }),
|
|
{ id: "missing-fields" }, // no provider/models
|
|
{ provider: "openai", models: ["x"] }, // no id
|
|
"not-an-object",
|
|
]),
|
|
})
|
|
const loaded = loadAdminProviders()
|
|
expect(loaded).toHaveLength(1)
|
|
expect(loaded[0].id).toBe("good")
|
|
})
|
|
|
|
it("returns [] when the stored value is not an array", () => {
|
|
saveSettings({ [ADMIN_PROVIDERS_KEY]: JSON.stringify({ nope: true }) })
|
|
expect(loadAdminProviders()).toEqual([])
|
|
})
|
|
|
|
it("returns [] on invalid JSON", () => {
|
|
saveSettings({ [ADMIN_PROVIDERS_KEY]: "{ broken" })
|
|
expect(loadAdminProviders()).toEqual([])
|
|
})
|
|
|
|
it("drops entries whose secret is an {isSet} marker, not a string", () => {
|
|
// A hand-edited file could hold a transit-only marker object; if it
|
|
// slipped through, maskSecret() would throw on a non-string value.
|
|
saveSettings({
|
|
[ADMIN_PROVIDERS_KEY]: JSON.stringify([
|
|
{ ...provider(), apiKey: { isSet: true, hint: "…1234" } },
|
|
]),
|
|
})
|
|
const loaded = loadAdminProviders()
|
|
expect(loaded).toEqual([])
|
|
// Masking the loaded list must not throw
|
|
expect(() => maskAdminProviders(loaded)).not.toThrow()
|
|
})
|
|
})
|