@crievo/omni 0.0.0-stage → 0.1.0

package/studio/api/routes/agent.ts

@@ -0,0 +1,162 @@
+/* Omni, the voice agent (AgentPage): its config and voices, the session token, the tools Grok calls
+   through the browser, the confirmation of a staged publish and the measurement log. */
+
+import { json } from "../lib/validate";
+import { router } from "../lib/hono";
+import { fail, result, shaped } from "../lib/result";
+import { notFound, notFoundResponse } from "../lib/errors";
+import { noTimeout } from "../middleware/no-timeout";
+import {
+  agentConfig,
+  agentStats,
+  checkHotword,
+  engineMismatch,
+  HotwordLimit,
+  logEvent,
+  logResolved,
+  OMNI_OFF,
+  QuotaError,
+  startSession,
+  transcribe,
+  voiceRemainingSeconds,
+  voiceSample,
+} from "../services/agent";
+import { askClaude, claudeReply } from "../services/agent-claude";
+import { readEnvKeys } from "../services/services";
+import {
+  cancelAction,
+  cancelSessionActions,
+  confirmAction,
+  isLoggedTool,
+  noteHeard,
+  pendingAction,
+  runTool,
+} from "../services/agent-tools";
+import { setAgentAvatar, setAgentGender } from "../services/settings";
+import { emptyBody, messageBody } from "../../shared/schemas/common";
+import {
+  agentAvatarBody,
+  agentHotwordBody,
+  agentLogBody,
+  agentSessionBody,
+  agentSttBody,
+  agentToolBody,
+  agentVoiceBody,
+} from "../../shared/schemas/agent";
+import type { AgentClaudeReply, AgentInfo, AgentSessionStart } from "../../shared/types/api";
+
+export const agent = router()
+  .get("/agent", c => {
+    const error = readEnvKeys().XAI_API_KEY ? null : "falta XAI_API_KEY no .env";
+    const config = agentConfig();
+    return c.json(
+      shaped<AgentInfo>({
+        config,
+        stats: agentStats(),
+        error,
+        voice_left_s: Math.floor(voiceRemainingSeconds(config)),
+      }),
+    );
+  })
+  .post("/agent/voice", json(agentVoiceBody), c => result(c, setAgentGender(c.req.valid("json").gender)))
+  .post("/agent/avatar", json(agentAvatarBody), c => result(c, setAgentAvatar(c.req.valid("json").avatar)))
+  .get("/agent/voices/:gender/sample", async c => {
+    try {
+      const file = await voiceSample(c.req.param("gender"), c.req.query("clip") ?? "greeting");
+      return new Response(Bun.file(file), { headers: { "content-type": "audio/mpeg" } });
+    } catch {
+      return notFoundResponse();
+    }
+  })
+  .post("/agent/session", json(agentSessionBody), async c => {
+    try {
+      return c.json(shaped<AgentSessionStart>({ ok: true, ...(await startSession(c.req.valid("json").resume)) }));
+    } catch (e) {
+      return c.json(
+        { ok: false as const, error: String((e as Error)?.message ?? e), quota: e instanceof QuotaError },
+        400,
+      );
+    }
+  })
+  /* Claude mode: the page's recording → text, then the text → the user's Claude */
+  .post("/agent/stt", noTimeout, json(agentSttBody), async c => {
+    const b = c.req.valid("json");
+    try {
+      return c.json({ ok: true as const, ...(await transcribe(b.audio, b.session)) });
+    } catch (e) {
+      return fail(c, String((e as Error)?.message ?? e));
+    }
+  })
+  /* "Oi, Omni" with the panel closed: does the start of this utterance call Omni? `limit`: stop for the day */
+  .post("/agent/hotword", noTimeout, json(agentHotwordBody), async c => {
+    try {
+      return c.json({ ok: true as const, ...(await checkHotword(c.req.valid("json").audio)) });
+    } catch (e) {
+      return c.json(
+        { ok: false as const, error: String((e as Error)?.message ?? e), limit: e instanceof HotwordLimit },
+        400,
+      );
+    }
+  })
+  .post("/agent/claude", json(messageBody), c => result(c, askClaude(c.req.valid("json").message ?? "")))
+  .get("/agent/claude/:id", c => {
+    const r = claudeReply(c.req.param("id"));
+    if (!r) throw notFound();
+    return c.json(shaped<AgentClaudeReply>(r));
+  })
+  /* inspect_content and the actions can take seconds */
+  .post("/agent/tools", noTimeout, json(agentToolBody), async c => {
+    const b = c.req.valid("json");
+    const t0 = performance.now();
+    /* Grok's tools: the admin switching Omni off (or off Grok) stops them too */
+    const cfg = agentConfig();
+    const off = !cfg.enabled ? OMNI_OFF : cfg.engine !== "grok" ? engineMismatch(cfg.engine) : null;
+    if (b.heard !== undefined) noteHeard(b.session, b.heard);
+    const output = off ? { error: off } : await runTool(b.session, b.name, b.arguments);
+    const ms = Math.round(performance.now() - t0);
+    logEvent({
+      session: b.session,
+      type: "tool",
+      name: b.name,
+      ms,
+      error: typeof output.error === "string" ? output.error : undefined,
+      cost_usd: typeof output.cost_usd === "number" ? output.cost_usd : undefined,
+      model: typeof output.model === "string" ? output.model : undefined,
+      /* audit: what each staged action asked for */
+      args: isLoggedTool(b.name) ? b.arguments.slice(0, 2000) : undefined,
+    });
+    logResolved(b.session, output);
+    return c.json({ ok: true as const, call_id: b.call_id, output, ms });
+  })
+  .post("/agent/actions/:id/confirm", noTimeout, json(emptyBody), async c => {
+    const id = c.req.param("id");
+    const action = pendingAction(id);
+    const r = await confirmAction(id);
+    if (action)
+      logEvent({
+        session: action.session,
+        type: "action",
+        kind: action.kind,
+        slug: action.slug,
+        summary: action.summary,
+        ok: r.ok,
+        error: r.ok ? undefined : r.error,
+      });
+    return result(c, r);
+  })
+  .post("/agent/actions/:id/cancel", json(emptyBody), c => {
+    const action = pendingAction(c.req.param("id"));
+    if (action)
+      logEvent({ session: action.session, type: "action", kind: action.kind, slug: action.slug, canceled: true });
+    return result(c, cancelAction(c.req.param("id")));
+  })
+  .post("/agent/sessions/:id/log", json(agentLogBody), c => {
+    const id = c.req.param("id");
+    const b = c.req.valid("json");
+    logEvent({ session: id, ...b });
+    /* the call ended: what it left waiting for Confirmar is canceled (not when it only went to sleep) */
+    if (b.type === "end" && b.reason !== "wait")
+      for (const a of cancelSessionActions(id))
+        logEvent({ session: id, type: "action", kind: a.kind, slug: a.slug, canceled: true, reason: "hangup" });
+    return c.json({ ok: true as const });
+  });

package/studio/api/routes/analytics.ts

@@ -0,0 +1,31 @@
+/* Analytics (AnalyticsPage): Reel metrics (tools/metrics.mjs), collect now, the metrics agent and
+   Claude's analysis. Metrics reading is a cloud candidate. */
+
+import { json } from "../lib/validate";
+import { router } from "../lib/hono";
+import { result, shaped } from "../lib/result";
+import { notFound } from "../lib/errors";
+import { noTimeout } from "../middleware/no-timeout";
+import {
+  chatAnalysis,
+  collectMetrics,
+  getAnalytics,
+  getReel,
+  requestAnalysis,
+  setMetricsAgent,
+} from "../services/analytics";
+import { emptyBody, enableBody, messageBody } from "../../shared/schemas/common";
+import { analyzeBody } from "../../shared/schemas/analytics";
+import type { Analytics, ReelDetail } from "../../shared/types/api";
+
+export const analytics = router()
+  .get("/analytics", async c => c.json(shaped<Analytics>(await getAnalytics())))
+  .get("/analytics/reels/:slug", async c => {
+    const r = shaped<ReelDetail | null>(await getReel(c.req.param("slug")));
+    if (!r) throw notFound();
+    return c.json(r);
+  })
+  .post("/analytics/collect", noTimeout, json(emptyBody), async c => result(c, await collectMetrics()))
+  .post("/analytics/agent", json(enableBody), async c => result(c, await setMetricsAgent(c.req.valid("json").enable)))
+  .post("/analytics/analyze", json(analyzeBody), c => result(c, requestAnalysis(c.req.valid("json"))))
+  .post("/analytics/claude", json(messageBody), c => result(c, chatAnalysis(c.req.valid("json").message)));

package/studio/api/routes/approval.ts

@@ -0,0 +1,60 @@
+/* Script and scene approval (ScriptApprovalPanel, ScenesApprovalPanel): decide, approve the pending
+   scenes, save the script edit (which approves), or pause/resume the auto countdown while editing. */
+
+import { json } from "../lib/validate";
+import { router } from "../lib/hono";
+import { result } from "../lib/result";
+import { videoDir } from "../lib/video";
+import { decideScenes, decideScript, resumeAfterApproval } from "../services/approval";
+import { refreshStatus } from "../services/videos";
+import { emptyBody } from "../../shared/schemas/common";
+import { sceneDecisionBody, scriptDecisionBody, scriptEditBody } from "../../shared/schemas/approval";
+
+type Decision = { ok: boolean; output?: string; error?: string };
+type SceneAction = Parameters<typeof decideScenes>[1];
+type ScriptAction = Parameters<typeof decideScript>[1];
+
+/* on ok: refresh the status and resume the session if the round ended (its note joins the output) */
+async function decided(slug: string, dir: string, kind: "scenes" | "script", r: Decision) {
+  if (r.ok) {
+    await refreshStatus(slug);
+    r.output += resumeAfterApproval(slug, dir, kind);
+  }
+  return r;
+}
+
+function scenes(slug: string, action: SceneAction, body: Parameters<typeof decideScenes>[2]) {
+  const dir = videoDir(slug);
+  return decided(slug, dir, "scenes", decideScenes(dir, action, body));
+}
+
+function script(slug: string, action: ScriptAction, body: Parameters<typeof decideScript>[2]) {
+  const dir = videoDir(slug);
+  return decided(slug, dir, "script", decideScript(dir, action, body));
+}
+
+export const approval = router()
+  .post("/videos/:slug/scenes/decide", json(sceneDecisionBody), async c =>
+    result(c, await scenes(c.req.param("slug"), "decide", c.req.valid("json"))),
+  )
+  .post("/videos/:slug/scenes/approve-all", json(emptyBody), async c =>
+    result(c, await scenes(c.req.param("slug"), "approve-all", {})),
+  )
+  .post("/videos/:slug/scenes/pause", json(emptyBody), async c =>
+    result(c, await scenes(c.req.param("slug"), "pause", {})),
+  )
+  .post("/videos/:slug/scenes/resume", json(emptyBody), async c =>
+    result(c, await scenes(c.req.param("slug"), "resume", {})),
+  )
+  .post("/videos/:slug/script/decide", json(scriptDecisionBody), async c =>
+    result(c, await script(c.req.param("slug"), "decide", c.req.valid("json"))),
+  )
+  .post("/videos/:slug/script/edit", json(scriptEditBody), async c =>
+    result(c, await script(c.req.param("slug"), "edit", c.req.valid("json"))),
+  )
+  .post("/videos/:slug/script/pause", json(emptyBody), async c =>
+    result(c, await script(c.req.param("slug"), "pause", {})),
+  )
+  .post("/videos/:slug/script/resume", json(emptyBody), async c =>
+    result(c, await script(c.req.param("slug"), "resume", {})),
+  );

package/studio/api/routes/archive.ts

@@ -0,0 +1,12 @@
+/* Archive and unarchive (VideoRow). */
+
+import { json } from "../lib/validate";
+import { router } from "../lib/hono";
+import { result } from "../lib/result";
+import { videoDir } from "../lib/video";
+import { archiveVideo } from "../services/archive";
+import { archiveBody } from "../../shared/schemas/videos";
+
+export const archive = router().post("/videos/:slug/archive", json(archiveBody), c =>
+  result(c, archiveVideo(videoDir(c.req.param("slug")), c.req.valid("json").archive !== false)),
+);

package/studio/api/routes/captions.ts

@@ -0,0 +1,28 @@
+/* Captions stage (CaptionPositionEditor): data, the preview page and frame, position and text. */
+
+import { json, query } from "../lib/validate";
+import { router } from "../lib/hono";
+import { result } from "../lib/result";
+import { videoDir } from "../lib/video";
+import { captionsPage, frameAt, getCaptionsData, saveCaptionPosition, saveCaptionText } from "../services/captions";
+import { captionPositionBody, captionTextBody, frameQuery } from "../../shared/schemas/captions";
+
+export const captions = router()
+  .get("/videos/:slug/captions", c => {
+    const dir = videoDir(c.req.param("slug"));
+    try {
+      return c.json(getCaptionsData(dir), 200);
+    } catch (e) {
+      return c.json({ error: (e as Error).message }, 400);
+    }
+  })
+  .get("/videos/:slug/captions/page", c => captionsPage(videoDir(c.req.param("slug"))))
+  .get("/videos/:slug/captions/frame", query(frameQuery), c =>
+    frameAt(videoDir(c.req.param("slug")), Number(c.req.valid("query").t ?? 0)),
+  )
+  .post("/videos/:slug/captions/position", json(captionPositionBody), c =>
+    result(c, saveCaptionPosition(videoDir(c.req.param("slug")), c.req.valid("json"))),
+  )
+  .post("/videos/:slug/captions/text", json(captionTextBody), c =>
+    result(c, saveCaptionText(videoDir(c.req.param("slug")), c.req.valid("json"))),
+  );

package/studio/api/routes/carousel.ts

@@ -0,0 +1,38 @@
+/* The content's carousel (CarouselCreate, CarouselChangeRequest, CarouselPublishStage): create and
+   adjust go to the content's session; caption saves the post text; publish uploads to Instagram
+   (minutes, no timeout). */
+
+import { json } from "../lib/validate";
+import { router } from "../lib/hono";
+import { result } from "../lib/result";
+import { videoDir } from "../lib/video";
+import { noTimeout } from "../middleware/no-timeout";
+import { adjustCarousel, createCarousel, publishCarousel, saveCaption } from "../services/carousel";
+import { refreshStatus } from "../services/videos";
+import {
+  carouselAdjustBody,
+  carouselCaptionBody,
+  carouselCreateBody,
+  carouselPublishBody,
+} from "../../shared/schemas/carousel";
+
+export const carousel = router()
+  .post("/videos/:slug/carousel/create", json(carouselCreateBody), async c => {
+    const slug = c.req.param("slug");
+    const r = createCarousel(slug, videoDir(slug), slug, c.req.valid("json").note ?? "");
+    if (r.ok) await refreshStatus(slug);
+    return result(c, r);
+  })
+  .post("/videos/:slug/carousel/adjust", json(carouselAdjustBody), c => {
+    const slug = c.req.param("slug");
+    return result(c, adjustCarousel(slug, videoDir(slug), slug, c.req.valid("json")));
+  })
+  .post("/videos/:slug/carousel/caption", json(carouselCaptionBody), c =>
+    result(c, saveCaption(videoDir(c.req.param("slug")), c.req.valid("json").caption)),
+  )
+  .post("/videos/:slug/carousel/publish", noTimeout, json(carouselPublishBody), async c => {
+    const slug = c.req.param("slug");
+    const r = await publishCarousel(videoDir(slug), c.req.valid("json"));
+    await refreshStatus(slug);
+    return result(c, r);
+  });

package/studio/api/routes/clone.ts

@@ -0,0 +1,27 @@
+/* Voice cloning (CloneVoiceDialog, ProviderDetail): the reading phrases, the account's plan, a
+   profile's stored recording, clone, recreate on one provider and redo the whole voice (minutes). */
+
+import { json } from "../lib/validate";
+import { router } from "../lib/hono";
+import { result } from "../lib/result";
+import { serveWav } from "../lib/files";
+import { noTimeout } from "../middleware/no-timeout";
+import { cloneVoice, getClonePlan, profileRecording, recreateClone, redoVoice } from "../services/clone";
+import { CLONE_CONTEXTS } from "../services/clone-phrases";
+import { originalWavFile } from "../services/media";
+import { cloneBody, recreateCloneBody, redoVoiceBody } from "../../shared/schemas/clone";
+
+export const clone = router()
+  .get("/settings/clone/phrases", c => c.json(CLONE_CONTEXTS))
+  .get("/settings/clone/plan", async c => c.json(await getClonePlan()))
+  .get("/settings/clone/recording/:profile", async c => c.json(await profileRecording(c.req.param("profile"))))
+  .get("/voice-original/:clone", c => serveWav(originalWavFile(c.req.param("clone"))))
+  .post("/settings/clone", noTimeout, json(cloneBody), async c => result(c, await cloneVoice(c.req.valid("json"))))
+  /* create or recreate the clone of a voice on a single provider (Editar voz → Configurar) */
+  .post("/settings/clone/recreate", noTimeout, json(recreateCloneBody), async c =>
+    result(c, await recreateClone(c.req.valid("json"))),
+  )
+  /* redo the whole voice, on all its providers (Editar voz → Refazer voz) */
+  .post("/settings/clone/redo", noTimeout, json(redoVoiceBody), async c =>
+    result(c, await redoVoice(c.req.valid("json"))),
+  );

package/studio/api/routes/create.ts

@@ -0,0 +1,19 @@
+/* New content and new references (NewVideoPage, NewReferenceForm, including the video upload). */
+
+import { json } from "../lib/validate";
+import { router } from "../lib/hono";
+import { result } from "../lib/result";
+import { noTimeout } from "../middleware/no-timeout";
+import { createReference, createVideo, storeUpload } from "../services/create";
+import { createVideoBody } from "../../shared/schemas/videos";
+import { createReferenceBody } from "../../shared/schemas/references";
+
+/* the upload takes the raw body with the name in x-file-name (the local-only guard checks it) */
+export const UPLOAD_PATH = "/api/references/upload";
+
+export const create = router()
+  .post("/videos", json(createVideoBody), async c => result(c, await createVideo(c.req.valid("json"))))
+  .post("/references", json(createReferenceBody), c => result(c, createReference(c.req.valid("json"))))
+  .post("/references/upload", noTimeout, async c =>
+    result(c, await storeUpload(c.req.header("x-file-name") ?? "", c.req.raw.body)),
+  );

package/studio/api/routes/events.ts

@@ -0,0 +1,11 @@
+/* The SSE stream the whole UI listens to (lib/sse.ts): queue, services, sessions and change notices. */
+
+import { router } from "../lib/hono";
+import { HttpError } from "../lib/errors";
+import { eventsStream } from "../services/events";
+
+export const events = router().get("/events", c => {
+  const server = c.env?.server;
+  if (!server) throw new HttpError(500, "o stream precisa do servidor do Bun");
+  return eventsStream(c.req.raw, server);
+});

package/studio/api/routes/export.ts

@@ -0,0 +1,14 @@
+/* Export (ReExport): assemble again; it waits in the queue. */
+
+import { json } from "../lib/validate";
+import { router } from "../lib/hono";
+import { result } from "../lib/result";
+import { videoDir } from "../lib/video";
+import { reassemble } from "../services/sound";
+import { emptyBody } from "../../shared/schemas/common";
+
+export const exportRoutes = router()
+  /* export again (assemble.mjs) after captions, scenes, voice or motion changed */
+  .post("/videos/:slug/assemble", json(emptyBody), async c =>
+    result(c, await reassemble(videoDir(c.req.param("slug")))),
+  );

package/studio/api/routes/media.ts

@@ -0,0 +1,30 @@
+/* Files the UI shows as they are: a video's media (/media), a reference's files (/ref), the sound
+   timeline's draft WAVs (/sound-draft) and kit MP3s (/kit), and the guide's images (/docs). */
+
+import { router } from "../lib/hono";
+import { pathSegments, serveFile } from "../lib/files";
+import { referenceMediaFile, videoMediaFile } from "../services/media";
+import { draftFile, kitFile } from "../services/sound";
+import { docFile } from "../services/onboarding";
+
+/* /<prefix>/<first>/<rest…>: the first segment and the rest joined, decoded */
+const split = (url: string) => {
+  const [first = "", ...rest] = pathSegments(url);
+  return [first, rest.join("/")] as const;
+};
+
+export const media = router()
+  .get("/media/:slug/*", c => {
+    const [slug, rel] = split(c.req.url);
+    return serveFile(videoMediaFile(slug, rel), c.req.url);
+  })
+  .get("/ref/:name/*", c => {
+    const [name, rel] = split(c.req.url);
+    return serveFile(referenceMediaFile(name, rel), c.req.url);
+  })
+  .get("/sound-draft/:slug/*", c => {
+    const [slug, rel] = split(c.req.url);
+    return serveFile(draftFile(slug, rel), c.req.url);
+  })
+  .get("/kit/:name", c => serveFile(kitFile(pathSegments(c.req.url)[0] ?? ""), c.req.url))
+  .get("/docs/*", c => serveFile(docFile(pathSegments(c.req.url, 2).join("/")), c.req.url));

package/studio/api/routes/omnichat.ts

@@ -0,0 +1,113 @@
+/* Omnichat on Instagram comments (OmnichatPage, OmnichatRulePanel, MissingDmsPanel,
+   VideoOmnichatPanel, settings Publicação). The same rule routes serve a video's Reel, its
+   carousel and an outside post. Cloud candidate. */
+
+import type { Context } from "hono";
+import { json, query } from "../lib/validate";
+import { router } from "../lib/hono";
+import { result, shaped } from "../lib/result";
+import { notFound } from "../lib/errors";
+import { noTimeout } from "../middleware/no-timeout";
+import {
+  carouselTarget,
+  createRuleFromLink,
+  deleteComments,
+  dryRunRule,
+  enableRule,
+  enableRuleWithTerm,
+  getOmnichatState,
+  getRuleDetail,
+  listMissingDms,
+  postTarget,
+  retryFailed,
+  saveRule,
+  sendManual,
+  setOmnichatAgent,
+  videoTarget,
+  type RuleTarget,
+} from "../services/omnichat";
+import { emptyBody, enableBody } from "../../shared/schemas/common";
+import {
+  deleteCommentsBody,
+  manualSendBody,
+  omnichatQuery,
+  ruleBody,
+  ruleFromLinkBody,
+  ruleTermBody,
+} from "../../shared/schemas/omnichat";
+import type {
+  DeletedComment,
+  MissingDmList,
+  ManualSend,
+  OmnichatRuleDetail,
+  OmnichatState,
+} from "../../shared/types/api";
+
+type FindTarget = (params: Record<string, string>) => RuleTarget | null;
+
+function targetOf(c: Context, find: FindTarget): RuleTarget {
+  const t = find(c.req.param());
+  if (!t) throw notFound();
+  return t;
+}
+
+/* GET the rule and the log, POST saves the rule; enable, term, retry, dry-run and comments (read the
+   API) and send (the chosen comments, at the agent's pace) */
+const ruleRoutes = (find: FindTarget) =>
+  router()
+    .get("/", async c => {
+      const detail = shaped<OmnichatRuleDetail>(await getRuleDetail(targetOf(c, find)));
+      return c.json(detail);
+    })
+    .post("/", json(ruleBody), async c => result(c, await saveRule(targetOf(c, find), c.req.valid("json"))))
+    .post("/enable", json(enableBody), async c =>
+      result(c, await enableRule(targetOf(c, find), c.req.valid("json").enable)),
+    )
+    /* the Publish stage: saves the term and enables right away, no second click */
+    .post("/term", json(ruleTermBody), async c =>
+      result(c, await enableRuleWithTerm(targetOf(c, find), c.req.valid("json").term)),
+    )
+    .post("/retry", json(emptyBody), async c => result(c, await retryFailed(targetOf(c, find))))
+    /* reads the Reel's comments through the API: seconds */
+    .post("/dry-run", noTimeout, json(emptyBody), async c => result(c, await dryRunRule(targetOf(c, find))))
+    /* by hand: who got no DM (reads the API) and the send to the chosen ones */
+    .post("/comments", noTimeout, json(emptyBody), async c => {
+      const r = await listMissingDms(targetOf(c, find));
+      return result(c, shaped<typeof r & { list?: MissingDmList }>(r));
+    })
+    /* Apagar: deletes comments on the post (outside, no way back; the UI asks twice) */
+    .post("/comments/delete", noTimeout, json(deleteCommentsBody), async c => {
+      const r = await deleteComments(targetOf(c, find), c.req.valid("json").ids);
+      return result(c, shaped<typeof r & { results?: DeletedComment[] }>(r));
+    })
+    .post("/send", noTimeout, json(manualSendBody), async c => {
+      const r = await sendManual(targetOf(c, find), c.req.valid("json"));
+      return result(c, shaped<typeof r & { results?: ManualSend[] }>(r));
+    });
+
+export const omnichat = router()
+  /* account, comments permission, agent and pause (the API part is cached for 2 min; ?refresh asks
+     again); ?rules=0 leaves the rule list out */
+  .get("/omnichat", query(omnichatQuery), async c => {
+    const q = c.req.valid("query");
+    const state = shaped<OmnichatState>(await getOmnichatState(q.refresh !== undefined, q.rules !== "0"));
+    return c.json(state);
+  })
+  .post("/omnichat/agent", json(enableBody), async c => result(c, await setOmnichatAgent(c.req.valid("json").enable)))
+  /* a post already live: finds it by link among the account's posts, seconds */
+  .post("/omnichat/post", noTimeout, json(ruleFromLinkBody), async c =>
+    result(c, await createRuleFromLink(c.req.valid("json"))),
+  )
+  .route(
+    "/omnichat/posts/:code",
+    ruleRoutes(p => postTarget(p.code ?? "")),
+  )
+  /* the content's carousel is another post, with its own rule (videos/<slug>/carousel) */
+  .route(
+    "/videos/:slug/carousel/omnichat",
+    ruleRoutes(p => carouselTarget(p.slug ?? "")),
+  )
+  .route(
+    "/videos/:slug/omnichat",
+    ruleRoutes(p => videoTarget(p.slug ?? "")),
+  );

package/studio/api/routes/onboarding.ts

@@ -0,0 +1,14 @@
+/* Getting started (GettingStartedPage, the menu's setup hint): the docs/onboarding.md guide with the
+   machine check; ?fresh=1 checks again. */
+
+import { query } from "../lib/validate";
+import { router } from "../lib/hono";
+import { shaped } from "../lib/result";
+import { getOnboarding } from "../services/onboarding";
+import { onboardingQuery } from "../../shared/schemas/onboarding";
+import type { Onboarding } from "../../shared/types/api";
+
+export const onboarding = router().get("/onboarding", query(onboardingQuery), async c => {
+  const o = shaped<Onboarding>(await getOnboarding(c.req.valid("query").fresh !== undefined));
+  return c.json(o);
+});

package/studio/api/routes/publish.ts

@@ -0,0 +1,40 @@
+/* Publishing a video (PublishForm, settings Publicação): the text from the script, the upload, the
+   connected accounts and the platform login. Cloud candidate: keeps to its own services. */
+
+import { json, query } from "../lib/validate";
+import { router } from "../lib/hono";
+import { result, shaped } from "../lib/result";
+import { videoDir } from "../lib/video";
+import { noTimeout } from "../middleware/no-timeout";
+import { connectPlatform, connectionStatus, generatePublishText, getAccounts, publishVideo } from "../services/publish";
+import { refreshStatus } from "../services/videos";
+import { accountsQuery, connectBody, connectQuery, publishBody, publishTextBody } from "../../shared/schemas/publish";
+import type { PlatformAccounts } from "../../shared/types/api";
+
+export const publish = router()
+  /* title, description and caption from the script: Claude takes a few seconds */
+  .post("/videos/:slug/publish/text", noTimeout, json(publishTextBody), async c => {
+    const slug = c.req.param("slug");
+    const r = await generatePublishText(videoDir(slug), c.req.valid("json").redo === true);
+    if (r.ok) await refreshStatus(slug);
+    return result(c, r);
+  })
+  /* uploads and waits for Instagram and TikTok to process: minutes */
+  .post("/videos/:slug/publish", noTimeout, json(publishBody), async c => {
+    const slug = c.req.param("slug");
+    const r = await publishVideo(videoDir(slug), c.req.valid("json"));
+    if (r.ok) await refreshStatus(slug);
+    return result(c, r);
+  })
+  .get("/publish/accounts", query(accountsQuery), async c => {
+    const accounts = shaped<PlatformAccounts>(await getAccounts(c.req.valid("query").refresh !== undefined));
+    return c.json(accounts);
+  })
+  /* the YouTube or TikTok login in progress: waiting (with the link), ok or error */
+  .get("/settings/publish/connect", query(connectQuery), c =>
+    c.json(connectionStatus(c.req.valid("query").platform ?? "youtube")),
+  )
+  .post("/settings/publish/connect", noTimeout, json(connectBody), async c => {
+    const b = c.req.valid("json");
+    return result(c, await connectPlatform(b.platform, b.token, b.mode));
+  });

package/studio/api/routes/queue.ts

@@ -0,0 +1,14 @@
+/* The machine queue (QueuePage, LogStream): the recent tickets and a ticket's live log. */
+
+import { router } from "../lib/hono";
+import { shaped } from "../lib/result";
+import { noTimeout } from "../middleware/no-timeout";
+import { getQueue, streamTicketLog } from "../services/queue";
+import type { Queue } from "../../shared/types/api";
+
+export const queue = router()
+  .get("/queue", c => {
+    const q = shaped<Queue>(getQueue(30));
+    return c.json(q);
+  })
+  .get("/queue/:id/log", noTimeout, c => streamTicketLog(c.req.param("id"), c.req.raw));