Skip to content

AI-native knowledge base & Evernote/Obsidian alternative with instant sync & native MCP. Free on Cloudflare or self-hosted via Docker.

feat(speech): extract video-note subtitles from a workspace speech service

tianma-if46f1c7d7646c
diff --git a/apps/api/src/ai-routes.test.mjs b/apps/api/src/ai-routes.test.mjs
index af72b279..6cb17bc9 100644
--- a/apps/api/src/ai-routes.test.mjs
+++ b/apps/api/src/ai-routes.test.mjs
@@ -742,3 +742,370 @@ describe("video outline", () => {
expect(await invalid.json()).toMatchObject({ error: { code: "video_outline_invalid" } });
});
});
+
+const transcriptionToken = "asr-token-should-not-leak-9f3c";
+const otherTranscriptionToken = "speech-test-token-b";
+
+const transcriptionRequest = (app, databaseEnvironment, path, method, body) => app.request(
+ path,
+ {
+ method,
+ headers: { "content-type": "application/json" },
+ ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+ },
+ databaseEnvironment,
+);
+
+const createTranscriptionProvider = (app, databaseEnvironment, body) => transcriptionRequest(
+ app,
+ databaseEnvironment,
+ "/api/v1/ai/transcription-providers",
+ "POST",
+ body,
+);
+
+describe("speech transcription settings", () => {
+ test("stores several encrypted services and never returns their tokens", async () => {
+ const app = createApp();
+ const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();
+ try {
+ const empty = await app.request("/api/v1/ai/transcription-settings", {}, databaseEnvironment);
+ expect(empty.status).toBe(200);
+ expect(await empty.json()).toEqual({
+ providers: [],
+ defaultModelId: null,
+ enabled: false,
+ encryptionConfigured: true,
+ readOnly: false,
+ });
+
+ const saved = await createTranscriptionProvider(app, databaseEnvironment, {
+ displayName: " Groq ",
+ baseUrl: "https://api.groq.com/openai/v1/",
+ apiKey: ` ${transcriptionToken} `,
+ initialModelId: " whisper-large-v3-turbo ",
+ });
+ expect(saved.status).toBe(201);
+ const first = await saved.json();
+ expect(first.providers).toHaveLength(1);
+ expect(first.providers[0]).toMatchObject({
+ provider: "openai-compatible",
+ displayName: "Groq",
+ baseUrl: "https://api.groq.com/openai/v1",
+ isEnabled: true,
+ hasApiKey: true,
+ });
+ expect(first.providers[0].models).toEqual([
+ expect.objectContaining({
+ modelId: "whisper-large-v3-turbo",
+ displayName: "whisper-large-v3-turbo",
+ }),
+ ]);
+ expect(first.defaultModelId).toBe(first.providers[0].models[0].id);
+ expect(first.enabled).toBe(true);
+ expect(JSON.stringify(first)).not.toContain(transcriptionToken);
+ const chatSettings = await app.request("/api/v1/ai/settings", {}, databaseEnvironment);
+ expect((await chatSettings.json()).providers).toEqual([]);
+ expect(JSON.stringify(await app.request("/api/v1/ai/settings", {}, databaseEnvironment).then((response) => response.json()))).not.toContain(transcriptionToken);
+
+ const stored = sqlite.query(
+ "SELECT base_url, api_key_encrypted FROM ai_transcription_providers WHERE id = ?",
+ ).get(first.providers[0].id);
+ expect(stored.base_url).toBe("https://api.groq.com/openai/v1");
+ expect(stored.api_key_encrypted.startsWith("v1.")).toBe(true);
+ expect(stored.api_key_encrypted).not.toContain(transcriptionToken);
+ const audits = sqlite.query(
+ "SELECT metadata_json FROM audit_events WHERE action = ?",
+ ).all("workspace.ai_transcription_provider.create");
+ expect(audits).toHaveLength(1);
+ expect(audits[0].metadata_json).not.toContain(transcriptionToken);
+ expect(JSON.parse(audits[0].metadata_json)).toEqual({
+ isEnabled: true,
+ provider: "openai-compatible",
+ modelId: "whisper-large-v3-turbo",
+ });
+
+ const second = await createTranscriptionProvider(app, databaseEnvironment, {
+ displayName: "Local",
+ baseUrl: "http://127.0.0.1:8080/v1",
+ apiKey: otherTranscriptionToken,
+ initialModelId: "local-whisper",
+ });
+ expect(second.status).toBe(201);
+ const both = await second.json();
+ expect(both.providers.map((provider) => provider.displayName).sort()).toEqual(["Groq", "Local"]);
+ expect(both.defaultModelId).toBe(first.defaultModelId);
+ expect(both.enabled).toBe(true);
+ expect(JSON.stringify(both)).not.toContain(transcriptionToken);
+ expect(JSON.stringify(both)).not.toContain(otherTranscriptionToken);
+
+ const kept = await transcriptionRequest(
+ app,
+ databaseEnvironment,
+ `/api/v1/ai/transcription-providers/${first.providers[0].id}`,
+ "PUT",
+ {
+ displayName: "Groq",
+ baseUrl: "https://api.groq.com/openai/v1",
+ isEnabled: false,
+ },
+ );
+ expect(kept.status).toBe(200);
+ const disabled = await kept.json();
+ expect(disabled.providers.find((provider) => provider.id === first.providers[0].id)).toMatchObject({
+ isEnabled: false,
+ hasApiKey: true,
+ });
+ expect(disabled.defaultModelId).toBe(first.defaultModelId);
+ expect(disabled.enabled).toBe(false);
+ expect(sqlite.query(
+ "SELECT api_key_encrypted FROM ai_transcription_providers WHERE id = ?",
+ ).get(first.providers[0].id).api_key_encrypted).toBe(stored.api_key_encrypted);
+ expect(sqlite.query("SELECT COUNT(*) AS count FROM ai_provider_configs").get().count).toBe(0);
+ } finally {
+ sqlite.close();
+ }
+ });
+
+ test("rejects a service without a token, with a blank model, or with an embedded credential", async () => {
+ const app = createApp();
+ const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();
+ try {
+ const missingToken = await createTranscriptionProvider(app, databaseEnvironment, {
+ displayName: "Example",
+ baseUrl: "https://api.example.com/v1",
+ initialModelId: "whisper-1",
+ });
+ expect(missingToken.status).toBe(400);
+ expect(await missingToken.json()).toMatchObject({
+ error: { code: "ai_transcription_request_invalid" },
+ });
+ const blankModel = await createTranscriptionProvider(app, databaseEnvironment, {
+ displayName: "Example",
+ baseUrl: "https://api.example.com/v1",
+ apiKey: transcriptionToken,
+ initialModelId: " ",
+ });
+ expect(blankModel.status).toBe(400);
+ expect(JSON.stringify(await blankModel.json())).not.toContain(transcriptionToken);
+
+ const embedded = await createTranscriptionProvider(app, databaseEnvironment, {
+ displayName: "Example",
+ baseUrl: "https://user:[email protected]/v1",
+ apiKey: transcriptionToken,
+ initialModelId: "whisper-1",
+ });
+ expect(embedded.status).toBe(400);
+ expect(await embedded.json()).toMatchObject({
+ error: { code: "ai_transcription_request_invalid" },
+ });
+ const ftp = await createTranscriptionProvider(app, databaseEnvironment, {
+ displayName: "Example",
+ baseUrl: "ftp://files.example.com/v1",
+ apiKey: transcriptionToken,
+ initialModelId: "whisper-1",
+ });
+ expect(ftp.status).toBe(400);
+ expect(JSON.stringify(await ftp.json())).not.toContain(transcriptionToken);
+ const otherStandard = await createTranscriptionProvider(app, databaseEnvironment, {
+ provider: "anthropic",
+ displayName: "Example",
+ baseUrl: "https://api.example.com/v1",
+ apiKey: transcriptionToken,
+ initialModelId: "whisper-1",
+ });
+ expect(otherStandard.status).toBe(400);
+ const otherStandardBody = await otherStandard.json();
+ expect(otherStandardBody).toMatchObject({
+ error: { code: "ai_transcription_request_invalid" },
+ });
+ expect(JSON.stringify(otherStandardBody)).not.toContain(transcriptionToken);
+ expect(sqlite.query("SELECT COUNT(*) AS count FROM ai_transcription_providers").get().count).toBe(0);
+ } finally {
+ sqlite.close();
+ }
+ });
+
+ test("keeps a saved token when the encryption key is later unavailable, and still refuses a replacement", async () => {
+ const app = createApp();
+ const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();
+ const withoutKey = { ...databaseEnvironment, EDGE_EVER_AUTH_PASSWORD: undefined };
+ try {
+ const created = await createTranscriptionProvider(app, databaseEnvironment, {
+ displayName: "OpenAI",
+ baseUrl: "https://api.openai.com/v1",
+ apiKey: transcriptionToken,
+ initialModelId: "whisper-1",
+ });
+ expect(created.status).toBe(201);
+ const providerId = (await created.json()).providers[0].id;
+ const stored = sqlite.query(
+ "SELECT api_key_encrypted FROM ai_transcription_providers WHERE id = ?",
+ ).get(providerId).api_key_encrypted;
+
+ const renamed = await transcriptionRequest(app, withoutKey, `/api/v1/ai/transcription-providers/${providerId}`, "PUT", {
+ displayName: "OpenAI renamed",
+ baseUrl: "https://api.openai.com/v1",
+ isEnabled: true,
+ });
+ expect(renamed.status).toBe(200);
+ expect(await renamed.json()).toMatchObject({
+ encryptionConfigured: false,
+ enabled: false,
+ providers: [expect.objectContaining({ displayName: "OpenAI renamed", hasApiKey: true })],
+ });
+ expect(sqlite.query(
+ "SELECT api_key_encrypted FROM ai_transcription_providers WHERE id = ?",
+ ).get(providerId).api_key_encrypted).toBe(stored);
+
+ const replaced = await transcriptionRequest(app, withoutKey, `/api/v1/ai/transcription-providers/${providerId}`, "PUT", {
+ displayName: "OpenAI renamed",
+ baseUrl: "https://api.openai.com/v1",
+ isEnabled: true,
+ apiKey: "replacement-token",
+ });
+ expect(replaced.status).toBe(400);
+ const replacedBody = await replaced.json();
+ expect(replacedBody).toMatchObject({ error: { code: "ai_encryption_key_missing" } });
+ expect(JSON.stringify(replacedBody)).not.toContain("replacement-token");
+ expect(sqlite.query(
+ "SELECT api_key_encrypted FROM ai_transcription_providers WHERE id = ?",
+ ).get(providerId).api_key_encrypted).toBe(stored);
+ } finally {
+ sqlite.close();
+ }
+ });
+
+ test("refuses demo mode and API tokens", async () => {
+ const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();
+ try {
+ const demo = await createTranscriptionProvider(createApp({ demoMode: true }), databaseEnvironment, {
+ displayName: "Example",
+ baseUrl: "https://api.example.com/v1",
+ apiKey: transcriptionToken,
+ initialModelId: "whisper-1",
+ });
+ expect(demo.status).toBe(403);
+ const demoRead = await createApp({ demoMode: true }).request(
+ "/api/v1/ai/transcription-settings",
+ {},
+ databaseEnvironment,
+ );
+ expect(demoRead.status).toBe(200);
+ expect(await demoRead.json()).toMatchObject({ readOnly: true, providers: [], enabled: false });
+
+ const tokenApp = createApp({ currentAuth: { ...auth, kind: "agent", actorType: "agent", scopes: ["ai:generate"] } });
+ const deniedRead = await tokenApp.request("/api/v1/ai/transcription-settings", {}, environment);
+ const deniedWrite = await createTranscriptionProvider(tokenApp, environment, {
+ displayName: "Example",
+ baseUrl: "https://api.example.com/v1",
+ apiKey: transcriptionToken,
+ initialModelId: "whisper-1",
+ });
+ expect(deniedRead.status).toBe(403);
+ expect(deniedWrite.status).toBe(403);
+ expect(sqlite.query("SELECT COUNT(*) AS count FROM ai_transcription_providers").get().count).toBe(0);
+ expect(JSON.stringify(await deniedWrite.json())).not.toContain(transcriptionToken);
+ } finally {
+ sqlite.close();
+ }
+ });
+
+ test("prepares only the selected enabled service for an interactive session", async () => {
+ const app = createApp();
+ const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();
+ const prepare = () => app.request(
+ "/api/v1/ai/transcription-settings/prepare",
+ { method: "POST" },
+ databaseEnvironment,
+ );
+ try {
+ const disabled = await prepare();
+ expect(disabled.status).toBe(200);
+ expect(await disabled.json()).toEqual({ enabled: false });
+
+ const firstResponse = await createTranscriptionProvider(app, databaseEnvironment, {
+ displayName: "Groq",
+ baseUrl: "https://api.groq.com/openai/v1/",
+ apiKey: transcriptionToken,
+ initialModelId: "whisper-large-v3-turbo",
+ });
+ const first = await firstResponse.json();
+ const secondResponse = await createTranscriptionProvider(app, databaseEnvironment, {
+ displayName: "Local",
+ baseUrl: "http://127.0.0.1:8080/v1",
+ apiKey: otherTranscriptionToken,
+ initialModelId: "local-whisper",
+ });
+ const second = await secondResponse.json();
+ const localModelId = second.providers.find((provider) => provider.displayName === "Local").models[0].id;
+ const prepared = await prepare();
+ expect(prepared.status).toBe(200);
+ expect(await prepared.json()).toEqual({
+ enabled: true,
+ provider: "openai-compatible",
+ baseUrl: "https://api.groq.com/openai/v1",
+ modelId: "whisper-large-v3-turbo",
+ apiKey: transcriptionToken,
+ });
+ const listed = await app.request("/api/v1/ai/transcription-settings", {}, databaseEnvironment);
+ const listedBody = JSON.stringify(await listed.json());
+ expect(listedBody).not.toContain(transcriptionToken);
+ expect(listedBody).not.toContain(otherTranscriptionToken);
+
+ const switched = await transcriptionRequest(
+ app,
+ databaseEnvironment,
+ "/api/v1/ai/transcription-default-model",
+ "PUT",
+ { modelConfigId: localModelId },
+ );
+ expect(switched.status).toBe(200);
+ expect((await switched.json()).defaultModelId).toBe(localModelId);
+ expect(await (await prepare()).json()).toEqual({
+ enabled: true,
+ provider: "openai-compatible",
+ baseUrl: "http://127.0.0.1:8080/v1",
+ modelId: "local-whisper",
+ apiKey: otherTranscriptionToken,
+ });
+
+ const cleared = await transcriptionRequest(
+ app,
+ databaseEnvironment,
+ "/api/v1/ai/transcription-default-model",
+ "PUT",
+ { modelConfigId: null },
+ );
+ expect(cleared.status).toBe(200);
+ const turnedOff = await prepare();
+ const turnedOffBody = await turnedOff.json();
+ expect(turnedOffBody).toEqual({ enabled: false });
+ expect(JSON.stringify(turnedOffBody)).not.toContain(transcriptionToken);
+ expect(JSON.stringify(turnedOffBody)).not.toContain(otherTranscriptionToken);
+ expect(sqlite.query("SELECT COUNT(*) AS count FROM ai_transcription_providers").get().count).toBe(2);
+
+ const demo = await createApp({ demoMode: true }).request(
+ "/api/v1/ai/transcription-settings/prepare",
+ { method: "POST" },
+ databaseEnvironment,
+ );
+ expect(demo.status).toBe(403);
+ expect(JSON.stringify(await demo.json())).not.toContain(transcriptionToken);
+
+ const tokenApp = createApp({
+ currentAuth: { ...auth, kind: "agent", actorType: "agent", scopes: ["ai:generate", "write:memos"] },
+ });
+ const denied = await tokenApp.request(
+ "/api/v1/ai/transcription-settings/prepare",
+ { method: "POST" },
+ databaseEnvironment,
+ );
+ expect(denied.status).toBe(403);
+ expect(JSON.stringify(await denied.json())).not.toContain(transcriptionToken);
+ expect(first.providers[0].id).not.toBe(localModelId);
+ } finally {
+ sqlite.close();
+ }
+ });
+});
diff --git a/apps/api/src/ai-routes.ts b/apps/api/src/ai-routes.ts
index 401ea2b0..5077068f 100644
--- a/apps/api/src/ai-routes.ts
+++ b/apps/api/src/ai-routes.ts
@@ -1,6 +1,10 @@
import {
AiDefaultModelUpdateSchema,
AiGenerateSchema,
+ AiTranscriptionDefaultModelUpdateSchema,
+ AiTranscriptionModelCreateSchema,
+ AiTranscriptionProviderCreateSchema,
+ AiTranscriptionProviderUpdateSchema,
InfographicAgentRequestSchema,
AiModelConfigCreateSchema,
AiProviderConfigCreateSchema,
@@ -18,7 +22,7 @@ import {
type AiTone,
} from "@edgeever/shared";
import { zValidator } from "@hono/zod-validator";
-import type { Hono } from "hono";
+import type { Context, Hono } from "hono";
import type { AppContext, AppEnv, Bindings } from "./api-context";
import { AppError } from "./app-error";
import { auditStatement } from "./audit";
@@ -40,6 +44,12 @@ import {
normalizeAiGenerationText,
normalizeAiBaseUrl,
prepareAiGeneration,
+ prepareAiTranscriptionCredentials,
+ aiTranscriptionDefaultStatement,
+ getAiTranscriptionModel,
+ getAiTranscriptionProvider,
+ getAiTranscriptionSettings,
+ getDefaultAiTranscriptionModelId,
resolvePrimaryAiCredentialEncryptionKey,
streamAiGeneration,
testAiModel,
@@ -109,6 +119,28 @@ const readSettings = (context: AppContext, dependencies: AiRouteDependencies) =>
context.env,
);
+const readTranscriptionSettings = (context: AppContext, dependencies: AiRouteDependencies) =>
+ getAiTranscriptionSettings(
+ context.env.storage.db,
+ getWorkspaceId(context),
+ encryptionConfigured(context),
+ dependencies.isDemoMode(context.env),
+ context.env,
+ );
+
+const invalidTranscriptionSettings = (
+ result: { success: boolean },
+ context: Context,
+) => {
+ if (result.success) return;
+ return apiError(
+ context,
+ "ai_transcription_request_invalid",
+ "The speech transcription settings are invalid.",
+ 400,
+ );
+};
+
const denyMutation = (context: AppContext, dependencies: AiRouteDependencies) => {
const denied = requireUser(context);
if (denied) return denied;
@@ -214,6 +246,296 @@ export const registerAiRoutes = (app: Hono<AppEnv>, dependencies: AiRouteDepende
return context.json(await readSettings(context, dependencies));
});
+ app.get("/api/v1/ai/transcription-settings", async (context) => {
+ const denied = requireUser(context);
+ if (denied) return denied;
+ return context.json(await readTranscriptionSettings(context, dependencies));
+ });
+
+ app.post(
+ "/api/v1/ai/transcription-providers",
+ zValidator("json", AiTranscriptionProviderCreateSchema, invalidTranscriptionSettings),
+ async (context) => {
+ const denied = denyMutation(context, dependencies);
+ if (denied) return denied;
+ try {
+ const input = context.req.valid("json");
+ const workspaceId = getWorkspaceId(context);
+ const providerId = createId("atp");
+ const modelConfigId = input.initialModelId ? createId("atm") : null;
+ const now = isoNow();
+ const statements = [
+ context.env.storage.db.prepare(
+ `INSERT INTO ai_transcription_providers (
+ id, workspace_id, provider, display_name, base_url, api_key_encrypted,
+ is_enabled, created_at, updated_at
+ ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+ ).bind(
+ providerId,
+ workspaceId,
+ input.provider,
+ input.displayName,
+ normalizeAiBaseUrl(input.baseUrl),
+ await encryptSecret(input.apiKey, requireEncryptionKey(context)),
+ input.isEnabled ? 1 : 0,
+ now,
+ now,
+ ),
+ ];
+ if (modelConfigId && input.initialModelId) {
+ statements.push(context.env.storage.db.prepare(
+ `INSERT INTO ai_transcription_models (
+ id, provider_id, model_id, display_name, created_at, updated_at
+ ) VALUES (?, ?, ?, ?, ?, ?)`,
+ ).bind(
+ modelConfigId,
+ providerId,
+ input.initialModelId,
+ input.initialModelId.slice(0, 80),
+ now,
+ now,
+ ));
+ if (input.isEnabled && !(await getDefaultAiTranscriptionModelId(context.env.storage.db, workspaceId))) {
+ statements.push(aiTranscriptionDefaultStatement(
+ context.env.storage.db,
+ workspaceId,
+ modelConfigId,
+ now,
+ ));
+ }
+ }
+ statements.push(auditStatement(
+ context.env.storage.db,
+ "user",
+ context.get("auth").actorId,
+ "workspace.ai_transcription_provider.create",
+ "ai_transcription_provider",
+ providerId,
+ { isEnabled: input.isEnabled, provider: input.provider, modelId: input.initialModelId ?? null },
+ ));
+ await context.env.storage.db.batch(statements);
+ return context.json(await readTranscriptionSettings(context, dependencies), 201);
+ } catch (error) {
+ return withAiError(context, error, "ai_transcription_provider_create_failed");
+ }
+ },
+ );
+
+ app.put(
+ "/api/v1/ai/transcription-providers/:providerId",
+ zValidator("json", AiTranscriptionProviderUpdateSchema, invalidTranscriptionSettings),
+ async (context) => {
+ const denied = denyMutation(context, dependencies);
+ if (denied) return denied;
+ try {
+ const input = context.req.valid("json");
+ const providerId = context.req.param("providerId");
+ const workspaceId = getWorkspaceId(context);
+ const existing = await getAiTranscriptionProvider(context.env.storage.db, workspaceId, providerId);
+ if (!existing) return notFound(context, "Speech service not found.");
+ const now = isoNow();
+ const apiKeyEncrypted = input.apiKey
+ ? await encryptSecret(input.apiKey, requireEncryptionKey(context))
+ : existing.api_key_encrypted;
+ await context.env.storage.db.batch([
+ context.env.storage.db.prepare(
+ `UPDATE ai_transcription_providers SET
+ provider = ?, display_name = ?, base_url = ?, api_key_encrypted = ?,
+ is_enabled = ?, updated_at = ?
+ WHERE id = ? AND workspace_id = ?`,
+ ).bind(
+ input.provider,
+ input.displayName,
+ normalizeAiBaseUrl(input.baseUrl),
+ apiKeyEncrypted,
+ input.isEnabled ? 1 : 0,
+ now,
+ providerId,
+ workspaceId,
+ ),
+ auditStatement(
+ context.env.storage.db,
+ "user",
+ context.get("auth").actorId,
+ "workspace.ai_transcription_provider.update",
+ "ai_transcription_provider",
+ providerId,
+ { isEnabled: input.isEnabled, provider: input.provider, apiKeyUpdated: Boolean(input.apiKey) },
+ ),
+ ]);
+ return context.json(await readTranscriptionSettings(context, dependencies));
+ } catch (error) {
+ return withAiError(context, error, "ai_transcription_provider_update_failed");
+ }
+ },
+ );
+
+ app.delete("/api/v1/ai/transcription-providers/:providerId", async (context) => {
+ const denied = denyMutation(context, dependencies);
+ if (denied) return denied;
+ const providerId = context.req.param("providerId");
+ const workspaceId = getWorkspaceId(context);
+ const existing = await getAiTranscriptionProvider(context.env.storage.db, workspaceId, providerId);
+ if (!existing) return notFound(context, "Speech service not found.");
+ await context.env.storage.db.batch([
+ context.env.storage.db.prepare(
+ `DELETE FROM ai_transcription_providers WHERE id = ? AND workspace_id = ?`,
+ ).bind(providerId, workspaceId),
+ auditStatement(
+ context.env.storage.db,
+ "user",
+ context.get("auth").actorId,
+ "workspace.ai_transcription_provider.delete",
+ "ai_transcription_provider",
+ providerId,
+ {},
+ ),
+ ]);
+ return context.json(await readTranscriptionSettings(context, dependencies));
+ });
+
+ app.post(
+ "/api/v1/ai/transcription-providers/:providerId/models",
+ zValidator("json", AiTranscriptionModelCreateSchema, invalidTranscriptionSettings),
+ async (context) => {
+ const denied = denyMutation(context, dependencies);
+ if (denied) return denied;
+ const providerId = context.req.param("providerId");
+ const workspaceId = getWorkspaceId(context);
+ const provider = await getAiTranscriptionProvider(context.env.storage.db, workspaceId, providerId);
+ if (!provider) return notFound(context, "Speech service not found.");
+ const input = context.req.valid("json");
+ const modelConfigId = createId("atm");
+ const now = isoNow();
+ const statements = [
+ context.env.storage.db.prepare(
+ `INSERT INTO ai_transcription_models (
+ id, provider_id, model_id, display_name, created_at, updated_at
+ ) VALUES (?, ?, ?, ?, ?, ?)`,
+ ).bind(
+ modelConfigId,
+ providerId,
+ input.modelId,
+ input.displayName ?? input.modelId.slice(0, 80),
+ now,
+ now,
+ ),
+ ];
+ if (provider.is_enabled && !(await getDefaultAiTranscriptionModelId(context.env.storage.db, workspaceId))) {
+ statements.push(aiTranscriptionDefaultStatement(
+ context.env.storage.db,
+ workspaceId,
+ modelConfigId,
+ now,
+ ));
+ }
+ statements.push(auditStatement(
+ context.env.storage.db,
+ "user",
+ context.get("auth").actorId,
+ "workspace.ai_transcription_model.create",
+ "ai_transcription_model",
+ modelConfigId,
+ { providerId, modelId: input.modelId },
+ ));
+ try {
+ await context.env.storage.db.batch(statements);
+ return context.json(await readTranscriptionSettings(context, dependencies), 201);
+ } catch (error) {
+ return withAiError(context, error, "ai_transcription_model_create_failed");
+ }
+ },
+ );
+
+ app.delete(
+ "/api/v1/ai/transcription-providers/:providerId/models/:modelConfigId",
+ async (context) => {
+ const denied = denyMutation(context, dependencies);
+ if (denied) return denied;
+ const workspaceId = getWorkspaceId(context);
+ const providerId = context.req.param("providerId");
+ const modelConfigId = context.req.param("modelConfigId");
+ const model = await getAiTranscriptionModel(context.env.storage.db, workspaceId, modelConfigId);
+ if (!model || model.provider_id !== providerId) {
+ return notFound(context, "Speech model not found.");
+ }
+ await context.env.storage.db.batch([
+ context.env.storage.db.prepare(
+ `DELETE FROM ai_transcription_models WHERE id = ? AND provider_id = ?`,
+ ).bind(modelConfigId, providerId),
+ auditStatement(
+ context.env.storage.db,
+ "user",
+ context.get("auth").actorId,
+ "workspace.ai_transcription_model.delete",
+ "ai_transcription_model",
+ modelConfigId,
+ { providerId, modelId: model.model_id },
+ ),
+ ]);
+ return context.json(await readTranscriptionSettings(context, dependencies));
+ },
+ );
+
+ app.put(
+ "/api/v1/ai/transcription-default-model",
+ zValidator("json", AiTranscriptionDefaultModelUpdateSchema, invalidTranscriptionSettings),
+ async (context) => {
+ const denied = denyMutation(context, dependencies);
+ if (denied) return denied;
+ const input = context.req.valid("json");
+ const workspaceId = getWorkspaceId(context);
+ if (input.modelConfigId) {
+ const model = await context.env.storage.db.prepare(
+ `SELECT models.id
+ FROM ai_transcription_models AS models
+ JOIN ai_transcription_providers AS providers ON providers.id = models.provider_id
+ WHERE models.id = ? AND providers.workspace_id = ? AND providers.is_enabled = 1
+ LIMIT 1`,
+ ).bind(input.modelConfigId, workspaceId).first<{ id: string }>();
+ if (!model) {
+ return apiError(
+ context,
+ "ai_transcription_default_unavailable",
+ "The selected speech model belongs to a disabled or missing service.",
+ 400,
+ );
+ }
+ }
+ const now = isoNow();
+ await context.env.storage.db.batch([
+ aiTranscriptionDefaultStatement(context.env.storage.db, workspaceId, input.modelConfigId, now),
+ auditStatement(
+ context.env.storage.db,
+ "user",
+ context.get("auth").actorId,
+ "workspace.ai_transcription_default.update",
+ "workspace",
+ workspaceId,
+ { modelConfigId: input.modelConfigId },
+ ),
+ ]);
+ return context.json(await readTranscriptionSettings(context, dependencies));
+ },
+ );
+
+ app.post("/api/v1/ai/transcription-settings/prepare", async (context) => {
+ const denied = requireUser(context);
+ if (denied) return denied;
+ if (dependencies.isDemoMode(context.env)) {
+ return forbidden(context, "Speech transcription credentials are unavailable in demo mode.");
+ }
+ try {
+ return context.json(await prepareAiTranscriptionCredentials(
+ context.env.storage.db,
+ getWorkspaceId(context),
+ context.env,
+ ));
+ } catch (error) {
+ return withAiError(context, error, "ai_transcription_prepare_failed");
+ }
+ });
+
app.post(
"/api/v1/ai/providers",
zValidator("json", AiProviderConfigCreateSchema),
diff --git a/apps/api/src/ai-service.ts b/apps/api/src/ai-service.ts
index 7b11b2ab..620b3717 100644
--- a/apps/api/src/ai-service.ts
+++ b/apps/api/src/ai-service.ts
@@ -8,6 +8,10 @@ import type {
AiProvider,
AiProviderConfig,
AiSettings,
+ AiTranscriptionModel,
+ AiTranscriptionProvider,
+ AiTranscriptionStandard,
+ AiTranscriptionSettings,
AiTargetLanguage,
AiTone,
} from "@edgeever/shared";
@@ -224,6 +228,197 @@ export const getAiSettings = async (
export const normalizeAiBaseUrl = (value: string) => value.trim().replace(/\/+$/, "");
+export type AiTranscriptionProviderRow = {
+ id: string;
+ workspace_id: string;
+ provider: AiTranscriptionStandard;
+ display_name: string;
+ base_url: string;
+ api_key_encrypted: string;
+ is_enabled: number;
+ created_at: string;
+ updated_at: string;
+};
+
+export type AiTranscriptionModelRow = {
+ id: string;
+ provider_id: string;
+ model_id: string;
+ display_name: string;
+ created_at: string;
+ updated_at: string;
+};
+
+const selectTranscriptionProviderSql = `SELECT
+ id, workspace_id, provider, display_name, base_url, api_key_encrypted, is_enabled, created_at, updated_at
+ FROM ai_transcription_providers`;
+
+const selectTranscriptionModelSql = `SELECT
+ id, provider_id, model_id, display_name, created_at, updated_at
+ FROM ai_transcription_models`;
+
+export const getAiTranscriptionProvider = (
+ db: DatabaseAdapter,
+ workspaceId: string,
+ providerId: string,
+) => db.prepare(
+ `${selectTranscriptionProviderSql} WHERE id = ? AND workspace_id = ? LIMIT 1`,
+).bind(providerId, workspaceId).first<AiTranscriptionProviderRow>();
+
+export const getAiTranscriptionModel = (
+ db: DatabaseAdapter,
+ workspaceId: string,
+ modelConfigId: string,
+) => db.prepare(
+ `${selectTranscriptionModelSql}
+ WHERE id = ? AND provider_id IN (
+ SELECT id FROM ai_transcription_providers WHERE workspace_id = ?
+ )
+ LIMIT 1`,
+).bind(modelConfigId, workspaceId).first<AiTranscriptionModelRow>();
+
+export const getDefaultAiTranscriptionModelId = async (db: DatabaseAdapter, workspaceId: string) => {
+ const row = await db.prepare(
+ `SELECT default_model_id
+ FROM ai_transcription_workspace_settings
+ WHERE workspace_id = ?
+ LIMIT 1`,
+ ).bind(workspaceId).first<{ default_model_id: string | null }>();
+ return row?.default_model_id ?? null;
+};
+
+export const aiTranscriptionDefaultStatement = (
+ db: DatabaseAdapter,
+ workspaceId: string,
+ modelConfigId: string | null,
+ now: string,
+) => db.prepare(
+ `INSERT INTO ai_transcription_workspace_settings (
+ workspace_id, default_model_id, created_at, updated_at
+ ) VALUES (?, ?, ?, ?)
+ ON CONFLICT(workspace_id) DO UPDATE SET
+ default_model_id = excluded.default_model_id,
+ updated_at = excluded.updated_at`,
+).bind(workspaceId, modelConfigId, now, now);
+
+const mapAiTranscriptionModel = (row: AiTranscriptionModelRow): AiTranscriptionModel => ({
+ id: row.id,
+ providerId: row.provider_id,
+ modelId: row.model_id,
+ displayName: row.display_name,
+});
+
+const mapAiTranscriptionProvider = (
+ row: AiTranscriptionProviderRow,
+ models: AiTranscriptionModelRow[],
+ credentialsUnavailable = false,
+): AiTranscriptionProvider => ({
+ id: row.id,
+ provider: row.provider,
+ displayName: row.display_name,
+ baseUrl: row.base_url,
+ isEnabled: Boolean(row.is_enabled),
+ hasApiKey: Boolean(row.api_key_encrypted),
+ models: models.filter((model) => model.provider_id === row.id).map(mapAiTranscriptionModel),
+ ...(credentialsUnavailable ? { credentialsUnavailable: true } : {}),
+});
+
+const withAiTranscriptionCredentialAvailability = async (
+ row: AiTranscriptionProviderRow,
+ models: AiTranscriptionModelRow[],
+ encryptionConfigured: boolean,
+ environment?: AiCredentialEnvironment,
+): Promise<AiTranscriptionProvider> => {
+ const mapped = mapAiTranscriptionProvider(row, models);
+ if (!encryptionConfigured || !environment || !row.api_key_encrypted) return mapped;
+ try {
+ await decryptAiCredential(row.api_key_encrypted, environment);
+ return mapped;
+ } catch {
+ return mapAiTranscriptionProvider(row, models, true);
+ }
+};
+
+export const getAiTranscriptionSettings = async (
+ db: DatabaseAdapter,
+ workspaceId: string,
+ encryptionConfigured: boolean,
+ readOnly: boolean,
+ environment?: AiCredentialEnvironment,
+): Promise<AiTranscriptionSettings> => {
+ const [providersResult, modelsResult, defaultModelId] = await Promise.all([
+ db.prepare(
+ `${selectTranscriptionProviderSql} WHERE workspace_id = ? ORDER BY created_at ASC, id ASC`,
+ ).bind(workspaceId).all<AiTranscriptionProviderRow>(),
+ db.prepare(
+ `${selectTranscriptionModelSql}
+ WHERE provider_id IN (
+ SELECT id FROM ai_transcription_providers WHERE workspace_id = ?
+ )
+ ORDER BY created_at ASC, id ASC`,
+ ).bind(workspaceId).all<AiTranscriptionModelRow>(),
+ getDefaultAiTranscriptionModelId(db, workspaceId),
+ ]);
+ const providers = await Promise.all(providersResult.results.map((provider) =>
+ withAiTranscriptionCredentialAvailability(provider, modelsResult.results, encryptionConfigured, environment)));
+ const defaultProvider = providers.find((provider) =>
+ provider.models.some((model) => model.id === defaultModelId));
+ const enabled = Boolean(
+ encryptionConfigured
+ && defaultProvider?.isEnabled
+ && defaultProvider.hasApiKey
+ && !defaultProvider.credentialsUnavailable
+ && defaultProvider.models.some((model) => model.id === defaultModelId && model.modelId),
+ );
+ return {
+ providers,
+ defaultModelId,
+ enabled,
+ encryptionConfigured,
+ readOnly,
+ };
+};
+
+export const prepareAiTranscriptionCredentials = async (
+ db: DatabaseAdapter,
+ workspaceId: string,
+ environment: AiCredentialEnvironment,
+) => {
+ const row = await db.prepare(
+ `SELECT
+ models.model_id,
+ providers.provider,
+ providers.base_url,
+ providers.api_key_encrypted
+ FROM ai_transcription_workspace_settings AS settings
+ JOIN ai_transcription_models AS models ON models.id = settings.default_model_id
+ JOIN ai_transcription_providers AS providers ON providers.id = models.provider_id
+ WHERE settings.workspace_id = ?
+ AND providers.workspace_id = ?
+ AND providers.is_enabled = 1
+ LIMIT 1`,
+ ).bind(workspaceId, workspaceId).first<{
+ model_id: string;
+ provider: AiTranscriptionStandard;
+ base_url: string;
+ api_key_encrypted: string;
+ }>();
+ if (!row?.base_url || !row.model_id || !row.api_key_encrypted || !row.provider) {
+ return { enabled: false as const };
+ }
+ try {
+ return {
+ enabled: true as const,
+ provider: row.provider,
+ baseUrl: normalizeAiBaseUrl(row.base_url),
+ modelId: row.model_id,
+ apiKey: await decryptAiCredential(row.api_key_encrypted, environment),
+ };
+ } catch {
+ return { enabled: false as const };
+ }
+};
+
const loadAiRuntime = () => import("./ai-runtime");
export const createAiModel = async (config: {
diff --git a/apps/api/src/index.ts b/apps/api/src/index.ts
index 7662a973..977b592f 100644
--- a/apps/api/src/index.ts
+++ b/apps/api/src/index.ts
@@ -90,6 +90,7 @@ import {
import { registerPluginDistributionRoutes } from "./plugin-distribution-routes";
import { registerSyncRoutes } from "./sync-routes";
import { registerMemoRoutes } from "./memo-routes";
+import { registerVideoTranscriptRoutes } from "./video-transcript-routes";
import { registerScheduledTaskRoutes } from "./scheduled-task-routes";
import { registerWorkspaceExtensionRoutes } from "./workspace-extension-routes";
import { registerBackupRoutes } from "./backup-routes";
@@ -341,6 +342,7 @@ registerTemplateRoutes(app, {
getMemoDetail: (...args) => getMemoDetail(...args),
});
+registerVideoTranscriptRoutes(app, { isDemoMode: (...args) => isDemoMode(...args) });
registerMemoRoutes(app, {
clampNumber: (...args) => clampNumber(...args),
createImageResource: (...args) => createImageResource(...args),
diff --git a/apps/api/src/memo-list-service.ts b/apps/api/src/memo-list-service.ts
index 761c2ad4..ef778573 100644
--- a/apps/api/src/memo-list-service.ts
+++ b/apps/api/src/memo-list-service.ts
@@ -6,6 +6,7 @@ import {
getDiagramSummary,
getInfographicSummary,
getTableSummary,
+ getVideoNoteSummary,
type MemoSummary,
} from "@edgeever/shared";
import { clampNumber, parseJsonArray } from "./entity-utils";
@@ -74,6 +75,7 @@ export const mapMemoSummary = (row: MemoSummaryRow): MemoSummary => ({
...getDiagramSummary(row.content_markdown),
...getInfographicSummary(row.content_markdown),
...getTableSummary(row.content_markdown),
+ ...getVideoNoteSummary(row.content_markdown),
tags: parseJsonArray(row.tags_json),
isPinned: Boolean(row.is_pinned),
isArchived: Boolean(row.is_archived),
diff --git a/apps/api/src/memo-routes.ts b/apps/api/src/memo-routes.ts
index aac28f43..d9ca731d 100644
--- a/apps/api/src/memo-routes.ts
+++ b/apps/api/src/memo-routes.ts
@@ -19,7 +19,6 @@ import type { ListMemosInput, ListMemosResult } from "./memo-list-service";
import { getActorLabel, getAuditActor, getWorkspaceId, requireScopes } from "./request-auth";
import { deleteReleasedResourceObjects } from "./resource-service";
import type { DatabaseAdapter } from "./storage-contract";
-
type MemoRouteDependencies = {
clampNumber: (value: number, min: number, max: number) => number;
createImageResource: (context: AppContext, input: {
@@ -151,10 +150,13 @@ export const registerMemoRoutes = (
if (denied) return denied;
try {
+ const input = context.req.valid("json");
+ const { videoTranscript, ...memoInput } = input;
+ void videoTranscript;
const memo = await dependencies.createMemo(
context.env.storage.db,
getWorkspaceId(context),
- context.req.valid("json"),
+ memoInput,
getAuditActor(context),
getActorLabel(context),
);
@@ -189,7 +191,6 @@ export const registerMemoRoutes = (
if (!(file instanceof File) || !notebookId || !contentMarkdown.includes("EDGEVERRESOURCEID")) {
return badRequest(context, "notebookId, contentMarkdown, and an image file are required.");
}
-
const resourceId = createId("res");
const markdown = contentMarkdown.replaceAll("EDGEVERRESOURCEID", resourceId);
const actor = getAuditActor(context);
diff --git a/apps/api/src/video-transcript-routes.ts b/apps/api/src/video-transcript-routes.ts
new file mode 100644
index 00000000..11ccac1d
--- /dev/null
+++ b/apps/api/src/video-transcript-routes.ts
@@ -0,0 +1,82 @@
+import { VideoTranscriptFinishSchema } from "@edgeever/shared";
+import { zValidator } from "@hono/zod-validator";
+import type { Hono } from "hono";
+import type { AppContext, AppEnv, Bindings } from "./api-context";
+import { apiError, databaseNotReady, forbidden, notFound } from "./http-errors";
+import { getWorkspaceId, requireUser } from "./request-auth";
+import {
+ claimVideoTranscriptJob,
+ extractVideoTranscript,
+ finishVideoTranscriptJob,
+ listClaimableVideoTranscriptJobs,
+} from "./video-transcript-service";
+
+const requireInteractiveUser = (context: AppContext, isDemoMode: (env: Bindings) => boolean) => {
+ const denied = requireUser(context);
+ if (denied) return denied;
+ if (isDemoMode(context.env)) {
+ return forbidden(context, "Speech transcription is unavailable in demo mode.");
+ }
+ return null;
+};
+
+export const registerVideoTranscriptRoutes = (
+ app: Hono<AppEnv>,
+ dependencies: { isDemoMode: (env: Bindings) => boolean },
+) => {
+ app.get("/api/v1/video-transcript-jobs", async (context) => {
+ const denied = requireInteractiveUser(context, dependencies.isDemoMode);
+ if (denied) return denied;
+ const jobs = await listClaimableVideoTranscriptJobs(context.env.storage.db, getWorkspaceId(context));
+ return context.json({ jobs });
+ });
+
+ app.post("/api/v1/video-transcript-jobs/:memoId/extract", async (context) => {
+ const denied = requireInteractiveUser(context, dependencies.isDemoMode);
+ if (denied) return denied;
+ const result = await extractVideoTranscript(
+ context.env.storage.db,
+ getWorkspaceId(context),
+ context.req.param("memoId"),
+ );
+ if (result.status === "missing") {
+ return notFound(context, "This note is not a video note.");
+ }
+ if (result.status === "unavailable") return databaseNotReady(context);
+ return context.json({ status: result.status });
+ });
+
+ app.post("/api/v1/video-transcript-jobs/:memoId/claim", async (context) => {
+ const denied = requireInteractiveUser(context, dependencies.isDemoMode);
+ if (denied) return denied;
+ const job = await claimVideoTranscriptJob(
+ context.env.storage.db,
+ getWorkspaceId(context),
+ context.req.param("memoId"),
+ );
+ if (!job) {
+ return apiError(context, "video_transcript_not_claimed", "This transcript job is not waiting.", 409);
+ }
+ return context.json({ job });
+ });
+
+ app.post(
+ "/api/v1/video-transcript-jobs/:memoId/finish",
+ zValidator("json", VideoTranscriptFinishSchema),
+ async (context) => {
+ const denied = requireInteractiveUser(context, dependencies.isDemoMode);
+ if (denied) return denied;
+ const input = context.req.valid("json");
+ const finished = await finishVideoTranscriptJob(
+ context.env.storage.db,
+ getWorkspaceId(context),
+ context.req.param("memoId"),
+ { status: input.status, errorCode: input.errorCode ?? null, claimedAt: input.claimedAt },
+ );
+ if (!finished) {
+ return apiError(context, "video_transcript_not_claimed", "This transcript job is not claimed.", 409);
+ }
+ return context.json({ ok: true });
+ },
+ );
+};
diff --git a/apps/api/src/video-transcript-service.ts b/apps/api/src/video-transcript-service.ts
new file mode 100644
index 00000000..98ba0142
--- /dev/null
+++ b/apps/api/src/video-transcript-service.ts
@@ -0,0 +1,184 @@
+import { parseVideoNoteMarker } from "@edgeever/shared";
+import { isDatabaseNotReadyError } from "./auth-state";
+import { isoNow } from "./entity-utils";
+import type { DatabaseAdapter } from "./storage-contract";
+
+const STALE_MS = 20 * 60 * 1000;
+
+export type VideoTranscriptJob = {
+ memoId: string;
+ platform: "youtube" | "bilibili";
+ videoId: string;
+ sourceUrl: string;
+ durationSeconds: number;
+ placeholderText: string;
+ transcriptLabel: string;
+ contentHash: string;
+ status: string;
+ claimedAt: string | null;
+};
+
+type VideoTranscriptJobRow = {
+ memo_id: string;
+ platform: "youtube" | "bilibili";
+ video_id: string;
+ source_url: string;
+ duration_seconds: number;
+ placeholder_text: string;
+ transcript_label: string;
+ content_hash: string;
+ status: string;
+ claimed_at: string | null;
+};
+
+const JOB_COLUMNS = `memo_id, platform, video_id, source_url, duration_seconds,
+ placeholder_text, transcript_label, content_hash, status, claimed_at`;
+
+const mapJob = (row: VideoTranscriptJobRow): VideoTranscriptJob => ({
+ memoId: row.memo_id,
+ platform: row.platform,
+ videoId: row.video_id,
+ sourceUrl: row.source_url,
+ durationSeconds: row.duration_seconds,
+ placeholderText: row.placeholder_text,
+ transcriptLabel: row.transcript_label,
+ contentHash: row.content_hash,
+ status: row.status,
+ claimedAt: row.claimed_at,
+});
+
+const changed = (result: { meta?: { changes?: unknown } }) => Number(result.meta?.changes) === 1;
+
+const staleBefore = (now: string) => new Date(Date.parse(now) - STALE_MS).toISOString();
+
+const claimableSql = `(
+ status = 'pending'
+ OR (status = 'transcribing' AND claimed_at IS NOT NULL AND claimed_at < ?)
+)`;
+
+export type VideoTranscriptExtractResult =
+ | { status: "queued" | "running" }
+ | { status: "missing" }
+ | { status: "unavailable" };
+
+export const extractVideoTranscript = async (
+ db: DatabaseAdapter,
+ workspaceId: string,
+ memoId: string,
+ now = isoNow(),
+): Promise<VideoTranscriptExtractResult> => {
+ if (!memoId) return { status: "missing" };
+ const memo = await db.prepare(
+ `SELECT c.content_markdown, c.content_hash
+ FROM memos m
+ JOIN memo_contents c ON c.memo_id = m.id
+ WHERE m.workspace_id = ? AND m.id = ? AND m.is_deleted = 0
+ LIMIT 1`,
+ ).bind(workspaceId, memoId).first<{ content_markdown: string; content_hash: string }>();
+ const identity = parseVideoNoteMarker(memo?.content_markdown);
+ if (!memo?.content_hash || !identity) return { status: "missing" };
+ try {
+ const result = await db.prepare(
+ `INSERT INTO video_transcript_jobs (
+ memo_id, workspace_id, platform, video_id, source_url, duration_seconds,
+ placeholder_text, transcript_label, content_hash, status, created_at, updated_at
+ ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'pending', ?, ?)
+ ON CONFLICT(memo_id) DO UPDATE SET
+ platform = excluded.platform,
+ video_id = excluded.video_id,
+ source_url = excluded.source_url,
+ duration_seconds = excluded.duration_seconds,
+ placeholder_text = excluded.placeholder_text,
+ transcript_label = excluded.transcript_label,
+ content_hash = excluded.content_hash,
+ status = 'pending',
+ claimed_at = NULL,
+ error_code = NULL,
+ updated_at = excluded.updated_at
+ WHERE video_transcript_jobs.workspace_id = excluded.workspace_id
+ AND (
+ video_transcript_jobs.status IN ('ready', 'failed')
+ OR (
+ video_transcript_jobs.status = 'transcribing'
+ AND video_transcript_jobs.claimed_at IS NOT NULL
+ AND video_transcript_jobs.claimed_at < ?
+ )
+ )`,
+ ).bind(
+ memoId,
+ workspaceId,
+ identity.platform,
+ identity.videoId,
+ identity.sourceUrl,
+ identity.durationSeconds,
+ identity.placeholderText,
+ identity.transcriptLabel,
+ memo.content_hash,
+ now,
+ now,
+ staleBefore(now),
+ ).run();
+ return { status: changed(result) ? "queued" : "running" };
+ } catch (error) {
+ if (isDatabaseNotReadyError(error)) return { status: "unavailable" };
+ throw error;
+ }
+};
+
+export const listClaimableVideoTranscriptJobs = async (
+ db: DatabaseAdapter,
+ workspaceId: string,
+ now = isoNow(),
+) => {
+ const rows = await db.prepare(
+ `SELECT ${JOB_COLUMNS}
+ FROM video_transcript_jobs
+ WHERE workspace_id = ? AND ${claimableSql}
+ ORDER BY created_at ASC
+ LIMIT 5`,
+ ).bind(workspaceId, staleBefore(now)).all<VideoTranscriptJobRow>();
+ return (rows.results ?? []).map(mapJob);
+};
+
+export const claimVideoTranscriptJob = async (
+ db: DatabaseAdapter,
+ workspaceId: string,
+ memoId: string,
+ now = isoNow(),
+) => {
+ const result = await db.prepare(
+ `UPDATE video_transcript_jobs
+ SET status = 'transcribing', claimed_at = ?, error_code = NULL, updated_at = ?
+ WHERE workspace_id = ? AND memo_id = ? AND ${claimableSql}`,
+ ).bind(now, now, workspaceId, memoId, staleBefore(now)).run();
+ if (!changed(result)) return null;
+ const row = await db.prepare(
+ `SELECT ${JOB_COLUMNS}
+ FROM video_transcript_jobs
+ WHERE workspace_id = ? AND memo_id = ? AND status = 'transcribing' AND claimed_at = ?
+ LIMIT 1`,
+ ).bind(workspaceId, memoId, now).first<VideoTranscriptJobRow>();
+ return row ? mapJob(row) : null;
+};
+
+export const finishVideoTranscriptJob = async (
+ db: DatabaseAdapter,
+ workspaceId: string,
+ memoId: string,
+ input: { status: "ready" | "failed"; errorCode: string | null; claimedAt: string },
+ now = isoNow(),
+) => {
+ const result = await db.prepare(
+ `UPDATE video_transcript_jobs
+ SET status = ?, error_code = ?, updated_at = ?
+ WHERE workspace_id = ? AND memo_id = ? AND status = 'transcribing' AND claimed_at = ?`,
+ ).bind(
+ input.status,
+ input.status === "failed" ? input.errorCode : null,
+ now,
+ workspaceId,
+ memoId,
+ input.claimedAt,
+ ).run();
+ return changed(result);
+};
diff --git a/apps/api/src/video-transcript.test.mjs b/apps/api/src/video-transcript.test.mjs
new file mode 100644
index 00000000..884e45b1
--- /dev/null
+++ b/apps/api/src/video-transcript.test.mjs
@@ -0,0 +1,336 @@
+import { serializeVideoNoteMarker } from "@edgeever/shared";
+import { afterEach, expect, test } from "bun:test";
+import { Database } from "bun:sqlite";
+import { globSync, readFileSync } from "node:fs";
+import { Hono } from "hono";
+import { mapMemoSummary } from "./memo-list-service.ts";
+import { createMemoRecord } from "./memo-service.ts";
+import { createSelfHostedStorageAdapter } from "./self-hosted-storage-adapter.ts";
+import { registerMemoRoutes } from "./memo-routes.ts";
+import { registerVideoTranscriptRoutes } from "./video-transcript-routes.ts";
+import { extractVideoTranscript } from "./video-transcript-service.ts";
+
+const opened = [];
+afterEach(() => opened.splice(0).forEach((db) => db.close()));
+
+const user = {
+ kind: "user",
+ actorType: "user",
+ actorId: "usr_1",
+ username: "member",
+ displayName: "Member",
+ scopes: [],
+ workspaceId: "paw",
+ role: "owner",
+};
+
+const jobInput = {
+ platform: "youtube",
+ videoId: "abcdefghijk",
+ sourceUrl: "https://www.youtube.com/watch?v=abcdefghijk",
+ durationSeconds: 42,
+ placeholderText: "这一集没有可用字幕",
+ transcriptLabel: "字幕实录",
+};
+
+const setup = () => {
+ const sqlite = new Database(":memory:");
+ opened.push(sqlite);
+ for (const file of globSync("migrations/*.sql").sort()) sqlite.exec(readFileSync(file, "utf8"));
+ sqlite.exec(`INSERT INTO workspaces(id, name) VALUES ('paw', 'Paw');
+ INSERT INTO notebooks(id, workspace_id, name) VALUES ('inbox', 'paw', 'Inbox');`);
+ const db = createSelfHostedStorageAdapter(sqlite, "/tmp/video-transcript-unused").db;
+ return { sqlite, db };
+};
+
+const createApp = (auth = user, { demoMode = false } = {}) => {
+ const app = new Hono();
+ app.use("/api/v1/*", async (context, next) => {
+ context.set("auth", auth);
+ await next();
+ });
+ const unused = async () => {
+ throw new Error("unused");
+ };
+ registerVideoTranscriptRoutes(app, { isDemoMode: () => demoMode });
+ registerMemoRoutes(app, {
+ clampNumber: (value) => value,
+ createImageResource: async () => ({ id: "res_1" }),
+ createMemo: (...args) => createMemoRecord(...args),
+ createMemoEditSession: unused,
+ deleteMemo: async () => {},
+ deleteMemos: async () => 0,
+ emptyTrash: async () => 0,
+ getMemoDetail: async () => null,
+ listMemos: async () => ({ memos: [] }),
+ listMemoRevisions: async () => [],
+ mergeMemos: unused,
+ moveMemos: async () => 0,
+ restoreMemo: unused,
+ restoreMemoRevision: unused,
+ updateMemo: unused,
+ });
+ return app;
+};
+
+const environmentFor = (db) => ({
+ storage: { db, resources: {} },
+});
+
+const postMemo = (app, db, body) => app.request("/api/v1/memos", {
+ method: "POST",
+ headers: { "content-type": "application/json" },
+ body: JSON.stringify({ notebookId: "inbox", title: "Video", contentMarkdown: "hello\n", ...body }),
+}, environmentFor(db));
+
+const videoMarkdown = () => `这一集没有可用字幕\n\n${serializeVideoNoteMarker(jobInput)}\n`;
+
+const extract = (app, db, memoId) => app.request(
+ `/api/v1/video-transcript-jobs/${memoId}/extract`,
+ { method: "POST" },
+ environmentFor(db),
+);
+
+test("a missing transcript table does not pretend extraction started", async () => {
+ const db = {
+ prepare(sql) {
+ return {
+ bind() { return this; },
+ async first() {
+ return String(sql).includes("FROM memos")
+ ? { content_markdown: videoMarkdown(), content_hash: "a".repeat(64) }
+ : null;
+ },
+ async run() { throw new Error("no such table: video_transcript_jobs"); },
+ };
+ },
+ };
+ await expect(extractVideoTranscript(db, "paw", "memo_1")).resolves.toEqual({ status: "unavailable" });
+});
+
+test("saving a video note waits for an explicit extract", async () => {
+ const { sqlite, db } = setup();
+ const app = createApp();
+ const created = await postMemo(app, db, { videoTranscript: jobInput, contentMarkdown: videoMarkdown() });
+ expect(created.status).toBe(201);
+ expect(sqlite.query("SELECT COUNT(*) AS count FROM video_transcript_jobs").get().count).toBe(0);
+ const memoId = (await created.json()).memo.id;
+ expect(mapMemoSummary({
+ id: memoId,
+ notebook_id: "inbox",
+ title: "Video",
+ excerpt: "",
+ content_markdown: videoMarkdown(),
+ tags_json: "[]",
+ is_pinned: 0,
+ is_archived: 0,
+ is_deleted: 0,
+ created_at: "2026-10-07T00:00:00.000Z",
+ updated_at: "2026-10-07T00:00:00.000Z",
+ deleted_at: null,
+ revision: 1,
+ }).videoNote).toBe(true);
+
+ const started = await extract(app, db, memoId);
+ expect(started.status).toBe(200);
+ expect(await started.json()).toEqual({ status: "queued" });
+ const row = sqlite.query(
+ "SELECT platform, video_id, source_url, duration_seconds, status, content_hash FROM video_transcript_jobs",
+ ).get();
+ expect(row).toMatchObject({
+ platform: "youtube",
+ video_id: "abcdefghijk",
+ source_url: jobInput.sourceUrl,
+ duration_seconds: 42,
+ status: "pending",
+ });
+ expect(row.content_hash).toHaveLength(64);
+
+ const again = await extract(app, db, memoId);
+ expect(await again.json()).toEqual({ status: "running" });
+ expect(sqlite.query("SELECT COUNT(*) AS count FROM video_transcript_jobs").get().count).toBe(1);
+
+ const plain = await postMemo(app, db, {});
+ expect(plain.status).toBe(201);
+ expect((await extract(app, db, (await plain.json()).memo.id)).status).toBe(404);
+
+ const rejected = await postMemo(app, db, {
+ videoTranscript: { ...jobInput, sourceUrl: "https://user:[email protected]/watch?v=abcdefghijk" },
+ });
+ expect(rejected.status).toBe(201);
+ expect(sqlite.query("SELECT COUNT(*) AS count FROM video_transcript_jobs").get().count).toBe(1);
+});
+
+test("a cover upload keeps the video note without starting transcription", async () => {
+ const { sqlite, db } = setup();
+ const app = createApp();
+ const form = new FormData();
+ form.append("notebookId", "inbox");
+ form.append("title", "Video");
+ form.append("contentMarkdown", `![封面](/api/v1/resources/EDGEVERRESOURCEID/blob)\n\n${videoMarkdown()}`);
+ form.append("tags", JSON.stringify(["web-clip"]));
+ form.append("videoTranscript", JSON.stringify(jobInput));
+ form.append("file", new File([Uint8Array.from([1, 2, 3])], "cover.jpg", { type: "image/jpeg" }));
+ const created = await app.request("/api/v1/memos/with-image", { method: "POST", body: form }, environmentFor(db));
+ expect(created.status).toBe(201);
+ expect(sqlite.query("SELECT COUNT(*) AS count FROM video_transcript_jobs").get().count).toBe(0);
+ const memoId = (await created.json()).memo.id;
+ expect((await extract(app, db, memoId)).status).toBe(200);
+ expect(sqlite.query("SELECT COUNT(*) AS count FROM video_transcript_jobs").get().count).toBe(1);
+ const markdown = sqlite.query("SELECT content_markdown FROM memo_contents").get().content_markdown;
+ expect(markdown).not.toContain("EDGEVERRESOURCEID");
+});
+
+test("one desktop claims the job, a second waits, and a stale claim can be taken", async () => {
+ const { sqlite, db } = setup();
+ const app = createApp();
+ const created = await postMemo(app, db, { contentMarkdown: videoMarkdown() });
+ expect(created.status).toBe(201);
+ const memoId = (await created.json()).memo.id;
+ expect((await extract(app, db, memoId)).status).toBe(200);
+ const environment = environmentFor(db);
+ const claim = () => app.request(`/api/v1/video-transcript-jobs/${memoId}/claim`, { method: "POST" }, environment);
+ const first = await claim();
+ expect(first.status).toBe(200);
+ const claimed = await first.json();
+ expect(claimed.job.memoId).toBe(memoId);
+ expect(claimed.job.claimedAt).toEqual(expect.any(String));
+ expect(JSON.stringify(claimed)).not.toContain("apiKey");
+
+ const second = await claim();
+ expect(second.status).toBe(409);
+ expect(sqlite.query("SELECT claimed_at FROM video_transcript_jobs").get().claimed_at).toBe(claimed.job.claimedAt);
+
+ const listed = await app.request("/api/v1/video-transcript-jobs", {}, environment);
+ expect(await listed.json()).toEqual({ jobs: [] });
+
+ sqlite.query("UPDATE video_transcript_jobs SET claimed_at = ?").run("2020-01-01T00:00:00.000Z");
+ const reclaimed = await claim();
+ expect(reclaimed.status).toBe(200);
+ const next = await reclaimed.json();
+ expect(next.job.claimedAt).not.toBe("2020-01-01T00:00:00.000Z");
+
+ const finished = await app.request(`/api/v1/video-transcript-jobs/${memoId}/finish`, {
+ method: "POST",
+ headers: { "content-type": "application/json" },
+ body: JSON.stringify({ status: "ready", claimedAt: next.job.claimedAt }),
+ }, environment);
+ expect(finished.status).toBe(200);
+ expect(sqlite.query("SELECT status, error_code FROM video_transcript_jobs").get()).toEqual({
+ status: "ready",
+ error_code: null,
+ });
+
+ const late = await app.request(`/api/v1/video-transcript-jobs/${memoId}/finish`, {
+ method: "POST",
+ headers: { "content-type": "application/json" },
+ body: JSON.stringify({ status: "failed", errorCode: "download_failed", claimedAt: next.job.claimedAt }),
+ }, environment);
+ expect(late.status).toBe(409);
+});
+
+test("a failed job stays failed and is not offered again", async () => {
+ const { sqlite, db } = setup();
+ const app = createApp();
+ const environment = environmentFor(db);
+ const created = await postMemo(app, db, { contentMarkdown: videoMarkdown() });
+ expect(created.status).toBe(201);
+ const memoId = (await created.json()).memo.id;
+ expect((await extract(app, db, memoId)).status).toBe(200);
+ const claimed = await (await app.request(
+ `/api/v1/video-transcript-jobs/${memoId}/claim`,
+ { method: "POST" },
+ environment,
+ )).json();
+ const failed = await app.request(`/api/v1/video-transcript-jobs/${memoId}/finish`, {
+ method: "POST",
+ headers: { "content-type": "application/json" },
+ body: JSON.stringify({
+ status: "failed",
+ errorCode: "download_failed",
+ claimedAt: claimed.job.claimedAt,
+ }),
+ }, environment);
+ expect(failed.status).toBe(200);
+ expect(await (await app.request("/api/v1/video-transcript-jobs", {}, environment)).json()).toEqual({ jobs: [] });
+ expect((await app.request(`/api/v1/video-transcript-jobs/${memoId}/claim`, { method: "POST" }, environment)).status).toBe(409);
+});
+
+test("a failed extract can be started again, and a fresh claim cannot", async () => {
+ const { sqlite, db } = setup();
+ const app = createApp();
+ const environment = environmentFor(db);
+ const created = await postMemo(app, db, { contentMarkdown: videoMarkdown() });
+ const memoId = (await created.json()).memo.id;
+ expect(await (await extract(app, db, memoId)).json()).toEqual({ status: "queued" });
+ const claimed = await (await app.request(
+ `/api/v1/video-transcript-jobs/${memoId}/claim`,
+ { method: "POST" },
+ environment,
+ )).json();
+ expect((await app.request(`/api/v1/video-transcript-jobs/${memoId}/finish`, {
+ method: "POST",
+ headers: { "content-type": "application/json" },
+ body: JSON.stringify({
+ status: "failed",
+ errorCode: "download_failed",
+ claimedAt: claimed.job.claimedAt,
+ }),
+ }, environment)).status).toBe(200);
+ expect(await (await extract(app, db, memoId)).json()).toEqual({ status: "queued" });
+ expect(sqlite.query("SELECT status, error_code, claimed_at FROM video_transcript_jobs").get()).toEqual({
+ status: "pending",
+ error_code: null,
+ claimed_at: null,
+ });
+
+ expect((await app.request(`/api/v1/video-transcript-jobs/${memoId}/claim`, { method: "POST" }, environment)).status).toBe(200);
+ expect(await (await extract(app, db, memoId)).json()).toEqual({ status: "running" });
+ expect(sqlite.query("SELECT status FROM video_transcript_jobs").get().status).toBe("transcribing");
+ sqlite.query("UPDATE video_transcript_jobs SET claimed_at = ?").run("2020-01-01T00:00:00.000Z");
+ expect(await (await extract(app, db, memoId)).json()).toEqual({ status: "queued" });
+ expect(sqlite.query("SELECT status, claimed_at FROM video_transcript_jobs").get()).toEqual({
+ status: "pending",
+ claimed_at: null,
+ });
+});
+
+test("clipper tokens cannot start, list, or claim transcription", async () => {
+ const { sqlite, db } = setup();
+ const clipper = createApp({
+ ...user,
+ kind: "agent",
+ actorType: "agent",
+ actorId: "tok_clip",
+ scopes: ["write:memos", "read:memos"],
+ });
+ const created = await postMemo(clipper, db, { contentMarkdown: videoMarkdown(), videoTranscript: jobInput });
+ expect(created.status).toBe(201);
+ expect(sqlite.query("SELECT COUNT(*) AS count FROM video_transcript_jobs").get().count).toBe(0);
+ const environment = environmentFor(db);
+ const memoId = (await created.json()).memo.id;
+ expect((await extract(clipper, db, memoId)).status).toBe(403);
+ expect((await clipper.request("/api/v1/video-transcript-jobs", {}, environment)).status).toBe(403);
+ expect((await clipper.request(`/api/v1/video-transcript-jobs/${memoId}/claim`, { method: "POST" }, environment)).status).toBe(403);
+ expect(sqlite.query("SELECT COUNT(*) AS count FROM video_transcript_jobs").get().count).toBe(0);
+
+ const demo = createApp(user, { demoMode: true });
+ expect((await extract(demo, db, memoId)).status).toBe(403);
+ expect((await demo.request("/api/v1/video-transcript-jobs", {}, environment)).status).toBe(403);
+});
+
+test("the API does not import the desktop transcription package", () => {
+ for (const name of [
+ "video-transcript-service.ts",
+ "video-transcript-routes.ts",
+ "ai-routes.ts",
+ "memo-routes.ts",
+ ]) {
+ const source = readFileSync(new URL(`./${name}`, import.meta.url), "utf8");
+ expect(source).not.toContain("@ai-sdk/openai");
+ expect(source).not.toContain("transcribe(");
+ }
+ const service = readFileSync(new URL("./ai-service.ts", import.meta.url), "utf8");
+ expect(service).not.toContain("@ai-sdk/openai");
+ expect(service).not.toContain(".transcription(");
+});
diff --git a/apps/desktop/package.json b/apps/desktop/package.json
index b1b9a9e9..2edc3b88 100644
--- a/apps/desktop/package.json
+++ b/apps/desktop/package.json
@@ -18,8 +18,10 @@
"electron-builder": "^26.0.12"
},
"dependencies": {
+ "@ai-sdk/openai": "4.0.36",
"@agentclientprotocol/sdk": "^1.5.1",
"@edgeever/public-network": "workspace:*",
+ "ai": "7.0.58",
"croner": "^10.0.1",
"electron-updater": "^6.6.2",
"fflate": "0.8.3",
diff --git a/apps/desktop/src/main/index.mjs b/apps/desktop/src/main/index.mjs
index 7b9d7e9b..f901b447 100644
--- a/apps/desktop/src/main/index.mjs
+++ b/apps/desktop/src/main/index.mjs
@@ -48,6 +48,13 @@ import {
} from "./windows-update-trust.mjs";
import electronUpdater from "electron-updater";
import { createPluginPublicNetworkRuntime } from "./plugin-public-network.mjs";
+import { createYtDlpManager, startYtDlpMaintenance } from "./yt-dlp-tool.mjs";
+import {
+ createSpeechTranscriptionRunner,
+ readCookieBrowserPreference,
+ startSpeechTranscription,
+ writeCookieBrowserPreference,
+} from "./speech-transcription.mjs";
import { createAiDirectRuntime } from "./ai-direct.mjs";
import { createAcpHostRuntime, registerAcpIpc } from "./acp-host.mjs";
import { shouldQuitAfterAllWindowsClosed } from "./window-lifecycle.mjs";
@@ -127,6 +134,10 @@ let updateState = "idle";
let updateCheckInFlight = null;
let updateDownloadInFlight = null;
let updateCheckTimer = null;
+let stopYtDlpMaintenance = null;
+let stopSpeechTranscription = null;
+let ytDlpMaintenanceTimer = null;
+let ytDlpManager = null;
let lastUpdateCheckAt = 0;
let downloadedUpdateVersion = null;
let promptedUpdateVersion = null;
@@ -174,6 +185,7 @@ const sessionTokenPath = () => join(app.getPath("userData"), "session-token");
const crashMarkerPath = () => join(app.getPath("userData"), "last-session-active");
const installationMarkerPath = () => join(app.getPath("userData"), "installation-confirmed");
const logPath = () => join(app.getPath("userData"), "logs", "desktop.log");
+const videoCookieBrowserPath = () => join(app.getPath("userData"), "video-cookie-browser.json");
let desktopSessionToken = "";
const sidecarDataDirectory = (accountId = null) => {
return accountId
@@ -1518,6 +1530,15 @@ const startApplication = async () => {
app.quit();
return;
}
+ ytDlpManager = createYtDlpManager({
+ directory: join(app.getPath("userData"), "tools"),
+ platform: process.platform,
+ arch: process.arch,
+ fetch: net.fetch.bind(net),
+ onDiagnostic: (event, details) => {
+ void writeDiagnostic(event, details);
+ },
+ });
await loadConfiguredApiBaseUrl();
await loadDesktopSessionToken();
app.setAsDefaultProtocolClient("edgeever");
@@ -1551,6 +1572,17 @@ const startApplication = async () => {
});
ipcMain.handle("desktop:sidecar-status", () => ({ available: Boolean(sidecar), path: sidecarPath, scope: sidecarScopeKey }));
ipcMain.handle("desktop:system-info", () => desktopRuntimeSystemInfo());
+ ipcMain.handle("desktop:yt-dlp-status", () => ytDlpManager?.status() ?? {
+ state: "idle",
+ version: null,
+ path: "",
+ errorCode: null,
+ httpStatus: null,
+ });
+ ipcMain.handle("desktop:video-cookie-browser-get", () => readCookieBrowserPreference(videoCookieBrowserPath()));
+ ipcMain.handle("desktop:video-cookie-browser-set", (_event, browser) => (
+ writeCookieBrowserPreference(videoCookieBrowserPath(), browser)
+ ));
ipcMain.handle("desktop:set-account-scope", async (_event, accountId) => {
const normalizedAccountId = typeof accountId === "string" && accountId.trim() ? accountId.trim() : null;
const nextScopeKey = accountScopeKey(configuredApiBaseUrl, normalizedAccountId);
@@ -1915,6 +1947,22 @@ const startApplication = async () => {
// user-visible critical path so the first installed launch opens promptly.
await ejectMountedMacInstallers();
await confirmMacInstallation();
+ // The standalone binary is about 35 MB. Start only after the window and the
+ // first-run installer dialog, and never await it: the workspace must stay usable.
+ ytDlpMaintenanceTimer = setTimeout(() => {
+ ytDlpMaintenanceTimer = null;
+ if (!ytDlpManager || stopYtDlpMaintenance) return;
+ stopYtDlpMaintenance = startYtDlpMaintenance(ytDlpManager, { intervalMs: updateCheckIntervalMs });
+ // Transcription waits on this same timer and is not awaited. A pass that
+ // finds nothing, or a download that fails, must not block the window.
+ stopSpeechTranscription = startSpeechTranscription(createSpeechTranscriptionRunner({
+ getSession: () => ({ baseUrl: configuredApiBaseUrl, token: desktopSessionToken }),
+ ytDlpStatus: () => ytDlpManager.status(),
+ cookieBrowser: () => readCookieBrowserPreference(videoCookieBrowserPath()),
+ audioDirectory: () => join(app.getPath("userData"), "tools", "transcript-audio"),
+ }));
+ }, 3_000);
+ ytDlpMaintenanceTimer.unref?.();
void enableMacShareExtension({
platform: process.platform,
packaged: app.isPackaged,
@@ -2004,6 +2052,14 @@ app.on("before-quit", (event) => {
clearInterval(updateCheckTimer);
updateCheckTimer = null;
}
+ if (ytDlpMaintenanceTimer) {
+ clearTimeout(ytDlpMaintenanceTimer);
+ ytDlpMaintenanceTimer = null;
+ }
+ stopYtDlpMaintenance?.();
+ stopYtDlpMaintenance = null;
+ stopSpeechTranscription?.();
+ stopSpeechTranscription = null;
tray?.destroy();
void (async () => {
await stopSidecar();
diff --git a/apps/desktop/src/main/speech-transcription.mjs b/apps/desktop/src/main/speech-transcription.mjs
new file mode 100644
index 00000000..1bc74f55
--- /dev/null
+++ b/apps/desktop/src/main/speech-transcription.mjs
@@ -0,0 +1,412 @@
+import { execFile } from "node:child_process";
+import { mkdir, readdir, readFile, stat, unlink, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+
+export const MAX_AUDIO_BYTES = 24 * 1024 * 1024;
+export const MAX_DURATION_SECONDS = 30 * 60;
+export const SPEECH_TRANSCRIPTION_INTERVAL_MS = 20_000;
+const DOWNLOAD_TIMEOUT_MS = 180_000;
+const TRANSCRIBE_TIMEOUT_MS = 180_000;
+
+const PUBLIC_VIDEO_HOSTS = new Set([
+ "youtube.com",
+ "www.youtube.com",
+ "m.youtube.com",
+ "youtu.be",
+ "bilibili.com",
+ "www.bilibili.com",
+ "m.bilibili.com",
+]);
+
+const FAILURE_CODES = new Set([
+ "duration_limit",
+ "unsupported_source",
+ "audio_too_large",
+ "download_failed",
+ "transcribe_failed",
+ "empty_transcript",
+ "note_changed",
+ "note_write_failed",
+ "credentials_unavailable",
+ "disabled",
+]);
+
+const fail = (code) => {
+ const error = new Error(code);
+ error.code = code;
+ return error;
+};
+
+export const isPublicVideoSourceUrl = (value) => {
+ try {
+ const url = new URL(value);
+ return url.protocol === "https:"
+ && !url.username
+ && !url.password
+ && PUBLIC_VIDEO_HOSTS.has(url.hostname);
+ } catch {
+ return false;
+ }
+};
+
+export const transcriptAudioBaseName = (memoId) => {
+ const value = String(memoId ?? "");
+ if (!value || !/^[A-Za-z0-9_-]+$/.test(value)) return null;
+ return value;
+};
+
+// Keep this aligned with packages/shared/src/video-cookie-browser.ts.
+export const COOKIE_BROWSERS = Object.freeze([
+ "chrome",
+ "chromium",
+ "edge",
+ "firefox",
+ "safari",
+ "brave",
+ "opera",
+ "vivaldi",
+ "whale",
+]);
+export const DEFAULT_COOKIE_BROWSER = "chrome";
+
+export const normalizeCookieBrowser = (value) => {
+ const name = String(value ?? "").trim().toLowerCase();
+ if (name === "none") return "none";
+ return COOKIE_BROWSERS.includes(name) ? name : DEFAULT_COOKIE_BROWSER;
+};
+
+export const readCookieBrowserPreference = async (filePath) => {
+ try {
+ const parsed = JSON.parse(await readFile(filePath, "utf8"));
+ return normalizeCookieBrowser(parsed?.browser);
+ } catch {
+ return DEFAULT_COOKIE_BROWSER;
+ }
+};
+
+export const writeCookieBrowserPreference = async (filePath, browser) => {
+ const name = String(browser ?? "").trim().toLowerCase();
+ if (name !== "none" && !COOKIE_BROWSERS.includes(name)) {
+ throw Object.assign(new Error("unsupported_browser"), { code: "unsupported_browser" });
+ }
+ await mkdir(dirname(filePath), { recursive: true });
+ await writeFile(filePath, `${JSON.stringify({ browser: name })}\n`, { mode: 0o600 });
+ return { browser: name };
+};
+
+export const bestAudioArguments = (sourceUrl, outputTemplate, browser = DEFAULT_COOKIE_BROWSER) => {
+ const selected = normalizeCookieBrowser(browser);
+ return [
+ "--no-playlist",
+ "--no-progress",
+ "--no-mtime",
+ "--no-cache-dir",
+ "--restrict-filenames",
+ "-f",
+ "bestaudio",
+ "--max-filesize",
+ "24M",
+ ...(selected === "none" ? [] : ["--cookies-from-browser", selected]),
+ "-o",
+ outputTemplate,
+ "--",
+ sourceUrl,
+ ];
+};
+
+export const formatTranscriptTimestamp = (seconds) => {
+ const total = Math.max(0, Math.floor(Number(seconds) || 0));
+ const hours = Math.floor(total / 3600);
+ const minutes = Math.floor((total % 3600) / 60);
+ const remain = total % 60;
+ const clock = `${String(minutes).padStart(2, "0")}:${String(remain).padStart(2, "0")}`;
+ return hours > 0 ? `${hours}:${clock}` : clock;
+};
+
+const escapeHtml = (value) => String(value)
+ .replace(/&/g, "&amp;")
+ .replace(/</g, "&lt;")
+ .replace(/>/g, "&gt;");
+
+const plain = (value) => escapeHtml(String(value).replace(/\s+/g, " ").trim())
+ .replace(/\]\(/g, "] (")
+ .replace(/\[/g, "[")
+ .replace(/\]/g, "]");
+
+export const videoTimestampUrl = (sourceUrl, platform, seconds) => {
+ const time = Math.max(0, Math.floor(Number(seconds) || 0));
+ if (platform === "youtube") {
+ return sourceUrl.includes("/shorts/")
+ ? `${sourceUrl}?t=${time}`
+ : `${sourceUrl}&t=${time}s`;
+ }
+ return sourceUrl.includes("?")
+ ? `${sourceUrl}&t=${time}`
+ : `${sourceUrl}?t=${time}`;
+};
+
+export const cuesFromTranscription = (result) => {
+ const segments = Array.isArray(result?.segments) ? result.segments : [];
+ return segments.flatMap((segment) => {
+ const text = String(segment?.text ?? "").replace(/\s+/g, " ").trim();
+ const start = Number(segment?.startSecond);
+ const end = Number(segment?.endSecond);
+ if (!text || !Number.isFinite(start) || !Number.isFinite(end)) return [];
+ return [{ start: Math.max(0, start), end: Math.max(start, end), text }];
+ });
+};
+
+export const buildTranscriptMarkdown = ({ label, text, cues, sourceUrl, platform }) => {
+ const summary = plain(label ?? "");
+ if (!summary) return null;
+ const lines = (cues ?? []).map((cue) => {
+ const body = plain(cue.text);
+ if (!body) return "";
+ return `- [${formatTranscriptTimestamp(cue.start)}](${videoTimestampUrl(sourceUrl, platform, cue.start)}) ${body}`;
+ }).filter(Boolean);
+ const inner = lines.length ? lines.join("\n") : plain(text ?? "");
+ if (!inner) return null;
+ return ["<details>", `<summary>${summary}</summary>`, "", inner, "", "</details>"].join("\n");
+};
+
+const VIDEO_NOTE_MARKER = /<!--\s*edgeever-video-v1:[A-Za-z0-9_=-]+\s*-->/g;
+
+export const applyTranscript = (markdown, placeholder, block) => {
+ const source = String(markdown ?? "");
+ const markers = source.match(VIDEO_NOTE_MARKER) ?? [];
+ const body = markers.length ? source.replace(VIDEO_NOTE_MARKER, "") : source;
+ const needle = String(placeholder ?? "").trim();
+ const addition = String(block ?? "").trim();
+ if (!addition) return source;
+ let next = body;
+ if (needle) {
+ const lines = body.split("\n");
+ const index = lines.findIndex((line) => line.trim() === needle);
+ if (index >= 0) {
+ lines.splice(index, 1, addition);
+ next = lines.join("\n");
+ } else {
+ next = `${body.trim()}\n\n${addition}`;
+ }
+ } else {
+ next = `${body.trim()}\n\n${addition}`;
+ }
+ const cleaned = `${next.replace(/\n{3,}/g, "\n\n").trim()}\n`;
+ if (!markers.length) return cleaned;
+ return `${cleaned.trim()}\n\n${markers.join("\n")}\n`;
+};
+
+export const transcriptionRequest = ({ baseUrl, apiKey, modelId, audio, abortSignal }) => ({
+ provider: { baseURL: baseUrl, apiKey },
+ modelId,
+ audio,
+ maxRetries: 0,
+ abortSignal,
+ providerOptions: { openai: { timestampGranularities: ["segment"] } },
+});
+
+export const transcribeLocalAudio = async (input, deps = {}) => {
+ const request = transcriptionRequest(input);
+ const createProvider = deps.createProvider ?? (await import("@ai-sdk/openai")).createOpenAI;
+ const transcribe = deps.transcribe ?? (await import("ai")).transcribe;
+ const provider = createProvider(request.provider);
+ return transcribe({
+ model: provider.transcription(request.modelId),
+ audio: request.audio,
+ maxRetries: request.maxRetries,
+ abortSignal: request.abortSignal,
+ providerOptions: request.providerOptions,
+ });
+};
+
+const instanceUrl = (baseUrl, path) => `${String(baseUrl).replace(/\/+$/, "")}${path}`;
+
+const requestJson = async (fetchImpl, session, path, init = {}) => {
+ const headers = {
+ Accept: "application/json",
+ Authorization: `Bearer ${session.token}`,
+ };
+ if (init.body) headers["content-type"] = "application/json";
+ const response = await fetchImpl(instanceUrl(session.baseUrl, path), {
+ method: init.method ?? "GET",
+ headers,
+ body: init.body,
+ });
+ const payload = await response.json().catch(() => null);
+ return { ok: response.ok, status: response.status, payload };
+};
+
+const removeAudioFiles = async (directory, baseName) => {
+ if (!directory || !baseName) return;
+ const names = await readdir(directory).catch(() => []);
+ await Promise.all(names
+ .filter((name) => name === baseName || name.startsWith(`${baseName}.`))
+ .map((name) => unlink(join(directory, name)).catch(() => undefined)));
+};
+
+const downloadBestAudio = async ({ execFileImpl, binaryPath, sourceUrl, directory, baseName, timeoutMs, browser }) => {
+ await mkdir(directory, { recursive: true });
+ const template = join(directory, `${baseName}.%(ext)s`);
+ const selected = typeof browser === "function" ? await browser() : browser;
+ await new Promise((resolve, reject) => {
+ execFileImpl(binaryPath, bestAudioArguments(sourceUrl, template, selected), {
+ timeout: timeoutMs,
+ windowsHide: true,
+ maxBuffer: 4 * 1024 * 1024,
+ }, (error) => {
+ if (error) reject(fail("download_failed"));
+ else resolve();
+ });
+ });
+ const names = await readdir(directory);
+ const audioName = names.find((name) => name.startsWith(`${baseName}.`) && !name.endsWith(".part") && !name.endsWith(".ytdl"));
+ if (!audioName) throw fail("download_failed");
+ return join(directory, audioName);
+};
+
+const failureCode = (error) => FAILURE_CODES.has(error?.code) ? error.code : "transcribe_failed";
+
+const processClaimedJob = async (deps, session, job) => {
+ const maxAudioBytes = deps.maxAudioBytes ?? MAX_AUDIO_BYTES;
+ const maxDurationSeconds = deps.maxDurationSeconds ?? MAX_DURATION_SECONDS;
+ const memoId = job.memoId;
+ const baseName = transcriptAudioBaseName(memoId);
+ let directory = null;
+ let settled = false;
+ const finish = (status, errorCode = null) => requestJson(
+ deps.fetchImpl,
+ session,
+ `/api/v1/video-transcript-jobs/${encodeURIComponent(memoId)}/finish`,
+ {
+ method: "POST",
+ body: JSON.stringify({
+ status,
+ errorCode,
+ claimedAt: job.claimedAt,
+ }),
+ },
+ );
+ try {
+ directory = await deps.audioDirectory();
+ const memoResponse = await requestJson(deps.fetchImpl, session, `/api/v1/memos/${encodeURIComponent(memoId)}`);
+ const memo = memoResponse.payload?.memo;
+ if (!memoResponse.ok || !memo) throw fail("note_write_failed");
+ if (memo.contentHash !== job.contentHash) throw fail("note_changed");
+ if (Number(job.durationSeconds) > maxDurationSeconds) throw fail("duration_limit");
+ if (!isPublicVideoSourceUrl(job.sourceUrl) || !baseName) throw fail("unsupported_source");
+ const tool = deps.ytDlpStatus();
+ if (tool?.state !== "ready" || !tool.path) throw fail("download_failed");
+ const prepared = await requestJson(deps.fetchImpl, session, "/api/v1/ai/transcription-settings/prepare", {
+ method: "POST",
+ body: "{}",
+ });
+ const standard = prepared.payload?.provider ?? "openai-compatible";
+ if (!prepared.ok || !prepared.payload?.enabled || !prepared.payload.apiKey || !prepared.payload.baseUrl || !prepared.payload.modelId || standard !== "openai-compatible") {
+ throw fail(prepared.ok ? "disabled" : "credentials_unavailable");
+ }
+ const audioPath = await downloadBestAudio({
+ execFileImpl: deps.execFileImpl,
+ binaryPath: tool.path,
+ sourceUrl: job.sourceUrl,
+ directory,
+ baseName,
+ timeoutMs: deps.downloadTimeoutMs ?? DOWNLOAD_TIMEOUT_MS,
+ browser: deps.cookieBrowser,
+ });
+ const audioStat = await stat(audioPath);
+ if (audioStat.size > maxAudioBytes) throw fail("audio_too_large");
+ if (audioStat.size <= 0) throw fail("download_failed");
+ const audio = await readFile(audioPath);
+ const result = await transcribeLocalAudio({
+ baseUrl: prepared.payload.baseUrl,
+ apiKey: prepared.payload.apiKey,
+ modelId: prepared.payload.modelId,
+ audio,
+ abortSignal: AbortSignal.timeout(deps.transcribeTimeoutMs ?? TRANSCRIBE_TIMEOUT_MS),
+ }, deps);
+ const cues = cuesFromTranscription(result);
+ const block = buildTranscriptMarkdown({
+ label: job.transcriptLabel,
+ text: result?.text,
+ cues,
+ sourceUrl: job.sourceUrl,
+ platform: job.platform,
+ });
+ if (!block) throw fail("empty_transcript");
+ const saved = await requestJson(deps.fetchImpl, session, `/api/v1/memos/${encodeURIComponent(memoId)}`, {
+ method: "PATCH",
+ body: JSON.stringify({
+ contentMarkdown: applyTranscript(memo.contentMarkdown, job.placeholderText, block),
+ expectedRevision: memo.revision,
+ expectedContentHash: memo.contentHash,
+ }),
+ });
+ if (saved.status === 409) throw fail("note_changed");
+ if (!saved.ok) throw fail("note_write_failed");
+ const done = await finish("ready");
+ if (!done.ok) throw fail("note_write_failed");
+ settled = true;
+ return { outcome: "ready", memoId };
+ } catch (error) {
+ if (!settled) await finish("failed", failureCode(error)).catch(() => undefined);
+ return { outcome: "failed", reason: failureCode(error), memoId };
+ } finally {
+ await removeAudioFiles(directory, baseName);
+ }
+};
+
+export const runSpeechTranscriptionPass = async (deps) => {
+ const fetchImpl = deps.fetchImpl ?? fetch;
+ const session = deps.getSession() ?? {};
+ if (!session.baseUrl || !session.token) return { outcome: "skipped", reason: "signed_out" };
+ const bound = { ...deps, fetchImpl, execFileImpl: deps.execFileImpl ?? execFile };
+ try {
+ const settings = await requestJson(fetchImpl, session, "/api/v1/ai/transcription-settings");
+ if (!settings.ok || settings.payload?.enabled !== true) return { outcome: "skipped", reason: "disabled" };
+ const tool = bound.ytDlpStatus();
+ if (tool?.state !== "ready" || !tool.path) return { outcome: "skipped", reason: "yt_dlp" };
+ const listed = await requestJson(fetchImpl, session, "/api/v1/video-transcript-jobs");
+ if (!listed.ok) return { outcome: "skipped", reason: "list_failed" };
+ const waiting = listed.payload?.jobs?.[0];
+ if (!waiting?.memoId) return { outcome: "skipped", reason: "idle" };
+ const claimed = await requestJson(
+ fetchImpl,
+ session,
+ `/api/v1/video-transcript-jobs/${encodeURIComponent(waiting.memoId)}/claim`,
+ { method: "POST", body: "{}" },
+ );
+ if (!claimed.ok || !claimed.payload?.job?.claimedAt) return { outcome: "skipped", reason: "claimed" };
+ return processClaimedJob(bound, session, claimed.payload.job);
+ } catch {
+ return { outcome: "failed", reason: "transcribe_failed" };
+ }
+};
+
+export const createSpeechTranscriptionRunner = (options) => ({
+ pass: () => runSpeechTranscriptionPass(options),
+});
+
+export const startSpeechTranscription = (
+ runner,
+ { intervalMs = SPEECH_TRANSCRIPTION_INTERVAL_MS, schedule = setInterval, cancel = clearInterval } = {},
+) => {
+ let stopped = false;
+ let running = false;
+ const tick = () => {
+ if (stopped || running) return;
+ running = true;
+ Promise.resolve()
+ .then(() => runner.pass())
+ .catch(() => undefined)
+ .finally(() => {
+ running = false;
+ });
+ };
+ const timer = schedule(tick, intervalMs);
+ timer?.unref?.();
+ tick();
+ return () => {
+ stopped = true;
+ cancel(timer);
+ };
+};
diff --git a/apps/desktop/src/main/speech-transcription.test.mjs b/apps/desktop/src/main/speech-transcription.test.mjs
new file mode 100644
index 00000000..e8ac22ae
--- /dev/null
+++ b/apps/desktop/src/main/speech-transcription.test.mjs
@@ -0,0 +1,454 @@
+import { expect, test } from "bun:test";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { VIDEO_COOKIE_BROWSERS } from "../../../../packages/shared/src/video-cookie-browser.ts";
+import {
+ applyTranscript,
+ bestAudioArguments,
+ buildTranscriptMarkdown,
+ COOKIE_BROWSERS,
+ DEFAULT_COOKIE_BROWSER,
+ readCookieBrowserPreference,
+ writeCookieBrowserPreference,
+ createSpeechTranscriptionRunner,
+ isPublicVideoSourceUrl,
+ runSpeechTranscriptionPass,
+ startSpeechTranscription,
+ transcriptionRequest,
+} from "./speech-transcription.mjs";
+
+const session = { baseUrl: "http://127.0.0.1:8787", token: "desktop-session" };
+const apiKey = "asr-test-key";
+const sourceUrl = "https://www.youtube.com/watch?v=abcdefghijk";
+const placeholder = "这一集没有可用字幕";
+
+const waitingJob = {
+ memoId: "memo_abc",
+ platform: "youtube",
+ videoId: "abcdefghijk",
+ sourceUrl,
+ durationSeconds: 12,
+ placeholderText: placeholder,
+ transcriptLabel: "字幕实录",
+ contentHash: "hash-1",
+ status: "pending",
+ claimedAt: null,
+};
+
+const memo = {
+ id: "memo_abc",
+ contentMarkdown: `# Title\n\n${placeholder}\n`,
+ contentHash: "hash-1",
+ revision: 0,
+};
+
+const jsonResponse = (body, status = 200) => new Response(JSON.stringify(body), {
+ status,
+ headers: { "content-type": "application/json" },
+});
+
+const installFetch = (state) => async (url, init = {}) => {
+ const path = new URL(url).pathname;
+ const body = init.body ? JSON.parse(init.body) : null;
+ state.calls.push({
+ path,
+ method: init.method ?? "GET",
+ body,
+ authorization: init.headers?.Authorization ?? init.headers?.authorization ?? "",
+ });
+ if (path === "/api/v1/ai/transcription-settings" && (init.method ?? "GET") === "GET") {
+ return jsonResponse({ enabled: state.enabled });
+ }
+ if (path === "/api/v1/video-transcript-jobs" && (init.method ?? "GET") === "GET") {
+ return jsonResponse({ jobs: state.jobs });
+ }
+ if (path.endsWith("/claim")) {
+ if (!state.jobs.length) return jsonResponse({ error: { code: "video_transcript_not_claimed" } }, 409);
+ const job = { ...state.jobs[0], status: "transcribing", claimedAt: "2026-10-06T00:00:00.000Z" };
+ state.jobs = [];
+ return jsonResponse({ job });
+ }
+ if (path.endsWith("/finish")) {
+ state.finished = body;
+ return jsonResponse({ ok: true });
+ }
+ if (path === "/api/v1/ai/transcription-settings/prepare") {
+ state.prepared = true;
+ return jsonResponse({
+ enabled: true,
+ provider: state.speechProvider ?? "openai-compatible",
+ baseUrl: "https://api.example.test/v1",
+ modelId: "whisper-1",
+ apiKey,
+ });
+ }
+ if (path === "/api/v1/memos/memo_abc" && (init.method ?? "GET") === "GET") {
+ return jsonResponse({ memo: state.memo });
+ }
+ if (path === "/api/v1/memos/memo_abc" && init.method === "PATCH") {
+ state.patched = body;
+ return jsonResponse({ memo: { ...state.memo, revision: 1 } }, state.patchStatus ?? 200);
+ }
+ return jsonResponse({ error: { code: "unexpected" } }, 500);
+};
+
+const baseState = (overrides = {}) => ({
+ enabled: true,
+ jobs: [{ ...waitingJob }],
+ memo: { ...memo },
+ calls: [],
+ finished: null,
+ patched: null,
+ prepared: false,
+ ...overrides,
+});
+
+const tempDir = async () => {
+ const directory = join(tmpdir(), `edgeever-transcript-${crypto.randomUUID()}`);
+ await mkdir(directory, { recursive: true });
+ return directory;
+};
+
+const readyTool = { state: "ready", path: "/usr/local/bin/yt-dlp" };
+
+test("downloads bestaudio with the chosen browser cookies and without extraction or a shell", () => {
+ const args = bestAudioArguments(sourceUrl, "/tmp/memo_abc.%(ext)s");
+ expect(args).toContain("-f");
+ expect(args).toContain("bestaudio");
+ expect(args).toContain("--max-filesize");
+ expect(args).toContain("--cookies-from-browser");
+ expect(args[args.indexOf("--cookies-from-browser") + 1]).toBe("chrome");
+ expect(args).toContain("--");
+ expect(args.at(-1)).toBe(sourceUrl);
+ expect(args).not.toContain("-x");
+ expect(args).not.toContain("--audio-format");
+ const firefox = bestAudioArguments(sourceUrl, "/tmp/memo_abc.%(ext)s", "Firefox");
+ expect(firefox[firefox.indexOf("--cookies-from-browser") + 1]).toBe("firefox");
+ const off = bestAudioArguments(sourceUrl, "/tmp/memo_abc.%(ext)s", "none");
+ expect(off.join(" ")).not.toContain("cookie");
+ const rejected = bestAudioArguments(sourceUrl, "/tmp/memo_abc.%(ext)s", "chrome:Profile --proxy");
+ expect(rejected[rejected.indexOf("--cookies-from-browser") + 1]).toBe("chrome");
+ expect(COOKIE_BROWSERS).toEqual([...VIDEO_COOKIE_BROWSERS]);
+ expect(DEFAULT_COOKIE_BROWSER).toBe("chrome");
+ expect(isPublicVideoSourceUrl(sourceUrl)).toBe(true);
+ expect(isPublicVideoSourceUrl("https://www.youtube.com/shorts/abcdefghijk")).toBe(true);
+ expect(isPublicVideoSourceUrl("https://www.bilibili.com/video/BV1xx411c7xx?p=2")).toBe(true);
+ expect(isPublicVideoSourceUrl("http://www.youtube.com/watch?v=abcdefghijk")).toBe(false);
+ expect(isPublicVideoSourceUrl("https://user:[email protected]/watch?v=abcdefghijk")).toBe(false);
+ expect(isPublicVideoSourceUrl("https://evil.youtube.com.example/watch?v=abcdefghijk")).toBe(false);
+});
+
+test("stores only an allowed browser name and defaults to chrome", async () => {
+ const directory = await tempDir();
+ const filePath = join(directory, "video-cookie-browser.json");
+ expect(await readCookieBrowserPreference(filePath)).toBe("chrome");
+ expect(await writeCookieBrowserPreference(filePath, "Edge")).toEqual({ browser: "edge" });
+ expect(await readCookieBrowserPreference(filePath)).toBe("edge");
+ expect(await readFile(filePath, "utf8")).toBe('{"browser":"edge"}\n');
+ expect(await writeCookieBrowserPreference(filePath, "none")).toEqual({ browser: "none" });
+ expect(await readCookieBrowserPreference(filePath)).toBe("none");
+ await expect(writeCookieBrowserPreference(filePath, "chrome:Default")).rejects.toThrow("unsupported_browser");
+ expect(await readCookieBrowserPreference(filePath)).toBe("none");
+ await writeFile(filePath, "{\"browser\":\"not-a-browser\"}\n");
+ expect(await readCookieBrowserPreference(filePath)).toBe("chrome");
+ await rm(directory, { recursive: true, force: true });
+});
+
+test("writes timestamped lines when segments exist and plain text when they do not", () => {
+ const timed = buildTranscriptMarkdown({
+ label: "字幕实录",
+ text: "ignored when cues exist",
+ cues: [{ start: 1.2, end: 3, text: "hello & there" }],
+ sourceUrl,
+ platform: "youtube",
+ });
+ expect(timed).toContain("<summary>字幕实录</summary>");
+ expect(timed).toContain("[00:01](https://www.youtube.com/watch?v=abcdefghijk&t=1s)");
+ expect(timed).toContain("hello &amp; there");
+ const plain = buildTranscriptMarkdown({
+ label: "字幕实录",
+ text: "only words",
+ cues: [],
+ sourceUrl,
+ platform: "youtube",
+ });
+ expect(plain).toContain("only words");
+ expect(plain).not.toContain("](http");
+ const replaced = applyTranscript(`# Title\n\n${placeholder}\n`, placeholder, timed);
+ expect(replaced).not.toContain(placeholder);
+ expect(replaced).toContain("<details>");
+ const marker = "<!-- edgeever-video-v1:abc -->";
+ const kept = applyTranscript(`# Title\n\n${placeholder}\n\n${marker}\n`, placeholder, "字幕");
+ expect(kept.trim().endsWith(marker)).toBe(true);
+ expect(kept.indexOf("字幕")).toBeLessThan(kept.indexOf(marker));
+});
+
+test("asks the OpenAI-compatible client for segment timestamps and does not retry", () => {
+ const audio = new Uint8Array([1, 2, 3]);
+ const signal = AbortSignal.timeout(1000);
+ expect(transcriptionRequest({
+ baseUrl: "https://api.example.test/v1",
+ apiKey,
+ modelId: "whisper-1",
+ audio,
+ abortSignal: signal,
+ })).toEqual({
+ provider: { baseURL: "https://api.example.test/v1", apiKey },
+ modelId: "whisper-1",
+ audio,
+ maxRetries: 0,
+ abortSignal: signal,
+ providerOptions: { openai: { timestampGranularities: ["segment"] } },
+ });
+});
+
+test("skips the job when speech recognition is off or yt-dlp is not ready", async () => {
+ const disabled = baseState({ enabled: false });
+ const disabledResult = await runSpeechTranscriptionPass({
+ getSession: () => session,
+ ytDlpStatus: () => readyTool,
+ fetchImpl: installFetch(disabled),
+ audioDirectory: async () => "/tmp/unused",
+ });
+ expect(disabledResult).toEqual({ outcome: "skipped", reason: "disabled" });
+ expect(disabled.calls.map((call) => call.path)).toEqual(["/api/v1/ai/transcription-settings"]);
+
+ const waiting = baseState();
+ const toolResult = await runSpeechTranscriptionPass({
+ getSession: () => session,
+ ytDlpStatus: () => ({ state: "downloading", path: null }),
+ fetchImpl: installFetch(waiting),
+ audioDirectory: async () => "/tmp/unused",
+ });
+ expect(toolResult).toEqual({ outcome: "skipped", reason: "yt_dlp" });
+ expect(waiting.calls.map((call) => call.path)).toEqual(["/api/v1/ai/transcription-settings"]);
+ expect(waiting.prepared).toBe(false);
+});
+
+test("does not download when the note changed or the video is too long", async () => {
+ const directory = await tempDir();
+ const changed = baseState({ memo: { ...memo, contentHash: "edited" } });
+ let spawned = 0;
+ const changedResult = await runSpeechTranscriptionPass({
+ getSession: () => session,
+ ytDlpStatus: () => readyTool,
+ fetchImpl: installFetch(changed),
+ audioDirectory: async () => directory,
+ execFileImpl: () => { spawned += 1; },
+ transcribe: async () => { throw new Error("should not transcribe"); },
+ });
+ expect(changedResult.reason).toBe("note_changed");
+ expect(spawned).toBe(0);
+ expect(changed.prepared).toBe(false);
+ expect(changed.finished).toMatchObject({ status: "failed", errorCode: "note_changed" });
+
+ const long = baseState({ jobs: [{ ...waitingJob, durationSeconds: 30 * 60 + 1 }] });
+ const longResult = await runSpeechTranscriptionPass({
+ getSession: () => session,
+ ytDlpStatus: () => readyTool,
+ fetchImpl: installFetch(long),
+ audioDirectory: async () => directory,
+ execFileImpl: () => { spawned += 1; },
+ });
+ expect(longResult.reason).toBe("duration_limit");
+ expect(spawned).toBe(0);
+ expect(long.prepared).toBe(false);
+ await rm(directory, { recursive: true, force: true });
+});
+
+test("does not call the OpenAI transcriber for another compatibility standard", async () => {
+ const state = baseState({ speechProvider: "future-vendor" });
+ let spawned = 0;
+ let transcribed = false;
+ const result = await runSpeechTranscriptionPass({
+ getSession: () => session,
+ ytDlpStatus: () => readyTool,
+ fetchImpl: installFetch(state),
+ audioDirectory: async () => "/tmp/unused",
+ execFileImpl: () => { spawned += 1; },
+ transcribe: async () => { transcribed = true; },
+ });
+ expect(result.reason).toBe("disabled");
+ expect(spawned).toBe(0);
+ expect(transcribed).toBe(false);
+ expect(state.prepared).toBe(true);
+ expect(state.finished).toMatchObject({ status: "failed", errorCode: "disabled" });
+});
+
+test("transcribes the local file and writes the same note", async () => {
+ const directory = await tempDir();
+ const state = baseState();
+ let seenAudio = null;
+ const providerCalls = [];
+ const result = await runSpeechTranscriptionPass({
+ getSession: () => session,
+ ytDlpStatus: () => readyTool,
+ cookieBrowser: async () => "safari",
+ fetchImpl: installFetch(state),
+ audioDirectory: async () => directory,
+ maxAudioBytes: 32,
+ execFileImpl: (_binary, args, options, callback) => {
+ expect(options.shell).toBeUndefined();
+ expect(args).toContain("bestaudio");
+ expect(args).not.toContain("-x");
+ expect(args[args.indexOf("--cookies-from-browser") + 1]).toBe("safari");
+ return writeFile(join(directory, "memo_abc.m4a"), Uint8Array.from([9, 8, 7, 6])).then(() => callback(null));
+ },
+ createProvider: (settings) => {
+ providerCalls.push(settings);
+ return { transcription: (modelId) => ({ modelId }) };
+ },
+ transcribe: async ({ model, audio, maxRetries, providerOptions }) => {
+ seenAudio = audio;
+ expect(model).toEqual({ modelId: "whisper-1" });
+ expect(maxRetries).toBe(0);
+ expect(providerOptions).toEqual({ openai: { timestampGranularities: ["segment"] } });
+ return {
+ text: "hello there",
+ segments: [{ text: " hello there", startSecond: 1.4, endSecond: 2 }],
+ };
+ },
+ });
+ expect(result).toEqual({ outcome: "ready", memoId: "memo_abc" });
+ expect(providerCalls).toEqual([{ baseURL: "https://api.example.test/v1", apiKey }]);
+ expect(Array.from(seenAudio)).toEqual([9, 8, 7, 6]);
+ expect(state.patched.contentMarkdown).toContain("[00:01](https://www.youtube.com/watch?v=abcdefghijk&t=1s)");
+ expect(state.patched.contentMarkdown).not.toContain(placeholder);
+ expect(state.patched.expectedRevision).toBe(0);
+ expect(state.patched.expectedContentHash).toBe("hash-1");
+ expect(state.finished).toEqual({
+ status: "ready",
+ errorCode: null,
+ claimedAt: "2026-10-06T00:00:00.000Z",
+ });
+ expect(JSON.stringify(state.finished)).not.toContain(apiKey);
+ expect(state.calls.every((call) => call.authorization === "Bearer desktop-session")).toBe(true);
+ expect(state.calls.some((call) => call.path.includes("audio/transcriptions"))).toBe(false);
+ const names = await readFile(join(directory, "memo_abc.m4a")).then(() => ["left"], () => []);
+ expect(names).toEqual([]);
+ await rm(directory, { recursive: true, force: true });
+});
+
+test("leaves the note in place when recognition fails and does not store the token", async () => {
+ const directory = await tempDir();
+ const state = baseState();
+ const result = await runSpeechTranscriptionPass({
+ getSession: () => session,
+ ytDlpStatus: () => readyTool,
+ fetchImpl: installFetch(state),
+ audioDirectory: async () => directory,
+ execFileImpl: (_binary, _args, _options, callback) => (
+ writeFile(join(directory, "memo_abc.webm"), Uint8Array.from([1])).then(() => callback(null))
+ ),
+ createProvider: () => ({ transcription: () => ({}) }),
+ transcribe: async () => {
+ throw new Error(`provider rejected ${apiKey}`);
+ },
+ });
+ expect(result.reason).toBe("transcribe_failed");
+ expect(state.patched).toBeNull();
+ expect(state.finished).toMatchObject({ status: "failed", errorCode: "transcribe_failed" });
+ expect(JSON.stringify(state.finished)).not.toContain(apiKey);
+ await expect(readFile(join(directory, "memo_abc.webm"))).rejects.toThrow();
+ await rm(directory, { recursive: true, force: true });
+});
+
+test("refuses an oversized download before calling the recognizer", async () => {
+ const directory = await tempDir();
+ const state = baseState();
+ let transcribed = false;
+ const result = await runSpeechTranscriptionPass({
+ getSession: () => session,
+ ytDlpStatus: () => readyTool,
+ fetchImpl: installFetch(state),
+ audioDirectory: async () => directory,
+ maxAudioBytes: 3,
+ execFileImpl: (_binary, _args, _options, callback) => (
+ writeFile(join(directory, "memo_abc.m4a"), Uint8Array.from([1, 2, 3, 4])).then(() => callback(null))
+ ),
+ transcribe: async () => { transcribed = true; },
+ });
+ expect(result.reason).toBe("audio_too_large");
+ expect(transcribed).toBe(false);
+ expect(state.patched).toBeNull();
+ await rm(directory, { recursive: true, force: true });
+});
+
+test("saves text without timestamps when the recognizer returns no segments", async () => {
+ const directory = await tempDir();
+ const state = baseState();
+ await runSpeechTranscriptionPass({
+ getSession: () => session,
+ ytDlpStatus: () => readyTool,
+ fetchImpl: installFetch(state),
+ audioDirectory: async () => directory,
+ execFileImpl: (_binary, _args, _options, callback) => (
+ writeFile(join(directory, "memo_abc.m4a"), Uint8Array.from([1])).then(() => callback(null))
+ ),
+ createProvider: () => ({ transcription: () => ({}) }),
+ transcribe: async () => ({ text: "plain words", segments: [] }),
+ });
+ expect(state.patched.contentMarkdown).toContain("plain words");
+ expect(state.patched.contentMarkdown).not.toContain("](http");
+ expect(state.finished.status).toBe("ready");
+ await rm(directory, { recursive: true, force: true });
+});
+
+test("does not start a second pass while one is still running, and the app does not await it", async () => {
+ let release = () => {};
+ const gate = new Promise((resolve) => { release = resolve; });
+ let calls = 0;
+ let scheduled = null;
+ const stop = startSpeechTranscription({
+ pass: () => {
+ calls += 1;
+ return gate;
+ },
+ }, {
+ intervalMs: 20,
+ schedule: (callback) => {
+ scheduled = callback;
+ return 4;
+ },
+ cancel: () => { scheduled = null; },
+ });
+ await Promise.resolve();
+ expect(calls).toBe(1);
+ scheduled();
+ await Promise.resolve();
+ expect(calls).toBe(1);
+ release();
+ await gate;
+ await Promise.resolve();
+ await Promise.resolve();
+ scheduled();
+ await Promise.resolve();
+ expect(calls).toBe(2);
+ stop();
+ expect(scheduled).toBeNull();
+
+ const main = await readFile(new URL("./index.mjs", import.meta.url), "utf8");
+ const windowAt = main.indexOf("await createWindow()");
+ const startAt = main.indexOf("startSpeechTranscription(");
+ expect(startAt).toBeGreaterThan(windowAt);
+ expect(main).not.toContain("await startSpeechTranscription");
+ expect(main).not.toContain("await runSpeechTranscriptionPass");
+ expect(main).toContain("stopSpeechTranscription?.()");
+});
+
+test("the installed provider can build a transcription model without a network call", async () => {
+ const { createOpenAI } = await import("@ai-sdk/openai");
+ const provider = createOpenAI({ baseURL: "https://example.test/v1", apiKey: "not-a-real-token" });
+ expect(typeof provider.transcription).toBe("function");
+ expect(provider.transcription("whisper-1")).toBeTruthy();
+});
+
+test("the runner factory passes the session through", async () => {
+ const runner = createSpeechTranscriptionRunner({
+ getSession: () => ({}),
+ ytDlpStatus: () => readyTool,
+ audioDirectory: async () => "/tmp/unused",
+ });
+ await expect(runner.pass()).resolves.toEqual({ outcome: "skipped", reason: "signed_out" });
+});
diff --git a/apps/desktop/src/main/yt-dlp-tool.mjs b/apps/desktop/src/main/yt-dlp-tool.mjs
new file mode 100644
index 00000000..8de4bd6c
--- /dev/null
+++ b/apps/desktop/src/main/yt-dlp-tool.mjs
@@ -0,0 +1,297 @@
+import { createHash, timingSafeEqual } from "node:crypto";
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { chmod, mkdir, open, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { Readable } from "node:stream";
+import { restrictDirectory, restrictFile } from "./file-permissions.mjs";
+
+const RELEASES_LATEST_URL = "https://github.com/yt-dlp/yt-dlp/releases/latest";
+const USER_AGENT = "EdgeEverDesktop yt-dlp-fetch";
+const MIN_BINARY_BYTES = 100_000;
+const MAX_BINARY_BYTES = 80 * 1024 * 1024;
+const MAX_SUMS_BYTES = 1024 * 1024;
+
+const toolError = (code, httpStatus = null) => {
+ const error = new Error(code);
+ error.code = code;
+ error.httpStatus = httpStatus;
+ return error;
+};
+
+// Official standalone builds. The 2.9 MB `yt-dlp` zipapp still needs a system Python.
+export const ytDlpAssetName = (platform, arch) => {
+ if (platform === "darwin") return "yt-dlp_macos";
+ if (platform === "win32" && arch === "arm64") return "yt-dlp_arm64.exe";
+ if (platform === "win32") return "yt-dlp.exe";
+ if (platform === "linux" && arch === "arm64") return "yt-dlp_linux_aarch64";
+ if (platform === "linux" && arch === "x64") return "yt-dlp_linux";
+ return null;
+};
+
+export const ytDlpExecutableName = (platform) => (platform === "win32" ? "yt-dlp.exe" : "yt-dlp");
+
+export const parseSha256Sums = (text) => {
+ const sums = new Map();
+ for (const line of String(text).split(/\r?\n/)) {
+ const match = /^([a-fA-F0-9]{64})\s+\*?(\S+)\s*$/.exec(line.trim());
+ if (match) sums.set(match[2], match[1].toLowerCase());
+ }
+ return sums;
+};
+
+export const releaseTagFromUrl = (url) => {
+ const match = /\/releases\/(?:tag|download)\/([^/?#]+)/.exec(String(url));
+ if (!match) return null;
+ try {
+ return decodeURIComponent(match[1]);
+ } catch {
+ return match[1];
+ }
+};
+
+const hashesMatch = (actual, expected) => {
+ const left = Buffer.from(actual, "hex");
+ const right = Buffer.from(expected, "hex");
+ return left.length === right.length && left.length > 0 && timingSafeEqual(left, right);
+};
+
+const readInstalledVersion = async (binaryPath) => {
+ const stdout = await new Promise((resolve, reject) => {
+ execFile(binaryPath, ["--version"], { timeout: 15_000, windowsHide: true }, (error, output) => {
+ if (error) reject(error);
+ else resolve(output);
+ });
+ });
+ return String(stdout).trim().split(/\s+/)[0] ?? "";
+};
+
+const fetchResponse = async (fetchImpl, url, timeoutMs) => {
+ let response;
+ try {
+ response = await fetchImpl(url, {
+ redirect: "follow",
+ headers: { "user-agent": USER_AGENT },
+ signal: AbortSignal.timeout(timeoutMs),
+ });
+ } catch (error) {
+ throw toolError(error?.name === "TimeoutError" ? "timeout" : "network");
+ }
+ if (!response.ok) throw toolError("http", response.status);
+ return response;
+};
+
+const fetchBytes = async (fetchImpl, url, { maxBytes, timeoutMs }) => {
+ const response = await fetchResponse(fetchImpl, url, timeoutMs);
+ const bytes = Buffer.from(await response.arrayBuffer());
+ if (bytes.byteLength > maxBytes) throw toolError("unexpected_size");
+ return bytes;
+};
+
+// Stream to disk and hash one chunk at a time. Buffering the whole binary and
+// hashing it in one call stalls the Electron main process and freezes the window.
+const downloadHashed = async (fetchImpl, url, destination, { maxBytes, minBytes, timeoutMs }) => {
+ const response = await fetchResponse(fetchImpl, url, timeoutMs);
+ const hash = createHash("sha256");
+ let size = 0;
+ const consume = (chunk) => {
+ const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+ size += bytes.byteLength;
+ if (size > maxBytes) throw toolError("unexpected_size");
+ hash.update(bytes);
+ return bytes;
+ };
+ const writeAll = async (handle, bytes) => {
+ let offset = 0;
+ while (offset < bytes.byteLength) {
+ const { bytesWritten } = await handle.write(bytes, offset, bytes.byteLength - offset);
+ if (!bytesWritten) throw toolError("storage");
+ offset += bytesWritten;
+ }
+ };
+ const webBody = response.body;
+ if (webBody && typeof webBody.getReader === "function") {
+ const handle = await open(destination, "w", 0o600);
+ try {
+ for await (const chunk of Readable.fromWeb(webBody)) {
+ await writeAll(handle, consume(chunk));
+ }
+ } finally {
+ await handle.close();
+ }
+ } else {
+ await writeFile(destination, consume(Buffer.from(await response.arrayBuffer())));
+ }
+ if (size < minBytes) throw toolError("unexpected_size");
+ return hash.digest("hex");
+};
+
+const latestReleaseTag = async (fetchImpl) => {
+ const response = await fetchResponse(fetchImpl, RELEASES_LATEST_URL, 20_000);
+ const page = await response.text();
+ if (page.length > MAX_SUMS_BYTES) throw toolError("unexpected_size");
+ const fromUrl = releaseTagFromUrl(response.url || "");
+ const fromPage = /\/releases\/tag\/(\d{4}\.\d{2}\.\d{2}(?:\.\d+)?)/.exec(page)?.[1] ?? null;
+ const tag = fromUrl && /^\d{4}\.\d{2}\.\d{2}/.test(fromUrl) ? fromUrl : fromPage;
+ if (!tag || !/^\d{4}\.\d{2}\.\d{2}(?:\.\d+)?$/.test(tag)) throw toolError("unrecognized_release");
+ return tag;
+};
+
+export const createYtDlpManager = ({
+ directory,
+ platform,
+ arch,
+ fetch: fetchImpl = globalThis.fetch,
+ readVersion = readInstalledVersion,
+ onDiagnostic = () => {},
+}) => {
+ const asset = ytDlpAssetName(platform, arch);
+ const binaryPath = join(directory, ytDlpExecutableName(platform));
+ const partialPath = `${binaryPath}.partial`;
+ const statePath = join(directory, "yt-dlp.json");
+ let current = {
+ state: asset ? "idle" : "failed",
+ version: null,
+ path: binaryPath,
+ errorCode: asset ? null : "unsupported_platform",
+ httpStatus: null,
+ };
+ let pending = null;
+
+ const publish = (next) => {
+ current = next;
+ };
+
+ const readState = async () => {
+ if (!existsSync(binaryPath)) return null;
+ try {
+ const parsed = JSON.parse(await readFile(statePath, "utf8"));
+ const version = typeof parsed?.version === "string" ? parsed.version : "";
+ return version ? { version } : null;
+ } catch {
+ return null;
+ }
+ };
+
+ const install = async (tag) => {
+ const releaseBase = `https://github.com/yt-dlp/yt-dlp/releases/download/${encodeURIComponent(tag)}`;
+ const sums = await fetchBytes(fetchImpl, `${releaseBase}/SHA2-256SUMS`, {
+ maxBytes: MAX_SUMS_BYTES,
+ timeoutMs: 20_000,
+ });
+ const expected = parseSha256Sums(sums.toString("utf8")).get(asset);
+ if (!expected) throw toolError("checksum_missing");
+ await mkdir(directory, { recursive: true });
+ await restrictDirectory(directory);
+ const actual = await downloadHashed(fetchImpl, `${releaseBase}/${asset}`, partialPath, {
+ maxBytes: MAX_BINARY_BYTES,
+ minBytes: MIN_BINARY_BYTES,
+ timeoutMs: 120_000,
+ });
+ if (!hashesMatch(actual, expected)) throw toolError("checksum_mismatch");
+ await chmod(partialPath, platform === "win32" ? 0o644 : 0o755);
+ let reported = "";
+ try {
+ reported = await readVersion(partialPath);
+ } catch {
+ throw toolError("not_executable");
+ }
+ if (reported !== tag) throw toolError("version_mismatch");
+ try {
+ await rename(partialPath, binaryPath);
+ } catch {
+ await unlink(binaryPath).catch(() => {});
+ await rename(partialPath, binaryPath);
+ }
+ await writeFile(statePath, `${JSON.stringify({
+ version: tag,
+ sha256: actual,
+ asset,
+ installedAt: new Date().toISOString(),
+ })}\n`);
+ await restrictFile(statePath);
+ };
+
+ const run = async () => {
+ if (!asset) return current;
+ const installed = await readState();
+ publish({
+ state: installed ? "ready" : "downloading",
+ version: installed?.version ?? null,
+ path: binaryPath,
+ errorCode: null,
+ httpStatus: null,
+ });
+ try {
+ const tag = await latestReleaseTag(fetchImpl);
+ if (installed?.version === tag) return current;
+ publish({
+ state: "downloading",
+ version: installed?.version ?? null,
+ path: binaryPath,
+ errorCode: null,
+ httpStatus: null,
+ });
+ await install(tag);
+ publish({
+ state: "ready",
+ version: tag,
+ path: binaryPath,
+ errorCode: null,
+ httpStatus: null,
+ });
+ onDiagnostic(installed ? "yt-dlp.updated" : "yt-dlp.installed", { version: tag });
+ } catch (error) {
+ const known = new Set([
+ "checksum_mismatch",
+ "checksum_missing",
+ "version_mismatch",
+ "not_executable",
+ "timeout",
+ "network",
+ "http",
+ "unexpected_size",
+ "unrecognized_release",
+ "storage",
+ ]);
+ const errorCode = known.has(error?.code)
+ ? error.code
+ : ["ENOENT", "EACCES", "EPERM", "ENOSPC", "EROFS"].includes(error?.code)
+ ? "storage"
+ : "network";
+ const httpStatus = Number.isInteger(error?.httpStatus) ? error.httpStatus : null;
+ publish({
+ state: installed ? "ready" : "failed",
+ version: installed?.version ?? null,
+ path: binaryPath,
+ errorCode,
+ httpStatus,
+ });
+ onDiagnostic("yt-dlp.failed", { version: installed?.version ?? null, errorCode, httpStatus });
+ } finally {
+ await unlink(partialPath).catch(() => {});
+ }
+ return current;
+ };
+
+ return {
+ status: () => ({ ...current }),
+ ensure: () => {
+ if (pending) return pending;
+ pending = run().finally(() => {
+ pending = null;
+ });
+ return pending;
+ },
+ };
+};
+
+export const startYtDlpMaintenance = (manager, { intervalMs, schedule = setInterval, cancel = clearInterval } = {}) => {
+ void manager.ensure();
+ if (!intervalMs) return () => {};
+ const timer = schedule(() => {
+ void manager.ensure();
+ }, intervalMs);
+ timer.unref?.();
+ return () => cancel(timer);
+};
diff --git a/apps/desktop/src/main/yt-dlp-tool.test.mjs b/apps/desktop/src/main/yt-dlp-tool.test.mjs
new file mode 100644
index 00000000..948a97b1
--- /dev/null
+++ b/apps/desktop/src/main/yt-dlp-tool.test.mjs
@@ -0,0 +1,217 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { mkdtemp, readFile, rm, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, test } from "bun:test";
+import {
+ createYtDlpManager,
+ parseSha256Sums,
+ releaseTagFromUrl,
+ startYtDlpMaintenance,
+ ytDlpAssetName,
+ ytDlpExecutableName,
+} from "./yt-dlp-tool.mjs";
+
+const sha256 = (bytes) => createHash("sha256").update(bytes).digest("hex");
+
+describe("yt-dlp release selection", () => {
+ test("picks the standalone binary for each desktop target", () => {
+ expect(ytDlpAssetName("darwin", "arm64")).toBe("yt-dlp_macos");
+ expect(ytDlpAssetName("darwin", "x64")).toBe("yt-dlp_macos");
+ expect(ytDlpAssetName("win32", "x64")).toBe("yt-dlp.exe");
+ expect(ytDlpAssetName("win32", "arm64")).toBe("yt-dlp_arm64.exe");
+ expect(ytDlpAssetName("linux", "x64")).toBe("yt-dlp_linux");
+ expect(ytDlpAssetName("linux", "arm64")).toBe("yt-dlp_linux_aarch64");
+ expect(ytDlpAssetName("freebsd", "x64")).toBeNull();
+ expect(ytDlpExecutableName("win32")).toBe("yt-dlp.exe");
+ expect(ytDlpExecutableName("darwin")).toBe("yt-dlp");
+ });
+
+ test("reads GNU checksum lines and release tags", () => {
+ const sums = parseSha256Sums("abc\n0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef yt-dlp_macos\n");
+ expect(sums.get("yt-dlp_macos")).toBe("0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef");
+ expect(releaseTagFromUrl("https://github.com/yt-dlp/yt-dlp/releases/tag/2026.08.19")).toBe("2026.08.19");
+ expect(releaseTagFromUrl("https://github.com/yt-dlp/yt-dlp/releases/latest")).toBeNull();
+ });
+});
+
+const response = ({ url, status = 200, body = "", stream = false }) => {
+ const payload = Buffer.from(body);
+ const result = {
+ ok: status >= 200 && status < 300,
+ status,
+ url,
+ text: async () => (typeof body === "string" ? body : payload.toString("utf8")),
+ arrayBuffer: async () => Uint8Array.from(payload).buffer,
+ };
+ if (stream) {
+ result.body = new ReadableStream({
+ start(controller) {
+ const chunk = 32_768;
+ for (let offset = 0; offset < payload.byteLength; offset += chunk) {
+ controller.enqueue(payload.subarray(offset, offset + chunk));
+ }
+ controller.close();
+ },
+ });
+ }
+ return result;
+};
+
+const fakeRelease = ({ tag, asset, body, checksum, stream = false }) => {
+ const calls = [];
+ const fetchImpl = async (url) => {
+ calls.push(url);
+ if (url.endsWith("/releases/latest")) {
+ return response({
+ url: `https://github.com/yt-dlp/yt-dlp/releases/tag/${tag}`,
+ body: `<a href="/releases/tag/${tag}">`,
+ });
+ }
+ if (url.endsWith("/SHA2-256SUMS")) {
+ return response({ url, body: `${checksum ?? sha256(body)} ${asset}\n` });
+ }
+ if (url.endsWith(`/${asset}`)) return response({ url, body, stream });
+ return response({ url, status: 404, body: "" });
+ };
+ return { calls, fetchImpl };
+};
+
+describe("yt-dlp install and update", () => {
+ test("downloads a missing binary, skips the same version, and replaces a newer release", async () => {
+ const directory = await mkdtemp(join(tmpdir(), "edgeever-yt-dlp-"));
+ const diagnostics = [];
+ let tag = "2026.08.19";
+ let body = Buffer.alloc(120_000, 7);
+ const reported = () => tag;
+ const release = () => fakeRelease({ tag, asset: "yt-dlp_macos", body });
+ let current = release();
+ const manager = createYtDlpManager({
+ directory,
+ platform: "darwin",
+ arch: "arm64",
+ fetch: (url, init) => current.fetchImpl(url, init),
+ readVersion: async () => reported(),
+ onDiagnostic: (event, details) => diagnostics.push({ event, details }),
+ });
+
+ expect(manager.status()).toMatchObject({ state: "idle", version: null, errorCode: null });
+ await manager.ensure();
+ expect(manager.status()).toMatchObject({ state: "ready", version: "2026.08.19", errorCode: null });
+ expect(await readFile(join(directory, "yt-dlp"))).toEqual(body);
+ expect((await stat(join(directory, "yt-dlp"))).mode & 0o111).toBeGreaterThan(0);
+ expect(diagnostics.map((item) => item.event)).toEqual(["yt-dlp.installed"]);
+
+ const callsAfterInstall = current.calls.length;
+ current = release();
+ await manager.ensure();
+ expect(current.calls.some((url) => url.endsWith("/yt-dlp_macos"))).toBe(false);
+ expect(current.calls.length).toBeLessThan(callsAfterInstall);
+
+ tag = "2026.09.27";
+ body = Buffer.alloc(120_000, 9);
+ current = release();
+ await manager.ensure();
+ expect(manager.status()).toMatchObject({ state: "ready", version: "2026.09.27", errorCode: null });
+ expect(await readFile(join(directory, "yt-dlp"))).toEqual(body);
+ expect(diagnostics.at(-1)).toEqual({ event: "yt-dlp.updated", details: { version: "2026.09.27" } });
+ await rm(directory, { recursive: true, force: true });
+ });
+
+ test("keeps the installed binary when a newer download fails its checksum", async () => {
+ const directory = await mkdtemp(join(tmpdir(), "edgeever-yt-dlp-"));
+ let tag = "2026.08.19";
+ let body = Buffer.alloc(120_000, 3);
+ let checksum = null;
+ const manager = createYtDlpManager({
+ directory,
+ platform: "darwin",
+ arch: "arm64",
+ fetch: (url) => fakeRelease({ tag, asset: "yt-dlp_macos", body, checksum }).fetchImpl(url),
+ readVersion: async () => tag,
+ });
+ await manager.ensure();
+ const installed = await readFile(join(directory, "yt-dlp"));
+
+ tag = "2026.09.27";
+ body = Buffer.alloc(120_000, 4);
+ checksum = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+ await manager.ensure();
+ expect(manager.status()).toMatchObject({
+ state: "ready",
+ version: "2026.08.19",
+ errorCode: "checksum_mismatch",
+ });
+ expect(await readFile(join(directory, "yt-dlp"))).toEqual(installed);
+ await rm(directory, { recursive: true, force: true });
+ });
+
+ test("reports a failed first download without leaving a binary", async () => {
+ const directory = await mkdtemp(join(tmpdir(), "edgeever-yt-dlp-"));
+ const manager = createYtDlpManager({
+ directory,
+ platform: "darwin",
+ arch: "arm64",
+ fetch: async () => response({ url: "https://github.com/yt-dlp/yt-dlp/releases/latest", status: 503 }),
+ readVersion: async () => "2026.08.19",
+ });
+ await manager.ensure();
+ expect(manager.status()).toMatchObject({ state: "failed", version: null, errorCode: "http", httpStatus: 503 });
+ await expect(stat(join(directory, "yt-dlp"))).rejects.toThrow();
+ await rm(directory, { recursive: true, force: true });
+ });
+
+ test("writes a streamed release body in chunks", async () => {
+ const directory = await mkdtemp(join(tmpdir(), "edgeever-yt-dlp-"));
+ const body = Buffer.alloc(120_000, 11);
+ const manager = createYtDlpManager({
+ directory,
+ platform: "darwin",
+ arch: "arm64",
+ fetch: (url) => fakeRelease({ tag: "2026.08.19", asset: "yt-dlp_macos", body, stream: true }).fetchImpl(url),
+ readVersion: async () => "2026.08.19",
+ });
+ await manager.ensure();
+ expect(manager.status()).toMatchObject({ state: "ready", version: "2026.08.19", errorCode: null });
+ expect(await readFile(join(directory, "yt-dlp"))).toEqual(body);
+ await rm(directory, { recursive: true, force: true });
+ });
+
+ test("starts the download after the window is open and does not await it", () => {
+ const main = readFileSync(new URL("./index.mjs", import.meta.url), "utf8");
+ const windowAt = main.indexOf("await createWindow()");
+ const confirmAt = main.indexOf("await confirmMacInstallation()");
+ const startAt = main.indexOf("startYtDlpMaintenance(");
+ expect(windowAt).toBeGreaterThan(0);
+ expect(confirmAt).toBeGreaterThan(windowAt);
+ expect(startAt).toBeGreaterThan(confirmAt);
+ expect(main).toContain("ytDlpMaintenanceTimer = setTimeout");
+ expect(main).toContain("clearTimeout(ytDlpMaintenanceTimer)");
+ expect(main).not.toContain("await startYtDlpMaintenance");
+ expect(main).not.toContain("await ytDlpManager.ensure");
+ });
+
+ test("schedules a later check and can stop it", () => {
+ const calls = [];
+ let scheduled = null;
+ const stop = startYtDlpMaintenance({
+ ensure: () => {
+ calls.push("now");
+ return Promise.resolve();
+ },
+ }, {
+ intervalMs: 50,
+ schedule: (callback) => {
+ scheduled = callback;
+ return 7;
+ },
+ cancel: (timer) => {
+ calls.push(timer);
+ },
+ });
+ scheduled();
+ stop();
+ expect(calls).toEqual(["now", "now", 7]);
+ });
+});
diff --git a/apps/desktop/src/preload/index.cjs b/apps/desktop/src/preload/index.cjs
index 1bdd05c4..5b1f12cf 100644
--- a/apps/desktop/src/preload/index.cjs
+++ b/apps/desktop/src/preload/index.cjs
@@ -30,6 +30,9 @@ contextBridge.exposeInMainWorld("edgeeverDesktop", Object.freeze({
recoveredAfterAbnormalExit: ipcRenderer.sendSync("desktop:recovered-after-abnormal-exit-sync"),
sidecarStatus: () => ipcRenderer.invoke("desktop:sidecar-status"),
systemInfo: () => ipcRenderer.invoke("desktop:system-info"),
+ ytDlpStatus: () => ipcRenderer.invoke("desktop:yt-dlp-status"),
+ videoCookieBrowser: () => ipcRenderer.invoke("desktop:video-cookie-browser-get"),
+ setVideoCookieBrowser: (browser) => ipcRenderer.invoke("desktop:video-cookie-browser-set", browser),
setAccountScope: (accountId) => ipcRenderer.invoke("desktop:set-account-scope", accountId),
apiBaseUrl: ipcRenderer.sendSync("desktop:api-base-url-sync"),
setApiBaseUrl: (value) => ipcRenderer.invoke("desktop:set-api-base-url", value),
diff --git a/apps/extension/src/video/read-youtube-in-page.ts b/apps/extension/src/video/read-youtube-in-page.ts
index 3b530783..1ae3eb8d 100644
--- a/apps/extension/src/video/read-youtube-in-page.ts
+++ b/apps/extension/src/video/read-youtube-in-page.ts
@@ -18,17 +18,18 @@ export const isYouTubePageRead = (value: unknown): value is YouTubePageRead => {
return record.ok === true && "playerResponse" in record;
};
-const VIDEO_ID = /^[A-Za-z0-9_-]{11}$/;
-
// Runs in the page main world after the click. Chrome serializes this function
// alone, so the helpers stay nested and the subtitle URL is fetched here.
+// A module-level binding would be erased by that serialization and every watch
+// page would fail as "not read".
export async function readYouTubeVideoInPage(uiLanguage: string): Promise<YouTubePageRead> {
+ const videoIdPattern = /^[A-Za-z0-9_-]{11}$/;
const asRecord = (value: unknown): Record<string, unknown> | null =>
value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : null;
const videoIdOf = (response: unknown) => {
const id = asRecord(asRecord(response)?.videoDetails)?.videoId;
- return typeof id === "string" && VIDEO_ID.test(id) ? id : "";
+ return typeof id === "string" && videoIdPattern.test(id) ? id : "";
};
const videoIdFromLocation = (href: string) => {
@@ -38,13 +39,13 @@ export async function readYouTubeVideoInPage(uiLanguage: string): Promise<YouTub
if (host === "music.youtube.com" || host === "www.youtube-nocookie.com") return "";
if (host === "youtu.be" || host === "www.youtu.be") {
const id = url.pathname.split("/").filter(Boolean)[0] ?? "";
- return VIDEO_ID.test(id) ? id : "";
+ return videoIdPattern.test(id) ? id : "";
}
const parts = url.pathname.split("/").filter(Boolean);
- if (parts[0] === "shorts" && VIDEO_ID.test(parts[1] ?? "")) return parts[1] ?? "";
+ if (parts[0] === "shorts" && videoIdPattern.test(parts[1] ?? "")) return parts[1] ?? "";
if (parts[0] === "watch") {
const id = url.searchParams.get("v") ?? "";
- return VIDEO_ID.test(id) ? id : "";
+ return videoIdPattern.test(id) ? id : "";
}
return "";
} catch {
@@ -137,29 +138,28 @@ export async function readYouTubeVideoInPage(uiLanguage: string): Promise<YouTub
const thumbnailOf = async (response: unknown) => {
const thumbs = asRecord(asRecord(asRecord(response)?.videoDetails)?.thumbnail)?.thumbnails;
if (!Array.isArray(thumbs)) return undefined;
- let best = "";
- let width = -1;
- for (const item of thumbs) {
+ const ordered = thumbs.flatMap((item) => {
const thumb = asRecord(item);
const url = typeof thumb?.url === "string" ? thumb.url : "";
- const size = typeof thumb?.width === "number" ? thumb.width : 0;
- if (!url || size < width) continue;
- best = url;
- width = size;
- }
- if (!best) return undefined;
- try {
- const absolute = best.startsWith("//") ? `https:${best}` : best;
- const response = await fetch(absolute, { credentials: "include", signal: AbortSignal.timeout(8000) });
- if (!response.ok) return undefined;
- const mimeType = (response.headers.get("content-type") || "").split(";")[0]?.trim().toLowerCase() ?? "";
- if (!mimeType.startsWith("image/")) return undefined;
- const bytes = new Uint8Array(await response.arrayBuffer());
- if (!bytes.byteLength || bytes.byteLength > 2 * 1024 * 1024) return undefined;
- return { base64: bytesToBase64(bytes), mimeType: mimeType === "image/jpg" ? "image/jpeg" : mimeType };
- } catch {
- return undefined;
+ const width = typeof thumb?.width === "number" ? thumb.width : 0;
+ return url ? [{ url, width }] : [];
+ }).sort((left, right) => right.width - left.width);
+ // ytimg rejects a credentialed fetch. Try the next size when one URL fails.
+ for (const thumb of ordered) {
+ try {
+ const absolute = thumb.url.startsWith("//") ? `https:${thumb.url}` : thumb.url;
+ const image = await fetch(absolute, { credentials: "omit", signal: AbortSignal.timeout(8000) });
+ if (!image.ok) continue;
+ const mimeType = (image.headers.get("content-type") || "").split(";")[0]?.trim().toLowerCase() ?? "";
+ if (!mimeType.startsWith("image/")) continue;
+ const bytes = new Uint8Array(await image.arrayBuffer());
+ if (!bytes.byteLength || bytes.byteLength > 2 * 1024 * 1024) continue;
+ return { base64: bytesToBase64(bytes), mimeType: mimeType === "image/jpg" ? "image/jpeg" : mimeType };
+ } catch {
+ // The next candidate may still be readable.
+ }
}
+ return undefined;
};
const slim = (response: unknown) => {
diff --git a/apps/extension/src/video/video-note.ts b/apps/extension/src/video/video-note.ts
index 9c9e73c1..4078ccae 100644
--- a/apps/extension/src/video/video-note.ts
+++ b/apps/extension/src/video/video-note.ts
@@ -27,6 +27,35 @@ export type VideoNoteLabels = {
const COVER_PLACEHOLDER = "EDGEVERRESOURCEID";
+export type VideoTranscriptRequest = {
+ platform: "youtube" | "bilibili";
+ videoId: string;
+ sourceUrl: string;
+ durationSeconds: number;
+ placeholderText: string;
+ transcriptLabel: string;
+};
+
+export const videoNoteIdentity = (
+ capture: VideoCapture,
+ labels: VideoNoteLabels,
+): VideoTranscriptRequest => ({
+ platform: capture.platform,
+ videoId: capture.videoId,
+ sourceUrl: capture.sourceUrl,
+ durationSeconds: Math.max(0, Math.floor(capture.duration || 0)),
+ placeholderText: labels.noCaptions,
+ transcriptLabel: labels.transcript,
+});
+
+const videoNoteMarker = (identity: VideoTranscriptRequest) => {
+ const bytes = new TextEncoder().encode(JSON.stringify(identity));
+ let binary = "";
+ for (const byte of bytes) binary += String.fromCharCode(byte);
+ const encoded = btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/g, "");
+ return `<!-- edgeever-video-v1:${encoded} -->`;
+};
+
export const videoNoteTitle = (title: string, fallback: string) => {
const clean = title.replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim();
const value = clean || fallback;
@@ -121,6 +150,7 @@ export const buildVideoNote = (input: {
"",
);
}
+ lines.push(videoNoteMarker(videoNoteIdentity(input.capture, input.labels)));
return { title, markdown: lines.join("\n").replace(/\n{3,}/g, "\n\n").trim() + "\n" };
};
@@ -230,7 +260,13 @@ export const persistVideoNote = async (input: {
labels: VideoNoteLabels;
capturedOn: string;
attempt: OutlineAttempt | null;
- createMemo: (body: { notebookId: string; title: string; contentMarkdown: string; tags: string[] }) => Promise<unknown>;
+ createMemo: (body: {
+ notebookId: string;
+ title: string;
+ contentMarkdown: string;
+ tags: string[];
+ videoTranscript?: VideoTranscriptRequest;
+ }) => Promise<unknown>;
createWithImage?: (body: {
notebookId: string;
title: string;
@@ -239,9 +275,16 @@ export const persistVideoNote = async (input: {
filename: string;
mimeType: string;
bytes: Uint8Array;
+ videoTranscript?: VideoTranscriptRequest;
}) => Promise<unknown>;
}) => {
const withCover = Boolean(input.capture.thumbnail && input.createWithImage);
+ const noteFields = (title: string, contentMarkdown: string) => ({
+ notebookId: input.notebookId,
+ title,
+ contentMarkdown,
+ tags: ["web-clip"] as string[],
+ });
const note = videoNoteFromCapture({
capture: input.capture,
attempt: input.attempt,
@@ -252,10 +295,7 @@ export const persistVideoNote = async (input: {
if (withCover && input.capture.thumbnail && input.createWithImage) {
try {
await input.createWithImage({
- notebookId: input.notebookId,
- title: note.title,
- contentMarkdown: note.markdown,
- tags: ["web-clip"],
+ ...noteFields(note.title, note.markdown),
filename: filenameForCover(input.capture.thumbnail.mimeType),
mimeType: input.capture.thumbnail.mimeType,
bytes: input.capture.thumbnail.bytes,
@@ -274,11 +314,6 @@ export const persistVideoNote = async (input: {
cover: "none",
})
: note;
- await input.createMemo({
- notebookId: input.notebookId,
- title: plainNote.title,
- contentMarkdown: plainNote.markdown,
- tags: ["web-clip"],
- });
+ await input.createMemo(noteFields(plainNote.title, plainNote.markdown));
return plainNote;
};
diff --git a/apps/extension/video-clip.test.mjs b/apps/extension/video-clip.test.mjs
index c7e1421d..cfac358a 100644
--- a/apps/extension/video-clip.test.mjs
+++ b/apps/extension/video-clip.test.mjs
@@ -13,6 +13,7 @@ import { VIDEO_DOCUMENT_PATTERNS } from "./src/video/patterns.ts";
import { readBilibiliVideoInPage } from "./src/video/read-bilibili-in-page.ts";
import { readYouTubeVideoInPage } from "./src/video/read-youtube-in-page.ts";
import { chunkTranscript, cleanCueText, sectionsFromOutline } from "./src/video/transcript.ts";
+import { parseVideoNoteMarker } from "../../packages/shared/src/video-note.ts";
import {
buildVideoNote,
persistVideoNote,
@@ -319,6 +320,67 @@ describe.serial("page main world", () => {
expect(calls).toEqual([]);
});
+ test("loads a YouTube cover without cookies and skips a thumbnail the browser cannot read", async () => {
+ const calls = [];
+ const read = await withPage(() => {
+ const response = playerResponse(CURRENT_ID);
+ delete response.captions;
+ response.videoDetails.thumbnail = {
+ thumbnails: [
+ { url: "https://i.ytimg.com/vi_webp/x/maxresdefault.webp", width: 1920 },
+ { url: "https://i.ytimg.com/vi/x/hqdefault.jpg", width: 336 },
+ ],
+ };
+ globalThis.document = {
+ getElementById: (id) => id === "movie_player"
+ ? { getPlayerResponse: () => response }
+ : null,
+ querySelector: () => null,
+ };
+ globalThis.window = {};
+ globalThis.location = new URL(`https://www.youtube.com/watch?v=${CURRENT_ID}`);
+ globalThis.fetch = async (url, init) => {
+ calls.push({ url: String(url), credentials: init?.credentials });
+ if (String(url).includes("maxresdefault")) throw new TypeError("Failed to fetch");
+ return new Response(Uint8Array.from([1, 2, 3, 4]), {
+ status: 200,
+ headers: { "content-type": "image/jpeg" },
+ });
+ };
+ }, () => readYouTubeVideoInPage("zh-CN"));
+ expect(read.ok).toBe(true);
+ if (!read.ok) return;
+ expect(read.thumbnail?.mimeType).toBe("image/jpeg");
+ expect(read.thumbnail?.base64).toBe(btoa("\u0001\u0002\u0003\u0004"));
+ expect(calls).toEqual([
+ { url: "https://i.ytimg.com/vi_webp/x/maxresdefault.webp", credentials: "omit" },
+ { url: "https://i.ytimg.com/vi/x/hqdefault.jpg", credentials: "omit" },
+ ]);
+ });
+
+ test("reads a Shorts player after the page function is serialized on its own", async () => {
+ const source = readYouTubeVideoInPage.toString();
+ expect(source).toContain("[A-Za-z0-9_-]{11}");
+ const readInPage = new Function(`return (${source})`)();
+ const read = await withPage(() => {
+ globalThis.document = {
+ getElementById: (id) => id === "shorts-player"
+ ? { getPlayerResponse: () => playerResponse(CURRENT_ID) }
+ : null,
+ querySelector: () => null,
+ };
+ globalThis.window = {};
+ globalThis.location = new URL(`https://www.youtube.com/shorts/${CURRENT_ID}`);
+ globalThis.fetch = async () => new Response("", { status: 404 });
+ }, () => readInPage("zh-CN"));
+ expect(read.ok).toBe(true);
+ if (!read.ok) return;
+ expect(read.playerResponse.videoDetails.videoId).toBe(CURRENT_ID);
+ const captured = youtubeCaptureFromRead(`https://www.youtube.com/shorts/${CURRENT_ID}`, read);
+ expect(captured.ok && captured.capture.title).toBe("Current video");
+ expect(captured.ok && captured.capture.sourceUrl).toBe(`https://www.youtube.com/shorts/${CURRENT_ID}`);
+ });
+
test("signs the Bilibili player query and never calls unsigned /x/player/v2", async () => {
const source = readBilibiliVideoInPage.toString();
expect(source).toContain("/x/player/wbi/v2");
@@ -472,6 +534,8 @@ test("assembles the Chinese note from chapters and keeps the transcript outside
- [00:25](https://www.bilibili.com/video/BV1xx411c7xx?p=1&t=25) 很多人收藏之后就没有再打开。
</details>
+
+<!-- edgeever-video-v1:eyJwbGF0Zm9ybSI6ImJpbGliaWxpIiwidmlkZW9JZCI6IkJWMXh4NDExYzd4eCIsInNvdXJjZVVybCI6Imh0dHBzOi8vd3d3LmJpbGliaWxpLmNvbS92aWRlby9CVjF4eDQxMWM3eHg_cD0xIiwiZHVyYXRpb25TZWNvbmRzIjoxNDU1LCJwbGFjZWhvbGRlclRleHQiOiLov5nkuIDpm4bmsqHmnInlj6_nlKjlrZfluZUiLCJ0cmFuc2NyaXB0TGFiZWwiOiLlrZfluZXlrp7lvZUifQ -->
`);
expect(note.markdown).not.toContain("模型不该重写大纲");
expect(note.markdown).not.toContain("hdslb.com");
@@ -594,6 +658,49 @@ test("omits the cover when the image upload fails and never hotlinks the thumbna
expect(memos[0].contentMarkdown).not.toContain("EDGEVERRESOURCEID");
expect(memos[0].contentMarkdown).not.toContain("ytimg.com");
expect(memos[0].contentMarkdown).toContain("caption");
+ expect(memos[0].videoTranscript).toBeUndefined();
+ expect(uploaded[0].videoTranscript).toBeUndefined();
+ expect(parseVideoNoteMarker(memos[0].contentMarkdown)).toMatchObject({
+ platform: "youtube",
+ videoId: CURRENT_ID,
+ sourceUrl: `https://www.youtube.com/watch?v=${CURRENT_ID}`,
+ });
+});
+
+test("marks every video note and leaves transcription for a later click", async () => {
+ const capture = {
+ platform: "youtube",
+ videoId: CURRENT_ID,
+ title: "Current video",
+ author: "Channel",
+ duration: 95,
+ sourceUrl: `https://www.youtube.com/watch?v=${CURRENT_ID}`,
+ chapters: [],
+ cues: [],
+ thumbnail: { bytes: new Uint8Array([1, 2, 3]), mimeType: "image/jpeg" },
+ };
+ const memos = [];
+ const uploaded = [];
+ await persistVideoNote({
+ notebookId: "nb_1",
+ capture,
+ labels: LABELS,
+ capturedOn: "2026-10-05",
+ attempt: null,
+ createMemo: async (body) => { memos.push(body); },
+ createWithImage: async (body) => { uploaded.push(body); throw new Error("missing write:resources"); },
+ });
+ expect(uploaded[0].videoTranscript).toBeUndefined();
+ expect(memos[0].videoTranscript).toBeUndefined();
+ expect(memos[0].contentMarkdown).toContain("这一集没有可用字幕");
+ expect(parseVideoNoteMarker(memos[0].contentMarkdown)).toEqual({
+ platform: "youtube",
+ videoId: CURRENT_ID,
+ sourceUrl: `https://www.youtube.com/watch?v=${CURRENT_ID}`,
+ durationSeconds: 95,
+ placeholderText: "这一集没有可用字幕",
+ transcriptLabel: "字幕实录",
+ });
});
test("keeps the video menu hosts away from the other page commands", () => {
diff --git a/apps/web/src/components/MemoListPane.tsx b/apps/web/src/components/MemoListPane.tsx
index 5ca95774..ba37828e 100644
--- a/apps/web/src/components/MemoListPane.tsx
+++ b/apps/web/src/components/MemoListPane.tsx
@@ -50,6 +50,7 @@ import {
Printer,
Pencil,
Copy,
+ Captions,
} from "lucide-react";
import { WeChatIcon } from "./WeChatIcon";
import { Button } from "@/components/ui/button";
@@ -82,6 +83,7 @@ import type {
} from "@/lib/app-helpers";
import { contentEnterMotion, paneEnterMotion } from "@/lib/motion";
import type { SyncQueueSummary } from "@/lib/sync-queue";
+import { api } from "@/lib/api";
import { isLocalMemoId } from "@/lib/local-mirror";
import { copyTextToClipboard } from "@/lib/clipboard";
import {
@@ -521,9 +523,11 @@ export const MemoListPane = ({
const [moveTargetNotebookId, setMoveTargetNotebookId] = useState("");
const [memoIdCopyNotice, setMemoIdCopyNotice] = useState<{ status: "copied" | "error"; id: string } | null>(null);
const [wechatCopyNotice, setWechatCopyNotice] = useState<"copied" | "error" | null>(null);
+ const [extractNotice, setExtractNotice] = useState<"started" | "running" | "error" | null>(null);
const [wechatCopyPending, setWechatCopyPending] = useState(false);
const wechatCopyPendingRef = useRef(false);
const wechatCopyNoticeTimerRef = useRef<number | null>(null);
+ const extractNoticeTimerRef = useRef<number | null>(null);
const [fileDragActive, setFileDragActive] = useState(false);
const filterOptions = useMemo(() => getMemoFilterOptions(t), [t]);
@@ -542,6 +546,9 @@ export const MemoListPane = ({
if (wechatCopyNoticeTimerRef.current !== null) {
window.clearTimeout(wechatCopyNoticeTimerRef.current);
}
+ if (extractNoticeTimerRef.current !== null) {
+ window.clearTimeout(extractNoticeTimerRef.current);
+ }
}, []);
const listScrollRef = useRef<HTMLDivElement | null>(null);
const [listScrollElement, setListScrollElement] = useState<HTMLDivElement | null>(null);
@@ -661,6 +668,24 @@ export const MemoListPane = ({
onRequestDocumentAction(memo.id, action, printWindow);
};
+ const showExtractNotice = (status: "started" | "running" | "error") => {
+ if (extractNoticeTimerRef.current !== null) window.clearTimeout(extractNoticeTimerRef.current);
+ setExtractNotice(status);
+ extractNoticeTimerRef.current = window.setTimeout(() => setExtractNotice(null), status === "error" ? 2600 : 2200);
+ };
+
+ const handleExtractTranscript = async () => {
+ const memo = memoContextMenu?.memo;
+ if (!memo || !memo.videoNote || isLocalMemoId(memo.id)) return;
+ setMemoContextMenu(null);
+ try {
+ const result = await api.extractVideoTranscript(memo.id);
+ showExtractNotice(result.status === "running" ? "running" : "started");
+ } catch {
+ showExtractNotice("error");
+ }
+ };
+
const handleCopyContextMemoId = async () => {
const memo = memoContextMenu?.memo;
if (!memo || isLocalMemoId(memo.id)) return;
@@ -1573,6 +1598,16 @@ export const MemoListPane = ({
<FileIcon className="h-4 w-4" />
{t("memoList.openMemo")}
</DropdownMenuItem>
+ {view !== "trash" && memoContextMenu.memo.videoNote && (
+ <DropdownMenuItem
+ className="flex h-9 w-full items-center gap-2 px-3 text-left text-xs text-slate-700 hover:bg-slate-50 cursor-pointer outline-none"
+ disabled={isLocalMemoId(memoContextMenu.memo.id)}
+ onClick={() => void handleExtractTranscript()}
+ >
+ <Captions className="h-4 w-4 text-slate-500" />
+ {t("memoList.extractTranscript")}
+ </DropdownMenuItem>
+ )}
<DropdownMenuItem
className="flex h-9 w-full items-center gap-2 px-3 text-left text-xs text-slate-700 hover:bg-slate-50 cursor-pointer outline-none"
onClick={() => {
@@ -1751,6 +1786,16 @@ export const MemoListPane = ({
</ClipboardCopyNotice>
)}
+ {extractNotice && (
+ <ClipboardCopyNotice status={extractNotice === "error" ? "error" : "copied"}>
+ {t(extractNotice === "started"
+ ? "memoList.extractTranscriptStarted"
+ : extractNotice === "running"
+ ? "memoList.extractTranscriptRunning"
+ : "memoList.extractTranscriptFailed")}
+ </ClipboardCopyNotice>
+ )}
+
{selectionMode && (
<MobileSelectionActionBar
canDelete={selectedMemoIds.size > 0 && !isDeleting}
diff --git a/apps/web/src/components/SettingsPane.tsx b/apps/web/src/components/SettingsPane.tsx
index 2bf54008..70fb4592 100644
--- a/apps/web/src/components/SettingsPane.tsx
+++ b/apps/web/src/components/SettingsPane.tsx
@@ -1,4 +1,5 @@
import {
+ AudioLines,
ChevronLeft,
ChevronRight,
Database,
@@ -37,6 +38,7 @@ import { PasswordCard } from "./settings/PasswordCard";
import { UserManagementCard } from "./settings/UserManagementCard";
import { ObjectStorageCard } from "./settings/ObjectStorageCard";
import { AiModelCard } from "./settings/AiModelCard";
+import { SpeechTranscriptionCard } from "./settings/SpeechTranscriptionCard";
import { DesktopAcpAgentCard } from "./settings/DesktopAcpAgentCard";
import { ThemeToggle } from "./ThemeToggle";
import type { AuthUser } from "@edgeever/shared";
@@ -73,7 +75,7 @@ const SettingsGroup = ({ children }: { children: ReactNode }) => (
</div>
);
-type TabKey = "general" | "shortcuts" | "users" | "data" | "ai" | "mcp" | "advanced" | "account" | "system";
+type TabKey = "general" | "shortcuts" | "users" | "data" | "ai" | "speech" | "mcp" | "advanced" | "account" | "system";
interface TabItem {
key: TabKey;
@@ -130,6 +132,11 @@ export const SettingsPane = ({
label: t("settings.tabs.mcp"),
icon: KeyRound,
},
+ {
+ key: "speech",
+ label: t("settings.tabs.speech"),
+ icon: AudioLines,
+ },
{
key: "data",
label: t("settings.tabs.data"),
@@ -236,6 +243,12 @@ export const SettingsPane = ({
<AiModelCard />
</SettingsGroup>
);
+ case "speech":
+ return (
+ <SettingsGroup>
+ <SpeechTranscriptionCard demoMode={demoMode} />
+ </SettingsGroup>
+ );
case "mcp":
return (
<SettingsGroup>
diff --git a/apps/web/src/components/settings/SpeechProviderCard.tsx b/apps/web/src/components/settings/SpeechProviderCard.tsx
new file mode 100644
index 00000000..c4be09b2
--- /dev/null
+++ b/apps/web/src/components/settings/SpeechProviderCard.tsx
@@ -0,0 +1,325 @@
+import { useEffect, useState, type FormEvent, type ReactNode } from "react";
+import { useMutation } from "@tanstack/react-query";
+import type { AiTranscriptionProvider, AiTranscriptionSettings, AiTranscriptionStandard } from "@edgeever/shared";
+import { Loader2, MoreHorizontal, Pencil, Plus, Trash2 } from "lucide-react";
+import { useTranslation } from "react-i18next";
+import { aiErrorMessage, trimAiText } from "@/components/settings/ai-provider-options";
+import { Button } from "@/components/ui/button";
+import {
+ Dialog,
+ DialogContent,
+ DialogFooter,
+ DialogHeader,
+ DialogTitle,
+} from "@/components/ui/dialog";
+import {
+ DropdownMenu,
+ DropdownMenuContent,
+ DropdownMenuItem,
+ DropdownMenuSeparator,
+ DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
+import { Input } from "@/components/ui/input";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import { Switch } from "@/components/ui/switch";
+import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "@/components/ui/tooltip";
+import { api } from "@/lib/api";
+
+export const SpeechProviderCard = ({
+ provider: saved,
+ defaultModelId,
+ readOnly,
+ onChanged,
+}: {
+ provider: AiTranscriptionProvider;
+ defaultModelId: string | null;
+ readOnly: boolean;
+ onChanged: (settings: AiTranscriptionSettings) => void;
+}) => {
+ const { t } = useTranslation();
+ const [provider, setProvider] = useState<AiTranscriptionStandard>(saved.provider);
+ const [displayName, setDisplayName] = useState(saved.displayName);
+ const [baseUrl, setBaseUrl] = useState(saved.baseUrl);
+ const [apiKey, setApiKey] = useState("");
+ const [modelId, setModelId] = useState("");
+ const [showConnection, setShowConnection] = useState(false);
+ const [showAddModel, setShowAddModel] = useState(false);
+
+ useEffect(() => {
+ setProvider(saved.provider);
+ setDisplayName(saved.displayName);
+ setBaseUrl(saved.baseUrl);
+ }, [saved.baseUrl, saved.displayName, saved.provider]);
+
+ const saveMutation = useMutation({
+ mutationFn: () => api.updateAiTranscriptionProvider(saved.id, {
+ provider,
+ displayName: displayName.trim(),
+ baseUrl: baseUrl.trim(),
+ isEnabled: saved.isEnabled,
+ ...(apiKey.trim() ? { apiKey: apiKey.trim() } : {}),
+ }),
+ onSuccess: (settings) => {
+ setApiKey("");
+ setShowConnection(false);
+ onChanged(settings);
+ },
+ });
+ const toggleMutation = useMutation({
+ mutationFn: (isEnabled: boolean) => api.updateAiTranscriptionProvider(saved.id, {
+ provider: saved.provider,
+ displayName: saved.displayName,
+ baseUrl: saved.baseUrl,
+ isEnabled,
+ }),
+ onSuccess: onChanged,
+ });
+ const deleteMutation = useMutation({
+ mutationFn: () => api.deleteAiTranscriptionProvider(saved.id),
+ onSuccess: onChanged,
+ });
+ const addModelMutation = useMutation({
+ mutationFn: () => api.addAiTranscriptionModel(saved.id, { modelId: trimAiText(modelId) }),
+ onSuccess: (settings) => {
+ setModelId("");
+ setShowAddModel(false);
+ onChanged(settings);
+ },
+ });
+ const deleteModelMutation = useMutation({
+ mutationFn: (modelConfigId: string) => api.deleteAiTranscriptionModel(saved.id, modelConfigId),
+ onSuccess: onChanged,
+ });
+
+ const cardBusy = toggleMutation.isPending || deleteMutation.isPending || deleteModelMutation.isPending;
+ const cardError = toggleMutation.error ?? deleteMutation.error ?? addModelMutation.error ?? deleteModelMutation.error;
+ const resetConnectionForm = () => {
+ setProvider(saved.provider);
+ setDisplayName(saved.displayName);
+ setBaseUrl(saved.baseUrl);
+ setApiKey("");
+ saveMutation.reset();
+ };
+ const handleConnectionChange = (open: boolean) => {
+ setShowConnection(open);
+ if (!open) resetConnectionForm();
+ };
+ const handleAddModelChange = (open: boolean) => {
+ setShowAddModel(open);
+ if (!open) {
+ setModelId("");
+ addModelMutation.reset();
+ }
+ };
+ const deleteProvider = () => {
+ if (window.confirm(t("speechTranscription.deleteProviderConfirm", { name: saved.displayName }))) {
+ deleteMutation.mutate();
+ }
+ };
+ const deleteModel = (model: AiTranscriptionProvider["models"][number]) => {
+ if (window.confirm(t("speechTranscription.deleteModelConfirm", { name: model.displayName }))) {
+ deleteModelMutation.mutate(model.id);
+ }
+ };
+
+ return (
+ <section>
+ <div className="flex flex-col gap-2.5 p-3.5 sm:p-4">
+ <div className="flex items-center justify-between gap-3">
+ <div className="flex min-w-0 flex-wrap items-center gap-2">
+ <span className="truncate text-xs font-normal text-slate-900">{saved.displayName}</span>
+ {saved.credentialsUnavailable ? (
+ <span className="rounded-md bg-amber-50 px-2 py-0.5 text-xs font-normal text-amber-800">
+ {t("aiModel.savedCredentialsUnavailableBadge")}
+ </span>
+ ) : null}
+ <span className="max-w-full truncate font-mono text-xs text-slate-400">{formatBaseUrl(saved.baseUrl)}</span>
+ <span className="max-w-full truncate text-xs text-slate-400">{t(`speechTranscription.standards.${saved.provider}`)}</span>
+ </div>
+ <div className="flex shrink-0 items-center gap-1.5">
+ <span className="hidden text-xs text-slate-400 sm:inline">
+ {saved.isEnabled ? t("speechTranscription.serviceEnabledStatus") : t("speechTranscription.serviceDisabledStatus")}
+ </span>
+ <Switch
+ checked={saved.isEnabled}
+ disabled={readOnly || toggleMutation.isPending}
+ aria-label={t("speechTranscription.serviceEnabled")}
+ onCheckedChange={(checked) => toggleMutation.mutate(checked)}
+ />
+ <TooltipProvider>
+ <Tooltip>
+ <TooltipTrigger asChild>
+ <Button
+ type="button"
+ variant="ghost"
+ size="icon"
+ className="h-8 w-8 text-slate-500 hover:text-slate-900"
+ disabled={readOnly}
+ onClick={() => setShowAddModel(true)}
+ aria-label={t("speechTranscription.addModel")}
+ >
+ <Plus className="h-4 w-4" />
+ </Button>
+ </TooltipTrigger>
+ <TooltipContent side="bottom">{t("speechTranscription.addModel")}</TooltipContent>
+ </Tooltip>
+ <DropdownMenu>
+ <Tooltip>
+ <TooltipTrigger asChild>
+ <DropdownMenuTrigger asChild>
+ <Button
+ type="button"
+ variant="ghost"
+ size="icon"
+ className="h-8 w-8 text-slate-500 hover:text-slate-900"
+ disabled={cardBusy}
+ aria-label={t("speechTranscription.serviceActions")}
+ >
+ <MoreHorizontal className="h-4 w-4" />
+ </Button>
+ </DropdownMenuTrigger>
+ </TooltipTrigger>
+ <TooltipContent side="bottom">{t("speechTranscription.serviceActions")}</TooltipContent>
+ </Tooltip>
+ <DropdownMenuContent align="end">
+ <DropdownMenuItem disabled={readOnly} onSelect={() => { resetConnectionForm(); setShowConnection(true); }}>
+ <Pencil className="mr-2 h-4 w-4" />{t("speechTranscription.editConnection")}
+ </DropdownMenuItem>
+ <DropdownMenuSeparator />
+ <DropdownMenuItem className="text-rose-600 focus:text-rose-700" disabled={readOnly} onSelect={deleteProvider}>
+ <Trash2 className="mr-2 h-4 w-4" />{t("common.delete")}
+ </DropdownMenuItem>
+ </DropdownMenuContent>
+ </DropdownMenu>
+ </TooltipProvider>
+ </div>
+ </div>
+ <div className="flex min-w-0 flex-wrap items-center gap-1.5 pt-0.5">
+ <TooltipProvider>
+ {saved.models.length ? saved.models.map((model) => (
+ <span
+ key={model.id}
+ className="inline-flex h-6.5 max-w-full min-w-0 items-center gap-1.5 rounded-md border border-slate-200/80 bg-slate-50/80 pl-2 pr-1 text-xs text-slate-700"
+ >
+ <span className="min-w-0 truncate font-normal">{model.displayName}</span>
+ {model.id === defaultModelId ? (
+ <span className="shrink-0 rounded border border-slate-200 bg-slate-100 px-1 py-0.5 text-xs font-normal text-slate-700">
+ {t("speechTranscription.defaultBadge")}
+ </span>
+ ) : null}
+ <Tooltip>
+ <TooltipTrigger asChild>
+ <Button
+ type="button"
+ variant="ghost"
+ size="icon"
+ className="h-4 w-4 shrink-0 text-slate-400 hover:bg-card hover:text-rose-600"
+ disabled={readOnly || deleteModelMutation.isPending}
+ onClick={() => deleteModel(model)}
+ aria-label={`${t("speechTranscription.removeModel")}: ${model.displayName}`}
+ >
+ <Trash2 className="h-3 w-3" />
+ </Button>
+ </TooltipTrigger>
+ <TooltipContent side="bottom">{t("speechTranscription.removeModel")}</TooltipContent>
+ </Tooltip>
+ </span>
+ )) : (
+ <span className="text-xs text-slate-400">{t("speechTranscription.noModels")}</span>
+ )}
+ </TooltipProvider>
+ </div>
+ </div>
+ {cardError ? (
+ <p className="border-t px-4 py-3 text-xs font-medium text-rose-600" role="alert">
+ {aiErrorMessage(cardError, t("speechTranscription.failed"), t("aiModel.encryptionKeyMissing"), t("speechTranscription.savedCredentialsUnavailable"))}
+ </p>
+ ) : null}
+ <Dialog open={showConnection} onOpenChange={handleConnectionChange}>
+ <DialogContent className="max-h-[calc(100vh-2rem)] overflow-y-auto sm:max-w-lg">
+ <form className="grid gap-4" onSubmit={(event: FormEvent) => { event.preventDefault(); if (readOnly) return; saveMutation.mutate(); }}>
+ <DialogHeader>
+ <DialogTitle className="text-xs font-normal">{t("speechTranscription.editConnection")}</DialogTitle>
+ </DialogHeader>
+ <div className="grid gap-4 sm:grid-cols-2">
+ <Field label={t("speechTranscription.displayName")}>
+ <Input className="h-9 text-xs" value={displayName} onChange={(event) => setDisplayName(event.target.value)} required maxLength={80} disabled={readOnly} />
+ </Field>
+ <Field label={t("speechTranscription.standard")}>
+ <Select value={provider} onValueChange={(value) => setProvider(value as AiTranscriptionStandard)} disabled={readOnly}>
+ <SelectTrigger className="h-9 bg-card text-xs font-normal"><SelectValue /></SelectTrigger>
+ <SelectContent>
+ <SelectItem value="openai-compatible">{t("speechTranscription.standards.openai-compatible")}</SelectItem>
+ </SelectContent>
+ </Select>
+ </Field>
+ </div>
+ <Field label={t("speechTranscription.baseUrl")} hint={t("speechTranscription.baseUrlHint")}>
+ <Input className="h-9 text-xs" value={baseUrl} onChange={(event) => setBaseUrl(event.target.value)} required inputMode="url" autoComplete="off" spellCheck={false} maxLength={500} disabled={readOnly} />
+ </Field>
+ <Field label={t("speechTranscription.apiToken")} hint={saved.hasApiKey ? t("speechTranscription.apiTokenSavedHint") : t("speechTranscription.apiTokenHint")}>
+ <Input
+ className="h-9 text-xs"
+ type="password"
+ value={apiKey}
+ onChange={(event) => setApiKey(event.target.value)}
+ placeholder={saved.hasApiKey ? t("speechTranscription.apiTokenStoredPlaceholder") : ""}
+ autoComplete="new-password"
+ maxLength={4096}
+ disabled={readOnly}
+ />
+ </Field>
+ {saveMutation.isError ? (
+ <p className="text-xs font-medium text-rose-600" role="alert">
+ {aiErrorMessage(saveMutation.error, t("speechTranscription.failed"), t("aiModel.encryptionKeyMissing"), t("speechTranscription.savedCredentialsUnavailable"))}
+ </p>
+ ) : null}
+ <DialogFooter className="gap-2 sm:space-x-0">
+ <Button type="button" variant="outline" className="text-xs font-normal" onClick={() => handleConnectionChange(false)}>{t("common.cancel")}</Button>
+ <Button type="submit" variant="solid" className="text-xs font-normal" disabled={readOnly || saveMutation.isPending}>
+ {saveMutation.isPending ? <Loader2 className="h-4 w-4 animate-spin" /> : null}{t("common.save")}
+ </Button>
+ </DialogFooter>
+ </form>
+ </DialogContent>
+ </Dialog>
+ <Dialog open={showAddModel} onOpenChange={handleAddModelChange}>
+ <DialogContent className="sm:max-w-md">
+ <form className="grid gap-4" onSubmit={(event: FormEvent) => { event.preventDefault(); if (readOnly || !trimAiText(modelId)) return; addModelMutation.mutate(); }}>
+ <DialogHeader>
+ <DialogTitle className="text-xs font-normal">{t("speechTranscription.addModel")}</DialogTitle>
+ </DialogHeader>
+ <Field label={t("speechTranscription.modelId")}>
+ <Input className="h-9 text-xs" value={modelId} onChange={(event) => setModelId(event.target.value)} placeholder={t("speechTranscription.modelIdPlaceholder")} autoComplete="off" spellCheck={false} maxLength={200} required disabled={readOnly} />
+ </Field>
+ {addModelMutation.isError ? (
+ <p className="text-xs font-medium text-rose-600" role="alert">
+ {aiErrorMessage(addModelMutation.error, t("speechTranscription.failed"), t("aiModel.encryptionKeyMissing"), t("speechTranscription.savedCredentialsUnavailable"))}
+ </p>
+ ) : null}
+ <DialogFooter className="gap-2 sm:space-x-0">
+ <Button type="button" variant="outline" className="text-xs font-normal" onClick={() => handleAddModelChange(false)}>{t("common.cancel")}</Button>
+ <Button type="submit" variant="solid" className="text-xs font-normal" disabled={readOnly || addModelMutation.isPending || !trimAiText(modelId)}>
+ {addModelMutation.isPending ? <Loader2 className="h-4 w-4 animate-spin" /> : null}{t("speechTranscription.addModel")}
+ </Button>
+ </DialogFooter>
+ </form>
+ </DialogContent>
+ </Dialog>
+ </section>
+ );
+};
+
+const formatBaseUrl = (baseUrl: string) => {
+ try {
+ return new URL(baseUrl).host;
+ } catch {
+ return baseUrl;
+ }
+};
+
+const Field = ({ label, hint, children }: { label: string; hint?: string; children: ReactNode }) => (
+ <label className="grid gap-1.5 text-xs font-normal leading-5 text-slate-700">
+ {label}{children}{hint ? <span className="text-xs font-normal leading-4 text-slate-500">{hint}</span> : null}
+ </label>
+);
diff --git a/apps/web/src/components/settings/SpeechTranscriptionCard.test.mjs b/apps/web/src/components/settings/SpeechTranscriptionCard.test.mjs
new file mode 100644
index 00000000..029762ad
--- /dev/null
+++ b/apps/web/src/components/settings/SpeechTranscriptionCard.test.mjs
@@ -0,0 +1,114 @@
+import { describe, expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { createElement } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import { createInstance } from "i18next";
+import { I18nextProvider } from "react-i18next";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { zhCN } from "../../../../../packages/shared/src/i18n/zh-CN.ts";
+import { SpeechTranscriptionCard } from "./SpeechTranscriptionCard.tsx";
+
+const saved = {
+ providers: [
+ {
+ id: "atp_groq",
+ provider: "openai-compatible",
+ displayName: "Groq",
+ baseUrl: "https://api.groq.com/openai/v1",
+ isEnabled: true,
+ hasApiKey: true,
+ models: [{
+ id: "atm_turbo",
+ providerId: "atp_groq",
+ modelId: "whisper-large-v3-turbo",
+ displayName: "whisper-large-v3-turbo",
+ }],
+ },
+ {
+ id: "atp_local",
+ provider: "openai-compatible",
+ displayName: "本机",
+ baseUrl: "http://127.0.0.1:8080/v1",
+ isEnabled: true,
+ hasApiKey: true,
+ models: [{
+ id: "atm_local",
+ providerId: "atp_local",
+ modelId: "local-whisper",
+ displayName: "local-whisper",
+ }],
+ },
+ ],
+ defaultModelId: "atm_turbo",
+ enabled: true,
+ encryptionConfigured: true,
+ readOnly: false,
+};
+
+const renderCard = async (settings, demoMode = false) => {
+ const i18n = createInstance();
+ await i18n.init({ lng: "zh-CN", resources: { "zh-CN": { translation: zhCN } } });
+ const queryClient = new QueryClient({
+ defaultOptions: { queries: { retry: false, staleTime: Infinity } },
+ });
+ queryClient.setQueryData(["ai-transcription-settings"], settings);
+ return renderToStaticMarkup(createElement(
+ QueryClientProvider,
+ { client: queryClient },
+ createElement(I18nextProvider, { i18n }, createElement(SpeechTranscriptionCard, { demoMode })),
+ ));
+};
+
+describe("speech transcription settings card", () => {
+ test("lists every saved speech service and the one used for extraction", async () => {
+ const html = await renderCard(saved);
+ expect(html).toContain("语音识别");
+ expect(html).toContain("默认语音模型");
+ expect(html).toContain("添加模型服务");
+ expect(html).toContain("Groq");
+ expect(html).toContain("本机");
+ expect(html).toContain("api.groq.com");
+ expect(html).toContain("127.0.0.1:8080");
+ expect(html).toContain("whisper-large-v3-turbo");
+ expect(html).toContain("local-whisper");
+ expect(html).toContain("默认");
+ expect(html).toContain("OpenAI 兼容标准");
+ expect(html).not.toContain("asr-token");
+ expect(html).not.toContain("title=");
+ });
+
+ test("shows an empty list when no speech service is saved", async () => {
+ const html = await renderCard({
+ providers: [],
+ defaultModelId: null,
+ enabled: false,
+ encryptionConfigured: true,
+ readOnly: false,
+ });
+ expect(html).toContain("还没有语音识别服务");
+ expect(html).toContain("默认语音模型");
+ expect(html).toContain("添加模型服务");
+ });
+
+ test("is its own settings page under models and agents", () => {
+ const pane = readFileSync(new URL("../SettingsPane.tsx", import.meta.url), "utf8");
+ const card = readFileSync(new URL("./SpeechTranscriptionCard.tsx", import.meta.url), "utf8");
+ const provider = readFileSync(new URL("./SpeechProviderCard.tsx", import.meta.url), "utf8");
+ const aiTab = pane.slice(pane.indexOf('case "ai"'), pane.indexOf('case "speech"'));
+ const speechTab = pane.slice(pane.indexOf('case "speech"'), pane.indexOf('case "mcp"'));
+ expect(aiTab).toContain("<AiModelCard />");
+ expect(aiTab).not.toContain("SpeechTranscriptionCard");
+ expect(speechTab).toContain("<SpeechTranscriptionCard demoMode={demoMode} />");
+ expect(pane.indexOf('key: "ai"')).toBeLessThan(pane.indexOf('key: "mcp"'));
+ expect(pane.indexOf('key: "mcp"')).toBeLessThan(pane.indexOf('key: "speech"'));
+ expect(card).toContain("createAiTranscriptionProvider");
+ expect(card).toContain("speechTranscription.standard");
+ expect(card).toContain('value="openai-compatible"');
+ expect(provider).toContain("apiKey.trim() ? { apiKey: apiKey.trim() } : {}");
+ expect(card).not.toContain("updateAiTranscriptionSettings");
+ expect(provider).not.toContain("@ai-sdk/openai");
+ expect(provider).not.toContain("transcribe(");
+ expect(card).not.toContain("title=");
+ expect(provider).not.toContain("title=");
+ });
+});
diff --git a/apps/web/src/components/settings/SpeechTranscriptionCard.tsx b/apps/web/src/components/settings/SpeechTranscriptionCard.tsx
new file mode 100644
index 00000000..28ded90a
--- /dev/null
+++ b/apps/web/src/components/settings/SpeechTranscriptionCard.tsx
@@ -0,0 +1,326 @@
+import { useState, type FormEvent, type ReactNode } from "react";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { VIDEO_COOKIE_BROWSERS, type AiTranscriptionSettings, type AiTranscriptionStandard, type VideoCookieBrowser } from "@edgeever/shared";
+import { AudioLines, Loader2, Plus, TriangleAlert } from "lucide-react";
+import { useTranslation } from "react-i18next";
+import { aiErrorMessage } from "@/components/settings/ai-provider-options";
+import { SpeechProviderCard } from "@/components/settings/SpeechProviderCard";
+import { Button } from "@/components/ui/button";
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card";
+import {
+ Dialog,
+ DialogContent,
+ DialogFooter,
+ DialogHeader,
+ DialogTitle,
+} from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "@/components/ui/tooltip";
+import { api } from "@/lib/api";
+import {
+ SETTINGS_CARD_DESCRIPTION_CLASSNAME,
+ SETTINGS_CARD_HEADER_CLASSNAME,
+ SETTINGS_CARD_ICON_CLASSNAME,
+ SETTINGS_CARD_TITLE_CLASSNAME,
+ SETTINGS_ITEM_TITLE_CLASSNAME,
+} from "./settings-ui";
+
+const emptyDraft = {
+ provider: "openai-compatible" as AiTranscriptionStandard,
+ displayName: "",
+ baseUrl: "",
+ apiKey: "",
+ initialModelId: "",
+};
+
+export const SpeechTranscriptionCard = ({ demoMode }: { demoMode: boolean }) => {
+ const { t } = useTranslation();
+ const queryClient = useQueryClient();
+ const desktop = typeof window !== "undefined" && window.edgeeverDesktop?.isAvailable === true;
+ const settingsQuery = useQuery({
+ queryKey: ["ai-transcription-settings"],
+ queryFn: api.getAiTranscriptionSettings,
+ });
+ const cookieBrowserQuery = useQuery({
+ queryKey: ["video-cookie-browser"],
+ queryFn: () => window.edgeeverDesktop!.videoCookieBrowser(),
+ enabled: desktop,
+ });
+ const [showAdd, setShowAdd] = useState(false);
+ const [draft, setDraft] = useState(emptyDraft);
+
+ const settings = settingsQuery.data;
+ const providers = settings?.providers ?? [];
+ const readOnly = demoMode || Boolean(settings?.readOnly);
+ const encryptionConfigured = settings?.encryptionConfigured ?? false;
+ const canAdd = !readOnly && encryptionConfigured;
+ const hasUnavailableCredentials = providers.some((provider) => provider.credentialsUnavailable);
+ const allModels = providers.flatMap((provider) =>
+ provider.models.map((model) => ({ ...model, providerName: provider.displayName, providerEnabled: provider.isEnabled })));
+ const defaultModelAvailable = !settings?.defaultModelId
+ || allModels.some((model) => model.id === settings.defaultModelId && model.providerEnabled);
+ const applySettings = (saved: AiTranscriptionSettings) => {
+ queryClient.setQueryData(["ai-transcription-settings"], saved);
+ };
+ const createMutation = useMutation({
+ mutationFn: () => api.createAiTranscriptionProvider({
+ provider: draft.provider,
+ displayName: draft.displayName.trim(),
+ baseUrl: draft.baseUrl.trim(),
+ apiKey: draft.apiKey.trim(),
+ isEnabled: true,
+ ...(draft.initialModelId.trim() ? { initialModelId: draft.initialModelId.trim() } : {}),
+ }),
+ onSuccess: (saved) => {
+ applySettings(saved);
+ setShowAdd(false);
+ setDraft(emptyDraft);
+ },
+ });
+ const defaultMutation = useMutation({
+ mutationFn: api.updateDefaultAiTranscriptionModel,
+ onSuccess: applySettings,
+ });
+ const cookieBrowserMutation = useMutation({
+ mutationFn: (browser: VideoCookieBrowser) => window.edgeeverDesktop!.setVideoCookieBrowser(browser),
+ onSuccess: (saved) => {
+ queryClient.setQueryData(["video-cookie-browser"], saved.browser);
+ },
+ });
+ const addDisabledReason = readOnly
+ ? t("speechTranscription.demoDisabled")
+ : !encryptionConfigured
+ ? t("aiModel.encryptionKeyMissing")
+ : undefined;
+ const handleAddDialogChange = (open: boolean) => {
+ setShowAdd(open);
+ if (!open) {
+ setDraft(emptyDraft);
+ createMutation.reset();
+ }
+ };
+
+ return (
+ <Card className="w-full min-w-0 overflow-hidden shadow-none">
+ <CardHeader className={SETTINGS_CARD_HEADER_CLASSNAME}>
+ <CardTitle className={SETTINGS_CARD_TITLE_CLASSNAME}>
+ <AudioLines className={SETTINGS_CARD_ICON_CLASSNAME} />
+ {t("speechTranscription.title")}
+ </CardTitle>
+ <CardDescription className={SETTINGS_CARD_DESCRIPTION_CLASSNAME}>
+ {t("speechTranscription.description")}
+ </CardDescription>
+ </CardHeader>
+ <CardContent className="grid gap-5 p-4 pt-0 sm:px-5 sm:pb-5">
+ {settingsQuery.isLoading ? (
+ <p className="flex items-center gap-2 text-xs leading-5 text-slate-500">
+ <Loader2 className="h-4 w-4 animate-spin" />
+ {t("common.loading")}
+ </p>
+ ) : settingsQuery.isError ? (
+ <p className="text-xs font-medium text-rose-600" role="alert">
+ {aiErrorMessage(settingsQuery.error, t("speechTranscription.failed"), t("aiModel.encryptionKeyMissing"), t("speechTranscription.savedCredentialsUnavailable"))}
+ </p>
+ ) : (
+ <>
+ {!encryptionConfigured ? (
+ <p className="flex items-start gap-2 rounded-lg border border-amber-200 bg-amber-50 p-3 text-xs leading-5 text-amber-800">
+ <TriangleAlert className="mt-0.5 h-4 w-4 shrink-0" />
+ {t("aiModel.encryptionKeyMissing")}
+ </p>
+ ) : null}
+ {hasUnavailableCredentials ? (
+ <p className="flex items-start gap-2 rounded-lg border border-amber-200 bg-amber-50 p-3 text-xs leading-5 text-amber-800">
+ <TriangleAlert className="mt-0.5 h-4 w-4 shrink-0" />
+ {t("speechTranscription.savedCredentialsUnavailable")}
+ </p>
+ ) : null}
+ <div className="space-y-2">
+ <div className="flex items-center justify-between gap-3">
+ <div className={SETTINGS_ITEM_TITLE_CLASSNAME}>{t("speechTranscription.defaultModel")}</div>
+ <div className="w-56 max-w-[60%] shrink-0 sm:w-72">
+ <Select
+ value={settings?.defaultModelId ?? "none"}
+ onValueChange={(value) => defaultMutation.mutate(value === "none" ? null : value)}
+ disabled={readOnly || defaultMutation.isPending}
+ >
+ <SelectTrigger className="h-8 bg-card text-xs"><SelectValue /></SelectTrigger>
+ <SelectContent>
+ <SelectItem value="none">{t("speechTranscription.noDefaultModel")}</SelectItem>
+ {allModels.map((model) => (
+ <SelectItem key={model.id} value={model.id} disabled={!model.providerEnabled}>
+ {model.displayName} · {model.providerName}
+ </SelectItem>
+ ))}
+ </SelectContent>
+ </Select>
+ </div>
+ </div>
+ {!defaultModelAvailable ? (
+ <p className="flex items-center gap-1.5 text-xs text-amber-700">
+ <TriangleAlert className="h-3.5 w-3.5 shrink-0" />
+ {t("speechTranscription.defaultUnavailable")}
+ </p>
+ ) : null}
+ {defaultMutation.isError ? (
+ <p className="text-xs font-medium text-rose-600" role="alert">
+ {aiErrorMessage(defaultMutation.error, t("speechTranscription.failed"), t("aiModel.encryptionKeyMissing"), t("speechTranscription.savedCredentialsUnavailable"))}
+ </p>
+ ) : null}
+ </div>
+ <section className="grid gap-3">
+ <div className="flex items-center justify-end">
+ <DisabledActionTooltip label={!canAdd ? addDisabledReason : undefined}>
+ <Button type="button" variant="outline" size="sm" className="h-8 gap-1.5 bg-card text-xs font-normal" disabled={!canAdd} onClick={() => handleAddDialogChange(true)}>
+ <Plus className="h-3.5 w-3.5" />{t("speechTranscription.addProvider")}
+ </Button>
+ </DisabledActionTooltip>
+ </div>
+ {providers.length ? (
+ <div className="overflow-hidden rounded-lg border border-slate-200 divide-y divide-slate-100 bg-card">
+ {providers.map((provider) => (
+ <SpeechProviderCard
+ key={provider.id}
+ provider={provider}
+ defaultModelId={settings?.defaultModelId ?? null}
+ readOnly={readOnly}
+ onChanged={applySettings}
+ />
+ ))}
+ </div>
+ ) : (
+ <p className="rounded-lg border border-dashed border-slate-200 p-6 text-center text-xs text-slate-400">{t("speechTranscription.noProviders")}</p>
+ )}
+ </section>
+ {readOnly ? <p className="text-xs leading-5 text-slate-500">{t("speechTranscription.demoDisabled")}</p> : null}
+ {desktop ? (
+ <div className="grid gap-1.5">
+ <label className="grid gap-1.5 text-xs font-normal leading-5 text-slate-700" htmlFor="video-cookie-browser">
+ {t("speechTranscription.cookieBrowser")}
+ </label>
+ <Select
+ value={cookieBrowserQuery.data ?? "chrome"}
+ onValueChange={(value) => cookieBrowserMutation.mutate(value as VideoCookieBrowser)}
+ disabled={cookieBrowserQuery.isLoading || cookieBrowserMutation.isPending}
+ >
+ <SelectTrigger id="video-cookie-browser" className="h-10 bg-card">
+ <SelectValue />
+ </SelectTrigger>
+ <SelectContent>
+ {VIDEO_COOKIE_BROWSERS.map((browser) => (
+ <SelectItem key={browser} value={browser}>
+ {t(`speechTranscription.cookieBrowsers.${browser}`)}
+ </SelectItem>
+ ))}
+ <SelectItem value="none">{t("speechTranscription.cookieBrowserNone")}</SelectItem>
+ </SelectContent>
+ </Select>
+ <p className="text-xs font-normal leading-4 text-slate-500">{t("speechTranscription.cookieBrowserHint")}</p>
+ {cookieBrowserMutation.isSuccess ? (
+ <p className="text-xs font-medium text-emerald-700">
+ {cookieBrowserMutation.data.browser === "none"
+ ? t("speechTranscription.cookieBrowserOff")
+ : t("speechTranscription.cookieBrowserApplied", {
+ browser: t(`speechTranscription.cookieBrowsers.${cookieBrowserMutation.data.browser}`),
+ })}
+ </p>
+ ) : null}
+ {cookieBrowserQuery.isError || cookieBrowserMutation.isError ? (
+ <p className="text-xs font-medium text-rose-600" role="alert">{t("speechTranscription.cookieBrowserFailed")}</p>
+ ) : null}
+ </div>
+ ) : null}
+ <Dialog open={showAdd} onOpenChange={handleAddDialogChange}>
+ <DialogContent className="max-h-[calc(100vh-2rem)] overflow-y-auto sm:max-w-lg">
+ <form
+ className="grid gap-4"
+ onSubmit={(event: FormEvent) => {
+ event.preventDefault();
+ if (!canAdd || createMutation.isPending) return;
+ createMutation.mutate();
+ }}
+ >
+ <DialogHeader>
+ <DialogTitle className="text-xs font-normal">{t("speechTranscription.addProvider")}</DialogTitle>
+ </DialogHeader>
+ <div className="grid gap-4 sm:grid-cols-2">
+ <Field label={t("speechTranscription.displayName")}>
+ <Input className="h-9 text-xs" value={draft.displayName} onChange={(event) => setDraft({ ...draft, displayName: event.target.value })} required maxLength={80} />
+ </Field>
+ <SpeechStandardField
+ value={draft.provider}
+ onChange={(provider) => setDraft({ ...draft, provider })}
+ />
+ </div>
+ <Field label={t("speechTranscription.baseUrl")} hint={t("speechTranscription.baseUrlHint")}>
+ <Input className="h-9 text-xs" value={draft.baseUrl} onChange={(event) => setDraft({ ...draft, baseUrl: event.target.value })} placeholder={t("speechTranscription.baseUrlPlaceholder")} required inputMode="url" autoComplete="off" spellCheck={false} maxLength={500} />
+ </Field>
+ <Field label={t("speechTranscription.modelId")}>
+ <Input className="h-9 text-xs" value={draft.initialModelId} onChange={(event) => setDraft({ ...draft, initialModelId: event.target.value })} placeholder={t("speechTranscription.modelIdPlaceholder")} required autoComplete="off" spellCheck={false} maxLength={200} />
+ </Field>
+ <Field label={t("speechTranscription.apiToken")} hint={t("speechTranscription.apiTokenHint")}>
+ <Input className="h-9 text-xs" type="password" value={draft.apiKey} onChange={(event) => setDraft({ ...draft, apiKey: event.target.value })} required autoComplete="new-password" maxLength={4096} />
+ </Field>
+ {createMutation.isError ? (
+ <p className="text-xs font-medium text-rose-600" role="alert">
+ {aiErrorMessage(createMutation.error, t("speechTranscription.failed"), t("aiModel.encryptionKeyMissing"), t("speechTranscription.savedCredentialsUnavailable"))}
+ </p>
+ ) : null}
+ <DialogFooter className="gap-2 sm:space-x-0">
+ <Button type="button" variant="outline" className="text-xs font-normal" onClick={() => handleAddDialogChange(false)}>{t("common.cancel")}</Button>
+ <Button type="submit" variant="solid" className="text-xs font-normal" disabled={!canAdd || createMutation.isPending}>
+ {createMutation.isPending ? <Loader2 className="h-4 w-4 animate-spin" /> : null}{t("speechTranscription.addProvider")}
+ </Button>
+ </DialogFooter>
+ </form>
+ </DialogContent>
+ </Dialog>
+ </>
+ )}
+ </CardContent>
+ </Card>
+ );
+};
+
+const SpeechStandardField = ({
+ value,
+ onChange,
+ disabled = false,
+}: {
+ value: AiTranscriptionStandard;
+ onChange: (value: AiTranscriptionStandard) => void;
+ disabled?: boolean;
+}) => {
+ const { t } = useTranslation();
+ return (
+ <Field label={t("speechTranscription.standard")}>
+ <Select value={value} onValueChange={(next) => onChange(next as AiTranscriptionStandard)} disabled={disabled}>
+ <SelectTrigger className="h-9 bg-card text-xs font-normal"><SelectValue /></SelectTrigger>
+ <SelectContent>
+ <SelectItem value="openai-compatible">{t("speechTranscription.standards.openai-compatible")}</SelectItem>
+ </SelectContent>
+ </Select>
+ </Field>
+ );
+};
+
+const Field = ({ label, hint, children }: { label: string; hint?: string; children: ReactNode }) => (
+ <label className="grid gap-1.5 text-xs font-normal leading-5 text-slate-700">
+ {label}{children}{hint ? <span className="text-xs font-normal leading-4 text-slate-500">{hint}</span> : null}
+ </label>
+);
+
+const DisabledActionTooltip = ({ label, children }: { label?: string; children: ReactNode }) => {
+ if (!label) return children;
+ return (
+ <TooltipProvider delayDuration={0} skipDelayDuration={0}>
+ <Tooltip>
+ <TooltipTrigger asChild>
+ <span className="inline-flex" tabIndex={0}>{children}</span>
+ </TooltipTrigger>
+ <TooltipContent side="bottom">{label}</TooltipContent>
+ </Tooltip>
+ </TooltipProvider>
+ );
+};
diff --git a/apps/web/src/components/settings/SystemInfoPanel.test.mjs b/apps/web/src/components/settings/SystemInfoPanel.test.mjs
index 374782be..14e71a85 100644
--- a/apps/web/src/components/settings/SystemInfoPanel.test.mjs
+++ b/apps/web/src/components/settings/SystemInfoPanel.test.mjs
@@ -37,6 +37,19 @@ describe("system information diagnostic fields", () => {
expect(feedbackSource).toContain("clientRuntime: clientRuntimeQuery.data");
});
+ test("shows the desktop yt-dlp version and local path", () => {
+ expect(source).toContain('t("systemInfo.ytDlpVersion")');
+ expect(source).toContain('t("systemInfo.ytDlpPath")');
+ expect(source).toContain("desktopBridge!.ytDlpStatus()");
+ expect(source).toContain("ytDlpVersionValue");
+ expect(source).toContain("localOnly: true");
+ expect(source).toContain("breakAll: true");
+ expect(source).toContain("desktopAvailable");
+ expect(source).toContain('t("systemInfo.ytDlpMissing")');
+ expect(source).toContain("refetchInterval: 30_000");
+ expect(source).not.toContain('ytDlpStatus?.state === "downloading"');
+ });
+
test("includes current screen resolution", () => {
expect(source).toContain('t("systemInfo.screenResolution")');
expect(source).toContain('t("systemInfo.screenResolutionValue", parts)');
diff --git a/apps/web/src/components/settings/SystemInfoPanel.tsx b/apps/web/src/components/settings/SystemInfoPanel.tsx
index 36a7d1e7..805572b3 100644
--- a/apps/web/src/components/settings/SystemInfoPanel.tsx
+++ b/apps/web/src/components/settings/SystemInfoPanel.tsx
@@ -30,6 +30,51 @@ export type SystemInfoItem = {
colSpan?: "full" | "two" | "double-sm";
status?: "connected" | "connecting" | "failed" | "warning" | "error" | "default";
localOnly?: boolean;
+ breakAll?: boolean;
+};
+
+type YtDlpStatus = {
+ state: "idle" | "checking" | "downloading" | "ready" | "failed";
+ version: string | null;
+ path: string;
+ errorCode: string | null;
+ httpStatus: number | null;
+};
+
+const ytDlpReason = (
+ t: (key: string, options?: Record<string, string>) => string,
+ status: YtDlpStatus,
+) => {
+ if (!status.errorCode) return "";
+ if (status.errorCode === "http") {
+ return t("systemInfo.ytDlpErrors.http", { status: String(status.httpStatus ?? "") });
+ }
+ const key = `systemInfo.ytDlpErrors.${status.errorCode}`;
+ const translated = t(key);
+ return translated === key ? t("systemInfo.ytDlpFailed") : translated;
+};
+
+const ytDlpVersionValue = (
+ t: (key: string, options?: Record<string, string>) => string,
+ status: YtDlpStatus | undefined,
+) => {
+ if (!status || status.state === "idle" || status.state === "checking") {
+ return status?.version || t("systemInfo.ytDlpMissing");
+ }
+ const reason = ytDlpReason(t, status);
+ if (status.state === "downloading") {
+ return status.version
+ ? t("systemInfo.ytDlpUpdating", { version: status.version })
+ : t("systemInfo.ytDlpDownloading");
+ }
+ if (status.state === "failed") return reason || t("systemInfo.ytDlpFailed");
+ if (status.errorCode && status.version) {
+ return t("systemInfo.ytDlpUpdateFailed", {
+ version: status.version,
+ reason: reason || t("systemInfo.ytDlpFailed"),
+ });
+ }
+ return status.version || t("systemInfo.ytDlpMissing");
};
type InstanceSystemDiagnostics = Pick<InstanceHealth, "build" | "containerImageSource" | "deployment" | "deploymentVersionCreatedAt" | "migration" | "objectStorageProvider" | "storage"> & {
@@ -311,6 +356,13 @@ export const SystemInfoPanel = ({ active = true }: { active?: boolean }) => {
refetchInterval: (query) => query.state.data?.state === "available" ? 1_000 : false,
retry: 1,
});
+ const ytDlpStatusQuery = useQuery({
+ queryKey: ["desktop-yt-dlp-status"],
+ queryFn: () => desktopBridge!.ytDlpStatus(),
+ enabled: active && desktopAvailable,
+ refetchInterval: 30_000,
+ retry: 1,
+ });
useEffect(() => {
if (active) markSeen();
}, [active, markSeen]);
@@ -348,6 +400,28 @@ export const SystemInfoPanel = ({ active = true }: { active?: boolean }) => {
? syncDiagnosticsQuery.data.error + syncDiagnosticsQuery.data.conflict
: null;
+ if (desktopAvailable) {
+ const clientGroup = groups.find((group) => group.id === "client");
+ const ytDlpStatus = ytDlpStatusQuery.data;
+ clientGroup?.items.push(
+ {
+ label: t("systemInfo.ytDlpVersion"),
+ value: ytDlpStatusQuery.isError ? t("systemInfo.ytDlpFailed") : ytDlpVersionValue(t, ytDlpStatus),
+ mono: true,
+ status: ytDlpStatusQuery.isError || ytDlpStatus?.state === "failed" || (ytDlpStatus?.state === "ready" && ytDlpStatus.errorCode)
+ ? "failed"
+ : "default",
+ },
+ {
+ label: t("systemInfo.ytDlpPath"),
+ value: ytDlpStatus?.path || t("systemInfo.unknown"),
+ mono: true,
+ colSpan: "full",
+ localOnly: true,
+ breakAll: true,
+ },
+ );
+ }
groups.push({
id: "connection",
title: t("systemInfo.connectionSection"),
@@ -396,6 +470,8 @@ export const SystemInfoPanel = ({ active = true }: { active?: boolean }) => {
syncDiagnosticsQuery.data,
t,
viewportRevision,
+ ytDlpStatusQuery.data,
+ ytDlpStatusQuery.isError,
]);
const releaseTag = release ? getReleaseTagForVersion(release.version) : null;
const releaseUrl = releaseTag
@@ -586,6 +662,7 @@ export const SystemInfoPanel = ({ active = true }: { active?: boolean }) => {
className={cn(
"break-words text-xs leading-5",
item.mono ? "font-mono font-medium" : "font-sans font-medium",
+ item.breakAll && "break-all",
item.status === "failed" || item.status === "error"
? "font-semibold text-rose-600"
: item.status === "warning"
diff --git a/apps/web/src/lib/local-mirror.ts b/apps/web/src/lib/local-mirror.ts
index 6bff331c..d3e98408 100644
--- a/apps/web/src/lib/local-mirror.ts
+++ b/apps/web/src/lib/local-mirror.ts
@@ -9,6 +9,7 @@ import {
getDiagramSummary,
getInfographicSummary,
getTableSummary,
+ getVideoNoteSummary,
getNotebookDescendantIds,
resolveMemoContentDoc,
resolveMergedMemoTitle,
@@ -81,6 +82,7 @@ const toSummary = (memo: MemoDetail): MemoSummary => ({
...getDiagramSummary(memo.contentMarkdown),
...getInfographicSummary(memo.contentMarkdown),
...getTableSummary(memo.contentMarkdown),
+ ...getVideoNoteSummary(memo.contentMarkdown),
tags: memo.tags,
isPinned: memo.isPinned,
isArchived: memo.isArchived,
diff --git a/apps/web/src/lib/wechat-copy.ts b/apps/web/src/lib/wechat-copy.ts
index dbb4ce2e..6afbf6e3 100644
--- a/apps/web/src/lib/wechat-copy.ts
+++ b/apps/web/src/lib/wechat-copy.ts
@@ -91,6 +91,7 @@ const applyLegacyWeChatStyles = (
};
root.style.cssText = `${textStyle} background-color: #ffffff; word-break: break-word;`;
+ root.querySelectorAll("[data-edgeever-video-note]").forEach((element) => element.remove());
root.querySelectorAll<HTMLElement>("*").forEach((element) => {
if (element.closest("[data-ee-math]")) return;
diff --git a/apps/web/src/vite-env.d.ts b/apps/web/src/vite-env.d.ts
index 167b9093..adbfb2a3 100644
--- a/apps/web/src/vite-env.d.ts
+++ b/apps/web/src/vite-env.d.ts
@@ -60,6 +60,15 @@ interface EdgeEverDesktopBridge {
chrome: string;
dataDir: string;
}>;
+ ytDlpStatus(): Promise<{
+ state: "idle" | "checking" | "downloading" | "ready" | "failed";
+ version: string | null;
+ path: string;
+ errorCode: string | null;
+ httpStatus: number | null;
+ }>;
+ videoCookieBrowser(): Promise<import("@edgeever/shared").VideoCookieBrowser>;
+ setVideoCookieBrowser(browser: import("@edgeever/shared").VideoCookieBrowser): Promise<{ browser: import("@edgeever/shared").VideoCookieBrowser }>;
setAccountScope(accountId: string | null): Promise<{ ready: true; scope: string }>;
updateStatus(): Promise<DesktopUpdateStatus>;
checkUpdate(): Promise<DesktopUpdateStatus>;
diff --git a/bun.lock b/bun.lock
index 1a0fbe66..208b5ef7 100644
--- a/bun.lock
+++ b/bun.lock
@@ -102,10 +102,12 @@
},
"apps/desktop": {
"name": "@edgeever/desktop",
- "version": "1.92.1",
+ "version": "1.100.0",
"dependencies": {
"@agentclientprotocol/sdk": "^1.5.1",
+ "@ai-sdk/openai": "4.0.36",
"@edgeever/public-network": "workspace:*",
+ "ai": "7.0.58",
"croner": "^10.0.1",
"electron-updater": "^6.6.2",
"fflate": "0.8.3",
@@ -119,7 +121,7 @@
},
"apps/extension": {
"name": "@edgeever/extension",
- "version": "0.1.16",
+ "version": "0.1.17",
"dependencies": {
"@mixmark-io/domino": "2.2.0",
"@mozilla/readability": "^0.6.0",
@@ -332,6 +334,8 @@
"@ai-sdk/google": ["@ai-sdk/[email protected]", "", { "dependencies": { "@ai-sdk/provider": "4.0.7", "@ai-sdk/provider-utils": "5.0.25" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-+mRx7UBZn9PkJ4J6YXowaRZKMZYa290cknVqqOw/roZaDg186IUOLn9JHNQkvgaj91/MLW1AZNESy1ZD2yXDCg=="],
+ "@ai-sdk/openai": ["@ai-sdk/[email protected]", "", { "dependencies": { "@ai-sdk/provider": "4.0.7", "@ai-sdk/provider-utils": "5.0.25" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-wHJNArBdjJPXb8GXcA+FslbRt+7qIE1KoHSAVi+CeBFidinVrTVBZKFMJz3mNZMj8YILBMl/VIvTD/oGFjX6/g=="],
+
"@ai-sdk/openai-compatible": ["@ai-sdk/[email protected]", "", { "dependencies": { "@ai-sdk/provider": "4.0.7", "@ai-sdk/provider-utils": "5.0.25" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-icGSoBDbFKZotUwehg7h/JjtD7arweeKfeDcsT9UsPY+YdwiT94JciD59bqAOAdNA3wlS+klW2vsaVLxTUUhbA=="],
"@ai-sdk/provider": ["@ai-sdk/[email protected]", "", { "dependencies": { "json-schema": "^0.4.0" } }, "sha512-6or44XprPzKbr8zkmzosowSE0pxkvJcoojBL+mCZvPUt3kvXp3XSNqeVun9golb1acEfSo6yaEBRT18h2VU+1Q=="],
diff --git a/crates/desktop-sidecar/src/note_summary.rs b/crates/desktop-sidecar/src/note_summary.rs
index 237a8aa3..832b1906 100644
--- a/crates/desktop-sidecar/src/note_summary.rs
+++ b/crates/desktop-sidecar/src/note_summary.rs
@@ -49,6 +49,7 @@ pub(crate) fn note_list_metadata(markdown: &str) -> Value {
}
}
metadata.insert("infographic".to_owned(), json!(is_infographic(markdown)));
+ metadata.insert("videoNote".to_owned(), json!(is_video_note(markdown)));
match table_preview(markdown) {
Some(preview) => {
metadata.insert("structuredTable".to_owned(), json!(true));
@@ -68,6 +69,10 @@ pub(crate) fn note_list_metadata(markdown: &str) -> Value {
Value::Object(metadata)
}
+fn is_video_note(markdown: &str) -> bool {
+ markdown.contains("<!-- edgeever-video-v1:")
+}
+
fn is_infographic(markdown: &str) -> bool {
let Some(payload) = infographic_payload(markdown) else {
return false;
@@ -578,10 +583,20 @@ mod tests {
assert!(metadata.get("diagramPreview").is_none(), "{markdown}");
assert_eq!(metadata["infographic"], false, "{markdown}");
assert_eq!(metadata["structuredTable"], false, "{markdown}");
+ assert_eq!(metadata["videoNote"], false, "{markdown}");
assert!(metadata.get("tablePreview").is_none(), "{markdown}");
}
}
+ #[test]
+ fn video_note_marker_is_recognized_without_reading_the_prose() {
+ assert_eq!(
+ note_list_metadata("这一集没有可用字幕\n\n<!-- edgeever-video-v1:abc -->")["videoNote"],
+ true
+ );
+ assert_eq!(note_list_metadata("ordinary note")["videoNote"], false);
+ }
+
#[test]
fn infographic_marker_from_js_base64_is_recognized_with_history() {
assert_eq!(
diff --git a/docs/video-clip-spec.zh-CN.md b/docs/video-clip-spec.zh-CN.md
index 543f8146..d4c525a4 100644
--- a/docs/video-clip-spec.zh-CN.md
+++ b/docs/video-clip-spec.zh-CN.md
@@ -1,266 +1,48 @@
-# EdgeEver 网页剪藏:YouTube 与哔哩哔哩视频笔记
+# 视频笔记:从保存到字幕
-用户在 YouTube 或哔哩哔哩的视频播放页点一次,把当前这一集保存成 EdgeEver 笔记。笔记带来源、可点击的时间戳、平台字幕实录;工作区已经配置默认模型时,再补一句话总结和分段大纲。字幕在用户正在看的页面里读取。插件不下载音视频,也不自己选择模型供应商。
+用户在 YouTube 或哔哩哔哩的播放页点一次「保存视频笔记到 EdgeEver」。笔记马上出现。字幕从哪来,取决于这一页当时有没有平台字幕。
-状态:第一期已实现,扩展版本 0.1.17。商店包尚未提交。合入前仍要用真实播放页点一次保存,确认时间戳和现有右键命令。
+只认这两类页面:YouTube 的普通视频和 Shorts,哔哩哔哩的普通视频(分 P 以地址里的 `p` 为准,没有就存第 1 P)。直播、番剧、课程和其他站点不创建笔记。
-## 第一期
+## 保存的那一刻
-第一期只做这两类播放页:
+插件读用户正在看的这一集:标题、作者、来源、封面,以及页面里已经有的字幕。读不到这一集时提示「没有读到这个视频」,不写空笔记。
-- YouTube:`youtube.com`、`www.youtube.com`、`m.youtube.com` 的 `/watch` 与 `/shorts/{id}`,以及 `youtu.be/{id}`。
-- 哔哩哔哩:`bilibili.com`、`www.bilibili.com`、`m.bilibili.com` 的 `/video/BV…` 与 `/video/av…`。分 P 以 URL 的 `p` 为准,没有 `p` 时保存第 1 P。
+笔记先保存。用户不用等总结,也不用等后面的语音识别。桌面端没开着也一样。
-规范化后的来源链接只保留视频和分 P。播放列表、电台和 `t` 参数不写入来源链接;时间戳链接单独生成。
+保存下来的视频笔记和普通笔记不一样。在笔记列表里右键它,菜单里有「提取字幕」。普通笔记没有这一项。
-直播、首播、尚未开播的预告、番剧、影视、课程页,以及 `music.youtube.com`、嵌入式播放器和其他站点,第一期提示不支持,不创建笔记。
+## 这一页有字幕
-## 本期不做
+字幕直接来自 YouTube 或哔哩哔哩,带可点回原片的时间戳,收在笔记底部的「字幕实录」里。
-- 不从音视频流做语音识别,不把音频送到 Groq、Gemini、Cloudflare Workers AI 或任何写死的供应商。
-- 插件不保存模型 API Key,不调用 `/api/v1/plugins/ai/generate/prepare`。该接口会把供应商凭据返回给调用方。
-- 不注入常驻 content script。播放页的地址就能确定视频,不需要像时间线那样记住指针下的条目。
-- 不增加清单里的 `commands` 快捷键。
-- 不承诺秒级完成,也不把模型费用写进产品文案。
-- 不为了这一期接入 Vimeo、播客、小红书或 X 的视频。
+工作区已经配好默认聊天模型,并且剪藏用的 Token 允许调用它时,再在实录前面补三块:一句话总结、分段大纲、几条要点。有章节就用章节当大纲。模型没配、没有权限、超时或结果不可用时,总结那几块空着,实录仍然在。
-## 触发
+保存时不下载音频。列表里仍可以再点「提取字幕」,那是再听一遍音频,新的实录接在笔记后面。
-右键菜单新增一条「保存视频笔记到 EdgeEver」。它只出现在上面两类播放页,上下文是 `page` 和 `video`。选中文字仍走现有的选区命令,图片仍走现有的图片命令。Chrome 和 Firefox 会在同一页面同时出现多条本扩展菜单时,把它们收进子菜单。`registerClipMenus` 会清空并重建全部菜单,新条目的 `documentUrlPatterns` 必须与选区、图片、X、GitHub、小红书、知乎、Reddit 互不重叠。
+## 这一页没有字幕
-工具栏弹窗发给后台的 `captureCurrentPage`,在当前标签是受支持的播放页时走同一条视频保存。其他网页仍按现在的正文提取保存。
+笔记仍然保存:标题、作者、来源,以及一句「这一集没有可用字幕」。不调用聊天模型,也不会自己开始识别。插件到这里就结束。
-文案放进 `apps/extension/public/_locales/` 的 `en`、`zh_CN`、`ja`。
+要字幕时,在笔记列表右键这条笔记,选「提取字幕」。之后由已登录的桌面端接着做,仍然是同一条笔记:
-## 页面内读取
+1. 语音识别没开启,或本机下载工具还没准备好:笔记保持原样。这次请求留着,等以后条件齐了再试。
+2. 桌面端没开:请求留到下次打开。只使用浏览器、没有桌面端的人,只能停在这句「没有可用字幕」。
+3. 语音识别已开启,下载工具也就绪:桌面端下载这一集的音频,交给用户配置的语音识别接口。下载默认带上这台电脑上 Chrome 的登录状态,所以会员或需要登录的视频也能下,只要那个浏览器里已经登录。成功后,用字幕实录换掉那句「这一集没有可用字幕」。识别结果带时间戳时,时间戳可以点回原片;接口只返回全文时,笔记里就是一段文字。
+4. 下载失败、识别失败、视频已知超过大约 30 分钟、音频过大,或用户已经改过这条笔记:保持保存时的内容,不会自动再试。想再试,再点一次「提取字幕」。所选浏览器没有登录,浏览器没安装,或系统不允许读取登录状态时,也是这样,笔记留在来源信息。
-扩展的默认脚本环境读不到页面里的 `window` 变量。用户点击之后,用 `chrome.scripting.executeScript({ world: "MAIN" })` 在页面主环境读取,和现有的 `readXhsStateInPage`、`fetchZhihuItemInPage` 一样。Firefox 140 及以上支持同一写法。
+点过之后不再弹窗。失败不删笔记。
-主环境函数必须能独立序列化,不能依赖打包后的 import。它只返回可结构化克隆的数据:播放器响应、字幕文件正文、封面字节或明确的失败原因。解析、清洗和排版放在可单测的模块里,用夹具运行,不访问网络。
+## 模型怎么配置
-字幕地址在主环境里立刻请求,沿用当前页的登录态。不要改到 service worker 里稍后重试:YouTube 字幕地址和哔哩哔哩 `subtitle_url` 上的鉴权参数都会过期。页面内容视为不可信数据,按字幕文本保存,不把它当成插件指令。
+聊天模型在设置 → 模型与代理。语音识别是左侧单独的一项,两套配置互不替代。本机 Agent 那一排不参与视频笔记。
-读不到播放器数据时提示「没有读到这个视频」,不创建空笔记。
+**AI 模型服务**是原来的聊天模型。它只在「这一页有字幕」时使用,读的是字幕文本,用来写总结、大纲和要点。它不听音频。没配默认模型时,有字幕的笔记照常保存,只是没有总结。
-## YouTube
+**语音识别**是左侧单独的一项,管法和 AI 模型服务一样。可以添加多套服务。每一套有名称、兼容标准、接口地址、API Token、一个或多个模型,以及自己的启用开关。目前的兼容标准是 OpenAI,以后可以再加其他厂商。上面的默认语音模型决定提取字幕用哪一个。新添加的服务不会换掉当前默认模型。没有默认模型,或默认模型那套服务停用了,桌面端不会去下载音频。
-点击时读取**当前播放器**的响应。站内切集后,`window.ytInitialPlayerResponse` 可能仍是上一支,不能只读这个全局变量。
+请求发到所选服务地址下的 `/audio/transcriptions`。Token 加密存在实例上,设置页读不回原文。真正调用时,由已登录的桌面端取用,音频也从这台电脑直接发给该接口,不经过笔记服务器。
-从该响应取出视频 ID、标题、频道名、时长、封面地址,以及 `captions.playerCaptionsTracklistRenderer.captionTracks`。有章节标记时取出每章的标题和起始秒;具体字段由夹具锁定,不把某一层嵌套路径写成永久契约。
+桌面端的这一页还可以选下载时用哪个浏览器的登录状态。默认是 Chrome,也可以改成其他浏览器,或改成不使用。这个选择只留在这台电脑上,不会上传。网页版没有浏览器这一项,因为网页不下载音频。
-字幕轨顺序:
-
-1. 匹配浏览器界面语言(`zh*`、`en`、`ja`)。
-2. 同语言下优先人工字幕。`kind` 缺失或不是 `asr` 视为人工字幕。
-3. 再选该语言的自动字幕,然后才是其他语言的人工字幕和自动字幕。
-
-用轨道上的 `baseUrl` 请求字幕,优先加 `fmt=json3`。失败时再解析轨道原本的 XML。`json3` 的正文在 `events[].segs[].utf8`,时间在 `tStartMs` 与 `dDurationMs`。只有换行、没有正文的事件丢掉。
-
-对外时间戳:
-
-- 普通视频:`https://www.youtube.com/watch?v={id}&t={seconds}s`
-- Shorts:`https://www.youtube.com/shorts/{id}?t={seconds}`
-
-`seconds` 为非负整数。
-
-## 哔哩哔哩
-
-元数据和分 P 从当前页状态读取:`bvid`、`aid`、标题、封面、UP 主,以及 `pages` 里的 `cid`、`page`、`part`、`duration`。当前 P 来自 URL 的 `p`;没有该参数时为第 1 P。客户端切 P 后以点击时的页面状态为准。
-
-字幕列表以页面主环境里签名后的 `https://api.bilibili.com/x/player/wbi/v2` 为准,请求带当前页 Cookie。未签名的 `/x/player/v2` 不作为契约。页面状态里如果已经有字幕列表,可以作为同一解析器的另一路输入。签名使用页面上已有的 WBI 材料,在主环境内完成。
-
-字幕项使用 `lan`、`lan_doc`、`subtitle_url`、`type`、`ai_type`、`ai_status`。不读取 `is_machine`。选择顺序与 YouTube 相同:先匹配界面语言,`lan` 不以 `ai-` 开头的视为人工字幕,`ai-zh` 这类轨道视为平台自动字幕。`subtitle_url` 缺协议时补 `https:`,并立刻请求。正文使用 `body[].from`、`body[].to`、`body[].content`,单位是秒。
-
-播放器响应里的 `view_points` 在同时具备起始秒和标题时当作章节。
-
-对外时间戳:`https://www.bilibili.com/video/{bvid}?t={seconds}`。多于 1 P 时加上 `p={page}`。
-
-## 数据模型
-
-```typescript
-export interface TranscriptCue {
- start: number; // 秒
- end: number;
- text: string;
-}
-
-export interface VideoChapter {
- start: number;
- title: string;
-}
-
-export type SubtitleOrigin = "creator" | "platform_auto";
-
-export interface VideoCapture {
- platform: "youtube" | "bilibili";
- videoId: string;
- partIndex?: number;
- partTitle?: string;
- title: string;
- author: string;
- authorUrl?: string;
- duration: number;
- sourceUrl: string;
- cues: TranscriptCue[];
- subtitleOrigin?: SubtitleOrigin;
- chapters: VideoChapter[];
- thumbnail?: { bytes: Uint8Array; mimeType: string };
-}
-
-export interface VideoOutline {
- tldr: string;
- sections: { start: number; text: string }[];
- takeaways: string[];
-}
-```
-
-清洗字幕时解码 HTML 实体、合并空白、丢掉空句。发给模型的输入再把相邻字幕收成大约 30–60 秒一块,并保留每块的起始秒。笔记里的实录仍按清洗后的字幕逐条保存,避免模型输入的粗分块变成用户看到的全文。
-
-## 笔记正文
-
-笔记标题用视频标题,截断到创建接口的 160 字上限。分 P 子标题写在来源信息里。笔记本用现有的 `notebookForClip`。标签只加 `web-clip`。
-
-封面只有在主环境拿到图片字节时才保存,复用现有图片笔记的资源上传。Markdown 使用本地资源地址:
-
-```markdown
-![封面](/api/v1/resources/{resourceId}/blob)
-```
-
-拿不到字节,或 Token 没有 `write:resources` 时,省略封面,笔记照常创建。不把 `hdslb.com`、`ytimg.com` 或其他外链图写进正文。哔哩哔哩图床校验来源页,外链会在笔记里裂开。
-
-正文由代码组装。模型不输出 Markdown,也不回写实录。标题和字段名走扩展的界面语言。下面是简体中文界面下、总结成功时的形态:
-
-```markdown
-# 打造第二大脑:从零构建个人知识库系统
-
-> **来源**:[影视飓风 - 打造第二大脑:从零构建个人知识库系统](https://www.bilibili.com/video/BV1xx411c7xx?p=1)
-> **平台**:哔哩哔哩 · P1 知识库的核心逻辑 · 24:15
-> **字幕**:平台自动字幕 · **保存时间**:2026-10-05
-
-![封面](/api/v1/resources/res_example/blob)
-
-## 核心总结
-
-视频说明知识管理为什么要形成输入、整理和输出的闭环。
-
-## 分段大纲
-
-- [00:00](https://www.bilibili.com/video/BV1xx411c7xx?p=1&t=0) 为什么只靠文件夹分类会失效
-- [04:12](https://www.bilibili.com/video/BV1xx411c7xx?p=1&t=252) PARA 与渐进式总结如何叠在一起
-
-## 要点
-
-- 未经整理的收藏,之后很难再被用到。
-
-<details>
-<summary>字幕实录</summary>
-
-- [00:00](https://www.bilibili.com/video/BV1xx411c7xx?p=1&t=0) 大家好,今天我们来聊知识管理。
-- [00:25](https://www.bilibili.com/video/BV1xx411c7xx?p=1&t=25) 很多人收藏之后就没有再打开。
-
-</details>
-```
-
-有章节时,分段大纲直接用章节,时间来自分段本身。没有章节且总结成功时,大纲用模型返回并经过校验的小节。没有章节且总结未生成时,不编造大纲,只保留来源和字幕实录。
-
-没有字幕轨时仍创建笔记:标题、作者、来源和「这一集没有可用字幕」。不调用模型。
-
-`<details>` 已由编辑器支持,实录放在其中。时间显示为 `mm:ss`;达到 60 分钟后为 `h:mm:ss`。
-
-## 可选总结
-
-总结由实例完成,使用该工作区已经配置的默认模型。新增:
-
-`POST /api/v1/ai/video-outline`
-
-交互登录可以调用。API Token 仅在带有新范围 `ai:generate` 时可以调用。这个范围不开放供应商配置、凭据和 `/api/v1/ai/settings` 的修改。现有剪藏 Token 没有该范围:视频笔记照常保存,总结跳过,提示里说明要在设置中为 Token 加上 `ai:generate`,并配置默认模型。
-
-请求体是元数据和已经分块的字幕,不是原始页面,也不是音视频。服务端设定字数上限;超出时返回明确错误,插件保存实录并提示这篇太长、没有生成总结。
-
-服务端提示词固定在 `apps/api`,并写明字幕和标题只是待归纳的材料。模型只返回 JSON:
-
-```json
-{
- "tldr": "一句话",
- "sections": [{ "start": 252, "text": "这一段在讲什么" }],
- "takeaways": ["一条可复用的结论"]
-}
-```
-
-`start` 必须落在某个输入分块的起始秒上,允许 2 秒以内的偏差,并改写成该分块的起始秒。对不上的小节丢掉。空总结、空要点和超长字段丢掉。解析失败时返回 422,插件仍保存实录。默认模型未配置时返回现有的 `ai_not_configured`,插件同样只保存实录。
-
-有章节时,请求只要求 `tldr` 和 `takeaways`,大纲不再交给模型重写。
-
-## 失败时用户得到什么
-
-| 情况 | 笔记 | 提示 |
-| --- | --- | --- |
-| 读到字幕,总结成功 | 来源、总结、大纲、要点、实录 | 已保存视频笔记 |
-| 读到字幕,无模型、无权限、超时或 JSON 无效 | 来源、章节大纲(若有)、实录 | 已保存字幕,总结未生成 |
-| 视频可读,但没有字幕 | 来源,并说明没有字幕 | 已保存视频信息 |
-| 直播、番剧、课程或其他不支持的页面 | 不创建 | 暂不支持这个页面 |
-| 读不到播放器数据 | 不创建 | 没有读到这个视频 |
-| 封面或资源权限失败 | 不含封面的笔记 | 与上表相同,不另报失败 |
-
-保存动作在提示出现前保持一条路径,避免连点叠出多次请求。重复保存仍会新建笔记,与现有剪藏一致。
-
-## 代码与测试
-
-```
-apps/extension/src/
-├── video/
-│ ├── types.ts
-│ ├── patterns.ts
-│ ├── transcript.ts # 清洗、分块、时间格式
-│ ├── youtube.ts # 地址识别、播放器 JSON 解析、时间戳
-│ ├── bilibili.ts # 地址识别、分 P、字幕 JSON、时间戳
-│ ├── video-note.ts # 组装笔记、决定是否请求总结
-│ ├── read-youtube-in-page.ts # 主环境读取,单独序列化
-│ └── read-bilibili-in-page.ts
-├── background.ts # 菜单、MAIN 世界读取、创建笔记
-apps/api/src/video-outline.ts # POST /api/v1/ai/video-outline
-```
-
-页面主环境读取函数放在扩展源码里,通过 `executeScript` 的 `func` 注入。解析函数保持纯函数,测试不打开浏览器。
-
-测试至少覆盖:
-
-- YouTube:`json3`、人工轨与 `asr`、Shorts 链接、过期全局变量不能覆盖当前播放器响应。
-- 哔哩哔哩:分 P、`ai-zh` 与人工轨、协议相对的字幕地址、`view_points`。
-- Markdown:章节大纲、非法 `start` 被丢弃、实录在 `<details>` 内、正文不含图床外链。
-- 菜单:新条目的 URL 模式与现有命令不相交。
-- 接口:无 `ai:generate` 的 Token 得到 403;未配置模型得到 `ai_not_configured`;合法 JSON 被规范化。插件在 403、409、422 和网络失败时仍能交出实录笔记。
-
-夹具使用脱敏的播放器 JSON,不把真实 Cookie 或字幕地址上的鉴权参数放进仓库。
-
-## 商店与权限
-
-实现阶段不需要新的主机权限。读取和字幕请求发生在用户点击之后的页面主环境,实例请求继续走用户已经授予的实例地址。
-
-提交商店前要提高 `apps/extension/package.json` 的版本。当前已上传版本不能重复提交。商店说明只加一行:可以把 YouTube 或哔哩哔哩播放页保存为视频笔记。不要在首句堆叠站点名。
-
-同步这些说明:
-
-- `apps/extension/STORE_LISTING.md`
-- `apps/extension/FIREFOX_STORE_LISTING.md`
-- `apps/extension/README.md`
-- 权限用途:新菜单只在受支持的播放页、用户点击后运行。
-- 数据披露:页面内容发给用户配置的 EdgeEver 实例。Token 带有 `ai:generate` 且工作区已配置默认模型时,实例把字幕文本发给该模型供应商。插件不把页面或音频发给其他第三方。
-
-产品发布流程不上传扩展。商店包仍由单独的 Submit Web Clipper 提交。
-
-## 以后
-
-新的视频站点沿用同一条保存路径:主环境返回 `VideoCapture`,纯函数解析,代码排版。那之前不为想象中的站点加抽象层。
-
-语音识别若以后要做,另写方案。它至少要同时满足:用户在这一次保存里明确同意,音频只发给用户自己配置且支持音频的模型,失败时保留已经写好的笔记,并且不依赖某家云厂商的独占接口。
-
-## 风险与验证
-
-价值是把正在看的一集收成可检索、可跳回原片的笔记。影响范围是剪藏菜单、弹窗在播放页上的行为、一个新的只读生成接口和 Token 范围。不改数据库迁移、安装器和自动升级。
-
-最坏情况是菜单重建让现有保存命令折叠或消失,解析失败却写出空笔记,或者新接口把供应商凭据返回给插件。实现时用现有菜单测试锁住 URL 模式,没有字幕正文就不写实录,接口响应里不包含凭据。
-
-回滚不依赖数据迁移。扩展版本独立于产品 Release;有问题的包停在商店审核之前即可。新接口是追加的,旧客户端不调用它。
-
-合入前用真实页面各点一次保存:普通 YouTube 视频、Shorts、站内切到下一支之后的视频、哔哩哔哩单 P、分 P、有人工字幕、只有自动字幕、没有字幕、未登录。确认笔记出现在默认笔记本,时间戳能打开对应秒数,现有图片和选区命令仍留在右键菜单第一级。
+接口要兼容 OpenAI 的语音转写:用 Bearer Token,提交音频文件和模型 ID。聊天模型的地址不能填在这里。
diff --git a/migrations/0060_ai_transcription_settings.sql b/migrations/0060_ai_transcription_settings.sql
new file mode 100644
index 00000000..8ad00203
--- /dev/null
+++ b/migrations/0060_ai_transcription_settings.sql
@@ -0,0 +1,13 @@
+PRAGMA foreign_keys = ON;
+
+CREATE TABLE ai_transcription_settings (
+ workspace_id TEXT PRIMARY KEY,
+ base_url TEXT NOT NULL DEFAULT '',
+ model_id TEXT NOT NULL DEFAULT '',
+ api_key_encrypted TEXT NOT NULL DEFAULT '',
+ created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+ updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+ FOREIGN KEY (workspace_id) REFERENCES workspaces(id)
+ ON UPDATE CASCADE
+ ON DELETE CASCADE
+);
diff --git a/migrations/0061_video_transcript_jobs.sql b/migrations/0061_video_transcript_jobs.sql
new file mode 100644
index 00000000..0a44db5b
--- /dev/null
+++ b/migrations/0061_video_transcript_jobs.sql
@@ -0,0 +1,23 @@
+PRAGMA foreign_keys = ON;
+
+CREATE TABLE video_transcript_jobs (
+ memo_id TEXT PRIMARY KEY,
+ workspace_id TEXT NOT NULL,
+ platform TEXT NOT NULL CHECK (platform IN ('youtube', 'bilibili')),
+ video_id TEXT NOT NULL,
+ source_url TEXT NOT NULL,
+ duration_seconds INTEGER NOT NULL DEFAULT 0,
+ placeholder_text TEXT NOT NULL,
+ transcript_label TEXT NOT NULL,
+ content_hash TEXT NOT NULL,
+ status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'transcribing', 'ready', 'failed')),
+ claimed_at TEXT,
+ error_code TEXT,
+ created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+ updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+ FOREIGN KEY (workspace_id) REFERENCES workspaces(id) ON UPDATE CASCADE ON DELETE CASCADE,
+ FOREIGN KEY (memo_id) REFERENCES memos(id) ON UPDATE CASCADE ON DELETE CASCADE
+);
+
+CREATE INDEX idx_video_transcript_jobs_workspace_status
+ ON video_transcript_jobs (workspace_id, status, created_at);
diff --git a/migrations/0062_ai_transcription_providers.sql b/migrations/0062_ai_transcription_providers.sql
new file mode 100644
index 00000000..e478bfef
--- /dev/null
+++ b/migrations/0062_ai_transcription_providers.sql
@@ -0,0 +1,119 @@
+-- Copy each workspace's single speech endpoint into its own service.
+-- The old ai_transcription_settings row stays in place.
+PRAGMA foreign_keys = ON;
+
+CREATE TABLE ai_transcription_providers (
+ id TEXT PRIMARY KEY,
+ workspace_id TEXT NOT NULL,
+ display_name TEXT NOT NULL CHECK (length(trim(display_name)) > 0),
+ base_url TEXT NOT NULL CHECK (length(trim(base_url)) > 0),
+ api_key_encrypted TEXT NOT NULL DEFAULT '',
+ is_enabled INTEGER NOT NULL DEFAULT 1 CHECK (is_enabled IN (0, 1)),
+ created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+ updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+ FOREIGN KEY (workspace_id) REFERENCES workspaces(id)
+ ON UPDATE CASCADE
+ ON DELETE CASCADE
+);
+
+CREATE INDEX idx_ai_transcription_providers_workspace
+ ON ai_transcription_providers(workspace_id, is_enabled, created_at);
+
+CREATE TABLE ai_transcription_models (
+ id TEXT PRIMARY KEY,
+ provider_id TEXT NOT NULL,
+ model_id TEXT NOT NULL CHECK (length(trim(model_id)) > 0),
+ display_name TEXT NOT NULL CHECK (length(trim(display_name)) > 0),
+ created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+ updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+ FOREIGN KEY (provider_id) REFERENCES ai_transcription_providers(id)
+ ON UPDATE CASCADE
+ ON DELETE CASCADE,
+ UNIQUE (provider_id, model_id)
+);
+
+CREATE INDEX idx_ai_transcription_models_provider
+ ON ai_transcription_models(provider_id, created_at);
+
+CREATE TABLE ai_transcription_workspace_settings (
+ workspace_id TEXT PRIMARY KEY,
+ default_model_id TEXT,
+ created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+ updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+ FOREIGN KEY (workspace_id) REFERENCES workspaces(id)
+ ON UPDATE CASCADE
+ ON DELETE CASCADE,
+ FOREIGN KEY (default_model_id) REFERENCES ai_transcription_models(id)
+ ON UPDATE CASCADE
+ ON DELETE SET NULL
+);
+
+WITH source AS (
+ SELECT
+ workspace_id,
+ rtrim(trim(base_url), '/') AS base_url,
+ trim(model_id) AS model_id,
+ api_key_encrypted,
+ created_at,
+ updated_at
+ FROM ai_transcription_settings
+ WHERE length(trim(base_url)) > 0
+),
+named AS (
+ SELECT
+ *,
+ CASE
+ WHEN lower(base_url) LIKE 'https://%' THEN substr(base_url, 9)
+ WHEN lower(base_url) LIKE 'http://%' THEN substr(base_url, 8)
+ ELSE base_url
+ END AS host_and_path
+ FROM source
+)
+INSERT INTO ai_transcription_providers (
+ id, workspace_id, display_name, base_url, api_key_encrypted,
+ is_enabled, created_at, updated_at
+)
+SELECT
+ 'atp_' || workspace_id,
+ workspace_id,
+ substr(
+ CASE
+ WHEN instr(host_and_path, '/') > 1 THEN substr(host_and_path, 1, instr(host_and_path, '/') - 1)
+ WHEN length(host_and_path) > 0 THEN host_and_path
+ ELSE 'Speech'
+ END,
+ 1,
+ 80
+ ),
+ base_url,
+ api_key_encrypted,
+ 1,
+ created_at,
+ updated_at
+FROM named;
+
+INSERT INTO ai_transcription_models (
+ id, provider_id, model_id, display_name, created_at, updated_at
+)
+SELECT
+ 'atm_' || workspace_id,
+ 'atp_' || workspace_id,
+ trim(model_id),
+ substr(trim(model_id), 1, 80),
+ created_at,
+ updated_at
+FROM ai_transcription_settings
+WHERE length(trim(base_url)) > 0
+ AND length(trim(model_id)) > 0;
+
+INSERT INTO ai_transcription_workspace_settings (
+ workspace_id, default_model_id, created_at, updated_at
+)
+SELECT
+ workspace_id,
+ 'atm_' || workspace_id,
+ created_at,
+ updated_at
+FROM ai_transcription_settings
+WHERE length(trim(base_url)) > 0
+ AND length(trim(model_id)) > 0;
diff --git a/migrations/0063_ai_transcription_provider_standard.sql b/migrations/0063_ai_transcription_provider_standard.sql
new file mode 100644
index 00000000..0f0d36e9
--- /dev/null
+++ b/migrations/0063_ai_transcription_provider_standard.sql
@@ -0,0 +1,6 @@
+-- Each speech service records the compatibility standard it speaks.
+-- Rows copied by 0062 are OpenAI-compatible. Another standard needs a later migration.
+PRAGMA foreign_keys = ON;
+
+ALTER TABLE ai_transcription_providers ADD COLUMN provider TEXT NOT NULL DEFAULT 'openai-compatible'
+ CHECK (provider IN ('openai-compatible'));
diff --git a/package.json b/package.json
index 299289b7..45d073ce 100644
--- a/package.json
+++ b/package.json
@@ -64,7 +64,7 @@
"publish:stores": "bun scripts/store-delivery.mjs",
"publish:extension": "bun scripts/publish-web-clipper.mjs",
"test:desktop:sidecar": "bun scripts/test-desktop-sidecar.mjs",
- "test:desktop": "bun test apps/desktop/src/main/account-scope.test.mjs apps/desktop/src/main/app-protocol.test.mjs apps/desktop/src/main/child-process-start.test.mjs apps/desktop/src/main/clipboard-write.test.mjs apps/desktop/src/main/desktop-diagnostics.test.mjs apps/desktop/src/main/desktop-menu.test.mjs apps/desktop/src/main/desktop-update-flow.test.mjs apps/desktop/src/main/diagnostic-log.test.mjs apps/desktop/src/main/file-association.test.mjs apps/desktop/src/main/wechat-chat-archive.test.mjs apps/desktop/src/main/wechat-share-import.test.mjs apps/desktop/src/main/share-extension-registration.test.mjs apps/desktop/src/main/windows-share-menu.test.mjs apps/desktop/src/main/file-permissions.test.mjs apps/desktop/src/main/installation-location.test.mjs apps/desktop/src/main/local-data-reset.test.mjs apps/desktop/src/main/ai-direct.test.mjs apps/desktop/src/main/plugin-public-network.test.mjs apps/desktop/src/main/renderer-recovery.test.mjs apps/desktop/src/main/renderer-hibernate.test.mjs apps/desktop/src/main/renderer-startup-guard.test.mjs apps/desktop/src/main/renderer-storage-migration.test.mjs apps/desktop/src/main/resource-request.test.mjs apps/desktop/src/main/resource-url.test.mjs apps/desktop/src/main/scheduled-task-scheduler.test.mjs apps/desktop/src/main/screenshot-capture.test.mjs apps/desktop/src/main/staged-resource.test.mjs apps/desktop/src/main/staged-resource-alias.test.mjs apps/desktop/src/main/tray-icon.test.mjs apps/desktop/src/main/user-data-directory.test.mjs apps/desktop/src/main/window-open-policy.test.mjs apps/desktop/src/main/window-visibility.test.mjs apps/desktop/src/main/windows-update-trust.test.mjs apps/web/src/lib/api.test.mjs apps/web/src/lib/app-page-path.test.mjs apps/web/src/lib/clipboard.test.mjs apps/web/src/lib/desktop-renderer-ready.test.mjs apps/web/src/lib/desktop-workspace-restore.test.mjs apps/web/src/lib/desktop-repository.test.mjs apps/web/src/lib/desktop-resources.test.mjs apps/web/src/lib/desktop-acp.test.mjs apps/web/src/lib/desktop-sync.test.mjs apps/web/src/lib/local-mirror.test.mjs apps/web/src/lib/repository.test.mjs apps/web/src/lib/runtime.test.mjs apps/web/src/lib/screenshot-import.test.mjs apps/web/src/lib/wechat-chat-import.test.mjs apps/web/src/lib/shared-file-import.test.mjs apps/web/src/lib/sync-queue.test.mjs && bun test --cwd apps/desktop src/main/acp-adapter-manager.test.mjs src/main/acp-host.test.mjs src/main/antigravity-proxy.test.mjs src/main/acp-mcp-bridge.test.mjs && bun run test:desktop:sidecar",
+ "test:desktop": "bun test apps/desktop/src/main/account-scope.test.mjs apps/desktop/src/main/app-protocol.test.mjs apps/desktop/src/main/child-process-start.test.mjs apps/desktop/src/main/clipboard-write.test.mjs apps/desktop/src/main/desktop-diagnostics.test.mjs apps/desktop/src/main/desktop-menu.test.mjs apps/desktop/src/main/desktop-update-flow.test.mjs apps/desktop/src/main/diagnostic-log.test.mjs apps/desktop/src/main/file-association.test.mjs apps/desktop/src/main/wechat-chat-archive.test.mjs apps/desktop/src/main/wechat-share-import.test.mjs apps/desktop/src/main/share-extension-registration.test.mjs apps/desktop/src/main/windows-share-menu.test.mjs apps/desktop/src/main/file-permissions.test.mjs apps/desktop/src/main/installation-location.test.mjs apps/desktop/src/main/local-data-reset.test.mjs apps/desktop/src/main/ai-direct.test.mjs apps/desktop/src/main/plugin-public-network.test.mjs apps/desktop/src/main/renderer-recovery.test.mjs apps/desktop/src/main/renderer-hibernate.test.mjs apps/desktop/src/main/renderer-startup-guard.test.mjs apps/desktop/src/main/renderer-storage-migration.test.mjs apps/desktop/src/main/resource-request.test.mjs apps/desktop/src/main/resource-url.test.mjs apps/desktop/src/main/scheduled-task-scheduler.test.mjs apps/desktop/src/main/screenshot-capture.test.mjs apps/desktop/src/main/staged-resource.test.mjs apps/desktop/src/main/staged-resource-alias.test.mjs apps/desktop/src/main/tray-icon.test.mjs apps/desktop/src/main/user-data-directory.test.mjs apps/desktop/src/main/yt-dlp-tool.test.mjs apps/desktop/src/main/speech-transcription.test.mjs apps/desktop/src/main/window-open-policy.test.mjs apps/desktop/src/main/window-visibility.test.mjs apps/desktop/src/main/windows-update-trust.test.mjs apps/web/src/lib/api.test.mjs apps/web/src/lib/app-page-path.test.mjs apps/web/src/lib/clipboard.test.mjs apps/web/src/lib/desktop-renderer-ready.test.mjs apps/web/src/lib/desktop-workspace-restore.test.mjs apps/web/src/lib/desktop-repository.test.mjs apps/web/src/lib/desktop-resources.test.mjs apps/web/src/lib/desktop-acp.test.mjs apps/web/src/lib/desktop-sync.test.mjs apps/web/src/lib/local-mirror.test.mjs apps/web/src/lib/repository.test.mjs apps/web/src/lib/runtime.test.mjs apps/web/src/lib/screenshot-import.test.mjs apps/web/src/lib/wechat-chat-import.test.mjs apps/web/src/lib/shared-file-import.test.mjs apps/web/src/lib/sync-queue.test.mjs && bun test --cwd apps/desktop src/main/acp-adapter-manager.test.mjs src/main/acp-host.test.mjs src/main/antigravity-proxy.test.mjs src/main/acp-mcp-bridge.test.mjs && bun run test:desktop:sidecar",
"verify:desktop-renderer": "bun scripts/verify-desktop-renderer.mjs",
"verify:renderer-origin-migration": "bun run --cwd apps/desktop verify-origin-migration",
"verify:desktop-cross-version-startup": "bun scripts/verify-desktop-cross-version-startup.mjs",
diff --git a/packages/client/src/index.ts b/packages/client/src/index.ts
index 7bbb28f0..95a10141 100644
--- a/packages/client/src/index.ts
+++ b/packages/client/src/index.ts
@@ -53,8 +53,10 @@ import type {
TagSummary,
TiptapDoc,
AiSettings,
+ AiTranscriptionSettings,
AiDiscoveredModel,
AiProvider,
+ AiTranscriptionStandard,
AiPromptTemplate,
AiPromptTemplateCreateInput,
AiPromptTemplateUpdateInput,
@@ -302,6 +304,23 @@ export type AiProviderUpdatePayload = {
isEnabled: boolean;
};
+export type AiTranscriptionProviderCreatePayload = {
+ provider: AiTranscriptionStandard;
+ displayName: string;
+ baseUrl: string;
+ apiKey: string;
+ isEnabled: boolean;
+ initialModelId?: string;
+};
+
+export type AiTranscriptionProviderUpdatePayload = {
+ provider: AiTranscriptionStandard;
+ displayName: string;
+ baseUrl: string;
+ apiKey?: string;
+ isEnabled: boolean;
+};
+
/** @deprecated Use SyncBootstrapResponse; kept for mobile source compatibility. */
export type MobileSyncBootstrapPage = SyncBootstrapResponse;
@@ -895,6 +914,50 @@ export const createEdgeEverClient = (options: EdgeEverClientOptions = {}) => {
return request<AiSettings>(`/api/v1/ai/settings${search}`);
},
+ getAiTranscriptionSettings: () =>
+ request<AiTranscriptionSettings>("/api/v1/ai/transcription-settings"),
+
+ createAiTranscriptionProvider: (payload: AiTranscriptionProviderCreatePayload) =>
+ request<AiTranscriptionSettings>("/api/v1/ai/transcription-providers", {
+ method: "POST",
+ body: JSON.stringify(payload),
+ }),
+
+ updateAiTranscriptionProvider: (providerId: string, payload: AiTranscriptionProviderUpdatePayload) =>
+ request<AiTranscriptionSettings>(`/api/v1/ai/transcription-providers/${encodeURIComponent(providerId)}`, {
+ method: "PUT",
+ body: JSON.stringify(payload),
+ }),
+
+ deleteAiTranscriptionProvider: (providerId: string) =>
+ request<AiTranscriptionSettings>(`/api/v1/ai/transcription-providers/${encodeURIComponent(providerId)}`, {
+ method: "DELETE",
+ }),
+
+ addAiTranscriptionModel: (providerId: string, payload: { modelId: string; displayName?: string }) =>
+ request<AiTranscriptionSettings>(`/api/v1/ai/transcription-providers/${encodeURIComponent(providerId)}/models`, {
+ method: "POST",
+ body: JSON.stringify(payload),
+ }),
+
+ deleteAiTranscriptionModel: (providerId: string, modelConfigId: string) =>
+ request<AiTranscriptionSettings>(
+ `/api/v1/ai/transcription-providers/${encodeURIComponent(providerId)}/models/${encodeURIComponent(modelConfigId)}`,
+ { method: "DELETE" },
+ ),
+
+ updateDefaultAiTranscriptionModel: (modelConfigId: string | null) =>
+ request<AiTranscriptionSettings>("/api/v1/ai/transcription-default-model", {
+ method: "PUT",
+ body: JSON.stringify({ modelConfigId }),
+ }),
+
+ extractVideoTranscript: (memoId: string) =>
+ request<{ status: "queued" | "running" }>(
+ `/api/v1/video-transcript-jobs/${encodeURIComponent(memoId)}/extract`,
+ { method: "POST" },
+ ),
+
createAiProvider: (payload: AiProviderCreatePayload) =>
request<AiSettings>("/api/v1/ai/providers", {
method: "POST",
diff --git a/packages/shared/src/document-extensions.ts b/packages/shared/src/document-extensions.ts
index e1f60a17..8b9154ed 100644
--- a/packages/shared/src/document-extensions.ts
+++ b/packages/shared/src/document-extensions.ts
@@ -8,6 +8,7 @@ import { createEdgeEverDetailsExtensions } from "./details";
import { FileAttachment } from "./file-attachment";
import { ImageGallery } from "./image-gallery";
import { MergeDivider } from "./merge-divider";
+import { VideoNoteMarker } from "./video-note";
import { PdfAttachment } from "./pdf-attachment";
import { PluginEmbed } from "./plugin-embed";
import { EmptyExternalLink } from "./empty-external-link";
@@ -52,6 +53,7 @@ export const createEdgeEverDocumentExtensions = (
...withOptional(options.pdf, PdfAttachment),
...withOptional(options.file, FileAttachment),
MergeDivider,
+ VideoNoteMarker,
...createEdgeEverDetailsExtensions(),
...withOptional(options.pluginEmbed, PluginEmbed),
...options.mathematics,
diff --git a/packages/shared/src/i18n/en-US.ts b/packages/shared/src/i18n/en-US.ts
index 8c03ff7b..d18d6a1c 100644
--- a/packages/shared/src/i18n/en-US.ts
+++ b/packages/shared/src/i18n/en-US.ts
@@ -942,6 +942,7 @@ export const enUS = {
general: "General",
shortcuts: "Shortcuts",
ai: "Models and agents",
+ speech: "Speech transcription",
mcp: "API / MCP",
data: "Import & Export",
advanced: "Advanced",
@@ -1034,7 +1035,6 @@ export const enUS = {
revoked: "This plugin was removed from the catalog: {{reason}}. Disable it.",
submissionTitle: "Submit a community plugin",
submissionDocs: "Community plugin repository",
- submissionHint: "This precheck only confirms that the current client can read a public repository Manifest and Release. License and source checks run in the community repository.",
submissionRepository: "GitHub repository URL to submit",
precheck: "Precheck",
precheckRunning: "Prechecking…",
@@ -1169,6 +1169,64 @@ export const enUS = {
savedCredentialsUnavailable: "Saved model credentials cannot be decrypted. Open the service and enter the API key again.",
savedCredentialsUnavailableBadge: "Re-enter API key",
},
+ speechTranscription: {
+ title: "Speech transcription",
+ description: "Speech transcription is currently used mainly to recognize subtitles in videos.",
+ baseUrl: "Endpoint URL",
+ baseUrlPlaceholder: "https://api.example.com/v1",
+ baseUrlHint: "Requests go to /audio/transcriptions under this URL.",
+ modelId: "Model ID",
+ modelIdPlaceholder: "whisper-1",
+ apiToken: "API token",
+ apiTokenHint: "The credential is encrypted on the EdgeEver server.",
+ apiTokenSavedHint: "The token is encrypted. Leave this blank to keep it unchanged.",
+ apiTokenStoredPlaceholder: "Saved; enter a new token to replace it",
+ apiTokenRequired: "An API token is required to turn speech transcription on.",
+ saved: "Speech transcription settings saved.",
+ failed: "Could not save speech transcription settings.",
+ demoDisabled: "Speech transcription cannot be changed on the demo instance.",
+ defaultModel: "Default speech model",
+ noDefaultModel: "No model selected",
+ defaultUnavailable: "The service for the current default model is disabled. Enable it or choose another model.",
+ defaultBadge: "Default",
+ addProvider: "Add a model service",
+ noProviders: "No speech services yet. Add one, enable it with the switch, and choose a default model above.",
+ displayName: "Name",
+ standard: "Compatibility standard",
+ standards: {
+ "openai-compatible": "OpenAI-compatible",
+ },
+ serviceEnabled: "Enable service",
+ serviceEnabledStatus: "Enabled",
+ serviceDisabledStatus: "Disabled",
+ serviceActions: "Service actions",
+ addModel: "Add a model",
+ editConnection: "Edit connection",
+ removeModel: "Remove model",
+ noModels: "No models yet",
+ deleteProviderConfirm: "Delete the speech service “{{name}}”? Its saved token is deleted too.",
+ deleteModelConfirm: "Remove the model “{{name}}”?",
+ savedCredentialsUnavailable: "The saved speech token cannot be decrypted. Open this service and enter it again.",
+ statusOn: "On",
+ statusOff: "Off",
+ cookieBrowser: "Browser sign-in",
+ cookieBrowserHint: "When subtitle extraction downloads audio, it uses the account already signed in to this browser on this computer. That sign-in stays on this computer and is not uploaded. The system may ask for permission the first time. If the browser is missing or access is refused, extraction fails; choose another browser, or choose None.",
+ cookieBrowserNone: "None",
+ cookieBrowserApplied: "Later downloads will use the {{browser}} sign-in.",
+ cookieBrowserOff: "Later downloads will not use a browser sign-in.",
+ cookieBrowserFailed: "Could not save the browser choice.",
+ cookieBrowsers: {
+ chrome: "Chrome",
+ chromium: "Chromium",
+ edge: "Edge",
+ firefox: "Firefox",
+ safari: "Safari",
+ brave: "Brave",
+ opera: "Opera",
+ vivaldi: "Vivaldi",
+ whale: "Whale",
+ },
+ },
aiPrompts: {
title: "Prompt library",
description: "Manage reusable note-processing prompts. New workspaces start with editable starters you can change or delete.",
@@ -1519,6 +1577,25 @@ export const enUS = {
existingAttachments: "Existing attachments",
existingAttachmentsOriginalStorage: "Continue reading from their original storage",
clientVersion: "Client version",
+ ytDlpVersion: "yt-dlp version",
+ ytDlpPath: "yt-dlp path",
+ ytDlpDownloading: "Downloading",
+ ytDlpUpdating: "{{version}} · updating",
+ ytDlpUpdateFailed: "{{version}} · {{reason}}",
+ ytDlpFailed: "Download failed",
+ ytDlpMissing: "Not downloaded",
+ ytDlpErrors: {
+ checksum_mismatch: "Checksum does not match",
+ checksum_missing: "Release has no checksum",
+ version_mismatch: "Version check failed",
+ not_executable: "File cannot run",
+ timeout: "Download timed out",
+ network: "Network failed",
+ unexpected_size: "Unexpected download size",
+ unrecognized_release: "Latest release was not recognized",
+ storage: "Could not write the local file",
+ http: "HTTP {{status}}",
+ },
releaseTime: "Release time",
build: "Build",
client: "Client",
@@ -1831,6 +1908,10 @@ export const enUS = {
importSharedFileInProgress: "Saving the file as a note…",
loadingMore: "Loading more notes",
openMemo: "Open note",
+ extractTranscript: "Extract subtitles",
+ extractTranscriptStarted: "Subtitle extraction started",
+ extractTranscriptRunning: "Subtitles are already being extracted",
+ extractTranscriptFailed: "Couldn't start subtitle extraction",
unpin: "Unpin",
pinMemo: "Pin note",
restoreMemo: "Restore note",
diff --git a/packages/shared/src/i18n/ja.ts b/packages/shared/src/i18n/ja.ts
index f67e5dd4..69edf3b6 100644
--- a/packages/shared/src/i18n/ja.ts
+++ b/packages/shared/src/i18n/ja.ts
@@ -942,6 +942,7 @@ export const ja = {
general: "一般",
shortcuts: "ショートカット",
ai: "モデルとエージェント",
+ speech: "音声認識",
mcp: "API / MCP",
data: "インポートとエクスポート",
advanced: "詳細",
@@ -1034,7 +1035,6 @@ export const ja = {
revoked: "このプラグインはカタログから削除されました:{{reason}}。無効にしてください。",
submissionTitle: "コミュニティプラグインを提出",
submissionDocs: "コミュニティプラグインのリポジトリ",
- submissionHint: "この事前確認は、公開リポジトリの Manifest と Release を現在のクライアントが読めることだけを見ます。ライセンスとソースの確認はコミュニティリポジトリで行います。",
submissionRepository: "提出する GitHub リポジトリの URL",
precheck: "事前確認",
precheckRunning: "事前確認中…",
@@ -1169,6 +1169,64 @@ export const ja = {
savedCredentialsUnavailable: "保存済みのモデル認証情報を復号できません。サービスを開いて API Key を再入力してください。",
savedCredentialsUnavailableBadge: "API Key を再入力",
},
+ speechTranscription: {
+ title: "音声認識",
+ description: "音声認識サービスは、現在主に動画の字幕認識に使います。",
+ baseUrl: "エンドポイント URL",
+ baseUrlPlaceholder: "https://api.example.com/v1",
+ baseUrlHint: "リクエストはこの URL 配下の /audio/transcriptions に送られます。",
+ modelId: "モデル ID",
+ modelIdPlaceholder: "whisper-1",
+ apiToken: "API トークン",
+ apiTokenHint: "認証情報は EdgeEver サーバーで暗号化されます。",
+ apiTokenSavedHint: "トークンは暗号化されています。空欄のままなら変更しません。",
+ apiTokenStoredPlaceholder: "保存済み。新しいトークンを入力すると置き換えます",
+ apiTokenRequired: "音声認識を有効にするには API トークンが必要です。",
+ saved: "音声認識の設定を保存しました。",
+ failed: "音声認識の設定を保存できませんでした。",
+ demoDisabled: "デモインスタンスでは音声認識の設定を変更できません。",
+ defaultModel: "デフォルト音声モデル",
+ noDefaultModel: "モデル未選択",
+ defaultUnavailable: "現在のデフォルトモデルのサービスは無効です。有効にするか、別のモデルを選んでください。",
+ defaultBadge: "デフォルト",
+ addProvider: "モデルサービスを追加",
+ noProviders: "音声認識サービスはまだありません。追加してスイッチで有効にし、上でデフォルトモデルを選んでください。",
+ displayName: "名前",
+ standard: "互換規格",
+ standards: {
+ "openai-compatible": "OpenAI 互換",
+ },
+ serviceEnabled: "サービスを有効にする",
+ serviceEnabledStatus: "有効",
+ serviceDisabledStatus: "無効",
+ serviceActions: "サービスの操作",
+ addModel: "モデルを追加",
+ editConnection: "接続を編集",
+ removeModel: "モデルを削除",
+ noModels: "モデルはまだありません",
+ deleteProviderConfirm: "音声サービス「{{name}}」を削除しますか?保存したトークンも削除されます。",
+ deleteModelConfirm: "モデル「{{name}}」を削除しますか?",
+ savedCredentialsUnavailable: "保存済みの音声認識トークンを復号できません。このサービスを開いて、トークンを入力し直してください。",
+ statusOn: "有効",
+ statusOff: "無効",
+ cookieBrowser: "ブラウザのログイン状態",
+ cookieBrowserHint: "字幕抽出で音声をダウンロードするとき、このパソコンのそのブラウザにログイン済みのアカウントを使います。ログイン状態はこのパソコンだけに残り、アップロードしません。初回はシステムが許可を求めることがあります。ブラウザが無い、または読み取りを拒否された場合は抽出に失敗します。別のブラウザか「使わない」を選んでください。",
+ cookieBrowserNone: "使わない",
+ cookieBrowserApplied: "これ以降のダウンロードは {{browser}} のログイン状態を使います。",
+ cookieBrowserOff: "これ以降のダウンロードはブラウザのログイン状態を使いません。",
+ cookieBrowserFailed: "ブラウザの選択を保存できませんでした。",
+ cookieBrowsers: {
+ chrome: "Chrome",
+ chromium: "Chromium",
+ edge: "Edge",
+ firefox: "Firefox",
+ safari: "Safari",
+ brave: "Brave",
+ opera: "Opera",
+ vivaldi: "Vivaldi",
+ whale: "Whale",
+ },
+ },
aiPrompts: {
title: "プロンプトライブラリ",
description: "再利用できるノート処理プロンプトを管理します。新しいワークスペースには、編集や削除できるスターターが入ります。",
@@ -1519,6 +1577,25 @@ export const ja = {
existingAttachments: "既存の添付",
existingAttachmentsOriginalStorage: "元のストレージから読み続けます",
clientVersion: "クライアントバージョン",
+ ytDlpVersion: "yt-dlp のバージョン",
+ ytDlpPath: "yt-dlp のパス",
+ ytDlpDownloading: "ダウンロード中",
+ ytDlpUpdating: "{{version}} · 更新中",
+ ytDlpUpdateFailed: "{{version}} · {{reason}}",
+ ytDlpFailed: "ダウンロード失敗",
+ ytDlpMissing: "未ダウンロード",
+ ytDlpErrors: {
+ checksum_mismatch: "チェックサムが一致しません",
+ checksum_missing: "リリースにチェックサムがありません",
+ version_mismatch: "バージョン確認に失敗しました",
+ not_executable: "ファイルを実行できません",
+ timeout: "ダウンロードがタイムアウトしました",
+ network: "ネットワークに失敗しました",
+ unexpected_size: "ダウンロードサイズが異常です",
+ unrecognized_release: "最新リリースを認識できません",
+ storage: "ローカルファイルに書き込めません",
+ http: "HTTP {{status}}",
+ },
releaseTime: "リリース日時",
build: "ビルド",
client: "クライアント",
@@ -1831,6 +1908,10 @@ export const ja = {
importSharedFileInProgress: "ファイルをノートとして保存しています…",
loadingMore: "さらにノートを読み込み中",
openMemo: "ノートを開く",
+ extractTranscript: "字幕を抽出",
+ extractTranscriptStarted: "字幕の抽出を開始しました",
+ extractTranscriptRunning: "このノートは字幕を抽出しています",
+ extractTranscriptFailed: "字幕の抽出を開始できませんでした",
unpin: "ピン留めを外す",
pinMemo: "ノートをピン留め",
restoreMemo: "ノートを復元",
diff --git a/packages/shared/src/i18n/pl.ts b/packages/shared/src/i18n/pl.ts
index ea4df1f3..141ffde4 100644
--- a/packages/shared/src/i18n/pl.ts
+++ b/packages/shared/src/i18n/pl.ts
@@ -942,6 +942,7 @@ export const pl = {
general: "Ogólne",
shortcuts: "Skróty",
ai: "Modele i agenci",
+ speech: "Rozpoznawanie mowy",
mcp: "API / MCP",
data: "Import i eksport",
advanced: "Zaawansowane",
@@ -1015,6 +1016,7 @@ export const pl = {
panelDescription: "Ten interfejs zapewnia włączona zaufana wtyczka.",
sources: {
verified: "Zweryfikowana",
+ community: "Społeczność",
github: "Instalacja ręczna z GitHub",
manifest: "Instalacja ręczna z manifestu",
marketplace: "Instalacja z marketplace",
@@ -1028,6 +1030,16 @@ export const pl = {
officialAutoUpdate: "Oficjalna · aktualizuje się automatycznie",
installVerified: "Zastąp zweryfikowaną wersją",
openRepository: "Otwórz repozytorium źródłowe {{name}}",
+ license: "Licencja {{spdx}}",
+ admissionNotice: "Przeszła kontrolę przyjęcia. To nie jest gwarancja bezpieczeństwa.",
+ revoked: "Ta wtyczka została usunięta z katalogu: {{reason}}. Wyłącz ją.",
+ submissionTitle: "Zgłoś wtyczkę społeczności",
+ submissionDocs: "Repozytorium wtyczek społeczności",
+ submissionRepository: "Adres repozytorium GitHub do zgłoszenia",
+ precheck: "Wstępna kontrola",
+ precheckRunning: "Trwa wstępna kontrola…",
+ precheckPassed: "Wstępna kontrola zakończona. Dodaj plugins/{{id}}.json w repozytorium społeczności, z tym samym adresem repozytorium i identyfikatorem wtyczki.",
+ openSubmission: "Otwórz instrukcję zgłoszenia",
},
toolbar: {
open: "Wtyczki",
@@ -1157,6 +1169,64 @@ export const pl = {
savedCredentialsUnavailable: "Nie można odszyfrować zapisanych danych uwierzytelniających modelu. Otwórz usługę i ponownie wpisz klucz API.",
savedCredentialsUnavailableBadge: "Wpisz ponownie klucz API",
},
+ speechTranscription: {
+ title: "Rozpoznawanie mowy",
+ description: "Usługa rozpoznawania mowy służy obecnie głównie do rozpoznawania napisów w filmach.",
+ baseUrl: "Adres interfejsu",
+ baseUrlPlaceholder: "https://api.example.com/v1",
+ baseUrlHint: "Żądanie trafia na /audio/transcriptions pod tym adresem.",
+ modelId: "ID modelu",
+ modelIdPlaceholder: "whisper-1",
+ apiToken: "Token API",
+ apiTokenHint: "Dane uwierzytelniające są szyfrowane na serwerze EdgeEver.",
+ apiTokenSavedHint: "Token jest zaszyfrowany. Pozostaw puste, aby go nie zmieniać.",
+ apiTokenStoredPlaceholder: "Zapisano; wpisz nowy token, aby go zastąpić",
+ apiTokenRequired: "Aby włączyć rozpoznawanie mowy, wpisz token API.",
+ saved: "Zapisano ustawienia rozpoznawania mowy.",
+ failed: "Nie udało się zapisać ustawień rozpoznawania mowy.",
+ demoDisabled: "Na instancji demonstracyjnej nie można zmieniać rozpoznawania mowy.",
+ defaultModel: "Domyślny model mowy",
+ noDefaultModel: "Nie wybrano modelu",
+ defaultUnavailable: "Usługa obecnego modelu domyślnego jest wyłączona. Włącz ją lub wybierz inny model.",
+ defaultBadge: "Domyślny",
+ addProvider: "Dodaj usługę modelu",
+ noProviders: "Nie ma jeszcze usług rozpoznawania mowy. Dodaj jedną, włącz ją przełącznikiem i wybierz powyżej model domyślny.",
+ displayName: "Nazwa",
+ standard: "Standard zgodności",
+ standards: {
+ "openai-compatible": "Zgodny z OpenAI",
+ },
+ serviceEnabled: "Włącz usługę",
+ serviceEnabledStatus: "Włączona",
+ serviceDisabledStatus: "Wyłączona",
+ serviceActions: "Działania usługi",
+ addModel: "Dodaj model",
+ editConnection: "Edytuj połączenie",
+ removeModel: "Usuń model",
+ noModels: "Nie ma jeszcze modeli",
+ deleteProviderConfirm: "Usunąć usługę mowy „{{name}}”? Zapisany token też zostanie usunięty.",
+ deleteModelConfirm: "Usunąć model „{{name}}”?",
+ savedCredentialsUnavailable: "Nie można odszyfrować zapisanego tokenu rozpoznawania mowy. Otwórz tę usługę i wpisz token ponownie.",
+ statusOn: "Włączone",
+ statusOff: "Wyłączone",
+ cookieBrowser: "Logowanie w przeglądarce",
+ cookieBrowserHint: "Gdy wyodrębnianie napisów pobiera dźwięk, używa konta zalogowanego w tej przeglądarce na tym komputerze. Logowanie zostaje na tym komputerze i nie jest wysyłane. System może raz zapytać o zgodę. Jeśli przeglądarki nie ma albo odmówi dostępu, wyodrębnianie się nie uda; wybierz inną albo „Nie używaj”.",
+ cookieBrowserNone: "Nie używaj",
+ cookieBrowserApplied: "Kolejne pobrania użyją logowania {{browser}}.",
+ cookieBrowserOff: "Kolejne pobrania nie użyją logowania w przeglądarce.",
+ cookieBrowserFailed: "Nie udało się zapisać wyboru przeglądarki.",
+ cookieBrowsers: {
+ chrome: "Chrome",
+ chromium: "Chromium",
+ edge: "Edge",
+ firefox: "Firefox",
+ safari: "Safari",
+ brave: "Brave",
+ opera: "Opera",
+ vivaldi: "Vivaldi",
+ whale: "Whale",
+ },
+ },
aiPrompts: {
title: "Biblioteka promptów",
description: "Zarządzaj promptami wielokrotnego użytku do przetwarzania notatek. Nowe obszary robocze zaczynają z przykładowymi promptami, które możesz zmienić lub usunąć.",
@@ -1507,6 +1577,25 @@ export const pl = {
existingAttachments: "Istniejące załączniki",
existingAttachmentsOriginalStorage: "Nadal odczytywane z pierwotnego magazynu",
clientVersion: "Wersja klienta",
+ ytDlpVersion: "Wersja yt-dlp",
+ ytDlpPath: "Ścieżka yt-dlp",
+ ytDlpDownloading: "Pobieranie",
+ ytDlpUpdating: "{{version}} · aktualizowanie",
+ ytDlpUpdateFailed: "{{version}} · {{reason}}",
+ ytDlpFailed: "Pobieranie nie powiodło się",
+ ytDlpMissing: "Nie pobrano",
+ ytDlpErrors: {
+ checksum_mismatch: "Suma kontrolna nie pasuje",
+ checksum_missing: "Wydanie nie ma sumy kontrolnej",
+ version_mismatch: "Sprawdzenie wersji nie powiodło się",
+ not_executable: "Nie można uruchomić pliku",
+ timeout: "Przekroczono czas pobierania",
+ network: "Błąd sieci",
+ unexpected_size: "Nieoczekiwany rozmiar pobierania",
+ unrecognized_release: "Nie rozpoznano najnowszego wydania",
+ storage: "Nie można zapisać pliku lokalnego",
+ http: "HTTP {{status}}",
+ },
releaseTime: "Data wydania",
build: "Kompilacja",
client: "Klient",
@@ -1819,6 +1908,10 @@ export const pl = {
importSharedFileInProgress: "Zapisywanie pliku jako notatki…",
loadingMore: "Wczytywanie kolejnych notatek",
openMemo: "Otwórz notatkę",
+ extractTranscript: "Wyodrębnij napisy",
+ extractTranscriptStarted: "Rozpoczęto wyodrębnianie napisów",
+ extractTranscriptRunning: "Napisy są już wyodrębniane",
+ extractTranscriptFailed: "Nie udało się rozpocząć wyodrębniania napisów",
unpin: "Odepnij",
pinMemo: "Przypnij notatkę",
restoreMemo: "Przywróć notatkę",
diff --git a/packages/shared/src/i18n/zh-CN.ts b/packages/shared/src/i18n/zh-CN.ts
index 2995d616..e2c84b97 100644
--- a/packages/shared/src/i18n/zh-CN.ts
+++ b/packages/shared/src/i18n/zh-CN.ts
@@ -942,6 +942,7 @@ export const zhCN = {
general: "常规设置",
shortcuts: "快捷键",
ai: "模型与代理",
+ speech: "语音识别",
mcp: "API / MCP",
data: "导入导出",
advanced: "高级设置",
@@ -1034,7 +1035,6 @@ export const zhCN = {
revoked: "此插件已下架:{{reason}}。请停用它。",
submissionTitle: "提交社区插件",
submissionDocs: "社区插件仓库说明",
- submissionHint: "预检只确认当前客户端能读取公开仓库的 Manifest 和 Release。许可证与源码检查在社区仓库的校验脚本里完成。",
submissionRepository: "要提交的 GitHub 仓库地址",
precheck: "预检",
precheckRunning: "正在预检…",
@@ -1169,6 +1169,64 @@ export const zhCN = {
savedCredentialsUnavailable: "已保存的模型凭据无法解密,请打开该服务并重新填写 API Key。",
savedCredentialsUnavailableBadge: "需重新填写密钥",
},
+ speechTranscription: {
+ title: "语音识别",
+ description: "语音识别服务当前主要用于视频字幕识别。",
+ baseUrl: "接口地址",
+ baseUrlPlaceholder: "https://api.example.com/v1",
+ baseUrlHint: "请求会发到该地址下的 /audio/transcriptions。",
+ modelId: "模型 ID",
+ modelIdPlaceholder: "whisper-1",
+ apiToken: "API Token",
+ apiTokenHint: "凭据将由 EdgeEver 服务端加密保存。",
+ apiTokenSavedHint: "密钥已加密保存;留空表示保持不变。",
+ apiTokenStoredPlaceholder: "已保存;输入新密钥可替换",
+ apiTokenRequired: "开启语音识别需要填写 API Token。",
+ saved: "语音识别设置已保存。",
+ failed: "语音识别设置保存失败。",
+ demoDisabled: "演示实例不允许修改语音识别设置。",
+ defaultModel: "默认语音模型",
+ noDefaultModel: "未选择模型",
+ defaultUnavailable: "当前默认模型所在的服务已停用,请启用该服务或另选一个模型。",
+ defaultBadge: "默认",
+ addProvider: "添加模型服务",
+ noProviders: "还没有语音识别服务。添加后用开关启用,并在上面选择默认模型。",
+ displayName: "名称",
+ standard: "兼容标准",
+ standards: {
+ "openai-compatible": "OpenAI 兼容标准",
+ },
+ serviceEnabled: "启用服务",
+ serviceEnabledStatus: "已启用",
+ serviceDisabledStatus: "已停用",
+ serviceActions: "服务操作",
+ addModel: "添加模型",
+ editConnection: "编辑连接",
+ removeModel: "移除模型",
+ noModels: "还没有模型",
+ deleteProviderConfirm: "删除语音服务「{{name}}」?保存的 Token 会一起删除。",
+ deleteModelConfirm: "移除模型「{{name}}」?",
+ savedCredentialsUnavailable: "已保存的语音识别 Token 无法解密,请打开该服务并重新填写。",
+ statusOn: "已开启",
+ statusOff: "未开启",
+ cookieBrowser: "浏览器登录状态",
+ cookieBrowserHint: "提取字幕下载音频时,默认使用这台电脑上该浏览器里已经登录的账号。登录状态只在本机使用,不会上传。第一次读取时,系统可能会询问是否允许。如果这个浏览器没安装,或系统拒绝读取,这次提取会失败,可以改选别的,或选「不使用」。",
+ cookieBrowserNone: "不使用",
+ cookieBrowserApplied: "之后的下载会使用 {{browser}} 的登录状态。",
+ cookieBrowserOff: "之后的下载不使用浏览器登录状态。",
+ cookieBrowserFailed: "没能保存浏览器选择。",
+ cookieBrowsers: {
+ chrome: "Chrome",
+ chromium: "Chromium",
+ edge: "Edge",
+ firefox: "Firefox",
+ safari: "Safari",
+ brave: "Brave",
+ opera: "Opera",
+ vivaldi: "Vivaldi",
+ whale: "Whale",
+ },
+ },
aiPrompts: {
title: "指令库",
description: "管理可复用的笔记处理指令。新工作区会预置常用示例,你可随意编辑或删除。",
@@ -1519,6 +1577,25 @@ export const zhCN = {
existingAttachments: "已有附件",
existingAttachmentsOriginalStorage: "继续从原存储读取",
clientVersion: "客户端版本",
+ ytDlpVersion: "yt-dlp 版本",
+ ytDlpPath: "yt-dlp 路径",
+ ytDlpDownloading: "正在下载",
+ ytDlpUpdating: "{{version}} · 正在更新",
+ ytDlpUpdateFailed: "{{version}} · {{reason}}",
+ ytDlpFailed: "下载失败",
+ ytDlpMissing: "尚未下载",
+ ytDlpErrors: {
+ checksum_mismatch: "校验和不符",
+ checksum_missing: "发布页没有校验和",
+ version_mismatch: "版本校验失败",
+ not_executable: "文件无法运行",
+ timeout: "下载超时",
+ network: "网络失败",
+ unexpected_size: "下载大小异常",
+ unrecognized_release: "无法识别最新版本",
+ storage: "无法写入本地文件",
+ http: "HTTP {{status}}",
+ },
releaseTime: "发版时间",
build: "构建",
client: "客户端",
@@ -1831,6 +1908,10 @@ export const zhCN = {
importSharedFileInProgress: "正在把文件保存为笔记…",
loadingMore: "正在加载更多笔记",
openMemo: "打开笔记",
+ extractTranscript: "提取字幕",
+ extractTranscriptStarted: "已开始提取字幕",
+ extractTranscriptRunning: "这条笔记正在提取字幕",
+ extractTranscriptFailed: "没能开始提取字幕",
unpin: "取消置顶",
pinMemo: "置顶笔记",
restoreMemo: "恢复笔记",
diff --git a/packages/shared/src/index.ts b/packages/shared/src/index.ts
index 2d4abbf6..1c00893f 100644
--- a/packages/shared/src/index.ts
+++ b/packages/shared/src/index.ts
@@ -49,6 +49,8 @@ export * from "./file-attachment";
export * from "./note-image-card";
export * from "./pdf-attachment";
export * from "./types";
+export * from "./video-note";
+export * from "./video-cookie-browser";
export * from "./version";
export * from './plugin-capabilities';
diff --git a/packages/shared/src/mobile-content-compatibility.ts b/packages/shared/src/mobile-content-compatibility.ts
index 9d84139b..0dbf6ace 100644
--- a/packages/shared/src/mobile-content-compatibility.ts
+++ b/packages/shared/src/mobile-content-compatibility.ts
@@ -39,6 +39,7 @@ export const NATIVE_EDITOR_NODE_TYPES = new Set<string>([
"tableHeader",
"tableCell",
"edgeeverMergeDivider",
+ "edgeeverVideoNote",
EMPTY_EXTERNAL_LINK_NODE_TYPE,
"inlineMath",
"blockMath",
diff --git a/packages/shared/src/schemas.ts b/packages/shared/src/schemas.ts
index 09102dde..2cc7ed0d 100644
--- a/packages/shared/src/schemas.ts
+++ b/packages/shared/src/schemas.ts
@@ -29,6 +29,70 @@ export const NotebookUpdateSchema = z.object({
sortOrder: z.number().int().optional(),
});
+const PUBLIC_VIDEO_HOSTS = new Set([
+ "youtube.com",
+ "www.youtube.com",
+ "m.youtube.com",
+ "youtu.be",
+ "bilibili.com",
+ "www.bilibili.com",
+ "m.bilibili.com",
+]);
+
+export const isPublicVideoSourceUrl = (value: string) => {
+ try {
+ const url = new URL(value);
+ return url.protocol === "https:"
+ && !url.username
+ && !url.password
+ && PUBLIC_VIDEO_HOSTS.has(url.hostname);
+ } catch {
+ return false;
+ }
+};
+
+export const VIDEO_TRANSCRIPT_ERROR_CODES = [
+ "duration_limit",
+ "unsupported_source",
+ "audio_too_large",
+ "download_failed",
+ "transcribe_failed",
+ "empty_transcript",
+ "note_changed",
+ "note_write_failed",
+ "credentials_unavailable",
+ "disabled",
+] as const;
+
+export const VideoTranscriptJobInputSchema = z.object({
+ platform: z.enum(["youtube", "bilibili"]),
+ videoId: z.string().trim().min(1).max(64),
+ sourceUrl: z.string().trim().max(2048).refine(isPublicVideoSourceUrl, {
+ message: "sourceUrl must be an https YouTube or Bilibili address.",
+ }),
+ durationSeconds: z.number().int().min(0).max(24 * 60 * 60).default(0),
+ placeholderText: z.string().trim().min(1).max(200),
+ transcriptLabel: z.string().trim().min(1).max(80),
+});
+
+export const parseVideoTranscriptJob = (value: unknown) => {
+ const parsed = VideoTranscriptJobInputSchema.safeParse(value);
+ return parsed.success ? parsed.data : undefined;
+};
+
+export const VideoTranscriptFinishSchema = z.object({
+ status: z.enum(["ready", "failed"]),
+ errorCode: z.enum(VIDEO_TRANSCRIPT_ERROR_CODES).nullable().optional(),
+ claimedAt: z.string().datetime(),
+}).superRefine((input, context) => {
+ if (input.status === "failed" && !input.errorCode) {
+ context.addIssue({ code: "custom", path: ["errorCode"], message: "A failure needs an error code." });
+ }
+ if (input.status === "ready" && input.errorCode) {
+ context.addIssue({ code: "custom", path: ["errorCode"], message: "A finished transcript has no error code." });
+ }
+});
+
export const MemoCreateSchema = z.object({
notebookId: z.string().trim().min(1),
title: z.string().trim().max(160).optional(),
@@ -37,6 +101,8 @@ export const MemoCreateSchema = z.object({
tags: z.array(z.string()).optional(),
createdAt: z.string().datetime().optional(),
updatedAt: z.string().datetime().optional(),
+ // An unusable job must not reject the note. The desktop simply has nothing to claim.
+ videoTranscript: z.unknown().optional().transform((value) => parseVideoTranscriptJob(value)),
});
export const MemoUpdateSchema = z.object({
@@ -250,11 +316,14 @@ export const ObjectStorageConnectionTestSchema = z.object({
export const AiProviderSchema = z.enum(["openai-compatible", "anthropic", "google"]);
-const AiBaseUrlSchema = z.string().trim().url().max(500).superRefine((value, context) => {
+export const AiTranscriptionStandardSchema = z.enum(["openai-compatible"]);
+
+const rejectUnsafeAiBaseUrl = (value: string, context: z.RefinementCtx) => {
let url: URL;
try {
url = new URL(value);
} catch {
+ context.addIssue({ code: "custom", message: "AI Base URL must be a valid URL." });
return;
}
if (url.protocol !== "http:" && url.protocol !== "https:") {
@@ -263,6 +332,42 @@ const AiBaseUrlSchema = z.string().trim().url().max(500).superRefine((value, con
if (url.username || url.password) {
context.addIssue({ code: "custom", message: "AI Base URL must not contain credentials." });
}
+};
+
+const AiBaseUrlSchema = z.string().trim().url().max(500).superRefine(rejectUnsafeAiBaseUrl);
+
+const AiTranscriptionProviderBaseUrlSchema = z.string().trim().min(1).max(500).superRefine((value, context) => {
+ if (!z.string().url().safeParse(value).success) {
+ context.addIssue({ code: "custom", message: "AI Base URL must be a valid URL." });
+ return;
+ }
+ rejectUnsafeAiBaseUrl(value, context);
+});
+
+export const AiTranscriptionProviderCreateSchema = z.object({
+ provider: AiTranscriptionStandardSchema.default("openai-compatible"),
+ displayName: z.string().trim().min(1).max(80),
+ baseUrl: AiTranscriptionProviderBaseUrlSchema,
+ apiKey: z.string().trim().min(1).max(4096),
+ isEnabled: z.boolean().default(true),
+ initialModelId: z.string().trim().min(1).max(200).optional(),
+});
+
+export const AiTranscriptionProviderUpdateSchema = z.object({
+ provider: AiTranscriptionStandardSchema.default("openai-compatible"),
+ displayName: z.string().trim().min(1).max(80),
+ baseUrl: AiTranscriptionProviderBaseUrlSchema,
+ apiKey: z.string().trim().min(1).max(4096).optional(),
+ isEnabled: z.boolean().default(true),
+});
+
+export const AiTranscriptionModelCreateSchema = z.object({
+ modelId: z.string().trim().min(1).max(200),
+ displayName: z.string().trim().min(1).max(80).optional(),
+});
+
+export const AiTranscriptionDefaultModelUpdateSchema = z.object({
+ modelConfigId: z.string().trim().min(1).nullable(),
});
const AiProviderConfigFieldsSchema = z.object({
@@ -470,6 +575,7 @@ export type PublicTableForm = {
export type NotebookCreateInput = z.infer<typeof NotebookCreateSchema>;
export type NotebookUpdateInput = z.infer<typeof NotebookUpdateSchema>;
+export type VideoTranscriptJobInput = z.infer<typeof VideoTranscriptJobInputSchema>;
export type MemoCreateInput = z.infer<typeof MemoCreateSchema>;
export type MemoUpdateInput = z.infer<typeof MemoUpdateSchema>;
export type TemplateCreateInput = z.infer<typeof TemplateCreateSchema>;
diff --git a/packages/shared/src/types.ts b/packages/shared/src/types.ts
index 7d88dc84..3a39cb5d 100644
--- a/packages/shared/src/types.ts
+++ b/packages/shared/src/types.ts
@@ -29,6 +29,7 @@ export type MemoSummary = {
structuredTable?: boolean;
tablePreview?: TableSummaryPreview;
infographic?: boolean;
+ videoNote?: boolean;
tags: string[];
isPinned: boolean;
isArchived: boolean;
@@ -181,6 +182,8 @@ export type ObjectStorageSettings = {
export type AiProvider = "openai-compatible" | "anthropic" | "google";
+export type AiTranscriptionStandard = "openai-compatible";
+
export type AiModelConfig = {
id: string;
providerConfigId: string;
@@ -206,6 +209,32 @@ export type AiSettings = {
readOnly: boolean;
};
+export type AiTranscriptionModel = {
+ id: string;
+ providerId: string;
+ modelId: string;
+ displayName: string;
+};
+
+export type AiTranscriptionProvider = {
+ id: string;
+ provider: AiTranscriptionStandard;
+ displayName: string;
+ baseUrl: string;
+ isEnabled: boolean;
+ hasApiKey: boolean;
+ models: AiTranscriptionModel[];
+ credentialsUnavailable?: boolean;
+};
+
+export type AiTranscriptionSettings = {
+ providers: AiTranscriptionProvider[];
+ defaultModelId: string | null;
+ enabled: boolean;
+ encryptionConfigured: boolean;
+ readOnly: boolean;
+};
+
export type AiPromptTemplate = {
id: string;
origin: "default" | "custom";
diff --git a/packages/shared/src/video-cookie-browser.ts b/packages/shared/src/video-cookie-browser.ts
new file mode 100644
index 00000000..3abe6eda
--- /dev/null
+++ b/packages/shared/src/video-cookie-browser.ts
@@ -0,0 +1,24 @@
+// Browser names accepted by yt-dlp --cookies-from-browser. "none" turns the
+// reuse off. The desktop app keeps its own copy of this list so Electron does
+// not have to load this TypeScript module.
+export const VIDEO_COOKIE_BROWSERS = [
+ "chrome",
+ "chromium",
+ "edge",
+ "firefox",
+ "safari",
+ "brave",
+ "opera",
+ "vivaldi",
+ "whale",
+] as const;
+
+export const DEFAULT_VIDEO_COOKIE_BROWSER = "chrome";
+
+export type VideoCookieBrowser = (typeof VIDEO_COOKIE_BROWSERS)[number] | "none";
+
+export const videoCookieBrowser = (value: unknown): VideoCookieBrowser => {
+ const name = String(value ?? "").trim().toLowerCase();
+ if (name === "none") return "none";
+ return VIDEO_COOKIE_BROWSERS.find((browser) => browser === name) ?? DEFAULT_VIDEO_COOKIE_BROWSER;
+};
diff --git a/packages/shared/src/video-note.test.mjs b/packages/shared/src/video-note.test.mjs
new file mode 100644
index 00000000..97daf91e
--- /dev/null
+++ b/packages/shared/src/video-note.test.mjs
@@ -0,0 +1,33 @@
+import { expect, test } from "bun:test";
+import { docToMarkdown, markdownToDoc } from "./content.ts";
+import { getVideoNoteSummary, parseVideoNoteMarker, serializeVideoNoteMarker } from "./video-note.ts";
+
+const identity = {
+ platform: "youtube",
+ videoId: "abcdefghijk",
+ sourceUrl: "https://www.youtube.com/watch?v=abcdefghijk",
+ durationSeconds: 42,
+ placeholderText: "这一集没有可用字幕",
+ transcriptLabel: "字幕实录",
+};
+
+test("a video-note marker round-trips and stays out of the visible text", () => {
+ const marker = serializeVideoNoteMarker(identity);
+ const markdown = `# 标题\n\n这一集没有可用字幕\n\n${marker}\n`;
+ expect(parseVideoNoteMarker(markdown)).toEqual(identity);
+ expect(getVideoNoteSummary(markdown)).toEqual({ videoNote: true });
+ expect(getVideoNoteSummary("普通笔记")).toEqual({ videoNote: false });
+ expect(parseVideoNoteMarker("<!-- edgeever-video-v1:not-json -->")).toBeUndefined();
+
+ const roundTrip = docToMarkdown(markdownToDoc(markdown));
+ expect(parseVideoNoteMarker(roundTrip)).toEqual(identity);
+ expect(roundTrip).not.toContain("&lt;!--");
+ const doc = markdownToDoc(markdown);
+ const texts = [];
+ const walk = (node) => {
+ if (node.text) texts.push(node.text);
+ for (const child of node.content ?? []) walk(child);
+ };
+ walk(doc);
+ expect(texts.join("\n")).not.toContain("edgeever-video");
+});
diff --git a/packages/shared/src/video-note.ts b/packages/shared/src/video-note.ts
new file mode 100644
index 00000000..e20593ee
--- /dev/null
+++ b/packages/shared/src/video-note.ts
@@ -0,0 +1,91 @@
+import { mergeAttributes, Node } from "@tiptap/core";
+import { Base64 } from "js-base64";
+import { parseVideoTranscriptJob, type VideoTranscriptJobInput } from "./schemas";
+
+/** Hidden block that marks a saved YouTube or Bilibili note. */
+export const VIDEO_NOTE_NODE_TYPE = "edgeeverVideoNote" as const;
+
+const MARKER_PREFIX = "edgeever-video-v1";
+const MARKER = new RegExp(`<!--\\s*${MARKER_PREFIX}:([A-Za-z0-9_=-]+)\\s*-->`);
+const MARKER_TOKEN = new RegExp(`^<!--\\s*${MARKER_PREFIX}:([A-Za-z0-9_=-]+)\\s*-->[ \\t]*(?:\\n+|$)`);
+
+export const serializeVideoNoteMarker = (input: VideoTranscriptJobInput) =>
+ `<!-- ${MARKER_PREFIX}:${Base64.encodeURI(JSON.stringify(input))} -->`;
+
+export const parseVideoNoteMarker = (markdown: string | null | undefined) => {
+ const encoded = markdown?.match(MARKER)?.[1];
+ if (!encoded || encoded.length > 8000) return undefined;
+ try {
+ return parseVideoTranscriptJob(JSON.parse(Base64.decode(encoded)));
+ } catch {
+ return undefined;
+ }
+};
+
+export const getVideoNoteSummary = (markdown: string | null | undefined) => ({
+ videoNote: Boolean(parseVideoNoteMarker(markdown)),
+});
+
+export const VideoNoteMarker = Node.create({
+ name: VIDEO_NOTE_NODE_TYPE,
+ group: "block",
+ atom: true,
+ selectable: false,
+ draggable: false,
+
+ addAttributes() {
+ return {
+ encoded: {
+ default: "",
+ parseHTML: (element) => element.getAttribute("data-edgeever-video-note") ?? "",
+ renderHTML: (attributes) => (
+ typeof attributes.encoded === "string" && attributes.encoded
+ ? { "data-edgeever-video-note": attributes.encoded }
+ : {}
+ ),
+ },
+ };
+ },
+
+ parseHTML() {
+ return [{ tag: "div[data-edgeever-video-note]" }];
+ },
+
+ renderHTML({ HTMLAttributes }) {
+ return ["div", mergeAttributes(HTMLAttributes, {
+ class: "edgeever-video-note",
+ contenteditable: "false",
+ style: "display:none",
+ })];
+ },
+
+ renderMarkdown(node) {
+ const encoded = String(node.attrs?.encoded ?? "");
+ if (!/^[A-Za-z0-9_=-]+$/.test(encoded)) return "";
+ return `<!-- ${MARKER_PREFIX}:${encoded} -->\n`;
+ },
+
+ parseMarkdown(token) {
+ return {
+ type: VIDEO_NOTE_NODE_TYPE,
+ attrs: { encoded: String(token.encoded ?? "") },
+ };
+ },
+
+ markdownTokenizer: {
+ name: VIDEO_NOTE_NODE_TYPE,
+ level: "block",
+ start(src: string) {
+ return src.indexOf(`<!-- ${MARKER_PREFIX}:`);
+ },
+ tokenize(src: string) {
+ const match = MARKER_TOKEN.exec(src);
+ if (!match) return undefined;
+ return {
+ type: VIDEO_NOTE_NODE_TYPE,
+ raw: match[0],
+ encoded: match[1],
+ };
+ },
+ },
+});
diff --git a/scripts/test-desktop-sidecar.mjs b/scripts/test-desktop-sidecar.mjs
index 730fef82..3f18de52 100644
--- a/scripts/test-desktop-sidecar.mjs
+++ b/scripts/test-desktop-sidecar.mjs
@@ -7,6 +7,7 @@ import { join } from "node:path";
import { createDefaultDiagramDocument, getDiagramSummary, serializeDiagramDocument } from "../packages/shared/src/diagram.ts";
import { createDefaultInfographicDocument, getInfographicSummary, serializeInfographicDocument } from "../packages/shared/src/infographic.ts";
import { createDefaultTableDocument, getTableSummary, serializeTableDocument } from "../packages/shared/src/table.ts";
+import { getVideoNoteSummary, serializeVideoNoteMarker } from "../packages/shared/src/video-note.ts";
const sidecarPath = process.env.EDGE_EVER_SIDECAR_PATH ?? join(process.cwd(), "crates/desktop-sidecar/target/debug/edgeever-sidecar");
const migrationsPath = process.env.EDGE_EVER_MIGRATIONS_PATH ?? join(process.cwd(), "migrations");
@@ -186,6 +187,7 @@ assert.deepEqual(search.memos.map((memo) => memo.id), [first.memo.id]);
assert.equal(search.memos[0].diagramKind, null, "an ordinary note has no diagram kind");
assert.equal(search.memos[0].infographic, false, "an ordinary note is not an infographic");
assert.equal(search.memos[0].structuredTable, false, "an ordinary note is not a table");
+assert.equal(search.memos[0].videoNote, false, "an ordinary note is not a video note");
assert.equal(Object.hasOwn(search.memos[0], "diagramPreview"), false);
assert.equal(Object.hasOwn(search.memos[0], "tablePreview"), false);
assert.equal(Object.hasOwn(search.memos[0], "contentMarkdown"), false, "list rows must not include the document payload");
@@ -193,11 +195,12 @@ const assertListMetadata = async (title, markdown) => {
const created = await request("memo.create", { notebookId: inbox.id, title, contentMarkdown: markdown, tags: [] });
const listed = (await request("memo.list", { q: title, limit: 20 })).memos.find((memo) => memo.id === created.memo.id);
assert.ok(listed, `${title} should appear in the desktop list`);
- const expected = { ...getDiagramSummary(markdown), ...getInfographicSummary(markdown), ...getTableSummary(markdown) };
+ const expected = { ...getDiagramSummary(markdown), ...getInfographicSummary(markdown), ...getTableSummary(markdown), ...getVideoNoteSummary(markdown) };
assert.equal(listed.diagramKind, expected.diagramKind, title);
assert.deepEqual(listed.diagramPreview, expected.diagramPreview, title);
assert.equal(listed.infographic, expected.infographic, title);
assert.equal(listed.structuredTable, expected.structuredTable, title);
+ assert.equal(listed.videoNote, expected.videoNote, title);
assert.deepEqual(listed.tablePreview, expected.tablePreview, title);
assert.equal(Object.hasOwn(listed, "contentMarkdown"), false, `${title} list row must not include the document payload`);
};
@@ -212,6 +215,14 @@ await assertListMetadata("Flowchart list icon", serializeDiagramDocument(createD
await assertListMetadata("Architecture list icon", serializeDiagramDocument(createDefaultDiagramDocument("architecture")));
await assertListMetadata("Table list icon", serializeTableDocument(createDefaultTableDocument()));
await assertListMetadata("Broken infographic list icon", "<!-- edgeever-infographic-v1:broken -->");
+await assertListMetadata("Video note list flag", `标题\n\n${serializeVideoNoteMarker({
+ platform: "youtube",
+ videoId: "abcdefghijk",
+ sourceUrl: "https://www.youtube.com/watch?v=abcdefghijk",
+ durationSeconds: 12,
+ placeholderText: "这一集没有可用字幕",
+ transcriptLabel: "字幕实录",
+})}\n`);
await request("memo.create", { notebookId: inbox.id, title: "Local daily", contentMarkdown: "prefix overlap", tags: ["local-daily"] });
const tagged = await request("memo.list", { tag: "local", limit: 20 });
assert.deepEqual(tagged.memos.map((memo) => memo.id), [first.memo.id], "tag filter should match an exact tag, not a prefix");
diff --git a/scripts/verify-deployment.mjs b/scripts/verify-deployment.mjs
index df590a97..91158d69 100644
--- a/scripts/verify-deployment.mjs
+++ b/scripts/verify-deployment.mjs
@@ -20,6 +20,11 @@ export const REQUIRED_TABLES = [
"ai_provider_configs",
"ai_models",
"ai_workspace_settings",
+ "ai_transcription_settings",
+ "ai_transcription_providers",
+ "ai_transcription_models",
+ "ai_transcription_workspace_settings",
+ "video_transcript_jobs",
];
export const buildSchemaVerificationSql = () =>
diff --git a/tests/ai-transcription-migration.test.ts b/tests/ai-transcription-migration.test.ts
new file mode 100644
index 00000000..529d02b0
--- /dev/null
+++ b/tests/ai-transcription-migration.test.ts
@@ -0,0 +1,70 @@
+import { globSync, readFileSync } from "node:fs";
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+describe("speech transcription provider migration", () => {
+ test("copies a filled-in endpoint into one selected service and leaves a cleared endpoint behind", () => {
+ const db = new Database(":memory:");
+ const migrations = globSync("migrations/*.sql").sort();
+ const migrationIndex = migrations.findIndex((path) => path.endsWith("0062_ai_transcription_providers.sql"));
+
+ for (const migration of migrations.slice(0, migrationIndex)) {
+ db.exec(readFileSync(migration, "utf8"));
+ }
+ db.query("INSERT INTO workspaces (id, name, is_personal) VALUES (?, ?, 0)").run("ws_speech_off", "Off");
+ db.query(
+ `INSERT INTO ai_transcription_settings (
+ workspace_id, base_url, model_id, api_key_encrypted
+ ) VALUES (?, ?, ?, ?)`,
+ ).run(
+ "ws_default",
+ "https://api.groq.com/openai/v1/",
+ "whisper-large-v3-turbo",
+ "v1.encrypted-speech-key",
+ );
+ db.query(
+ `INSERT INTO ai_transcription_settings (
+ workspace_id, base_url, model_id, api_key_encrypted
+ ) VALUES (?, ?, ?, ?)`,
+ ).run("ws_speech_off", "", "whisper-1", "v1.kept-but-hidden");
+
+ for (const migration of migrations.slice(migrationIndex)) {
+ db.exec(readFileSync(migration, "utf8"));
+ }
+
+ expect(db.query(
+ `SELECT id, provider, display_name, base_url, api_key_encrypted, is_enabled
+ FROM ai_transcription_providers WHERE workspace_id = ?`,
+ ).get("ws_default")).toEqual({
+ id: "atp_ws_default",
+ provider: "openai-compatible",
+ display_name: "api.groq.com",
+ base_url: "https://api.groq.com/openai/v1",
+ api_key_encrypted: "v1.encrypted-speech-key",
+ is_enabled: 1,
+ });
+ expect(db.query(
+ `SELECT id, provider_id, model_id, display_name
+ FROM ai_transcription_models WHERE provider_id = ?`,
+ ).get("atp_ws_default")).toEqual({
+ id: "atm_ws_default",
+ provider_id: "atp_ws_default",
+ model_id: "whisper-large-v3-turbo",
+ display_name: "whisper-large-v3-turbo",
+ });
+ expect(db.query(
+ `SELECT default_model_id FROM ai_transcription_workspace_settings WHERE workspace_id = ?`,
+ ).get("ws_default")).toEqual({ default_model_id: "atm_ws_default" });
+ expect(db.query(
+ `SELECT COUNT(*) AS count FROM ai_transcription_providers WHERE workspace_id = ?`,
+ ).get("ws_speech_off")).toEqual({ count: 0 });
+ expect(db.query(
+ `SELECT api_key_encrypted FROM ai_transcription_settings WHERE workspace_id = ?`,
+ ).get("ws_speech_off")).toEqual({ api_key_encrypted: "v1.kept-but-hidden" });
+
+ db.query("DELETE FROM ai_transcription_providers WHERE id = ?").run("atp_ws_default");
+ expect(db.query(
+ `SELECT default_model_id FROM ai_transcription_workspace_settings WHERE workspace_id = ?`,
+ ).get("ws_default")).toEqual({ default_model_id: null });
+ });
+});