Skip to content

Formerly KrillinAI, VideoTranslation and Dubbing Tool for 120+ Languages. Open-source AI workspace for creators, powered by Codex. Video downloader, video translation, create videos, images, audios, and edits with Agents in one place. For your Social Media like YouTube, TikTok, Instagram, etc.

perf: restore official accounts in the background to accelerate startup

wulien-center04a7b103389b
diff --git a/apps/daemon/src/api/server.ts b/apps/daemon/src/api/server.ts
index cbf2ee4f..f94e4855 100644
--- a/apps/daemon/src/api/server.ts
+++ b/apps/daemon/src/api/server.ts
@@ -540,6 +540,7 @@ export async function buildServer(input: BuildServerInput) {
let officialInjectors: Record<string, import('../agent-tools/run-injection.js').AgentScheduleProcessInjector> = {};
const gatewayAccount: GatewayAccountService = createGatewayAccountService({
dataDir, client: gatewayClient,
+ deferStartupActivation: true,
modelAccess: createOfficialModelAccess({
dataDir, fetcher: createOfficialFetch({ readProxy: readCommonProxy }), readProxy: readCommonProxy,
readProbeCredentials: () => gatewayAccount.probeCredentials()
@@ -581,6 +582,7 @@ export async function buildServer(input: BuildServerInput) {
}
}
});
+ await gatewayAccount.initialize();
const creatorAgentRepository = createCreatorAgentRepository(db);
const creatorAgentReconciler = createCreatorAgentReconciler({
repository: creatorAgentRepository
@@ -1227,18 +1229,6 @@ export async function buildServer(input: BuildServerInput) {
creator: creatorService,
dispatcher: creatorCommandDispatcher
});
- void coverWorkflow?.recover().catch(error => {
- console.warn(`Cover workflow recovery failed: ${formatError(error)}`);
- });
- void videoTranslationWorkflow?.recover().catch(error => {
- console.warn(`Video translation workflow recovery failed: ${formatError(error)}`);
- });
- void stickmanVideoWorkflow?.recover().catch(error => {
- console.warn(`Stickman video workflow recovery failed: ${formatError(error)}`);
- });
- void autoClipWorkflow?.recover().catch(error => {
- console.warn(`Video clip workflow recovery failed: ${formatError(error)}`);
- });
const scheduleRunInjector = createAgentScheduleRunInjector({
capabilities: agentCapabilityTokens,
getBaseUrl: getAgentToolBaseUrl,
@@ -1413,7 +1403,28 @@ export async function buildServer(input: BuildServerInput) {
throw error;
});
+ let closing = false;
+ let backgroundStartup: Promise<void> | undefined;
server.addHook('onListen', () => {
+ backgroundStartup = (async () => {
+ await gatewayAccount.startBackgroundRestore();
+ if (closing) return;
+ void coverWorkflow?.recover().catch(error => {
+ console.warn(`Cover workflow recovery failed: ${formatError(error)}`);
+ });
+ void videoTranslationWorkflow?.recover().catch(error => {
+ console.warn(`Video translation workflow recovery failed: ${formatError(error)}`);
+ });
+ void stickmanVideoWorkflow?.recover().catch(error => {
+ console.warn(`Stickman video workflow recovery failed: ${formatError(error)}`);
+ });
+ void autoClipWorkflow?.recover().catch(error => {
+ console.warn(`Video clip workflow recovery failed: ${formatError(error)}`);
+ });
+ if (input.schedulerAutostart === true) scheduler.start();
+ })().catch(error => {
+ console.warn(`Background startup failed: ${formatError(error)}`);
+ });
if (
startKrillinVerification === undefined
|| !hasKrillinRuntimeVerificationWorker()
@@ -1426,9 +1437,11 @@ export async function buildServer(input: BuildServerInput) {
});
server.addHook('onClose', async () => {
+ closing = true;
await youtubeConnection.close();
await douyinConnection.close();
await gatewayAccount.close();
+ await backgroundStartup;
let firstError: unknown;
const capture = async (operation: () => void | Promise<void>) => {
try {
@@ -1562,7 +1575,6 @@ export async function buildServer(input: BuildServerInput) {
: localCodexTextModelDefaults.readStatus(),
storedCreatorServicesConfigStore
);
- await gatewayAccount.readState();
await registerGatewayAccountRoutes(server, gatewayAccount);
await gatewayCreatorSource.register(server);
await registerSmartDubbingRoutes(server, smartDubbingService);
@@ -1650,7 +1662,6 @@ export async function buildServer(input: BuildServerInput) {
}
});
- if (input.schedulerAutostart === true) scheduler.start();
input.onPrepareAvailabilityProbe?.(() => preparePlatformProbe({ account: gatewayAccount, readProxy: readCommonProxy }));
return server;
}
diff --git a/apps/daemon/src/gateway/account-service.ts b/apps/daemon/src/gateway/account-service.ts
index fdf30cf6..fdb7769e 100644
--- a/apps/daemon/src/gateway/account-service.ts
+++ b/apps/daemon/src/gateway/account-service.ts
@@ -12,6 +12,7 @@ export function createGatewayAccountService(input: {
hasPendingTasks?(): boolean;
automaticPolling?: boolean;
modelAccess?: OfficialModelAccess;
+ deferStartupActivation?: boolean;
}) {
const store = createGatewayConfigStore(input.dataDir);
let state: GatewayAccountState = { source: 'manual', authState: 'signed_out', activationState: 'inactive', account: null, bindingVersion: null, models: [], activationError: null };
@@ -21,6 +22,9 @@ export function createGatewayAccountService(input: {
let pollTimer: NodeJS.Timeout | undefined;
let pollWork: { attempt: NonNullable<typeof attempt>; work: Promise<void> } | undefined;
let initialization: Promise<void> | undefined;
+ let startupRestoreWork: Promise<void> | undefined;
+ let startupRestoreFinished = false;
+ let stateRefreshWork: Promise<void> | undefined;
let refreshWork: Promise<void> | undefined;
let profileWork: Promise<void> | undefined;
let profileUpdatedAt = 0;
@@ -103,10 +107,29 @@ export function createGatewayAccountService(input: {
await saveConfiguration();
if (!credentials) return;
state.account = credentials.account ?? null; state.authState = 'signed_in'; state.models = credentials.models ?? [];
+ if (input.deferStartupActivation) {
+ const cached = bootstrapSchema.safeParse(credentials);
+ if (cached.success) state.models = (await visibleBootstrap(cached.data)).models;
+ state.activationState = 'loading';
+ return;
+ }
await refresh();
await activateCurrent();
} catch (error) { fail(error); }
}
+ function startBackgroundRestore(): Promise<void> {
+ if (!input.deferStartupActivation || closing) return Promise.resolve();
+ startupRestoreWork ??= (async () => {
+ await initialize();
+ if (!credentials || state.authState !== 'signed_in') return;
+ await serialize(async () => {
+ if (!closing && !accessPaused && state.authState === 'signed_in' && state.activationState === 'loading') {
+ await activateCurrent();
+ }
+ });
+ })().catch(error => { if (!closing) fail(error); }).finally(() => { startupRestoreFinished = true; });
+ return startupRestoreWork;
+ }
async function refresh() {
if (refreshWork) return refreshWork;
refreshWork = (async () => {
@@ -114,11 +137,11 @@ export function createGatewayAccountService(input: {
if (Date.parse(original.accessExpiresAt) > Date.now() + 60_000) return;
try {
const tokens = await input.client.refresh(original.refreshToken);
- if (generation !== expected || credentials !== original || state.authState !== 'signed_in') return;
+ if (closing || accessPaused || generation !== expected || credentials !== original || state.authState !== 'signed_in') return;
credentials = { ...original, ...tokens, accessExpiresAt: new Date(Date.now() + tokens.expiresIn * 1000).toISOString() };
await store.writeCredentials(credentials);
} catch (error) {
- if (error instanceof GatewayError && error.status === 401 && generation === expected && credentials === original && state.authState === 'signed_in') {
+ if (!closing && !accessPaused && error instanceof GatewayError && error.status === 401 && generation === expected && credentials === original && state.authState === 'signed_in') {
state = { ...state, authState: 'expired', activationState: 'inactive', bindingVersion: null, activationError: null };
runtimeTextModel = undefined; accessController?.abort();
clearInterval(usageTimer); usageTimer = undefined;
@@ -133,50 +156,55 @@ export function createGatewayAccountService(input: {
// Connecting a new session must not wait for unrelated or persisted jobs.
if (state.activationState === 'ready') assertIdle();
await refresh();
+ if (closing || accessPaused) return;
const original = assertSignedIn(); const expected = generation;
state.activationState = 'loading'; state.activationError = null;
try {
state.source = 'gateway'; state.bindingVersion = null;
await saveConfiguration();
await reportUsage();
+ if (closing || accessPaused || generation !== expected || state.authState !== 'signed_in') return;
const bootstrap = await input.client.bootstrap(original.accessToken, { rotate: !input.hasPendingTasks?.() });
- if (generation !== expected || state.authState !== 'signed_in') return;
+ if (closing || accessPaused || generation !== expected || state.authState !== 'signed_in') return;
if (original.account && bootstrap.account.id !== original.account.id) throw new GatewayError('account_mismatch');
state.account = bootstrap.account;
for (const [modality, model] of Object.entries(selectedModels)) {
if (bootstrap.models.some(candidate => candidate.modality === modality && candidate.id === model)) bootstrap.defaults[modality] = model;
}
const visible = await visibleBootstrap(bootstrap);
- if (generation !== expected || state.authState !== 'signed_in') return;
+ if (closing || accessPaused || generation !== expected || state.authState !== 'signed_in') return;
selectedModels = { ...visible.defaults }; state.selectedModels = { ...selectedModels };
credentials = { ...original, ...bootstrap, defaults: visible.defaults };
await store.writeCredentials(credentials);
+ if (closing || accessPaused || generation !== expected || state.authState !== 'signed_in') return;
state.account = bootstrap.account; state.models = visible.models;
accessBlocked = !visible.defaults.text;
if (accessBlocked) throw new GatewayError('services_not_ready');
await input.activateRuntime(visible);
runtimeTextModel = visible.defaults.text;
- if (generation !== expected || state.authState !== 'signed_in') { await input.closeRuntime(); return; }
+ if (closing || accessPaused || generation !== expected || state.authState !== 'signed_in') { await input.closeRuntime(); return; }
state.bindingVersion = bootstrap.bindingVersion;
catalogUpdatedAt = Date.now();
await saveConfiguration();
+ if (closing || accessPaused || generation !== expected || state.authState !== 'signed_in') { await input.closeRuntime(); return; }
state = { ...state, source: 'gateway', activationState: 'ready', account: bootstrap.account, models: visible.models, bindingVersion: bootstrap.bindingVersion, activationError: null };
await reportUsage();
startUsageHeartbeat();
- } catch (error) { runtimeTextModel = undefined; fail(error); await input.closeRuntime(); }
+ } catch (error) { runtimeTextModel = undefined; if (!closing && !accessPaused) fail(error); await input.closeRuntime(); }
scheduleModelAccess();
}
async function readProfile() {
- if (!credentials || state.authState !== 'signed_in') return;
+ if (closing || accessPaused || !credentials || state.authState !== 'signed_in') return;
if (profileWork) return profileWork;
if (Date.now() - profileUpdatedAt < 30_000) return;
profileUpdatedAt = Date.now();
profileWork = (async () => {
await refresh();
+ if (closing || accessPaused) return;
const original = assertSignedIn(); const expected = generation;
const profile = z.object({ account: accountSchema }).parse(await input.client.request('/api/v1/me', original.accessToken));
await serialize(async () => {
- if (expected !== generation || credentials !== original || state.authState !== 'signed_in') return;
+ if (closing || accessPaused || expected !== generation || credentials !== original || state.authState !== 'signed_in') return;
if (original.account && profile.account.id !== original.account.id) throw new GatewayError('account_mismatch');
const next = { ...original, account: profile.account };
await store.writeCredentials(next);
@@ -187,21 +215,30 @@ export function createGatewayAccountService(input: {
finally { profileWork = undefined; }
}
async function readCatalog() {
- if (!credentials || state.authState !== 'signed_in' || state.source !== 'gateway' || state.activationState !== 'ready') return;
+ if (closing || accessPaused || !credentials || state.authState !== 'signed_in' || state.source !== 'gateway' || state.activationState !== 'ready') return;
if (catalogWork) return catalogWork;
if (input.hasActiveTasks() || input.hasPendingTasks?.() || Date.now() - catalogUpdatedAt < 30_000) return;
catalogUpdatedAt = Date.now();
catalogWork = (async () => {
await refresh();
+ if (closing || accessPaused) return;
const original = assertSignedIn(); const expected = generation;
const catalog = catalogSchema.parse(await input.client.request('/api/v1/client/models', original.accessToken));
await serialize(async () => {
- if (generation !== expected || credentials !== original || state.source !== 'gateway' || state.authState !== 'signed_in' || input.hasActiveTasks() || input.hasPendingTasks?.()) return;
+ if (closing || accessPaused || generation !== expected || credentials !== original || state.source !== 'gateway' || state.authState !== 'signed_in' || input.hasActiveTasks() || input.hasPendingTasks?.()) return;
if (original.rotationPending || JSON.stringify(catalog.models) !== JSON.stringify(original.models)) await activateCurrent();
});
})().catch(() => undefined);
try { await catalogWork; } finally { catalogWork = undefined; }
}
+ function refreshState(): Promise<void> {
+ stateRefreshWork ??= (async () => {
+ await readProfile(); await readCatalog();
+ if (needsAccessibleRuntime()) await serialize(synchronizeAccessibleRuntime);
+ scheduleModelAccess();
+ })().finally(() => { stateRefreshWork = undefined; });
+ return stateRefreshWork;
+ }
function schedulePoll(id: string, seconds: number) {
if (attempt?.attemptId !== id) return;
attempt.nextPollAt = Date.now() + Math.max(5, seconds) * 1000;
@@ -303,13 +340,16 @@ export function createGatewayAccountService(input: {
platformProbeWork = work;
try { return await work; } finally { if (platformProbeWork === work) platformProbeWork = undefined; }
}
- function reportUsage() {
+ function reportUsage(allowClosing = false) {
const result = usageMutation.then(async () => {
- if (!credentials?.keyRotation || !credentials.keyVersion || state.authState !== 'signed_in') return undefined;
+ if ((closing && !allowClosing) || !credentials?.keyRotation || !credentials.keyVersion || state.authState !== 'signed_in') return undefined;
await refresh();
+ if (closing && !allowClosing) return undefined;
const current = assertSignedIn(); const expected = generation;
+ const installationId = await store.readDeviceID();
+ if (closing && !allowClosing) return undefined;
const value = z.object({ keyVersion: z.string().min(1) }).parse(await input.client.request('/api/v1/client/usage', current.accessToken, {
- keyVersion: current.keyVersion, installationId: await store.readDeviceID(), busy: localUses > 0 || input.hasActiveTasks(), pending: input.hasPendingTasks?.() === true
+ keyVersion: current.keyVersion, installationId, busy: localUses > 0 || input.hasActiveTasks(), pending: input.hasPendingTasks?.() === true
}));
if (generation !== expected || state.authState !== 'signed_in') throw new GatewayError('auth_required', 401);
return value.keyVersion;
@@ -318,7 +358,7 @@ export function createGatewayAccountService(input: {
return result;
}
function startUsageHeartbeat() {
- if (usageTimer || !credentials?.keyRotation || input.automaticPolling === false) return;
+ if (closing || accessPaused || usageTimer || !credentials?.keyRotation || input.automaticPolling === false) return;
usageTimer = setInterval(() => { void reportUsage().catch(() => undefined); }, 10_000);
usageTimer.unref();
}
@@ -362,6 +402,7 @@ export function createGatewayAccountService(input: {
async function logout() {
await initialize();
accessPaused = true;
+ input.client.cancelPendingRequests?.();
accessController?.abort(); await accessWork;
await serialize(async () => {
await reportUsage().catch(() => undefined);
@@ -385,6 +426,7 @@ export function createGatewayAccountService(input: {
} catch (error) { return { status: 'unavailable', lastKnown: balance, code: error instanceof GatewayError ? error.code : 'gateway_unavailable' }; }
}
return {
+ initialize, startBackgroundRestore,
peekState() { return structuredClone(state); },
startAuthorization, cancelAuthorization, pollAuthorization, checkAuthorization, refresh, logout, modelCredentials, beginModelUse, probeCredentials, readBalance, billing,
readPlans() { return input.client.request('/api/v1/plans', ''); },
@@ -400,10 +442,11 @@ export function createGatewayAccountService(input: {
async readState() {
await initialize();
// Login is visible while model preparation still owns the mutation queue.
- if (state.activationState === 'loading' || state.authState === 'signing_out') return structuredClone(state);
- await readProfile(); await readCatalog();
- if (needsAccessibleRuntime()) await serialize(synchronizeAccessibleRuntime);
- scheduleModelAccess(); return structuredClone(state);
+ if (closing || state.activationState === 'loading' || state.authState === 'signing_out') return structuredClone(state);
+ const work = refreshState();
+ if (input.deferStartupActivation) void work.catch(() => undefined);
+ else await work;
+ return structuredClone(state);
},
async setSource(source: ServiceSource) {
await initialize(); await serialize(async () => {
@@ -424,7 +467,16 @@ export function createGatewayAccountService(input: {
});
return structuredClone(state);
},
- async close() { closing = true; accessController?.abort(); await accessWork; clearTimeout(pollTimer); clearInterval(usageTimer); usageTimer = undefined; await profileWork; await catalogWork; await mutation; await refreshWork?.catch(() => undefined); await input.closeRuntime(); await reportUsage().catch(() => undefined); await usageMutation; generation++; }
+ async close() {
+ const restoring = startupRestoreWork !== undefined && !startupRestoreFinished;
+ closing = true; input.client.cancelPendingRequests?.(); accessController?.abort();
+ clearTimeout(pollTimer); clearInterval(usageTimer); usageTimer = undefined;
+ await initialization; await startupRestoreWork; await stateRefreshWork?.catch(() => undefined);
+ await accessWork; await profileWork; await catalogWork; await mutation; await refreshWork?.catch(() => undefined);
+ await input.closeRuntime();
+ if (!restoring && state.activationState === 'ready') await reportUsage(true).catch(() => undefined);
+ await usageMutation; generation++;
+ }
};
}
export type GatewayAccountService = ReturnType<typeof createGatewayAccountService>;
diff --git a/apps/daemon/src/gateway/client.ts b/apps/daemon/src/gateway/client.ts
index 10d2b695..ce0e49e4 100644
--- a/apps/daemon/src/gateway/client.ts
+++ b/apps/daemon/src/gateway/client.ts
@@ -43,6 +43,7 @@ export type GatewayClient = {
avatar(access: string, accountId: string): Promise<{ data: Uint8Array; contentType: string }>;
logout(access: string): Promise<void>;
request(path: string, access: string, body?: unknown): Promise<unknown>;
+ cancelPendingRequests?(): void;
};
export class GatewayError extends Error {
constructor(readonly code: string, readonly status = 503) { super('OpenCreator 网关请求未完成'); }
@@ -55,25 +56,30 @@ export function validateGatewayOrigin(origin: string) {
}
export function createGatewayClient(origin: string, fetcher: typeof fetch = fetch): GatewayClient {
origin = validateGatewayOrigin(origin);
+ const pendingRequests = new Set<AbortController>();
async function readResponse(path: string, access: string, body?: unknown) {
if (!path.startsWith('/api/v1/') || path.includes('..')) throw new GatewayError('invalid_gateway_path');
- let res: Response;
+ const controller = new AbortController();
+ pendingRequests.add(controller);
try {
- res = await fetcher(`${origin}${path}`, { method: body === undefined ? 'GET' : 'POST', redirect: 'error', signal: AbortSignal.timeout(30_000),
- headers: { 'Content-Type': 'application/json', ...(access ? { Authorization: `Bearer ${access}` } : {}) }, ...(body === undefined ? {} : { body: JSON.stringify(body) }) });
- } catch { throw new GatewayError('gateway_unavailable'); }
- const reader = res.body?.getReader();
- if (!reader) throw new GatewayError('invalid_gateway_response');
- const chunks: Uint8Array[] = []; let size = 0;
- try {
- while (true) {
- const item = await reader.read(); if (item.done) break;
- size += item.value.byteLength;
- if (size > 1024 * 1024) { await reader.cancel(); throw new GatewayError('invalid_gateway_response'); }
- chunks.push(item.value);
- }
- } catch (error) { if (error instanceof GatewayError) throw error; throw new GatewayError('gateway_unavailable'); }
- return { res, data: Buffer.concat(chunks) };
+ let res: Response;
+ try {
+ res = await fetcher(`${origin}${path}`, { method: body === undefined ? 'GET' : 'POST', redirect: 'error', signal: AbortSignal.any([controller.signal, AbortSignal.timeout(30_000)]),
+ headers: { 'Content-Type': 'application/json', ...(access ? { Authorization: `Bearer ${access}` } : {}) }, ...(body === undefined ? {} : { body: JSON.stringify(body) }) });
+ } catch { throw new GatewayError('gateway_unavailable'); }
+ const reader = res.body?.getReader();
+ if (!reader) throw new GatewayError('invalid_gateway_response');
+ const chunks: Uint8Array[] = []; let size = 0;
+ try {
+ while (true) {
+ const item = await reader.read(); if (item.done) break;
+ size += item.value.byteLength;
+ if (size > 1024 * 1024) { await reader.cancel(); throw new GatewayError('invalid_gateway_response'); }
+ chunks.push(item.value);
+ }
+ } catch (error) { if (error instanceof GatewayError) throw error; throw new GatewayError('gateway_unavailable'); }
+ return { res, data: Buffer.concat(chunks) };
+ } finally { pendingRequests.delete(controller); }
}
function responseError(data: Uint8Array, status: number): never {
let value: unknown;
@@ -90,6 +96,7 @@ export function createGatewayClient(origin: string, fetcher: typeof fetch = fetc
}
return {
origin, request,
+ cancelPendingRequests() { for (const controller of pendingRequests) controller.abort(); },
async startDevice() { return z.object({ attemptId: z.string().min(1), deviceSecret: z.string().min(12), authorizationUrl: z.string().url(), interval: z.number().positive(), expiresIn: z.number().positive() }).parse(await request('/api/v1/auth/device/start', '', { label: 'OpenCreator' })); },
async pollDevice(attemptId, deviceSecret) { return tokenSchema.parse(await request('/api/v1/auth/device/token', '', { attemptId, deviceSecret })); },
async cancelDevice(attemptId, deviceSecret) { await request('/api/v1/auth/device/cancel', '', { attemptId, deviceSecret }); },
diff --git a/apps/daemon/test/integration/api.test.ts b/apps/daemon/test/integration/api.test.ts
index 38beaf30..c75133ad 100644
--- a/apps/daemon/test/integration/api.test.ts
+++ b/apps/daemon/test/integration/api.test.ts
@@ -87,7 +87,10 @@ describe('runtime api', () => {
schedulerAutostart: true
});
- expect(scheduler.start).toHaveBeenCalledTimes(1);
+ expect(scheduler.start).not.toHaveBeenCalled();
+ expect(steps).toEqual(['repair', 'classify']);
+ await server.listen({ host: '127.0.0.1', port: 0 });
+ await expect.poll(() => vi.mocked(scheduler.start).mock.calls.length).toBe(1);
expect(steps).toEqual(['repair', 'classify', 'start']);
await server.close();
diff --git a/apps/daemon/test/integration/gateway-startup.test.ts b/apps/daemon/test/integration/gateway-startup.test.ts
new file mode 100644
index 00000000..d23aa7b9
--- /dev/null
+++ b/apps/daemon/test/integration/gateway-startup.test.ts
@@ -0,0 +1,70 @@
+import { createServer } from 'node:http';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { expect, it, vi } from 'vitest';
+import { buildServer } from '../../src/api/server.js';
+import { createGatewayConfigStore } from '../../src/gateway/config-store.js';
+import type { SchedulerService } from '../../src/scheduler/service.js';
+
+it.each([true, false])('网关请求未完成时本地服务已可用,调度等待恢复且关闭会取消恢复(提前关闭=%s)', async closeWhileRestoring => {
+ const root = await mkdtemp(join(tmpdir(), 'oc-gateway-startup-'));
+ let release!: () => void;
+ const waiting = new Promise<void>(resolve => { release = resolve; });
+ let bootstrapStarted = false;
+ let bootstrapCanceled = false;
+ const gateway = createServer(async (_request, response) => {
+ bootstrapStarted = true;
+ response.once('close', () => { bootstrapCanceled = true; });
+ await waiting;
+ if (!response.destroyed) response.writeHead(503, { 'Content-Type': 'application/json' }).end(JSON.stringify({ error: { code: 'gateway_unavailable' } }));
+ });
+ await new Promise<void>(resolve => gateway.listen(0, '127.0.0.1', resolve));
+ const address = gateway.address();
+ if (!address || typeof address === 'string') throw new Error('Missing gateway address');
+ const origin = `http://127.0.0.1:${address.port}`;
+ const dataDir = join(root, 'data');
+ await createGatewayConfigStore(dataDir).writeCredentials({
+ schemaVersion: 1, account: { id: 'a', email: '[email protected]', verified: true },
+ accessToken: 'private-access-token', refreshToken: 'private-refresh-token',
+ expiresIn: 900, accessExpiresAt: new Date(Date.now() + 900_000).toISOString(),
+ modelKey: 'private-model-key', keyVersion: '1', bindingVersion: 'a:1', baseUrl: `${origin}/v1`,
+ models: [{ id: 'official-model', modality: 'text', capabilities: ['responses'] }], defaults: { text: 'official-model' }
+ });
+ let server: Awaited<ReturnType<typeof buildServer>> | undefined;
+ const start = vi.fn();
+ const stop = vi.fn();
+ const scheduler = { start, stop, refreshTimer: vi.fn() } as unknown as SchedulerService;
+ try {
+ server = await buildServer({ token: 'local-runtime-token', appHome: root, dataDir,
+ codexHome: join(root, 'codex'), localCodexHome: join(root, 'codex'),
+ defaultCwd: root, defaultProjectRoot: join(root, 'projects'), gatewayOrigin: origin,
+ creatorExecutors: [], schedulerAutostart: true, scheduler
+ });
+ expect(bootstrapStarted).toBe(false);
+ expect(start).not.toHaveBeenCalled();
+ await server.listen({ host: '127.0.0.1', port: 0 });
+ await expect.poll(() => bootstrapStarted).toBe(true);
+ expect((await server.inject('/healthz')).json()).toEqual({ ok: true });
+ const state = await server.inject({ method: 'GET', url: '/gateway/account', headers: { authorization: 'Bearer local-runtime-token' } });
+ expect(state.json()).toMatchObject({ source: 'gateway', authState: 'signed_in', activationState: 'loading', account: { id: 'a' } });
+ expect(state.body).not.toContain('private-');
+ expect(start).not.toHaveBeenCalled();
+ if (!closeWhileRestoring) {
+ release();
+ await expect.poll(() => start.mock.calls.length).toBe(1);
+ expect((await server.inject({ url: '/gateway/account', headers: { authorization: 'Bearer local-runtime-token' } })).json())
+ .toMatchObject({ authState: 'signed_in', activationState: 'blocked' });
+ }
+ await server.close();
+ await expect.poll(() => bootstrapCanceled).toBe(true);
+ expect(start).toHaveBeenCalledTimes(closeWhileRestoring ? 0 : 1);
+ expect(stop).toHaveBeenCalled();
+ } finally {
+ release();
+ await server?.close();
+ gateway.closeAllConnections();
+ await new Promise<void>(resolve => gateway.close(() => resolve()));
+ await rm(root, { recursive: true, force: true });
+ }
+});
diff --git a/apps/daemon/test/unit/gateway-account-service.test.ts b/apps/daemon/test/unit/gateway-account-service.test.ts
index 7ac2a87f..2e340089 100644
--- a/apps/daemon/test/unit/gateway-account-service.test.ts
+++ b/apps/daemon/test/unit/gateway-account-service.test.ts
@@ -10,6 +10,8 @@ import { registerGatewayAccountRoutes } from '../../src/api/routes.gateway-accou
import { createOfficialModelAccess, type OfficialModelAccess } from '../../src/gateway/model-access.js';
import { createGatewayCreatorSource } from '../../src/gateway/creator-service-source.js';
import { createDefaultCreatorServicesConfig } from '@opencreator/protocol';
+import { createRuntimeSource } from '../../src/gateway/runtime-source.js';
+import type { AppServerRuntimeManager } from '../../src/codex/app-server-runtime-manager.js';
const roots: string[] = [];
const platformCredentials = (): GatewayProbeCredentials => ({
@@ -17,7 +19,7 @@ const platformCredentials = (): GatewayProbeCredentials => ({
baseUrl: 'https://openrouter.ai/api/v1', expiresAt: new Date(Date.now() + 60 * 60_000).toISOString()
});
afterEach(async () => { await Promise.all(roots.splice(0).map(root => rm(root, { recursive: true, force: true }))); });
-async function setup(activate = vi.fn(async () => undefined), close = vi.fn(async () => undefined), hasPendingTasks = () => false, hasActiveTasks = () => false, modelAccess?: (root: string, readProbeCredentials: () => Promise<GatewayProbeCredentials>) => OfficialModelAccess) {
+async function setup(activate = vi.fn(async () => undefined), close = vi.fn(async () => undefined), hasPendingTasks = () => false, hasActiveTasks = () => false, modelAccess?: (root: string, readProbeCredentials: () => Promise<GatewayProbeCredentials>) => OfficialModelAccess, deferStartupActivation = false) {
expect(module).toHaveProperty('createGatewayAccountService', expect.any(Function));
const root = await mkdtemp(join(tmpdir(), 'oc-gateway-account-')); roots.push(root);
let attempt = 0;
@@ -30,15 +32,118 @@ async function setup(activate = vi.fn(async () => undefined), close = vi.fn(asyn
async logout() {},
avatar: vi.fn(async () => ({ data: new Uint8Array([1, 2, 3]), contentType: 'image/png' })),
bootstrap: vi.fn(async (access: string): Promise<GatewayBootstrap> => { const id = access.split('-').at(-1)!; return { schemaVersion: 1 as const, account: { id, email: `${id}@example.test`, verified: true }, modelKey: `cloud-${id}`, keyVersion: '1', bindingVersion: `${id}:1`, baseUrl: 'https://gateway.example/v1', models: [{ id: 'gateway-text', modality: 'text' as const, capabilities: ['responses'] }], defaults: { text: 'gateway-text' } }; }),
- async request(path?: string) { return path === '/api/v1/client/probe-credentials' ? platformCredentials() : {}; }
+ async request(path?: string) { return path === '/api/v1/client/probe-credentials' ? platformCredentials() : {}; },
+ cancelPendingRequests: vi.fn()
};
const service: module.GatewayAccountService = module.createGatewayAccountService({
- dataDir: root, client, activateRuntime: activate, closeRuntime: close, hasActiveTasks, hasPendingTasks, automaticPolling: false,
+ dataDir: root, client, activateRuntime: activate, closeRuntime: close, hasActiveTasks, hasPendingTasks, automaticPolling: false, deferStartupActivation,
modelAccess: modelAccess?.(root, () => service.probeCredentials())
});
return { service, root, client, activate, close };
}
+async function seedSavedAccount(f: Awaited<ReturnType<typeof setup>>) {
+ const bootstrap = await f.client.bootstrap('access-1');
+ const store = createGatewayConfigStore(f.root);
+ await store.writeConfiguration({ source: 'gateway', bindingVersion: bootstrap.bindingVersion, selectedModels: bootstrap.defaults });
+ await store.writeCredentials({ ...bootstrap, accessToken: 'access-1', refreshToken: 'refresh-1', expiresIn: 900, accessExpiresAt: new Date(Date.now() + 900_000).toISOString() });
+ f.client.bootstrap.mockClear();
+ return bootstrap;
+}
+
+it('本地账号初始化不联网,恢复期间状态可读且任务不会回退到个人模型', async () => {
+ const f = await setup(undefined, undefined, undefined, undefined, undefined, true);
+ const bootstrap = await seedSavedAccount(f);
+ let release!: () => void;
+ const waiting = new Promise<void>(resolve => { release = resolve; });
+ f.client.bootstrap.mockImplementation(async () => { await waiting; return bootstrap; });
+ try {
+ await f.service.initialize();
+ expect(f.client.bootstrap).not.toHaveBeenCalled();
+ expect(f.client.refresh).not.toHaveBeenCalled();
+ expect(await f.service.readState()).toMatchObject({ source: 'gateway', authState: 'signed_in', activationState: 'loading', account: bootstrap.account, selectedModels: bootstrap.defaults });
+ f.service.startBackgroundRestore();
+ f.service.startBackgroundRestore();
+ await expect.poll(() => f.client.bootstrap.mock.calls.length).toBe(1);
+ expect(await f.service.readState()).toMatchObject({ source: 'gateway', activationState: 'loading' });
+ const manual = { startTurn: vi.fn() } as unknown as AppServerRuntimeManager;
+ const runtime = createRuntimeSource(manual, f.service.peekState, () => undefined);
+ expect(() => runtime.startTurn({} as Parameters<AppServerRuntimeManager['startTurn']>[0])).toThrow(GatewayError);
+ expect(manual.startTurn).not.toHaveBeenCalled();
+ release();
+ await expect.poll(() => f.service.peekState().activationState).toBe('ready');
+ expect(f.activate).toHaveBeenCalledOnce();
+ } finally { release(); await f.service.close(); }
+});
+
+it('后台恢复失败时保留登录态并允许重试', async () => {
+ const f = await setup(undefined, undefined, undefined, undefined, undefined, true);
+ await seedSavedAccount(f);
+ f.client.bootstrap.mockRejectedValueOnce(new GatewayError('gateway_unavailable'));
+ try {
+ await f.service.initialize();
+ f.service.startBackgroundRestore();
+ await expect.poll(() => f.service.peekState().activationState).toBe('blocked');
+ expect(await f.service.readState()).toMatchObject({ source: 'gateway', authState: 'signed_in', account: { id: '1' } });
+ await f.service.activate();
+ expect(f.service.peekState().activationState).toBe('ready');
+ } finally { await f.service.close(); }
+});
+
+it('账号资料刷新不阻塞缓存状态读取,连续读取只发送一个请求', async () => {
+ const f = await setup(undefined, undefined, undefined, undefined, undefined, true);
+ const bootstrap = await seedSavedAccount(f);
+ let release!: () => void;
+ const waiting = new Promise<void>(resolve => { release = resolve; });
+ const request = vi.spyOn(f.client, 'request').mockImplementation(async () => {
+ await waiting; return { account: { ...bootstrap.account, email: '[email protected]' } };
+ });
+ try {
+ await f.service.initialize(); f.service.startBackgroundRestore();
+ await expect.poll(() => f.service.peekState().activationState).toBe('ready');
+ const first = await f.service.readState();
+ await f.service.readState();
+ expect(first.account).toEqual(bootstrap.account);
+ expect(request).toHaveBeenCalledOnce();
+ release();
+ await expect.poll(() => f.service.peekState().account?.email).toBe('[email protected]');
+ } finally { release(); await f.service.close(); }
+});
+
+it.each(['close', 'logout'] as const)('后台恢复等待网络时可以%s,迟到结果不会激活模型', async action => {
+ const f = await setup(undefined, undefined, undefined, undefined, undefined, true);
+ await seedSavedAccount(f);
+ let rejectBootstrap!: (error: Error) => void;
+ f.client.bootstrap.mockImplementation(() => new Promise((_resolve, reject) => { rejectBootstrap = reject; }));
+ f.client.cancelPendingRequests.mockImplementation(() => rejectBootstrap?.(new GatewayError('gateway_unavailable')));
+ try {
+ await f.service.initialize(); f.service.startBackgroundRestore();
+ await expect.poll(() => f.client.bootstrap.mock.calls.length).toBe(1);
+ await f.service[action]();
+ expect(f.client.cancelPendingRequests).toHaveBeenCalled();
+ expect(f.activate).not.toHaveBeenCalled();
+ if (action === 'logout') expect(f.service.peekState()).toMatchObject({ source: 'manual', authState: 'signed_out', activationState: 'inactive' });
+ } finally { await f.service.close(); }
+});
+
+it('启动用量上报挂起时关闭会取消请求,不会继续启动或发送结束上报', async () => {
+ const f = await setup(undefined, undefined, undefined, undefined, undefined, true);
+ await seedSavedAccount(f);
+ const store = createGatewayConfigStore(f.root);
+ await store.writeCredentials({ ...(await store.readCredentials())!, keyRotation: true });
+ let rejectUsage!: (error: Error) => void;
+ const request = vi.spyOn(f.client, 'request').mockImplementation(() => new Promise((_resolve, reject) => { rejectUsage = reject; }));
+ f.client.cancelPendingRequests.mockImplementation(() => rejectUsage?.(new GatewayError('gateway_unavailable')));
+ try {
+ await f.service.initialize(); f.service.startBackgroundRestore();
+ await expect.poll(() => request.mock.calls.length).toBe(1);
+ await f.service.close();
+ expect(request).toHaveBeenCalledOnce();
+ expect(f.client.bootstrap).not.toHaveBeenCalled();
+ expect(f.activate).not.toHaveBeenCalled();
+ } finally { await f.service.close(); }
+});
+
it('returns signed-in state immediately while bootstrap is still preparing model services', async () => {
const f = await setup();
const bootstrap = await f.client.bootstrap('access-1');
diff --git a/apps/daemon/test/unit/gateway-client.test.ts b/apps/daemon/test/unit/gateway-client.test.ts
index 09bf5b9a..c7fb32fe 100644
--- a/apps/daemon/test/unit/gateway-client.test.ts
+++ b/apps/daemon/test/unit/gateway-client.test.ts
@@ -32,3 +32,35 @@ it('rejects oversized and non-image avatar responses and preserves account error
const client = createGatewayClient('https://gateway.example', vi.fn(async () => Response.json({ error: { code: 'auth_required' } }, { status: 401 })));
await expect(client.avatar('private-device-token', 'a')).rejects.toMatchObject({ code: 'auth_required', status: 401 });
});
+
+it('取消未完成的请求后仍能发起新的请求', async () => {
+ const fetcher = vi.fn<typeof fetch>().mockImplementationOnce(async (_url, options) => (
+ new Promise<Response>((_resolve, reject) => {
+ options!.signal!.addEventListener('abort', () => reject(options!.signal!.reason), { once: true });
+ })
+ )).mockResolvedValue(Response.json({ account: { id: 'a' } }));
+ const client = createGatewayClient('https://gateway.example', fetcher);
+ const pending = client.request('/api/v1/me', 'device-token');
+ const rejected = expect(pending).rejects.toMatchObject({ code: 'gateway_unavailable' });
+ client.cancelPendingRequests!();
+ await rejected;
+ expect(await client.request('/api/v1/me', 'device-token')).toEqual({ account: { id: 'a' } });
+});
+
+it('收到响应头后仍可取消未完成的响应体读取', async () => {
+ let bodyStarted!: () => void;
+ const started = new Promise<void>(resolve => { bodyStarted = resolve; });
+ const fetcher: typeof fetch = async (_url, options) => new Response(new ReadableStream({
+ start(controller) {
+ controller.enqueue(new TextEncoder().encode('{'));
+ options!.signal!.addEventListener('abort', () => controller.error(options!.signal!.reason), { once: true });
+ bodyStarted();
+ }
+ }));
+ const client = createGatewayClient('https://gateway.example', fetcher);
+ const pending = client.request('/api/v1/me', 'device-token');
+ const rejected = expect(pending).rejects.toMatchObject({ code: 'gateway_unavailable' });
+ await started;
+ client.cancelPendingRequests!();
+ await rejected;
+});
diff --git a/apps/desktop/e2e/desktop.spec.ts b/apps/desktop/e2e/desktop.spec.ts
index 5a5e75da..07153403 100644
--- a/apps/desktop/e2e/desktop.spec.ts
+++ b/apps/desktop/e2e/desktop.spec.ts
@@ -27,6 +27,7 @@ import {
type Page
} from '@playwright/test';
import { packagedExecutable } from './package-artifact.js';
+import type { GatewayCredentials } from '../../daemon/src/gateway/config-store.js';
import {
closePackagedApp,
launchPackagedApp,
@@ -46,6 +47,78 @@ const fakeCodexLauncherSource = join(e2eDir, 'fixtures', 'fake-codex-launcher.go
test.describe.configure({ mode: 'serial' });
+test('@package-smoke 慢网关不阻塞缓存账号进入工作区,后台恢复完成后可输入任务', async ({}, testInfo) => {
+ const account = { id: 'startup-test', email: '[email protected]', verified: true };
+ const models = [{ id: 'official-model', modality: 'text' as const, capabilities: ['responses'] }];
+ let release!: () => void;
+ const waiting = new Promise<void>(resolve => { release = resolve; });
+ let bootstrapRequests = 0;
+ const gateway = createServer(async (request, response) => {
+ response.setHeader('Content-Type', 'application/json');
+ const path = request.url?.split('?')[0];
+ if (path === '/api/v1/client/bootstrap') {
+ bootstrapRequests++;
+ await waiting;
+ if (!response.destroyed) response.end(JSON.stringify(bootstrap));
+ } else if (path === '/api/v1/client/usage') {
+ response.end(JSON.stringify({ keyVersion: '1' }));
+ } else if (path === '/api/v1/me') {
+ response.end(JSON.stringify({ account }));
+ } else if (path === '/api/v1/client/models') {
+ response.end(JSON.stringify({ models }));
+ } else {
+ response.end(JSON.stringify({ items: [] }));
+ }
+ });
+ await new Promise<void>(resolve => gateway.listen(0, '127.0.0.1', resolve));
+ const origin = `http://127.0.0.1:${(gateway.address() as AddressInfo).port}`;
+ const bootstrap = {
+ schemaVersion: 1 as const, account, models, defaults: { text: 'official-model' },
+ modelKey: 'private-model-key', keyVersion: '1', bindingVersion: 'startup:1',
+ baseUrl: `${origin}/v1`, keyRotation: true
+ };
+ let fixture: DesktopFixture | undefined;
+ try {
+ const startedAt = Date.now();
+ fixture = await launchPackagedDesktop('success', {
+ runtimeMode: 'bundled',
+ gatewayOrigin: origin,
+ gatewayCredentials: {
+ ...bootstrap, accessToken: 'private-access-token', refreshToken: 'private-refresh-token',
+ expiresIn: 900, accessExpiresAt: new Date(Date.now() + 900_000).toISOString()
+ }
+ });
+ await fixture.page.waitForURL(url => url.protocol === 'opencreator-app:' && url.hostname === 'app');
+ await expect(fixture.page.locator('.opencreator-shell')).toBeVisible();
+ await expect.poll(() => fixture!.page.evaluate(async () => (await window.opencreatorDesktop?.readBootstrapState())?.phase)).toBe('ready');
+ await expect.poll(() => bootstrapRequests).toBe(1);
+ await navigateToAppRoute(fixture.page, '#/chat');
+ const input = fixture.page.getByRole('textbox', { name: '输入任务' });
+ await expect(input).toBeDisabled();
+ await expect(fixture.page.getByRole('status').filter({ hasText: '已登录,正在连接模型服务…' })).toBeVisible();
+ expect((await runtimeRequest(fixture.page, 'GET', '/gateway/account')).body)
+ .toMatchObject({ source: 'gateway', authState: 'signed_in', activationState: 'loading', account });
+ expect((await runtimeRequest(fixture.page, 'GET', '/projects?status=all')).body)
+ .toMatchObject({ projects: expect.arrayContaining([expect.objectContaining({ name: '默认项目' })]) });
+ await testInfo.attach('startup-timing.json', {
+ body: JSON.stringify({ workspaceReadyMs: Date.now() - startedAt, gatewayStillPending: true }),
+ contentType: 'application/json'
+ });
+ await fixture.page.screenshot({ path: testInfo.outputPath('startup-models-loading.png') });
+ release();
+ await expect.poll(async () => (await runtimeRequest<{ activationState: string }>(fixture!.page, 'GET', '/gateway/account')).body.activationState)
+ .toBe('ready');
+ await expect(input).toBeEnabled();
+ await input.fill('启动后可输入任务');
+ await expect(input).toHaveValue('启动后可输入任务');
+ } finally {
+ release();
+ if (fixture) await closeFixture(fixture);
+ gateway.closeAllConnections();
+ await new Promise<void>(resolve => gateway.close(() => resolve()));
+ }
+});
+
test('@package-smoke 充值回跳进入个人中心并以网关订单确认到账', async ({}, testInfo) => {
let paid = false;
let orderChecks = 0;
@@ -1447,6 +1520,7 @@ async function launchPackagedDesktop(
seedLocalCodexProvider?: boolean;
telemetryUrl?: string;
gatewayOrigin?: string;
+ gatewayCredentials?: GatewayCredentials;
} = {}
): Promise<DesktopFixture> {
const root = mkdtempSync(join(tmpdir(), 'opencreator-desktop-e2e-'));
@@ -1493,6 +1567,11 @@ async function launchPackagedDesktop(
if (options.misleadingCodexWrapper === true) {
writeMisleadingCodexWrapper(join(root, '.local', 'bin'));
}
+ if (options.gatewayCredentials) {
+ const configDir = join(root, '.opencreator', 'data', 'config');
+ mkdirSync(configDir, { recursive: true });
+ writeFileSync(join(configDir, 'gateway-credentials.json'), JSON.stringify(options.gatewayCredentials));
+ }
const app = await launchPackagedApp({
executablePath: packagedExecutable(desktopDir),
diff --git a/apps/web/src/app/App.test.tsx b/apps/web/src/app/App.test.tsx
index e32c772c..d261ad7a 100644
--- a/apps/web/src/app/App.test.tsx
+++ b/apps/web/src/app/App.test.tsx
@@ -185,7 +185,7 @@ describe('App', () => {
}
);
- it.each(['ready', 'blocked'] as const)('enters the application after gateway sign-in with %s activation and never asks for provider credentials', async activationState => {
+ it.each(['ready', 'blocked', 'loading'] as const)('enters the application after gateway sign-in with %s activation and never asks for provider credentials', async activationState => {
window.localStorage.clear();
writeCachedModelCatalog({ models: [{ ...createCodexModelListResponse().models[0]!, id: 'personal-model', model: 'personal-model', displayName: 'Personal cached model', isDefault: true }] });
const user = userEvent.setup();
@@ -229,6 +229,10 @@ describe('App', () => {
await user.click(within(screen.getByText('已登录,模型服务暂不可用。').parentElement!).getByRole('button', { name: '账户' }));
await waitFor(() => expect(window.location.hash).toBe('#/account'));
}
+ if (activationState === 'loading') {
+ expect(screen.getByText('已登录,正在连接模型服务…')).toBeInTheDocument();
+ expect(screen.getByRole('textbox', { name: '输入任务' })).toBeDisabled();
+ }
});
it('asks to confirm an existing ChatGPT login on first run, then remembers that choice while it remains valid', async () => {