@crievo/omni 0.0.0-stage → 0.1.0

package/studio/shared/schemas/clone.ts

@@ -0,0 +1,40 @@
+/* Voice cloning (CloneVoiceDialog, ProviderDetail): recordings go as base64 samples. */
+
+import { z } from "zod";
+
+const sample = z.object({ mime: z.string(), data: z.string(), text: z.string().nullish() });
+
+/* POST /api/settings/clone: a new voice on the chosen providers */
+export const cloneBody = z.object({
+  name: z.string(),
+  avatar: z.string().optional(),
+  order: z.array(z.string()).optional(),
+  context: z.string().optional(),
+  providers: z.array(z.string()).optional(),
+  samples: z.array(sample),
+  consent: z.boolean(),
+});
+export type CloneBody = z.infer<typeof cloneBody>;
+
+/* POST /api/settings/clone/recreate: one provider of an existing voice (samples only when the voice
+   has no stored recording) */
+export const recreateCloneBody = z.object({
+  profile: z.string(),
+  provider: z.string(),
+  samples: z.array(sample).optional(),
+  context: z.string().optional(),
+  consent: z.boolean().optional(),
+});
+export type RecreateCloneBody = z.infer<typeof recreateCloneBody>;
+
+/* POST /api/settings/clone/redo: the whole voice, on all its providers */
+export const redoVoiceBody = z.object({
+  profile: z.string(),
+  name: z.string().optional(),
+  avatar: z.string().optional(),
+  samples: z.array(sample).optional(),
+  keep: z.boolean().optional(),
+  context: z.string().optional(),
+  consent: z.boolean().optional(),
+});
+export type RedoVoiceBody = z.infer<typeof redoVoiceBody>;

package/studio/shared/schemas/common.ts

@@ -0,0 +1,16 @@
+/* Bodies shared by several domains. The services still check meaning (lengths, formats, what
+   exists); these schemas check shape, so a malformed request stops at the route. */
+
+import { z } from "zod";
+
+/* routes that take no fields: any JSON object (the UI posts {}) */
+export const emptyBody = z.object({});
+export type EmptyBody = z.infer<typeof emptyBody>;
+
+/* a chat message to an agent session */
+export const messageBody = z.object({ message: z.string().optional() });
+export type MessageBody = z.infer<typeof messageBody>;
+
+/* turning an agent (launchd) on or off */
+export const enableBody = z.object({ enable: z.boolean() });
+export type EnableBody = z.infer<typeof enableBody>;

package/studio/shared/schemas/omnichat.ts

@@ -0,0 +1,54 @@
+/* Omnichat on Instagram comments: the rule of a video, of a content's carousel or of an outside
+   post, and the account-wide controls. */
+
+import { z } from "zod";
+
+/* GET /api/omnichat?refresh&rules=0 */
+export const omnichatQuery = z.object({ refresh: z.string().optional(), rules: z.string().optional() });
+
+const list = z.union([z.array(z.string()), z.string()]);
+
+/* POST <rule>: the rule's fields; what is missing stays as it was */
+export const ruleBody = z.object({
+  any_comment: z.boolean().optional(),
+  keywords: list.optional(),
+  link: z.string().optional(),
+  dm: z.string().optional(),
+  public_replies: list.optional(),
+  already_replied: z.enum(["skip", "send"]).optional(),
+  already_replied_if: list.optional(),
+  generic_phrases: z.boolean().optional(),
+  offer: z.string().optional(),
+  quote_post: z.boolean().optional(),
+  button: z.boolean().optional(),
+  require_follow: z.boolean().optional(),
+  opening_dm: z.string().optional(),
+  button_label: z.string().optional(),
+  not_following_dm: z.string().optional(),
+  retry_label: z.string().optional(),
+  link_button: z.boolean().optional(),
+  link_label: z.string().optional(),
+  follow_skip: z.boolean().optional(),
+  skip_label: z.string().optional(),
+  skip_dm: z.string().optional(),
+});
+export type RuleBody = z.infer<typeof ruleBody>;
+
+/* POST /api/omnichat/post: a post already live, by link (plus optional rule fields) */
+export const ruleFromLinkBody = ruleBody.extend({ link: z.string() });
+export type RuleFromLinkBody = z.infer<typeof ruleFromLinkBody>;
+
+/* POST <rule>/term: the Publish stage saves the term and enables right away */
+export const ruleTermBody = z.object({ term: z.string() });
+export type RuleTermBody = z.infer<typeof ruleTermBody>;
+
+/* POST <rule>/send: the chosen comments, by hand */
+export const manualSendBody = z.object({
+  ids: z.array(z.string()),
+  public_reply: z.boolean().optional(),
+  public_reply_only: z.boolean().optional(),
+  text: z.string().optional(),
+});
+export type ManualSendBody = z.infer<typeof manualSendBody>;
+export const deleteCommentsBody = z.object({ ids: z.array(z.string()).min(1) });
+export type DeleteCommentsBody = z.infer<typeof deleteCommentsBody>;

package/studio/shared/schemas/onboarding.ts

@@ -0,0 +1,5 @@
+/* Getting started (/getting-started): ?fresh=1 runs the machine check again. */
+
+import { z } from "zod";
+
+export const onboardingQuery = z.object({ fresh: z.string().optional() });

package/studio/shared/schemas/publish.ts

@@ -0,0 +1,45 @@
+/* Publishing (PublishForm, SchedulePage, settings Publicação): the request, scheduling and the
+   platform connection. Privacy values are checked by the service against publish.mjs's lists. */
+
+import { z } from "zod";
+
+/* POST /api/videos/:slug/publish: where (one flag per platform), privacy, the text and "again" */
+export const publishBody = z.object({
+  youtube: z.boolean().optional(),
+  instagram: z.boolean().optional(),
+  tiktok: z.boolean().optional(),
+  privacy: z.string().optional(),
+  tiktok_privacy: z.string().optional(),
+  title: z.string().optional(),
+  description: z.string().optional(),
+  caption: z.string().optional(),
+  republish: z.boolean().optional(),
+});
+export type PublishBody = z.infer<typeof publishBody>;
+
+/* POST …/publish/schedule: the same request for the day and time (`when`, ISO) */
+export const scheduleBody = publishBody.extend({ when: z.string() });
+export type ScheduleBody = z.infer<typeof scheduleBody>;
+
+/* POST …/publish/schedule/reschedule */
+export const rescheduleBody = z.object({ when: z.string() });
+export type RescheduleBody = z.infer<typeof rescheduleBody>;
+
+/* POST …/publish/text: title, description and caption from the script (redo writes them again) */
+export const publishTextBody = z.object({ redo: z.boolean().optional() });
+export type PublishTextBody = z.infer<typeof publishTextBody>;
+
+/* GET /api/publish/accounts?refresh */
+export const accountsQuery = z.object({ refresh: z.string().optional() });
+
+/* GET /api/settings/publish/connect?platform= : the browser login in progress */
+export const connectQuery = z.object({ platform: z.string().optional() });
+
+/* POST /api/settings/publish/connect: YouTube/TikTok open the browser login (mode), Instagram takes
+   the token */
+export const connectBody = z.object({
+  platform: z.string(),
+  token: z.string().optional(),
+  mode: z.string().optional(),
+});
+export type ConnectBody = z.infer<typeof connectBody>;

package/studio/shared/schemas/references.ts

@@ -0,0 +1,20 @@
+/* The reference library (ReferencesPage, ReferencePage). */
+
+import { z } from "zod";
+
+/* POST /api/references: a new visual style from a link, photos sent through the upload (their paths) or both;
+   the name is optional (the form does not ask for it) */
+export const createReferenceBody = z.object({
+  name: z.string().optional(),
+  source: z.string().optional(),
+  images: z.array(z.string()).max(12).optional(),
+  note: z.string().optional(),
+});
+export type CreateReferenceBody = z.infer<typeof createReferenceBody>;
+
+export const referenceEnableBody = z.object({ enabled: z.boolean() });
+export type ReferenceEnableBody = z.infer<typeof referenceEnableBody>;
+
+/* POST …/text: one of the reference's texts (GUIDE.md and the like) */
+export const referenceTextBody = z.object({ path: z.string(), text: z.string() });
+export type ReferenceTextBody = z.infer<typeof referenceTextBody>;

package/studio/shared/schemas/settings.ts

@@ -0,0 +1,82 @@
+/* Settings (SettingsPage and the voice components): keys, voice providers and profiles, models,
+   publishing and omnichat options. Each value is still validated by the service. */
+
+import { z } from "zod";
+
+const text = z.string();
+const numberOrText = z.union([z.number(), z.string()]);
+
+/* POST /api/settings/key: an .env key ("" clears it) */
+export const keyBody = z.object({ name: text, value: text });
+export type KeyBody = z.infer<typeof keyBody>;
+
+export const fishModelBody = z.object({ model: text, fallback: text.nullish() });
+export type FishModelBody = z.infer<typeof fishModelBody>;
+
+/* quota and day come as typed in the inputs */
+export const cartesiaPlanBody = z.object({ plan: text, quota: numberOrText.optional(), day: numberOrText });
+export type CartesiaPlanBody = z.infer<typeof cartesiaPlanBody>;
+
+export const fishPriceBody = z.object({ value: numberOrText });
+export type FishPriceBody = z.infer<typeof fishPriceBody>;
+
+export const defaultVoiceBody = z.object({ provider: text });
+export type DefaultVoiceBody = z.infer<typeof defaultVoiceBody>;
+
+export const voiceIdBody = z.object({ provider: text, voice_id: text });
+export type VoiceIdBody = z.infer<typeof voiceIdBody>;
+
+/* POST /api/settings/voice-profile: empty id creates, an existing id edits; one Voice ID per provider */
+export const voiceProfileBody = z.object({
+  id: text.optional(),
+  name: text,
+  order: z.array(text).optional(),
+  avatar: text.optional(),
+  fish: text.optional(),
+  cartesia: text.optional(),
+  voicestudio: text.optional(),
+  elevenlabs: text.optional(),
+});
+export type VoiceProfileBody = z.infer<typeof voiceProfileBody>;
+
+/* default, remove: one profile by id */
+export const profileIdBody = z.object({ id: text });
+export type ProfileIdBody = z.infer<typeof profileIdBody>;
+
+/* POST …/voice-profile/sample: the stored sample of a provider, or "original" (the recording) */
+export const voiceSampleBody = z.object({ id: text, provider: text.optional() });
+export type VoiceSampleBody = z.infer<typeof voiceSampleBody>;
+
+/* POST /api/settings/publish: one config section (publish.<section>), field by field */
+export const publishSettingsBody = z.object({ section: text, values: z.record(z.string(), z.unknown()) });
+export type PublishSettingsBody = z.infer<typeof publishSettingsBody>;
+
+export const omnichatSettingsBody = z.object({ values: z.record(z.string(), z.unknown()) });
+export type OmnichatSettingsBody = z.infer<typeof omnichatSettingsBody>;
+
+const modelChoice = z.object({ model: text, effort: text.optional() });
+/* POST /api/settings/models: the orchestrator, the reference and each stage */
+export const modelsBody = z.object({
+  orchestrator: modelChoice.nullish(),
+  reference: modelChoice.nullish(),
+  stages: z.record(z.string(), modelChoice).optional(),
+});
+export type ModelsBody = z.infer<typeof modelsBody>;
+
+/* POST /api/settings/agents: the agent accounts in rotation order, and Codex's model and sandbox */
+const agentAccount = z.object({
+  id: text.optional(),
+  provider: z.enum(["claude", "codex"]),
+  dir: text,
+  label: text.optional(),
+  enabled: z.boolean().optional(),
+});
+export const agentsBody = z.object({
+  accounts: z.array(agentAccount).optional(),
+  codex: z.object({ model: text.optional(), effort: text.optional(), sandbox: text.optional() }).optional(),
+});
+export type AgentsBody = z.infer<typeof agentsBody>;
+
+/* POST /api/settings/agents/login | clear-limit: one account */
+export const agentIdBody = z.object({ id: text });
+export type AgentIdBody = z.infer<typeof agentIdBody>;

package/studio/shared/schemas/sound.ts

@@ -0,0 +1,22 @@
+/* Sound timeline (SoundTimeline): the draft (plan and save) and the Epidemic download. The draft is
+   the timeline's whole edit, checked piece by piece by the service (tools/sound.mjs rules). */
+
+import { z } from "zod";
+
+export const soundDraftBody = z.looseObject({
+  places: z.array(z.unknown()).optional(),
+  scene_clips: z.record(z.string(), z.unknown()).optional(),
+  line_clips: z.record(z.string(), z.unknown()).optional(),
+  bed: z.unknown().optional(),
+  cuts: z.unknown().optional(),
+  speed: z.unknown().optional(),
+});
+export type SoundDraftBody = z.infer<typeof soundDraftBody>;
+
+/* POST …/sound/download: a captured Epidemic URL and the effect's name */
+export const soundDownloadBody = z.object({ url: z.string(), name: z.string().optional() });
+export type SoundDownloadBody = z.infer<typeof soundDownloadBody>;
+
+/* POST …/sound/capture: an Epidemic page (a playlist, theme or search) the agent opens in Chrome */
+export const soundCaptureBody = z.object({ url: z.string(), name: z.string().optional() });
+export type SoundCaptureBody = z.infer<typeof soundCaptureBody>;

package/studio/shared/schemas/videos.ts

@@ -0,0 +1,38 @@
+/* Videos: the new-video request and the per-video actions outside a stage. */
+
+import { z } from "zod";
+
+/* POST /api/videos (NewVideoPage) */
+export const createVideoBody = z.object({
+  request: z.string(),
+  subject: z.string().optional(),
+  format: z.string().optional(),
+  duration: z.string().optional(),
+  reference: z.string().optional(),
+  voice: z.string().optional(),
+  voice_profile: z.string().optional(),
+  /* false: "Sem narração e voz", no spoken script, narration nor voice (default true) */
+  narration: z.boolean().optional(),
+  deliverables: z.array(z.enum(["video", "carousel"])).optional(),
+});
+export type CreateVideoBody = z.infer<typeof createVideoBody>;
+
+/* POST /api/videos/:slug/reference: swap the style reference after starting */
+export const swapReferenceBody = z.object({ reference: z.string(), note: z.string().optional() });
+export type SwapReferenceBody = z.infer<typeof swapReferenceBody>;
+
+/* POST /api/videos/:slug/archive */
+export const archiveBody = z.object({ archive: z.boolean().optional() });
+export type ArchiveBody = z.infer<typeof archiveBody>;
+
+/* POST /api/videos/:slug/thumbnail: three random (no mode), one with the instruction (manual),
+   or a change to a version */
+export const thumbnailBody = z.object({
+  mode: z.string().optional(),
+  instruction: z.string().optional(),
+  version: z.string().optional(),
+});
+export type ThumbnailBody = z.infer<typeof thumbnailBody>;
+
+export const chooseThumbnailBody = z.object({ version: z.string() });
+export type ChooseThumbnailBody = z.infer<typeof chooseThumbnailBody>;

package/studio/shared/schemas/voices.ts

@@ -0,0 +1,23 @@
+/* Voice stage (VideoVoicePicker, LineTakes, LineTextEditor). */
+
+import { z } from "zod";
+
+/* POST /api/videos/:slug/voice: the video's provider or voice profile */
+export const chooseVoiceBody = z.object({ provider: z.string().optional(), voice_profile: z.string().optional() });
+export type ChooseVoiceBody = z.infer<typeof chooseVoiceBody>;
+
+/* POST …/voice/regenerate: one line, on another provider when given */
+export const regenerateLineBody = z.object({ line: z.string(), provider: z.string().optional() });
+export type RegenerateLineBody = z.infer<typeof regenerateLineBody>;
+
+/* POST …/voice/use: the take kept for the line */
+export const useTakeBody = z.object({ line: z.string(), version: z.string() });
+export type UseTakeBody = z.infer<typeof useTakeBody>;
+
+/* POST …/line/text */
+export const lineTextBody = z.object({ line: z.string(), text: z.string() });
+export type LineTextBody = z.infer<typeof lineTextBody>;
+
+/* POST …/line/remove */
+export const removeLineBody = z.object({ line: z.string() });
+export type RemoveLineBody = z.infer<typeof removeLineBody>;