utilitas 1999.1.56 → 1999.1.58

package/lib/gen.mjs

@@ -1,8 +1,12 @@
-import { ensureString, need, throwError, tryUntil } from './utilitas.mjs';
-import { MIME_PNG, convert } from './storage.mjs';
+import {
+    ensureString, log as _log, need, throwError, tryUntil,
+} from './utilitas.mjs';
 
-const _NEED = ['OpenAI'];
+import { convert, MIME_PNG } from './storage.mjs';
+import { assertCommand, exec } from './shell.mjs';
 
+const _NEED = ['OpenAI'];
+const log = (cnt, opt) => _log(cnt, import.meta.url, { time: 1, ...opt || {} });
 const [
     clients, OPENAI, GEMINI, BASE64, BUFFER, ERROR_GENERATING, IMAGEN_MODEL,
     OPENAI_MODEL, VEO_MODEL,
@@ -13,8 +17,8 @@ const [
 
 const init = async (options) => {
     assert(
-        options?.apiKey || (options?.projectId && options?.accessToken),
-        'API key or project ID (with access token) are required.'
+        options?.apiKey || (options?.credentials && options?.projectId),
+        'API key or credentials are required.'
     );
     const provider = ensureString(options?.provider, { case: 'UP' });
     switch (provider) {
@@ -27,7 +31,7 @@ const init = async (options) => {
             clients[provider] = {
                 apiKey: options.apiKey,
                 projectId: options.projectId,
-                accessToken: options.accessToken,
+                credentials: options.credentials,
             };
             break;
         default:
@@ -46,7 +50,7 @@ const extractVideo = async (data, options) => await convert(
 
 const generateImage = async (prompt, options) => {
     let provider = ensureString(options?.provider, { case: 'UP' });
-    if (!provider && clients?.[GEMINI] && client.apiKey) { provider = GEMINI; }
+    if (!provider && clients?.[GEMINI]?.apiKey) { provider = GEMINI; }
     if (!provider && clients?.[OPENAI]) { provider = OPENAI; }
     const client = clients?.[provider];
     const n = options?.n || 4;
@@ -105,7 +109,20 @@ const generateImage = async (prompt, options) => {
     }
 };
 
-const getGeminiVideo = async (jobId) => {
+const getGeminiAccessToken = async (credentials) => {
+    await assertCommand('gcloud');
+    const actResp = await exec(
+        `gcloud auth activate-service-account --key-file=${credentials}`,
+        { acceptError: true }
+    );
+    assert(actResp.includes('Activated service account credentials'),
+        'Failed to activate service account credentials.', 500);
+    const tokResp = (await exec(`gcloud auth print-access-token`)).trim();
+    assert(tokResp, 'Failed to get access token.', 500);
+    return tokResp;
+};
+
+const getGeminiVideo = async (jobId, accessToken) => {
     const client = clients?.[GEMINI];
     assert(client, 'No available video generation provider.');
     const resp = await (await fetch(
@@ -114,26 +131,23 @@ const getGeminiVideo = async (jobId) => {
         + `${VEO_MODEL}:fetchPredictOperation`, {
         method: 'POST', headers: {
             'Content-Type': 'application/json',
-            'Authorization': `Bearer ${client.accessToken}`,
-        },
-        body: JSON.stringify({
-            operationName: jobId,
-        })
+            'Authorization': `Bearer ${accessToken}`,
+        }, body: JSON.stringify({ operationName: jobId })
     })).json();
-    assert(
-        resp?.response?.videos?.length,
-        `Waiting for Gemini video generation: \`${jobId}\`...`
-    );
+    assert(resp?.response?.videos?.length,
+        'Waiting for Gemini video generation: '
+        + jobId.replace(/^.*\/([^/]+)$/, '$1'));
     return resp?.response?.videos;
 };
 
 const generateVideo = async (prompt, options) => {
     let provider = ensureString(options?.provider, { case: 'UP' });
-    if (!provider && clients?.[GEMINI] && client.accessToken) {
-        provider = GEMINI;
-    }
+    if (!provider
+        && clients?.[GEMINI]?.credentials
+        && clients?.[GEMINI]?.projectId) { provider = GEMINI; }
     const client = clients?.[provider];
     assert(client, 'No available video generation provider.');
+    const accessToken = await getGeminiAccessToken(client.credentials);
     prompt = ensureString(prompt);
     assert(prompt.length <= 4000,
         'Prompt must be less than 4000 characters.', 400);
@@ -149,7 +163,7 @@ const generateVideo = async (prompt, options) => {
                 + `models/${VEO_MODEL}:predictLongRunning`, {
                 method: 'POST', headers: {
                     'Content-Type': 'application/json',
-                    'Authorization': `Bearer ${client.accessToken}`,
+                    'Authorization': `Bearer ${accessToken}`,
                 },
                 body: JSON.stringify({
                     instances: [{ prompt }], parameters: {
@@ -166,10 +180,9 @@ const generateVideo = async (prompt, options) => {
                 resp?.error?.message || ERROR_GENERATING
             );
             if (options?.generateRaw) { return resp; }
-            var videos = await tryUntil(
-                async () => await getGeminiVideo(resp.name),
-                { maxTry: 60 * 10, log: true }
-            );
+            var videos = await tryUntil(async () => await getGeminiVideo(
+                resp.name, accessToken
+            ), { maxTry: 60 * 10, log });
             assert(videos?.length, 'Failed to generate Gemini video.');
             if (options?.videoRaw) { return videos; }
             return await Promise.all(videos.map(async x => ({

package/lib/manifest.mjs

@@ -1,7 +1,7 @@
 const manifest = {
     "name": "utilitas",
     "description": "Just another common utility for JavaScript.",
-    "version": "1999.1.56",
+    "version": "1999.1.58",
     "private": false,
     "homepage": "https://github.com/Leask/utilitas",
     "main": "index.mjs",

package/lib/shell.mjs

@@ -11,8 +11,10 @@ const exist = (bin) => { assertCommand(bin); return which(bin); };
 const exec = async (command, options = {}) => {
     assertCommand(command);
     const { stdout, stderr } = await pmsExec(command);
-    assert(!stderr, stderr, 500);
-    return stdout;
+    assert(options?.acceptError || !stderr, stderr, 500);
+    return options?.acceptError
+        ? [stdout, stderr].map(x => x.trim()).filter(x => x).join('\n')
+        : stdout.trim();
 };
 
 const which = async (bin) => {
@@ -28,4 +30,4 @@ const assertExist = async (bin, er, code = 500) => {
 };
 
 export default exec;
-export { assertExist, exec, exist, which };
+export { assertCommand, assertExist, exec, exist, which };

package/lib/utilitas.mjs

@@ -394,6 +394,7 @@ const log = (content, filename, options) => {
     const args = ['[' + color.red(name) + color.yellow(strTime) + ']'
         + (isErr ? '' : ` ${content}`)];
     if (isErr) { args.push(content); }
+    if (options?.return) { return args[0]; }
     return console.info.apply(null, args);
 };
 
@@ -669,12 +670,15 @@ const tryUntil = async (fnTry, options) => {
         interval: 1000 * 1, maxTry: Infinity, log: false, error: 'Operation failed.',
         verify: async (err, res) => { return !err; }, ...options || {}
     };
-    let [curTry, result, err] = [0, null, null];
+    let [curTry, result, err, msg] = [0, null, null, null];
     do {
         try {
             assert(await options.verify((err = null), (result = await fnTry())), options.error);
         } catch (e) {
-            (err = e) && options?.log && console.log(err?.message || err);
+            (err = e) && (msg = err?.message || err) && (
+                Function.isFunction(options?.log)
+                    ? await options.log(msg) : console.log(msg)
+            );
             await timeout(options.interval);
         }
     } while (++curTry < options.maxTry && err)

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "utilitas",
     "description": "Just another common utility for JavaScript.",
-    "version": "1999.1.56",
+    "version": "1999.1.58",
     "private": false,
     "homepage": "https://github.com/Leask/utilitas",
     "main": "index.mjs",