nixamp 0.23.7 → 0.24.0

package/dist/transcript-client.js

@@ -0,0 +1,76 @@
+function base(site) {
+    return site.replace(/\/+$/, "");
+}
+async function asJson(response) {
+    const body = (await response.json().catch(() => ({})));
+    if (!response.ok)
+        return { ok: false, status: response.status, error: body.error ?? `nixamp.com answered ${response.status}` };
+    return { ok: true, body };
+}
+function unreachable(site, error) {
+    return { ok: false, status: 0, error: `could not reach ${site}: ${error.message}` };
+}
+/** The transcript of some media in a language ("" for the original), if the store has one. */
+export async function fetchTranscript(signed, id, language = "", fetcher = fetch) {
+    const url = new URL(`${base(signed.site)}/api/v1/transcripts/${encodeURIComponent(id)}`);
+    if (language)
+        url.searchParams.set("language", language);
+    try {
+        const response = await fetcher(url.toString(), { headers: { authorization: `Bearer ${signed.token}` } });
+        return await asJson(response);
+    }
+    catch (error) {
+        return unreachable(signed.site, error);
+    }
+}
+/** Keep lines: appended to what the store has, or the whole thing when `complete`. */
+export async function keepLines(signed, id, ask, fetcher = fetch) {
+    try {
+        const response = await fetcher(`${base(signed.site)}/api/v1/transcripts/${encodeURIComponent(id)}/lines`, {
+            method: "POST",
+            headers: { authorization: `Bearer ${signed.token}`, "content-type": "application/json" },
+            body: JSON.stringify(ask),
+        });
+        return await asJson(response);
+    }
+    catch (error) {
+        return unreachable(signed.site, error);
+    }
+}
+/** Texts in another language. `from` may be "" when nixamp.com should tell. */
+export async function translateTexts(signed, texts, from, to, fetcher = fetch) {
+    try {
+        const response = await fetcher(`${base(signed.site)}/api/v1/translate`, {
+            method: "POST",
+            headers: { authorization: `Bearer ${signed.token}`, "content-type": "application/json" },
+            body: JSON.stringify({ texts, from, to }),
+        });
+        return await asJson(response);
+    }
+    catch (error) {
+        return unreachable(signed.site, error);
+    }
+}
+/** Forget some media's transcripts. Only whoever stored them may. */
+export async function forgetTranscript(signed, id, fetcher = fetch) {
+    try {
+        const response = await fetcher(`${base(signed.site)}/api/v1/transcripts/${encodeURIComponent(id)}`, {
+            method: "DELETE",
+            headers: { authorization: `Bearer ${signed.token}` },
+        });
+        return await asJson(response);
+    }
+    catch (error) {
+        return unreachable(signed.site, error);
+    }
+}
+/** What this account has had written down. */
+export async function listTranscripts(signed, fetcher = fetch) {
+    try {
+        const response = await fetcher(`${base(signed.site)}/api/v1/transcripts`, { headers: { authorization: `Bearer ${signed.token}` } });
+        return await asJson(response);
+    }
+    catch (error) {
+        return unreachable(signed.site, error);
+    }
+}

package/dist/transcript.d.ts

@@ -1,8 +1,11 @@
+import { type Session } from "./session.ts";
 export interface TranscriptLine {
     channel: string;
     at: number;
     until: number;
     text: string;
+    language?: string;
+    original?: string;
 }
 export interface TranscriptAnswer {
     channel: string;
@@ -26,8 +29,8 @@ export type Fetched = {
 export declare function readTranscript(target: {
     url: string;
     key: string | null;
-}, channel: string, after?: number, fetcher?: typeof fetch): Promise<Fetched>;
-/** A line as the terminal prints it: the time its sound was heard, then the words. */
+}, channel: string, after?: number, fetcher?: typeof fetch, language?: string): Promise<Fetched>;
+/** A line as the terminal prints it: the time its sound was heard, then the words; a translation says its language. */
 export declare function printed(line: TranscriptLine): string;
 export interface TranscriptDeps {
     fetcher?: typeof fetch;
@@ -36,5 +39,7 @@ export interface TranscriptDeps {
     /** How many asks --follow makes before it stops. Forever, except in the tests. */
     polls?: number;
     sleep?: (ms: number) => Promise<void>;
+    /** The sign-in, for what nixamp.com keeps; the tests hand one in. */
+    session?: Pick<Session, "site" | "token"> | null;
 }
 export declare function transcript(argv: string[], deps?: TranscriptDeps): Promise<number>;

package/dist/transcript.js

@@ -12,24 +12,35 @@
  * share link, or the daemon on this machine when neither is given.
  */
 import { resolveTarget } from "./admin.js";
+import { readSession } from "./session.js";
 import { KEY_HEADER } from "./share.js";
+import { awaitTranscript, rendered } from "./transcribe.js";
+import { listTranscripts } from "./transcript-client.js";
+import { idFrom, languageCode } from "./transcripts.js";
 const HELP = `nixamp transcript — what a channel is saying, written down.
 
   nixamp transcript --channel ID                 the recent lines from this machine's daemon
   nixamp transcript --url URL --key K --channel ID   from another server, with its share link
   nixamp transcript ... --follow                 and keep printing as it speaks
+  nixamp transcript ... --language sv            the lines in Swedish, translated as they are said
   nixamp transcript ... --json                   the lines as JSON
+  nixamp transcript --kept MEDIA_OR_ID [--language de] [--srt|--vtt|--txt]
+                                                 a transcript nixamp.com keeps: a file's, a link's, a past live's
+  nixamp transcript --list                       what this account has had written down
 
 ID is the channel's id as the server names it (the address bar says it when
 you are watching one). The server captions a channel while somebody is asking
 for the transcript, with nixamp.com's ear; it needs an ffmpeg and a sign-in
-(\`nixamp login\`) on that server.
+(\`nixamp login\`) on that server. What it hears is kept on nixamp.com under
+what the channel is playing, and read back from there the next time.
 `;
 /** One ask for a channel's recent lines, after a moment when given. */
-export async function readTranscript(target, channel, after = 0, fetcher = fetch) {
+export async function readTranscript(target, channel, after = 0, fetcher = fetch, language = "") {
     const url = new URL(`${target.url.replace(/\/+$/, "")}/api/channels/${encodeURIComponent(channel)}/transcript`);
     if (after > 0)
         url.searchParams.set("after", String(after));
+    if (language)
+        url.searchParams.set("language", language);
     let response;
     try {
         response = await fetcher(url.toString(), { headers: target.key ? { [KEY_HEADER]: target.key } : {} });
@@ -54,21 +65,78 @@ export async function readTranscript(target, channel, after = 0, fetcher = fetch
         },
     };
 }
-/** A line as the terminal prints it: the time its sound was heard, then the words. */
+/** A line as the terminal prints it: the time its sound was heard, then the words; a translation says its language. */
 export function printed(line) {
     const at = new Date(line.at);
     const clock = Number.isNaN(at.getTime()) ? "--:--:--" : at.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
-    return `${clock}  ${line.text}`;
+    return `${clock}  ${line.original !== undefined && line.language ? `[${line.language}] ` : ""}${line.text}`;
 }
 function flag(argv, name) {
     const at = argv.indexOf(name);
     return at === -1 ? undefined : argv[at + 1];
 }
+/** `--kept` and `--list`: what nixamp.com keeps, rather than what a server is saying now. */
+async function kept(argv, deps, language) {
+    const session = deps.session === undefined ? readSession() : deps.session;
+    if (session === null) {
+        console.error("nixamp: not signed in. Try `nixamp login`.");
+        return 1;
+    }
+    const fetcher = deps.fetcher ?? fetch;
+    if (argv.includes("--list")) {
+        const got = await listTranscripts(session, fetcher);
+        if (!got.ok) {
+            console.error(`nixamp: ${got.error}`);
+            return 1;
+        }
+        if (argv.includes("--json")) {
+            console.log(JSON.stringify(got.body.transcripts, null, 2));
+            return 0;
+        }
+        if (got.body.transcripts.length === 0) {
+            console.log("Nothing written down yet. `nixamp transcribe FILE` keeps a file; a captioned channel keeps itself.");
+            return 0;
+        }
+        for (const one of got.body.transcripts) {
+            console.log(`${one.id}  ${(one.language || "?").padEnd(2)}${one.translatedFrom ? `<${one.translatedFrom}` : "   "}  ${String(one.lines).padStart(5)} lines${one.complete ? " " : "+"}  ${one.title || one.media}`);
+        }
+        return 0;
+    }
+    const named = flag(argv, "--kept") ?? "";
+    if (!named) {
+        console.error("nixamp: --kept needs the transcript's id, or the media identity.");
+        return 64;
+    }
+    const got = await awaitTranscript(session, idFrom(named), language, {
+        fetcher, onProgress: (line) => console.error(line), ...(deps.sleep ? { sleep: deps.sleep } : {}), ...(deps.polls !== undefined ? { polls: deps.polls } : {}),
+    });
+    if (!got.ok) {
+        console.error(`nixamp: ${got.error}`);
+        return 1;
+    }
+    if (got.body.translating) {
+        console.error(`nixamp: still being translated (${got.body.translating.done} of ${got.body.translating.total}); ask again in a moment.`);
+        return 1;
+    }
+    if (argv.includes("--json")) {
+        console.log(JSON.stringify(got.body, null, 2));
+        return 0;
+    }
+    console.log(rendered(got.body.lines, argv.includes("--srt") ? "srt" : argv.includes("--vtt") ? "vtt" : argv.includes("--txt") ? "txt" : "lines"));
+    return 0;
+}
 export async function transcript(argv, deps = {}) {
     if (argv.includes("--help") || argv.includes("-h") || argv[0] === "help") {
         console.log(HELP);
         return 0;
     }
+    const language = languageCode(flag(argv, "--language"));
+    if (language === null) {
+        console.error("nixamp: --language is a two-letter code, such as sv.");
+        return 64;
+    }
+    if (argv.includes("--kept") || argv.includes("--list"))
+        return kept(argv, deps, language);
     let target;
     try {
         target = resolveTarget(argv);
@@ -85,7 +153,7 @@ export async function transcript(argv, deps = {}) {
     let after = 0;
     let polls = 0;
     for (;;) {
-        const got = await readTranscript(target, channel, after, fetcher);
+        const got = await readTranscript(target, channel, after, fetcher, language);
         if (!got.ok) {
             console.error(`nixamp: ${got.error}`);
             return 1;

package/dist/transcripts.d.ts

@@ -0,0 +1,135 @@
+import type { Queryable } from "./follows.ts";
+/** One thing said: seconds into the media, and the words. */
+export interface TranscriptLine {
+    start: number;
+    end: number;
+    text: string;
+}
+export type MediaKind = "file" | "url" | "live";
+export interface Transcript {
+    /** sha256 of the media identity: what the routes are addressed by. */
+    id: string;
+    /** The identity itself: file:v1:<hex>, url:<address>, live:<server>/<channel>@<started>. */
+    media: string;
+    kind: MediaKind;
+    /** ISO 639-1 of the lines, or "" when the ear was not told and did not say. */
+    language: string;
+    /** The language this was translated from, or null for what was heard. */
+    translatedFrom: string | null;
+    model: string;
+    /** Whether the whole media was heard in one pass, rather than in windows as it played. */
+    complete: boolean;
+    /** What it was called when it was heard, for a list. */
+    title: string;
+    /** Who stored it: the account the ear was asked as. */
+    by: string;
+    /** How far into the media the lines reach, seconds. */
+    seconds: number;
+    lines: TranscriptLine[];
+    updatedAt: string;
+}
+/** A transcript without its lines, as a list shows it. */
+export type TranscriptSummary = Omit<Transcript, "lines"> & {
+    lines: number;
+};
+/** A row grows no further than this; a day of talk is under half of it. */
+export declare const MAX_LINES = 20000;
+/** A line longer than this is not a line. */
+export declare const MAX_LINE_CHARS = 2000;
+/** How much of a file's bytes go into its fingerprint, at each end. */
+export declare const FINGERPRINT_BYTES: number;
+/**
+ * A file's identity from its size and a megabyte at each end. Hashing every
+ * byte of a film takes seconds a captioner does not have at start, and the
+ * ends plus the size tell two files apart as surely as anything short of
+ * the whole does. The v1 says how it was made, so a better way later does
+ * not collide with this one.
+ */
+export declare function fileFingerprint(path: string): string;
+/** A link's identity: the address without its fragment, which no server sees. */
+export declare function mediaOfUrl(url: string): string;
+/** A broadcast's identity: the server, the channel, and when it began, so a second airing is a second transcript. */
+export declare function mediaOfLive(server: string, channel: string, startedAt: number): string;
+export declare function kindOf(media: string): MediaKind;
+/** The id a transcript is addressed by: a hash, so a link with a key in it is not in the address bar. */
+export declare function transcriptIdOf(media: string): string;
+/** A transcript id as a request names one, or null when it is not one. */
+export declare function transcriptId(value: unknown): string | null;
+/** Either the id itself or a media identity, as a route accepts both. */
+export declare function idFrom(value: string): string;
+/** Lines as a request or a row hands them in: only the well-formed ones, tidied. */
+export declare function linesFrom(value: unknown): TranscriptLine[];
+/**
+ * Lines in order, with the duplicates gone. Two servers playing one file
+ * both append what they heard, a captioner that restarted hears a window
+ * again: the second copy of a moment says the same thing, later, and a
+ * viewer would read it twice. A line whose span mostly overlaps one already
+ * kept is that second copy.
+ */
+export declare function mergeLines(lines: TranscriptLine[]): TranscriptLine[];
+/** Whether the kept lines already say what this span says: over half of it is covered. */
+export declare function covered(lines: TranscriptLine[], start: number, end: number): TranscriptLine[];
+/** The line for a moment, if there is one: the one that begins nearest, within a second. */
+export declare function lineAt(lines: TranscriptLine[], start: number): TranscriptLine | null;
+/** How far the lines reach, seconds. */
+export declare function reach(lines: TranscriptLine[]): number;
+/** Seconds as a subtitle clock: 01:02:03,456 for SRT, 01:02:03.456 for VTT. */
+export declare function stamp(seconds: number, separator?: "," | "."): string;
+export declare function toSrt(lines: TranscriptLine[]): string;
+export declare function toVtt(lines: TranscriptLine[]): string;
+/** The words alone, one line each, as a person reads them. */
+export declare function toText(lines: TranscriptLine[]): string;
+export type Format = "json" | "srt" | "vtt" | "txt";
+export declare function formatOf(value: unknown): Format | null;
+/** A two-letter language, or "" for none; null when the value is something else. */
+export declare function languageCode(value: unknown): string | null;
+export interface SaveAsk {
+    media: string;
+    language: string;
+    translatedFrom?: string | null;
+    model?: string;
+    /** A whole-media pass: these lines are the transcript, not part of it. */
+    complete?: boolean;
+    title?: string;
+    by: string;
+    lines: TranscriptLine[];
+}
+export declare class Transcripts {
+    private readonly db;
+    private readonly onEvent;
+    private ready;
+    constructor(db: Queryable, onEvent?: (message: string) => void);
+    private ensure;
+    /**
+     * Keep lines. New media is a new row; known media grows by these lines,
+     * unless the row is already whole -- then pieces are nothing it needs --
+     * or these lines are the whole, which replaces whatever pieces there
+     * were. Answers the row as it now stands.
+     */
+    save(ask: SaveAsk): Promise<Transcript | null>;
+    /**
+     * The transcript of some media in a language: the original when none is
+     * named, which is the heard row -- the whole one when there is one.
+     */
+    get(id: string, language?: string): Promise<Transcript | null>;
+    /** Every language some media has been written down in, with how much of it. */
+    languages(id: string): Promise<{
+        language: string;
+        translatedFrom: string | null;
+        lines: number;
+        complete: boolean;
+    }[]>;
+    /** What an account has had written down, newest first. */
+    list(by: string, limit?: number): Promise<TranscriptSummary[]>;
+    /** Forget some media, in every language. Only whoever stored it may. Says whether anything went. */
+    forget(id: string, by: string): Promise<boolean>;
+    /** Never throws: a store that is having a moment costs the memory, not the request. */
+    quietly<T>(what: string, run: () => Promise<T>): Promise<T | null>;
+}
+/** A transcript as the routes answer it, with or without its lines. */
+export declare function wire(transcript: Transcript, languages?: {
+    language: string;
+    translatedFrom: string | null;
+    lines: number;
+    complete: boolean;
+}[]): Record<string, unknown>;