@vibes.diy/vibe-srv-sandbox 2.5.10 → 2.5.11-dev.1

package/srv-sandbox.js

@@ -1,8 +1,9 @@
-import { Evento, Lazy, Result, Option, EventoResult, processStream, exception2Result, Future, OnFunc, } from "@adviser/cement";
-import { isReqCallAI, isEvtRuntimeReady, isReqImgGen, isReqPutDoc, isReqGetDoc, isReqQueryDocs, isReqDeleteDoc, isReqSetDbAcl, isReqSubscribeDocs, isReqListDbNames, isEvtVibeHotSwapError, isReqVibePutAsset, isReqVibeWhoAmI, isReqVibeUpdateAvatarCid, isReqVibeLogin, isReqOpenDmThread, } from "@vibes.diy/vibe-types";
-import { isPromptBlockEnd, isPromptReq, isSectionEvent } from "@vibes.diy/api-types";
-import { isBlockImage, isCodeBegin, isCodeEnd, isCodeLine } from "@vibes.diy/call-ai-v2";
-import { buildSchemaSystemMessage } from "@vibes.diy/prompts";
+import { Evento, Lazy, Result, Option, EventoResult, OnFunc, } from "@adviser/cement";
+import { isEvtRuntimeReady, isEvtVibeHotSwapError, isReqOpenDmThread, } from "@vibes.diy/vibe-types";
+import { vibeCallAI, vibeImgGen } from "./srv-sandbox-ai-image-handlers.js";
+import { vibePutDoc, vibeGetDoc, vibeQueryDocs, vibeDeleteDoc, vibeSubscribeDocs, vibeSetDbAcl, vibeListDbNames, } from "./srv-sandbox-firefly-doc-handlers.js";
+import { vibePutAsset, vibeWhoAmI, vibeUpdateAvatarCid, vibeRequestLogin } from "./srv-sandbox-asset-identity-auth-handlers.js";
+export { getCodeBlock, getImageFiles } from "./srv-sandbox-ai-image-handlers.js";
 export class MessageEventEventoEnDecoder {
     async encode(me) {
         return Result.Ok(me);
@@ -39,674 +40,6 @@ function vibeRuntimeReady(sandbox) {
         },
     };
 }
-export function getCodeBlock(stream) {
-    const codeParts = [];
-    let promptReq;
-    const firstCodeBlock = new Future();
-    processStream(stream, (msg) => {
-        if (isSectionEvent(msg)) {
-            for (const block of msg.blocks) {
-                if (isPromptReq(block)) {
-                    promptReq = block;
-                }
-                if (isCodeBegin(block) && block.lang.toLocaleUpperCase() === "JSON") {
-                    codeParts.splice(0, codeParts.length);
-                }
-                if (isCodeLine(block)) {
-                    codeParts.push(block.line);
-                }
-                if (isCodeEnd(block)) {
-                    firstCodeBlock.resolve({ code: codeParts.join("\n"), sectionEvt: msg, promptReq, codeEnd: block });
-                }
-            }
-        }
-    });
-    return firstCodeBlock.asPromise();
-}
-function vibeCallAI(sandbox) {
-    const { chatApi } = sandbox.args;
-    return {
-        hash: "vibe.callAI",
-        validate: (ctx) => {
-            const { request: req } = ctx;
-            if (isReqCallAI(req?.data)) {
-                return Promise.resolve(Result.Ok(Option.Some(req.data)));
-            }
-            return Promise.resolve(Result.Ok(Option.None()));
-        },
-        handle: async (ctx) => {
-            await chatApi
-                .openChat({ ownerHandle: ctx.validated.ownerHandle, appSlug: ctx.validated.appSlug, mode: "app" })
-                .then(async (rChat) => {
-                if (rChat.isErr()) {
-                    return ctx.send.send(ctx, {
-                        tid: ctx.validated.tid,
-                        type: "vibe.res.callAI",
-                        status: "error",
-                        message: rChat.Err().message,
-                    });
-                }
-                getCodeBlock(rChat.Ok().sectionStream)
-                    .then(({ code, sectionEvt: msg }) => {
-                    ctx.send.send(ctx, {
-                        tid: ctx.validated.tid,
-                        type: "vibe.res.callAI",
-                        status: "ok",
-                        promptId: msg.promptId,
-                        result: code,
-                    });
-                })
-                    .catch((err) => {
-                    ctx.send.send(ctx, {
-                        tid: ctx.validated.tid,
-                        type: "vibe.res.callAI",
-                        status: "error",
-                        message: err?.message ?? String(err),
-                    });
-                });
-                const generateSchema = [];
-                if (ctx.validated.schema) {
-                    generateSchema.push({
-                        role: "system",
-                        content: [
-                            {
-                                type: "text",
-                                text: await buildSchemaSystemMessage(ctx.validated.schema),
-                            },
-                        ],
-                    });
-                }
-                const rPrompt = await rChat.Ok().prompt({
-                    messages: [
-                        ...generateSchema,
-                        {
-                            role: "user",
-                            content: [
-                                {
-                                    type: "text",
-                                    text: ctx.validated.prompt,
-                                },
-                            ],
-                        },
-                    ],
-                });
-                if (rPrompt.isErr()) {
-                    return ctx.send.send(ctx, {
-                        tid: ctx.validated.tid,
-                        type: "vibe.res.callAI",
-                        status: "error",
-                        message: rPrompt.Err().message,
-                    });
-                }
-            });
-            return Result.Ok(EventoResult.Stop);
-        },
-    };
-}
-export function getImageFiles(stream) {
-    const files = [];
-    const done = new Future();
-    processStream(stream, (msg) => {
-        if (isSectionEvent(msg)) {
-            for (const block of msg.blocks) {
-                if (isBlockImage(block)) {
-                    if (block.uploadId && block.cid && block.mimeType && typeof block.size === "number") {
-                        files.push({ uploadId: block.uploadId, cid: block.cid, mimeType: block.mimeType, size: block.size });
-                    }
-                }
-                if (isPromptBlockEnd(block)) {
-                    done.resolve(files);
-                }
-            }
-        }
-    });
-    return done.asPromise();
-}
-function vibeImgGen(sandbox) {
-    return {
-        hash: "vibe.imgGen",
-        validate: (ctx) => {
-            const { request: req } = ctx;
-            if (isReqImgGen(req?.data)) {
-                return Promise.resolve(Result.Ok(Option.Some(req.data)));
-            }
-            return Promise.resolve(Result.Ok(Option.None()));
-        },
-        handle: async (ctx) => {
-            const tid = ctx.validated.tid;
-            const sendErr = (message) => ctx.send.send(ctx, {
-                tid,
-                type: "vibe.res.imgGen",
-                status: "error",
-                message,
-            });
-            const sendOk = (files) => ctx.send.send(ctx, {
-                tid,
-                type: "vibe.res.imgGen",
-                status: "ok",
-                files,
-            });
-            const api = await requireVibeApi(sandbox, ctx, "vibe.res.imgGen");
-            if (api === undefined)
-                return Result.Ok(EventoResult.Stop);
-            await api
-                .openChat({ ownerHandle: ctx.validated.ownerHandle, appSlug: ctx.validated.appSlug, mode: "img" })
-                .then(async (rChat) => {
-                if (rChat.isErr())
-                    return sendErr(rChat.Err().message);
-                const chat = rChat.Ok();
-                const filesPromise = getImageFiles(chat.sectionStream);
-                const rPrompt = await chat.prompt({
-                    ...(ctx.validated.model ? { model: ctx.validated.model } : {}),
-                    messages: [{ role: "user", content: [{ type: "text", text: ctx.validated.prompt }] }],
-                }, ctx.validated.inputImageBase64 ? { inputImageBase64: ctx.validated.inputImageBase64 } : undefined);
-                if (rPrompt.isErr())
-                    return sendErr(rPrompt.Err().message);
-                const rFiles = await exception2Result(() => filesPromise);
-                if (rFiles.isErr())
-                    return sendErr(rFiles.Err().message);
-                const files = rFiles.Ok();
-                if (!files || files.length === 0) {
-                    return sendErr("Image generation completed without producing a file");
-                }
-                return sendOk(files);
-            });
-            return Result.Ok(EventoResult.Stop);
-        },
-    };
-}
-async function requireVibeApi(sandbox, ctx, resType) {
-    const vibeApi = sandbox.vibeApi;
-    if (vibeApi !== undefined)
-        return vibeApi;
-    const { ownerHandle, appSlug } = ctx.validated;
-    const where = ownerHandle !== undefined && appSlug !== undefined ? ` for ${ownerHandle}/${appSlug}` : "";
-    await ctx.send.send(ctx, {
-        tid: ctx.validated.tid,
-        type: resType,
-        status: "error",
-        message: `vibeApi unavailable — no active app session for this route${where} (route not vibe-bound yet or provider/session mismatch)`,
-    });
-    return undefined;
-}
-function vibePutDoc(sandbox) {
-    return {
-        hash: "vibe.putDoc",
-        validate: (ctx) => {
-            const { request: req } = ctx;
-            if (isReqPutDoc(req?.data)) {
-                return Promise.resolve(Result.Ok(Option.Some(req.data)));
-            }
-            return Promise.resolve(Result.Ok(Option.None()));
-        },
-        handle: async (ctx) => {
-            const api = await requireVibeApi(sandbox, ctx, "vibes.diy.res-put-doc");
-            if (api === undefined)
-                return Result.Ok(EventoResult.Stop);
-            const rRes = await api.putDoc({
-                ownerHandle: ctx.validated.ownerHandle,
-                appSlug: ctx.validated.appSlug,
-                dbName: ctx.validated.dbName,
-                doc: ctx.validated.doc,
-                docId: ctx.validated.docId,
-            });
-            if (rRes.isErr()) {
-                const err = rRes.Err();
-                const errMessage = typeof err === "string" ? err : (err?.message ?? "unknown error");
-                const code = typeof err === "string" ? undefined : err?.error?.code;
-                const isAccessDenied = code === "access-denied" || errMessage === "Access denied";
-                let toast;
-                if (code === "access-denied") {
-                    const trimmed = errMessage.trim();
-                    toast = trimmed.length > 200 ? `${trimmed.slice(0, 199)}…` : trimmed;
-                }
-                else if (errMessage === "Access denied") {
-                    toast = "You have read-only access to this app.";
-                }
-                else {
-                    toast = "Failed to save your changes. Please try again.";
-                }
-                sandbox.args.errorLogger(toast);
-                if (!isAccessDenied) {
-                    console.debug("vibePutDoc failed", err);
-                }
-                await ctx.send.send(ctx, {
-                    tid: ctx.validated.tid,
-                    type: "vibes.diy.res-put-doc",
-                    status: "error",
-                    message: errMessage,
-                });
-            }
-            else {
-                const res = rRes.Ok();
-                await ctx.send.send(ctx, {
-                    tid: ctx.validated.tid,
-                    type: "vibes.diy.res-put-doc",
-                    status: "ok",
-                    id: res.id,
-                });
-            }
-            return Result.Ok(EventoResult.Stop);
-        },
-    };
-}
-function vibeGetDoc(sandbox) {
-    return {
-        hash: "vibe.getDoc",
-        validate: (ctx) => {
-            const { request: req } = ctx;
-            if (isReqGetDoc(req?.data)) {
-                return Promise.resolve(Result.Ok(Option.Some(req.data)));
-            }
-            return Promise.resolve(Result.Ok(Option.None()));
-        },
-        handle: async (ctx) => {
-            const api = await requireVibeApi(sandbox, ctx, "vibes.diy.res-get-doc");
-            if (api === undefined)
-                return Result.Ok(EventoResult.Stop);
-            const rRes = await api.getDoc({
-                ownerHandle: ctx.validated.ownerHandle,
-                appSlug: ctx.validated.appSlug,
-                dbName: ctx.validated.dbName,
-                docId: ctx.validated.docId,
-            });
-            if (rRes.isErr()) {
-                await ctx.send.send(ctx, {
-                    tid: ctx.validated.tid,
-                    type: "vibes.diy.res-get-doc",
-                    status: "error",
-                    message: rRes.Err().message,
-                });
-            }
-            else {
-                const res = rRes.Ok();
-                await ctx.send.send(ctx, {
-                    ...res,
-                    tid: ctx.validated.tid,
-                    type: "vibes.diy.res-get-doc",
-                });
-            }
-            return Result.Ok(EventoResult.Stop);
-        },
-    };
-}
-function vibeQueryDocs(sandbox) {
-    return {
-        hash: "vibe.queryDocs",
-        validate: (ctx) => {
-            const { request: req } = ctx;
-            if (isReqQueryDocs(req?.data)) {
-                return Promise.resolve(Result.Ok(Option.Some(req.data)));
-            }
-            return Promise.resolve(Result.Ok(Option.None()));
-        },
-        handle: async (ctx) => {
-            const api = await requireVibeApi(sandbox, ctx, "vibes.diy.res-query-docs");
-            if (api === undefined)
-                return Result.Ok(EventoResult.Stop);
-            const rRes = await api.queryDocs({
-                ownerHandle: ctx.validated.ownerHandle,
-                appSlug: ctx.validated.appSlug,
-                dbName: ctx.validated.dbName,
-            });
-            if (rRes.isErr()) {
-                await ctx.send.send(ctx, {
-                    tid: ctx.validated.tid,
-                    type: "vibes.diy.res-query-docs",
-                    status: "error",
-                    message: rRes.Err().message,
-                });
-            }
-            else {
-                const res = rRes.Ok();
-                await ctx.send.send(ctx, {
-                    ...res,
-                    tid: ctx.validated.tid,
-                    type: "vibes.diy.res-query-docs",
-                });
-            }
-            return Result.Ok(EventoResult.Stop);
-        },
-    };
-}
-function vibeDeleteDoc(sandbox) {
-    return {
-        hash: "vibe.deleteDoc",
-        validate: (ctx) => {
-            const { request: req } = ctx;
-            if (isReqDeleteDoc(req?.data)) {
-                return Promise.resolve(Result.Ok(Option.Some(req.data)));
-            }
-            return Promise.resolve(Result.Ok(Option.None()));
-        },
-        handle: async (ctx) => {
-            const api = await requireVibeApi(sandbox, ctx, "vibes.diy.res-delete-doc");
-            if (api === undefined)
-                return Result.Ok(EventoResult.Stop);
-            const rRes = await api.deleteDoc({
-                ownerHandle: ctx.validated.ownerHandle,
-                appSlug: ctx.validated.appSlug,
-                dbName: ctx.validated.dbName,
-                docId: ctx.validated.docId,
-            });
-            if (rRes.isErr()) {
-                await ctx.send.send(ctx, {
-                    tid: ctx.validated.tid,
-                    type: "vibes.diy.res-delete-doc",
-                    status: "error",
-                    message: rRes.Err().message,
-                });
-            }
-            else {
-                const res = rRes.Ok();
-                await ctx.send.send(ctx, {
-                    ...res,
-                    tid: ctx.validated.tid,
-                    type: "vibes.diy.res-delete-doc",
-                });
-            }
-            return Result.Ok(EventoResult.Stop);
-        },
-    };
-}
-function vibeSubscribeDocs(sandbox) {
-    return {
-        hash: "vibe.subscribeDocs",
-        validate: (ctx) => {
-            const { request: req } = ctx;
-            if (isReqSubscribeDocs(req?.data)) {
-                return Promise.resolve(Result.Ok(Option.Some(req.data)));
-            }
-            return Promise.resolve(Result.Ok(Option.None()));
-        },
-        handle: async (ctx) => {
-            const api = await requireVibeApi(sandbox, ctx, "vibes.diy.res-subscribe-docs");
-            if (api === undefined)
-                return Result.Ok(EventoResult.Stop);
-            const rRes = await api.subscribeDocs({
-                ownerHandle: ctx.validated.ownerHandle,
-                appSlug: ctx.validated.appSlug,
-                dbName: ctx.validated.dbName,
-            });
-            if (rRes.isErr()) {
-                await ctx.send.send(ctx, {
-                    tid: ctx.validated.tid,
-                    type: "vibes.diy.res-subscribe-docs",
-                    status: "error",
-                    message: rRes.Err().message,
-                });
-            }
-            else {
-                await ctx.send.send(ctx, {
-                    ...rRes.Ok(),
-                    tid: ctx.validated.tid,
-                    type: "vibes.diy.res-subscribe-docs",
-                });
-            }
-            return Result.Ok(EventoResult.Stop);
-        },
-    };
-}
-function vibeSetDbAcl(sandbox) {
-    return {
-        hash: "vibe.setDbAcl",
-        validate: (ctx) => {
-            const { request: req } = ctx;
-            if (isReqSetDbAcl(req?.data)) {
-                return Promise.resolve(Result.Ok(Option.Some(req.data)));
-            }
-            return Promise.resolve(Result.Ok(Option.None()));
-        },
-        handle: async (ctx) => {
-            const api = await requireVibeApi(sandbox, ctx, "vibes.diy.res-set-db-acl");
-            if (api === undefined)
-                return Result.Ok(EventoResult.Stop);
-            const rRes = await api.ensureAppSettings({
-                ownerHandle: ctx.validated.ownerHandle,
-                appSlug: ctx.validated.appSlug,
-                dbAcl: { dbName: ctx.validated.dbName, acl: ctx.validated.acl },
-            });
-            if (rRes.isErr()) {
-                await ctx.send.send(ctx, {
-                    tid: ctx.validated.tid,
-                    type: "vibes.diy.res-set-db-acl",
-                    status: "error",
-                    message: rRes.Err().message,
-                });
-            }
-            else {
-                await ctx.send.send(ctx, {
-                    tid: ctx.validated.tid,
-                    type: "vibes.diy.res-set-db-acl",
-                    status: "ok",
-                });
-            }
-            return Result.Ok(EventoResult.Stop);
-        },
-    };
-}
-function vibeListDbNames(sandbox) {
-    return {
-        hash: "vibe.listDbNames",
-        validate: (ctx) => {
-            const { request: req } = ctx;
-            if (isReqListDbNames(req?.data)) {
-                return Promise.resolve(Result.Ok(Option.Some(req.data)));
-            }
-            return Promise.resolve(Result.Ok(Option.None()));
-        },
-        handle: async (ctx) => {
-            const api = await requireVibeApi(sandbox, ctx, "vibes.diy.res-list-db-names");
-            if (api === undefined)
-                return Result.Ok(EventoResult.Stop);
-            const rRes = await api.listDbNames({
-                ownerHandle: ctx.validated.ownerHandle,
-                appSlug: ctx.validated.appSlug,
-            });
-            if (rRes.isErr()) {
-                await ctx.send.send(ctx, {
-                    tid: ctx.validated.tid,
-                    type: "vibes.diy.res-list-db-names",
-                    status: "error",
-                    message: rRes.Err().message,
-                });
-            }
-            else {
-                await ctx.send.send(ctx, {
-                    ...rRes.Ok(),
-                    tid: ctx.validated.tid,
-                });
-            }
-            return Result.Ok(EventoResult.Stop);
-        },
-    };
-}
-const PROGRESS_INTERVAL_MS = 3000;
-function vibePutAsset(sandbox) {
-    const doFetch = sandbox.args.fetch ?? ((...a) => fetch(...a));
-    return {
-        hash: "vibe.putAsset",
-        validate: (ctx) => {
-            const { request: req } = ctx;
-            if (isReqVibePutAsset(req?.data)) {
-                return Promise.resolve(Result.Ok(Option.Some(req.data)));
-            }
-            return Promise.resolve(Result.Ok(Option.None()));
-        },
-        handle: async (ctx) => {
-            const api = await requireVibeApi(sandbox, ctx, "vibe.res.putAsset");
-            if (api === undefined)
-                return Result.Ok(EventoResult.Stop);
-            const { tid, blob, ownerHandle, appSlug, mimeType } = ctx.validated;
-            const sendErr = async (message) => {
-                await ctx.send.send(ctx, {
-                    tid,
-                    type: "vibe.res.putAsset",
-                    status: "error",
-                    message,
-                });
-            };
-            const rGrant = await api.requestAssetUploadGrant({
-                ownerHandle,
-                appSlug,
-                ...(mimeType ? { mimeType } : mimeType === undefined && blob.type ? { mimeType: blob.type } : {}),
-            });
-            if (rGrant.isErr()) {
-                await sendErr(`grant minting failed: ${rGrant.Err().message}`);
-                return Result.Ok(EventoResult.Stop);
-            }
-            const grant = rGrant.Ok();
-            const progressTimer = setInterval(() => {
-                ctx.send.send(ctx, {
-                    tid,
-                    type: "vibe.evt.putAsset.progress",
-                    bytes: blob.size,
-                });
-            }, PROGRESS_INTERVAL_MS);
-            try {
-                const res = await doFetch(grant.uploadUrl, {
-                    method: "POST",
-                    headers: {
-                        "X-Asset-Grant": grant.grant,
-                        "Content-Type": blob.type || "application/octet-stream",
-                    },
-                    body: blob,
-                });
-                if (!res.ok) {
-                    const text = await res.text().catch(() => "");
-                    await sendErr(`POST ${grant.uploadUrl} returned ${res.status}: ${text}`);
-                    return Result.Ok(EventoResult.Stop);
-                }
-                const body = (await res.json());
-                sandbox.recordAssetGetURL(body.cid, body.getURL);
-                await ctx.send.send(ctx, {
-                    tid,
-                    type: "vibe.res.putAsset",
-                    status: "ok",
-                    cid: body.cid,
-                    getURL: body.getURL,
-                    size: body.size,
-                    uploadId: body.uploadId,
-                });
-            }
-            catch (e) {
-                const msg = e instanceof Error ? e.message : String(e);
-                await sendErr(`upload failed: ${msg}`);
-            }
-            finally {
-                clearInterval(progressTimer);
-            }
-            return Result.Ok(EventoResult.Stop);
-        },
-    };
-}
-function vibeWhoAmI(sandbox) {
-    return {
-        hash: "vibe.whoAmI",
-        validate: (ctx) => {
-            const { request: req } = ctx;
-            if (isReqVibeWhoAmI(req?.data)) {
-                return Promise.resolve(Result.Ok(Option.Some(req.data)));
-            }
-            return Promise.resolve(Result.Ok(Option.None()));
-        },
-        handle: async (ctx) => {
-            const api = await requireVibeApi(sandbox, ctx, "vibe.res.whoAmI");
-            if (api === undefined)
-                return Result.Ok(EventoResult.Stop);
-            const { tid, appSlug, ownerHandle, adminMode } = ctx.validated;
-            const rRes = await api.whoAmI({ tid, appSlug, ownerHandle, adminMode });
-            if (rRes.isErr()) {
-                await ctx.send.send(ctx, {
-                    tid,
-                    type: "vibe.res.whoAmI",
-                    viewer: null,
-                    access: "none",
-                });
-                return Result.Ok(EventoResult.Stop);
-            }
-            const r = rRes.Ok();
-            await ctx.send.send(ctx, {
-                tid,
-                type: "vibe.res.whoAmI",
-                viewer: r.viewer,
-                access: r.access,
-                ...(r.isOwner !== undefined ? { isOwner: r.isOwner } : {}),
-                ...(r.dbAcls !== undefined ? { dbAcls: r.dbAcls } : {}),
-                ...(r.grants !== undefined ? { grants: r.grants } : {}),
-            });
-            return Result.Ok(EventoResult.Stop);
-        },
-    };
-}
-function vibeUpdateAvatarCid(sandbox) {
-    const { chatApi } = sandbox.args;
-    return {
-        hash: "vibe.updateAvatarCid",
-        validate: (ctx) => {
-            const { request: req } = ctx;
-            if (isReqVibeUpdateAvatarCid(req?.data)) {
-                return Promise.resolve(Result.Ok(Option.Some(req.data)));
-            }
-            return Promise.resolve(Result.Ok(Option.None()));
-        },
-        handle: async (ctx) => {
-            const { tid, cid, mimeType, handle } = ctx.validated;
-            if (sandbox.args.confirmAvatarUpdate) {
-                const getURL = sandbox.getAssetGetURL(cid);
-                const confirmed = await sandbox.args.confirmAvatarUpdate({
-                    cid,
-                    ...(mimeType ? { mimeType } : {}),
-                    ...(getURL ? { getURL } : {}),
-                });
-                if (!confirmed) {
-                    await ctx.send.send(ctx, {
-                        tid,
-                        type: "vibe.res.updateAvatarCid",
-                        status: "cancelled",
-                    });
-                    return Result.Ok(EventoResult.Stop);
-                }
-            }
-            const rRes = await chatApi.ensureHandleAvatar({
-                handle,
-                cid,
-                ...(mimeType ? { mime: mimeType } : {}),
-            });
-            if (rRes.isErr()) {
-                await ctx.send.send(ctx, {
-                    tid,
-                    type: "vibe.res.updateAvatarCid",
-                    status: "error",
-                    message: rRes.Err().message,
-                });
-                return Result.Ok(EventoResult.Stop);
-            }
-            await ctx.send.send(ctx, {
-                tid,
-                type: "vibe.res.updateAvatarCid",
-                status: "ok",
-            });
-            return Result.Ok(EventoResult.Stop);
-        },
-    };
-}
-function vibeRequestLogin(sandbox) {
-    return {
-        hash: "vibe.requestLogin",
-        validate: (ctx) => {
-            const { request: req } = ctx;
-            if (isReqVibeLogin(req?.data)) {
-                return Promise.resolve(Result.Ok(Option.Some(req.data)));
-            }
-            return Promise.resolve(Result.Ok(Option.None()));
-        },
-        handle: async (_ctx) => {
-            sandbox.args.openSignIn?.();
-            return Result.Ok(EventoResult.Stop);
-        },
-    };
-}
 export class vibesDiySrvSandbox {
     evento;
     onRuntimeReady = OnFunc();