+ {email} +
{label}
{hint}
{u.intro}
{u.empty}
{u.updated(fromNow(usage.observedAt))}
- +
+ + + {t.chat.approval.wants(bot.name, label)}
+
{approval.summary}
{pretty(approval.input)} @@ -99,7 +102,7 @@ export function ApprovalCard({ approval, bot }: { approval: ApprovalItem; bot: B value={note} onChange={(event) => setNote(event.target.value)} placeholder={t.chat.approval.notePlaceholder} - className="mt-3 h-8 w-full rounded-[3px] border border-line-strong bg-canvas px-2.5 text-sm outline-none placeholder:text-muted focus:border-accent" + className="mt-3 h-9 w-full rounded-xl border border-line-strong bg-canvas px-3 text-sm outline-none placeholder:text-muted focus:border-muted" /> answer(true)}> diff --git a/app/src/features/chat/AttachmentList.tsx b/app/src/features/chat/AttachmentList.tsx index 6994f428..bf71169c 100644 --- a/app/src/features/chat/AttachmentList.tsx +++ b/app/src/features/chat/AttachmentList.tsx @@ -43,7 +43,7 @@ function FileCard({ ? FileText : File; return ( - + @@ -64,7 +64,7 @@ function FileCard({ host.openPath(attachmentFolder(workspace, attachment)), ) } - className="grid h-7 w-7 shrink-0 place-items-center rounded-[3px] text-muted hover:bg-sunken hover:text-ink" + className="grid h-7 w-7 shrink-0 place-items-center rounded-lg text-muted hover:bg-sunken hover:text-ink" > @@ -93,7 +93,7 @@ function Thumbnail({ } if (source.kind === "loading") { return ( - + setOpen(true)} - className="overflow-hidden rounded-md border border-line bg-sunken" + className="overflow-hidden rounded-xl border border-line bg-sunken" title={attachment.name} > {children} : children; +} + function Working() { const t = useT(); return ( @@ -45,10 +53,10 @@ function Working() { className="flex items-center gap-1 py-1 text-muted" aria-label={t.chat.run.working} > - {[0, 150, 300].map((delay) => ( + {[0, 160, 320].map((delay) => ( ))} @@ -67,9 +75,12 @@ export function BotRun({ }) { const first = items[0]; return ( - - - + // A turn shows up as the bot starts it, still empty; what it does then + // arrives inside, so a run with items never animates as a whole. + + {/* Only the run in progress moves, like the bot it stands for. */} + + {bot.name} {first && ( @@ -84,18 +95,27 @@ export function BotRun({ case "tool": return ; case "reply": + // It was already on screen as it was written. return ; case "approval": - return ; + return ( + + + + ); case "turn": - return ; + return ( + + + + ); default: return null; } })} {live?.draft && ( - - + + )} {live && !live.draft && live.working && } diff --git a/app/src/features/chat/ChatComposer.tsx b/app/src/features/chat/ChatComposer.tsx index f1b25d84..2fc1a641 100644 --- a/app/src/features/chat/ChatComposer.tsx +++ b/app/src/features/chat/ChatComposer.tsx @@ -6,6 +6,7 @@ import { type ClipboardEvent, type FormEvent, type KeyboardEvent, + useEffect, useId, useLayoutEffect, useRef, @@ -17,6 +18,8 @@ import { fileSize } from "../../lib/format"; import { type Bot, FIELD_LIMITS } from "../../lib/protocol.gen"; import { useApi } from "../../store/context"; import { rememberImage } from "./images"; +import { ModelPicker } from "./ModelPicker"; +import { ModePicker } from "./ModePicker"; import type { Files, PendingFile } from "./useFiles"; const MAX_HEIGHT_PX = 240; @@ -24,9 +27,9 @@ const MAX_HEIGHT_PX = 240; function Chip({ file, onRemove }: { file: PendingFile; onRemove(): void }) { const t = useT(); return ( - + {file.preview ? ( - + ) : ( )} @@ -64,12 +67,21 @@ export function ChatComposer({ const t = useT(); const [text, setText] = useState(""); const [busy, setBusy] = useState(false); + /** A new mode or model that waits for the bot to finish what it is doing. */ + const [later, setLater] = useState(null); const field = useRef(null); const picker = useRef(null); const fieldId = useId(); const tooLong = text.length > FIELD_LIMITS.message; const empty = !text.trim() && files.files.length === 0; + const working = bot.state === "busy" || bot.state === "needs_approval"; + useEffect(() => { + if (!working) { + setLater(null); + } + }, [working]); + // Grows with the text up to a limit, then scrolls. useLayoutEffect(() => { const element = field.current; @@ -130,14 +142,18 @@ export function ChatComposer({ }; return ( - - {stopped && {t.chat.composer.paused(bot.name)}} - + + {stopped && ( + {t.chat.composer.paused(bot.name)} + )} + {later && ( + + {later} + + )} + {files.files.length > 0 && ( - + {files.files.map((file) => ( files.remove(file.key)} /> ))} @@ -155,15 +171,15 @@ export function ChatComposer({ onKeyDown={onKeyDown} onPaste={onPaste} placeholder={t.chat.composer.placeholder(bot.name)} - className="block max-h-60 w-full resize-none bg-transparent px-3.5 pt-3 pb-1 leading-relaxed outline-none placeholder:text-muted" + className="block max-h-60 w-full resize-none bg-transparent px-4 pt-3.5 pb-1.5 leading-relaxed outline-none placeholder:text-muted" /> - + picker.current?.click()} - className="grid h-8 w-8 place-items-center rounded-[3px] text-muted hover:bg-sunken hover:text-ink" + className="grid h-8 w-8 shrink-0 place-items-center rounded-full text-muted hover:bg-sunken hover:text-ink" > @@ -178,18 +194,27 @@ export function ChatComposer({ event.target.value = ""; }} /> - + + {tooLong ? t.chat.composer.tooLong(text.length, FIELD_LIMITS.message) - : t.chat.composer.keys} + : text && t.chat.composer.keys} + - + diff --git a/app/src/features/chat/ChatView.tsx b/app/src/features/chat/ChatView.tsx index 82b7e59d..8e8754ff 100644 --- a/app/src/features/chat/ChatView.tsx +++ b/app/src/features/chat/ChatView.tsx @@ -2,13 +2,14 @@ // written, and the composer. Files dropped anywhere on it are attached. import { LoaderCircle, Paperclip } from "lucide-react"; -import { type DragEvent, type ReactNode, useLayoutEffect, useRef, useState } from "react"; +import { type DragEvent, type ReactNode, useLayoutEffect, useMemo, useRef, useState } from "react"; import { useT } from "../../i18n"; import { day } from "../../lib/format"; import type { Bot } from "../../lib/protocol.gen"; import { Button } from "../../ui/Button"; import { Callout } from "../../ui/Callout"; -import { BotAvatar } from "../bots/BotAvatar"; +import { SeenSince } from "../../ui/motion"; +import { BotAvatar, moodOf } from "../bots/BotAvatar"; import { BotRun, type Live } from "./BotRun"; import { ChatComposer } from "./ChatComposer"; import { InboundRow } from "./InboundRow"; @@ -31,6 +32,10 @@ export function ChatView({ bot, stopped }: { bot: Bot; stopped: boolean }) { /** Distance from the bottom to keep while older items load above. */ const anchor = useRef(null); const [dragging, setDragging] = useState(false); + // What was there when the owner opened this chat stays still; what + // arrives while they look animates in. + // biome-ignore lint/correctness/useExhaustiveDependencies: a new bot is a new chat + const openedAt = useMemo(() => Date.now(), [bot.id]); const last = chat.items.at(-1); /** Changes whenever the end of the chat does. */ const end = `${chat.items.length}/${last?.id}/${last?.updatedAt}/${chat.draft.length}`; @@ -67,10 +72,10 @@ export function ChatView({ bot, stopped }: { bot: Bot; stopped: boolean }) { const list: ReactNode[] = rows.map((row, index) => { if (row.kind === "day") { return ( - - - {day(row.at)} - + + + {day(row.at)} + ); } @@ -78,7 +83,7 @@ export function ChatView({ bot, stopped }: { bot: Bot; stopped: boolean }) { return ; } if (row.kind === "notice") { - return ; + return ; } const isLast = index === rows.length - 1; return ( @@ -126,7 +131,7 @@ export function ChatView({ bot, stopped }: { bot: Bot; stopped: boolean }) { element.scrollHeight - element.scrollTop - element.clientHeight < STICKY_PX; }} > - + {chat.error && ( {chat.error} @@ -147,18 +152,22 @@ export function ChatView({ bot, stopped }: { bot: Bot; stopped: boolean }) { )} {chat.items.length === 0 && !chat.loading && !chat.error && !live && ( - + + + {t.chat.view.emptyTitle(bot.name)} {bot.role && {bot.role}} {t.chat.view.emptyBody} )} - - {list} - + + + {list} + + - + {dragging && ( - + {t.chat.view.dropToAttach} diff --git a/app/src/features/chat/InboundRow.tsx b/app/src/features/chat/InboundRow.tsx index 39eb95a1..84e41f93 100644 --- a/app/src/features/chat/InboundRow.tsx +++ b/app/src/features/chat/InboundRow.tsx @@ -6,6 +6,7 @@ import { useT } from "../../i18n"; import { when } from "../../lib/format"; import type { Bot, Message } from "../../lib/protocol.gen"; import { useApp } from "../../store/context"; +import { useArrival } from "../../ui/motion"; import { BotAvatar } from "../bots/BotAvatar"; import { DeliveryStatus } from "../messages/DeliveryStatus"; import { AttachmentList } from "./AttachmentList"; @@ -20,12 +21,13 @@ function Time({ at }: { at: number }) { function OwnerMessage({ message, bot }: { message: Message; bot: Bot }) { const delivery = useApp((state) => state.deliveries[message.id]); + const arrival = useArrival(message.createdAt); return ( - + {message.body && ( {message.body} @@ -46,7 +48,7 @@ function TaskTag({ message }: { message: Message }) { } const Icon = message.kind === "task" ? ListTodo : Reply; return ( - + {message.kind === "task" ? t.chat.inbound.task : t.chat.inbound.result} @@ -59,9 +61,14 @@ function OtherMessage({ message }: { message: Message }) { const delivery = useApp((state) => state.deliveries[message.id]); const system = message.fromKind === "system"; const name = system ? "Botloft" : (sender?.name ?? t.chat.inbound.archivedBot); + const arrival = useArrival(message.createdAt); return ( - - + + {name} @@ -70,7 +77,7 @@ function OtherMessage({ message }: { message: Message }) { {message.body} diff --git a/app/src/features/chat/Markdown.tsx b/app/src/features/chat/Markdown.tsx index 0f659c72..f1cdaaca 100644 --- a/app/src/features/chat/Markdown.tsx +++ b/app/src/features/chat/Markdown.tsx @@ -60,9 +60,16 @@ const components: Components = { img: ({ src, alt }) => , }; -export const Markdown = memo(function Markdown({ text }: { text: string }) { +/** `streaming` shows a caret after the text, while the bot still writes it. */ +export const Markdown = memo(function Markdown({ + text, + streaming = false, +}: { + text: string; + streaming?: boolean; +}) { return ( - + {text} diff --git a/app/src/features/chat/ModePicker.tsx b/app/src/features/chat/ModePicker.tsx new file mode 100644 index 00000000..22b6f0af --- /dev/null +++ b/app/src/features/chat/ModePicker.tsx @@ -0,0 +1,137 @@ +// How much the bot may do without asking (spec 7.4), picked below the chat +// as in Claude Code. Bypassing permissions asks first: the bot is then not +// held to its folder. + +import { + ChevronDown, + FilePen, + Hand, + ListTodo, + type LucideIcon, + ShieldOff, + WandSparkles, +} from "lucide-react"; +import { useCallback, useRef, useState } from "react"; +import { useT } from "../../i18n"; +import type { Bot, PermissionMode } from "../../lib/protocol.gen"; +import { useApi, useApp } from "../../store/context"; +import { Confirm } from "../../ui/Confirm"; +import { POPOVER } from "../../ui/surface"; +import { attempt } from "../../ui/toast"; +import { useDismiss } from "../../ui/useDismiss"; +import { PickerOption } from "./PickerOption"; + +const MODES: { mode: PermissionMode; icon: LucideIcon }[] = [ + { mode: "auto", icon: WandSparkles }, + { mode: "default", icon: Hand }, + { mode: "accept_edits", icon: FilePen }, + { mode: "plan", icon: ListTodo }, +]; + +export function ModePicker({ bot, onLater }: { bot: Bot; onLater(text: string): void }) { + const api = useApi(); + const putBot = useApp((state) => state.putBot); + const chief = useApp((state) => state.crews[bot.crewId]?.leadBotId === bot.id); + const m = useT().chat.mode; + const [open, setOpen] = useState(false); + const [confirming, setConfirming] = useState(false); + const root = useRef(null); + const close = useCallback(() => setOpen(false), []); + useDismiss(open, root, close); + + const current = bot.permissionMode; + const bypass = current === "bypass_permissions"; + const Icon = bypass ? ShieldOff : (MODES.find((entry) => entry.mode === current)?.icon ?? Hand); + + const choose = async (mode: PermissionMode) => { + setOpen(false); + if (mode === current) { + return; + } + // The bot restarts into the new mode once nothing is in progress. + const working = bot.state === "busy" || bot.state === "needs_approval"; + await attempt(m.failed, async () => { + putBot(await api.call("bots.setPermissionMode", { botId: bot.id, mode })); + if (working) { + onLater(m.later(bot.name, m.names[mode])); + } + }); + }; + + return ( + + {open && ( + + {m.title} + {MODES.map(({ mode, icon }) => ( + choose(mode)} + /> + ))} + + { + setOpen(false); + if (!bypass) { + setConfirming(true); + } + }} + trailing={ + + {m.turnOn} + + } + /> + + )} + setOpen(!open)} + className={`flex h-8 items-center gap-1.5 rounded-full px-2.5 text-sm transition-colors ${ + bypass + ? "bg-danger/10 text-danger hover:bg-danger/15" + : `text-ink-soft hover:bg-sunken hover:text-ink ${open ? "bg-sunken text-ink" : ""}` + }`} + > + + {m.names[current]} + + + {confirming && ( + choose("bypass_permissions")} + onClose={() => setConfirming(false)} + > + {m.bypassBody(bot.name)} + {m.bypassRisk} + {chief && {m.bypassChief(bot.name)}} + {m.bypassAdvice} + + )} + + ); +} diff --git a/app/src/features/chat/ModelPicker.tsx b/app/src/features/chat/ModelPicker.tsx new file mode 100644 index 00000000..f0d37a12 --- /dev/null +++ b/app/src/features/chat/ModelPicker.tsx @@ -0,0 +1,97 @@ +// Which Claude model the bot runs on (spec 7.4), picked below the chat as +// in Claude's apps. The plan's default shows the model Claude Code named. + +import { ChevronDown } from "lucide-react"; +import { useCallback, useRef, useState } from "react"; +import { useT } from "../../i18n"; +import { modelFamily, modelName } from "../../lib/models"; +import type { Bot, BotModel } from "../../lib/protocol.gen"; +import { useApi, useApp } from "../../store/context"; +import { POPOVER } from "../../ui/surface"; +import { attempt } from "../../ui/toast"; +import { useDismiss } from "../../ui/useDismiss"; +import { PickerOption } from "./PickerOption"; + +const MODELS: BotModel[] = ["default", "fable", "opus", "sonnet", "haiku"]; + +export function ModelPicker({ bot, onLater }: { bot: Bot; onLater(text: string): void }) { + const api = useApi(); + const putBot = useApp((state) => state.putBot); + const m = useT().chat.model; + const [open, setOpen] = useState(false); + const root = useRef(null); + const close = useCallback(() => setOpen(false), []); + useDismiss(open, root, close); + + const current = bot.model; + const inUse = bot.modelInUse ? modelName(bot.modelInUse) : null; + // The version once Claude Code has named it; until then, the choice. + const label = + current === "default" + ? (inUse ?? m.short) + : bot.modelInUse && modelFamily(bot.modelInUse) === current && inUse + ? inUse + : m.names[current]; + + const choose = async (model: BotModel) => { + setOpen(false); + if (model === current) { + return; + } + // The bot restarts on the new model once nothing is in progress. + const working = bot.state === "busy" || bot.state === "needs_approval"; + await attempt(m.failed, async () => { + putBot(await api.call("bots.setModel", { botId: bot.id, model })); + if (working) { + onLater(m.later(bot.name, m.names[model])); + } + }); + }; + + const hint = (model: BotModel) => + model === "default" ? m.hints.default(bot.name, inUse) : m.hints[model](bot.name); + + return ( + + {open && ( + + {m.title} + {MODELS.map((model) => ( + choose(model)} + /> + ))} + + {m.cost} + + + )} + setOpen(!open)} + className={`flex h-8 items-center gap-1 rounded-full px-2.5 text-sm text-ink-soft transition-colors hover:bg-sunken hover:text-ink ${ + open ? "bg-sunken text-ink" : "" + }`} + > + {label} + + + + ); +} diff --git a/app/src/features/chat/NoticeRow.tsx b/app/src/features/chat/NoticeRow.tsx index c9ef6526..8a0f2d67 100644 --- a/app/src/features/chat/NoticeRow.tsx +++ b/app/src/features/chat/NoticeRow.tsx @@ -4,20 +4,23 @@ import { CircleAlert, Info, TriangleAlert } from "lucide-react"; import { type Messages, useT } from "../../i18n"; import type { NoticeItem } from "../../lib/protocol.gen"; +import { useArrival } from "../../ui/motion"; const LOOK = { - info: { icon: Info, tone: "text-work", frame: "border-line" }, - warning: { icon: TriangleAlert, tone: "text-warn", frame: "border-warn/50" }, - error: { icon: CircleAlert, tone: "text-danger", frame: "border-danger/50" }, + info: { icon: Info, tone: "text-work", frame: "border-line bg-panel" }, + warning: { icon: TriangleAlert, tone: "text-warn", frame: "border-warn/40 bg-warn/6" }, + error: { icon: CircleAlert, tone: "text-danger", frame: "border-danger/40 bg-danger/6" }, } as const; -export function NoticeRow({ notice }: { notice: NoticeItem }) { +/** `at` is when the notice came, so a new one animates in. */ +export function NoticeRow({ notice, at = 0 }: { notice: NoticeItem; at?: number }) { const t = useT(); const { icon: Icon, tone, frame } = LOOK[notice.level]; + const arrival = useArrival(at); return ( @@ -36,6 +39,8 @@ function noticeText(notice: NoticeItem, words: Messages["chat"]["notice"]): stri return words.usageLimit; case "turn_failed": return words.turnFailed(notice.text); + case "model_unavailable": + return words.modelUnavailable; default: return notice.text; } diff --git a/app/src/features/chat/PickerOption.tsx b/app/src/features/chat/PickerOption.tsx new file mode 100644 index 00000000..6c6a843e --- /dev/null +++ b/app/src/features/chat/PickerOption.tsx @@ -0,0 +1,47 @@ +// One choice in a picker below the chat (mode, model): a name, a line +// about what it means for the bot, and a check on the current one. + +import { Check, type LucideIcon } from "lucide-react"; +import type { ReactNode } from "react"; +import { POPOVER_ITEM } from "../../ui/surface"; + +export function PickerOption({ + icon: Icon, + name, + hint, + checked, + danger = false, + trailing, + onSelect, +}: { + icon?: LucideIcon; + name: string; + hint: string; + checked: boolean; + danger?: boolean; + trailing?: ReactNode; + onSelect(): void; +}) { + return ( + + {Icon && ( + + )} + + {name} + {hint} + + {checked ? : trailing} + + ); +} diff --git a/app/src/features/chat/PlanCard.tsx b/app/src/features/chat/PlanCard.tsx new file mode 100644 index 00000000..44157ecd --- /dev/null +++ b/app/src/features/chat/PlanCard.tsx @@ -0,0 +1,110 @@ +// A bot in plan mode asking to go ahead (spec 10.1): Claude Code asks for +// it as the ExitPlanMode tool, with the plan. Approving lets the bot work; +// sending it back keeps it planning, with what should change. + +import { Check, ChevronRight, ListTodo, PencilLine, TimerOff } from "lucide-react"; +import { useId } from "react"; +import { useT } from "../../i18n"; +import type { ApprovalItem, Bot } from "../../lib/protocol.gen"; +import { Button } from "../../ui/Button"; +import { Markdown } from "./Markdown"; +import { useAnswer } from "./useAnswer"; + +export const PLAN_TOOL = "ExitPlanMode"; + +/** The plan in the request's input; the input itself if it is not JSON. */ +export function planText(input: string): string { + try { + const parsed: unknown = JSON.parse(input); + if (typeof parsed === "object" && parsed !== null && "plan" in parsed) { + const { plan } = parsed; + if (typeof plan === "string") { + return plan; + } + } + } catch { + // Cut short or not JSON: show it as it came. + } + return input; +} + +export function PlanCard({ approval, bot }: { approval: ApprovalItem; bot: Bot }) { + const p = useT().chat.plan; + const { note, setNote, busy, answer } = useAnswer(approval, { + allow: p.approveFailed, + deny: p.keepFailed, + }); + const noteId = useId(); + const plan = planText(approval.input); + if (approval.status !== "pending") { + return ; + } + + return ( + + + + + + {p.ready(bot.name)} + + + + + + + {p.noteLabel(bot.name)} + + setNote(event.target.value)} + placeholder={p.notePlaceholder} + className="block w-full resize-none rounded-xl border border-line-strong bg-panel px-3 py-2 text-sm outline-none placeholder:text-muted focus:border-muted" + /> + <div className="mt-2.5 flex flex-wrap gap-2"> + <Button variant="primary" icon={Check} disabled={busy} onClick={() => answer(true)}> + {p.approve} + </Button> + <Button icon={PencilLine} disabled={busy} onClick={() => answer(false)}> + {p.keepPlanning} + </Button> + </div> + </div> + </section> + ); +} + +/** One line once answered; the plan stays a click away. */ +function Answered({ approval, plan }: { approval: ApprovalItem; plan: string }) { + const p = useT().chat.plan; + const [Icon, text, tone] = + approval.status === "allowed" + ? [Check, p.approved, "text-ok"] + : approval.status === "denied" + ? [PencilLine, p.sentBack, "text-work"] + : [TimerOff, p.expired, "text-quiet"]; + return ( + <details className="group"> + <summary className="flex min-w-0 cursor-default items-center gap-2 rounded-lg px-1.5 py-1 text-sm hover:bg-sunken"> + <Icon aria-hidden size={14} className={`shrink-0 ${tone}`} /> + <span className="shrink-0 font-medium">{text}</span> + {approval.note && ( + <span className="truncate text-muted text-xs">{`“${approval.note}”`}</span> + )} + <ChevronRight + aria-hidden + size={13} + className="shrink-0 text-muted transition-transform group-open:rotate-90" + /> + </summary> + <div className="mt-1.5 ml-6 rounded-xl border border-line bg-panel px-4 py-3" data-selectable> + <Markdown text={plan} /> + </div> + </details> + ); +} diff --git a/app/src/features/chat/SuggestionCard.tsx b/app/src/features/chat/SuggestionCard.tsx new file mode 100644 index 00000000..1d87109b --- /dev/null +++ b/app/src/features/chat/SuggestionCard.tsx @@ -0,0 +1,171 @@ +// The crew's chief suggesting a new bot (spec 10.2). The owner can change +// the name, role, model and instructions before creating it, or say no +// with a note for the chief. Once answered it shrinks to one line. + +import { Ban, Check, ChevronRight, TimerOff, UserPlus } from "lucide-react"; +import { useId, useState } from "react"; +import { useT } from "../../i18n"; +import type { ApprovalItem, Bot, BotModel } from "../../lib/protocol.gen"; +import { Button } from "../../ui/Button"; +import { SelectField, TextArea, TextField } from "../../ui/Field"; +import { useAnswer } from "./useAnswer"; + +export const SUGGEST_TOOL = "mcp__botloft__suggest_bot"; + +const MODELS: BotModel[] = ["default", "fable", "opus", "sonnet", "haiku"]; + +interface Suggestion { + name: string; + role: string; + instructions: string; + model?: BotModel; + reason: string; +} + +/** The suggestion in the request's input; empty fields if it is cut short. */ +export function suggestionOf(input: string): Suggestion { + try { + const parsed = JSON.parse(input) as Partial<Suggestion>; + return { + name: parsed.name ?? "", + role: parsed.role ?? "", + instructions: parsed.instructions ?? "", + ...(parsed.model && { model: parsed.model }), + reason: parsed.reason ?? "", + }; + } catch { + return { name: "", role: "", instructions: input, reason: "" }; + } +} + +export function SuggestionCard({ approval, bot }: { approval: ApprovalItem; bot: Bot }) { + const t = useT(); + const s = t.chat.suggestion; + const asked = suggestionOf(approval.input); + const [edited, setEdited] = useState<Suggestion>(asked); + const { note, setNote, busy, answer } = useAnswer(approval, { + allow: s.createFailed, + deny: s.declineFailed, + }); + const noteId = useId(); + if (approval.status !== "pending") { + return <Answered approval={approval} />; + } + const changed = JSON.stringify(edited) !== JSON.stringify(asked); + const set = (field: keyof Suggestion) => (value: string) => + setEdited((current) => ({ ...current, [field]: value })); + + return ( + <section + aria-label={s.title(bot.name)} + className="my-1 overflow-hidden rounded-2xl border border-line bg-panel shadow-sm animate-attention" + > + <p className="flex items-center gap-2.5 border-line border-b px-4 py-3 font-semibold text-sm"> + <span className="grid h-7 w-7 place-items-center rounded-full bg-accent/12 text-accent"> + <UserPlus aria-hidden size={15} /> + </span> + {s.title(bot.name)} + </p> + <div className="flex flex-col gap-3 px-4 py-3"> + {asked.reason && ( + <p className="text-ink-soft text-sm" data-selectable> + <span className="font-medium text-ink">{s.why}: </span> + {asked.reason} + </p> + )} + <div className="grid grid-cols-[1fr_12rem] gap-3"> + <TextField + label={s.name} + value={edited.name} + onChange={(event) => set("name")(event.target.value)} + /> + <SelectField + label={s.model} + value={edited.model ?? "default"} + onChange={(event) => set("model")(event.target.value)} + options={MODELS.map((value) => ({ value, label: t.chat.model.names[value] }))} + /> + </div> + <TextField + label={s.role} + value={edited.role} + onChange={(event) => set("role")(event.target.value)} + /> + <TextArea + label={s.instructions} + value={edited.instructions} + rows={5} + onChange={(event) => set("instructions")(event.target.value)} + /> + <p className="text-muted text-xs">{s.startsNow(bot.name)}</p> + </div> + <div className="border-line border-t bg-canvas/40 px-4 py-3"> + <label htmlFor={noteId} className="sr-only"> + {s.noteLabel(bot.name)} + </label> + <textarea + id={noteId} + rows={2} + value={note} + onChange={(event) => setNote(event.target.value)} + placeholder={s.notePlaceholder(bot.name)} + className="block w-full resize-none rounded-xl border border-line-strong bg-panel px-3 py-2 text-sm outline-none placeholder:text-muted focus:border-muted" + /> + <div className="mt-2.5 flex flex-wrap gap-2"> + <Button + variant="primary" + icon={Check} + disabled={busy || !edited.name.trim()} + onClick={() => answer(true, changed ? JSON.stringify(edited) : undefined)} + > + {s.create} + </Button> + <Button icon={Ban} disabled={busy} onClick={() => answer(false)}> + {s.decline} + </Button> + </div> + </div> + </section> + ); +} + +/** One line once answered; what was suggested stays a click away. */ +function Answered({ approval }: { approval: ApprovalItem }) { + const t = useT(); + const s = t.chat.suggestion; + const suggestion = suggestionOf(approval.input); + const name = suggestion.name || s.name; + const [Icon, text, tone] = + approval.status === "allowed" + ? [Check, s.created(name), "text-ok"] + : approval.status === "denied" + ? [Ban, s.declined(name), "text-danger"] + : [TimerOff, s.expired(name), "text-quiet"]; + return ( + <details className="group"> + <summary className="flex min-w-0 cursor-default items-center gap-2 rounded-lg px-1.5 py-1 text-sm hover:bg-sunken"> + <Icon aria-hidden size={14} className={`shrink-0 ${tone}`} /> + <span className="shrink-0 font-medium">{text}</span> + {approval.note && ( + <span className="truncate text-muted text-xs">{`“${approval.note}”`}</span> + )} + <ChevronRight + aria-hidden + size={13} + className="shrink-0 text-muted transition-transform group-open:rotate-90" + /> + </summary> + <dl + className="mt-1.5 ml-6 grid grid-cols-[auto_1fr] gap-x-3 gap-y-1 rounded-xl border border-line bg-panel px-4 py-3 text-sm" + data-selectable + > + <dt className="text-muted">{s.role}</dt> + <dd>{suggestion.role}</dd> + <dt className="text-muted">{s.model}</dt> + <dd>{t.chat.model.names[suggestion.model ?? "default"]}</dd> + <dt className="text-muted">{s.instructions}</dt> + <dd className="whitespace-pre-wrap">{suggestion.instructions}</dd> + </dl> + </details> + ); +} diff --git a/app/src/features/chat/ToolLines.tsx b/app/src/features/chat/ToolLines.tsx index 1cbecb96..dcc8a53a 100644 --- a/app/src/features/chat/ToolLines.tsx +++ b/app/src/features/chat/ToolLines.tsx @@ -9,10 +9,12 @@ import { FileText, Globe, ListChecks, + ListTodo, LoaderCircle, type LucideIcon, Send, SquareTerminal, + UserPlus, Users, Wrench, X, @@ -20,6 +22,7 @@ import { import { useState } from "react"; import { useT } from "../../i18n"; import type { ChatItem, ToolItem } from "../../lib/protocol.gen"; +import { useArrival } from "../../ui/motion"; const ICONS: Record<string, LucideIcon> = { Bash: SquareTerminal, @@ -34,9 +37,11 @@ const ICONS: Record<string, LucideIcon> = { WebFetch: Globe, WebSearch: Globe, TodoWrite: ListChecks, + ExitPlanMode: ListTodo, Task: Users, Agent: Users, send_message: Send, + suggest_bot: UserPlus, }; /** `mcp__botloft__send_message` reads as `send_message`. */ @@ -71,20 +76,21 @@ function Status({ status }: { status: ToolItem["status"] }) { } } -function ToolLine({ tool }: { tool: ToolItem }) { +function ToolLine({ tool, createdAt }: { tool: ToolItem; createdAt: number }) { const t = useT(); const [open, setOpen] = useState(false); + const arrival = useArrival(createdAt); const label = toolLabel(tool.name); const Icon = ICONS[label] ?? Wrench; const block = - "max-h-64 overflow-auto whitespace-pre-wrap break-all rounded-[3px] border border-line bg-sunken px-2.5 py-1.5 font-mono text-xs leading-relaxed"; + "max-h-64 overflow-auto whitespace-pre-wrap break-all rounded-lg border border-line bg-sunken px-2.5 py-1.5 font-mono text-xs leading-relaxed"; return ( - <li> + <li className={arrival}> <button type="button" aria-expanded={open} onClick={() => setOpen(!open)} - className="group flex w-full min-w-0 items-center gap-2 rounded-[3px] px-1.5 py-1 text-left text-sm hover:bg-sunken" + className="group flex w-full min-w-0 items-center gap-2 rounded-lg px-1.5 py-1 text-left text-sm transition-colors hover:bg-sunken" > <Icon aria-hidden size={14} className="shrink-0 text-muted" /> <span className="shrink-0 font-medium">{label}</span> @@ -99,7 +105,7 @@ function ToolLine({ tool }: { tool: ToolItem }) { /> </button> {open && ( - <div className="mt-1 mb-2 ml-7 flex flex-col gap-1.5" data-selectable> + <div className="mt-1 mb-2 ml-7 flex animate-rise flex-col gap-1.5" data-selectable> <p className="text-muted text-xs">{t.chat.tools.input}</p> <pre className={block}>{pretty(tool.input)}</pre> {tool.output !== null && ( @@ -121,7 +127,9 @@ export function ToolLines({ items }: { items: ChatItem[] }) { return ( <ul aria-label={t.chat.tools.label} className="-mx-1.5 flex flex-col"> {items.map((item) => - item.body.kind === "tool" ? <ToolLine key={item.id} tool={item.body} /> : null, + item.body.kind === "tool" ? ( + <ToolLine key={item.id} tool={item.body} createdAt={item.createdAt} /> + ) : null, )} </ul> ); diff --git a/app/src/features/chat/models.test.tsx b/app/src/features/chat/models.test.tsx new file mode 100644 index 00000000..50bf6038 --- /dev/null +++ b/app/src/features/chat/models.test.tsx @@ -0,0 +1,94 @@ +import { act, cleanup, fireEvent, screen, within } from "@testing-library/react"; +import { afterEach, describe, expect, test } from "vitest"; +import { FakeBotloft } from "../../lib/fake"; +import { crewOpened, openBot, renderApp } from "../../test/app"; + +afterEach(cleanup); + +/** A crew "Ops" with @scout, open on its chat. */ +async function openScout(setup?: (fake: FakeBotloft, botId: string) => void) { + const fake = new FakeBotloft(); + const ops = fake.addCrew("Ops"); + const scout = fake.addBot(ops.id, "Scout", "Finds sources"); + fake.setBotState(scout.id, "idle"); + setup?.(fake, scout.id); + renderApp(fake); + await crewOpened("Ops"); + openBot("Scout"); + await screen.findByRole("list", { name: "Messages" }); + return { fake, scout }; +} + +const picker = () => screen.getByRole("button", { name: /^Model: / }); +const modelCalls = (fake: FakeBotloft) => + fake.calls.filter((call) => call.method === "bots.setModel"); + +function choose(name: RegExp) { + fireEvent.click(picker()); + const menu = screen.getByRole("menu", { name: "Model" }); + fireEvent.click(within(menu).getByRole("menuitemradio", { name })); +} + +describe("models", () => { + test("a bot runs on the plan's default until the owner picks a model", async () => { + const { fake, scout } = await openScout(); + expect(picker().getAttribute("aria-label")).toBe("Model: Default"); + fireEvent.click(picker()); + const menu = screen.getByRole("menu", { name: "Model" }); + const plan = within(menu).getByRole("menuitemradio", { name: /Plan default/ }); + expect(plan.getAttribute("aria-checked")).toBe("true"); + expect(within(menu).getByText(/use up your plan's limit faster/)).toBeDefined(); + fireEvent.click(within(menu).getByRole("menuitemradio", { name: /Haiku/ })); + + await screen.findByRole("button", { name: "Model: Haiku" }); + expect(modelCalls(fake).at(-1)?.params).toEqual({ botId: scout.id, model: "haiku" }); + expect(screen.queryByText(/switches to/)).toBeNull(); + }); + + test("the plan's default is named once Claude Code reported it", async () => { + await openScout((fake, botId) => { + fake.bot(botId).modelInUse = "claude-opus-5-5"; + }); + expect(picker().getAttribute("aria-label")).toBe("Model: Opus 5.5"); + fireEvent.click(picker()); + expect(screen.getByText("Scout uses your plan's default model, now Opus 5.5")).toBeDefined(); + }); + + test("a busy bot changes model when it finishes what it is doing", async () => { + const { fake, scout } = await openScout(); + act(() => fake.setBotState(scout.id, "busy")); + choose(/Sonnet/); + expect( + await screen.findByText("Scout switches to Sonnet when it finishes what it's doing."), + ).toBeDefined(); + }); + + test("a model the plan does not have is told in the owner's words", async () => { + const { fake, scout } = await openScout(); + act(() => { + fake.chat.add(scout.id, { + kind: "notice", + level: "error", + code: "model_unavailable", + text: "Claude Code could not use this bot's model.", + }); + }); + expect(await screen.findByText(/may not be on your Claude plan/)).toBeDefined(); + }); + + test("a new bot can start on a chosen model", async () => { + const fake = new FakeBotloft(); + fake.addCrew("Ops"); + renderApp(fake); + await crewOpened("Ops"); + const [headerButton] = await screen.findAllByRole("button", { name: "New bot" }); + fireEvent.click(headerButton as HTMLElement); + const dialog = screen.getByRole("dialog", { name: "New bot" }); + fireEvent.change(within(dialog).getByLabelText("Name"), { target: { value: "Writer" } }); + fireEvent.change(within(dialog).getByLabelText("Model"), { target: { value: "sonnet" } }); + fireEvent.click(within(dialog).getByRole("button", { name: "Create bot" })); + await screen.findByRole("button", { name: "Model: Sonnet" }); + const create = fake.calls.find((call) => call.method === "bots.create"); + expect(create?.params).toMatchObject({ name: "Writer", model: "sonnet" }); + }); +}); diff --git a/app/src/features/chat/modes.test.tsx b/app/src/features/chat/modes.test.tsx new file mode 100644 index 00000000..9cfff293 --- /dev/null +++ b/app/src/features/chat/modes.test.tsx @@ -0,0 +1,113 @@ +import { act, cleanup, fireEvent, screen, within } from "@testing-library/react"; +import { afterEach, describe, expect, test } from "vitest"; +import { FakeBotloft } from "../../lib/fake"; +import { crewOpened, openBot, renderApp } from "../../test/app"; + +afterEach(cleanup); + +/** A crew "Ops" with @scout, open on its chat. */ +async function openScout() { + const fake = new FakeBotloft(); + const ops = fake.addCrew("Ops"); + const scout = fake.addBot(ops.id, "Scout", "Finds sources"); + fake.setBotState(scout.id, "idle"); + renderApp(fake); + await crewOpened("Ops"); + openBot("Scout"); + await screen.findByRole("list", { name: "Messages" }); + return { fake, scout }; +} + +const picker = () => screen.getByRole("button", { name: /^Mode: / }); +const modeCalls = (fake: FakeBotloft) => + fake.calls.filter((call) => call.method === "bots.setPermissionMode"); + +function choose(name: RegExp) { + fireEvent.click(picker()); + const menu = screen.getByRole("menu", { name: "Mode" }); + fireEvent.click(within(menu).getByRole("menuitemradio", { name: name })); +} + +describe("permission modes", () => { + test("a bot starts in Manual and the owner picks another mode", async () => { + const { fake, scout } = await openScout(); + expect(picker().getAttribute("aria-label")).toBe("Mode: Manual"); + fireEvent.click(picker()); + const menu = screen.getByRole("menu", { name: "Mode" }); + const manual = within(menu).getByRole("menuitemradio", { name: /Manual/ }); + expect(manual.getAttribute("aria-checked")).toBe("true"); + fireEvent.click(within(menu).getByRole("menuitemradio", { name: /Accept edits/ })); + + await screen.findByRole("button", { name: "Mode: Accept edits" }); + expect(screen.queryByRole("menu", { name: "Mode" })).toBeNull(); + expect(modeCalls(fake).at(-1)?.params).toEqual({ botId: scout.id, mode: "accept_edits" }); + // Nothing was running: no note about waiting. + expect(screen.queryByText(/switches to/)).toBeNull(); + }); + + test("bypassing permissions asks first, then marks the bot in red", async () => { + const { fake } = await openScout(); + choose(/Bypass permissions/); + const dialog = screen.getByRole("dialog", { name: "Let Scout do anything without asking?" }); + expect(within(dialog).getByText(/other bots' files/)).toBeDefined(); + fireEvent.click(within(dialog).getByRole("button", { name: "Cancel" })); + expect(modeCalls(fake)).toHaveLength(0); + expect(screen.queryByText("Asks nothing")).toBeNull(); + + choose(/Bypass permissions/); + fireEvent.click(screen.getByRole("button", { name: "Turn on" })); + await screen.findByRole("button", { name: "Mode: Bypass permissions" }); + expect(screen.getByText("Asks nothing")).toBeDefined(); + expect(modeCalls(fake).at(-1)?.params).toMatchObject({ mode: "bypass_permissions" }); + }); + + test("a busy bot changes mode when it finishes what it is doing", async () => { + const { fake, scout } = await openScout(); + act(() => fake.setBotState(scout.id, "busy")); + choose(/Plan/); + expect( + await screen.findByText("Scout switches to Plan when it finishes what it's doing."), + ).toBeDefined(); + act(() => fake.setBotState(scout.id, "idle")); + expect(screen.queryByText(/switches to Plan/)).toBeNull(); + }); +}); + +describe("plans", () => { + const PLAN = "## Cache the report\n\n1. Save it once a week"; + + function askToGoAhead(fake: FakeBotloft, botId: string) { + act(() => { + fake.chat.ask(botId, "ExitPlanMode", "Cache the report", JSON.stringify({ plan: PLAN })); + }); + return screen.getByRole("region", { name: "Scout made a plan and wants to go ahead" }); + } + + test("the plan shows in full and approving it lets the bot go ahead", async () => { + const { fake, scout } = await openScout(); + await act(() => fake.call("bots.setPermissionMode", { botId: scout.id, mode: "plan" })); + const card = askToGoAhead(fake, scout.id); + expect(within(card).getByRole("heading", { name: "Cache the report" })).toBeDefined(); + expect(within(card).getByText("Save it once a week")).toBeDefined(); + + fireEvent.click(within(card).getByRole("button", { name: "Approve plan" })); + expect(await screen.findByText("You approved the plan")).toBeDefined(); + const answer = fake.calls.find((call) => call.method === "approvals.answer"); + expect(answer?.params).toMatchObject({ allow: true }); + // As Claude Code does, the bot left plan mode. + expect(await screen.findByRole("button", { name: "Mode: Manual" })).toBeDefined(); + }); + + test("keeping on planning sends back what should change", async () => { + const { fake, scout } = await openScout(); + const card = askToGoAhead(fake, scout.id); + fireEvent.change(within(card).getByLabelText("What Scout should change in the plan"), { + target: { value: "Keep the cache in memory" }, + }); + fireEvent.click(within(card).getByRole("button", { name: "Keep planning" })); + expect(await screen.findByText("You asked for changes to the plan")).toBeDefined(); + expect(screen.getByText("“Keep the cache in memory”")).toBeDefined(); + const answer = fake.calls.find((call) => call.method === "approvals.answer"); + expect(answer?.params).toMatchObject({ allow: false, note: "Keep the cache in memory" }); + }); +}); diff --git a/app/src/features/chat/useAnswer.ts b/app/src/features/chat/useAnswer.ts new file mode 100644 index 00000000..1f249343 --- /dev/null +++ b/app/src/features/chat/useAnswer.ts @@ -0,0 +1,28 @@ +import { useState } from "react"; +import type { ApprovalItem } from "../../lib/protocol.gen"; +import { useApi } from "../../store/context"; +import { attempt } from "../../ui/toast"; + +/** + * Answering a request; the note goes to the bot on a denial. `input` is a + * bot suggestion as the owner changed it (spec 10.2). + */ +export function useAnswer(approval: ApprovalItem, failed: { allow: string; deny: string }) { + const api = useApi(); + const [note, setNote] = useState(""); + const [busy, setBusy] = useState(false); + const answer = async (allow: boolean, input?: string) => { + setBusy(true); + const trimmed = note.trim(); + await attempt(allow ? failed.allow : failed.deny, () => + api.call("approvals.answer", { + approvalId: approval.approvalId, + allow, + ...(allow || !trimmed ? {} : { note: trimmed }), + ...(allow && input !== undefined ? { input } : {}), + }), + ); + setBusy(false); + }; + return { note, setNote, busy, answer }; +} diff --git a/app/src/features/crews/CrewBots.tsx b/app/src/features/crews/CrewBots.tsx index 22fdfbf1..fb35bd5e 100644 --- a/app/src/features/crews/CrewBots.tsx +++ b/app/src/features/crews/CrewBots.tsx @@ -3,8 +3,9 @@ import { useT } from "../../i18n"; import type { Bot, Crew } from "../../lib/protocol.gen"; import { useApp } from "../../store/context"; import { Button } from "../../ui/Button"; -import { BotAvatar } from "../bots/BotAvatar"; +import { BotAvatar, moodOf } from "../bots/BotAvatar"; import { BotStateBadge } from "../bots/BotStateBadge"; +import { ChiefBadge, isChief } from "../bots/ChiefBadge"; /** The crew's bots as cards; a card opens the bot. */ export function CrewBots({ crew, bots, onNewBot }: { crew: Crew; bots: Bot[]; onNewBot(): void }) { @@ -12,7 +13,7 @@ export function CrewBots({ crew, bots, onNewBot }: { crew: Crew; bots: Bot[]; on const selectBot = useApp((state) => state.selectBot); if (bots.length === 0) { return ( - <div className="border border-line border-dashed px-6 py-10 text-center"> + <div className="rounded-2xl border border-line border-dashed px-6 py-10 text-center"> <p className="font-medium">{t.crews.bots.empty(crew.name)}</p> <p className="mt-1 text-muted text-sm">{t.crews.bots.emptyHint}</p> <Button className="mt-4" variant="primary" icon={Plus} onClick={onNewBot}> @@ -28,12 +29,15 @@ export function CrewBots({ crew, bots, onNewBot }: { crew: Crew; bots: Bot[]; on <button type="button" onClick={() => selectBot(bot.id)} - className="flex h-full w-full flex-col gap-2 border border-line bg-panel p-3 text-left hover:border-line-strong" + className="flex h-full w-full flex-col gap-2 rounded-xl border border-line bg-panel p-3.5 text-left transition-[border-color,transform,box-shadow] duration-200 hover:-translate-y-0.5 hover:border-line-strong hover:shadow-sm" > <div className="flex w-full items-center gap-2.5"> - <BotAvatar color={bot.color} size={32} /> + <BotAvatar color={bot.color} size={32} mood={moodOf(bot, crew.paused)} /> <div className="min-w-0 flex-1"> - <p className="truncate font-semibold">{bot.name}</p> + <p className="flex items-center gap-1.5"> + <span className="truncate font-semibold">{bot.name}</span> + {isChief(bot, crew) && <ChiefBadge crew={crew} compact />} + </p> <p className="truncate font-mono text-muted text-xs">@{bot.handle}</p> </div> </div> diff --git a/app/src/features/crews/CrewDialog.tsx b/app/src/features/crews/CrewDialog.tsx index c73a5f92..1703010a 100644 --- a/app/src/features/crews/CrewDialog.tsx +++ b/app/src/features/crews/CrewDialog.tsx @@ -1,19 +1,27 @@ import { type FormEvent, useState } from "react"; import { useT } from "../../i18n"; import { errorText } from "../../lib/api"; -import { type Crew, FIELD_LIMITS } from "../../lib/protocol.gen"; +import { type BotModel, type Crew, FIELD_LIMITS } from "../../lib/protocol.gen"; import { useApi, useApp } from "../../store/context"; import { Button } from "../../ui/Button"; import { Dialog } from "../../ui/Dialog"; -import { TextField } from "../../ui/Field"; +import { SelectField, TextArea, TextField } from "../../ui/Field"; +import { WorkFolderField } from "./WorkFolderField"; -/** Creates a crew, or renames `crew`. */ +const MODELS: BotModel[] = ["default", "fable", "opus", "sonnet", "haiku"]; + +/** Creates a crew with its chief, or renames `crew`. */ export function CrewDialog({ crew, onClose }: { crew?: Crew; onClose(): void }) { const t = useT(); const api = useApi(); const putCrew = useApp((state) => state.putCrew); const selectCrew = useApp((state) => state.selectCrew); const [name, setName] = useState(crew?.name ?? ""); + const [folder, setFolder] = useState<string | null>(null); + const [goal, setGoal] = useState(""); + const [chiefModel, setChiefModel] = useState<BotModel>("default"); + const selectBot = useApp((state) => state.selectBot); + const putBot = useApp((state) => state.putBot); const [error, setError] = useState<string | null>(null); const [busy, setBusy] = useState(false); @@ -22,12 +30,31 @@ export function CrewDialog({ crew, onClose }: { crew?: Crew; onClose(): void }) setBusy(true); setError(null); try { + const d = t.crews.dialog; const saved = crew ? await api.call("crews.rename", { crewId: crew.id, name }) - : await api.call("crews.create", { name }); + : await api.call("crews.create", { + name, + ...(folder && { workFolder: folder }), + // Every new crew starts with its chief (spec 10.2). + lead: { + name: d.chiefName, + role: d.chiefRole, + instructions: goal.trim(), + ...(chiefModel !== "default" && { model: chiefModel }), + }, + }); putCrew(saved); if (!crew) { selectCrew(saved.id); + // Straight to the chief's chat, to say what the crew should do. + const bots = await api.call("bots.list", { crewId: saved.id }); + for (const bot of bots) { + putBot(bot); + } + if (saved.leadBotId) { + selectBot(saved.leadBotId); + } } onClose(); } catch (failure) { @@ -61,6 +88,26 @@ export function CrewDialog({ crew, onClose }: { crew?: Crew; onClose(): void }) autoFocus required /> + {!crew && ( + <> + <TextArea + label={t.crews.dialog.goal} + value={goal} + rows={3} + max={FIELD_LIMITS.instructions} + onChange={(event) => setGoal(event.target.value)} + placeholder={t.crews.dialog.goalPlaceholder} + hint={t.crews.dialog.goalHint} + /> + <WorkFolderField value={folder} onChange={setFolder} /> + <SelectField + label={t.crews.dialog.chiefModel} + value={chiefModel} + onChange={(event) => setChiefModel(event.target.value as BotModel)} + options={MODELS.map((value) => ({ value, label: t.chat.model.names[value] }))} + /> + </> + )} {error && ( <p role="alert" className="text-danger text-sm"> {error} diff --git a/app/src/features/crews/CrewView.tsx b/app/src/features/crews/CrewView.tsx index 22d63e04..ce4fb906 100644 --- a/app/src/features/crews/CrewView.tsx +++ b/app/src/features/crews/CrewView.tsx @@ -1,8 +1,18 @@ -import { Archive, Ellipsis, FolderOpen, Pause, Pencil, Play, Plus } from "lucide-react"; +import { + Archive, + Ellipsis, + Folder, + FolderInput, + FolderOpen, + Pause, + Pencil, + Play, + Plus, +} from "lucide-react"; import { useState } from "react"; import { useShallow } from "zustand/react/shallow"; import { useT } from "../../i18n"; -import type { Bot, Crew } from "../../lib/protocol.gen"; +import type { Crew } from "../../lib/protocol.gen"; import { botsOf } from "../../store/app"; import { useApi, useApp, useHost } from "../../store/context"; import { Button } from "../../ui/Button"; @@ -17,13 +27,7 @@ import { TaskList } from "../tasks/TaskList"; import { CrewBots } from "./CrewBots"; import { CrewDialog } from "./CrewDialog"; -/** The crew's `shared` folder, next to its bots' workspaces (spec 5). */ -export function sharedFolder(bots: Bot[]): string | null { - const workspace = bots[0]?.workspace; - return workspace ? workspace.replace(/[\\/][^\\/]+$/, "\\shared") : null; -} - -type Open = "bot" | "rename" | "archive" | null; +type Open = "bot" | "rename" | "archive" | { move: string } | null; type Pane = "bots" | "timeline" | "tasks"; export function CrewView({ crew }: { crew: Crew }) { @@ -35,7 +39,6 @@ export function CrewView({ crew }: { crew: Crew }) { const bots = useApp(useShallow((state) => botsOf(state, crew.id))); const [open, setOpen] = useState<Open>(null); const [pane, setPane] = useState<Pane>("bots"); - const shared = sharedFolder(bots); const close = () => setOpen(null); const tabs: Tab<Pane>[] = [ { id: "bots", label: words.tabs.bots }, @@ -43,6 +46,15 @@ export function CrewView({ crew }: { crew: Crew }) { { id: "tasks", label: words.tabs.tasks }, ]; + const openFolder = () => attempt(words.failed.openFolder, () => host.openPath(crew.workFolder)); + const pickFolder = () => + attempt(words.failed.changeFolder, async () => { + const folder = await host.pickFolder(t.crews.dialog.pickTitle, crew.workFolder); + if (folder && folder !== crew.workFolder) { + setOpen({ move: folder }); + } + }); + const setPaused = (paused: boolean) => attempt(paused ? words.failed.pause : words.failed.resume, async () => putCrew(await api.call("crews.setPaused", { crewId: crew.id, paused })), @@ -53,9 +65,21 @@ export function CrewView({ crew }: { crew: Crew }) { <header className="flex items-center gap-3 border-line border-b px-5 py-3.5"> <div className="min-w-0 flex-1"> <h1 className="truncate font-semibold text-xl tracking-tight">{crew.name}</h1> - <p className="mt-0.5 text-muted text-sm"> - {words.bots(bots.length)} - {crew.paused && ` · ${words.pausedNote}`} + <p className="mt-0.5 flex min-w-0 items-center gap-1.5 text-muted text-sm"> + <span className="shrink-0"> + {words.bots(bots.length)} + {crew.paused && ` · ${words.pausedNote}`} + </span> + <span aria-hidden>·</span> + <button + type="button" + onClick={openFolder} + title={words.openFolder} + className="flex min-w-0 items-center gap-1 rounded-md px-1 hover:bg-sunken hover:text-ink" + > + <Folder aria-hidden size={13} className="shrink-0" /> + <span className="truncate">{words.folder(crew.workFolder)}</span> + </button> </p> </div> <Button variant="primary" icon={Plus} onClick={() => setOpen("bot")}> @@ -75,13 +99,8 @@ export function CrewView({ crew }: { crew: Crew }) { icon={Ellipsis} items={[ { label: t.crews.rename, icon: Pencil, onSelect: () => setOpen("rename") }, - { - label: words.openShared, - icon: FolderOpen, - disabled: !shared, - onSelect: () => - shared && attempt(words.failed.openFolder, () => host.openPath(shared)), - }, + { label: words.openFolder, icon: FolderOpen, onSelect: openFolder }, + { label: words.changeFolder, icon: FolderInput, onSelect: pickFolder }, { label: words.archive, icon: Archive, @@ -127,6 +146,22 @@ export function CrewView({ crew }: { crew: Crew }) { {open === "bot" && <BotDialog crewId={crew.id} onClose={close} />} {open === "rename" && <CrewDialog crew={crew} onClose={close} />} + {typeof open === "object" && open !== null && ( + <Confirm + title={words.moveTitle(crew.name)} + confirmLabel={words.move} + onClose={close} + onConfirm={() => + attempt(words.failed.changeFolder, async () => + putCrew( + await api.call("crews.setWorkFolder", { crewId: crew.id, workFolder: open.move }), + ), + ) + } + > + {words.moveBody(open.move)} + </Confirm> + )} {open === "archive" && ( <Confirm title={words.archiveTitle(crew.name)} diff --git a/app/src/features/crews/Sidebar.tsx b/app/src/features/crews/Sidebar.tsx index eb2239bb..1d894481 100644 --- a/app/src/features/crews/Sidebar.tsx +++ b/app/src/features/crews/Sidebar.tsx @@ -7,8 +7,11 @@ import type { Activity, Bot, Crew } from "../../lib/protocol.gen"; import { botsOf, crewList } from "../../store/app"; import { useApp } from "../../store/context"; import { Button } from "../../ui/Button"; -import { BotAvatar } from "../bots/BotAvatar"; +import { APP_OPENED } from "../../ui/motion"; +import { AccountArea } from "../account/AccountArea"; +import { BotAvatar, moodOf } from "../bots/BotAvatar"; import { BotStateBadge, stateView } from "../bots/BotStateBadge"; +import { ChiefBadge, isChief } from "../bots/ChiefBadge"; import { CrewDialog } from "./CrewDialog"; /** Crews as sections and their bots as conversations (spec 15.1). */ @@ -17,34 +20,34 @@ export function Sidebar() { const crews = useApp(useShallow(crewList)); const [creating, setCreating] = useState(false); return ( - <nav - aria-label={t.crews.sidebar.label} - className="flex w-72 shrink-0 flex-col border-line border-r bg-panel" - > - <div className="flex h-10 shrink-0 items-center justify-between pr-1.5 pl-4"> - <h2 className="font-semibold text-muted text-xs uppercase tracking-[0.12em]"> - {t.crews.sidebar.label} - </h2> - <Button - variant="ghost" - size="sm" - icon={Plus} - label={t.crews.newCrew} - onClick={() => setCreating(true)} - /> - </div> - <ul className="min-h-0 flex-1 overflow-y-auto pb-3"> - {crews.map((crew) => ( - <CrewEntry key={crew.id} crew={crew} /> - ))} - </ul> + <div className="flex w-72 shrink-0 flex-col border-line border-r bg-panel"> + <nav aria-label={t.crews.sidebar.label} className="flex min-h-0 flex-1 flex-col"> + <div className="flex h-10 shrink-0 items-center justify-between pr-1.5 pl-4"> + <h2 className="font-semibold text-muted text-xs uppercase tracking-[0.12em]"> + {t.crews.sidebar.label} + </h2> + <Button + variant="ghost" + size="sm" + icon={Plus} + label={t.crews.newCrew} + onClick={() => setCreating(true)} + /> + </div> + <ul className="min-h-0 flex-1 overflow-y-auto px-2 pb-3"> + {crews.map((crew) => ( + <CrewEntry key={crew.id} crew={crew} /> + ))} + </ul> + </nav> + <AccountArea /> {creating && <CrewDialog onClose={() => setCreating(false)} />} - </nav> + </div> ); } -const row = "relative flex w-full items-center text-left hover:bg-sunken"; -const marker = "before:absolute before:inset-y-0 before:left-0 before:w-[3px] before:bg-accent"; +const row = + "relative flex w-full items-center rounded-lg text-left transition-colors duration-150 hover:bg-sunken"; function CrewEntry({ crew }: { crew: Crew }) { const t = useT(); @@ -58,7 +61,7 @@ function CrewEntry({ crew }: { crew: Crew }) { type="button" aria-current={selected ? "page" : undefined} onClick={() => selectCrew(crew.id)} - className={`${row} h-8 gap-2 pr-3 pl-4 font-semibold text-sm ${selected ? `bg-sunken ${marker}` : ""}`} + className={`${row} h-8 gap-2 px-2.5 font-semibold text-sm ${selected ? "bg-sunken" : ""}`} > <span className="min-w-0 flex-1 truncate">{crew.name}</span> {crew.paused && ( @@ -83,18 +86,21 @@ function Conversation({ bot, crew }: { bot: Bot; crew: Crew }) { const selectBot = useApp((state) => state.selectBot); const activity = bot.lastActivity; return ( - <li> + <li className={bot.createdAt > APP_OPENED ? "animate-rise" : undefined}> <button type="button" aria-current={selected ? "page" : undefined} aria-label={`${bot.name}, ${stateView(bot, crew.paused).label}`} onClick={() => selectBot(bot.id)} - className={`${row} gap-2.5 py-2 pr-3 pl-4 ${selected ? `bg-sunken ${marker}` : ""}`} + className={`${row} gap-2.5 px-2.5 py-2 ${selected ? "bg-sunken" : ""}`} > - <BotAvatar color={bot.color} size={32} /> + <BotAvatar color={bot.color} size={32} mood={moodOf(bot, crew.paused)} /> <span className="min-w-0 flex-1"> <span className="flex items-baseline gap-2"> - <span className="min-w-0 flex-1 truncate font-medium text-sm">{bot.name}</span> + <span className="flex min-w-0 flex-1 items-center gap-1"> + <span className="truncate font-medium text-sm">{bot.name}</span> + {isChief(bot, crew) && <ChiefBadge crew={crew} compact />} + </span> {activity && ( <time className="shrink-0 text-muted text-xs" diff --git a/app/src/features/crews/WorkFolderField.tsx b/app/src/features/crews/WorkFolderField.tsx new file mode 100644 index 00000000..370d22ad --- /dev/null +++ b/app/src/features/crews/WorkFolderField.tsx @@ -0,0 +1,58 @@ +// Where a new crew works (spec 5): a folder the owner picks with Windows' +// folder picker, or a new one inside Botloft. + +import { Folder, X } from "lucide-react"; +import { useT } from "../../i18n"; +import { useHost } from "../../store/context"; +import { Button } from "../../ui/Button"; +import { attempt } from "../../ui/toast"; + +export function WorkFolderField({ + value, + onChange, +}: { + value: string | null; + onChange(folder: string | null): void; +}) { + const words = useT().crews.dialog; + const failed = useT().crews.view.failed.changeFolder; + const host = useHost(); + + const pick = () => + attempt(failed, async () => { + const folder = await host.pickFolder(words.pickTitle, value ?? undefined); + if (folder) { + onChange(folder); + } + }); + + return ( + <fieldset className="flex flex-col gap-1"> + <legend className="mb-1 font-medium text-ink-soft text-sm">{words.folder}</legend> + <div className="flex items-center gap-2"> + <p + className="flex h-8 min-w-0 flex-1 items-center gap-2 rounded-lg border border-line-strong bg-canvas px-2.5 text-sm" + title={value ?? undefined} + > + <Folder aria-hidden size={15} className="shrink-0 text-muted" /> + <span className={`truncate ${value ? "text-ink" : "text-muted"}`}> + {value ?? words.folderDefault} + </span> + </p> + {value && ( + <button + type="button" + aria-label={words.useDefault} + title={words.useDefault} + onClick={() => onChange(null)} + className="grid h-8 w-8 shrink-0 place-items-center rounded-lg text-muted hover:bg-sunken hover:text-ink" + > + <X aria-hidden size={15} /> + </button> + )} + <Button onClick={pick}>{words.chooseFolder}</Button> + </div> + <p className="text-muted text-xs">{words.folderHint}</p> + </fieldset> + ); +} diff --git a/app/src/features/crews/chief.test.tsx b/app/src/features/crews/chief.test.tsx new file mode 100644 index 00000000..a7116b4f --- /dev/null +++ b/app/src/features/crews/chief.test.tsx @@ -0,0 +1,127 @@ +import { act, cleanup, fireEvent, screen, within } from "@testing-library/react"; +import { afterEach, describe, expect, test } from "vitest"; +import { FakeBotloft } from "../../lib/fake"; +import { SUGGEST_TOOL } from "../../lib/fakeChat"; +import { crewOpened, openBot, renderApp, sidebar } from "../../test/app"; + +afterEach(cleanup); + +const DESIGNER = { + name: "Designer", + role: "Draws each page", + instructions: "Design the pages in shared/design.", + model: "sonnet", + reason: "The site needs a look before anyone builds it.", +}; + +/** A crew "Site" with its chief, open on the chief's chat. */ +async function openChief() { + const fake = new FakeBotloft(); + const site = fake.call("crews.create", { + name: "Site", + lead: { name: "Chief", role: "Leads the crew", instructions: "Build the site" }, + }); + const crew = await site; + const chiefId = crew.leadBotId as string; + fake.setBotState(chiefId, "idle"); + renderApp(fake); + await crewOpened("Site"); + openBot("Chief"); + await screen.findByRole("list", { name: "Messages" }); + return { fake, crew, chiefId }; +} + +function suggest(fake: FakeBotloft, chiefId: string) { + act(() => { + fake.chat.ask(chiefId, SUGGEST_TOOL, "Designer", JSON.stringify(DESIGNER)); + }); + return screen.getByRole("region", { name: "Chief suggests a new bot" }); +} + +const answer = (fake: FakeBotloft) => + fake.calls.find((call) => call.method === "approvals.answer")?.params; + +describe("the crew's chief", () => { + test("a new crew starts with a chief, from the crew's goal", async () => { + const fake = new FakeBotloft(); + fake.addCrew("Ops"); + renderApp(fake); + await crewOpened("Ops"); + fireEvent.click(screen.getByRole("button", { name: "New crew" })); + const dialog = screen.getByRole("dialog", { name: "New crew" }); + fireEvent.change(within(dialog).getByLabelText("Name"), { target: { value: "Bakery" } }); + fireEvent.change(within(dialog).getByLabelText("What is this crew for?"), { + target: { value: "Build my bakery's website" }, + }); + fireEvent.change(within(dialog).getByLabelText("Chief's model"), { + target: { value: "opus" }, + }); + fireEvent.click(within(dialog).getByRole("button", { name: "Create crew" })); + + expect(await screen.findByRole("heading", { level: 1, name: "Chief" })).toBeDefined(); + const create = fake.calls.find((call) => call.method === "crews.create"); + expect(create?.params).toMatchObject({ + name: "Bakery", + lead: { name: "Chief", instructions: "Build my bakery's website", model: "opus" }, + }); + // The crown, in the header and the conversation list. + expect(screen.getAllByTitle(/^Leads Bakery/)).toHaveLength(2); + }); + + test("the owner creates the bot the chief suggests", async () => { + const { fake, chiefId } = await openChief(); + const card = suggest(fake, chiefId); + expect(within(card).getByText(DESIGNER.reason)).toBeDefined(); + expect((within(card).getByLabelText("Name") as HTMLInputElement).value).toBe("Designer"); + fireEvent.click(within(card).getByRole("button", { name: "Create bot" })); + + expect(await screen.findByText("You created Designer")).toBeDefined(); + expect(answer(fake)).toEqual({ approvalId: expect.any(String), allow: true }); + expect(within(sidebar()).getByRole("button", { name: /^Designer/ })).toBeDefined(); + }); + + test("the owner can change the suggestion before creating it", async () => { + const { fake, chiefId } = await openChief(); + const card = suggest(fake, chiefId); + fireEvent.change(within(card).getByLabelText("Name"), { target: { value: "Illustrator" } }); + fireEvent.change(within(card).getByLabelText("Model"), { target: { value: "haiku" } }); + fireEvent.click(within(card).getByRole("button", { name: "Create bot" })); + + expect(await screen.findByText("You created Illustrator")).toBeDefined(); + const sent = answer(fake) as { input: string }; + expect(JSON.parse(sent.input)).toMatchObject({ name: "Illustrator", model: "haiku" }); + const illustrator = [...fake.bots.values()].find((bot) => bot.name === "Illustrator"); + expect(illustrator?.model).toBe("haiku"); + }); + + test("saying no tells the chief why", async () => { + const { fake, chiefId } = await openChief(); + const card = suggest(fake, chiefId); + fireEvent.change(within(card).getByLabelText("What to tell Chief if you say no"), { + target: { value: "The writer can do it" }, + }); + fireEvent.click(within(card).getByRole("button", { name: "Not now" })); + + expect(await screen.findByText("You said no to Designer")).toBeDefined(); + expect(answer(fake)).toMatchObject({ allow: false, note: "The writer can do it" }); + expect([...fake.bots.values()].some((bot) => bot.name === "Designer")).toBe(false); + }); + + test("the owner moves the chief to another bot", async () => { + const { fake, crew } = await openChief(); + act(() => { + fake.setBotState(fake.addBot(crew.id, "Writer").id, "idle"); + }); + openBot("Writer"); + await screen.findByRole("heading", { level: 1, name: "Writer" }); + fireEvent.click(screen.getByRole("button", { name: "More bot actions" })); + fireEvent.click(screen.getByRole("menuitem", { name: "Make crew chief" })); + + // The header and the conversation list of the new chief. + await screen.findByText("Chief", { selector: "header span" }); + const moved = fake.calls.find((call) => call.method === "crews.setLead"); + expect(moved?.params).toMatchObject({ crewId: crew.id }); + fireEvent.click(screen.getByRole("button", { name: "More bot actions" })); + expect(screen.getByRole("menuitem", { name: "Stop being chief" })).toBeDefined(); + }); +}); diff --git a/app/src/features/crews/folders.test.tsx b/app/src/features/crews/folders.test.tsx new file mode 100644 index 00000000..87b15cd2 --- /dev/null +++ b/app/src/features/crews/folders.test.tsx @@ -0,0 +1,95 @@ +import { cleanup, fireEvent, screen, within } from "@testing-library/react"; +import { afterEach, describe, expect, test } from "vitest"; +import { FakeBotloft } from "../../lib/fake"; +import { FakeHost } from "../../lib/fakeHost"; +import { crewOpened, renderApp } from "../../test/app"; + +afterEach(cleanup); + +const PROJECT = "D:\\Projects\\Bakery site"; + +describe("work folders", () => { + test("a new crew can work in a folder the owner picks", async () => { + const fake = new FakeBotloft(); + fake.addCrew("Ops"); + const host = new FakeHost(); + host.nextFolder = PROJECT; + renderApp(fake, host); + await crewOpened("Ops"); + + fireEvent.click(screen.getByRole("button", { name: "New crew" })); + const dialog = screen.getByRole("dialog", { name: "New crew" }); + fireEvent.change(within(dialog).getByLabelText("Name"), { target: { value: "Bakery" } }); + expect(within(dialog).getByText("A new folder inside Botloft")).toBeDefined(); + fireEvent.click(within(dialog).getByRole("button", { name: "Choose folder…" })); + expect(await within(dialog).findByText(PROJECT)).toBeDefined(); + fireEvent.click(within(dialog).getByRole("button", { name: "Create crew" })); + + // The new crew opens on its chief's chat. + await screen.findByRole("heading", { level: 1, name: "Chief" }); + const create = fake.calls.find((call) => call.method === "crews.create"); + expect(create?.params).toMatchObject({ name: "Bakery", workFolder: PROJECT }); + const bakery = [...fake.crews.values()].find((crew) => crew.name === "Bakery"); + expect(bakery?.workFolder).toBe(PROJECT); + }); + + test("without a choice the crew gets a new folder", async () => { + const fake = new FakeBotloft(); + fake.addCrew("Ops"); + const host = new FakeHost(); + host.nextFolder = PROJECT; + renderApp(fake, host); + await crewOpened("Ops"); + + fireEvent.click(screen.getByRole("button", { name: "New crew" })); + const dialog = screen.getByRole("dialog", { name: "New crew" }); + fireEvent.change(within(dialog).getByLabelText("Name"), { target: { value: "Bakery" } }); + fireEvent.click(within(dialog).getByRole("button", { name: "Choose folder…" })); + await within(dialog).findByText(PROJECT); + fireEvent.click(within(dialog).getByRole("button", { name: "Use a new folder" })); + fireEvent.click(within(dialog).getByRole("button", { name: "Create crew" })); + + await screen.findByRole("heading", { level: 1, name: "Chief" }); + const create = fake.calls.find((call) => call.method === "crews.create"); + expect(create?.params).not.toHaveProperty("workFolder"); + const bakery = [...fake.crews.values()].find((crew) => crew.name === "Bakery"); + expect(bakery?.workFolderChosen).toBe(false); + }); + + test("the owner opens the folder and moves the crew to another one", async () => { + const fake = new FakeBotloft(); + const ops = fake.addCrew("Ops"); + const host = new FakeHost(); + renderApp(fake, host); + await crewOpened("Ops"); + + fireEvent.click(screen.getByRole("button", { name: /^Works in / })); + expect(host.opened).toEqual([ops.workFolder]); + + host.nextFolder = PROJECT; + fireEvent.click(screen.getByRole("button", { name: "More crew actions" })); + fireEvent.click(screen.getByRole("menuitem", { name: "Change work folder…" })); + const confirm = await screen.findByRole("dialog", { name: "Move Ops to another folder?" }); + expect(host.pickerStarts).toEqual([ops.workFolder]); + expect(within(confirm).getByText(/restarts when it finishes/)).toBeDefined(); + fireEvent.click(within(confirm).getByRole("button", { name: "Move" })); + + expect(await screen.findByText(`Works in ${PROJECT}`)).toBeDefined(); + const move = fake.calls.find((call) => call.method === "crews.setWorkFolder"); + expect(move?.params).toEqual({ crewId: ops.id, workFolder: PROJECT }); + }); + + test("cancelling the picker changes nothing", async () => { + const fake = new FakeBotloft(); + fake.addCrew("Ops"); + const host = new FakeHost(); + host.nextFolder = null; + renderApp(fake, host); + await crewOpened("Ops"); + fireEvent.click(screen.getByRole("button", { name: "More crew actions" })); + fireEvent.click(screen.getByRole("menuitem", { name: "Change work folder…" })); + await Promise.resolve(); + expect(screen.queryByRole("dialog")).toBeNull(); + expect(fake.calls.some((call) => call.method === "crews.setWorkFolder")).toBe(false); + }); +}); diff --git a/app/src/features/messages/Composer.tsx b/app/src/features/messages/Composer.tsx index 25d4c243..8ed6dd85 100644 --- a/app/src/features/messages/Composer.tsx +++ b/app/src/features/messages/Composer.tsx @@ -73,7 +73,7 @@ export function Composer({ aria-label={t.messages.composer.recipient} value={to ?? ""} onChange={(event) => setChosen(event.target.value)} - className="h-7 rounded-[3px] border border-line-strong bg-canvas px-1.5 text-sm" + className="h-7 rounded-lg border border-line-strong bg-canvas px-1.5 text-sm" > {bots.map((bot) => ( <option key={bot.id} value={bot.id}> @@ -94,7 +94,7 @@ export function Composer({ onChange={(event) => setBody(event.target.value)} onKeyDown={onKeyDown} placeholder={t.messages.composer.placeholder(recipient?.handle)} - className="min-h-16 flex-1 resize-y rounded-[3px] border border-line-strong bg-canvas px-2.5 py-2 text-sm leading-relaxed outline-none placeholder:text-muted focus:border-accent" + className="min-h-16 flex-1 resize-y rounded-xl border border-line-strong bg-canvas px-2.5 py-2 text-sm leading-relaxed outline-none placeholder:text-muted focus:border-accent" /> <Button variant="primary" diff --git a/app/src/features/messages/FailedDeliveries.tsx b/app/src/features/messages/FailedDeliveries.tsx index aad7658d..52ebeeec 100644 --- a/app/src/features/messages/FailedDeliveries.tsx +++ b/app/src/features/messages/FailedDeliveries.tsx @@ -99,7 +99,7 @@ function FailedDialog({ dead, onClose }: { dead: Delivery[]; onClose(): void }) } > <p className="mb-3 text-ink-soft text-sm">{text.explanation}</p> - <ul className="flex flex-col border border-line"> + <ul className="flex flex-col overflow-hidden rounded-xl border border-line"> {dead.map((delivery) => { const bot = bots[delivery.botId]; const message = bodies[delivery.messageId]; diff --git a/app/src/features/messages/MessageRow.tsx b/app/src/features/messages/MessageRow.tsx index d917abad..835adeb6 100644 --- a/app/src/features/messages/MessageRow.tsx +++ b/app/src/features/messages/MessageRow.tsx @@ -32,7 +32,7 @@ function Sender({ message, bots }: { message: Message; bots: Record<BotId, Bot> case "system": return ( <span className="inline-flex items-center gap-1.5 font-medium"> - <BotAvatar color="#ffffff" size={14} /> + <BotAvatar color="#ffffff" size={14} framed /> {t.messages.row.system} </span> ); @@ -56,7 +56,7 @@ function TaskTag({ message, task }: { message: Message; task: Task | undefined } : text.taskStatus[task.status]; } return ( - <span className="inline-flex items-center gap-1 border border-line px-1.5 text-muted text-xs"> + <span className="inline-flex items-center gap-1 rounded-md border border-line px-1.5 text-muted text-xs"> <Icon aria-hidden size={11} /> {message.kind === "task" ? text.task : text.result} {detail && <span>· {detail}</span>} diff --git a/app/src/features/onboarding/Welcome.tsx b/app/src/features/onboarding/Welcome.tsx index 3ecb421d..5d9e803b 100644 --- a/app/src/features/onboarding/Welcome.tsx +++ b/app/src/features/onboarding/Welcome.tsx @@ -3,6 +3,7 @@ import { type ReactNode, useState } from "react"; import { useT } from "../../i18n"; import { useApp } from "../../store/context"; import { Button } from "../../ui/Button"; +import { BotAvatar } from "../bots/BotAvatar"; import { CrewDialog } from "../crews/CrewDialog"; import { ClaudeCodeHelp } from "./ClaudeCodeHelp"; import { SignInButton } from "./SignIn"; @@ -56,14 +57,17 @@ export function Welcome() { return ( <main className="min-h-0 flex-1 overflow-y-auto p-8"> <div className="mx-auto max-w-xl"> + <span className="mb-3 inline-block animate-float"> + <BotAvatar color="#ff7a59" size={56} mood="idle" /> + </span> <h1 className="font-semibold text-2xl tracking-tight">{w.title}</h1> <p className="mt-1 text-ink-soft leading-relaxed">{w.intro}</p> - <ul className="mt-6 flex flex-col border border-line bg-panel"> + <ul className="mt-6 flex flex-col overflow-hidden rounded-xl border border-line bg-panel"> <Check state="ok" title={w.botloft} detail={w.running} /> {claude} {account} </ul> - <div className="mt-4 border border-line bg-panel p-4 text-sm leading-relaxed"> + <div className="mt-4 rounded-xl border border-line bg-panel p-4 text-sm leading-relaxed"> <p className="font-semibold">{w.askFirstTitle}</p> <p className="mt-1 text-ink-soft">{w.askFirstBody}</p> </div> diff --git a/app/src/features/tasks/TaskList.tsx b/app/src/features/tasks/TaskList.tsx index f6281a5d..f6912a24 100644 --- a/app/src/features/tasks/TaskList.tsx +++ b/app/src/features/tasks/TaskList.tsx @@ -58,7 +58,7 @@ export function TaskList({ crewId }: { crewId: CrewId }) { type="button" aria-pressed={show === option} onClick={() => setShow(option)} - className={`h-7 rounded-[3px] px-2.5 font-medium text-sm ${show === option ? "bg-ink text-canvas" : "text-ink-soft hover:bg-sunken"}`} + className={`h-7 rounded-lg px-2.5 font-medium text-sm ${show === option ? "bg-ink text-canvas" : "text-ink-soft hover:bg-sunken"}`} > {option === "open" ? words.open : words.all} </button> diff --git a/app/src/i18n/en/account.ts b/app/src/i18n/en/account.ts new file mode 100644 index 00000000..da35e870 --- /dev/null +++ b/app/src/i18n/en/account.ts @@ -0,0 +1,43 @@ +// The account area at the bottom of the sidebar: who the owner is, the +// plan's usage, settings, language, what's new and help. + +export const account = { + open: (name: string) => `${name}: account and settings`, + plan: (plan: string) => `${plan} plan`, + notSignedIn: "Not signed in to Claude", + menu: { + usage: "Usage", + settings: "Settings", + language: "Language", + whatsNew: "What's new", + help: "Help", + openFailed: "Could not open the page", + }, + usage: { + title: "Usage", + intro: "How much of your Claude plan your bots have used. It updates whenever a bot works.", + empty: "Usage shows up after a bot's first reply.", + windows: { + five_hour: "5-hour window", + seven_day: "This week", + seven_day_opus: "This week, Opus", + seven_day_sonnet: "This week, Sonnet", + } as Record<string, string>, + used: (percent: number) => `${percent}% used`, + resets: (relative: string) => `Resets ${relative}`, + limited: "Limit reached. Your bots wait until it resets.", + updated: (relative: string) => `Updated ${relative}`, + }, + settings: { + title: "Settings", + appearance: "Appearance", + theme: "Theme", + themes: { system: "System", light: "Light", dark: "Dark" }, + size: "Size", + sizeHint: "Ctrl+= and Ctrl+- change the size too, and Ctrl+0 goes back to the default.", + language: "Language", + about: "About", + claudeCode: (version: string) => `Claude Code ${version}`, + botloft: (version: string) => `Botloft ${version}`, + }, +}; diff --git a/app/src/i18n/en/bots.ts b/app/src/i18n/en/bots.ts index 25c5c338..14d5b269 100644 --- a/app/src/i18n/en/bots.ts +++ b/app/src/i18n/en/bots.ts @@ -29,6 +29,10 @@ export const bots = { /** Paused (the bot or its crew) and not running. */ paused: { label: "Paused", hint: "Paused; resume to start it." }, }, + chief: { + badge: "Chief", + hint: (crew: string) => `Leads ${crew}: plans the work and suggests new bots`, + }, header: { noRole: "No role", pause: "Pause", @@ -40,12 +44,15 @@ export const bots = { edit: "Edit", restartFresh: "Restart with a new conversation", openFolder: "Open folder", + makeChief: "Make crew chief", + stopChief: "Stop being chief", archive: "Archive bot", failed: { pause: "Could not pause the bot", resume: "Could not resume the bot", restart: "Could not restart the bot", openFolder: "Could not open the folder", + chief: "Could not change the chief", archive: "Could not archive the bot", }, fresh: { diff --git a/app/src/i18n/en/chat.ts b/app/src/i18n/en/chat.ts index d1c83aed..c718682b 100644 --- a/app/src/i18n/en/chat.ts +++ b/app/src/i18n/en/chat.ts @@ -74,6 +74,96 @@ export const chat = { denied: (tool: string) => `You denied ${tool}`, expired: (tool: string) => `${tool} was not approved in time`, }, + mode: { + title: "Mode", + button: (mode: string) => `Mode: ${mode}`, + names: { + auto: "Auto", + default: "Manual", + accept_edits: "Accept edits", + plan: "Plan", + bypass_permissions: "Bypass permissions", + }, + hints: { + auto: (bot: string) => `${bot} decides what needs your OK`, + default: (bot: string) => `${bot} always asks before making changes`, + accept_edits: (bot: string) => `${bot} edits files without asking`, + plan: (bot: string) => `${bot} makes a plan before making changes`, + bypass_permissions: (bot: string) => `${bot} does everything without asking`, + }, + turnOn: "Turn on", + failed: "Could not change the mode", + later: (bot: string, mode: string) => + `${bot} switches to ${mode} when it finishes what it's doing.`, + bypassTitle: (bot: string) => `Let ${bot} do anything without asking?`, + bypassBody: (bot: string) => + `${bot} will edit files, run commands and use the internet on this computer without asking you first.`, + bypassRisk: + "It is not limited to its folder: it can read and change your other files, other bots' files and Botloft's own files. A message from someone else could get it to do something you did not want.", + bypassChief: (bot: string) => + `${bot} leads its crew, so it will also create new bots without asking you.`, + bypassAdvice: + "Turn this on only for a bot you trust with everything, and only while you need it.", + badge: "Asks nothing", + badgeHint: + "This bot does everything without asking. Change it in the mode picker below the chat.", + }, + model: { + title: "Model", + button: (model: string) => `Model: ${model}`, + names: { + default: "Plan default", + fable: "Fable", + opus: "Opus", + sonnet: "Sonnet", + haiku: "Haiku", + }, + short: "Default", + hints: { + default: (bot: string, inUse: string | null) => + inUse + ? `${bot} uses your plan's default model, now ${inUse}` + : `${bot} uses your plan's default model`, + fable: (bot: string) => `${bot} is at its most capable, for the hardest work`, + opus: (bot: string) => `${bot} handles long, complex tasks well`, + sonnet: (bot: string) => `${bot} is fast and capable, good for most work`, + haiku: (bot: string) => `${bot} is quickest and uses less of your plan, for simple tasks`, + }, + cost: "More capable models use up your plan's limit faster.", + failed: "Could not change the model", + later: (bot: string, model: string) => + `${bot} switches to ${model} when it finishes what it's doing.`, + }, + suggestion: { + title: (bot: string) => `${bot} suggests a new bot`, + why: "Why", + name: "Name", + role: "Role", + model: "Model", + instructions: "Instructions", + startsNow: (bot: string) => `It starts right away and gets its work from ${bot}.`, + noteLabel: (bot: string) => `What to tell ${bot} if you say no`, + notePlaceholder: (bot: string) => `If you say no, tell ${bot} why (optional)`, + create: "Create bot", + decline: "Not now", + createFailed: "Could not create the bot", + declineFailed: "Could not send the answer", + created: (name: string) => `You created ${name}`, + declined: (name: string) => `You said no to ${name}`, + expired: (name: string) => `${name} was not answered in time`, + }, + plan: { + ready: (bot: string) => `${bot} made a plan and wants to go ahead`, + noteLabel: (bot: string) => `What ${bot} should change in the plan`, + notePlaceholder: "What should change? Sent to the bot if you keep planning (optional)", + approve: "Approve plan", + keepPlanning: "Keep planning", + approveFailed: "Could not approve the plan", + keepFailed: "Could not send it back", + approved: "You approved the plan", + sentBack: "You asked for changes to the plan", + expired: "The plan was not approved in time", + }, markdown: { image: "image", openLinkFailed: "Could not open the link", @@ -82,6 +172,8 @@ export const chat = { signedOut: "Claude Code is not signed in, or the account can't be used right now. Sign in to Claude, or check your Claude plan.", usageLimit: "Your Claude plan reached its usage limit. Messages wait until it resets.", + modelUnavailable: + "This bot's model isn't available: it may not be on your Claude plan. Pick another model below the chat.", turnFailed: (detail: string) => `The bot couldn't finish this: ${detail}`, }, }; diff --git a/app/src/i18n/en/crews.ts b/app/src/i18n/en/crews.ts index e97a1efa..0ea025b5 100644 --- a/app/src/i18n/en/crews.ts +++ b/app/src/i18n/en/crews.ts @@ -15,6 +15,19 @@ export const crews = { awaitingApproval: (text: string) => `Waiting for approval: ${text}`, }, dialog: { + folder: "Work folder", + folderHint: "Where the bots put what they make. It can be a folder you already use.", + folderDefault: "A new folder inside Botloft", + chooseFolder: "Choose folder…", + pickTitle: "Choose where the crew works", + useDefault: "Use a new folder", + goal: "What is this crew for?", + goalPlaceholder: "Build and keep up my bakery's website", + goalHint: + "The crew starts with a chief, who reads this, plans the work and suggests the bots it needs.", + chiefModel: "Chief's model", + chiefName: "Chief", + chiefRole: "Leads the crew: plans the work, suggests new bots and hands out tasks", renameTitle: "Rename crew", create: "Create crew", name: "Name", @@ -28,7 +41,13 @@ export const crews = { pause: "Pause crew", resume: "Resume crew", moreActions: "More crew actions", - openShared: "Open shared folder", + folder: (path: string) => `Works in ${path}`, + openFolder: "Open work folder", + changeFolder: "Change work folder…", + moveTitle: (crew: string) => `Move ${crew} to another folder?`, + moveBody: (path: string) => + `The bots will work in ${path}. Each one restarts when it finishes what it's doing. Files already made stay where they are.`, + move: "Move", archive: "Archive crew", tabs: { label: "Crew views", @@ -46,6 +65,7 @@ export const crews = { failed: { pause: "Could not pause the crew", resume: "Could not resume the crew", + changeFolder: "Could not change the folder", openFolder: "Could not open the folder", archive: "Could not archive the crew", }, diff --git a/app/src/i18n/en/index.ts b/app/src/i18n/en/index.ts index 7e0ceee4..774883e6 100644 --- a/app/src/i18n/en/index.ts +++ b/app/src/i18n/en/index.ts @@ -1,5 +1,6 @@ // English, the reference: every other language has exactly this shape. +import { account } from "./account"; import { bots } from "./bots"; import { chat } from "./chat"; import { common } from "./common"; @@ -9,6 +10,16 @@ import { onboarding } from "./onboarding"; import { shell } from "./shell"; import { updates } from "./updates"; -export const en = { common, shell, onboarding, updates, bots, chat, crews, messages }; +export const en = { + common, + shell, + onboarding, + updates, + account, + bots, + chat, + crews, + messages, +}; export type Messages = typeof en; diff --git a/app/src/i18n/en/onboarding.ts b/app/src/i18n/en/onboarding.ts index a7401a55..05fe3a18 100644 --- a/app/src/i18n/en/onboarding.ts +++ b/app/src/i18n/en/onboarding.ts @@ -45,7 +45,7 @@ export const onboarding = { welcome: { title: "Welcome to Botloft", intro: - "A crew is a group of Claude Code bots that keep running, message each other and share a folder. Start with one crew and a bot or two.", + "A crew is a group of Claude Code bots that keep running, message each other and share a folder. Each crew starts with a chief: tell it what the crew is for, and it plans the work and suggests the bots it needs.", botloft: "Botloft", running: "Running in the background. It starts with Windows, so your bots keep working after you close this window.", diff --git a/app/src/i18n/en/shell.ts b/app/src/i18n/en/shell.ts index 8beff70e..745c3686 100644 --- a/app/src/i18n/en/shell.ts +++ b/app/src/i18n/en/shell.ts @@ -8,12 +8,9 @@ export const shell = { restore: "Restore", close: "Close", }, - theme: { - system: "system", - light: "light", - dark: "dark", - label: (theme: string) => `Theme: ${theme}`, - hint: (theme: string) => `Theme: ${theme} (click to change)`, + zoom: { + level: (percent: number, isDefault: boolean) => + isDefault ? `${percent}% (default)` : `${percent}%`, }, language: { label: "Language", diff --git a/app/src/i18n/es/account.ts b/app/src/i18n/es/account.ts new file mode 100644 index 00000000..8a18cf30 --- /dev/null +++ b/app/src/i18n/es/account.ts @@ -0,0 +1,43 @@ +import type { Messages } from "../en"; + +export const account: Messages["account"] = { + open: (name: string) => `${name}: cuenta y configuración`, + plan: (plan: string) => `Plan ${plan}`, + notSignedIn: "Sin sesión en Claude", + menu: { + usage: "Uso", + settings: "Configuración", + language: "Idioma", + whatsNew: "Novedades", + help: "Ayuda", + openFailed: "No se pudo abrir la página", + }, + usage: { + title: "Uso", + intro: + "Cuánto de tu plan de Claude han usado tus bots. Se actualiza cada vez que un bot trabaja.", + empty: "El uso aparece después de la primera respuesta de un bot.", + windows: { + five_hour: "Ventana de 5 horas", + seven_day: "Esta semana", + seven_day_opus: "Esta semana, Opus", + seven_day_sonnet: "Esta semana, Sonnet", + }, + used: (percent: number) => `${percent}% usado`, + resets: (relative: string) => `Se renueva ${relative}`, + limited: "Límite alcanzado. Tus bots esperan hasta que se renueve.", + updated: (relative: string) => `Actualizado ${relative}`, + }, + settings: { + title: "Configuración", + appearance: "Apariencia", + theme: "Tema", + themes: { system: "Sistema", light: "Claro", dark: "Oscuro" }, + size: "Tamaño", + sizeHint: "Ctrl+= y Ctrl+- también cambian el tamaño, y Ctrl+0 vuelve al predeterminado.", + language: "Idioma", + about: "Acerca de", + claudeCode: (version: string) => `Claude Code ${version}`, + botloft: (version: string) => `Botloft ${version}`, + }, +}; diff --git a/app/src/i18n/es/bots.ts b/app/src/i18n/es/bots.ts index 178ab7fe..b4dcfab9 100644 --- a/app/src/i18n/es/bots.ts +++ b/app/src/i18n/es/bots.ts @@ -25,6 +25,10 @@ export const bots: Messages["bots"] = { archived: { label: "Archivado", hint: "Archivado." }, paused: { label: "En pausa", hint: "En pausa; reanúdalo para iniciarlo." }, }, + chief: { + badge: "Jefe", + hint: (crew: string) => `Dirige ${crew}: planea el trabajo y sugiere bots nuevos`, + }, header: { noRole: "Sin rol", pause: "Pausar", @@ -36,12 +40,15 @@ export const bots: Messages["bots"] = { edit: "Editar", restartFresh: "Reiniciar con una conversación nueva", openFolder: "Abrir carpeta", + makeChief: "Hacer jefe del equipo", + stopChief: "Dejar de ser jefe", archive: "Archivar bot", failed: { pause: "No se pudo pausar el bot", resume: "No se pudo reanudar el bot", restart: "No se pudo reiniciar el bot", openFolder: "No se pudo abrir la carpeta", + chief: "No se pudo cambiar el jefe", archive: "No se pudo archivar el bot", }, fresh: { diff --git a/app/src/i18n/es/chat.ts b/app/src/i18n/es/chat.ts index 5a5af18f..55ea3aa0 100644 --- a/app/src/i18n/es/chat.ts +++ b/app/src/i18n/es/chat.ts @@ -79,6 +79,97 @@ export const chat: Messages["chat"] = { denied: (tool: string) => `Denegaste ${tool}`, expired: (tool: string) => `${tool} no se aprobó a tiempo`, }, + mode: { + title: "Modo", + button: (mode: string) => `Modo: ${mode}`, + names: { + auto: "Automático", + default: "Manual", + accept_edits: "Aceptar ediciones", + plan: "Plan", + bypass_permissions: "Omitir permisos", + }, + hints: { + auto: (bot: string) => `${bot} decide qué necesita tu aprobación`, + default: (bot: string) => `${bot} siempre pregunta antes de hacer cambios`, + accept_edits: (bot: string) => `${bot} edita archivos sin preguntar`, + plan: (bot: string) => `${bot} crea un plan antes de hacer cambios`, + bypass_permissions: (bot: string) => `${bot} lo hace todo sin preguntar`, + }, + turnOn: "Activar", + failed: "No se pudo cambiar el modo", + later: (bot: string, mode: string) => + `${bot} cambiará a ${mode} cuando termine lo que está haciendo.`, + bypassTitle: (bot: string) => `¿Dejar que ${bot} haga todo sin preguntar?`, + bypassBody: (bot: string) => + `${bot} editará archivos, ejecutará comandos y usará internet en este equipo sin pedirte permiso antes.`, + bypassRisk: + "No se limita a su carpeta: puede leer y cambiar tus otros archivos, los de otros bots y los del propio Botloft. Un mensaje de otra persona podría llevarlo a hacer algo que no querías.", + bypassChief: (bot: string) => + `${bot} es el jefe del equipo, así que también creará bots nuevos sin preguntar.`, + bypassAdvice: + "Actívalo solo para un bot en el que confíes para todo, y solo mientras lo necesites.", + badge: "No pregunta nada", + badgeHint: + "Este bot lo hace todo sin preguntar. Cámbialo en el selector de modo, debajo del chat.", + }, + model: { + title: "Modelo", + button: (model: string) => `Modelo: ${model}`, + names: { + default: "Predeterminado del plan", + fable: "Fable", + opus: "Opus", + sonnet: "Sonnet", + haiku: "Haiku", + }, + short: "Predeterminado", + hints: { + default: (bot: string, inUse: string | null) => + inUse + ? `${bot} usa el modelo predeterminado de tu plan, ahora ${inUse}` + : `${bot} usa el modelo predeterminado de tu plan`, + fable: (bot: string) => `${bot} rinde al máximo, para el trabajo más difícil`, + opus: (bot: string) => `${bot} maneja bien tareas largas y complejas`, + sonnet: (bot: string) => `${bot} es rápido y capaz, bueno para casi todo`, + haiku: (bot: string) => + `${bot} es el más rápido y gasta menos de tu plan, para tareas simples`, + }, + cost: "Los modelos más capaces gastan el límite de tu plan más rápido.", + failed: "No se pudo cambiar el modelo", + later: (bot: string, model: string) => + `${bot} cambia a ${model} cuando termine lo que está haciendo.`, + }, + suggestion: { + title: (bot: string) => `${bot} sugiere un bot nuevo`, + why: "Por qué", + name: "Nombre", + role: "Rol", + model: "Modelo", + instructions: "Instrucciones", + startsNow: (bot: string) => `Empieza enseguida y recibe el trabajo de ${bot}.`, + noteLabel: (bot: string) => `Qué decirle a ${bot} si dices que no`, + notePlaceholder: (bot: string) => `Si dices que no, dile a ${bot} por qué (opcional)`, + create: "Crear bot", + decline: "Ahora no", + createFailed: "No se pudo crear el bot", + declineFailed: "No se pudo enviar la respuesta", + created: (name: string) => `Creaste ${name}`, + declined: (name: string) => `Rechazaste ${name}`, + expired: (name: string) => `${name} no se respondió a tiempo`, + }, + plan: { + ready: (bot: string) => `${bot} hizo un plan y quiere seguir con él`, + noteLabel: (bot: string) => `Qué debe cambiar ${bot} en el plan`, + notePlaceholder: "¿Qué debe cambiar? Se envía al bot si pides cambios (opcional)", + approve: "Aprobar plan", + keepPlanning: "Pedir cambios", + approveFailed: "No se pudo aprobar el plan", + keepFailed: "No se pudo devolver el plan", + approved: "Aprobaste el plan", + sentBack: "Pediste cambios en el plan", + expired: "El plan no se aprobó a tiempo", + }, markdown: { image: "imagen", openLinkFailed: "No se pudo abrir el enlace", @@ -88,6 +179,8 @@ export const chat: Messages["chat"] = { "Claude Code no tiene una sesión iniciada, o la cuenta no se puede usar ahora. Inicia sesión en Claude o revisa tu plan de Claude.", usageLimit: "Tu plan de Claude alcanzó su límite de uso. Los mensajes esperarán hasta que se restablezca.", + modelUnavailable: + "El modelo de este bot no está disponible: quizá no esté en tu plan de Claude. Elige otro modelo debajo del chat.", turnFailed: (detail: string) => `El bot no pudo terminar esto: ${detail}`, }, }; diff --git a/app/src/i18n/es/crews.ts b/app/src/i18n/es/crews.ts index 2ad18604..b5b164f4 100644 --- a/app/src/i18n/es/crews.ts +++ b/app/src/i18n/es/crews.ts @@ -12,6 +12,19 @@ export const crews: Messages["crews"] = { awaitingApproval: (text: string) => `Esperando aprobación: ${text}`, }, dialog: { + folder: "Carpeta de trabajo", + folderHint: "Donde los bots guardan lo que hacen. Puede ser una carpeta que ya usas.", + folderDefault: "Una carpeta nueva dentro de Botloft", + chooseFolder: "Elegir carpeta…", + pickTitle: "Elige dónde trabaja el equipo", + useDefault: "Usar una carpeta nueva", + goal: "¿Para qué es este equipo?", + goalPlaceholder: "Crear y mantener la web de mi panadería", + goalHint: + "El equipo empieza con un jefe, que lee esto, planea el trabajo y sugiere los bots que necesita.", + chiefModel: "Modelo del jefe", + chiefName: "Jefe", + chiefRole: "Dirige el equipo: planea el trabajo, sugiere bots nuevos y reparte las tareas", renameTitle: "Renombrar equipo", create: "Crear equipo", name: "Nombre", @@ -25,7 +38,13 @@ export const crews: Messages["crews"] = { pause: "Pausar equipo", resume: "Reanudar equipo", moreActions: "Más acciones del equipo", - openShared: "Abrir carpeta compartida", + folder: (path: string) => `Trabaja en ${path}`, + openFolder: "Abrir carpeta de trabajo", + changeFolder: "Cambiar carpeta de trabajo…", + moveTitle: (crew: string) => `¿Mover ${crew} a otra carpeta?`, + moveBody: (path: string) => + `Los bots trabajarán en ${path}. Cada uno se reinicia cuando termine lo que está haciendo. Lo que ya hicieron se queda donde está.`, + move: "Mover", archive: "Archivar equipo", tabs: { label: "Vistas del equipo", @@ -43,6 +62,7 @@ export const crews: Messages["crews"] = { failed: { pause: "No se pudo pausar el equipo", resume: "No se pudo reanudar el equipo", + changeFolder: "No se pudo cambiar la carpeta", openFolder: "No se pudo abrir la carpeta", archive: "No se pudo archivar el equipo", }, diff --git a/app/src/i18n/es/index.ts b/app/src/i18n/es/index.ts index 2da37bda..45a4b409 100644 --- a/app/src/i18n/es/index.ts +++ b/app/src/i18n/es/index.ts @@ -1,6 +1,7 @@ // Spanish. import type { Messages } from "../en"; +import { account } from "./account"; import { bots } from "./bots"; import { chat } from "./chat"; import { common } from "./common"; @@ -10,4 +11,14 @@ import { onboarding } from "./onboarding"; import { shell } from "./shell"; import { updates } from "./updates"; -export const es: Messages = { common, shell, onboarding, updates, bots, chat, crews, messages }; +export const es: Messages = { + common, + shell, + onboarding, + updates, + account, + bots, + chat, + crews, + messages, +}; diff --git a/app/src/i18n/es/onboarding.ts b/app/src/i18n/es/onboarding.ts index a5d66198..f25217f7 100644 --- a/app/src/i18n/es/onboarding.ts +++ b/app/src/i18n/es/onboarding.ts @@ -44,7 +44,7 @@ export const onboarding: Messages["onboarding"] = { welcome: { title: "Te damos la bienvenida a Botloft", intro: - "Un equipo es un grupo de bots de Claude Code que siguen funcionando, se envían mensajes y comparten una carpeta. Empieza con un equipo y uno o dos bots.", + "Un equipo es un grupo de bots de Claude Code que siguen funcionando, se envían mensajes y comparten una carpeta. Cada equipo empieza con un jefe: dile para qué es el equipo, y planea el trabajo y sugiere los bots que necesita.", botloft: "Botloft", running: "Funcionando en segundo plano. Se inicia con Windows, así que tus bots siguen trabajando después de cerrar esta ventana.", diff --git a/app/src/i18n/es/shell.ts b/app/src/i18n/es/shell.ts index c36d0857..8020d799 100644 --- a/app/src/i18n/es/shell.ts +++ b/app/src/i18n/es/shell.ts @@ -7,12 +7,9 @@ export const shell: Messages["shell"] = { restore: "Restaurar", close: "Cerrar", }, - theme: { - system: "sistema", - light: "claro", - dark: "oscuro", - label: (theme: string) => `Tema: ${theme}`, - hint: (theme: string) => `Tema: ${theme} (haz clic para cambiarlo)`, + zoom: { + level: (percent: number, isDefault: boolean) => + isDefault ? `${percent}% (predeterminado)` : `${percent}%`, }, language: { label: "Idioma", diff --git a/app/src/i18n/i18n.test.tsx b/app/src/i18n/i18n.test.tsx index 5deb2fa5..d033b37b 100644 --- a/app/src/i18n/i18n.test.tsx +++ b/app/src/i18n/i18n.test.tsx @@ -56,13 +56,13 @@ describe("languages", () => { render(<App host={new FakeHost()} connect={() => fake as Client} />); expect(await screen.findByRole("heading", { name: "Welcome to Botloft" })).toBeDefined(); - fireEvent.click(screen.getByRole("button", { name: "Language" })); + // The language lives in the account menu at the bottom of the sidebar. + fireEvent.click(screen.getByRole("button", { name: /Ana Lima/ })); + fireEvent.click(screen.getByRole("menuitem", { name: "Language" })); fireEvent.click(screen.getByRole("menuitemradio", { name: /Português/ })); expect(screen.getByRole("heading", { name: "Boas-vindas ao Botloft" })).toBeDefined(); expect(document.documentElement.lang).toBe("pt-BR"); expect(localStorage.getItem("botloft.locale")).toBe("pt-BR"); - - fireEvent.click(screen.getByRole("button", { name: "Idioma" })); expect( screen.getByRole("menuitemradio", { name: /Português/ }).getAttribute("aria-checked"), ).toBe("true"); diff --git a/app/src/i18n/pt-BR/account.ts b/app/src/i18n/pt-BR/account.ts new file mode 100644 index 00000000..aaa52320 --- /dev/null +++ b/app/src/i18n/pt-BR/account.ts @@ -0,0 +1,43 @@ +import type { Messages } from "../en"; + +export const account: Messages["account"] = { + open: (name: string) => `${name}: conta e configurações`, + plan: (plan: string) => `Plano ${plan}`, + notSignedIn: "Sem conta do Claude conectada", + menu: { + usage: "Uso", + settings: "Configurações", + language: "Idioma", + whatsNew: "Novidades", + help: "Ajuda", + openFailed: "Não foi possível abrir a página", + }, + usage: { + title: "Uso", + intro: + "Quanto do seu plano do Claude os seus bots já usaram. Atualiza sempre que um bot trabalha.", + empty: "O uso aparece depois da primeira resposta de um bot.", + windows: { + five_hour: "Janela de 5 horas", + seven_day: "Esta semana", + seven_day_opus: "Esta semana, Opus", + seven_day_sonnet: "Esta semana, Sonnet", + }, + used: (percent: number) => `${percent}% usado`, + resets: (relative: string) => `Renova ${relative}`, + limited: "Limite atingido. Seus bots esperam até ele renovar.", + updated: (relative: string) => `Atualizado ${relative}`, + }, + settings: { + title: "Configurações", + appearance: "Aparência", + theme: "Tema", + themes: { system: "Sistema", light: "Claro", dark: "Escuro" }, + size: "Tamanho", + sizeHint: "Ctrl+= e Ctrl+- também mudam o tamanho, e Ctrl+0 volta ao padrão.", + language: "Idioma", + about: "Sobre", + claudeCode: (version: string) => `Claude Code ${version}`, + botloft: (version: string) => `Botloft ${version}`, + }, +}; diff --git a/app/src/i18n/pt-BR/bots.ts b/app/src/i18n/pt-BR/bots.ts index ebddc4b0..9cad8fc3 100644 --- a/app/src/i18n/pt-BR/bots.ts +++ b/app/src/i18n/pt-BR/bots.ts @@ -25,6 +25,10 @@ export const bots: Messages["bots"] = { archived: { label: "Arquivado", hint: "Arquivado." }, paused: { label: "Pausado", hint: "Pausado; retome para iniciar." }, }, + chief: { + badge: "Chefe", + hint: (crew: string) => `Lidera ${crew}: planeja o trabalho e sugere bots novos`, + }, header: { noRole: "Sem função definida", pause: "Pausar", @@ -36,12 +40,15 @@ export const bots: Messages["bots"] = { edit: "Editar", restartFresh: "Reiniciar com uma nova conversa", openFolder: "Abrir pasta", + makeChief: "Tornar chefe da equipe", + stopChief: "Deixar de ser chefe", archive: "Arquivar bot", failed: { pause: "Não foi possível pausar o bot", resume: "Não foi possível retomar o bot", restart: "Não foi possível reiniciar o bot", openFolder: "Não foi possível abrir a pasta", + chief: "Não foi possível trocar o chefe", archive: "Não foi possível arquivar o bot", }, fresh: { diff --git a/app/src/i18n/pt-BR/chat.ts b/app/src/i18n/pt-BR/chat.ts index b4657f15..e01756e2 100644 --- a/app/src/i18n/pt-BR/chat.ts +++ b/app/src/i18n/pt-BR/chat.ts @@ -79,6 +79,95 @@ export const chat: Messages["chat"] = { denied: (tool: string) => `Você negou ${tool}`, expired: (tool: string) => `${tool} não foi aprovado a tempo`, }, + mode: { + title: "Modo", + button: (mode: string) => `Modo: ${mode}`, + names: { + auto: "Automático", + default: "Manual", + accept_edits: "Aceitar edições", + plan: "Plano", + bypass_permissions: "Ignorar permissões", + }, + hints: { + auto: (bot: string) => `${bot} decide o que precisa do seu OK`, + default: (bot: string) => `${bot} sempre pergunta antes de fazer alterações`, + accept_edits: (bot: string) => `${bot} edita arquivos sem perguntar`, + plan: (bot: string) => `${bot} cria um plano antes de fazer alterações`, + bypass_permissions: (bot: string) => `${bot} faz tudo sem perguntar`, + }, + turnOn: "Ativar", + failed: "Não foi possível mudar o modo", + later: (bot: string, mode: string) => + `${bot} muda para ${mode} quando terminar o que está fazendo.`, + bypassTitle: (bot: string) => `Deixar ${bot} fazer tudo sem perguntar?`, + bypassBody: (bot: string) => + `${bot} vai editar arquivos, rodar comandos e usar a internet neste computador sem pedir sua permissão antes.`, + bypassRisk: + "Ele não fica preso à pasta dele: pode ler e alterar seus outros arquivos, os arquivos de outros bots e os do próprio Botloft. Uma mensagem de outra pessoa pode levá-lo a fazer algo que você não queria.", + bypassChief: (bot: string) => + `${bot} é o chefe da equipe, então também vai criar bots novos sem perguntar.`, + bypassAdvice: "Ative só para um bot em quem você confia para tudo, e só enquanto precisar.", + badge: "Não pergunta nada", + badgeHint: "Este bot faz tudo sem perguntar. Mude isso no seletor de modo, embaixo do chat.", + }, + model: { + title: "Modelo", + button: (model: string) => `Modelo: ${model}`, + names: { + default: "Padrão do plano", + fable: "Fable", + opus: "Opus", + sonnet: "Sonnet", + haiku: "Haiku", + }, + short: "Padrão", + hints: { + default: (bot: string, inUse: string | null) => + inUse + ? `${bot} usa o modelo padrão do seu plano, hoje o ${inUse}` + : `${bot} usa o modelo padrão do seu plano`, + fable: (bot: string) => `${bot} fica no máximo, para o trabalho mais difícil`, + opus: (bot: string) => `${bot} vai bem em tarefas longas e complexas`, + sonnet: (bot: string) => `${bot} fica rápido e capaz, bom para quase tudo`, + haiku: (bot: string) => + `${bot} fica mais rápido e gasta menos do seu plano, para tarefas simples`, + }, + cost: "Modelos mais capazes gastam o limite do seu plano mais rápido.", + failed: "Não foi possível trocar o modelo", + later: (bot: string, model: string) => + `${bot} muda para ${model} quando terminar o que está fazendo.`, + }, + suggestion: { + title: (bot: string) => `${bot} sugere um bot novo`, + why: "Por quê", + name: "Nome", + role: "Função", + model: "Modelo", + instructions: "Instruções", + startsNow: (bot: string) => `Ele começa na hora e recebe o trabalho de ${bot}.`, + noteLabel: (bot: string) => `O que dizer a ${bot} se você recusar`, + notePlaceholder: (bot: string) => `Se recusar, diga a ${bot} o porquê (opcional)`, + create: "Criar bot", + decline: "Agora não", + createFailed: "Não foi possível criar o bot", + declineFailed: "Não foi possível enviar a resposta", + created: (name: string) => `Você criou ${name}`, + declined: (name: string) => `Você recusou ${name}`, + expired: (name: string) => `${name} não foi respondido a tempo`, + }, + plan: { + ready: (bot: string) => `${bot} fez um plano e quer seguir com ele`, + noteLabel: (bot: string) => `O que ${bot} deve mudar no plano`, + notePlaceholder: "O que deve mudar? Vai para o bot se você pedir mudanças (opcional)", + approve: "Aprovar plano", + keepPlanning: "Pedir mudanças", + approveFailed: "Não foi possível aprovar o plano", + keepFailed: "Não foi possível devolver o plano", + approved: "Você aprovou o plano", + sentBack: "Você pediu mudanças no plano", + expired: "O plano não foi aprovado a tempo", + }, markdown: { image: "imagem", openLinkFailed: "Não foi possível abrir o link", @@ -88,6 +177,8 @@ export const chat: Messages["chat"] = { "O Claude Code não está conectado a uma conta, ou a conta não pode ser usada agora. Entre no Claude ou confira o seu plano do Claude.", usageLimit: "Seu plano do Claude atingiu o limite de uso. As mensagens ficam esperando até o limite renovar.", + modelUnavailable: + "O modelo deste bot não está disponível: talvez não faça parte do seu plano do Claude. Escolha outro modelo abaixo do chat.", turnFailed: (detail: string) => `O bot não conseguiu terminar isto: ${detail}`, }, }; diff --git a/app/src/i18n/pt-BR/crews.ts b/app/src/i18n/pt-BR/crews.ts index 3acaf0c9..526e27ed 100644 --- a/app/src/i18n/pt-BR/crews.ts +++ b/app/src/i18n/pt-BR/crews.ts @@ -12,6 +12,19 @@ export const crews: Messages["crews"] = { awaitingApproval: (text: string) => `Aguardando aprovação: ${text}`, }, dialog: { + folder: "Pasta de trabalho", + folderHint: "Onde os bots guardam o que fazem. Pode ser uma pasta que você já usa.", + folderDefault: "Uma pasta nova dentro do Botloft", + chooseFolder: "Escolher pasta…", + pickTitle: "Escolha onde a equipe trabalha", + useDefault: "Usar uma pasta nova", + goal: "Para que é esta equipe?", + goalPlaceholder: "Criar e manter o site da minha padaria", + goalHint: + "A equipe começa com um Chefe, que lê isto, planeja o trabalho e sugere os bots de que precisa.", + chiefModel: "Modelo do Chefe", + chiefName: "Chefe", + chiefRole: "Lidera a equipe: planeja o trabalho, sugere bots novos e distribui as tarefas", renameTitle: "Renomear equipe", create: "Criar equipe", name: "Nome", @@ -26,7 +39,13 @@ export const crews: Messages["crews"] = { pause: "Pausar equipe", resume: "Retomar equipe", moreActions: "Mais ações da equipe", - openShared: "Abrir pasta compartilhada", + folder: (path: string) => `Trabalha em ${path}`, + openFolder: "Abrir pasta de trabalho", + changeFolder: "Mudar pasta de trabalho…", + moveTitle: (crew: string) => `Mudar ${crew} para outra pasta?`, + moveBody: (path: string) => + `Os bots vão trabalhar em ${path}. Cada um reinicia quando terminar o que está fazendo. O que já foi feito fica onde está.`, + move: "Mudar", archive: "Arquivar equipe", tabs: { label: "Visões da equipe", @@ -44,6 +63,7 @@ export const crews: Messages["crews"] = { failed: { pause: "Não foi possível pausar a equipe", resume: "Não foi possível retomar a equipe", + changeFolder: "Não foi possível mudar a pasta", openFolder: "Não foi possível abrir a pasta", archive: "Não foi possível arquivar a equipe", }, diff --git a/app/src/i18n/pt-BR/index.ts b/app/src/i18n/pt-BR/index.ts index e15ad594..a3aa413b 100644 --- a/app/src/i18n/pt-BR/index.ts +++ b/app/src/i18n/pt-BR/index.ts @@ -1,6 +1,7 @@ // Brazilian Portuguese. import type { Messages } from "../en"; +import { account } from "./account"; import { bots } from "./bots"; import { chat } from "./chat"; import { common } from "./common"; @@ -10,4 +11,14 @@ import { onboarding } from "./onboarding"; import { shell } from "./shell"; import { updates } from "./updates"; -export const ptBR: Messages = { common, shell, onboarding, updates, bots, chat, crews, messages }; +export const ptBR: Messages = { + common, + shell, + onboarding, + updates, + account, + bots, + chat, + crews, + messages, +}; diff --git a/app/src/i18n/pt-BR/onboarding.ts b/app/src/i18n/pt-BR/onboarding.ts index f7058f32..1e699416 100644 --- a/app/src/i18n/pt-BR/onboarding.ts +++ b/app/src/i18n/pt-BR/onboarding.ts @@ -44,7 +44,7 @@ export const onboarding: Messages["onboarding"] = { welcome: { title: "Boas-vindas ao Botloft", intro: - "Uma equipe é um grupo de bots do Claude Code que ficam rodando, trocam mensagens entre si e compartilham uma pasta. Comece com uma equipe e um ou dois bots.", + "Uma equipe é um grupo de bots do Claude Code que ficam rodando, trocam mensagens entre si e compartilham uma pasta. Cada equipe começa com um Chefe: diga a ele para que é a equipe, e ele planeja o trabalho e sugere os bots de que precisa.", botloft: "Botloft", running: "Rodando em segundo plano. Inicia com o Windows, então seus bots continuam trabalhando depois que você fecha esta janela.", diff --git a/app/src/i18n/pt-BR/shell.ts b/app/src/i18n/pt-BR/shell.ts index 6abb735e..bb82a25a 100644 --- a/app/src/i18n/pt-BR/shell.ts +++ b/app/src/i18n/pt-BR/shell.ts @@ -7,12 +7,9 @@ export const shell: Messages["shell"] = { restore: "Restaurar", close: "Fechar", }, - theme: { - system: "sistema", - light: "claro", - dark: "escuro", - label: (theme: string) => `Tema: ${theme}`, - hint: (theme: string) => `Tema: ${theme} (clique para trocar)`, + zoom: { + level: (percent: number, isDefault: boolean) => + isDefault ? `${percent}% (padrão)` : `${percent}%`, }, language: { label: "Idioma", diff --git a/app/src/index.css b/app/src/index.css index 5cc62aa2..2efd28f9 100644 --- a/app/src/index.css +++ b/app/src/index.css @@ -4,6 +4,7 @@ @import "@fontsource/ibm-plex-sans/600.css"; @import "@fontsource/ibm-plex-mono/400.css"; @import "@fontsource/ibm-plex-mono/500.css"; +@import "./motion.css"; /* Colors are tokens so the light and dark themes swap in one place (spec 15.3). State colors always go with an icon and a label. */ @@ -23,6 +24,10 @@ --warn: #a35f00; --danger: #c2372a; --idle-state: #6f6f69; + /* The thin edge around a bot's avatar, so light colors hold their shape. */ + --avatar-edge: rgb(0 0 0 / 0.2); + /* Under menus, pickers and dialogs. */ + --lift: rgb(0 0 0 / 0.12); } [data-theme="dark"] { @@ -41,6 +46,8 @@ --warn: #f0b24a; --danger: #ff6d60; --idle-state: #8c8c86; + --avatar-edge: rgb(255 255 255 / 0.14); + --lift: rgb(0 0 0 / 0.5); } @theme inline { @@ -58,6 +65,7 @@ --color-warn: var(--warn); --color-danger: var(--danger); --color-quiet: var(--idle-state); + --shadow-lift: 0 12px 32px -8px var(--lift), 0 2px 8px -2px var(--lift); } @theme { @@ -121,6 +129,10 @@ margin-top: 0.6em; } + .chat-md > :first-child { + margin-top: 0; + } + .chat-md :is(h1, h2, h3, h4) { font-weight: 600; letter-spacing: -0.01em; @@ -160,7 +172,7 @@ font-size: 0.9em; background: var(--sunken); padding: 0.1em 0.35em; - border-radius: 3px; + border-radius: 5px; } .chat-md pre { @@ -169,8 +181,8 @@ line-height: 1.5; background: var(--sunken); border: 1px solid var(--line); - border-radius: 4px; - padding: 0.7em 0.9em; + border-radius: 10px; + padding: 0.75em 1em; overflow-x: auto; overflow-wrap: normal; } @@ -187,18 +199,31 @@ } .chat-md table { - border-collapse: collapse; + border-collapse: separate; + border-spacing: 0; display: block; + width: fit-content; + max-width: 100%; overflow-x: auto; font-size: 0.8125rem; + border: 1px solid var(--line); + border-radius: 10px; } .chat-md :is(th, td) { - border: 1px solid var(--line); - padding: 0.3em 0.6em; + border-bottom: 1px solid var(--line); + padding: 0.4em 0.75em; text-align: left; } + .chat-md :is(th, td) + :is(th, td) { + border-left: 1px solid var(--line); + } + + .chat-md tbody tr:last-child > td { + border-bottom: 0; + } + .chat-md th { background: var(--sunken); font-weight: 600; diff --git a/app/src/lib/fake.ts b/app/src/lib/fake.ts index c8d9a0b1..5492ed29 100644 --- a/app/src/lib/fake.ts +++ b/app/src/lib/fake.ts @@ -3,11 +3,12 @@ // handles, archiving, and the notifications each change sends. import type { BotloftApi } from "./api"; +import { botHandlers } from "./fakeBots"; import { FakeChat } from "./fakeChat"; import { FakeConversation } from "./fakeConversation"; -import { checkName, conflict, invalid, notFound, slugify } from "./fakeRules"; +import { crewHandlers } from "./fakeCrews"; +import { conflict, invalid, notFound, slugify } from "./fakeRules"; import { - AVATAR_PALETTE, type Bot, type BotId, type BotState, @@ -42,6 +43,10 @@ export class FakeBotloft implements BotloftApi { runtimeError: null, claudePath: "C:\\Users\\owner\\.local\\bin\\claude.exe", claudeSignedIn: true, + account: { + name: "Ana Lima", + claude: { email: "ana@example.com", plan: "max", organization: null }, + }, deliveries: { pending: 0, dead: 0 }, usage: null, }; @@ -138,7 +143,8 @@ export class FakeBotloft implements BotloftApi { return `${prefix}_${String(counter).padStart(4, "0")}`; } - private crew(crewId: CrewId, active = true): Crew { + /** The crew; archived ones only when `active` is false. */ + crew(crewId: CrewId, active = true): Crew { const crew = this.crews.get(crewId); if (!crew) { throw notFound(`crew ${crewId}`); @@ -161,23 +167,23 @@ export class FakeBotloft implements BotloftApi { return bot; } - private activeBots(crewId?: CrewId): Bot[] { + activeBots(crewId?: CrewId): Bot[] { return [...this.bots.values()].filter( (bot) => bot.archivedAt === null && (crewId === undefined || bot.crewId === crewId), ); } - private changedCrew(crew: Crew): Crew { + changedCrew(crew: Crew): Crew { this.emit({ name: "crew.changed", params: crew }); return crew; } - private changedBot(bot: Bot): Bot { + changedBot(bot: Bot): Bot { this.emit({ name: "bot.changed", params: bot }); return bot; } - private handle(name: string, crewId: CrewId, except?: BotId): string { + handle(name: string, crewId: CrewId, except?: BotId): string { const handle = slugify(name, "bot"); const taken = this.activeBots(crewId).some((bot) => bot.handle === handle && bot.id !== except); if (taken) { @@ -196,104 +202,8 @@ export class FakeBotloft implements BotloftApi { this.refreshes += 1; return this.system; }, - "crews.list": () => [...this.crews.values()].filter((crew) => crew.archivedAt === null), - "crews.create": ({ name }) => { - const checked = checkName(name); - const crew: Crew = { - id: this.id("crw"), - name: checked, - slug: slugify(checked, "crew"), - paused: false, - createdAt: this.now, - archivedAt: null, - }; - this.crews.set(crew.id, crew); - return this.changedCrew(crew); - }, - "crews.rename": ({ crewId, name }) => { - const crew = this.crew(crewId); - crew.name = checkName(name); - return this.changedCrew(crew); - }, - "crews.setPaused": ({ crewId, paused }) => { - const crew = this.crew(crewId); - crew.paused = paused; - return this.changedCrew(crew); - }, - "crews.archive": ({ crewId }) => { - const crew = this.crew(crewId, false); - if (crew.archivedAt === null) { - crew.archivedAt = this.now; - for (const bot of this.activeBots(crewId)) { - bot.archivedAt = this.now; - bot.state = "archived"; - this.changedBot(bot); - } - this.changedCrew(crew); - } - return crew; - }, - "bots.list": ({ crewId }) => { - if (crewId !== undefined) { - this.crew(crewId); - } - return this.activeBots(crewId); - }, - "bots.create": ({ crewId, name, role, instructions, color }) => { - const crew = this.crew(crewId); - const checked = checkName(name); - const handle = this.handle(checked, crewId); - const index = [...this.bots.values()].filter((bot) => bot.crewId === crewId).length; - const bot: Bot = { - id: this.id("bot"), - crewId, - name: checked, - handle, - slug: handle, - role: role.trim(), - instructions, - color: color ?? AVATAR_PALETTE[index % AVATAR_PALETTE.length] ?? "#FF7A59", - paused: false, - state: crew.paused ? "offline" : "launching", - generation: crew.paused ? null : 1, - workspace: `C:\\Users\\owner\\Botloft\\${crew.slug}\\${handle}`, - lastActivity: null, - createdAt: this.now, - archivedAt: null, - }; - this.bots.set(bot.id, bot); - return this.changedBot(bot); - }, - "bots.update": ({ botId, name, role, instructions, color }) => { - const bot = this.bot(botId); - if (name !== undefined) { - bot.name = checkName(name); - bot.handle = this.handle(bot.name, bot.crewId, botId); - } - bot.role = role?.trim() ?? bot.role; - bot.instructions = instructions ?? bot.instructions; - bot.color = color ?? bot.color; - return this.changedBot(bot); - }, - "bots.setPaused": ({ botId, paused }) => { - const bot = this.bot(botId); - bot.paused = paused; - return this.changedBot(bot); - }, - "bots.restart": ({ botId }) => { - const bot = this.bot(botId); - this.setBotState(botId, "launching", (bot.generation ?? 0) + 1); - return bot; - }, - "bots.archive": ({ botId }) => { - const bot = this.bot(botId, false); - if (bot.archivedAt === null) { - bot.archivedAt = this.now; - bot.state = "archived"; - this.changedBot(bot); - } - return bot; - }, + ...crewHandlers(this), + ...botHandlers(this), ...this.chat.handlers(), ...this.conversation.handlers(), }; diff --git a/app/src/lib/fakeBots.ts b/app/src/lib/fakeBots.ts new file mode 100644 index 00000000..914fa21b --- /dev/null +++ b/app/src/lib/fakeBots.ts @@ -0,0 +1,93 @@ +// The fake daemon's `bots.*` methods, following the daemon's rules for +// handles, colors, archiving and the notifications each change sends. + +import type { FakeBotloft, Handlers } from "./fake"; +import { checkName } from "./fakeRules"; +import { AVATAR_PALETTE, type Bot } from "./protocol.gen"; + +type BotMethods = Extract<keyof Handlers, `bots.${string}`>; + +export function botHandlers(fake: FakeBotloft): Pick<Handlers, BotMethods> { + return { + "bots.list": ({ crewId }) => { + if (crewId !== undefined) { + fake.crew(crewId); + } + return fake.activeBots(crewId); + }, + "bots.create": ({ crewId, name, role, instructions, color, model }) => { + const crew = fake.crew(crewId); + const checked = checkName(name); + const handle = fake.handle(checked, crewId); + const index = [...fake.bots.values()].filter((bot) => bot.crewId === crewId).length; + const bot: Bot = { + id: fake.id("bot"), + crewId, + name: checked, + handle, + slug: handle, + role: role.trim(), + instructions, + color: color ?? AVATAR_PALETTE[index % AVATAR_PALETTE.length] ?? "#FF7A59", + paused: false, + permissionMode: "default", + model: model ?? "default", + modelInUse: null, + state: crew.paused ? "offline" : "launching", + generation: crew.paused ? null : 1, + workspace: `C:\\Users\\owner\\Botloft\\${crew.slug}\\${handle}`, + lastActivity: null, + createdAt: fake.now, + archivedAt: null, + }; + fake.bots.set(bot.id, bot); + return fake.changedBot(bot); + }, + "bots.update": ({ botId, name, role, instructions, color }) => { + const bot = fake.bot(botId); + if (name !== undefined) { + bot.name = checkName(name); + bot.handle = fake.handle(bot.name, bot.crewId, botId); + } + bot.role = role?.trim() ?? bot.role; + bot.instructions = instructions ?? bot.instructions; + bot.color = color ?? bot.color; + return fake.changedBot(bot); + }, + "bots.setPaused": ({ botId, paused }) => { + const bot = fake.bot(botId); + bot.paused = paused; + return fake.changedBot(bot); + }, + "bots.setPermissionMode": ({ botId, mode }) => { + const bot = fake.bot(botId); + bot.permissionMode = mode; + return fake.changedBot(bot); + }, + "bots.setModel": ({ botId, model }) => { + const bot = fake.bot(botId); + bot.model = model; + return fake.changedBot(bot); + }, + "bots.restart": ({ botId }) => { + const bot = fake.bot(botId); + fake.setBotState(botId, "launching", (bot.generation ?? 0) + 1); + return bot; + }, + "bots.archive": ({ botId }) => { + const bot = fake.bot(botId, false); + if (bot.archivedAt === null) { + bot.archivedAt = fake.now; + bot.state = "archived"; + fake.changedBot(bot); + // An archived chief leaves its crew without one. + const crew = fake.crews.get(bot.crewId); + if (crew?.leadBotId === botId) { + crew.leadBotId = null; + fake.changedCrew(crew); + } + } + return bot; + }, + }; +} diff --git a/app/src/lib/fakeChat.ts b/app/src/lib/fakeChat.ts index db390b1d..0912bb7e 100644 --- a/app/src/lib/fakeChat.ts +++ b/app/src/lib/fakeChat.ts @@ -9,11 +9,15 @@ import type { Approval, ApprovalItem, BotId, + BotModel, ChatBody, ChatItem, ToolItem, } from "./protocol.gen"; +/** The chief's tool to suggest a bot (spec 10.2). */ +export const SUGGEST_TOOL = "mcp__botloft__suggest_bot"; + /** The conversation-list line for an item, like the daemon's (spec 8.3). */ export function activityLine(body: ChatBody): { kind: ActivityKind; text: string } | null { const label = (name: string) => name.split("__").at(-1) ?? name; @@ -138,7 +142,7 @@ export class FakeChat { .reverse() .slice(0, limit ?? 50); }, - "approvals.answer": ({ approvalId, allow, note }) => { + "approvals.answer": ({ approvalId, allow, note, input }) => { const approval = this.approvals.get(approvalId); if (!approval) { throw notFound(`approval ${approvalId}`); @@ -149,12 +153,41 @@ export class FakeChat { approval.status = allow ? "allowed" : "denied"; approval.note = allow ? null : (note ?? null); approval.answeredAt = this.fake.now; + // Claude Code leaves plan mode once the plan is approved. + const bot = this.fake.bots.get(approval.botId); + if (allow && approval.toolName === "ExitPlanMode" && bot?.permissionMode === "plan") { + void this.fake.call("bots.setPermissionMode", { botId: bot.id, mode: "default" }); + } + // An allowed suggestion becomes a bot, as the owner left it. + if (allow && approval.toolName === SUGGEST_TOOL && bot) { + if (input !== undefined) { + approval.input = input; + } + const { name, role, instructions, model } = JSON.parse(approval.input) as { + name: string; + role: string; + instructions: string; + model?: BotModel; + }; + void this.fake.call("bots.create", { + crewId: bot.crewId, + name, + role, + instructions, + ...(model && { model }), + }); + } const item = this.items.find( (entry) => entry.body.kind === "approval" && entry.body.approvalId === approvalId, ); if (item) { const body = item.body as { kind: "approval" } & ApprovalItem; - this.update(item.id, { ...body, status: approval.status, note: approval.note }); + this.update(item.id, { + ...body, + input: approval.input, + status: approval.status, + note: approval.note, + }); } return approval; }, diff --git a/app/src/lib/fakeCrews.ts b/app/src/lib/fakeCrews.ts new file mode 100644 index 00000000..72706174 --- /dev/null +++ b/app/src/lib/fakeCrews.ts @@ -0,0 +1,85 @@ +// The fake daemon's `crews.*` methods: names, slugs, the work folder, +// pausing and archiving, with the notifications each change sends. + +import type { FakeBotloft, Handlers } from "./fake"; +import { botHandlers } from "./fakeBots"; +import { checkName, invalid, slugify } from "./fakeRules"; +import type { Crew } from "./protocol.gen"; + +type CrewMethods = Extract<keyof Handlers, `crews.${string}`>; + +/** The crew's `shared` folder, where it works unless the owner chose another. */ +const sharedFolder = (slug: string) => `C:\\Users\\owner\\Botloft\\${slug}\\shared`; + +function checkFolder(folder: string): string { + if (!/^[A-Za-z]:\\./.test(folder)) { + throw invalid("the work folder must be a full path, like C:\\Projects\\Site"); + } + return folder; +} + +export function crewHandlers(fake: FakeBotloft): Pick<Handlers, CrewMethods> { + return { + "crews.list": () => [...fake.crews.values()].filter((crew) => crew.archivedAt === null), + "crews.create": ({ name, workFolder, lead }) => { + const checked = checkName(name); + const slug = slugify(checked, "crew"); + const crew: Crew = { + id: fake.id("crw"), + name: checked, + slug, + workFolder: workFolder === undefined ? sharedFolder(slug) : checkFolder(workFolder), + workFolderChosen: workFolder !== undefined, + leadBotId: null, + paused: false, + createdAt: fake.now, + archivedAt: null, + }; + fake.crews.set(crew.id, crew); + fake.changedCrew(crew); + if (lead) { + const chief = botHandlers(fake)["bots.create"]({ crewId: crew.id, ...lead }); + crew.leadBotId = chief.id; + fake.changedCrew(crew); + } + return crew; + }, + "crews.setLead": ({ crewId, botId }) => { + const crew = fake.crew(crewId); + if (botId !== null && fake.bot(botId).crewId !== crewId) { + throw invalid(`bot ${botId} is not in crew ${crewId}`); + } + crew.leadBotId = botId; + return fake.changedCrew(crew); + }, + "crews.rename": ({ crewId, name }) => { + const crew = fake.crew(crewId); + crew.name = checkName(name); + return fake.changedCrew(crew); + }, + "crews.setPaused": ({ crewId, paused }) => { + const crew = fake.crew(crewId); + crew.paused = paused; + return fake.changedCrew(crew); + }, + "crews.setWorkFolder": ({ crewId, workFolder }) => { + const crew = fake.crew(crewId); + crew.workFolder = workFolder === null ? sharedFolder(crew.slug) : checkFolder(workFolder); + crew.workFolderChosen = workFolder !== null; + return fake.changedCrew(crew); + }, + "crews.archive": ({ crewId }) => { + const crew = fake.crew(crewId, false); + if (crew.archivedAt === null) { + crew.archivedAt = fake.now; + for (const bot of fake.activeBots(crewId)) { + bot.archivedAt = fake.now; + bot.state = "archived"; + fake.changedBot(bot); + } + fake.changedCrew(crew); + } + return crew; + }, + }; +} diff --git a/app/src/lib/fakeHost.ts b/app/src/lib/fakeHost.ts index f4190df1..957b18d4 100644 --- a/app/src/lib/fakeHost.ts +++ b/app/src/lib/fakeHost.ts @@ -23,6 +23,10 @@ export class FakeHost implements Host { afterInstall: DaemonStatus | Error = running(); token: string | Error = "a".repeat(64); readonly opened: string[] = []; + /** What the folder picker gives back; null is a cancel. */ + nextFolder: string | null = null; + /** Where each folder picker started. */ + readonly pickerStarts: (string | null)[] = []; readonly installs: ("install" | "restart")[] = []; /** Paths `signInToClaude` ran, and what it answers. */ readonly signIns: string[] = []; @@ -32,6 +36,8 @@ export class FakeHost implements Host { /** What `checkForUpdate` finds, or its error. */ update: AppUpdate | null | Error = null; updateChecks = 0; + /** The window's size, as the app last set it. */ + zoom = 1; maximized = false; closed = false; attention = false; @@ -57,6 +63,11 @@ export class FakeHost implements Host { return Promise.resolve(this.signInResult); } + setZoom(factor: number): Promise<void> { + this.zoom = factor; + return Promise.resolve(); + } + checkForUpdate(): Promise<AppUpdate | null> { this.updateChecks += 1; return this.update instanceof Error @@ -82,6 +93,11 @@ export class FakeHost implements Host { return Promise.resolve(); } + pickFolder(_title: string, start?: string): Promise<string | null> { + this.pickerStarts.push(start ?? null); + return Promise.resolve(this.nextFolder); + } + openUrl(url: string): Promise<void> { this.opened.push(url); return Promise.resolve(); diff --git a/app/src/lib/host.ts b/app/src/lib/host.ts index 2c9b3150..c41b33b0 100644 --- a/app/src/lib/host.ts +++ b/app/src/lib/host.ts @@ -57,11 +57,18 @@ export interface Host { * waits for it to end. Resolves whether it signed in. */ signInToClaude(claudePath: string): Promise<boolean>; + /** Draws the whole window at `factor` times its size (1 = 100%). */ + setZoom(factor: number): Promise<void>; /** A newer version of the app, or null when this one is the latest. */ checkForUpdate(): Promise<AppUpdate | null>; readOwnerToken(): Promise<string>; /** Opens a folder in Explorer. */ openPath(path: string): Promise<void>; + /** + * Asks the owner for a folder with Windows' folder picker, starting at + * `start` if given. Resolves null if they cancel. + */ + pickFolder(title: string, start?: string): Promise<string | null>; /** Opens an http(s) link in the default browser. */ openUrl(url: string): Promise<void>; window: AppWindow; diff --git a/app/src/lib/models.test.ts b/app/src/lib/models.test.ts new file mode 100644 index 00000000..b1777f26 --- /dev/null +++ b/app/src/lib/models.test.ts @@ -0,0 +1,17 @@ +import { describe, expect, test } from "vitest"; +import { modelFamily, modelName } from "./models"; + +describe("model names", () => { + test("Claude ids read as their family and version", () => { + expect(modelName("claude-opus-5-5")).toBe("Opus 5.5"); + expect(modelName("claude-haiku-4-5-20251001")).toBe("Haiku 4.5"); + expect(modelName("claude-fable-5-1")).toBe("Fable 5.1"); + expect(modelName("claude-sonnet-5")).toBe("Sonnet 5"); + expect(modelFamily("claude-sonnet-5-5")).toBe("sonnet"); + }); + + test("other ids stay as they are", () => { + expect(modelName("gpt-oss")).toBe("gpt-oss"); + expect(modelFamily("claude-opus-5-5[1m]")).toBeNull(); + }); +}); diff --git a/app/src/lib/models.ts b/app/src/lib/models.ts new file mode 100644 index 00000000..78f72bb4 --- /dev/null +++ b/app/src/lib/models.ts @@ -0,0 +1,19 @@ +// Names for the Claude model ids Claude Code reports (spec 7.4). + +const FAMILY = /^claude-(fable|opus|sonnet|haiku)-(\d+)(?:-(\d{1,2}))?(?:-\d{8})?$/; + +/** "claude-opus-5-5" -> "Opus 5.5"; an id it does not know stays as it is. */ +export function modelName(id: string): string { + const match = FAMILY.exec(id); + if (!match) { + return id; + } + const [, family = "", major, minor] = match; + const name = family.charAt(0).toUpperCase() + family.slice(1); + return minor === undefined ? `${name} ${major}` : `${name} ${major}.${minor}`; +} + +/** The family of a model id ("opus"), if it is one of Claude's. */ +export function modelFamily(id: string): string | null { + return FAMILY.exec(id)?.[1] ?? null; +} diff --git a/app/src/lib/protocol.gen.ts b/app/src/lib/protocol.gen.ts index 9fb5ac0c..bf236f1f 100644 --- a/app/src/lib/protocol.gen.ts +++ b/app/src/lib/protocol.gen.ts @@ -62,7 +62,21 @@ export type Crew = { id: CrewId, name: string, /** * Folder name under the workspaces root. Set at creation, never changes. */ -slug: string, paused: boolean, +slug: string, +/** + * Absolute path of the folder the crew works in (spec 5): one the owner + * chose, or the crew's `shared` folder. + */ +workFolder: string, +/** + * Whether the owner chose `work_folder`. + */ +workFolderChosen: boolean, +/** + * The bot that leads the crew and may suggest new bots (spec 10.2); + * `null` when the crew has no chief. + */ +leadBotId: BotId | null, paused: boolean, /** * Unix time in milliseconds. */ @@ -77,6 +91,18 @@ archivedAt: number | null, }; */ export type BotState = "offline" | "launching" | "idle" | "busy" | "needs_approval" | "rate_limited" | "auth_error" | "backoff" | "archived"; +/** + * How much a bot may do without asking the owner: Claude Code's + * permission modes (spec 7.4). + */ +export type PermissionMode = "default" | "accept_edits" | "plan" | "auto" | "bypass_permissions"; + +/** + * Which Claude model a bot runs on (spec 7.4): Claude Code's `--model` + * aliases, or the account's default. + */ +export type BotModel = "default" | "fable" | "opus" | "sonnet" | "haiku"; + /** * What the conversation-list line shows; the app words it. */ @@ -111,7 +137,12 @@ slug: string, role: string, instructions: string, /** * Avatar color, `#RRGGBB`. */ -color: string, paused: boolean, state: BotState, +color: string, paused: boolean, permissionMode: PermissionMode, model: BotModel, +/** + * The model id Claude Code reported when the bot last started a turn + * (`claude-opus-5-5`); `null` before its first turn. + */ +modelInUse: string | null, state: BotState, /** * Current process generation; `null` if the bot has not started since * the daemon did. Changes on every (re)start. @@ -190,6 +221,29 @@ resetsAt: number | null, windows: Array<UsageWindow>, */ observedAt: number, }; +/** + * What `claude auth status` says about the account (spec 7.3). + */ +export type ClaudeAccount = { email: string | null, +/** + * As Claude Code says it: `max`, `pro`, `team`, `enterprise`... + */ +plan: string | null, organization: string | null, }; + +/** + * The owner, as the app shows them in its account area (spec 15.1). + */ +export type OwnerAccount = { +/** + * The Windows account's display name, or the user name without one. + */ +name: string, +/** + * The Claude account Claude Code is signed in to; `null` when signed out + * or not checked yet. + */ +claude: ClaudeAccount | null, }; + export type SystemStatus = { daemonVersion: string, protocol: number, uptimeMs: number, /** * Version reported by `claude --version`; `null` until the runtime probe runs. @@ -206,18 +260,49 @@ claudePath: string | null, /** * Whether Claude Code is signed in (`claude auth status`); `null` until checked. */ -claudeSignedIn: boolean | null, deliveries: DeliveryBacklog, +claudeSignedIn: boolean | null, +/** + * Who the owner is, for the account area of the app. + */ +account: OwnerAccount, deliveries: DeliveryBacklog, /** * The Claude account's usage as last reported; `null` before any turn. */ usage: AccountUsage | null, }; -export type CrewsCreateParams = { name: string, }; +export type CrewsCreateParams = { name: string, +/** + * Absolute path of the folder the crew works in; the crew's `shared` + * folder when absent. + */ +workFolder?: string, +/** + * The chief, created with the crew (spec 10.2). + */ +lead?: NewLead, }; export type CrewsRenameParams = { crewId: CrewId, name: string, }; export type CrewsSetPausedParams = { crewId: CrewId, paused: boolean, }; +export type CrewsSetWorkFolderParams = { crewId: CrewId, +/** + * `null` goes back to the crew's `shared` folder. + */ +workFolder: string | null, }; + +/** + * The bot that leads a new crew. The app writes its name and role in the + * owner's language; the instructions carry the crew's goal. + */ +export type NewLead = { name: string, role: string, instructions: string, model?: BotModel, }; + +export type CrewsSetLeadParams = { crewId: CrewId, +/** + * `null` leaves the crew without a chief. + */ +botId: BotId | null, }; + export type CrewIdParams = { crewId: CrewId, }; export type BotsListParams = { @@ -230,7 +315,11 @@ export type BotsCreateParams = { crewId: CrewId, name: string, role: string, ins /** * Avatar color `#RRGGBB`; the next palette color when absent. */ -color?: string, }; +color?: string, +/** + * The account's default when absent. + */ +model?: BotModel, }; /** * Fields left out stay unchanged. @@ -239,6 +328,10 @@ export type BotsUpdateParams = { botId: BotId, name?: string, role?: string, ins export type BotsSetPausedParams = { botId: BotId, paused: boolean, }; +export type BotsSetPermissionModeParams = { botId: BotId, mode: PermissionMode, }; + +export type BotsSetModelParams = { botId: BotId, model: BotModel, }; + export type BotIdParams = { botId: BotId, }; export type BotsRestartParams = { botId: BotId, @@ -427,7 +520,7 @@ export type NoticeLevel = "info" | "warning" | "error"; /** * What a notice is about, so the app can say it in the owner's language. */ -export type NoticeCode = "signed_out" | "usage_limit" | "turn_failed"; +export type NoticeCode = "signed_out" | "usage_limit" | "turn_failed" | "model_unavailable"; export type InboundItem = { message: Message, }; @@ -532,7 +625,12 @@ export type ApprovalsAnswerParams = { approvalId: ApprovalId, allow: boolean, /** * Passed to the bot with a denial. */ -note?: string, }; +note?: string, +/** + * A bot suggestion as the owner changed it before allowing it, in the + * JSON of the tool's input (spec 10.2). Ignored for other requests. + */ +input?: string, }; /** Params and result of every request method. */ export interface RpcMethods { @@ -543,11 +641,15 @@ export interface RpcMethods { "crews.create": { params: CrewsCreateParams; result: Crew }; "crews.rename": { params: CrewsRenameParams; result: Crew }; "crews.setPaused": { params: CrewsSetPausedParams; result: Crew }; + "crews.setWorkFolder": { params: CrewsSetWorkFolderParams; result: Crew }; + "crews.setLead": { params: CrewsSetLeadParams; result: Crew }; "crews.archive": { params: CrewIdParams; result: Crew }; "bots.list": { params: BotsListParams; result: Array<Bot> }; "bots.create": { params: BotsCreateParams; result: Bot }; "bots.update": { params: BotsUpdateParams; result: Bot }; "bots.setPaused": { params: BotsSetPausedParams; result: Bot }; + "bots.setPermissionMode": { params: BotsSetPermissionModeParams; result: Bot }; + "bots.setModel": { params: BotsSetModelParams; result: Bot }; "bots.archive": { params: BotIdParams; result: Bot }; "bots.restart": { params: BotsRestartParams; result: Bot }; "chat.history": { params: ChatHistoryParams; result: Array<ChatItem> }; diff --git a/app/src/lib/tauriHost.ts b/app/src/lib/tauriHost.ts index b3630472..8c61491a 100644 --- a/app/src/lib/tauriHost.ts +++ b/app/src/lib/tauriHost.ts @@ -2,7 +2,9 @@ import { invoke } from "@tauri-apps/api/core"; import { Image } from "@tauri-apps/api/image"; +import { getCurrentWebview } from "@tauri-apps/api/webview"; import { getCurrentWindow } from "@tauri-apps/api/window"; +import { open } from "@tauri-apps/plugin-dialog"; import { check } from "@tauri-apps/plugin-updater"; import type { AppUpdate, DaemonStatus, Host } from "./host"; @@ -70,9 +72,19 @@ export function tauriHost(): Host { installDaemon: () => invoke<DaemonStatus>("daemon_install"), restartDaemon: () => invoke<DaemonStatus>("daemon_restart"), signInToClaude: (path) => invoke<boolean>("claude_sign_in", { path }), + setZoom: (factor) => getCurrentWebview().setZoom(factor), checkForUpdate, readOwnerToken: () => invoke<string>("read_owner_token"), openPath: (path) => invoke<void>("open_path", { path }), + pickFolder: async (title, start) => { + const picked = await open({ + directory: true, + multiple: false, + title, + ...(start ? { defaultPath: start } : {}), + }); + return typeof picked === "string" ? picked : null; + }, openUrl: (url) => invoke<void>("open_url", { url }), window: { minimize: () => window.minimize(), diff --git a/app/src/main.tsx b/app/src/main.tsx index 3b1f9880..76bde7fa 100644 --- a/app/src/main.tsx +++ b/app/src/main.tsx @@ -6,6 +6,7 @@ import type { Connect } from "./features/onboarding/link"; import { connect, rpcUrl } from "./lib/client"; import type { Host } from "./lib/host"; import { tauriHost } from "./lib/tauriHost"; +import { currentZoom } from "./shell/zoom"; import "./index.css"; const root = document.getElementById("root"); @@ -28,10 +29,12 @@ async function props(): Promise<{ host: Host; connect: Connect }> { throw new Error("Botloft runs inside its desktop app"); } -props().then(({ host, connect: open }) => +props().then(({ host, connect: open }) => { + // Before the first paint, so the window never flashes at the small size. + host.setZoom(currentZoom()).catch(() => {}); createRoot(root).render( <StrictMode> <App host={host} connect={open} /> </StrictMode>, - ), -); + ); +}); diff --git a/app/src/motion.css b/app/src/motion.css new file mode 100644 index 00000000..b72ad6b5 --- /dev/null +++ b/app/src/motion.css @@ -0,0 +1,283 @@ +/* Motion (spec 15.3): short and calm, so the app feels alive without + getting in the way. Everything stops when Windows turns animations off + (prefers-reduced-motion). */ + +:root { + --ease-out: cubic-bezier(0.2, 0.8, 0.2, 1); + --ease-spring: cubic-bezier(0.34, 1.45, 0.64, 1); + /* Lets heights animate to and from `auto` (details, collapsing rows). */ + interpolate-size: allow-keywords; +} + +@theme { + /* Something new in a list: a message, a tool call, a bot. */ + --animate-rise: rise 300ms var(--ease-out) both; + /* A menu or a dialog opening. */ + --animate-pop: pop 170ms var(--ease-out) both; + --animate-fade: fade 180ms ease-out both; + /* A notice sliding in from the side. */ + --animate-toast: toast 380ms var(--ease-spring) both; + /* The three dots of a bot thinking. */ + --animate-dot: dot 1.3s ease-in-out infinite; + /* A request that waits for the owner: one ring, once. */ + --animate-attention: attention 1.4s var(--ease-out) 1 both; + /* The hand of "needs approval", waving now and then. */ + --animate-wave: wave 2.4s ease-in-out infinite; + /* A gauge filling up. */ + --animate-grow: grow 800ms var(--ease-out) both; + /* A mascot floating on an empty page. */ + --animate-float: float 4s ease-in-out infinite; + + @keyframes rise { + from { + opacity: 0; + transform: translateY(10px); + } + } + + @keyframes pop { + from { + opacity: 0; + transform: scale(0.96) translateY(4px); + } + } + + @keyframes fade { + from { + opacity: 0; + } + } + + @keyframes toast { + from { + opacity: 0; + transform: translateX(28px) scale(0.98); + } + } + + @keyframes dot { + 0%, + 60%, + 100% { + transform: translateY(0); + opacity: 0.4; + } + 30% { + transform: translateY(-4px); + opacity: 1; + } + } + + @keyframes attention { + 0% { + box-shadow: 0 0 0 0 color-mix(in srgb, var(--warn) 40%, transparent); + } + 100% { + box-shadow: 0 0 0 14px color-mix(in srgb, var(--warn) 0%, transparent); + } + } + + @keyframes wave { + 0%, + 50%, + 100% { + transform: rotate(0); + } + 10%, + 30% { + transform: rotate(16deg); + } + 20%, + 40% { + transform: rotate(-10deg); + } + } + + @keyframes grow { + from { + transform: scaleX(0); + } + } + + @keyframes float { + 0%, + 100% { + transform: translateY(0); + } + 50% { + transform: translateY(-6px); + } + } +} + +@layer components { + /* The mascot (features/bots/BotAvatar.tsx). Its mood follows what the + bot does: it blinks, flickers while it works, hops while it waits for + the owner, and sleeps while paused. The state still has its own icon + and label. */ + .avatar-flame, + .avatar-eye { + transform-box: fill-box; + } + + .avatar-flame { + transform-origin: 50% 100%; + } + + .avatar-eye { + transform-origin: 50% 55%; + transition: transform 400ms var(--ease-out); + } + + [data-mood] .avatar-eye { + animation: blink 7s infinite; + animation-delay: var(--blink-delay, 0s); + } + + [data-mood="working"] .avatar-flame { + animation: flicker 1.5s ease-in-out infinite; + animation-delay: var(--blink-delay, 0s); + } + + [data-mood="waiting"] .avatar-flame { + animation: hop 2.6s var(--ease-out) infinite; + } + + [data-mood="sleeping"] .avatar-eye { + animation: none; + transform: scaleY(0.12); + } + + [data-mood="tired"] .avatar-eye { + animation: none; + transform: scaleY(0.45); + } + + /* Text still being written: a caret after the last line. */ + .chat-md.is-streaming > :is(p, h1, h2, h3, h4):last-child::after, + .chat-md.is-streaming > :is(ul, ol):last-child > li:last-child::after { + content: ""; + display: inline-block; + width: 0.5em; + height: 1.05em; + margin-left: 0.2em; + vertical-align: -0.2em; + border-radius: 2px; + background: var(--accent); + animation: caret 1.1s steps(2, jump-none) infinite; + } + + /* Opening and closing a <details> slides instead of jumping. */ + details::details-content { + block-size: 0; + overflow-y: clip; + transition: + block-size 240ms var(--ease-out), + content-visibility 240ms allow-discrete; + } + + details[open]::details-content { + block-size: auto; + } +} + +@keyframes blink { + 0%, + 45%, + 49%, + 100% { + transform: scaleY(1); + } + 47% { + transform: scaleY(0.1); + } +} + +@keyframes flicker { + 0%, + 100% { + transform: scale(1, 1) skewX(0deg); + } + 25% { + transform: scale(0.97, 1.04) skewX(-2deg); + } + 50% { + transform: scale(1.02, 0.98) skewX(1.5deg); + } + 75% { + transform: scale(0.99, 1.03) skewX(-1deg); + } +} + +@keyframes hop { + 0%, + 45%, + 100% { + transform: translateY(0) scale(1, 1); + } + 10% { + transform: translateY(0) scale(1.08, 0.92); + } + 22% { + transform: translateY(-12%) scale(0.96, 1.05); + } + 34% { + transform: translateY(0) scale(1.05, 0.95); + } +} + +@keyframes caret { + 0% { + opacity: 1; + } + 100% { + opacity: 0; + } +} + +/* Switching bots or crews: the main pane fades out and the new one rises + in; the rest of the window stays put (ui/motion.ts). */ +::view-transition-old(root), +::view-transition-new(root) { + animation: none; +} + +::view-transition-old(main-pane) { + animation: 110ms ease-out both view-out; +} + +::view-transition-new(main-pane) { + animation: 240ms var(--ease-out) both view-in; +} + +@keyframes view-out { + to { + opacity: 0; + } +} + +@keyframes view-in { + from { + opacity: 0; + transform: translateY(8px); + } +} + +/* biome-ignore-start lint/complexity/noImportantStyles: less motion must win over every animation, inline delays included */ +@media (prefers-reduced-motion: reduce) { + *, + *::before, + *::after, + ::details-content { + animation-duration: 0.01ms !important; + animation-iteration-count: 1 !important; + transition-duration: 0.01ms !important; + } + + ::view-transition-group(*), + ::view-transition-old(*), + ::view-transition-new(*) { + animation: none !important; + } +} +/* biome-ignore-end lint/complexity/noImportantStyles: less motion must win over every animation, inline delays included */ diff --git a/app/src/shell/TitleBar.tsx b/app/src/shell/TitleBar.tsx index 61874ef6..52bff414 100644 --- a/app/src/shell/TitleBar.tsx +++ b/app/src/shell/TitleBar.tsx @@ -1,33 +1,31 @@ // The window's own title bar (spec 15.3: `decorations: false`), with the -// Windows controls on the right. Empty space drags the window. +// Windows controls on the right. Empty space drags the window. Theme, size +// and language live in the account area of the sidebar (spec 15.1). -import { Copy, Languages, Minus, Monitor, Moon, Square, Sun, X } from "lucide-react"; +import { Copy, Languages, Minus, Square, X } from "lucide-react"; import { type ReactNode, useEffect, useState } from "react"; import { BotAvatar } from "../features/bots/BotAvatar"; import { LOCALES, setLocaleChoice, systemLocale, useLocale, useT } from "../i18n"; import { useHost } from "../store/context"; import { Menu } from "../ui/Menu"; -import { setTheme, type ThemeChoice, useTheme } from "./theme"; -const NEXT_THEME: Record<ThemeChoice, ThemeChoice> = { - system: "light", - light: "dark", - dark: "system", -}; -const THEME_ICON = { system: Monitor, light: Sun, dark: Moon }; - -export function TitleBar({ children, status }: { children?: ReactNode; status?: ReactNode }) { - const t = useT(); - const { choice } = useTheme(); - const ThemeIcon = THEME_ICON[choice]; - const themeName = t.shell.theme[choice]; +export function TitleBar({ + children, + status, + language = false, +}: { + children?: ReactNode; + status?: ReactNode; + /** Shows the language menu, for the setup screens that have no sidebar. */ + language?: boolean; +}) { return ( <header data-tauri-drag-region className="flex h-9 shrink-0 items-center border-line border-b bg-panel" > <div data-tauri-drag-region className="flex items-center gap-2 pr-4 pl-3"> - <BotAvatar color="#ffffff" size={18} /> + <BotAvatar color="#ffffff" size={18} framed /> <span data-tauri-drag-region className="font-semibold text-sm tracking-tight"> Botloft </span> @@ -37,16 +35,7 @@ export function TitleBar({ children, status }: { children?: ReactNode; status?: </div> <div className="flex items-center gap-1 pr-2"> {status} - <LanguageMenu /> - <button - type="button" - aria-label={t.shell.theme.label(themeName)} - title={t.shell.theme.hint(themeName)} - onClick={() => setTheme(NEXT_THEME[choice])} - className="grid h-7 w-7 place-items-center text-muted hover:bg-sunken hover:text-ink" - > - <ThemeIcon aria-hidden size={14} /> - </button> + {language && <LanguageMenu />} </div> <WindowControls /> </header> diff --git a/app/src/shell/Workspace.tsx b/app/src/shell/Workspace.tsx index 4bf49ca5..bef1788d 100644 --- a/app/src/shell/Workspace.tsx +++ b/app/src/shell/Workspace.tsx @@ -39,12 +39,18 @@ export function Workspace() { } else if (!loaded) { main = null; } else if (!hasCrews) { - main = <Welcome />; + // The sidebar stays, with the account area, before the first crew too. + main = ( + <div className="flex min-h-0 flex-1"> + <Sidebar /> + <Welcome /> + </div> + ); } else { main = ( <div className="flex min-h-0 flex-1"> <Sidebar /> - <main className="flex min-w-0 flex-1 flex-col"> + <main className="flex min-w-0 flex-1 flex-col [view-transition-name:main-pane]"> {runtimeError ? ( <div className="border-line border-b p-3"> <Callout tone="danger" title={t.shell.botsCantStart}> diff --git a/app/src/shell/zoom.test.tsx b/app/src/shell/zoom.test.tsx new file mode 100644 index 00000000..f9c611bb --- /dev/null +++ b/app/src/shell/zoom.test.tsx @@ -0,0 +1,67 @@ +import { cleanup, fireEvent, render, screen, waitFor, within } from "@testing-library/react"; +import { afterEach, describe, expect, test } from "vitest"; +import { App } from "../App"; +import type { Client } from "../lib/client"; +import { FakeBotloft } from "../lib/fake"; +import { FakeHost } from "../lib/fakeHost"; +import { currentZoom, DEFAULT_ZOOM, setZoom, stepZoom } from "./zoom"; + +afterEach(() => { + cleanup(); + setZoom(DEFAULT_ZOOM); +}); + +function renderApp() { + const host = new FakeHost(); + render(<App host={host} connect={() => new FakeBotloft() as Client} />); + return host; +} + +const key = (options: KeyboardEventInit) => fireEvent.keyDown(window, options); + +describe("app size", () => { + test("the app opens at the default size, bigger than the compact one", async () => { + const host = renderApp(); + await screen.findByRole("heading", { name: "Welcome to Botloft" }); + expect(DEFAULT_ZOOM).toBe(1.25); + expect(host.zoom).toBe(1.25); + }); + + test("settings set the size and remember it", async () => { + const host = renderApp(); + await screen.findByRole("heading", { name: "Welcome to Botloft" }); + fireEvent.click(screen.getByRole("button", { name: /Ana Lima/ })); + fireEvent.click(screen.getByRole("menuitem", { name: "Settings" })); + const sizes = screen.getByRole("radiogroup", { name: "Size" }); + expect( + (within(sizes).getByRole("radio", { name: "125% (default)" }) as HTMLInputElement).checked, + ).toBe(true); + fireEvent.click(within(sizes).getByRole("radio", { name: "150%" })); + await waitFor(() => expect(host.zoom).toBe(1.5)); + expect(localStorage.getItem("botloft.zoom")).toBe("1.5"); + }); + + test("Ctrl+= and Ctrl+- step through the sizes and Ctrl+0 goes back", async () => { + const host = renderApp(); + await screen.findByRole("heading", { name: "Welcome to Botloft" }); + key({ key: "=", ctrlKey: true }); + await waitFor(() => expect(host.zoom).toBe(1.5)); + key({ key: "-", ctrlKey: true }); + key({ key: "-", ctrlKey: true }); + key({ key: "-", ctrlKey: true }); + await waitFor(() => expect(host.zoom).toBe(1)); + key({ key: "0", ctrlKey: true }); + await waitFor(() => expect(host.zoom).toBe(1.25)); + key({ key: "=" }); + expect(currentZoom()).toBe(1.25); + }); + + test("the size stays within the levels", () => { + setZoom(1.5); + stepZoom(1); + expect(currentZoom()).toBe(1.5); + setZoom(1); + stepZoom(-1); + expect(currentZoom()).toBe(1); + }); +}); diff --git a/app/src/shell/zoom.ts b/app/src/shell/zoom.ts new file mode 100644 index 00000000..a3c04658 --- /dev/null +++ b/app/src/shell/zoom.ts @@ -0,0 +1,88 @@ +// How big the app is drawn (spec 15.3). The whole window scales, text, +// spacing and icons alike, like zooming a browser. 100% is the compact +// size the app was first drawn at; 125% is the default. Ctrl+= and Ctrl+- +// step through the levels and Ctrl+0 goes back to the default. The choice +// is a per-machine convenience kept in localStorage. + +import { useEffect, useSyncExternalStore } from "react"; +import type { Host } from "../lib/host"; + +export const ZOOM_LEVELS = [1, 1.1, 1.25, 1.5] as const; +export type ZoomLevel = (typeof ZOOM_LEVELS)[number]; +export const DEFAULT_ZOOM: ZoomLevel = 1.25; + +const KEY = "botloft.zoom"; +const listeners = new Set<() => void>(); + +function stored(): ZoomLevel { + try { + const value = Number(localStorage.getItem(KEY)); + return ZOOM_LEVELS.find((level) => level === value) ?? DEFAULT_ZOOM; + } catch { + return DEFAULT_ZOOM; + } +} + +let zoom: ZoomLevel = stored(); + +export function currentZoom(): ZoomLevel { + return zoom; +} + +export function setZoom(next: ZoomLevel): void { + zoom = next; + try { + localStorage.setItem(KEY, String(next)); + } catch { + // Private storage off: the choice lasts for this window. + } + for (const listener of listeners) { + listener(); + } +} + +/** One level bigger (1) or smaller (-1), staying within the levels. */ +export function stepZoom(direction: 1 | -1): void { + const index = ZOOM_LEVELS.indexOf(zoom) + direction; + const next = ZOOM_LEVELS[Math.min(ZOOM_LEVELS.length - 1, Math.max(0, index))]; + if (next !== undefined) { + setZoom(next); + } +} + +function subscribe(listener: () => void): () => void { + listeners.add(listener); + return () => listeners.delete(listener); +} + +export function useZoom(): ZoomLevel { + return useSyncExternalStore(subscribe, () => zoom); +} + +/** Draws the window at the chosen size and handles the zoom shortcuts. */ +export function useZoomRoot(host: Host): void { + const level = useZoom(); + useEffect(() => { + host.setZoom(level).catch(() => {}); + }, [host, level]); + + useEffect(() => { + const onKey = (event: KeyboardEvent) => { + if (!event.ctrlKey || event.altKey || event.metaKey) { + return; + } + if (event.key === "=" || event.key === "+") { + stepZoom(1); + } else if (event.key === "-") { + stepZoom(-1); + } else if (event.key === "0") { + setZoom(DEFAULT_ZOOM); + } else { + return; + } + event.preventDefault(); + }; + window.addEventListener("keydown", onKey); + return () => window.removeEventListener("keydown", onKey); + }, []); +} diff --git a/app/src/store/app.ts b/app/src/store/app.ts index b1ccb270..1ab7f709 100644 --- a/app/src/store/app.ts +++ b/app/src/store/app.ts @@ -15,6 +15,7 @@ import type { Task, TaskId, } from "../lib/protocol.gen"; +import { viewTransition } from "../ui/motion"; export interface AppState { connection: ConnectionState; @@ -80,11 +81,16 @@ export function createAppStore(api: BotloftApi): AppStore { tasks: {}, selectedCrewId: null, selectedBotId: null, - selectCrew: (crewId) => set({ selectedCrewId: crewId, selectedBotId: null }), + selectCrew: (crewId) => { + const { selectedCrewId, selectedBotId } = get(); + if (selectedCrewId !== crewId || selectedBotId !== null) { + viewTransition(() => set({ selectedCrewId: crewId, selectedBotId: null })); + } + }, selectBot: (botId) => { const bot = get().bots[botId]; - if (bot) { - set({ selectedCrewId: bot.crewId, selectedBotId: botId }); + if (bot && get().selectedBotId !== botId) { + viewTransition(() => set({ selectedCrewId: bot.crewId, selectedBotId: botId })); } }, putCrew: (crew) => set((state) => withCrew(state, crew)), diff --git a/app/src/ui/Button.tsx b/app/src/ui/Button.tsx index 58644b1f..c354a95a 100644 --- a/app/src/ui/Button.tsx +++ b/app/src/ui/Button.tsx @@ -35,7 +35,7 @@ export function Button({ type={type} aria-label={label} title={label} - className={`inline-flex shrink-0 items-center justify-center gap-1.5 rounded-[3px] font-medium transition-colors disabled:pointer-events-none disabled:opacity-45 ${height} ${padding} ${variants[variant]} ${className}`} + className={`inline-flex shrink-0 items-center justify-center gap-1.5 rounded-lg font-medium transition-[color,background-color,border-color,transform] duration-150 active:scale-[0.97] disabled:pointer-events-none disabled:opacity-45 ${height} ${padding} ${variants[variant]} ${className}`} {...rest} > {Icon && <Icon aria-hidden size={size === "sm" ? 14 : 15} strokeWidth={2} />} diff --git a/app/src/ui/Callout.tsx b/app/src/ui/Callout.tsx index 661df278..49891ec1 100644 --- a/app/src/ui/Callout.tsx +++ b/app/src/ui/Callout.tsx @@ -4,9 +4,9 @@ import type { ReactNode } from "react"; type Tone = "info" | "warn" | "danger"; const tones: Record<Tone, { icon: typeof Info; frame: string; mark: string }> = { - info: { icon: Info, frame: "border-line-strong", mark: "text-work" }, - warn: { icon: TriangleAlert, frame: "border-warn/60", mark: "text-warn" }, - danger: { icon: CircleAlert, frame: "border-danger/60", mark: "text-danger" }, + info: { icon: Info, frame: "border-line bg-panel", mark: "text-work" }, + warn: { icon: TriangleAlert, frame: "border-warn/45 bg-warn/6", mark: "text-warn" }, + danger: { icon: CircleAlert, frame: "border-danger/45 bg-danger/6", mark: "text-danger" }, }; export function Callout({ @@ -24,7 +24,7 @@ export function Callout({ return ( <div role={tone === "info" ? "status" : "alert"} - className={`flex items-start gap-3 border border-l-4 bg-panel px-3 py-2.5 ${frame}`} + className={`flex items-start gap-3 rounded-xl border px-3.5 py-3 ${frame}`} > <Icon aria-hidden size={16} className={`mt-0.5 shrink-0 ${mark}`} /> <div className="min-w-0 flex-1 text-sm"> diff --git a/app/src/ui/Choices.tsx b/app/src/ui/Choices.tsx new file mode 100644 index 00000000..3fcf409e --- /dev/null +++ b/app/src/ui/Choices.tsx @@ -0,0 +1,45 @@ +import { useId } from "react"; + +/** + * A short set of options where one is chosen, shown side by side. Real + * radio buttons underneath, so the arrow keys and screen readers work. + */ +export function Choices<T extends string | number>({ + label, + value, + options, + onChange, +}: { + label: string; + value: T; + options: readonly { value: T; label: string }[]; + onChange(value: T): void; +}) { + const name = useId(); + return ( + <div role="radiogroup" aria-label={label} className="flex flex-wrap gap-1.5"> + {options.map((option) => { + const chosen = option.value === value; + return ( + <label + key={String(option.value)} + className={`flex h-8 cursor-pointer items-center rounded-lg border px-3 text-sm has-[input:focus-visible]:outline-2 has-[input:focus-visible]:outline-accent ${ + chosen + ? "border-ink bg-ink text-canvas" + : "border-line-strong bg-panel text-ink hover:bg-sunken" + }`} + > + <input + type="radio" + name={name} + className="sr-only" + checked={chosen} + onChange={() => onChange(option.value)} + /> + {option.label} + </label> + ); + })} + </div> + ); +} diff --git a/app/src/ui/Dialog.tsx b/app/src/ui/Dialog.tsx index a4c3cf32..faf36925 100644 --- a/app/src/ui/Dialog.tsx +++ b/app/src/ui/Dialog.tsx @@ -28,22 +28,22 @@ export function Dialog({ title, onClose, children, footer, width = "md" }: Dialo }, [onClose]); return ( - <div className="fixed inset-0 z-40 grid place-items-center bg-black/55 p-6"> + <div className="fixed inset-0 z-40 grid animate-fade place-items-center bg-black/50 p-6"> <div role="dialog" aria-modal="true" aria-labelledby={titleId} - className={`flex max-h-full w-full flex-col border border-line-strong bg-panel ${width === "lg" ? "max-w-2xl" : "max-w-md"}`} + className={`flex max-h-full w-full animate-pop flex-col overflow-hidden rounded-2xl border border-line bg-panel shadow-lift ${width === "lg" ? "max-w-2xl" : "max-w-md"}`} > - <header className="flex h-11 shrink-0 items-center justify-between border-line border-b pr-1.5 pl-4"> + <header className="flex h-12 shrink-0 items-center justify-between border-line border-b pr-2 pl-5"> <h2 id={titleId} className="font-semibold text-base tracking-tight"> {title} </h2> <Button variant="ghost" icon={X} label={t.common.close} onClick={onClose} /> </header> - <div className="min-h-0 overflow-y-auto p-4">{children}</div> + <div className="min-h-0 overflow-y-auto px-5 py-4">{children}</div> {footer && ( - <footer className="flex shrink-0 justify-end gap-2 border-line border-t px-4 py-3"> + <footer className="flex shrink-0 justify-end gap-2 border-line border-t px-5 py-3"> {footer} </footer> )} diff --git a/app/src/ui/Field.tsx b/app/src/ui/Field.tsx index 0de24c9a..419edf8a 100644 --- a/app/src/ui/Field.tsx +++ b/app/src/ui/Field.tsx @@ -1,6 +1,7 @@ import { type InputHTMLAttributes, type ReactNode, + type SelectHTMLAttributes, type TextareaHTMLAttributes, useId, } from "react"; @@ -41,7 +42,7 @@ function Frame({ } const control = - "w-full rounded-[3px] border border-line-strong bg-canvas px-2.5 text-ink text-sm outline-none placeholder:text-muted focus:border-accent"; + "w-full rounded-lg border border-line-strong bg-canvas px-2.5 text-ink text-sm outline-none placeholder:text-muted focus:border-accent"; export function TextField({ label, @@ -72,3 +73,25 @@ export function TextArea({ </Frame> ); } + +export function SelectField({ + label, + hint, + options, + ...select +}: Framing & { + options: { value: string; label: string }[]; +} & SelectHTMLAttributes<HTMLSelectElement>) { + const id = useId(); + return ( + <Frame id={id} label={label} hint={hint}> + <select id={id} className={`${control} h-8`} {...select}> + {options.map((option) => ( + <option key={option.value} value={option.value}> + {option.label} + </option> + ))} + </select> + </Frame> + ); +} diff --git a/app/src/ui/Menu.tsx b/app/src/ui/Menu.tsx index 72c48006..8341378f 100644 --- a/app/src/ui/Menu.tsx +++ b/app/src/ui/Menu.tsx @@ -1,6 +1,8 @@ import { Check, type LucideIcon } from "lucide-react"; -import { useEffect, useRef, useState } from "react"; +import { useCallback, useRef, useState } from "react"; import { Button } from "./Button"; +import { POPOVER, POPOVER_ITEM } from "./surface"; +import { useDismiss } from "./useDismiss"; export interface MenuItem { label: string; @@ -25,23 +27,11 @@ export function Menu({ const [open, setOpen] = useState(false); const root = useRef<HTMLDivElement>(null); - useEffect(() => { - if (!open) { - return; - } - const onPointer = (event: PointerEvent) => { - if (!root.current?.contains(event.target as Node)) { - setOpen(false); - } - }; - const onKey = (event: KeyboardEvent) => event.key === "Escape" && setOpen(false); - window.addEventListener("pointerdown", onPointer); - window.addEventListener("keydown", onKey); - return () => { - window.removeEventListener("pointerdown", onPointer); - window.removeEventListener("keydown", onKey); - }; - }, [open]); + useDismiss( + open, + root, + useCallback(() => setOpen(false), []), + ); return ( <div ref={root} className="relative"> @@ -56,7 +46,7 @@ export function Menu({ {open && ( <div role="menu" - className="absolute top-full right-0 z-30 mt-1 min-w-60 border border-line-strong bg-panel py-1" + className={`absolute top-full right-0 mt-1 min-w-60 origin-top-right ${POPOVER}`} > {items.map(({ label: itemLabel, icon: Icon, danger, disabled, checked, onSelect }) => ( <button @@ -70,7 +60,7 @@ export function Menu({ setOpen(false); onSelect(); }} - className={`flex h-8 w-full items-center gap-2 whitespace-nowrap px-3 text-left text-sm hover:bg-sunken disabled:opacity-45 ${danger ? "text-danger" : "text-ink"}`} + className={`h-8 whitespace-nowrap ${POPOVER_ITEM} ${danger ? "text-danger" : "text-ink"}`} > {Icon && <Icon aria-hidden size={14} />} {checked !== undefined && ( diff --git a/app/src/ui/Tabs.tsx b/app/src/ui/Tabs.tsx index 11a0af98..5b37df5e 100644 --- a/app/src/ui/Tabs.tsx +++ b/app/src/ui/Tabs.tsx @@ -1,9 +1,14 @@ +import { useLayoutEffect, useRef, useState } from "react"; + export interface Tab<T extends string> { id: T; label: string; } -/** A row of tabs; the panels are the caller's, labelled by `tabId(id)`. */ +/** + * A row of tabs; the panels are the caller's, labelled by `tabId(id)`. The + * accent line under the selected tab slides to the next one. + */ export function Tabs<T extends string>({ label, tabs, @@ -15,11 +20,23 @@ export function Tabs<T extends string>({ value: T; onChange(value: T): void; }) { + const list = useRef<HTMLDivElement>(null); + const [line, setLine] = useState<{ left: number; width: number } | null>(null); + + // biome-ignore lint/correctness/useExhaustiveDependencies: re-measured when the selection or the tabs change + useLayoutEffect(() => { + const selected = list.current?.querySelector<HTMLElement>('[aria-selected="true"]'); + if (selected) { + setLine({ left: selected.offsetLeft + 4, width: selected.offsetWidth - 8 }); + } + }, [value, tabs]); + return ( <div + ref={list} role="tablist" aria-label={label} - className="flex h-9 shrink-0 gap-1 border-line border-b px-3" + className="relative flex h-9 shrink-0 gap-1 border-line border-b px-3" > {tabs.map((tab) => { const selected = tab.id === value; @@ -31,12 +48,19 @@ export function Tabs<T extends string>({ role="tab" aria-selected={selected} onClick={() => onChange(tab.id)} - className={`relative px-2.5 font-medium text-sm ${selected ? "text-ink after:absolute after:inset-x-1 after:bottom-0 after:h-0.5 after:bg-accent" : "text-muted hover:text-ink"}`} + className={`px-2.5 font-medium text-sm transition-colors ${selected ? "text-ink" : "text-muted hover:text-ink"}`} > {tab.label} </button> ); })} + {line && ( + <span + aria-hidden + className="absolute bottom-0 h-0.5 rounded-full bg-accent transition-[left,width] duration-300 ease-[var(--ease-out)]" + style={{ left: line.left, width: line.width }} + /> + )} </div> ); } diff --git a/app/src/ui/motion.test.tsx b/app/src/ui/motion.test.tsx new file mode 100644 index 00000000..fe9218fb --- /dev/null +++ b/app/src/ui/motion.test.tsx @@ -0,0 +1,93 @@ +import { act, cleanup, render, screen, within } from "@testing-library/react"; +import { afterEach, describe, expect, test, vi } from "vitest"; +import { moodOf } from "../features/bots/BotAvatar"; +import { FakeBotloft } from "../lib/fake"; +import { crewOpened, openBot, renderApp } from "../test/app"; +import { SeenSince, useArrival, viewTransition } from "./motion"; + +afterEach(() => { + cleanup(); + vi.unstubAllGlobals(); + Reflect.deleteProperty(document, "startViewTransition"); +}); + +describe("the mascot's mood", () => { + test("follows what the bot does", () => { + const bot = (state: Parameters<typeof moodOf>[0]["state"], paused = false) => + moodOf({ state, paused }); + expect(bot("idle")).toBe("idle"); + expect(bot("busy")).toBe("working"); + expect(bot("launching")).toBe("working"); + expect(bot("needs_approval")).toBe("waiting"); + expect(bot("rate_limited")).toBe("tired"); + expect(bot("offline")).toBe("sleeping"); + expect(bot("idle", true)).toBe("sleeping"); + expect(moodOf({ state: "busy", paused: false }, true)).toBe("sleeping"); + }); +}); + +describe("arrivals", () => { + function Item({ at }: { at: number }) { + return <p className={useArrival(at)}>{`item ${at}`}</p>; + } + + test("only what came after the owner started looking animates", () => { + render( + <SeenSince.Provider value={100}> + <Item at={50} /> + <Item at={150} /> + </SeenSince.Provider>, + ); + expect(screen.getByText("item 50").className).toBe(""); + expect(screen.getByText("item 150").className).toBe("animate-rise"); + }); + + test("a chat's history stays still and a new message rises in", async () => { + const fake = new FakeBotloft(); + const ops = fake.addCrew("Ops"); + const scout = fake.addBot(ops.id, "Scout"); + fake.setBotState(scout.id, "idle"); + fake.chat.add(scout.id, { kind: "reply", text: "From before" }); + fake.chat.turn(scout.id); + renderApp(fake); + await crewOpened("Ops"); + openBot("Scout"); + const messages = await screen.findByRole("list", { name: "Messages" }); + const before = within(messages).getByText("From before").closest("li"); + expect(before?.className).not.toContain("animate-rise"); + + act(() => { + fake.now = Date.now() + 1000; + void fake.call("messages.send", { botId: scout.id, body: "Something new" }); + }); + const fresh = await within(messages).findByText("Something new"); + expect(fresh.closest("li")?.className).toContain("animate-rise"); + }); +}); + +describe("view transitions", () => { + test("run the change at once where the webview has none", () => { + const update = vi.fn(); + viewTransition(update); + expect(update).toHaveBeenCalledOnce(); + }); + + test("go through the webview's transition when it has one", () => { + const start = vi.fn((run: () => void) => run()); + Object.assign(document, { startViewTransition: start }); + const update = vi.fn(); + viewTransition(update); + expect(start).toHaveBeenCalledOnce(); + expect(update).toHaveBeenCalledOnce(); + }); + + test("skip the transition when Windows asks for less motion", () => { + const start = vi.fn((run: () => void) => run()); + Object.assign(document, { startViewTransition: start }); + vi.stubGlobal("matchMedia", (query: string) => ({ matches: query.includes("reduce") })); + const update = vi.fn(); + viewTransition(update); + expect(start).not.toHaveBeenCalled(); + expect(update).toHaveBeenCalledOnce(); + }); +}); diff --git a/app/src/ui/motion.ts b/app/src/ui/motion.ts new file mode 100644 index 00000000..f1f26b3a --- /dev/null +++ b/app/src/ui/motion.ts @@ -0,0 +1,43 @@ +// Helpers for motion (spec 15.3): switching views with a short transition, +// and telling what is new since the owner started looking, so only that +// animates in. + +import { createContext, useContext } from "react"; +import { flushSync } from "react-dom"; + +/** Whether Windows asked for less motion ("Animation effects" off). */ +export function reducedMotion(): boolean { + return ( + typeof window.matchMedia === "function" && + window.matchMedia("(prefers-reduced-motion: reduce)").matches + ); +} + +type WithTransitions = Document & { startViewTransition?(update: () => void): unknown }; + +/** + * Applies a change of view (another bot or crew) as a short transition of + * the main pane, where the webview can; otherwise at once. + */ +export function viewTransition(update: () => void): void { + const doc = document as WithTransitions; + if (typeof doc.startViewTransition !== "function" || reducedMotion()) { + update(); + return; + } + doc.startViewTransition(() => flushSync(update)); +} + +/** When the app opened: a bot created after it is new to the owner. */ +export const APP_OPENED = Date.now(); + +/** + * When the owner opened what they look at (a chat). Items created before + * it were already there and stay still; later ones animate in. + */ +export const SeenSince = createContext<number>(Number.POSITIVE_INFINITY); + +/** The class that animates an item in, if it is new. */ +export function useArrival(createdAt: number): string { + return createdAt > useContext(SeenSince) ? "animate-rise" : ""; +} diff --git a/app/src/ui/surface.ts b/app/src/ui/surface.ts new file mode 100644 index 00000000..4b83045a --- /dev/null +++ b/app/src/ui/surface.ts @@ -0,0 +1,8 @@ +// Shared looks for floating panels, so menus and pickers match. + +/** A menu or picker floating over the page; add the `origin-*` it opens from. */ +export const POPOVER = "z-30 animate-pop rounded-xl border border-line bg-panel p-1 shadow-lift"; + +/** One row of a popover. */ +export const POPOVER_ITEM = + "flex w-full items-center gap-2 rounded-lg px-2.5 text-left text-sm hover:bg-sunken disabled:opacity-45"; diff --git a/app/src/ui/toast.tsx b/app/src/ui/toast.tsx index a513d3de..5689756c 100644 --- a/app/src/ui/toast.tsx +++ b/app/src/ui/toast.tsx @@ -46,7 +46,7 @@ export function Toaster() { <div key={toast.id} role="alert" - className="pointer-events-auto flex items-start gap-2 border border-danger/60 border-l-4 bg-panel py-2 pr-1.5 pl-3 text-sm" + className="pointer-events-auto flex animate-toast items-start gap-2 rounded-xl border border-danger/45 bg-panel py-2.5 pr-2 pl-3.5 text-sm shadow-lift" > <p className="min-w-0 flex-1 break-words" data-selectable> {toast.text} @@ -55,7 +55,7 @@ export function Toaster() { type="button" aria-label={t.common.dismiss} onClick={() => dismiss(toast.id)} - className="grid h-6 w-6 shrink-0 place-items-center text-muted hover:text-ink" + className="grid h-6 w-6 shrink-0 place-items-center rounded-md text-muted hover:bg-sunken hover:text-ink" > <X aria-hidden size={14} /> </button> diff --git a/app/src/ui/useDismiss.ts b/app/src/ui/useDismiss.ts new file mode 100644 index 00000000..4d9455ec --- /dev/null +++ b/app/src/ui/useDismiss.ts @@ -0,0 +1,22 @@ +import { type RefObject, useEffect } from "react"; + +/** Closes a popover on Escape or a click outside `root`, while it is open. */ +export function useDismiss(open: boolean, root: RefObject<HTMLElement | null>, close: () => void) { + useEffect(() => { + if (!open) { + return; + } + const onPointer = (event: PointerEvent) => { + if (!root.current?.contains(event.target as Node)) { + close(); + } + }; + const onKey = (event: KeyboardEvent) => event.key === "Escape" && close(); + window.addEventListener("pointerdown", onPointer); + window.addEventListener("keydown", onKey); + return () => { + window.removeEventListener("pointerdown", onPointer); + window.removeEventListener("keydown", onKey); + }; + }, [open, root, close]); +} diff --git a/crates/botloft-core/src/chat.rs b/crates/botloft-core/src/chat.rs index 3c8405e9..779ffcfa 100644 --- a/crates/botloft-core/src/chat.rs +++ b/crates/botloft-core/src/chat.rs @@ -7,6 +7,14 @@ use crate::protocol::{ActivityKind, ChatBody, SenderKind}; /// Longest tool input kept, in bytes. pub const TOOL_INPUT_MAX: usize = 4 * 1024; +/// Longest plan kept, in bytes: the owner reads all of it to approve it. +pub const PLAN_INPUT_MAX: usize = 32 * 1024; +/// The tool Claude Code uses to leave plan mode with a plan (spec 10.1). +pub const PLAN_TOOL: &str = "ExitPlanMode"; +/// The chief's tool to suggest a new bot (spec 10.2). +pub const SUGGEST_TOOL: &str = "mcp__botloft__suggest_bot"; +/// Longest suggestion kept, in bytes: the owner reads and edits all of it. +pub const SUGGESTION_INPUT_MAX: usize = 64 * 1024; /// Longest tool output kept, in bytes. pub const TOOL_OUTPUT_MAX: usize = 8 * 1024; /// Longest activity line, in characters. @@ -37,6 +45,15 @@ pub fn one_line(text: &str, max: usize) -> String { format!("{}…", cut.trim_end()) } +/// Longest input kept for `tool`, in bytes. +pub fn tool_input_max(tool: &str) -> usize { + match tool { + PLAN_TOOL => PLAN_INPUT_MAX, + SUGGEST_TOOL => SUGGESTION_INPUT_MAX, + _ => TOOL_INPUT_MAX, + } +} + fn field<'a>(input: &'a Value, name: &str) -> Option<&'a str> { input.get(name).and_then(Value::as_str) } @@ -59,6 +76,13 @@ pub fn tool_summary(name: &str, input: &Value) -> String { "WebSearch" => field(input, "query").map(str::to_owned), "Task" | "Agent" => field(input, "description").map(str::to_owned), "TodoWrite" => Some("Updated the plan".to_owned()), + // The plan's first line, usually its title. + PLAN_TOOL => field(input, "plan").and_then(|plan| { + plan.lines() + .map(|line| line.trim_start_matches('#').trim()) + .find(|line| !line.is_empty()) + .map(str::to_owned) + }), // Claude Code loads deferred tools (such as ours) by name first. "ToolSearch" => field(input, "query").map(|query| match query.strip_prefix("select:") { Some(names) => { @@ -71,6 +95,7 @@ pub fn tool_summary(name: &str, input: &Value) -> String { field(input, "to").map(|to| format!("to @{}", to.trim_start_matches('@'))) } "mcp__botloft__complete_task" => field(input, "task_id").map(|id| format!("task {id}")), + SUGGEST_TOOL => field(input, "name").map(str::to_owned), _ => None, }; one_line(&summary.unwrap_or_default(), SUMMARY_MAX_CHARS) @@ -171,6 +196,16 @@ mod tests { "notebook jupyter" ); assert_eq!(tool_summary("SomethingNew", &json!({ "a": 1 })), ""); + assert_eq!( + tool_summary( + PLAN_TOOL, + &json!({ "plan": " +## Move the cache + +1. Read" }) + ), + "Move the cache" + ); assert_eq!(tool_label("mcp__botloft__send_message"), "send_message"); assert_eq!(tool_label("Bash"), "Bash"); } diff --git a/crates/botloft-core/src/protocol/chat.rs b/crates/botloft-core/src/protocol/chat.rs index b7676717..f8ac8ad4 100644 --- a/crates/botloft-core/src/protocol/chat.rs +++ b/crates/botloft-core/src/protocol/chat.rs @@ -42,6 +42,8 @@ text_enum!( UsageLimit => "usage_limit", /// The turn failed; `text` holds Claude Code's detail or error code. TurnFailed => "turn_failed", + /// The bot's model does not exist or the account cannot use it. + ModelUnavailable => "model_unavailable", } ); @@ -220,6 +222,11 @@ pub struct ApprovalsAnswerParams { #[serde(default)] #[cfg_attr(test, ts(optional))] pub note: Option<String>, + /// A bot suggestion as the owner changed it before allowing it, in the + /// JSON of the tool's input (spec 10.2). Ignored for other requests. + #[serde(default)] + #[cfg_attr(test, ts(optional))] + pub input: Option<String>, } /// The last thing in a bot's chat, for the conversation list. diff --git a/crates/botloft-core/src/protocol/export.rs b/crates/botloft-core/src/protocol/export.rs index db1db5a5..fd49d7aa 100644 --- a/crates/botloft-core/src/protocol/export.rs +++ b/crates/botloft-core/src/protocol/export.rs @@ -87,6 +87,8 @@ fn export_bindings() { out.decl::<AttachmentId>(); out.decl::<Crew>(); out.decl::<BotState>(); + out.decl::<PermissionMode>(); + out.decl::<BotModel>(); out.decl::<ActivityKind>(); out.decl::<Activity>(); out.decl::<Bot>(); @@ -96,15 +98,22 @@ fn export_bindings() { out.decl::<DeliveryBacklog>(); out.decl::<UsageWindow>(); out.decl::<AccountUsage>(); + out.decl::<ClaudeAccount>(); + out.decl::<OwnerAccount>(); out.decl::<SystemStatus>(); out.decl::<CrewsCreateParams>(); out.decl::<CrewsRenameParams>(); out.decl::<CrewsSetPausedParams>(); + out.decl::<CrewsSetWorkFolderParams>(); + out.decl::<NewLead>(); + out.decl::<CrewsSetLeadParams>(); out.decl::<CrewIdParams>(); out.decl::<BotsListParams>(); out.decl::<BotsCreateParams>(); out.decl::<BotsUpdateParams>(); out.decl::<BotsSetPausedParams>(); + out.decl::<BotsSetPermissionModeParams>(); + out.decl::<BotsSetModelParams>(); out.decl::<BotIdParams>(); out.decl::<BotsRestartParams>(); out.decl::<BotStateChanged>(); @@ -181,6 +190,16 @@ fn export_bindings() { &out.name::<CrewsSetPausedParams>(), &crew, ); + out.method( + method::CREWS_SET_WORK_FOLDER, + &out.name::<CrewsSetWorkFolderParams>(), + &crew, + ); + out.method( + method::CREWS_SET_LEAD, + &out.name::<CrewsSetLeadParams>(), + &crew, + ); out.method(method::CREWS_ARCHIVE, &out.name::<CrewIdParams>(), &crew); out.method(method::BOTS_LIST, &out.name::<BotsListParams>(), &bots); out.method(method::BOTS_CREATE, &out.name::<BotsCreateParams>(), &bot); @@ -190,6 +209,16 @@ fn export_bindings() { &out.name::<BotsSetPausedParams>(), &bot, ); + out.method( + method::BOTS_SET_PERMISSION_MODE, + &out.name::<BotsSetPermissionModeParams>(), + &bot, + ); + out.method( + method::BOTS_SET_MODEL, + &out.name::<BotsSetModelParams>(), + &bot, + ); out.method(method::BOTS_ARCHIVE, &out.name::<BotIdParams>(), &bot); out.method(method::BOTS_RESTART, &out.name::<BotsRestartParams>(), &bot); out.method( diff --git a/crates/botloft-core/src/protocol/methods.rs b/crates/botloft-core/src/protocol/methods.rs index 342c2df9..db17f0d3 100644 --- a/crates/botloft-core/src/protocol/methods.rs +++ b/crates/botloft-core/src/protocol/methods.rs @@ -4,7 +4,7 @@ use std::fmt; use serde::{Deserialize, Serialize}; -use super::DeliveryBacklog; +use super::{BotModel, DeliveryBacklog, PermissionMode}; use crate::ids::{BotId, CrewId}; /// Identifies the connecting app in `session.hello`. @@ -60,11 +60,36 @@ pub struct SystemStatus { pub claude_path: Option<String>, /// Whether Claude Code is signed in (`claude auth status`); `null` until checked. pub claude_signed_in: Option<bool>, + /// Who the owner is, for the account area of the app. + pub account: OwnerAccount, pub deliveries: DeliveryBacklog, /// The Claude account's usage as last reported; `null` before any turn. pub usage: Option<AccountUsage>, } +/// The owner, as the app shows them in its account area (spec 15.1). +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +#[cfg_attr(test, derive(ts_rs::TS))] +pub struct OwnerAccount { + /// The Windows account's display name, or the user name without one. + pub name: String, + /// The Claude account Claude Code is signed in to; `null` when signed out + /// or not checked yet. + pub claude: Option<ClaudeAccount>, +} + +/// What `claude auth status` says about the account (spec 7.3). +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +#[cfg_attr(test, derive(ts_rs::TS))] +pub struct ClaudeAccount { + pub email: Option<String>, + /// As Claude Code says it: `max`, `pro`, `team`, `enterprise`... + pub plan: Option<String>, + pub organization: Option<String>, +} + /// The account's usage, from Claude Code's `rate_limit_event` (spec 8.1). #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] @@ -96,6 +121,47 @@ pub struct UsageWindow { #[cfg_attr(test, derive(ts_rs::TS))] pub struct CrewsCreateParams { pub name: String, + /// Absolute path of the folder the crew works in; the crew's `shared` + /// folder when absent. + #[serde(default)] + #[cfg_attr(test, ts(optional))] + pub work_folder: Option<String>, + /// The chief, created with the crew (spec 10.2). + #[serde(default)] + #[cfg_attr(test, ts(optional))] + pub lead: Option<NewLead>, +} + +/// The bot that leads a new crew. The app writes its name and role in the +/// owner's language; the instructions carry the crew's goal. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +#[cfg_attr(test, derive(ts_rs::TS))] +pub struct NewLead { + pub name: String, + pub role: String, + pub instructions: String, + #[serde(default)] + #[cfg_attr(test, ts(optional))] + pub model: Option<BotModel>, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +#[cfg_attr(test, derive(ts_rs::TS))] +pub struct CrewsSetLeadParams { + pub crew_id: CrewId, + /// `null` leaves the crew without a chief. + pub bot_id: Option<BotId>, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +#[cfg_attr(test, derive(ts_rs::TS))] +pub struct CrewsSetWorkFolderParams { + pub crew_id: CrewId, + /// `null` goes back to the crew's `shared` folder. + pub work_folder: Option<String>, } #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] @@ -143,6 +209,10 @@ pub struct BotsCreateParams { #[serde(default)] #[cfg_attr(test, ts(optional))] pub color: Option<String>, + /// The account's default when absent. + #[serde(default)] + #[cfg_attr(test, ts(optional))] + pub model: Option<BotModel>, } /// Fields left out stay unchanged. @@ -173,6 +243,22 @@ pub struct BotsSetPausedParams { pub paused: bool, } +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +#[cfg_attr(test, derive(ts_rs::TS))] +pub struct BotsSetPermissionModeParams { + pub bot_id: BotId, + pub mode: PermissionMode, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +#[cfg_attr(test, derive(ts_rs::TS))] +pub struct BotsSetModelParams { + pub bot_id: BotId, + pub model: BotModel, +} + #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] #[cfg_attr(test, derive(ts_rs::TS))] diff --git a/crates/botloft-core/src/protocol/mod.rs b/crates/botloft-core/src/protocol/mod.rs index 00883bb4..d4f70d9e 100644 --- a/crates/botloft-core/src/protocol/mod.rs +++ b/crates/botloft-core/src/protocol/mod.rs @@ -74,11 +74,15 @@ pub mod method { pub const CREWS_CREATE: &str = "crews.create"; pub const CREWS_RENAME: &str = "crews.rename"; pub const CREWS_SET_PAUSED: &str = "crews.setPaused"; + pub const CREWS_SET_WORK_FOLDER: &str = "crews.setWorkFolder"; + pub const CREWS_SET_LEAD: &str = "crews.setLead"; pub const CREWS_ARCHIVE: &str = "crews.archive"; pub const BOTS_LIST: &str = "bots.list"; pub const BOTS_CREATE: &str = "bots.create"; pub const BOTS_UPDATE: &str = "bots.update"; pub const BOTS_SET_PAUSED: &str = "bots.setPaused"; + pub const BOTS_SET_PERMISSION_MODE: &str = "bots.setPermissionMode"; + pub const BOTS_SET_MODEL: &str = "bots.setModel"; pub const BOTS_ARCHIVE: &str = "bots.archive"; pub const BOTS_RESTART: &str = "bots.restart"; pub const CHAT_HISTORY: &str = "chat.history"; diff --git a/crates/botloft-core/src/protocol/model.rs b/crates/botloft-core/src/protocol/model.rs index 5311dd63..7d890865 100644 --- a/crates/botloft-core/src/protocol/model.rs +++ b/crates/botloft-core/src/protocol/model.rs @@ -14,6 +14,14 @@ pub struct Crew { pub name: String, /// Folder name under the workspaces root. Set at creation, never changes. pub slug: String, + /// Absolute path of the folder the crew works in (spec 5): one the owner + /// chose, or the crew's `shared` folder. + pub work_folder: String, + /// Whether the owner chose `work_folder`. + pub work_folder_chosen: bool, + /// The bot that leads the crew and may suggest new bots (spec 10.2); + /// `null` when the crew has no chief. + pub lead_bot_id: Option<BotId>, pub paused: bool, /// Unix time in milliseconds. pub created_at: i64, @@ -37,6 +45,75 @@ pub enum BotState { Archived, } +text_enum!( + /// How much a bot may do without asking the owner: Claude Code's + /// permission modes (spec 7.4). + PermissionMode, "permission mode" { + /// Asks before edits, commands and the network ("Manual"). + Default => "default", + /// Edits files and runs common file commands without asking. + AcceptEdits => "accept_edits", + /// Plans first, then asks to go ahead with the plan. + Plan => "plan", + /// A classifier reviews each action; what it does not allow is asked. + Auto => "auto", + /// Does everything without asking. + BypassPermissions => "bypass_permissions", + } +); + +impl PermissionMode { + /// The value of Claude Code's `--permission-mode`, and what it reports + /// in `system/init`. + pub fn cli_value(self) -> &'static str { + match self { + Self::Default => "default", + Self::AcceptEdits => "acceptEdits", + Self::Plan => "plan", + Self::Auto => "auto", + Self::BypassPermissions => "bypassPermissions", + } + } + + pub fn from_cli(value: &str) -> Option<Self> { + [ + Self::Default, + Self::AcceptEdits, + Self::Plan, + Self::Auto, + Self::BypassPermissions, + ] + .into_iter() + .find(|mode| mode.cli_value() == value) + } +} + +text_enum!( + /// Which Claude model a bot runs on (spec 7.4): Claude Code's `--model` + /// aliases, or the account's default. + BotModel, "model" { + /// No `--model`: the default of the owner's Claude plan. + Default => "default", + Fable => "fable", + Opus => "opus", + Sonnet => "sonnet", + Haiku => "haiku", + } +); + +impl BotModel { + /// The value of Claude Code's `--model`; `None` leaves the flag out. + pub fn cli_value(self) -> Option<&'static str> { + match self { + Self::Default => None, + Self::Fable => Some("fable"), + Self::Opus => Some("opus"), + Self::Sonnet => Some("sonnet"), + Self::Haiku => Some("haiku"), + } + } +} + /// A persistent Claude Code session with a name, a role and instructions. #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] @@ -55,6 +132,11 @@ pub struct Bot { /// Avatar color, `#RRGGBB`. pub color: String, pub paused: bool, + pub permission_mode: PermissionMode, + pub model: BotModel, + /// The model id Claude Code reported when the bot last started a turn + /// (`claude-opus-5-5`); `null` before its first turn. + pub model_in_use: Option<String>, pub state: BotState, /// Current process generation; `null` if the bot has not started since /// the daemon did. Changes on every (re)start. diff --git a/crates/botloft-store/migrations/0004_permission_mode.sql b/crates/botloft-store/migrations/0004_permission_mode.sql new file mode 100644 index 00000000..ccc2fe85 --- /dev/null +++ b/crates/botloft-store/migrations/0004_permission_mode.sql @@ -0,0 +1,3 @@ +-- How much each bot may do without asking (spec 7.4). Existing bots keep +-- asking before everything, as they did. +ALTER TABLE bots ADD COLUMN permission_mode TEXT NOT NULL DEFAULT 'default'; diff --git a/crates/botloft-store/migrations/0005_bot_model.sql b/crates/botloft-store/migrations/0005_bot_model.sql new file mode 100644 index 00000000..2c93cd73 --- /dev/null +++ b/crates/botloft-store/migrations/0005_bot_model.sql @@ -0,0 +1,4 @@ +-- Which Claude model each bot runs on (spec 7.4), and the model Claude Code +-- last reported. Existing bots keep the account's default, as they did. +ALTER TABLE bots ADD COLUMN model TEXT NOT NULL DEFAULT 'default'; +ALTER TABLE bots ADD COLUMN model_in_use TEXT; diff --git a/crates/botloft-store/migrations/0006_crew_work_folder.sql b/crates/botloft-store/migrations/0006_crew_work_folder.sql new file mode 100644 index 00000000..62bae47a --- /dev/null +++ b/crates/botloft-store/migrations/0006_crew_work_folder.sql @@ -0,0 +1,3 @@ +-- The folder a crew works in, when the owner chose one (spec 5). NULL keeps +-- the crew's shared folder, as before. +ALTER TABLE crews ADD COLUMN work_dir TEXT; diff --git a/crates/botloft-store/migrations/0007_crew_lead.sql b/crates/botloft-store/migrations/0007_crew_lead.sql new file mode 100644 index 00000000..886911e2 --- /dev/null +++ b/crates/botloft-store/migrations/0007_crew_lead.sql @@ -0,0 +1,4 @@ +-- The bot that leads each crew (spec 10.2). No foreign key: the chief of a +-- new crew is saved in the same transaction as its bot, and an archived +-- chief simply no longer counts. +ALTER TABLE crews ADD COLUMN lead_bot_id TEXT; diff --git a/crates/botloft-store/src/approvals.rs b/crates/botloft-store/src/approvals.rs index ff0a3704..72574322 100644 --- a/crates/botloft-store/src/approvals.rs +++ b/crates/botloft-store/src/approvals.rs @@ -71,22 +71,25 @@ impl Store { .optional()?) } - /// Answers a pending approval. `None` if it was already settled. + /// Answers a pending approval; `input` replaces what was asked, when the + /// owner changed it. `None` if it was already settled. pub fn settle_approval( &self, id: &ApprovalId, status: ApprovalStatus, note: Option<&str>, + input: Option<&str>, now: i64, ) -> Result<Option<ApprovalRecord>> { Ok(self .conn .query_row( &format!( - "UPDATE approvals SET status = ?2, note = ?3, answered_at = ?4 \ + "UPDATE approvals SET status = ?2, note = ?3, answered_at = ?4, \ + input = COALESCE(?5, input) \ WHERE id = ?1 AND status = 'pending' RETURNING {COLUMNS}, tool_use_id" ), - params![id.as_str(), status.as_str(), note, now], + params![id.as_str(), status.as_str(), note, now, input], from_row, ) .optional()?) @@ -163,6 +166,7 @@ mod tests { &record.approval.id, ApprovalStatus::Denied, Some("not now"), + None, 20, ) .expect("settle") @@ -172,11 +176,29 @@ mod tests { assert_eq!(denied.approval.answered_at, Some(20)); let again = fx .store - .settle_approval(&record.approval.id, ApprovalStatus::Allowed, None, 30) + .settle_approval(&record.approval.id, ApprovalStatus::Allowed, None, None, 30) .expect("settle"); assert_eq!(again, None); } + #[test] + fn an_answer_can_replace_what_was_asked() { + let fx = Fixture::new(); + let record = pending(&fx, 0); + let allowed = fx + .store + .settle_approval( + &record.approval.id, + ApprovalStatus::Allowed, + None, + Some(r#"{"name":"Designer"}"#), + 40, + ) + .expect("settle") + .expect("was pending"); + assert_eq!(allowed.approval.input, r#"{"name":"Designer"}"#); + } + #[test] fn a_bots_pending_approvals_expire_together() { let fx = Fixture::new(); diff --git a/crates/botloft-store/src/bots.rs b/crates/botloft-store/src/bots.rs index e26804fe..59e5e5ac 100644 --- a/crates/botloft-store/src/bots.rs +++ b/crates/botloft-store/src/bots.rs @@ -1,6 +1,7 @@ //! `bots` table. use botloft_core::ids::{BotId, CrewId}; +use botloft_core::protocol::{BotModel, PermissionMode}; use rusqlite::{OptionalExtension, Row, params}; use crate::{Result, Store, parse_column, unique_as_duplicate}; @@ -18,12 +19,17 @@ pub struct BotRecord { pub instructions: String, pub color: String, pub paused: bool, + pub permission_mode: PermissionMode, + pub model: BotModel, + /// What Claude Code last reported; written by [`Store::set_model_in_use`] + /// and left alone by [`Store::update_bot`]. + pub model_in_use: Option<String>, pub created_at: i64, pub archived_at: Option<i64>, } -const COLUMNS: &str = - "id, crew_id, name, handle, slug, role, instructions, color, paused, created_at, archived_at"; +const COLUMNS: &str = "id, crew_id, name, handle, slug, role, instructions, color, paused, created_at, archived_at, \ + permission_mode, model, model_in_use"; fn from_row(row: &Row<'_>) -> rusqlite::Result<BotRecord> { Ok(BotRecord { @@ -38,6 +44,9 @@ fn from_row(row: &Row<'_>) -> rusqlite::Result<BotRecord> { paused: row.get(8)?, created_at: row.get(9)?, archived_at: row.get(10)?, + permission_mode: parse_column(row, 11)?, + model: parse_column(row, 12)?, + model_in_use: row.get(13)?, }) } @@ -47,7 +56,7 @@ impl Store { .execute( &format!( "INSERT INTO bots ({COLUMNS}) \ - VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11)" + VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14)" ), params![ bot.id.as_str(), @@ -60,7 +69,10 @@ impl Store { bot.color, bot.paused, bot.created_at, - bot.archived_at + bot.archived_at, + bot.permission_mode.as_str(), + bot.model.as_str(), + bot.model_in_use ], ) .map_err(|err| unique_as_duplicate(err, "bot handle or slug"))?; @@ -128,7 +140,7 @@ impl Store { self.conn .execute( "UPDATE bots SET name = ?2, handle = ?3, role = ?4, instructions = ?5, \ - color = ?6, paused = ?7, archived_at = ?8 WHERE id = ?1", + color = ?6, paused = ?7, archived_at = ?8, permission_mode = ?9, model = ?10 WHERE id = ?1", params![ bot.id.as_str(), bot.name, @@ -137,13 +149,24 @@ impl Store { bot.instructions, bot.color, bot.paused, - bot.archived_at + bot.archived_at, + bot.permission_mode.as_str(), + bot.model.as_str() ], ) .map_err(|err| unique_as_duplicate(err, "bot handle"))?; Ok(()) } + /// The model Claude Code reported at the start of a turn (spec 7.4). + pub fn set_model_in_use(&self, id: &BotId, model: &str) -> Result<()> { + self.conn.execute( + "UPDATE bots SET model_in_use = ?2 WHERE id = ?1", + params![id.as_str(), model], + )?; + Ok(()) + } + /// The Claude Code conversation the bot resumes (spec 7.3). pub fn session_id(&self, id: &BotId) -> Result<Option<String>> { Ok(self @@ -180,6 +203,9 @@ mod tests { id: CrewId::generate(), name: "Docs".to_owned(), slug: "docs".to_owned(), + work_folder: String::new(), + work_folder_chosen: false, + lead_bot_id: None, paused: false, created_at: 1, archived_at: None, @@ -199,6 +225,9 @@ mod tests { instructions: "Be brief.\nCite sources.".to_owned(), color: "#FF7A59".to_owned(), paused: false, + permission_mode: PermissionMode::Default, + model: BotModel::Default, + model_in_use: None, created_at, archived_at: None, } diff --git a/crates/botloft-store/src/crews.rs b/crates/botloft-store/src/crews.rs index e56c8061..8ad96163 100644 --- a/crates/botloft-store/src/crews.rs +++ b/crates/botloft-store/src/crews.rs @@ -6,31 +6,45 @@ use rusqlite::{OptionalExtension, Row, params}; use crate::{Result, Store, parse_column, unique_as_duplicate}; -const COLUMNS: &str = "id, name, slug, paused, created_at, archived_at"; +const COLUMNS: &str = "id, name, slug, paused, created_at, archived_at, work_dir, lead_bot_id"; +/// A crew without a chosen folder comes back with an empty `work_folder`; +/// the daemon fills in the `shared` folder, which depends on its paths. fn from_row(row: &Row<'_>) -> rusqlite::Result<Crew> { + let work_dir: Option<String> = row.get(6)?; Ok(Crew { id: parse_column(row, 0)?, name: row.get(1)?, slug: row.get(2)?, + work_folder_chosen: work_dir.is_some(), + work_folder: work_dir.unwrap_or_default(), + lead_bot_id: row + .get::<_, Option<String>>(7)? + .and_then(|id| id.parse().ok()), paused: row.get(3)?, created_at: row.get(4)?, archived_at: row.get(5)?, }) } +fn work_dir(crew: &Crew) -> Option<&str> { + crew.work_folder_chosen.then_some(crew.work_folder.as_str()) +} + impl Store { pub fn insert_crew(&self, crew: &Crew) -> Result<()> { self.conn .execute( - &format!("INSERT INTO crews ({COLUMNS}) VALUES (?1, ?2, ?3, ?4, ?5, ?6)"), + &format!("INSERT INTO crews ({COLUMNS}) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)"), params![ crew.id.as_str(), crew.name, crew.slug, crew.paused, crew.created_at, - crew.archived_at + crew.archived_at, + work_dir(crew), + crew.lead_bot_id.as_ref().map(|id| id.as_str()) ], ) .map_err(|err| unique_as_duplicate(err, "crew slug"))?; @@ -66,11 +80,20 @@ impl Store { )?) } - /// Saves the mutable fields: name, paused and archived_at. + /// Saves the mutable fields: name, paused, archived_at, the chosen work + /// folder and the chief. pub fn update_crew(&self, crew: &Crew) -> Result<()> { self.conn.execute( - "UPDATE crews SET name = ?2, paused = ?3, archived_at = ?4 WHERE id = ?1", - params![crew.id.as_str(), crew.name, crew.paused, crew.archived_at], + "UPDATE crews SET name = ?2, paused = ?3, archived_at = ?4, work_dir = ?5, \ + lead_bot_id = ?6 WHERE id = ?1", + params![ + crew.id.as_str(), + crew.name, + crew.paused, + crew.archived_at, + work_dir(crew), + crew.lead_bot_id.as_ref().map(|id| id.as_str()) + ], )?; Ok(()) } @@ -101,6 +124,9 @@ mod tests { id: CrewId::generate(), name: slug.to_uppercase(), slug: slug.to_owned(), + work_folder: String::new(), + work_folder_chosen: false, + lead_bot_id: None, paused: false, created_at, archived_at: None, diff --git a/crates/botloft-store/src/lib.rs b/crates/botloft-store/src/lib.rs index e89ea935..d145ae71 100644 --- a/crates/botloft-store/src/lib.rs +++ b/crates/botloft-store/src/lib.rs @@ -122,6 +122,9 @@ pub(crate) mod tests { id: CrewId::generate(), name: "Ops".to_owned(), slug: "ops".to_owned(), + work_folder: String::new(), + work_folder_chosen: false, + lead_bot_id: None, paused: false, created_at: 0, archived_at: None, @@ -140,6 +143,9 @@ pub(crate) mod tests { instructions: String::new(), color: "#FF7A59".to_owned(), paused: false, + permission_mode: botloft_core::protocol::PermissionMode::Default, + model: botloft_core::protocol::BotModel::Default, + model_in_use: None, created_at: 0, archived_at: None, }; diff --git a/crates/botloft-store/src/migrate.rs b/crates/botloft-store/src/migrate.rs index 5b8a68a1..7d15649c 100644 --- a/crates/botloft-store/src/migrate.rs +++ b/crates/botloft-store/src/migrate.rs @@ -10,6 +10,10 @@ const MIGRATIONS: &[(u32, &str)] = &[ (1, include_str!("../migrations/0001_init.sql")), (2, include_str!("../migrations/0002_messages.sql")), (3, include_str!("../migrations/0003_chat.sql")), + (4, include_str!("../migrations/0004_permission_mode.sql")), + (5, include_str!("../migrations/0005_bot_model.sql")), + (6, include_str!("../migrations/0006_crew_work_folder.sql")), + (7, include_str!("../migrations/0007_crew_lead.sql")), ]; /// Schema version after every migration has run. diff --git a/crates/botloftd/Cargo.toml b/crates/botloftd/Cargo.toml index 7b4a6488..98cd9b40 100644 --- a/crates/botloftd/Cargo.toml +++ b/crates/botloftd/Cargo.toml @@ -33,7 +33,7 @@ tracing-subscriber = { version = "0.3.23", features = ["env-filter"] } workspace = true [target."cfg(windows)".dependencies] -windows = { version = "0.62.2", features = ["Win32_Foundation", "Win32_Security", "Win32_Security_Authorization", "Win32_System_Threading", "Win32_System_Memory", "Win32_System_JobObjects", "Win32_System_Environment", "Win32_System_Power", "Win32_System_Console", "Win32_System_Com", "Win32_System_Ole", "Win32_System_Variant", "Win32_System_TaskScheduler"] } +windows = { version = "0.62.2", features = ["Win32_Foundation", "Win32_Security", "Win32_Security_Authorization", "Win32_System_Threading", "Win32_System_Memory", "Win32_System_JobObjects", "Win32_System_Environment", "Win32_System_Power", "Win32_System_Console", "Win32_System_Com", "Win32_System_Ole", "Win32_System_Variant", "Win32_System_TaskScheduler", "Win32_Security_Authentication_Identity"] } [target."cfg(windows)".build-dependencies] embed-resource = "3.0.11" diff --git a/crates/botloftd/src/approvals.rs b/crates/botloftd/src/approvals/mod.rs similarity index 66% rename from crates/botloftd/src/approvals.rs rename to crates/botloftd/src/approvals/mod.rs index 0674a880..e7626cd0 100644 --- a/crates/botloftd/src/approvals.rs +++ b/crates/botloftd/src/approvals/mod.rs @@ -1,30 +1,28 @@ -//! Permission requests (spec 10.1). Claude Code calls the MCP tool -//! `permission_prompt`; the call waits here until the owner answers in the -//! chat, the request times out, or the bot's process ends. +//! Requests that wait for the owner in the chat: Claude Code's permission +//! requests (spec 10.1) and the chief's bot suggestions (spec 10.2). The +//! MCP call waits here until the owner answers, the request times out, or +//! the bot's process ends. + +mod prompt; use std::collections::HashMap; use std::sync::{Mutex, MutexGuard}; -use std::time::Duration; -use botloft_core::chat::{TOOL_INPUT_MAX, clip, tool_summary}; +use botloft_core::chat::{SUGGEST_TOOL, clip, tool_input_max, tool_summary}; use botloft_core::ids::{ApprovalId, BotId, ChatItemId}; use botloft_core::protocol::{ - Approval, ApprovalItem, ApprovalStatus, ApprovalsAnswerParams, ChatBody, ToolStatus, + Approval, ApprovalItem, ApprovalStatus, ApprovalsAnswerParams, ChatBody, }; use botloft_store::ApprovalRecord; -use serde_json::{Value, json}; +use serde_json::Value; use tokio::sync::oneshot; use tracing::{debug, warn}; +pub use self::prompt::{PromptArgs, prompt}; use crate::chat::items; use crate::service::{ApiError, ApiResult}; use crate::state::Daemon; -/// How long to wait for the `tool_use` event that the request is about; -/// it can arrive a moment after the MCP call. -const MATCH_WINDOW: Duration = Duration::from_secs(2); -const MATCH_POLL: Duration = Duration::from_millis(50); - /// Requests waiting for an answer, in memory: they cannot outlive the /// daemon, since the bots' processes do not either. #[derive(Default)] @@ -36,6 +34,21 @@ pub struct Approvals { struct Decision { allow: bool, note: Option<String>, + input: Option<String>, +} + +/// How the owner answered a request. +#[derive(Debug, Clone, PartialEq, Eq)] +pub(crate) enum Answer { + /// `input` is the request as the owner changed it, if they did. + Allowed { + input: Option<String>, + }, + Denied { + note: Option<String>, + }, + /// No answer in time, or the process ended. + Expired, } impl Approvals { @@ -46,26 +59,17 @@ impl Approvals { } } -/// Arguments Claude Code sends to the permission tool. -#[derive(Debug, Clone, serde::Deserialize)] -pub struct PromptArgs { - pub tool_name: String, - #[serde(default)] - pub input: Value, - #[serde(default)] - pub tool_use_id: String, -} - -/// Handles one `permission_prompt` call and returns the text of the tool -/// result: `{"behavior": "allow" | "deny", ...}`. -pub async fn prompt(daemon: &Daemon, bot: &BotId, generation: u64, args: PromptArgs) -> String { - if !matches_running_tool(daemon, bot, &args.tool_use_id).await { - debug!(bot = %bot, "permission request for no running tool; denied"); - return deny("There is no pending tool call with that id."); - } - let Some(pending) = open(daemon, bot, &args) else { - return deny("Botloft could not ask the owner."); - }; +/// Puts a request in the bot's chat and waits for the owner. `None` if it +/// could not be saved. +pub(crate) async fn ask( + daemon: &Daemon, + bot: &BotId, + generation: u64, + tool_name: &str, + input: &Value, + tool_use_id: &str, +) -> Option<Answer> { + let pending = open(daemon, bot, tool_name, input, tool_use_id)?; let (answer, waiting) = oneshot::channel(); daemon .approvals @@ -83,20 +87,17 @@ pub async fn prompt(daemon: &Daemon, bot: &BotId, generation: u64, args: PromptA guard.settled = true; daemon.approvals.lock().remove(&pending.record.approval.id); daemon.supervisor.approval_closed(bot, generation); - match decision { - Ok(Ok(Decision { allow: true, .. })) => { - json!({ "behavior": "allow", "updatedInput": args.input }).to_string() - } - Ok(Ok(Decision { allow: false, note })) => match note { - Some(note) => deny(&format!("The owner denied this: {note}")), - None => deny("The owner denied this."), - }, + Some(match decision { + Ok(Ok(Decision { + allow: true, input, .. + })) => Answer::Allowed { input }, + Ok(Ok(Decision { note, .. })) => Answer::Denied { note }, // Timed out, or the answer was dropped (the process ended). Ok(Err(_)) | Err(_) => { - settle(daemon, &pending.record, ApprovalStatus::Expired, None); - deny("The owner did not answer in time.") + settle(daemon, &pending.record, ApprovalStatus::Expired, None, None); + Answer::Expired } - } + }) } /// The owner's answer (`approvals.answer`). @@ -114,7 +115,16 @@ pub fn answer(daemon: &Daemon, params: ApprovalsAnswerParams) -> ApiResult<Appro .store() .approval(¶ms.approval_id)? .ok_or_else(|| ApiError::NotFound(format!("approval {}", params.approval_id)))?; - let Some(record) = settle(daemon, &existing, status, note.as_deref()) else { + // Only a bot suggestion can be changed before it is allowed (spec 10.2). + let input = match params.input { + Some(input) if params.allow && existing.approval.tool_name == SUGGEST_TOOL => { + let value: Value = serde_json::from_str(&input) + .map_err(|_| ApiError::validation("the changed suggestion is not valid JSON"))?; + Some(value.to_string()) + } + _ => None, + }; + let Some(record) = settle(daemon, &existing, status, note.as_deref(), input.as_deref()) else { return Err(ApiError::Conflict(format!( "approval {} was already answered or expired", params.approval_id @@ -124,6 +134,7 @@ pub fn answer(daemon: &Daemon, params: ApprovalsAnswerParams) -> ApiResult<Appro let _ = waiter.send(Decision { allow: params.allow, note, + input, }); } Ok(record.approval) @@ -160,44 +171,25 @@ pub fn expire_all(daemon: &Daemon) { } } -fn deny(message: &str) -> String { - json!({ "behavior": "deny", "message": message }).to_string() -} - -/// Whether the bot's chat shows `tool_use_id` running, waiting briefly for -/// the event if it has not been read yet. -async fn matches_running_tool(daemon: &Daemon, bot: &BotId, tool_use_id: &str) -> bool { - if tool_use_id.is_empty() { - return false; - } - let deadline = tokio::time::Instant::now() + MATCH_WINDOW; - loop { - let found = daemon.store().tool_item(bot, tool_use_id); - if let Ok(Some(item)) = found - && matches!(&item.body, ChatBody::Tool(tool) if tool.status == ToolStatus::Running) - { - return true; - } - if tokio::time::Instant::now() >= deadline { - return false; - } - tokio::time::sleep(MATCH_POLL).await; - } -} - struct Pending { record: ApprovalRecord, } /// Saves the request and puts it in the chat. -fn open(daemon: &Daemon, bot: &BotId, args: &PromptArgs) -> Option<Pending> { +fn open( + daemon: &Daemon, + bot: &BotId, + tool_name: &str, + input: &Value, + tool_use_id: &str, +) -> Option<Pending> { let now = daemon.clock.now_ms(); let approval = Approval { id: ApprovalId::generate(), bot_id: bot.clone(), - tool_name: args.tool_name.clone(), - summary: tool_summary(&args.tool_name, &args.input), - input: clip(&args.input.to_string(), TOOL_INPUT_MAX), + tool_name: tool_name.to_owned(), + summary: tool_summary(tool_name, input), + input: clip(&input.to_string(), tool_input_max(tool_name)), status: ApprovalStatus::Pending, note: None, created_at: now, @@ -207,7 +199,7 @@ fn open(daemon: &Daemon, bot: &BotId, args: &PromptArgs) -> Option<Pending> { let record = ApprovalRecord { approval, chat_item_id: item.id, - tool_use_id: args.tool_use_id.clone(), + tool_use_id: tool_use_id.to_owned(), }; if let Err(err) = daemon.store().insert_approval(&record) { warn!(bot = %bot, "could not save an approval: {err}"); @@ -234,11 +226,12 @@ fn settle( record: &ApprovalRecord, status: ApprovalStatus, note: Option<&str>, + input: Option<&str>, ) -> Option<ApprovalRecord> { let now = daemon.clock.now_ms(); let settled = daemon .store() - .settle_approval(&record.approval.id, status, note, now); + .settle_approval(&record.approval.id, status, note, input, now); match settled { Ok(Some(settled)) => { show(daemon, &settled); @@ -276,7 +269,13 @@ impl Drop for Guard<'_> { .approvals .lock() .remove(&self.record.approval.id); - settle(self.daemon, self.record, ApprovalStatus::Expired, None); + settle( + self.daemon, + self.record, + ApprovalStatus::Expired, + None, + None, + ); self.daemon .supervisor .approval_closed(self.bot, self.generation); diff --git a/crates/botloftd/src/approvals/prompt.rs b/crates/botloftd/src/approvals/prompt.rs new file mode 100644 index 00000000..f9a9af59 --- /dev/null +++ b/crates/botloftd/src/approvals/prompt.rs @@ -0,0 +1,82 @@ +//! Claude Code's permission requests (spec 10.1): the MCP tool +//! `permission_prompt`, named with `--permission-prompt-tool`. + +use std::time::Duration; + +use botloft_core::ids::BotId; +use botloft_core::protocol::{ChatBody, ToolStatus}; +use serde_json::{Value, json}; +use tracing::debug; + +use super::{Answer, ask}; +use crate::state::Daemon; + +/// How long to wait for the `tool_use` event that the request is about; +/// it can arrive a moment after the MCP call. +const MATCH_WINDOW: Duration = Duration::from_secs(2); +const MATCH_POLL: Duration = Duration::from_millis(50); + +/// Arguments Claude Code sends to the permission tool. +#[derive(Debug, Clone, serde::Deserialize)] +pub struct PromptArgs { + pub tool_name: String, + #[serde(default)] + pub input: Value, + #[serde(default)] + pub tool_use_id: String, +} + +/// Handles one `permission_prompt` call and returns the text of the tool +/// result: `{"behavior": "allow" | "deny", ...}`. +pub async fn prompt(daemon: &Daemon, bot: &BotId, generation: u64, args: PromptArgs) -> String { + if !matches_running_tool(daemon, bot, &args.tool_use_id).await { + debug!(bot = %bot, "permission request for no running tool; denied"); + return deny("There is no pending tool call with that id."); + } + let asked = ask( + daemon, + bot, + generation, + &args.tool_name, + &args.input, + &args.tool_use_id, + ) + .await; + match asked { + // What runs is what was asked: the owner cannot edit a tool call. + Some(Answer::Allowed { .. }) => { + json!({ "behavior": "allow", "updatedInput": args.input }).to_string() + } + Some(Answer::Denied { note: Some(note) }) => { + deny(&format!("The owner denied this: {note}")) + } + Some(Answer::Denied { note: None }) => deny("The owner denied this."), + Some(Answer::Expired) => deny("The owner did not answer in time."), + None => deny("Botloft could not ask the owner."), + } +} + +fn deny(message: &str) -> String { + json!({ "behavior": "deny", "message": message }).to_string() +} + +/// Whether the bot's chat shows `tool_use_id` running, waiting briefly for +/// the event if it has not been read yet. +async fn matches_running_tool(daemon: &Daemon, bot: &BotId, tool_use_id: &str) -> bool { + if tool_use_id.is_empty() { + return false; + } + let deadline = tokio::time::Instant::now() + MATCH_WINDOW; + loop { + let found = daemon.store().tool_item(bot, tool_use_id); + if let Ok(Some(item)) = found + && matches!(&item.body, ChatBody::Tool(tool) if tool.status == ToolStatus::Running) + { + return true; + } + if tokio::time::Instant::now() >= deadline { + return false; + } + tokio::time::sleep(MATCH_POLL).await; + } +} diff --git a/crates/botloftd/src/chat/events.rs b/crates/botloftd/src/chat/events.rs index ea5b644d..95db46f9 100644 --- a/crates/botloftd/src/chat/events.rs +++ b/crates/botloftd/src/chat/events.rs @@ -2,7 +2,7 @@ //! (spec 8.1). Fields are read defensively: the format is not documented //! and grows between Claude Code versions. -use botloft_core::chat::{TOOL_INPUT_MAX, TOOL_OUTPUT_MAX, clip, tool_summary}; +use botloft_core::chat::{TOOL_OUTPUT_MAX, clip, tool_input_max, tool_summary}; use botloft_core::ids::BotId; use botloft_core::protocol::{ AccountUsage, ChatBody, ChatDelta, NoticeCode, NoticeItem, NoticeLevel, ReplyItem, ToolItem, @@ -12,6 +12,7 @@ use serde_json::Value; use tracing::{debug, warn}; use super::items; +use crate::service; use crate::state::{Daemon, Event}; /// Errors that restarting cannot fix: Claude Code needs the owner. @@ -21,6 +22,8 @@ const SIGN_IN_ERRORS: &[&str] = &[ "billing_error", "account_on_hold", ]; +/// The model does not exist or the account cannot use it (spec 7.4). +const MODEL_NOT_FOUND: &str = "model_not_found"; /// When a rate limit gives no reset time. const DEFAULT_LIMIT_MS: i64 = 5 * 60 * 1000; @@ -59,6 +62,12 @@ fn session(daemon: &Daemon, bot: &BotId, event: &Value) { } drop(store); daemon.supervisor.remember_session(bot, session); + if let Some(mode) = event["permissionMode"].as_str() { + service::modes::reported(daemon, bot, mode); + } + if let Some(model) = event["model"].as_str() { + service::models::reported(daemon, bot, model); + } } fn delta(daemon: &Daemon, bot: &BotId, event: &Value) { @@ -111,7 +120,7 @@ fn assistant(daemon: &Daemon, bot: &BotId, generation: u64, event: &Value) { tool_use_id: block["id"].as_str().unwrap_or_default().to_owned(), name: name.to_owned(), summary: tool_summary(name, input), - input: clip(&input.to_string(), TOOL_INPUT_MAX), + input: clip(&input.to_string(), tool_input_max(name)), status: ToolStatus::Running, output: None, }), @@ -144,6 +153,12 @@ fn failed_turn(daemon: &Daemon, bot: &BotId, generation: u64, error: &str, event NoticeCode::UsageLimit, "The account reached its usage limit. Messages wait until it resets.".to_owned(), ) + } else if error == MODEL_NOT_FOUND { + ( + NoticeCode::ModelUnavailable, + "Claude Code could not use this bot's model: it may not exist or not be on the account's plan. Pick another model." + .to_owned(), + ) } else if detail.is_empty() { (NoticeCode::TurnFailed, error.to_owned()) } else { diff --git a/crates/botloftd/src/config.rs b/crates/botloftd/src/config.rs index 692a602b..d0085e5f 100644 --- a/crates/botloftd/src/config.rs +++ b/crates/botloftd/src/config.rs @@ -85,6 +85,8 @@ pub struct BotsConfig { pub approval_timeout_minutes: u64, /// Largest attachment, per file (spec 9.5). pub attachment_max_mb: u64, + /// Most bots a chief's suggestions can bring a crew to (spec 10.2). + pub max_per_crew: usize, } impl Default for BotsConfig { @@ -92,6 +94,7 @@ impl Default for BotsConfig { Self { approval_timeout_minutes: 60, attachment_max_mb: 20, + max_per_crew: 12, } } } diff --git a/crates/botloftd/src/paths.rs b/crates/botloftd/src/paths.rs index 60286db9..a8bcc105 100644 --- a/crates/botloftd/src/paths.rs +++ b/crates/botloftd/src/paths.rs @@ -3,6 +3,8 @@ use std::io; use std::path::{Path, PathBuf}; +use botloft_core::protocol::Crew; + use crate::config::Config; /// Environment variable that moves the daemon's data directory, so a dev @@ -60,6 +62,15 @@ impl Paths { pub fn bot_workspace(&self, crew_slug: &str, bot_slug: &str) -> PathBuf { self.crew_dir(crew_slug).join(bot_slug) } + + /// The folder the crew works in: the one the owner chose, or `shared`. + pub fn work_folder(&self, crew: &Crew) -> PathBuf { + if crew.work_folder_chosen { + PathBuf::from(&crew.work_folder) + } else { + self.shared_dir(&crew.slug) + } + } } /// `--home` when given (the scheduled task passes it, spec 14), else diff --git a/crates/botloftd/src/platform/mod.rs b/crates/botloftd/src/platform/mod.rs index 1440b7d4..5fb51a5e 100644 --- a/crates/botloftd/src/platform/mod.rs +++ b/crates/botloftd/src/platform/mod.rs @@ -12,12 +12,12 @@ use std::path::{Path, PathBuf}; #[cfg(unix)] pub use unix::{ - KeepAwake, ProcessJob, delete_task, find_task, leave_own_console, register_task, + KeepAwake, ProcessJob, delete_task, find_task, leave_own_console, owner_name, register_task, restrict_to_current_user, run_task, stop_task, user_environment, }; #[cfg(windows)] pub use windows::{ - KeepAwake, ProcessJob, delete_task, find_task, leave_own_console, register_task, + KeepAwake, ProcessJob, delete_task, find_task, leave_own_console, owner_name, register_task, restrict_to_current_user, run_task, stop_task, user_environment, }; @@ -98,6 +98,11 @@ mod tests { assert!(!has("CLAUDE_CODE_MESSAGING_SOCKET")); } + #[test] + fn the_owner_has_a_name() { + assert!(!owner_name().trim().is_empty()); + } + #[test] fn a_job_can_be_created_and_terminated_empty() { let job = ProcessJob::new().expect("job"); diff --git a/crates/botloftd/src/platform/unix.rs b/crates/botloftd/src/platform/unix.rs index de9772d8..738a38e0 100644 --- a/crates/botloftd/src/platform/unix.rs +++ b/crates/botloftd/src/platform/unix.rs @@ -68,6 +68,11 @@ pub fn user_environment() -> io::Result<Vec<(OsString, OsString)>> { .collect()) } +/// The login name; Unix has no display name to ask for. +pub fn owner_name() -> String { + std::env::var("USER").unwrap_or_default() +} + /// Nothing to leave: Unix never opens a console for the daemon. pub fn leave_own_console() {} diff --git a/crates/botloftd/src/platform/windows.rs b/crates/botloftd/src/platform/windows.rs index fce4924d..426b9876 100644 --- a/crates/botloftd/src/platform/windows.rs +++ b/crates/botloftd/src/platform/windows.rs @@ -4,6 +4,7 @@ mod console; mod env; mod job; +mod owner; mod power; mod task; mod task_xml; @@ -11,6 +12,7 @@ mod task_xml; pub use console::leave_own_console; pub use env::user_environment; pub use job::ProcessJob; +pub use owner::owner_name; pub use power::KeepAwake; pub use task::{delete_task, find_task, register_task, run_task, stop_task}; diff --git a/crates/botloftd/src/platform/windows/owner.rs b/crates/botloftd/src/platform/windows/owner.rs new file mode 100644 index 00000000..8b97666d --- /dev/null +++ b/crates/botloftd/src/platform/windows/owner.rs @@ -0,0 +1,26 @@ +//! The owner's name as Windows shows it, for the app's account area. + +use windows::Win32::Security::Authentication::Identity::{GetUserNameExW, NameDisplay}; +use windows::core::PWSTR; + +/// The account's display name ("Ana Lima"), or the user name without one. +pub fn owner_name() -> String { + display_name() + .filter(|name| !name.trim().is_empty()) + .unwrap_or_else(|| std::env::var("USERNAME").unwrap_or_default()) +} + +fn display_name() -> Option<String> { + let mut len = 0u32; + // SAFETY: a size query with no buffer; it fails and sets `len` to the + // size needed, counting the final NUL. + let _ = unsafe { GetUserNameExW(NameDisplay, None, &mut len) }; + if len == 0 { + return None; + } + let mut buf = vec![0u16; len as usize]; + // SAFETY: `buf` holds `len` UTF-16 units; on success `len` becomes the + // length of the name without the NUL. + let found = unsafe { GetUserNameExW(NameDisplay, Some(PWSTR(buf.as_mut_ptr())), &mut len) }; + found.then(|| String::from_utf16_lossy(&buf[..len as usize])) +} diff --git a/crates/botloftd/src/rpc/dispatch.rs b/crates/botloftd/src/rpc/dispatch.rs index b7a6774f..75bbcc15 100644 --- a/crates/botloftd/src/rpc/dispatch.rs +++ b/crates/botloftd/src/rpc/dispatch.rs @@ -8,7 +8,8 @@ use serde_json::Value; use super::jsonrpc::{RpcError, empty_params}; use crate::approvals; use crate::service::{ - self, ApiResult, attachments, bots, chat, crews, deliveries, messages, tasks, + self, ApiResult, attachments, bots, chat, crews, deliveries, lead, messages, models, modes, + tasks, }; use crate::state::Daemon; @@ -24,11 +25,17 @@ pub fn dispatch(daemon: &Daemon, name: &str, params: Option<Value>) -> Result<Va method::CREWS_CREATE => reply(crews::create(daemon, parse(params)?)), method::CREWS_RENAME => reply(crews::rename(daemon, parse(params)?)), method::CREWS_SET_PAUSED => reply(crews::set_paused(daemon, parse(params)?)), + method::CREWS_SET_WORK_FOLDER => reply(crews::set_work_folder(daemon, parse(params)?)), + method::CREWS_SET_LEAD => reply(lead::set_lead(daemon, parse(params)?)), method::CREWS_ARCHIVE => reply(crews::archive(daemon, parse(params)?)), method::BOTS_LIST => reply(bots::list(daemon, parse(params)?)), method::BOTS_CREATE => reply(bots::create(daemon, parse(params)?)), method::BOTS_UPDATE => reply(bots::update(daemon, parse(params)?)), method::BOTS_SET_PAUSED => reply(bots::set_paused(daemon, parse(params)?)), + method::BOTS_SET_PERMISSION_MODE => { + reply(modes::set_permission_mode(daemon, parse(params)?)) + } + method::BOTS_SET_MODEL => reply(models::set_model(daemon, parse(params)?)), method::BOTS_ARCHIVE => reply(bots::archive(daemon, parse(params)?)), method::BOTS_RESTART => reply(bots::restart(daemon, parse(params)?)), method::CHAT_HISTORY => reply(chat::history(daemon, parse(params)?)), diff --git a/crates/botloftd/src/runtime/claude.rs b/crates/botloftd/src/runtime/claude.rs index 68509653..08ec832a 100644 --- a/crates/botloftd/src/runtime/claude.rs +++ b/crates/botloftd/src/runtime/claude.rs @@ -6,6 +6,10 @@ use std::path::{Path, PathBuf}; use std::process::{Command, Output, Stdio}; use std::time::{Duration, Instant}; +use botloft_core::protocol::ClaudeAccount; + +use super::AuthStatus; + /// First version with the inbox as a named pipe on native Windows. pub const MIN_VERSION: (u32, u32, u32) = (2, 1, 234); const PROBE_TIMEOUT: Duration = Duration::from_secs(15); @@ -108,16 +112,34 @@ pub fn probe(path: &Path, env: &[(OsString, OsString)]) -> Result<Claude, Claude /// Runs `claude auth status`, documented to print JSON with `loggedIn` and /// to exit with 0 when signed in and 1 when not (spec 19). -pub fn signed_in(path: &Path, env: &[(OsString, OsString)]) -> io::Result<bool> { +pub fn auth_status(path: &Path, env: &[(OsString, OsString)]) -> io::Result<AuthStatus> { let output = run(path, &["auth", "status", "--json"], env)?; - Ok(parse_signed_in(&output.stdout).unwrap_or(output.status.success())) + Ok(parse_auth_status(&output.stdout).unwrap_or(AuthStatus { + signed_in: output.status.success(), + account: None, + })) } -fn parse_signed_in(stdout: &[u8]) -> Option<bool> { - serde_json::from_slice::<serde_json::Value>(stdout) - .ok()? - .get("loggedIn")? - .as_bool() +/// Reads `loggedIn`, and when signed in `email`, `subscriptionType` and +/// `orgName` (seen with 2.1.284). +fn parse_auth_status(stdout: &[u8]) -> Option<AuthStatus> { + let json = serde_json::from_slice::<serde_json::Value>(stdout).ok()?; + let signed_in = json.get("loggedIn")?.as_bool()?; + let text = |key: &str| { + json.get(key) + .and_then(|value| value.as_str()) + .map(str::trim) + .filter(|value| !value.is_empty()) + .map(str::to_owned) + }; + Some(AuthStatus { + signed_in, + account: signed_in.then(|| ClaudeAccount { + email: text("email"), + plan: text("subscriptionType"), + organization: text("orgName"), + }), + }) } /// Runs Claude Code without a window and with `env` only, giving up after @@ -176,16 +198,31 @@ mod tests { } #[test] - fn reads_the_sign_in_from_auth_status() { + fn reads_the_sign_in_and_account_from_auth_status() { + let signed_in = parse_auth_status( + br#"{"loggedIn": true, "authMethod": "claude.ai", "email": "ana@example.com", + "orgName": "Exemplo", "subscriptionType": "max"}"#, + ) + .expect("parsed"); + assert!(signed_in.signed_in); assert_eq!( - parse_signed_in(br#"{"loggedIn": true, "authMethod": "claude.ai"}"#), - Some(true) + signed_in.account, + Some(ClaudeAccount { + email: Some("ana@example.com".into()), + plan: Some("max".into()), + organization: Some("Exemplo".into()), + }) ); + let signed_out = + parse_auth_status(br#"{"loggedIn": false, "authMethod": "none"}"#).expect("parsed"); assert_eq!( - parse_signed_in(br#"{"loggedIn": false, "authMethod": "none"}"#), - Some(false) + signed_out, + AuthStatus { + signed_in: false, + account: None + } ); - assert_eq!(parse_signed_in(b"Logged in"), None); + assert_eq!(parse_auth_status(b"Logged in"), None); } #[test] diff --git a/crates/botloftd/src/runtime/fake.rs b/crates/botloftd/src/runtime/fake.rs index 0a2a158c..c7f95b4e 100644 --- a/crates/botloftd/src/runtime/fake.rs +++ b/crates/botloftd/src/runtime/fake.rs @@ -12,7 +12,11 @@ use tokio::sync::{Notify, mpsc}; use serde_json::Value; -use super::{EVENT_BUFFER, Process, ProcessControl, ProcessEvent, Runtime, SignInCheck, SpawnSpec}; +use botloft_core::protocol::ClaudeAccount; + +use super::{ + AuthCheck, AuthStatus, EVENT_BUFFER, Process, ProcessControl, ProcessEvent, Runtime, SpawnSpec, +}; #[derive(Clone, Default)] pub struct FakeRuntime { @@ -93,10 +97,18 @@ impl FakeRuntime { } impl Runtime for FakeRuntime { - fn signed_in(&self, _program: std::path::PathBuf) -> SignInCheck { + fn auth_status(&self, _program: std::path::PathBuf) -> AuthCheck { let mut state = lock(&self.state); state.sign_in_checks += 1; - Box::pin(std::future::ready(Ok(state.signed_in))) + let signed_in = state.signed_in; + Box::pin(std::future::ready(Ok(AuthStatus { + signed_in, + account: signed_in.then(|| ClaudeAccount { + email: Some("owner@example.com".into()), + plan: Some("max".into()), + organization: None, + }), + }))) } fn spawn(&self, spec: SpawnSpec) -> io::Result<Process> { diff --git a/crates/botloftd/src/runtime/mod.rs b/crates/botloftd/src/runtime/mod.rs index 54ffe902..49591ac9 100644 --- a/crates/botloftd/src/runtime/mod.rs +++ b/crates/botloftd/src/runtime/mod.rs @@ -12,6 +12,7 @@ use std::io; use std::path::PathBuf; use std::pin::Pin; +use botloft_core::protocol::ClaudeAccount; use bytes::Bytes; use tokio::sync::mpsc; @@ -49,13 +50,21 @@ pub struct Process { pub control: Box<dyn ProcessControl>, } -/// The answer to "is Claude Code signed in?", computed off the async workers. -pub type SignInCheck = Pin<Box<dyn Future<Output = io::Result<bool>> + Send>>; +/// What `claude auth status` says: signed in or not, and to which account. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct AuthStatus { + pub signed_in: bool, + pub account: Option<ClaudeAccount>, +} + +/// An [`AuthStatus`], computed off the async workers. +pub type AuthCheck = Pin<Box<dyn Future<Output = io::Result<AuthStatus>> + Send>>; pub trait Runtime: Send + Sync + 'static { fn spawn(&self, spec: SpawnSpec) -> io::Result<Process>; - /// Whether the Claude Code at `program` is signed in (`claude auth status`). - fn signed_in(&self, program: PathBuf) -> SignInCheck; + /// Whether the Claude Code at `program` is signed in, and to which + /// account (`claude auth status`). + fn auth_status(&self, program: PathBuf) -> AuthCheck; } /// Capacity of the event channel between a process and the daemon. When it diff --git a/crates/botloftd/src/runtime/pipe.rs b/crates/botloftd/src/runtime/pipe.rs index 66a344b8..67ffd4d0 100644 --- a/crates/botloftd/src/runtime/pipe.rs +++ b/crates/botloftd/src/runtime/pipe.rs @@ -13,7 +13,7 @@ use tokio::sync::mpsc; use tracing::debug; use super::{ - EVENT_BUFFER, Process, ProcessControl, ProcessEvent, Runtime, SignInCheck, SpawnSpec, claude, + AuthCheck, EVENT_BUFFER, Process, ProcessControl, ProcessEvent, Runtime, SpawnSpec, claude, }; use crate::platform::{self, ProcessJob}; @@ -24,11 +24,11 @@ const STDERR_LINE_MAX: usize = 300; pub struct PipeRuntime; impl Runtime for PipeRuntime { - fn signed_in(&self, program: std::path::PathBuf) -> SignInCheck { + fn auth_status(&self, program: std::path::PathBuf) -> AuthCheck { Box::pin(async move { tokio::task::spawn_blocking(move || { let env = platform::user_environment()?; - claude::signed_in(&program, &env) + claude::auth_status(&program, &env) }) .await .map_err(io::Error::other)? diff --git a/crates/botloftd/src/service/bots.rs b/crates/botloftd/src/service/bots.rs index c69262b5..3b3f57f1 100644 --- a/crates/botloftd/src/service/bots.rs +++ b/crates/botloftd/src/service/bots.rs @@ -2,8 +2,8 @@ use botloft_core::ids::{BotId, CrewId}; use botloft_core::protocol::{ - Bot, BotIdParams, BotState, BotsCreateParams, BotsListParams, BotsRestartParams, - BotsSetPausedParams, BotsUpdateParams, Crew, + Bot, BotIdParams, BotModel, BotState, BotsCreateParams, BotsListParams, BotsRestartParams, + BotsSetPausedParams, BotsUpdateParams, Crew, PermissionMode, }; use botloft_core::{avatar, now_ms, slug, validate}; use botloft_store::{BotRecord, Store}; @@ -32,16 +32,62 @@ pub fn list(daemon: &Daemon, params: BotsListParams) -> ApiResult<Vec<Bot>> { } pub fn create(daemon: &Daemon, params: BotsCreateParams) -> ApiResult<Bot> { - let name = validate::name("name", ¶ms.name)?; - let role = validate::role(¶ms.role)?; - let instructions = validate::instructions(¶ms.instructions)?; + let new = NewBot::check( + ¶ms.name, + ¶ms.role, + ¶ms.instructions, + params.color, + params.model, + )?; let store = daemon.store(); let crew = crews::active(&store, ¶ms.crew_id)?; + let record = insert(daemon, &store, &crew, BotId::generate(), new)?; + let bot = changed(daemon, &store, &crew, record); + daemon.supervisor.wake(); + Ok(bot) +} + +/// The fields of a new bot, checked. +pub(crate) struct NewBot { + pub name: String, + pub role: String, + pub instructions: String, + pub color: Option<String>, + pub model: BotModel, +} + +impl NewBot { + pub(crate) fn check( + name: &str, + role: &str, + instructions: &str, + color: Option<String>, + model: Option<BotModel>, + ) -> ApiResult<Self> { + Ok(Self { + name: validate::name("name", name)?, + role: validate::role(role)?, + instructions: validate::instructions(instructions)?, + color: color.as_deref().map(parse_color).transpose()?, + model: model.unwrap_or(BotModel::Default), + }) + } +} - let handle = slug::slugify(&name, "bot"); - ensure_handle_free(&store, &crew.id, &handle, None)?; - let color = match params.color { - Some(color) => parse_color(&color)?, +/// Saves a bot in `crew` and writes its workspace, under the caller's lock +/// on the store; the caller announces it and wakes the supervisor. When +/// `crew.lead_bot_id` already names `id`, its rules say it leads. +pub(crate) fn insert( + daemon: &Daemon, + store: &Store, + crew: &Crew, + id: BotId, + new: NewBot, +) -> ApiResult<BotRecord> { + let handle = slug::slugify(&new.name, "bot"); + ensure_handle_free(store, &crew.id, &handle, None)?; + let color = match new.color { + Some(color) => color, None => avatar::palette_color(store.count_bots(&crew.id)?).to_owned(), }; let slug = pick_slug(&handle, |candidate| { @@ -51,23 +97,24 @@ pub fn create(daemon: &Daemon, params: BotsCreateParams) -> ApiResult<Bot> { })?; let record = BotRecord { - id: BotId::generate(), + id, crew_id: crew.id.clone(), - name, + name: new.name, handle, slug, - role, - instructions, + role: new.role, + instructions: new.instructions, color, paused: false, + permission_mode: PermissionMode::Default, + model: new.model, + model_in_use: None, created_at: now_ms(), archived_at: None, }; - workspace::prepare_bot(daemon.workspace_env(), &crew, &record).map_err(ApiError::Workspace)?; + workspace::prepare_bot(daemon.workspace_env(), crew, &record).map_err(ApiError::Workspace)?; store.insert_bot(&record)?; - let bot = changed(daemon, &store, &crew, record); - daemon.supervisor.wake(); - Ok(bot) + Ok(record) } pub fn update(daemon: &Daemon, params: BotsUpdateParams) -> ApiResult<Bot> { @@ -135,6 +182,7 @@ pub fn archive(daemon: &Daemon, params: BotIdParams) -> ApiResult<Bot> { } record.archived_at = Some(now_ms()); store.update_bot(&record)?; + super::lead::forget_archived(daemon, &store, &crew, &record.id)?; let bot = changed(daemon, &store, &crew, record); daemon.supervisor.wake(); Ok(bot) @@ -166,6 +214,9 @@ pub(crate) fn to_protocol(daemon: &Daemon, store: &Store, crew: &Crew, record: B instructions: record.instructions, color: record.color, paused: record.paused, + permission_mode: record.permission_mode, + model: record.model, + model_in_use: record.model_in_use, state, generation, workspace: workspace.to_string_lossy().into_owned(), @@ -175,7 +226,7 @@ pub(crate) fn to_protocol(daemon: &Daemon, store: &Store, crew: &Crew, record: B } } -fn changed(daemon: &Daemon, store: &Store, crew: &Crew, record: BotRecord) -> Bot { +pub(crate) fn changed(daemon: &Daemon, store: &Store, crew: &Crew, record: BotRecord) -> Bot { let bot = to_protocol(daemon, store, crew, record); daemon.emit(Event::BotChanged(bot.clone())); bot @@ -197,7 +248,7 @@ pub(crate) fn active(store: &Store, id: &BotId) -> ApiResult<(Crew, BotRecord)> Ok((crew, record)) } -fn ensure_handle_free( +pub(crate) fn ensure_handle_free( store: &Store, crew: &CrewId, handle: &str, diff --git a/crates/botloftd/src/service/crews.rs b/crates/botloftd/src/service/crews.rs index b9bc65e7..67e4d8ae 100644 --- a/crates/botloftd/src/service/crews.rs +++ b/crates/botloftd/src/service/crews.rs @@ -3,17 +3,23 @@ use botloft_core::ids::CrewId; use botloft_core::protocol::{ Crew, CrewIdParams, CrewsCreateParams, CrewsRenameParams, CrewsSetPausedParams, + CrewsSetWorkFolderParams, }; use botloft_core::{now_ms, slug, validate}; use botloft_store::Store; use tracing::warn; +use super::bots::NewBot; use super::{ApiError, ApiResult, bots, pick_slug}; use crate::state::{Daemon, Event}; use crate::workspace; pub fn list(daemon: &Daemon) -> ApiResult<Vec<Crew>> { - Ok(daemon.store().crews(false)?) + let crews = daemon.store().crews(false)?; + Ok(crews + .into_iter() + .map(|crew| present(daemon, crew)) + .collect()) } pub fn create(daemon: &Daemon, params: CrewsCreateParams) -> ApiResult<Crew> { @@ -23,18 +29,40 @@ pub fn create(daemon: &Daemon, params: CrewsCreateParams) -> ApiResult<Crew> { let slug = pick_slug(&slug::slugify(&name, "crew"), |candidate| { Ok(store.crew_slug_exists(candidate)? || daemon.paths.crew_dir(candidate).exists()) })?; - workspace::prepare_crew(&daemon.paths, &slug).map_err(ApiError::Workspace)?; + let chosen = params + .work_folder + .as_deref() + .map(|input| choose_folder(daemon, input)) + .transpose()?; - let crew = Crew { + let lead = params + .lead + .map(|lead| NewBot::check(&lead.name, &lead.role, &lead.instructions, None, lead.model)) + .transpose()?; + + let mut crew = Crew { id: CrewId::generate(), name, slug, + work_folder_chosen: chosen.is_some(), + work_folder: chosen.unwrap_or_default(), + lead_bot_id: None, paused: false, created_at: now_ms(), archived_at: None, }; + workspace::prepare_crew(&daemon.paths, &crew).map_err(ApiError::Workspace)?; store.insert_crew(&crew)?; - daemon.emit(Event::CrewChanged(crew.clone())); + // The chief is saved before the store is let go, so it starts as one. + let chief = match lead { + Some(lead) => Some(super::lead::create_chief(daemon, &store, &mut crew, lead)?), + None => None, + }; + let crew = changed(daemon, crew); + if let Some(chief) = chief { + bots::changed(daemon, &store, &crew, chief); + daemon.supervisor.wake(); + } Ok(crew) } @@ -51,8 +79,41 @@ pub fn rename(daemon: &Daemon, params: CrewsRenameParams) -> ApiResult<Crew> { warn!(bot = %bot.id, "could not refresh the bot rules after a crew rename: {err}"); } } - daemon.emit(Event::CrewChanged(crew.clone())); - Ok(crew) + Ok(changed(daemon, crew)) +} + +/// Moves the crew to another work folder, or back to `shared`. Each bot +/// restarts to reach it once nothing is in progress (spec 7.4). +pub fn set_work_folder(daemon: &Daemon, params: CrewsSetWorkFolderParams) -> ApiResult<Crew> { + let chosen = params + .work_folder + .as_deref() + .map(|input| choose_folder(daemon, input)) + .transpose()?; + let store = daemon.store(); + let mut crew = active(&store, ¶ms.crew_id)?; + if crew.work_folder_chosen == chosen.is_some() + && chosen + .as_deref() + .is_none_or(|path| path == crew.work_folder) + { + return Ok(present(daemon, crew)); + } + crew.work_folder_chosen = chosen.is_some(); + crew.work_folder = chosen.unwrap_or_default(); + workspace::prepare_crew(&daemon.paths, &crew).map_err(ApiError::Workspace)?; + store.update_crew(&crew)?; + + let bots = store.bots(Some(&crew.id), false)?; + drop(store); + for bot in &bots { + if let Err(err) = workspace::write_rules(&daemon.paths, &crew, bot) { + warn!(bot = %bot.id, "could not refresh the bot rules after a folder change: {err}"); + } + daemon.supervisor.launch_settings_changed(&bot.id); + } + tracing::info!(crew = %crew.id, "work folder changed"); + Ok(changed(daemon, crew)) } pub fn set_paused(daemon: &Daemon, params: CrewsSetPausedParams) -> ApiResult<Crew> { @@ -61,10 +122,11 @@ pub fn set_paused(daemon: &Daemon, params: CrewsSetPausedParams) -> ApiResult<Cr if crew.paused != params.paused { crew.paused = params.paused; store.update_crew(&crew)?; - daemon.emit(Event::CrewChanged(crew.clone())); + let crew = changed(daemon, crew); daemon.supervisor.wake(); + return Ok(crew); } - Ok(crew) + Ok(present(daemon, crew)) } /// Archives the crew and its bots. Archiving twice is not an error. @@ -72,7 +134,7 @@ pub fn archive(daemon: &Daemon, params: CrewIdParams) -> ApiResult<Crew> { let store = daemon.store(); let crew = find(&store, ¶ms.crew_id)?; if crew.archived_at.is_some() { - return Ok(crew); + return Ok(present(daemon, crew)); } let bots = store.bots(Some(&crew.id), false)?; store.archive_crew(&crew.id, now_ms())?; @@ -85,11 +147,31 @@ pub fn archive(daemon: &Daemon, params: CrewIdParams) -> ApiResult<Crew> { ))); } } - daemon.emit(Event::CrewChanged(crew.clone())); + let crew = changed(daemon, crew); daemon.supervisor.wake(); Ok(crew) } +/// The crew as the app sees it: with the path of its `shared` folder when +/// the owner chose none. +pub(crate) fn present(daemon: &Daemon, mut crew: Crew) -> Crew { + if !crew.work_folder_chosen { + crew.work_folder = daemon.paths.work_folder(&crew).display().to_string(); + } + crew +} + +pub(crate) fn changed(daemon: &Daemon, crew: Crew) -> Crew { + let crew = present(daemon, crew); + daemon.emit(Event::CrewChanged(crew.clone())); + crew +} + +fn choose_folder(daemon: &Daemon, input: &str) -> ApiResult<String> { + let path = workspace::folder::choose(&daemon.paths, input).map_err(ApiError::validation)?; + Ok(path.display().to_string()) +} + pub(crate) fn find(store: &Store, id: &CrewId) -> ApiResult<Crew> { store .crew(id)? diff --git a/crates/botloftd/src/service/lead.rs b/crates/botloftd/src/service/lead.rs new file mode 100644 index 00000000..c288fa87 --- /dev/null +++ b/crates/botloftd/src/service/lead.rs @@ -0,0 +1,132 @@ +//! A crew's chief (spec 10.2): created with the crew, moved by the owner, +//! and the only bot that may suggest new ones. + +use botloft_core::ids::BotId; +use botloft_core::protocol::{Bot, Crew, CrewsSetLeadParams}; +use botloft_store::{BotRecord, Store}; +use tracing::{info, warn}; + +use super::bots::{self, NewBot}; +use super::{ApiError, ApiResult, crews}; +use crate::state::Daemon; +use crate::workspace; + +pub(crate) fn is_lead(crew: &Crew, bot: &BotId) -> bool { + crew.lead_bot_id.as_ref() == Some(bot) +} + +/// Saves the chief of a crew being created, under the caller's lock, so its +/// first start already reads that it leads. +pub(crate) fn create_chief( + daemon: &Daemon, + store: &Store, + crew: &mut Crew, + lead: NewBot, +) -> ApiResult<BotRecord> { + let id = BotId::generate(); + crew.lead_bot_id = Some(id.clone()); + let record = bots::insert(daemon, store, crew, id, lead)?; + store.update_crew(crew)?; + Ok(record) +} + +/// Makes a bot of the crew its chief, or leaves the crew without one. The +/// old and the new chief restart to read their rules once idle. +pub fn set_lead(daemon: &Daemon, params: CrewsSetLeadParams) -> ApiResult<Crew> { + let store = daemon.store(); + let mut crew = crews::active(&store, ¶ms.crew_id)?; + if let Some(bot) = ¶ms.bot_id { + let (bot_crew, _) = bots::active(&store, bot)?; + if bot_crew.id != crew.id { + return Err(ApiError::validation(format!( + "bot {bot} is not in crew {}", + crew.id + ))); + } + } + if crew.lead_bot_id == params.bot_id { + return Ok(crews::present(daemon, crew)); + } + let old = std::mem::replace(&mut crew.lead_bot_id, params.bot_id.clone()); + store.update_crew(&crew)?; + + let touched: Vec<BotId> = old.into_iter().chain(params.bot_id).collect(); + for id in &touched { + match store.bot(id) { + Ok(Some(record)) if record.archived_at.is_none() => { + if let Err(err) = workspace::write_rules(&daemon.paths, &crew, &record) { + warn!(bot = %id, "could not refresh the rules of a chief: {err}"); + } + } + Ok(_) => {} + Err(err) => warn!(bot = %id, "could not read a chief: {err}"), + } + } + drop(store); + for id in &touched { + daemon.supervisor.launch_settings_changed(id); + } + info!(crew = %crew.id, "chief changed"); + Ok(crews::changed(daemon, crew)) +} + +/// An archived chief leaves its crew without one. +pub(crate) fn forget_archived( + daemon: &Daemon, + store: &Store, + crew: &Crew, + bot: &BotId, +) -> ApiResult<()> { + if !is_lead(crew, bot) { + return Ok(()); + } + let mut crew = crew.clone(); + crew.lead_bot_id = None; + store.update_crew(&crew)?; + crews::changed(daemon, crew); + Ok(()) +} + +/// Whether the chief `lead` may add `new` to its crew now: it still leads, +/// the name is free and the crew has room. Checked before asking the owner +/// and again when creating. +pub(crate) fn check_suggestion(daemon: &Daemon, lead: &BotId, new: &NewBot) -> ApiResult<()> { + let store = daemon.store(); + room_for(daemon, &store, lead, new).map(drop) +} + +/// Creates a bot the chief suggested and the owner allowed (spec 10.2). +pub(crate) fn create_suggested(daemon: &Daemon, lead: &BotId, new: NewBot) -> ApiResult<Bot> { + let store = daemon.store(); + let crew = room_for(daemon, &store, lead, &new)?; + let record = bots::insert(daemon, &store, &crew, BotId::generate(), new)?; + let bot = bots::changed(daemon, &store, &crew, record); + drop(store); + daemon.supervisor.wake(); + info!(crew = %crew.id, bot = %bot.id, "the chief's suggested bot was created"); + Ok(bot) +} + +fn room_for(daemon: &Daemon, store: &Store, lead: &BotId, new: &NewBot) -> ApiResult<Crew> { + let (crew, _) = bots::active(store, lead)?; + if !is_lead(&crew, lead) { + return Err(ApiError::Conflict( + "only the crew's chief can suggest new bots; ask the chief with send_message".into(), + )); + } + let size = store.bots(Some(&crew.id), false)?.len(); + let max = daemon.bots.max_per_crew; + if size >= max { + return Err(ApiError::Conflict(format!( + "the crew already has {size} bots, the most a chief can reach ({max}); \ + use the bots you have, or ask the owner to archive one" + ))); + } + bots::ensure_handle_free( + store, + &crew.id, + &botloft_core::slug::slugify(&new.name, "bot"), + None, + )?; + Ok(crew) +} diff --git a/crates/botloftd/src/service/mod.rs b/crates/botloftd/src/service/mod.rs index b3c42fe4..108e5c7f 100644 --- a/crates/botloftd/src/service/mod.rs +++ b/crates/botloftd/src/service/mod.rs @@ -6,10 +6,13 @@ pub mod bots; pub mod chat; pub mod crews; pub mod deliveries; +pub mod lead; pub mod messages; +pub mod models; +pub mod modes; pub mod tasks; -use botloft_core::protocol::{PROTOCOL_VERSION, SystemStatus, error_code}; +use botloft_core::protocol::{OwnerAccount, PROTOCOL_VERSION, SystemStatus, error_code}; use botloft_core::slug; use botloft_core::validate::ValidationError; use botloft_store::StoreError; @@ -58,6 +61,13 @@ impl From<StoreError> for ApiError { pub type ApiResult<T> = Result<T, ApiError>; +/// The owner's name, asked of Windows once: it does not change while the +/// daemon runs. +fn owner_name() -> String { + static NAME: std::sync::OnceLock<String> = std::sync::OnceLock::new(); + NAME.get_or_init(crate::platform::owner_name).clone() +} + pub fn status(daemon: &Daemon) -> ApiResult<SystemStatus> { let deliveries = daemon.store().delivery_backlog()?; Ok(SystemStatus { @@ -71,6 +81,10 @@ pub fn status(daemon: &Daemon) -> ApiResult<SystemStatus> { .claude_path() .map(|path| path.display().to_string()), claude_signed_in: daemon.supervisor.claude_signed_in(), + account: OwnerAccount { + name: owner_name(), + claude: daemon.supervisor.claude_account(), + }, deliveries, usage: daemon.usage(), }) diff --git a/crates/botloftd/src/service/models.rs b/crates/botloftd/src/service/models.rs new file mode 100644 index 00000000..3a1b76a0 --- /dev/null +++ b/crates/botloftd/src/service/models.rs @@ -0,0 +1,44 @@ +//! A bot's model (spec 7.4): what the owner picks, and the model Claude +//! Code reports at the start of each turn. + +use botloft_core::ids::BotId; +use botloft_core::protocol::{Bot, BotsSetModelParams}; +use tracing::{info, warn}; + +use super::ApiResult; +use super::bots::{active, changed, to_protocol}; +use crate::state::Daemon; + +/// Saves the model; the bot restarts on it when nothing is in progress. +pub fn set_model(daemon: &Daemon, params: BotsSetModelParams) -> ApiResult<Bot> { + let store = daemon.store(); + let (crew, mut record) = active(&store, ¶ms.bot_id)?; + if record.model == params.model { + return Ok(to_protocol(daemon, &store, &crew, record)); + } + record.model = params.model; + store.update_bot(&record)?; + let bot = changed(daemon, &store, &crew, record); + drop(store); + info!(bot = %params.bot_id, model = params.model.as_str(), "model changed"); + daemon.supervisor.launch_settings_changed(¶ms.bot_id); + Ok(bot) +} + +/// The model id in `system/init`, so the app can name the model a bot +/// really runs on, the plan's default included. +pub(crate) fn reported(daemon: &Daemon, bot: &BotId, model: &str) { + let store = daemon.store(); + let Ok((crew, mut record)) = active(&store, bot) else { + return; + }; + if model.is_empty() || record.model_in_use.as_deref() == Some(model) { + return; + } + if let Err(err) = store.set_model_in_use(bot, model) { + warn!(bot = %bot, "could not save the model in use: {err}"); + return; + } + record.model_in_use = Some(model.to_owned()); + changed(daemon, &store, &crew, record); +} diff --git a/crates/botloftd/src/service/modes.rs b/crates/botloftd/src/service/modes.rs new file mode 100644 index 00000000..85a02c91 --- /dev/null +++ b/crates/botloftd/src/service/modes.rs @@ -0,0 +1,55 @@ +//! A bot's permission mode (spec 7.4): what the owner picks in the chat, +//! and what Claude Code reports when it changes the mode by itself. + +use botloft_core::ids::BotId; +use botloft_core::protocol::{Bot, BotsSetPermissionModeParams, PermissionMode}; +use tracing::{info, warn}; + +use super::ApiResult; +use super::bots::{active, changed, to_protocol}; +use crate::state::Daemon; + +/// Saves the mode; the bot restarts into it when nothing is in progress. +pub fn set_permission_mode(daemon: &Daemon, params: BotsSetPermissionModeParams) -> ApiResult<Bot> { + let store = daemon.store(); + let (crew, mut record) = active(&store, ¶ms.bot_id)?; + if record.permission_mode == params.mode { + return Ok(to_protocol(daemon, &store, &crew, record)); + } + record.permission_mode = params.mode; + store.update_bot(&record)?; + let bot = changed(daemon, &store, &crew, record); + drop(store); + info!(bot = %params.bot_id, mode = params.mode.as_str(), "permission mode changed"); + daemon.supervisor.launch_settings_changed(¶ms.bot_id); + Ok(bot) +} + +/// The mode Claude Code reports in `system/init`. It leaves plan mode by +/// itself when the owner approves a plan; the stored mode follows, so the +/// app shows what the bot does and a restart keeps it. Any other difference +/// comes from a process that is about to restart into the mode the owner +/// just picked, and is ignored. +pub(crate) fn reported(daemon: &Daemon, bot: &BotId, reported: &str) { + let Some(mode) = PermissionMode::from_cli(reported) else { + return; + }; + if mode == PermissionMode::Plan + || daemon.supervisor.launched_mode(bot) != Some(PermissionMode::Plan) + { + return; + } + let store = daemon.store(); + let Ok((crew, mut record)) = active(&store, bot) else { + return; + }; + if record.permission_mode != PermissionMode::Plan { + return; + } + record.permission_mode = mode; + if let Err(err) = store.update_bot(&record) { + warn!(bot = %bot, "could not save the mode after the plan: {err}"); + return; + } + changed(daemon, &store, &crew, record); +} diff --git a/crates/botloftd/src/state.rs b/crates/botloftd/src/state.rs index bbba196a..318b18b0 100644 --- a/crates/botloftd/src/state.rs +++ b/crates/botloftd/src/state.rs @@ -44,6 +44,8 @@ pub struct BotSettings { pub approval_timeout: Duration, /// Largest attachment, per file (spec 9.5). pub attachment_max_bytes: u64, + /// Most bots a chief's suggestions can bring a crew to (spec 10.2). + pub max_per_crew: usize, } impl BotSettings { @@ -51,6 +53,7 @@ impl BotSettings { Self { approval_timeout: Duration::from_secs(config.bots.approval_timeout_minutes * 60), attachment_max_bytes: config.bots.attachment_max_mb * 1024 * 1024, + max_per_crew: config.bots.max_per_crew, } } } diff --git a/crates/botloftd/src/supervisor/mod.rs b/crates/botloftd/src/supervisor/mod.rs index 8724f696..0a4f83c0 100644 --- a/crates/botloftd/src/supervisor/mod.rs +++ b/crates/botloftd/src/supervisor/mod.rs @@ -6,6 +6,7 @@ //! (service calls read states), never the other way around. mod reconcile; +mod relaunch; mod settings; mod sign_in; mod slot; diff --git a/crates/botloftd/src/supervisor/relaunch.rs b/crates/botloftd/src/supervisor/relaunch.rs new file mode 100644 index 00000000..21f9626c --- /dev/null +++ b/crates/botloftd/src/supervisor/relaunch.rs @@ -0,0 +1,65 @@ +//! A new launch setting reaches the bot (spec 7.4): its permission mode or +//! its model. Claude Code only reads `--permission-mode` and `--model` when +//! it starts, so the process restarts, resuming the conversation, as soon +//! as nothing is in progress: at once when idle, or when the turn that is +//! running (and its approvals) ends. + +use botloft_core::ids::BotId; +use botloft_core::protocol::PermissionMode; +use tracing::warn; + +use super::Supervisor; +use super::slot::{Slot, StopIntent}; + +impl Supervisor { + pub fn launch_settings_changed(&self, bot: &BotId) { + let mut inner = self.lock(); + let Some(slot) = inner.slots.get_mut(bot) else { + return; + }; + if slot.running.is_none() || slot.stop.is_some() { + // The next start reads the new settings anyway. + return; + } + if slot.turns == 0 && slot.approvals == 0 { + self.relaunch(bot, slot); + } else { + slot.restart_when_idle = true; + } + } + + /// Whether new settings wait for the running turn to end. + pub fn relaunch_pending(&self, bot: &BotId) -> bool { + self.lock() + .slots + .get(bot) + .is_some_and(|slot| slot.restart_when_idle) + } + + /// The `--permission-mode` the running process started with. + pub fn launched_mode(&self, bot: &BotId) -> Option<PermissionMode> { + self.lock() + .slots + .get(bot) + .and_then(|slot| slot.running.as_ref()) + .map(|running| running.permission_mode) + } + + /// Called when a turn or an approval ends. + pub(super) fn relaunch_if_idle(&self, bot: &BotId, slot: &mut Slot) { + if slot.restart_when_idle && slot.turns == 0 && slot.approvals == 0 && slot.stop.is_none() { + self.relaunch(bot, slot); + } + } + + fn relaunch(&self, bot: &BotId, slot: &mut Slot) { + slot.restart_when_idle = false; + slot.stop = Some(StopIntent::Restart { fresh: false }); + if let Some(running) = &slot.running + && let Err(err) = running.control.kill() + { + warn!(bot = %bot, "could not restart the bot for its new settings: {err}"); + } + self.wake(); + } +} diff --git a/crates/botloftd/src/supervisor/sign_in.rs b/crates/botloftd/src/supervisor/sign_in.rs index f1afec03..d9170e2d 100644 --- a/crates/botloftd/src/supervisor/sign_in.rs +++ b/crates/botloftd/src/supervisor/sign_in.rs @@ -4,7 +4,7 @@ //! When it turns from signed out to signed in, the bots a sign-in error //! stopped start again by themselves: the owner just signed in. -use botloft_core::protocol::BotState; +use botloft_core::protocol::{BotState, ClaudeAccount}; use tokio::time::Instant; use tracing::{debug, info}; @@ -13,6 +13,7 @@ use super::{ClaudeStatus, Inner, REPROBE_AFTER, Supervisor}; #[derive(Debug, Default)] pub(super) struct SignIn { known: Option<bool>, + account: Option<ClaudeAccount>, checked_at: Option<Instant>, recheck: bool, } @@ -36,6 +37,11 @@ impl Supervisor { self.lock().sign_in.known } + /// The Claude account Claude Code is signed in to, once checked. + pub fn claude_account(&self) -> Option<ClaudeAccount> { + self.lock().sign_in.account.clone() + } + /// Checks Claude Code again now: the sign-in, and the executable if it /// was missing or too old (after the owner signed in or installed it). pub fn refresh_claude(&self) { @@ -64,12 +70,14 @@ impl Supervisor { _ => return, } }; - let checked = self.runtime.signed_in(program).await; + let checked = self.runtime.auth_status(program).await; let mut inner = self.lock(); inner.sign_in.recheck = false; inner.sign_in.checked_at = Some(Instant::now()); match checked { - Ok(signed_in) => { + Ok(status) => { + let signed_in = status.signed_in; + inner.sign_in.account = status.account; let was = inner.sign_in.known.replace(signed_in); if signed_in && was == Some(false) { info!("Claude Code is signed in again; starting the bots it stopped"); diff --git a/crates/botloftd/src/supervisor/slot.rs b/crates/botloftd/src/supervisor/slot.rs index 2f911930..7b1b605e 100644 --- a/crates/botloftd/src/supervisor/slot.rs +++ b/crates/botloftd/src/supervisor/slot.rs @@ -2,7 +2,7 @@ use std::time::Duration; -use botloft_core::protocol::BotState; +use botloft_core::protocol::{BotState, PermissionMode}; use tokio::time::Instant; use crate::runtime::ProcessControl; @@ -24,6 +24,9 @@ pub(super) struct Slot { pub approvals: u32, /// While `rate_limited`: Unix ms when the limit resets. pub limited_until: Option<i64>, + /// A new permission mode or model waits for the running turn to end + /// (spec 7.4). + pub restart_when_idle: bool, } impl Slot { @@ -39,6 +42,7 @@ impl Slot { turns: 0, approvals: 0, limited_until: None, + restart_when_idle: false, } } @@ -69,6 +73,8 @@ pub(super) struct Running { /// Started with `--resume`. pub resumed: bool, pub token_hash: String, + /// The `--permission-mode` it started with. + pub permission_mode: PermissionMode, } #[derive(Debug, Clone, Copy, PartialEq, Eq)] diff --git a/crates/botloftd/src/supervisor/spawn.rs b/crates/botloftd/src/supervisor/spawn.rs index 00757a4b..911e710b 100644 --- a/crates/botloftd/src/supervisor/spawn.rs +++ b/crates/botloftd/src/supervisor/spawn.rs @@ -23,6 +23,8 @@ use crate::{approvals, courier, workspace}; /// Tools the bot uses without asking: its crew tools (spec 7.4). const ALLOWED_TOOLS: &str = "mcp__botloft"; +/// Makes Claude Code load `CLAUDE.md` from `--add-dir` folders (spec 5). +const ADDITIONAL_MEMORY: &str = "CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD"; /// Where permission requests go (spec 10.1). const PERMISSION_TOOL: &str = "mcp__botloft__permission_prompt"; @@ -67,12 +69,14 @@ impl Supervisor { slot.turns = 0; slot.approvals = 0; slot.limited_until = None; + slot.restart_when_idle = false; tokens.insert(launch.token_hash.clone(), (bot.id.clone(), generation)); slot.running = Some(Running { control: process.control, started: Instant::now(), resumed: launch.resumed, token_hash: launch.token_hash, + permission_mode: bot.permission_mode, }); self.count_busy(slot.state, BotState::Launching); slot.state = BotState::Launching; @@ -197,7 +201,7 @@ fn launch_spec( "project,local", "--strict-mcp-config", "--permission-mode", - "default", + bot.permission_mode.cli_value(), "--permission-prompt-tool", PERMISSION_TOOL, "--allowedTools", @@ -207,6 +211,14 @@ fn launch_spec( args.push(arg.into()); } args.push(mcp.into_os_string()); + // The crew's work folder, which the bot edits like its own (spec 5). + args.push("--add-dir".into()); + args.push(daemon.paths.work_folder(crew).into_os_string()); + // Without the flag, Claude Code uses the default of the owner's plan. + if let Some(model) = bot.model.cli_value() { + args.push("--model".into()); + args.push(model.into()); + } let mut env = platform::user_environment()?; env.retain(|(name, _)| { @@ -219,6 +231,8 @@ fn launch_spec( ("BOTLOFT_BOT_ID", OsString::from(bot.id.as_str())), ("BOTLOFT_BOT_TOKEN", OsString::from(&token)), ("BOTLOFT_PORT", OsString::from(daemon.port.to_string())), + // Loads the work folder's CLAUDE.md with the bot's memory. + (ADDITIONAL_MEMORY, OsString::from("1")), ] { env.push((OsString::from(name), value)); } diff --git a/crates/botloftd/src/supervisor/turns.rs b/crates/botloftd/src/supervisor/turns.rs index 88afbd99..cfab3617 100644 --- a/crates/botloftd/src/supervisor/turns.rs +++ b/crates/botloftd/src/supervisor/turns.rs @@ -44,6 +44,7 @@ impl Supervisor { if slot.is_working() { supervisor.set_state(bot, slot, slot.working_state()); } + supervisor.relaunch_if_idle(bot, slot); }); } diff --git a/crates/botloftd/src/tools/calls.rs b/crates/botloftd/src/tools/calls.rs index 313bae2f..6afe4f5d 100644 --- a/crates/botloftd/src/tools/calls.rs +++ b/crates/botloftd/src/tools/calls.rs @@ -17,7 +17,7 @@ use tracing::warn; use super::Failure; use super::catalog::{COMPLETE_TASK, CREW_ROSTER, MY_TASKS, SEND_MESSAGE}; use crate::service::tasks::{self, BotMessage}; -use crate::service::{ApiError, bots}; +use crate::service::{ApiError, bots, lead}; use crate::state::Daemon; /// What the bot reads when a tool fails. @@ -38,6 +38,11 @@ pub(super) fn call(daemon: &Daemon, bot: &BotId, params: &Value) -> Result<Value MY_TASKS => parse(arguments).and_then(|args| my_tasks(daemon, bot, args)), other => return Err(invalid(&format!("Unknown tool: {other}"))), }; + Ok(tool_result(outcome)) +} + +/// A tool result: the value as JSON text, or the error the bot reads. +pub(super) fn tool_result(outcome: Outcome) -> Value { let (text, is_error) = match outcome { Ok(value) => ( serde_json::to_string_pretty(&value).unwrap_or_default(), @@ -45,23 +50,23 @@ pub(super) fn call(daemon: &Daemon, bot: &BotId, params: &Value) -> Result<Value ), Err(message) => (message, true), }; - Ok(json!({ + json!({ "content": [{ "type": "text", "text": text }], "isError": is_error, - })) + }) } fn invalid(message: &str) -> Failure { Failure::new(StatusCode::OK, error_code::INVALID_PARAMS, message) } -fn parse<T: DeserializeOwned>(arguments: Value) -> Result<T, String> { +pub(super) fn parse<T: DeserializeOwned>(arguments: Value) -> Result<T, String> { serde_json::from_value(arguments).map_err(|err| format!("invalid arguments: {err}")) } /// The message a bot may see. Internal errors can name paths; they go to /// the log instead. -fn explain(err: ApiError) -> String { +pub(super) fn explain(err: ApiError) -> String { match err { ApiError::Internal(_) | ApiError::Workspace(_) => { warn!(error = %err, "a tool call failed"); @@ -81,10 +86,21 @@ fn roster(daemon: &Daemon, bot: &BotId) -> Outcome { .iter() .filter(|other| other.id != me.id) .map(|other| { - json!({ "handle": other.handle, "name": other.name, "role": other.role, "state": other.state }) + json!({ + "handle": other.handle, + "name": other.name, + "role": other.role, + "state": other.state, + "chief": lead::is_lead(&crew, &other.id), + }) }) .collect(); - Ok(json!({ "crew": crew.name, "you": me.handle, "bots": others })) + Ok(json!({ + "crew": crew.name, + "you": me.handle, + "you_lead": lead::is_lead(&crew, &me.id), + "bots": others, + })) } #[derive(Deserialize)] diff --git a/crates/botloftd/src/tools/catalog.rs b/crates/botloftd/src/tools/catalog.rs index 600073bb..ad9952ab 100644 --- a/crates/botloftd/src/tools/catalog.rs +++ b/crates/botloftd/src/tools/catalog.rs @@ -3,12 +3,16 @@ use serde_json::{Value, json}; +use super::suggest::{INSTRUCTIONS_MAX, REASON_MAX}; use crate::service::tasks::MAX_DEADLINE_MINUTES; +use botloft_core::validate::{NAME_MAX_CHARS, ROLE_MAX_CHARS}; pub const CREW_ROSTER: &str = "crew_roster"; pub const SEND_MESSAGE: &str = "send_message"; pub const COMPLETE_TASK: &str = "complete_task"; pub const MY_TASKS: &str = "my_tasks"; +/// The chief's tool (spec 10.2); Claude Code names it `mcp__botloft__suggest_bot`. +pub const SUGGEST_BOT: &str = "suggest_bot"; /// Claude Code's `--permission-prompt-tool` (spec 10.1). pub const PERMISSION_PROMPT: &str = "permission_prompt"; @@ -101,6 +105,50 @@ pub fn tools() -> Value { }, "annotations": { "readOnlyHint": true }, }, + { + "name": SUGGEST_BOT, + "title": "Suggest a new bot", + "description": "Only for the crew's chief (crew_roster marks it). Suggests a new bot \ + for work that needs a specialist the crew lacks. The owner sees the suggestion in \ + your chat, may change it, and approves or declines it; the call waits for that. \ + Once approved the bot starts at once: give it work with send_message. If the owner \ + declines, do the work yourself or with the bots you have.", + "inputSchema": { + "type": "object", + "properties": { + "name": { + "type": "string", + "maxLength": NAME_MAX_CHARS, + "description": "A short name, like \"Designer\". Its handle comes from it.", + }, + "role": { + "type": "string", + "maxLength": ROLE_MAX_CHARS, + "description": "One line: what the bot does in the crew.", + }, + "instructions": { + "type": "string", + "maxLength": INSTRUCTIONS_MAX, + "description": "Written to the new bot: what it works on, how, what it \ + hands back and when to ask.", + }, + "model": { + "type": "string", + "enum": ["default", "fable", "opus", "sonnet", "haiku"], + "description": "\"haiku\" for simple, repetitive work; \"sonnet\" for most \ + work; \"opus\" or \"fable\" for the hardest reasoning. The owner's \ + plan default when absent.", + }, + "reason": { + "type": "string", + "maxLength": REASON_MAX, + "description": "For the owner: why the crew needs this bot now.", + }, + }, + "required": ["name", "role", "instructions", "reason"], + "additionalProperties": false, + }, + }, { "name": PERMISSION_PROMPT, "title": "Permission prompt", diff --git a/crates/botloftd/src/tools/mod.rs b/crates/botloftd/src/tools/mod.rs index 9757df87..f2a00de6 100644 --- a/crates/botloftd/src/tools/mod.rs +++ b/crates/botloftd/src/tools/mod.rs @@ -9,6 +9,7 @@ mod calls; mod catalog; mod era; +mod suggest; use std::sync::Arc; @@ -30,8 +31,9 @@ use crate::state::Daemon; const CACHE_TTL_MS: u64 = 60 * 60 * 1000; const INSTRUCTIONS: &str = "Tools to work with your Botloft crew: see who is in it, send notes \ - or tasks to other bots, and report the result of tasks assigned to you. The owner writes to \ - you directly; messages from other bots and from Botloft start with [botloft]."; + or tasks to other bots, report the result of tasks assigned to you and, for the crew's chief, \ + suggest new bots. The owner writes to you directly; messages from other bots and from Botloft \ + start with [botloft]."; /// A JSON-RPC error with the HTTP status it goes out with. struct Failure { @@ -107,12 +109,16 @@ pub async fn handle( return StatusCode::ACCEPTED.into_response(); }; let answered = match era(&headers, &request) { - // Holds the request until the owner answers (spec 10.1). - Ok(era) if is_permission_prompt(&request) => { + // Both hold the request until the owner answers (spec 10.1, 10.2). + Ok(era) if called(&request) == Some(catalog::PERMISSION_PROMPT) => { permission(&daemon, &bot, generation, &request) .await .map(|result| decorate(era, &request, result)) } + Ok(era) if called(&request) == Some(catalog::SUGGEST_BOT) => { + let result = suggest::suggest(&daemon, &bot, generation, arguments(&request)).await; + Ok(decorate(era, &request, result)) + } Ok(era) => answer(&daemon, &bot, era, &request), Err(failure) => Err(failure), }; @@ -139,14 +145,25 @@ fn json_response(status: StatusCode, body: String) -> Response { (status, [(header::CONTENT_TYPE, "application/json")], body).into_response() } -fn is_permission_prompt(request: &Request) -> bool { - request.method == "tools/call" - && request - .params - .as_ref() - .and_then(|params| params.get("name")) - .and_then(Value::as_str) - == Some(catalog::PERMISSION_PROMPT) +/// The tool a `tools/call` names. +fn called(request: &Request) -> Option<&str> { + if request.method != "tools/call" { + return None; + } + request + .params + .as_ref() + .and_then(|params| params.get("name")) + .and_then(Value::as_str) +} + +fn arguments(request: &Request) -> Value { + request + .params + .as_ref() + .and_then(|params| params.get("arguments")) + .cloned() + .unwrap_or_else(|| json!({})) } async fn permission( @@ -155,19 +172,14 @@ async fn permission( generation: u64, request: &Request, ) -> Result<Value, Failure> { - let arguments = request - .params - .as_ref() - .and_then(|params| params.get("arguments")) - .cloned() - .unwrap_or_else(|| json!({})); - let args: approvals::PromptArgs = serde_json::from_value(arguments).map_err(|err| { - Failure::new( - StatusCode::OK, - error_code::INVALID_PARAMS, - format!("invalid arguments: {err}"), - ) - })?; + let args: approvals::PromptArgs = + serde_json::from_value(arguments(request)).map_err(|err| { + Failure::new( + StatusCode::OK, + error_code::INVALID_PARAMS, + format!("invalid arguments: {err}"), + ) + })?; let decision = approvals::prompt(daemon, bot, generation, args).await; Ok(json!({ "content": [{ "type": "text", "text": decision }], "isError": false })) } diff --git a/crates/botloftd/src/tools/suggest.rs b/crates/botloftd/src/tools/suggest.rs new file mode 100644 index 00000000..81887a37 --- /dev/null +++ b/crates/botloftd/src/tools/suggest.rs @@ -0,0 +1,144 @@ +//! `suggest_bot` (spec 10.2): the crew's chief asks for a new bot. The owner +//! sees the suggestion in the chief's chat, may change it, and allows or +//! declines it; the call waits for that, like a permission request. A chief +//! that bypasses permissions creates the bot at once. + +use botloft_core::chat::SUGGEST_TOOL; +use botloft_core::ids::BotId; +use botloft_core::protocol::{Bot, BotModel, PermissionMode}; +use serde::{Deserialize, Serialize}; +use serde_json::{Value, json}; + +use super::calls::{explain, parse, tool_result}; +use crate::approvals::{self, Answer}; +use crate::service::bots::{self, NewBot}; +use crate::service::lead; +use crate::state::Daemon; + +/// Longest instructions a chief may write for a new bot, in characters. +pub(super) const INSTRUCTIONS_MAX: usize = 8_000; +/// Longest reason, in characters. +pub(super) const REASON_MAX: usize = 1_000; + +/// The tool's input, and what the owner sends back when they change it. +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +struct Suggestion { + name: String, + role: String, + instructions: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + model: Option<String>, + reason: String, +} + +pub(super) async fn suggest( + daemon: &Daemon, + bot: &BotId, + generation: u64, + arguments: Value, +) -> Value { + tool_result(run(daemon, bot, generation, arguments).await) +} + +async fn run( + daemon: &Daemon, + bot: &BotId, + generation: u64, + arguments: Value, +) -> Result<Value, String> { + let suggestion: Suggestion = parse(arguments)?; + let new = check(&suggestion)?; + // Nothing impossible goes to the owner. + lead::check_suggestion(daemon, bot, &new).map_err(explain)?; + let mode = bots::find(&daemon.store(), bot) + .map_err(explain)? + .permission_mode; + if mode == PermissionMode::BypassPermissions { + let created = lead::create_suggested(daemon, bot, new).map_err(explain)?; + return Ok(created_note( + &created, + "You bypass permissions, so it was created without asking the owner.", + )); + } + + let input = serde_json::to_value(&suggestion).map_err(|err| err.to_string())?; + match approvals::ask(daemon, bot, generation, SUGGEST_TOOL, &input, "").await { + Some(Answer::Allowed { input: None }) => { + let created = lead::create_suggested(daemon, bot, new).map_err(explain)?; + Ok(created_note(&created, "The owner approved it.")) + } + Some(Answer::Allowed { + input: Some(changed), + }) => { + let changed: Suggestion = serde_json::from_str(&changed) + .map_err(|err| format!("the owner's changes could not be read: {err}"))?; + let created = lead::create_suggested(daemon, bot, check(&changed)?).map_err(explain)?; + Ok(created_note( + &created, + "The owner changed the suggestion before approving it: read the name, role \ + and model above.", + )) + } + Some(Answer::Denied { note }) => { + let why = note.map_or_else(String::new, |note| format!(" They said: {note}")); + Ok(json!({ + "created": false, + "note": format!( + "The owner declined this bot.{why} Do the work yourself or with the bots \ + you have." + ), + })) + } + Some(Answer::Expired) => Ok(json!({ + "created": false, + "note": "The owner did not answer in time. Do the work yourself or with the bots you \ + have, and suggest it again later if it still helps.", + })), + None => Err("Botloft could not ask the owner.".to_owned()), + } +} + +/// The suggestion as a new bot, with the limits of this tool on top of a +/// bot's own. +fn check(suggestion: &Suggestion) -> Result<NewBot, String> { + if suggestion.instructions.chars().count() > INSTRUCTIONS_MAX { + return Err(format!( + "instructions must be at most {INSTRUCTIONS_MAX} characters" + )); + } + let reason = suggestion.reason.trim(); + if reason.is_empty() || reason.chars().count() > REASON_MAX { + return Err(format!( + "reason must say, in at most {REASON_MAX} characters, why the crew needs this bot" + )); + } + let model = match suggestion.model.as_deref() { + None => None, + Some(model) => Some(model.parse::<BotModel>().map_err(|_| { + "model must be \"default\", \"fable\", \"opus\", \"sonnet\" or \"haiku\"".to_owned() + })?), + }; + NewBot::check( + &suggestion.name, + &suggestion.role, + &suggestion.instructions, + None, + model, + ) + .map_err(explain) +} + +fn created_note(bot: &Bot, how: &str) -> Value { + json!({ + "created": true, + "handle": bot.handle, + "name": bot.name, + "role": bot.role, + "model": bot.model, + "note": format!( + "{how} @{} is starting now. Give it work with send_message(to: \"{}\", kind: \"task\").", + bot.handle, bot.handle + ), + }) +} diff --git a/crates/botloftd/src/workspace/files.rs b/crates/botloftd/src/workspace/files.rs index 4c0370ff..ec24332d 100644 --- a/crates/botloftd/src/workspace/files.rs +++ b/crates/botloftd/src/workspace/files.rs @@ -50,9 +50,32 @@ session, including after restarts. Keep decisions, context about ongoing work and lessons learned here, and remove what is no longer true. "; +/// Added to the rules of the crew's chief (spec 10.2). +const LEAD_MD: &str = " +## You lead this crew + +The owner made you the chief of this crew: its goal is in your instructions. + +- Plan the work, split it into pieces that can run at the same time, and hand + them out with `send_message` and `kind: \"task\"`. Each bot works in + parallel; results come back as messages. Check them before you report. +- When a piece needs a specialist the crew lacks, call `suggest_bot`: a name, a + one-line role, instructions written to that bot, a model and why it helps. + The owner approves each new bot in your chat and may change it (unless you + bypass permissions). Then give it work with a task. +- Pick the model by the work: `haiku` for simple, repetitive tasks, `sonnet` + for most work, `opus` or `fable` only for the hardest reasoning. Leave it out + to use the owner's plan default. Stronger models use up the owner's plan + faster. +- Keep the crew small: do small jobs yourself and prefer a bot that already + exists (`crew_roster`). +- Tell the owner what each bot is doing, so they can follow and talk to each + one in its own chat. +"; + /// `.claude/rules/botloft.md`: who the bot is and how to work with its crew. /// Regenerated whenever the bot or its crew changes. -pub fn rules_md(crew: &Crew, bot: &BotRecord, shared_dir: &Path) -> String { +pub fn rules_md(crew: &Crew, bot: &BotRecord, work_folder: &Path) -> String { let role = if bot.role.is_empty() { "No role was given. Ask the owner if it is unclear what you should do." } else { @@ -63,6 +86,11 @@ pub fn rules_md(crew: &Crew, bot: &BotRecord, shared_dir: &Path) -> String { } else { bot.instructions.as_str() }; + let lead = if crew.lead_bot_id.as_ref() == Some(&bot.id) { + LEAD_MD + } else { + "" + }; format!( "<!-- Generated by Botloft. Edits are overwritten; change the bot in the Botloft app. --> @@ -91,8 +119,11 @@ app; the other bots of your crew send you messages too. ## Working with your crew -- This folder is your workspace. `CLAUDE.md` here is your memory across restarts. -- Files for the whole crew go in the shared folder: `{shared}`. +- The crew works in `{work}`: the owner reads what you make there, and so do + the other bots. Put the files you make for them in it. A `CLAUDE.md` in it + is loaded with your memory: follow it. +- This folder is yours: `CLAUDE.md` here is your memory across restarts, and + scratch files can stay here. - Messages from other bots and notices from Botloft start with `[botloft]`. The first line says who sent it; for a task it also has the task id and the deadline. @@ -107,11 +138,14 @@ app; the other bots of your crew send you messages too. (`status: \"failed\"` and why): the bot that asked is waiting for it. - Do not wait in a loop for a reply. Finish your turn; the reply arrives as a new message. -", +- If the crew needs another bot, ask its chief (`crew_roster` marks it with + `\"chief\": true`). Only the chief can suggest new bots. +{lead}", name = bot.name, handle = bot.handle, crew = crew.name, - shared = shared_dir.display(), + work = work_folder.display(), + lead = lead, ) } @@ -149,6 +183,9 @@ mod tests { id: CrewId::generate(), name: "Site".to_owned(), slug: "site".to_owned(), + work_folder: String::new(), + work_folder_chosen: false, + lead_bot_id: None, paused: false, created_at: 0, archived_at: None, @@ -163,6 +200,9 @@ mod tests { instructions: "Review every PR.".to_owned(), color: "#FF7A59".to_owned(), paused: false, + permission_mode: botloft_core::protocol::PermissionMode::Default, + model: botloft_core::protocol::BotModel::Default, + model_in_use: None, created_at: 0, archived_at: None, }; @@ -173,5 +213,14 @@ mod tests { assert!(rules.contains("Ask the owner")); assert!(rules.contains("/ws/site/shared")); assert!(rules.contains("attachments/")); + assert!(!rules.contains("You lead this crew")); + + let chief = Crew { + lead_bot_id: Some(bot.id.clone()), + ..crew + }; + let rules = rules_md(&chief, &bot, Path::new("/ws/site/shared")); + assert!(rules.contains("## You lead this crew")); + assert!(rules.contains("`suggest_bot`")); } } diff --git a/crates/botloftd/src/workspace/folder.rs b/crates/botloftd/src/workspace/folder.rs new file mode 100644 index 00000000..6271246f --- /dev/null +++ b/crates/botloftd/src/workspace/folder.rs @@ -0,0 +1,130 @@ +//! A work folder the owner picks for a crew (spec 5). Every bot of the crew +//! may edit it like its own folder, so it must not reach Botloft's data or +//! the other crews. + +use std::io; +use std::path::{Component, Path, PathBuf}; + +use crate::paths::Paths; + +/// Checks `input` and creates the folder if it is missing. The error is a +/// sentence for the owner. +pub fn choose(paths: &Paths, input: &str) -> Result<PathBuf, String> { + let input = input.trim(); + if input.is_empty() { + return Err("the work folder must not be empty".to_owned()); + } + let path = Path::new(input); + if !path.is_absolute() { + return Err(r"the work folder must be a full path, like C:\Projects\Site".to_owned()); + } + let path = + std::path::absolute(path).map_err(|err| format!("the work folder is not valid: {err}"))?; + if path.parent().is_none() { + return Err("pick a folder for the work folder, not a whole drive".to_owned()); + } + if overlaps(&path, &paths.home) { + return Err( + "the work folder cannot be inside Botloft's data folder or contain it".to_owned(), + ); + } + if contains(&path, &paths.workspaces_root) { + return Err("the work folder cannot contain the folders of every bot".to_owned()); + } + create(&path).map_err(|err| format!("could not create the work folder: {err}"))?; + Ok(path) +} + +fn create(path: &Path) -> io::Result<()> { + std::fs::create_dir_all(path)?; + if path.is_dir() { + Ok(()) + } else { + Err(io::Error::other("a file already has that name")) + } +} + +/// Windows paths ignore case; `\?\` and plain forms of a drive path match. +fn parts(path: &Path) -> Vec<String> { + path.components() + .filter_map(|component| match component { + Component::Prefix(prefix) => Some(match prefix.kind() { + std::path::Prefix::VerbatimDisk(drive) | std::path::Prefix::Disk(drive) => { + format!("{}:", char::from(drive).to_ascii_lowercase()) + } + _ => prefix.as_os_str().to_string_lossy().to_lowercase(), + }), + Component::RootDir | Component::CurDir => None, + Component::ParentDir => Some("..".to_owned()), + Component::Normal(part) => Some(part.to_string_lossy().to_lowercase()), + }) + .collect() +} + +/// Whether `outer` is `inner` or one of its parents. +fn contains(outer: &Path, inner: &Path) -> bool { + let (outer, inner) = (parts(outer), parts(inner)); + inner.len() >= outer.len() && inner[..outer.len()] == outer[..] +} + +fn overlaps(a: &Path, b: &Path) -> bool { + contains(a, b) || contains(b, a) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn paths(dir: &Path) -> Paths { + Paths::new(dir.join("Data").join("Botloft"), dir.join("Botloft")) + } + + #[test] + fn a_folder_of_the_owner_is_created_and_kept() { + let dir = tempfile::tempdir().expect("tempdir"); + let wanted = dir.path().join("Projects").join("Site"); + let chosen = choose(&paths(dir.path()), wanted.to_str().expect("utf-8")).expect("chosen"); + assert_eq!(chosen, wanted); + assert!(wanted.is_dir()); + } + + #[test] + fn botloft_data_the_bot_folders_and_drives_are_refused() { + let dir = tempfile::tempdir().expect("tempdir"); + let paths = paths(dir.path()); + let refused = [ + String::new(), + r"relative\folder".to_owned(), + paths.home.join("secrets").display().to_string(), + dir.path().join("Data").display().to_string(), + paths.workspaces_root.display().to_string(), + dir.path().display().to_string(), + ]; + for input in refused { + assert!(choose(&paths, &input).is_err(), "{input:?} was accepted"); + } + let root = dir.path().ancestors().last().expect("root"); + assert!(choose(&paths, root.to_str().expect("utf-8")).is_err()); + } + + #[test] + fn a_folder_inside_the_crew_folders_is_fine() { + let dir = tempfile::tempdir().expect("tempdir"); + let paths = paths(dir.path()); + let inside = paths.workspaces_root.join("site").join("out"); + assert!(choose(&paths, inside.to_str().expect("utf-8")).is_ok()); + } + + #[cfg(windows)] + #[test] + fn case_and_verbatim_prefixes_do_not_hide_an_overlap() { + assert!(contains( + Path::new(r"C:\Users\Ana"), + Path::new(r"\\?\c:\users\ana\AppData\Local\Botloft") + )); + assert!(!contains( + Path::new(r"C:\Users\Ana2"), + Path::new(r"C:\Users\Ana\x") + )); + } +} diff --git a/crates/botloftd/src/workspace/mod.rs b/crates/botloftd/src/workspace/mod.rs index 25c4779e..12bab010 100644 --- a/crates/botloftd/src/workspace/mod.rs +++ b/crates/botloftd/src/workspace/mod.rs @@ -3,6 +3,7 @@ //! bot's own `CLAUDE.md`. mod files; +pub mod folder; use std::io; use std::path::{Path, PathBuf}; @@ -22,14 +23,16 @@ pub struct WorkspaceEnv<'a> { pub approval_timeout: Duration, } -/// Creates the crew folder and its `shared` folder. -pub fn prepare_crew(paths: &Paths, crew_slug: &str) -> io::Result<()> { - std::fs::create_dir_all(paths.shared_dir(crew_slug)) +/// Creates the crew folder, its `shared` folder and the work folder the +/// owner chose, if it went missing. +pub fn prepare_crew(paths: &Paths, crew: &Crew) -> io::Result<()> { + std::fs::create_dir_all(paths.shared_dir(&crew.slug))?; + std::fs::create_dir_all(paths.work_folder(crew)) } /// Creates the workspace and writes every generated file. Returns the path. pub fn prepare_bot(env: WorkspaceEnv<'_>, crew: &Crew, bot: &BotRecord) -> io::Result<PathBuf> { - prepare_crew(env.paths, &crew.slug)?; + prepare_crew(env.paths, crew)?; let dir = env.paths.bot_workspace(&crew.slug, &bot.slug); std::fs::create_dir_all(dir.join(".claude").join("rules"))?; std::fs::create_dir_all(dir.join(".botloft"))?; @@ -55,7 +58,7 @@ pub fn write_rules(paths: &Paths, crew: &Crew, bot: &BotRecord) -> io::Result<() let dir = paths.bot_workspace(&crew.slug, &bot.slug); let rules_dir = dir.join(".claude").join("rules"); std::fs::create_dir_all(&rules_dir)?; - let text = files::rules_md(crew, bot, &paths.shared_dir(&crew.slug)); + let text = files::rules_md(crew, bot, &paths.work_folder(crew)); write_atomic(&rules_dir.join("botloft.md"), text.as_bytes()) } @@ -88,6 +91,9 @@ mod tests { id: CrewId::generate(), name: "Site".to_owned(), slug: "site".to_owned(), + work_folder: String::new(), + work_folder_chosen: false, + lead_bot_id: None, paused: false, created_at: 0, archived_at: None, @@ -102,6 +108,9 @@ mod tests { instructions: String::new(), color: "#FF7A59".to_owned(), paused: false, + permission_mode: botloft_core::protocol::PermissionMode::Default, + model: botloft_core::protocol::BotModel::Default, + model_in_use: None, created_at: 0, archived_at: None, }; diff --git a/crates/botloftd/tests/bot_models.rs b/crates/botloftd/tests/bot_models.rs new file mode 100644 index 00000000..3597f1b6 --- /dev/null +++ b/crates/botloftd/tests/bot_models.rs @@ -0,0 +1,129 @@ +//! A bot's model (spec 7.4): the flag it starts with, the restart onto a new +//! model once nothing is in progress, the model Claude Code reports and a +//! model the account cannot use. + +mod common; + +use std::time::Duration; + +use botloft_core::protocol::{BotModel, BotState, BotsSetModelParams, ChatBody, NoticeCode}; +use botloftd::service::{bots, models}; +use common::stream; +use common::supervised::{Setup, arg_after, setup}; +use serde_json::json; + +fn set_model(s: &Setup, model: BotModel) { + models::set_model( + &s.daemon, + BotsSetModelParams { + bot_id: s.bot.clone(), + model, + }, + ) + .expect("set model"); +} + +fn bot(s: &Setup) -> botloft_core::protocol::Bot { + bots::list(&s.daemon, Default::default()) + .expect("list") + .into_iter() + .find(|bot| bot.id == s.bot) + .expect("bot") +} + +#[tokio::test(start_paused = true)] +async fn a_new_bot_runs_on_the_plans_default_model() { + let s = setup().await; + let process = s.runtime.process(1).await; + assert!(!process.args().iter().any(|arg| arg == "--model")); + assert_eq!(bot(&s).model, BotModel::Default); + assert_eq!(bot(&s).model_in_use, None); +} + +#[tokio::test(start_paused = true)] +async fn an_idle_bot_restarts_on_its_new_model_in_the_same_conversation() { + let s = setup().await; + let first = s.runtime.process(1).await; + s.until(BotState::Idle).await; + let session = arg_after(&first, "--session-id").expect("session"); + + set_model(&s, BotModel::Haiku); + let second = s.runtime.process(2).await; + assert!(first.killed()); + assert_eq!(arg_after(&second, "--model").as_deref(), Some("haiku")); + assert_eq!(arg_after(&second, "--resume"), Some(session)); + + // Back to the plan's default: no flag at all. + s.until(BotState::Idle).await; + set_model(&s, BotModel::Default); + let third = s.runtime.process(3).await; + assert!(!third.args().iter().any(|arg| arg == "--model")); +} + +#[tokio::test(start_paused = true)] +async fn a_busy_bot_finishes_its_turn_before_changing_model() { + let s = setup().await; + let first = s.runtime.process(1).await; + s.until(BotState::Idle).await; + s.message("work"); + set_model(&s, BotModel::Opus); + tokio::time::sleep(Duration::from_secs(30)).await; + assert_eq!(s.runtime.processes().len(), 1, "the turn is not cut short"); + assert!(s.daemon.supervisor.relaunch_pending(&s.bot)); + + first.emit(stream::result(false)).await; + let second = s.runtime.process(2).await; + assert_eq!(arg_after(&second, "--model").as_deref(), Some("opus")); +} + +#[tokio::test(start_paused = true)] +async fn the_reported_model_is_kept_for_the_app() { + let s = setup().await; + let process = s.runtime.process(1).await; + s.until(BotState::Idle).await; + let session = arg_after(&process, "--session-id").expect("session"); + process + .emit(json!({ + "type": "system", "subtype": "init", "session_id": session, + "model": "claude-opus-5-5", "permissionMode": "default", + })) + .await; + tokio::time::sleep(Duration::from_millis(50)).await; + assert_eq!(bot(&s).model_in_use.as_deref(), Some("claude-opus-5-5")); + assert_eq!( + bot(&s).model, + BotModel::Default, + "the choice stays the owner's" + ); +} + +#[tokio::test(start_paused = true)] +async fn a_model_the_account_cannot_use_is_told_in_the_chat() { + let s = setup().await; + let process = s.runtime.process(1).await; + s.until(BotState::Idle).await; + s.message("hi"); + process + .emit(stream::api_error( + "model_not_found", + "There's an issue with the selected model (fable).", + )) + .await; + process.emit(stream::result(true)).await; + s.until(BotState::Idle).await; + + let items = s + .daemon + .store() + .chat_history(&s.bot, None, 50) + .expect("history"); + let notice = items + .iter() + .find_map(|item| match &item.body { + ChatBody::Notice(notice) => Some(notice.clone()), + _ => None, + }) + .expect("a notice"); + assert_eq!(notice.code, Some(NoticeCode::ModelUnavailable)); + assert_eq!(s.runtime.processes().len(), 1, "the bot keeps running"); +} diff --git a/crates/botloftd/tests/common/mod.rs b/crates/botloftd/tests/common/mod.rs index 0fd8ff64..75615f39 100644 --- a/crates/botloftd/tests/common/mod.rs +++ b/crates/botloftd/tests/common/mod.rs @@ -64,6 +64,7 @@ pub fn bot_settings() -> BotSettings { BotSettings { approval_timeout: Duration::from_secs(3), attachment_max_bytes: 1024 * 1024, + max_per_crew: 3, } } diff --git a/crates/botloftd/tests/common/supervised.rs b/crates/botloftd/tests/common/supervised.rs index 749c6d7c..abfc3fcf 100644 --- a/crates/botloftd/tests/common/supervised.rs +++ b/crates/botloftd/tests/common/supervised.rs @@ -26,7 +26,15 @@ pub struct Setup { pub async fn setup() -> Setup { let parts = new_daemon(test_settings()); let (daemon, runtime, clock, dir) = (parts.daemon, parts.runtime, parts.clock, parts.dir); - let crew = crews::create(&daemon, CrewsCreateParams { name: "Ops".into() }).expect("crew"); + let crew = crews::create( + &daemon, + CrewsCreateParams { + name: "Ops".into(), + work_folder: None, + lead: None, + }, + ) + .expect("crew"); let bot = bots::create( &daemon, BotsCreateParams { @@ -35,6 +43,7 @@ pub async fn setup() -> Setup { role: String::new(), instructions: String::new(), color: None, + model: None, }, ) .expect("bot"); diff --git a/crates/botloftd/tests/crew_chief.rs b/crates/botloftd/tests/crew_chief.rs new file mode 100644 index 00000000..b265d954 --- /dev/null +++ b/crates/botloftd/tests/crew_chief.rs @@ -0,0 +1,289 @@ +//! A crew's chief (spec 10.2): created with the crew, the only bot that can +//! suggest new ones, and the owner's say over each suggestion. + +mod common; + +use std::path::Path; + +use botloft_core::protocol::BotState; +use botloftd::runtime::fake::FakeProcess; +use common::bots::ready_bot; +use common::mcp::Mcp; +use common::{Client, TestDaemon}; +use serde_json::{Value, json}; +use tokio::task::JoinHandle; + +struct Chief { + t: TestDaemon, + app: Client, + crew: Value, + chief: Value, + mcp: Mcp, +} + +/// A crew "Site" created with its chief, whose process is ready. +async fn crew_with_chief() -> Chief { + let t = TestDaemon::start_supervised().await; + let mut app = t.session().await; + let crew = app + .call( + "crews.create", + json!({ + "name": "Site", + "lead": { "name": "Chefe", "role": "Leads the crew", "instructions": "Build the bakery's site" }, + }), + ) + .await + .expect("crew"); + let bots = app + .call("bots.list", json!({ "crewId": crew["id"] })) + .await + .expect("bots"); + let chief = bots[0].clone(); + assert_eq!(crew["leadBotId"], chief["id"]); + let (process, mcp) = ready(&t, &chief).await; + drop(process); + Chief { + t, + app, + crew, + chief, + mcp, + } +} + +async fn ready(t: &TestDaemon, bot: &Value) -> (FakeProcess, Mcp) { + let process = t.process_of(bot).await; + t.until_state(bot, BotState::Idle).await; + let mcp = Mcp::new(t.addr, process.env("BOTLOFT_BOT_TOKEN").expect("token")); + (process, mcp) +} + +fn designer() -> Value { + json!({ + "name": "Designer", + "role": "Draws each page", + "instructions": "Design the pages in shared/design and tell me when each is ready.", + "model": "sonnet", + "reason": "The site needs a look before anyone builds it.", + }) +} + +fn suggest(mcp: &Mcp, arguments: Value) -> JoinHandle<Result<Value, String>> { + let mut mcp = Mcp::new(mcp.addr, mcp.token.clone()); + tokio::spawn(async move { mcp.tool("suggest_bot", arguments).await }) +} + +/// Waits for the suggestion to show up in the chief's chat. +async fn pending_suggestion(app: &mut Client) -> Value { + loop { + let changed = app.notification("chat.item").await; + let body = &changed["item"]["body"]; + if body["kind"] == "approval" && body["status"] == "pending" { + assert_eq!(body["toolName"], "mcp__botloft__suggest_bot"); + return body.clone(); + } + } +} + +async fn crew_bots(c: &mut Chief) -> Vec<Value> { + c.app + .call("bots.list", json!({ "crewId": c.crew["id"] })) + .await + .expect("bots") + .as_array() + .expect("list") + .clone() +} + +fn rules(bot: &Value) -> String { + let workspace = bot["workspace"].as_str().expect("workspace"); + std::fs::read_to_string(Path::new(workspace).join(".claude/rules/botloft.md")).expect("rules") +} + +#[tokio::test] +async fn a_new_crew_comes_with_its_chief() { + let mut c = crew_with_chief().await; + assert_eq!(c.chief["name"], "Chefe"); + assert!(rules(&c.chief).contains("## You lead this crew")); + assert!(rules(&c.chief).contains("Build the bakery's site")); + + let roster = c.mcp.tool("crew_roster", json!({})).await.expect("roster"); + assert_eq!(roster["you_lead"], true); + let (_, _, mut writer) = ready_bot(&c.t, &mut c.app, &c.crew, "Writer").await; + let seen = writer.tool("crew_roster", json!({})).await.expect("roster"); + assert_eq!(seen["you_lead"], false); + assert_eq!(seen["bots"][0]["chief"], true); +} + +#[tokio::test] +async fn the_owner_approves_a_suggested_bot() { + let mut c = crew_with_chief().await; + let call = suggest(&c.mcp, designer()); + let asked = pending_suggestion(&mut c.app).await; + assert_eq!(asked["summary"], "Designer"); + c.t.until_state(&c.chief, BotState::NeedsApproval).await; + + c.app + .call( + "approvals.answer", + json!({ "approvalId": asked["approvalId"], "allow": true }), + ) + .await + .expect("answer"); + let created = call.await.expect("task").expect("created"); + assert_eq!(created["created"], true); + assert_eq!(created["handle"], "designer"); + assert!( + created["note"] + .as_str() + .expect("note") + .contains("send_message") + ); + + let bots = crew_bots(&mut c).await; + let new = bots + .iter() + .find(|bot| bot["handle"] == "designer") + .expect("designer"); + assert_eq!(new["model"], "sonnet"); + assert!(!rules(new).contains("You lead this crew")); + c.t.process_of(new).await; +} + +#[tokio::test] +async fn the_owner_can_change_a_suggestion_before_approving_it() { + let mut c = crew_with_chief().await; + let call = suggest(&c.mcp, designer()); + let asked = pending_suggestion(&mut c.app).await; + + let mut changed = designer(); + changed["name"] = json!("Illustrator"); + changed["model"] = json!("haiku"); + c.app + .call( + "approvals.answer", + json!({ "approvalId": asked["approvalId"], "allow": true, "input": changed.to_string() }), + ) + .await + .expect("answer"); + let created = call.await.expect("task").expect("created"); + assert_eq!(created["handle"], "illustrator"); + assert_eq!(created["model"], "haiku"); + assert!(created["note"].as_str().expect("note").contains("changed")); + // The card shows what was created. + let item = loop { + let changed = c.app.notification("chat.item").await; + if changed["item"]["body"]["status"] == "allowed" { + break changed["item"]["body"].clone(); + } + }; + assert!( + item["input"] + .as_str() + .expect("input") + .contains("Illustrator") + ); +} + +#[tokio::test] +async fn a_declined_suggestion_creates_nothing() { + let mut c = crew_with_chief().await; + let call = suggest(&c.mcp, designer()); + let asked = pending_suggestion(&mut c.app).await; + c.app + .call( + "approvals.answer", + json!({ "approvalId": asked["approvalId"], "allow": false, "note": "Use the writer" }), + ) + .await + .expect("answer"); + let declined = call.await.expect("task").expect("answered"); + assert_eq!(declined["created"], false); + assert!( + declined["note"] + .as_str() + .expect("note") + .contains("Use the writer") + ); + assert_eq!(crew_bots(&mut c).await.len(), 1); +} + +#[tokio::test] +async fn a_chief_that_bypasses_permissions_creates_at_once() { + let mut c = crew_with_chief().await; + c.app + .call( + "bots.setPermissionMode", + json!({ "botId": c.chief["id"], "mode": "bypass_permissions" }), + ) + .await + .expect("mode"); + // The chief restarts into the new mode, with a new token. + let old = c.mcp.token.clone(); + let mcp = loop { + let (_, mcp) = ready(&c.t, &c.chief).await; + if mcp.token != old { + break mcp; + } + tokio::time::sleep(std::time::Duration::from_millis(20)).await; + }; + let created = suggest(&mcp, designer()) + .await + .expect("task") + .expect("created"); + assert_eq!(created["created"], true); + assert!( + created["note"] + .as_str() + .expect("note") + .contains("without asking") + ); + assert_eq!(crew_bots(&mut c).await.len(), 2); +} + +#[tokio::test] +async fn only_the_chief_suggests_and_only_while_the_crew_has_room() { + let mut c = crew_with_chief().await; + let (_, _, writer) = ready_bot(&c.t, &mut c.app, &c.crew, "Writer").await; + let refused = suggest(&writer, designer()).await.expect("task"); + assert!( + refused + .expect_err("refused") + .contains("only the crew's chief") + ); + + // The tests allow three bots per crew. + ready_bot(&c.t, &mut c.app, &c.crew, "Reviewer").await; + let full = suggest(&c.mcp, designer()).await.expect("task"); + assert!(full.expect_err("full").contains("already has 3 bots")); + + let mut nameless = designer(); + nameless["reason"] = json!(" "); + let refused = suggest(&c.mcp, nameless).await.expect("task"); + assert!(refused.expect_err("no reason").contains("reason")); +} + +#[tokio::test] +async fn the_owner_moves_the_chief_and_an_archived_chief_leaves_none() { + let mut c = crew_with_chief().await; + let (writer, _, _) = ready_bot(&c.t, &mut c.app, &c.crew, "Writer").await; + let crew = c + .app + .call( + "crews.setLead", + json!({ "crewId": c.crew["id"], "botId": writer["id"] }), + ) + .await + .expect("move"); + assert_eq!(crew["leadBotId"], writer["id"]); + assert!(rules(&writer).contains("## You lead this crew")); + assert!(!rules(&c.chief).contains("## You lead this crew")); + + c.app + .call("bots.archive", json!({ "botId": writer["id"] })) + .await + .expect("archive"); + let crews = c.app.call("crews.list", json!({})).await.expect("crews"); + assert_eq!(crews[0]["leadBotId"], Value::Null); +} diff --git a/crates/botloftd/tests/crew_folders.rs b/crates/botloftd/tests/crew_folders.rs new file mode 100644 index 00000000..61c25e81 --- /dev/null +++ b/crates/botloftd/tests/crew_folders.rs @@ -0,0 +1,157 @@ +//! The folder a crew works in (spec 5): the `shared` folder by default, or +//! one the owner chose, handed to every bot with `--add-dir`. + +mod common; + +use std::path::Path; +use std::sync::Arc; + +use botloft_core::protocol::{ + BotState, BotsCreateParams, Crew, CrewsCreateParams, CrewsSetWorkFolderParams, +}; +use botloftd::service::{ApiError, bots, crews}; +use botloftd::supervisor; +use common::supervised::arg_after; +use common::{Parts, new_daemon, test_settings}; + +fn crew(parts: &Parts, work_folder: Option<&Path>) -> Result<Crew, ApiError> { + crews::create( + &parts.daemon, + CrewsCreateParams { + name: "Site".into(), + work_folder: work_folder.map(|path| path.display().to_string()), + lead: None, + }, + ) +} + +fn bot(parts: &Parts, crew: &Crew) -> botloft_core::protocol::Bot { + bots::create( + &parts.daemon, + BotsCreateParams { + crew_id: crew.id.clone(), + name: "Writer".into(), + role: String::new(), + instructions: String::new(), + color: None, + model: None, + }, + ) + .expect("bot") +} + +fn rules(bot: &botloft_core::protocol::Bot) -> String { + std::fs::read_to_string(Path::new(&bot.workspace).join(".claude/rules/botloft.md")) + .expect("rules") +} + +#[tokio::test(start_paused = true)] +async fn a_crew_works_in_its_shared_folder_by_default() { + let parts = new_daemon(test_settings()); + let crew = crew(&parts, None).expect("crew"); + let shared = parts.paths.shared_dir("site"); + assert!(!crew.work_folder_chosen); + assert_eq!(Path::new(&crew.work_folder), shared); + assert!(shared.is_dir()); + + let writer = bot(&parts, &crew); + tokio::spawn(supervisor::run(Arc::clone(&parts.daemon))); + let process = parts.runtime.process(1).await; + assert_eq!( + arg_after(&process, "--add-dir").map(std::path::PathBuf::from), + Some(shared.clone()) + ); + assert_eq!( + process + .env("CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD") + .as_deref(), + Some("1") + ); + assert!(rules(&writer).contains(&shared.display().to_string())); +} + +#[tokio::test(start_paused = true)] +async fn the_owner_can_choose_where_the_crew_works() { + let parts = new_daemon(test_settings()); + let chosen = parts.dir.path().join("Projects").join("Site"); + let crew = crew(&parts, Some(&chosen)).expect("crew"); + assert!(crew.work_folder_chosen); + assert_eq!(Path::new(&crew.work_folder), chosen); + assert!(chosen.is_dir(), "a missing folder is created"); + + let writer = bot(&parts, &crew); + tokio::spawn(supervisor::run(Arc::clone(&parts.daemon))); + let process = parts.runtime.process(1).await; + assert_eq!( + arg_after(&process, "--add-dir").map(std::path::PathBuf::from), + Some(chosen.clone()) + ); + assert!(rules(&writer).contains(&chosen.display().to_string())); + // The listing keeps the choice. + let listed = crews::list(&parts.daemon).expect("list"); + assert_eq!(listed[0].work_folder, crew.work_folder); +} + +#[tokio::test(start_paused = true)] +async fn moving_the_crew_restarts_its_bots_in_the_new_folder() { + let parts = new_daemon(test_settings()); + let crew = crew(&parts, None).expect("crew"); + let writer = bot(&parts, &crew); + tokio::spawn(supervisor::run(Arc::clone(&parts.daemon))); + let first = parts.runtime.process(1).await; + wait_idle(&parts, &writer.id).await; + + let moved = parts.dir.path().join("Elsewhere"); + let changed = crews::set_work_folder( + &parts.daemon, + CrewsSetWorkFolderParams { + crew_id: crew.id.clone(), + work_folder: Some(moved.display().to_string()), + }, + ) + .expect("move"); + assert_eq!(Path::new(&changed.work_folder), moved); + assert!(rules(&writer).contains(&moved.display().to_string())); + let second = parts.runtime.process(2).await; + assert!(first.killed()); + assert_eq!( + arg_after(&second, "--add-dir").map(std::path::PathBuf::from), + Some(moved) + ); + + wait_idle(&parts, &writer.id).await; + let back = crews::set_work_folder( + &parts.daemon, + CrewsSetWorkFolderParams { + crew_id: crew.id, + work_folder: None, + }, + ) + .expect("back"); + assert!(!back.work_folder_chosen); + assert_eq!(Path::new(&back.work_folder), parts.paths.shared_dir("site")); + parts.runtime.process(3).await; +} + +#[tokio::test(start_paused = true)] +async fn botlofts_own_folders_are_refused() { + let parts = new_daemon(test_settings()); + for folder in [ + parts.paths.home.join("secrets"), + parts.paths.workspaces_root.clone(), + ] { + let refused = crew(&parts, Some(&folder)).expect_err("refused"); + assert!(matches!(refused, ApiError::Validation(_)), "{refused:?}"); + } + assert!(crews::list(&parts.daemon).expect("list").is_empty()); +} + +async fn wait_idle(parts: &Parts, bot: &botloft_core::ids::BotId) { + for _ in 0..600 { + if parts.daemon.supervisor.status(bot).map(|(state, _)| state) == Some(BotState::Idle) { + return; + } + tokio::time::sleep(std::time::Duration::from_millis(10)).await; + } + panic!("the bot never became idle"); +} diff --git a/crates/botloftd/tests/mcp.rs b/crates/botloftd/tests/mcp.rs index f4fa1f9b..79e8327e 100644 --- a/crates/botloftd/tests/mcp.rs +++ b/crates/botloftd/tests/mcp.rs @@ -71,6 +71,7 @@ async fn claude_code_discovers_the_server_and_lists_the_tools() { "send_message", "complete_task", "my_tasks", + "suggest_bot", "permission_prompt" ] ); @@ -115,7 +116,7 @@ async fn earlier_revisions_start_with_initialize() { let listed = mcp::post(t.addr, &legacy, &list).await; assert_eq!( listed.body["result"]["tools"].as_array().map(Vec::len), - Some(5) + Some(6) ); let unknown = json!({ "jsonrpc": "2.0", "id": 2, "method": "prompts/list" }).to_string(); let unknown = mcp::post(t.addr, &legacy, &unknown).await; diff --git a/crates/botloftd/tests/permission_modes.rs b/crates/botloftd/tests/permission_modes.rs new file mode 100644 index 00000000..62b0f52b --- /dev/null +++ b/crates/botloftd/tests/permission_modes.rs @@ -0,0 +1,158 @@ +//! A bot's permission mode (spec 7.4): the flag it starts with, the restart +//! into a new mode once nothing is in progress, and leaving plan mode. + +mod common; + +use std::time::Duration; + +use botloft_core::protocol::{BotState, BotsSetPermissionModeParams, PermissionMode}; +use botloftd::runtime::fake::FakeProcess; +use botloftd::service::modes; +use common::stream; +use common::supervised::{Setup, setup}; +use serde_json::json; + +fn arg_after(process: &FakeProcess, flag: &str) -> Option<String> { + let args = process.args(); + let at = args.iter().position(|arg| arg == flag)?; + args.get(at + 1).cloned() +} + +fn set_mode(s: &Setup, mode: PermissionMode) { + modes::set_permission_mode( + &s.daemon, + BotsSetPermissionModeParams { + bot_id: s.bot.clone(), + mode, + }, + ) + .expect("set mode"); +} + +fn stored_mode(s: &Setup) -> PermissionMode { + s.daemon + .store() + .bot(&s.bot) + .expect("read") + .expect("bot") + .permission_mode +} + +fn init_with_mode(session: &str, mode: &str) -> serde_json::Value { + json!({ "type": "system", "subtype": "init", "session_id": session, "permissionMode": mode }) +} + +#[tokio::test(start_paused = true)] +async fn a_new_bot_asks_before_everything() { + let s = setup().await; + let process = s.runtime.process(1).await; + assert_eq!( + arg_after(&process, "--permission-mode").as_deref(), + Some("default") + ); + assert_eq!(stored_mode(&s), PermissionMode::Default); +} + +#[tokio::test(start_paused = true)] +async fn an_idle_bot_restarts_into_its_new_mode_in_the_same_conversation() { + let s = setup().await; + let first = s.runtime.process(1).await; + s.until(BotState::Idle).await; + let session = arg_after(&first, "--session-id").expect("session"); + + set_mode(&s, PermissionMode::AcceptEdits); + let second = s.runtime.process(2).await; + assert!(first.killed()); + assert_eq!( + arg_after(&second, "--permission-mode").as_deref(), + Some("acceptEdits") + ); + assert_eq!(arg_after(&second, "--resume"), Some(session)); +} + +#[tokio::test(start_paused = true)] +async fn a_busy_bot_finishes_its_turn_before_changing_mode() { + let s = setup().await; + let first = s.runtime.process(1).await; + s.until(BotState::Idle).await; + s.message("work"); + set_mode(&s, PermissionMode::Auto); + tokio::time::sleep(Duration::from_secs(30)).await; + assert_eq!(s.runtime.processes().len(), 1, "the turn is not cut short"); + assert!(s.daemon.supervisor.relaunch_pending(&s.bot)); + + first.emit(stream::result(false)).await; + let second = s.runtime.process(2).await; + assert_eq!( + arg_after(&second, "--permission-mode").as_deref(), + Some("auto") + ); + assert!(!s.daemon.supervisor.relaunch_pending(&s.bot)); +} + +#[tokio::test(start_paused = true)] +async fn approving_a_plan_moves_the_bot_out_of_plan_mode() { + let s = setup().await; + s.runtime.process(1).await; + s.until(BotState::Idle).await; + set_mode(&s, PermissionMode::Plan); + let planning = s.runtime.process(2).await; + s.until(BotState::Idle).await; + let session = arg_after(&planning, "--resume").expect("session"); + + // Claude Code left plan mode when the plan was approved. + planning.emit(init_with_mode(&session, "default")).await; + tokio::time::sleep(Duration::from_millis(50)).await; + assert_eq!(stored_mode(&s), PermissionMode::Default); + assert_eq!( + s.runtime.processes().len(), + 2, + "no restart: it already changed" + ); +} + +#[tokio::test(start_paused = true)] +async fn a_turn_of_the_old_process_does_not_undo_the_owners_choice() { + let s = setup().await; + let first = s.runtime.process(1).await; + s.until(BotState::Idle).await; + let session = arg_after(&first, "--session-id").expect("session"); + s.message("queued"); + set_mode(&s, PermissionMode::AcceptEdits); + + first.emit(init_with_mode(&session, "default")).await; + tokio::time::sleep(Duration::from_millis(50)).await; + assert_eq!(stored_mode(&s), PermissionMode::AcceptEdits); + first.emit(stream::init(&session)).await; + assert_eq!(stored_mode(&s), PermissionMode::AcceptEdits); +} + +#[tokio::test(start_paused = true)] +async fn a_plan_approved_while_a_new_model_waits_still_leaves_plan_mode() { + let s = setup().await; + s.runtime.process(1).await; + s.until(BotState::Idle).await; + set_mode(&s, PermissionMode::Plan); + let planning = s.runtime.process(2).await; + s.until(BotState::Idle).await; + let session = arg_after(&planning, "--resume").expect("session"); + s.message("plan it"); + botloftd::service::models::set_model( + &s.daemon, + botloft_core::protocol::BotsSetModelParams { + bot_id: s.bot.clone(), + model: botloft_core::protocol::BotModel::Sonnet, + }, + ) + .expect("set model"); + + planning.emit(init_with_mode(&session, "default")).await; + tokio::time::sleep(Duration::from_millis(50)).await; + assert_eq!(stored_mode(&s), PermissionMode::Default); + planning.emit(stream::result(false)).await; + let next = s.runtime.process(3).await; + assert_eq!( + arg_after(&next, "--permission-mode").as_deref(), + Some("default") + ); +} diff --git a/crates/botloftd/tests/sign_in.rs b/crates/botloftd/tests/sign_in.rs index 9a74f665..78ecfd7d 100644 --- a/crates/botloftd/tests/sign_in.rs +++ b/crates/botloftd/tests/sign_in.rs @@ -30,6 +30,13 @@ async fn the_status_says_whether_claude_code_is_signed_in() { let status = service::status(&s.daemon).expect("status"); assert_eq!(status.claude_signed_in, Some(true)); assert!(status.claude_path.is_some()); + assert!( + !status.account.name.is_empty(), + "the Windows account's name" + ); + let claude = status.account.claude.expect("the signed-in Claude account"); + assert_eq!(claude.email.as_deref(), Some("owner@example.com")); + assert_eq!(claude.plan.as_deref(), Some("max")); assert_eq!(s.runtime.sign_in_checks(), 1, "checked once, then trusted"); tokio::time::sleep(Duration::from_secs(300)).await; assert_eq!(s.runtime.sign_in_checks(), 1); @@ -43,6 +50,11 @@ async fn signing_in_again_brings_the_stopped_bots_back() { sign_in_error(&s).await; tokio::time::sleep(Duration::from_millis(50)).await; assert_eq!(s.daemon.supervisor.claude_signed_in(), Some(false)); + assert_eq!( + s.daemon.supervisor.claude_account(), + None, + "no account while signed out" + ); // Still signed out: checked every 30 s, the bot stays stopped. tokio::time::sleep(Duration::from_secs(40)).await; diff --git a/crates/botloftd/tests/supervisor.rs b/crates/botloftd/tests/supervisor.rs index 17a1322a..413d75d7 100644 --- a/crates/botloftd/tests/supervisor.rs +++ b/crates/botloftd/tests/supervisor.rs @@ -190,13 +190,22 @@ async fn a_failed_spawn_backs_off_and_retries() { let parts = new_daemon(test_settings()); let (daemon, runtime) = (parts.daemon, parts.runtime); runtime.fail_next_spawn(); - let crew = crews::create(&daemon, CrewsCreateParams { name: "Ops".into() }).expect("crew"); + let crew = crews::create( + &daemon, + CrewsCreateParams { + name: "Ops".into(), + work_folder: None, + lead: None, + }, + ) + .expect("crew"); let params = BotsCreateParams { crew_id: crew.id, name: "Scout".into(), role: String::new(), instructions: String::new(), color: None, + model: None, }; let bot = bots::create(&daemon, params).expect("bot"); tokio::spawn(supervisor::run(Arc::clone(&daemon))); diff --git a/crates/botloftd/tests/tasks.rs b/crates/botloftd/tests/tasks.rs index f2ef2a8e..56dca545 100644 --- a/crates/botloftd/tests/tasks.rs +++ b/crates/botloftd/tests/tasks.rs @@ -185,7 +185,7 @@ async fn mistakes_come_back_as_tool_errors() { assert_eq!(roster["you"], "lead"); assert_eq!( roster["bots"], - json!([{ "handle": "writer", "name": "Writer", "role": "Writer role", "state": "idle" }]) + json!([{ "handle": "writer", "name": "Writer", "role": "Writer role", "state": "idle", "chief": false }]) ); let err = |out: Result<Value, String>| out.expect_err("refused"); diff --git a/docs/spec.md b/docs/spec.md index 7150cf35..2847ac4d 100644 --- a/docs/spec.md +++ b/docs/spec.md @@ -24,8 +24,9 @@ Princípios: | Termo | Significado | |---|---| -| **Crew** | Grupo de bots que podem conversar entre si. Tem pasta compartilhada `shared/`. | +| **Crew** | Grupo de bots que podem conversar entre si. Trabalha numa pasta: a `shared/` dela ou uma que o dono escolhe. | | **Bot** | Uma sessão Claude Code persistente com nome, papel e instruções. | +| **Chefe** | O bot que lidera a crew (`Crew.leadBotId`): nasce com ela, planeja o trabalho, distribui tarefas e é o único que sugere bots novos (10.2). | | **Workspace** | Pasta de trabalho do bot, onde o Claude Code roda. | | **Message** | Texto enviado a um bot, pelo dono, por outro bot ou pelo daemon. Pode trazer anexos (só do dono). | | **Delivery** | Entrega de uma message ao processo do bot. Tem estado, tentativas e prazo. | @@ -101,7 +102,7 @@ Tipos do protocolo ficam em `botloft-core` e são exportados para TypeScript com | Logs | `%LOCALAPPDATA%\Botloft\logs\` (rotação diária, 14 dias) | | | Config | `%LOCALAPPDATA%\Botloft\config.toml` | `--config` | | Workspaces | `%USERPROFILE%\Botloft\<crew>\<bot>\` | `workspaces_root` na config | -| Pasta compartilhada da crew | `%USERPROFILE%\Botloft\<crew>\shared\` | | +| Pasta de trabalho da crew | `%USERPROFILE%\Botloft\<crew>\shared\` | uma pasta que o dono escolhe (`Crew.workFolder`) | | Binário do daemon | `%LOCALAPPDATA%\Botloft\bin\botloftd.exe` (seção 14) | `--home` | | App instalado | `%LOCALAPPDATA%\Botloft\` (`Botloft.exe`, o sidecar `botloftd.exe`, `uninstall.exe`; seção 15.4) | | @@ -111,6 +112,8 @@ O instalador por usuário do Tauri põe o app em `%LOCALAPPDATA%\<produto>`, a m Workspaces ficam num caminho curto e visível para o usuário abrir no Explorer e para reduzir estouro do limite de 260 caracteres (bots rodam `npm install`). +**Pasta de trabalho da crew.** É onde os bots põem o que fazem para o dono e para os outros bots. Por padrão é a `shared\` da crew; o dono pode escolher outra ao criar a crew ou depois (`crews.setWorkFolder`), como uma pasta de projeto que ele já usa. O workspace de cada bot continua onde está, com a memória, as regras e os anexos dele: o daemon nunca grava nada na pasta escolhida. Cada bot recebe a pasta com `--add-dir` (7.4), e o Claude Code a trata como a pasta do bot: lê e, em "Aceitar edições", edita sem perguntar, e carrega o `CLAUDE.md` dela junto com a memória do bot. A pasta escolhida precisa ser um caminho completo e não pode ser um disco inteiro, ficar dentro da pasta de dados do Botloft ou contê-la, nem conter `workspaces_root` (com os workspaces de todos os bots). Se não existe, é criada. Trocar a pasta regrava as regras e reinicia cada bot da crew quando nada estiver em andamento, como a troca de modo (7.4). Arquivar a crew não apaga pasta nenhuma. + Nomes de pasta de crew e bot são slugs gerados na criação e **não mudam** quando o nome de exibição muda. Slug: ASCII minúsculo com hífens, acentos transliterados (`Revisão` -> `revisao`), no máximo 32 caracteres, nunca um nome de dispositivo do Windows (`con`, `lpt1`...) e nunca `shared` para bot. Colisão ganha sufixo (`docs-2`), inclusive com slug de item arquivado ou pasta que já exista no disco. O **handle** do bot (`@revisao`) é derivado do nome pela mesma regra, acompanha renomeações e é único entre os bots ativos da crew; um nome que gere handle já usado é recusado com erro de validação. @@ -123,7 +126,7 @@ O **handle** do bot (`@revisao`) é derivado do nome pela mesma regra, acompanha attachments\<aaaa-mm-dd>\ arquivos que o dono mandou no chat (9.5) .claude\ settings.json regra de negação para os segredos (gerado pelo daemon, sobrescrito a cada start) - rules\botloft.md identidade, papel, crew e guia de uso das tools (gerado pelo daemon) + rules\botloft.md identidade, papel, crew, pasta de trabalho, guia de uso das tools e, no chefe, como liderar (gerado pelo daemon) .botloft\ mcp.json config MCP do bot (gerado pelo daemon) ``` @@ -154,6 +157,7 @@ retry_backoff_max_ms = 120000 [bots] approval_timeout_minutes = 60 # sem resposta do dono, a ferramenta é negada attachment_max_mb = 20 # por arquivo; no máximo 10 arquivos por message +max_per_crew = 12 # até onde as sugestões do chefe levam uma crew (10.2) [tasks] max_hops = 4 @@ -202,7 +206,7 @@ Eventos de uma generation antiga são ignorados. Todo processo novo emite `bot.s - **Sessão:** o daemon guarda em `bots.session_id` o id da conversa. O primeiro start usa `--session-id <uuid novo>`; os seguintes, `--resume <session_id>`. Se a sessão retomada morrer em menos de `fresh_start_if_dies_within_s`, o próximo start vem com um id novo. `bots.restart {fresh: true}` também começa conversa nova. O histórico do chat fica no banco do daemon (seção 8) e não depende do transcript do Claude Code. - Mudanças em nome, papel ou instruções regravam as regras na hora, mas o bot só as lê no próximo start; o daemon não reinicia o bot sozinho. - `auth_error` não entra em loop de restart: fica parado até o owner pedir `bots.restart` ou até o daemon ver o Claude Code conectado de novo. -- **Login do Claude Code:** o daemon roda `claude auth status` (JSON com `loggedIn`; sai com 0 conectado e 1 desconectado, seção 19) no ambiente do usuário, sem janela: quando acha o Claude Code, a cada 30 s enquanto desconectado ou desconhecido, na hora quando um bot cai em `auth_error` e quando o app pede (`system.refresh`). Conectado, não confere de novo sozinho. Quando o resultado passa de desconectado para conectado, os bots em `auth_error` sobem de novo sem o dono pedir. Um erro de conta com o login válido (`billing_error`, `account_on_hold`, organização bloqueada) não muda o resultado e por isso não vira loop. O resultado sai em `system.status.claudeSignedIn`. O login em si é feito pelo app (15.2). +- **Login do Claude Code:** o daemon roda `claude auth status` (JSON com `loggedIn` e, conectado, `email`, `subscriptionType` e `orgName`; sai com 0 conectado e 1 desconectado, seção 19) no ambiente do usuário, sem janela: quando acha o Claude Code, a cada 30 s enquanto desconectado ou desconhecido, na hora quando um bot cai em `auth_error` e quando o app pede (`system.refresh`). Conectado, não confere de novo sozinho. Quando o resultado passa de desconectado para conectado, os bots em `auth_error` sobem de novo sem o dono pedir. Um erro de conta com o login válido (`billing_error`, `account_on_hold`, organização bloqueada) não muda o resultado e por isso não vira loop. O resultado sai em `system.status.claudeSignedIn`, e a conta (e-mail, plano, organização) em `system.status.account.claude`. O login em si é feito pelo app (15.2). - Cada processo de bot entra num **Job Object** com `KILL_ON_JOB_CLOSE`. Se o daemon morrer, a árvore de processos dos bots morre junto e não sobra `claude.exe` órfão. ### 7.4 Spawn @@ -218,7 +222,9 @@ Eventos de uma generation antiga são ignorados. Todo processo novo emite `bot.s (--session-id <uuid> | --resume <session_id>) --setting-sources project,local --mcp-config <workspace>\.botloft\mcp.json --strict-mcp-config - --permission-mode default + --add-dir <pasta de trabalho da crew> + --permission-mode <modo do bot> + [--model <modelo do bot>] --permission-prompt-tool mcp__botloft__permission_prompt --allowedTools mcp__botloft ``` @@ -226,7 +232,12 @@ Eventos de uma generation antiga são ignorados. Todo processo novo emite `bot.s - `--setting-sources project,local` e `--strict-mcp-config` deixam de fora hooks, skills, agents, modo de permissão e servidores MCP pessoais do dono: o bot vê o que o Botloft gera. O login da conta não é uma fonte de settings e continua valendo. - `--allowedTools mcp__botloft` libera as tools da crew sem aprovação. Uma regra `allow` no `settings.json` do projeto não bastaria: em `-p`, numa pasta que nunca passou pelo diálogo de confiança, o Claude Code não aplica as regras `allow` do projeto (documentado em `permissions`). - Qualquer outra ferramenta que peça permissão passa pela tool de aprovação (10.1) e vira um pedido no chat. -5. Ambiente: o bloco padrão do usuário (`CreateEnvironmentBlock`, o mesmo de um logon novo), **não** o ambiente do daemon. Um daemon iniciado de dentro de uma sessão do Claude Code herda `CLAUDECODE`, `CLAUDE_CODE_MESSAGING_SOCKET`, `ANTHROPIC_BASE_URL` e outras variáveis da sessão, que fariam o bot se achar filho dela. Por cima vão `BOTLOFT_BOT_ID`, `BOTLOFT_BOT_TOKEN` e `BOTLOFT_PORT`. + - `--add-dir` põe a pasta de trabalho da crew (5) entre as pastas do bot. Sem ela, gravar na `shared\`, que fica fora do workspace, pedia aprovação até em "Aceitar edições" (19). + - `--permission-mode` vem do modo do bot (`Bot.permissionMode`), que o dono escolhe no chat (15.1): `default` (Manual: pergunta antes de editar, rodar comandos e usar a rede), `accept_edits` (`acceptEdits`: edita arquivos sem perguntar), `plan` (planeja e pede para seguir, 10.1), `auto` (um classificador libera o que é seguro e o resto vira pedido) e `bypass_permissions` (`bypassPermissions`: faz tudo sem perguntar, ver 13). Bot novo começa em `default`. `dontAsk` não é oferecido: nega o que não estiver liberado, e o bot não teria como pedir. Regras `deny` valem em todos os modos. + - O Claude Code só lê a flag ao iniciar e não entra em `bypassPermissions` no meio da sessão. Por isso mudar o modo reinicia o processo com `--resume`, e a conversa continua: na hora se o bot está parado, ou quando o turno em andamento e as aprovações dele terminam, sem cortar o trabalho. + - `--model` vem do modelo do bot (`Bot.model`), que o dono escolhe no chat ou ao criar o bot (15.1): `fable`, `opus`, `sonnet` ou `haiku`, os apelidos do Claude Code, que apontam sempre para a versão mais nova de cada família. `default` deixa a flag de fora, e o Claude Code usa o padrão da conta, que depende do plano (19). Bot novo começa em `default`. O Claude Code não troca de modelo sozinho conforme a tarefa. Mudar o modelo reinicia o processo como a troca de modo, e `--resume` com `--model` passa a usar o modelo novo. O `system/init` de cada turno traz o modelo em uso (`claude-opus-5-5`); o daemon o guarda em `Bot.modelInUse` para o app dizer qual é o padrão do plano. Um modelo que a conta não pode usar falha o turno com o erro `model_not_found` (8.1), e o processo continua vivo. + - O Claude Code sai do modo `plan` sozinho quando o dono aprova o plano. Cada turno começa com um `system/init` que traz `permissionMode` (19); se o processo começou em `plan`, o modo gravado ainda é `plan` e o init diz outro, o daemon grava o novo, sem reiniciar, para o app mostrar o que o bot faz e um reinício manter. Qualquer outra diferença vem de um processo que está para reiniciar no modo que o dono acabou de escolher, e é ignorada. +5. Ambiente: o bloco padrão do usuário (`CreateEnvironmentBlock`, o mesmo de um logon novo), **não** o ambiente do daemon. Um daemon iniciado de dentro de uma sessão do Claude Code herda `CLAUDECODE`, `CLAUDE_CODE_MESSAGING_SOCKET`, `ANTHROPIC_BASE_URL` e outras variáveis da sessão, que fariam o bot se achar filho dela. Por cima vão `BOTLOFT_BOT_ID`, `BOTLOFT_BOT_TOKEN`, `BOTLOFT_PORT` e `CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD=1`, que faz o Claude Code carregar o `CLAUDE.md` da pasta de trabalho (5). 6. stdin, stdout e stderr em pipes, sem console (`CREATE_NO_WINDOW`). O stdin fica aberto enquanto o processo vive; fechá-lo encerra o Claude Code com código 0. O stderr vai para o log em nível `debug`, sem conteúdo de mensagem. ### 7.5 `settings.json` gerado @@ -253,13 +264,13 @@ Uma linha JSON por evento, em UTF-8. Linha que não é JSON, ou maior que 8 MiB, | Evento | O que vira | |---|---| -| `system/init` | guarda `session_id` em `bots.session_id` (vem no começo de cada turno) | +| `system/init` | guarda `session_id` em `bots.session_id` (vem no começo de cada turno); segue `permissionMode` e guarda `model` (7.4) | | `user` com `isReplay: true` | a message com aquele `uuid` começou a ser processada: a delivery ganha `read_at` (9.1) | | `stream_event` com `text_delta` | texto ao vivo da resposta (`chat.delta`, 8.3); não é gravado | | `assistant`, bloco `text` | item `reply` com o texto (markdown) | | `assistant`, bloco `tool_use` | item `tool` em `running`, com resumo da entrada | | `user`, bloco `tool_result` | atualiza o item `tool` do mesmo `tool_use_id`: `done` ou `failed` e um trecho da saída | -| `assistant` com `error` | item `notice` e, conforme o erro, estado `rate_limited` ou `auth_error` (7.2) | +| `assistant` com `error` | item `notice` e, conforme o erro, estado `rate_limited` ou `auth_error` (7.2); `model_not_found` vira o aviso `model_unavailable` | | `rate_limit_event` | uso da conta (janelas de 5 h e 7 dias) em `system.status.usage`; status diferente de `allowed` leva a `rate_limited` | | `result` | item `turn` com duração, custo e erro (se houve); fecha um turno pendente | @@ -276,7 +287,7 @@ Todo item tem `id` (`cht_`), `botId`, `kind`, `createdAt` e `updatedAt`. | `tool` | `toolUseId`, `name`, `summary`, `input`, `status` (`running`, `done`, `failed`), `output` | ferramenta usada pelo bot | | `approval` | `approvalId`, `toolName`, `summary`, `input`, `status` (`pending`, `allowed`, `denied`, `expired`), `note` | pedido de permissão (10.1) | | `turn` | `durationMs`, `costUsd`, `error` | fim de um turno | -| `notice` | `level` (`info`, `warning`, `error`), `code` (`signed_out`, `usage_limit`, `turn_failed`; ausente em avisos antigos), `text` | avisos do daemon: limite de uso, login, turno com erro. O app escreve os avisos com `code` no idioma do dono; `text` fica em inglês para quem não conhece o código e, em `turn_failed`, traz o detalhe do erro | +| `notice` | `level` (`info`, `warning`, `error`), `code` (`signed_out`, `usage_limit`, `turn_failed`, `model_unavailable`; ausente em avisos antigos), `text` | avisos do daemon: limite de uso, login, turno com erro. O app escreve os avisos com `code` no idioma do dono; `text` fica em inglês para quem não conhece o código e, em `turn_failed`, traz o detalhe do erro | - `summary` é uma frase curta feita pelo daemon a partir da entrada: o comando do `Bash`, o arquivo do `Read`/`Edit`/`Write`, o padrão do `Grep`/`Glob`, a URL do `WebFetch`, a busca do `WebSearch`, o destinatário do `send_message`. Ferramenta desconhecida mostra só o nome. - `input` guarda o JSON da entrada até 4 KB; `output`, até 8 KB de texto. O resto fica só no transcript do próprio Claude Code. @@ -382,10 +393,11 @@ Transporte: Streamable HTTP, só POST e resposta `application/json`, sem sessão | Tool | Entrada | Saída (JSON em texto) | |---|---|---| -| `crew_roster` | nenhuma | `crew`, `you` e os outros bots da crew: handle, nome, papel, estado | +| `crew_roster` | nenhuma | `crew`, `you`, `you_lead` e os outros bots da crew: handle, nome, papel, estado e `chief` | | `send_message` | `to` (handle, com ou sem `@`), `body`, `kind?` (`note` padrão, `task`), `deadline_minutes?` (só task) | `message_id`, `task_id` e `due` (task), e um lembrete de que a resposta chega depois | | `complete_task` | `task_id`, `result`, `status?` (`done` padrão, `failed`) | `task_id`, `status` e quem recebe o resultado | | `my_tasks` | `role?` (`assigned`, `requested`) | tasks `open` e `expired`: id, de, para, status, prazo relativo, hops e o pedido original | +| `suggest_bot` | `name`, `role`, `instructions` (até 8 000 caracteres), `model?`, `reason` (até 1 000) | `created` e, criado, `handle`, `name`, `role`, `model` e um lembrete para mandar a primeira task; recusado ou sem resposta, o porquê (10.2). Só o chefe | | `permission_prompt` | `tool_name`, `input`, `tool_use_id` | decisão do dono (10.1). Chamada pelo Claude Code, não pelo modelo | - Erro que o modelo pode corrigir (handle desconhecido, argumento inválido, limite de hops, task de outro bot) volta como resultado com `isError: true` e uma frase explicando. Só tool desconhecida ou chamada malformada vira erro JSON-RPC (`-32602`). @@ -408,8 +420,21 @@ Com `--permission-prompt-tool mcp__botloft__permission_prompt`, toda ferramenta "Permitir sempre" (gravar uma regra para o bot) fica para depois do MVP. +**Plano.** No modo `plan`, o bot pede para seguir com a ferramenta `ExitPlanMode`, cuja entrada traz o plano em markdown (`{plan}`). O pedido passa pela mesma tool e vira no chat um cartão com o plano inteiro: a entrada dessa ferramenta é guardada até 32 KB (as outras, até 4 KB) e o resumo é a primeira linha do plano. "Aprovar plano" permite; "Pedir mudanças" nega com a nota do dono, e o bot continua planejando. Depois de aprovado, o Claude Code troca de modo sozinho (7.4). Que o pedido passa pela tool em `-p` e para qual modo o bot vai ainda precisam de teste real (19). + A aprovação só abre se `tool_use_id` for de uma ferramenta em `running` no chat daquele bot. O daemon espera até 2 s pelo evento, que às vezes chega depois da chamada. Senão nega na hora, sem incomodar o dono. Assim um bot que chame `permission_prompt` por conta própria não consegue pôr um pedido inventado na frente do dono. A descrição da tool também diz para não chamá-la. +### 10.2 Chefe e sugestões de bots + +Toda crew nova nasce com um **chefe**: `crews.create` com `lead` cria a crew e esse bot juntos, e `Crew.leadBotId` aponta para ele. O app escreve nome e papel no idioma do dono ("Chefe", "Lidera a equipe: planeja o trabalho, sugere bots novos e distribui as tarefas"); as instruções são o objetivo que o dono escreveu para a crew. O chefe é gravado antes de o supervisor poder subi-lo, então o primeiro start já lê que lidera. O dono troca o chefe (`crews.setLead`) ou deixa a crew sem nenhum; o chefe antigo e o novo têm as regras regravadas e reiniciam quando nada estiver em andamento (7.4). Arquivar o chefe deixa a crew sem chefe. Crews de antes não têm chefe até o dono escolher um. + +- **Regras do chefe:** além das de todo bot, uma seção "You lead this crew": planejar, dividir o trabalho em partes que rodam em paralelo e distribuí-las com `send_message` (`kind: "task"`); conferir os resultados antes de responder ao dono; quando faltar um especialista, sugerir um bot com `suggest_bot`; escolher o modelo pelo trabalho (`haiku` para o simples e repetitivo, `sonnet` para quase tudo, `opus` ou `fable` só para o raciocínio mais difícil, lembrando que gastam mais do plano); manter a crew pequena; e contar ao dono o que cada bot faz, para ele acompanhar e falar com cada um no chat dele. Os outros bots leem que, se a crew precisar de outro bot, devem pedir ao chefe, que o `crew_roster` marca com `chief`. +- **`suggest_bot`:** aparece para todos os bots, mas só o chefe pode usar; os outros recebem um erro que manda pedir ao chefe. Antes de incomodar o dono, o daemon confere os campos (os de um bot, mais o limite de instruções e o porquê), que o nome está livre na crew e que a crew tem menos de `max_per_crew` bots ativos. Um pedido impossível volta como erro ao chefe. +- **Aprovação:** a sugestão vira um pedido no chat do chefe, pelo mesmo caminho das aprovações (10.1): `approval` com `toolName: "mcp__botloft__suggest_bot"`, entrada até 64 KB e resumo com o nome sugerido. O chefe fica `needs_approval`, e a chamada MCP espera a resposta até `approval_timeout_minutes`. A tool vem liberada por `--allowedTools mcp__botloft`, então o Claude Code não pede permissão antes: quem decide é o dono, pelo cartão. +- **Resposta:** permitir cria o bot na crew do chefe, com modo Manual e o modelo sugerido. O dono pode mudar nome, papel, modelo e instruções antes: `approvals.answer` leva `input`, o JSON da sugestão como ele deixou, que substitui a entrada gravada (o cartão mostra o que foi criado); `input` só vale para sugestões. Negar volta ao chefe com a nota do dono, e nada é criado. Sem resposta no prazo, o chefe lê que pode sugerir de novo depois. O bot novo sobe na hora e aparece na barra lateral, com o próprio chat; o resultado da tool lembra o chefe de mandar a primeira task. +- **Chefe em `bypass_permissions`:** a sugestão cria o bot na hora, sem cartão, como tudo o que esse modo faz sem perguntar (13). O resultado diz ao chefe que foi criado sem pedir. +- Bots criados assim são bots comuns: o dono conversa, muda, pausa e arquiva cada um como qualquer outro. + ## 11. Protocolo do app (JSON-RPC 2.0 sobre WebSocket) Endpoint: `ws://127.0.0.1:45710/rpc`. Mensagens seguem JSON-RPC 2.0: requests com `id`, respostas com `result` ou `error`, notificações do servidor sem `id`. O maior frame aceito do app é de 32 MiB, por causa dos anexos. @@ -426,21 +451,25 @@ Endpoint: `ws://127.0.0.1:45710/rpc`. Mensagens seguem JSON-RPC 2.0: requests co | Método | Params | Result | |---|---|---| -| `system.status` | | versão, uptime, versão e caminho do claude (`claudeVersion`, `claudePath`), `runtimeError` (por que os bots não sobem), `claudeSignedIn` (7.3; `null` antes de conferir), backlog de entrega, `usage` (uso da conta, 8.1) | +| `system.status` | | versão, uptime, versão e caminho do claude (`claudeVersion`, `claudePath`), `runtimeError` (por que os bots não sobem), `claudeSignedIn` (7.3; `null` antes de conferir), `account` (o dono para a área da conta do app: `name`, o nome de exibição da conta do Windows, `GetUserNameExW(NameDisplay)`, ou o nome de usuário sem ele, lido uma vez; e `claude`, a conta do Claude com `email`, `plan` e `organization`, ou `null` desconectado), backlog de entrega, `usage` (uso da conta, 8.1) | | `system.refresh` | | pede uma nova conferência do Claude Code (login e, se falhou, o executável) e responde na hora com o `system.status` atual; o app relê o status até ver o resultado | | `crews.list` | | `Crew[]` | -| `crews.create` | `name` | `Crew` | +| `crews.create` | `name, workFolder?, lead?` (`{name, role, instructions, model?}`: o chefe, 10.2) | `Crew` | | `crews.rename` | `crewId, name` | `Crew` | | `crews.setPaused` | `crewId, paused` | `Crew` | +| `crews.setLead` | `crewId, botId` (ou `null`, sem chefe) | `Crew`; o chefe antigo e o novo reiniciam quando nada estiver em andamento (10.2) | +| `crews.setWorkFolder` | `crewId, workFolder` (caminho, ou `null` para voltar à `shared\`) | `Crew`; os bots reiniciam na pasta nova quando nada estiver em andamento (5) | | `crews.archive` | `crewId` | `Crew` | | `bots.list` | `crewId?` | `Bot[]` | -| `bots.create` | `crewId, name, role, instructions, color?` | `Bot` | +| `bots.create` | `crewId, name, role, instructions, color?, model?` | `Bot` | | `bots.update` | `botId, name?, role?, instructions?, color?` | `Bot` | | `bots.setPaused` | `botId, paused` | `Bot` | +| `bots.setPermissionMode` | `botId, mode` (`default`, `accept_edits`, `plan`, `auto`, `bypass_permissions`) | `Bot`; o bot reinicia no novo modo quando nada estiver em andamento (7.4) | +| `bots.setModel` | `botId, model` (`default`, `fable`, `opus`, `sonnet`, `haiku`) | `Bot`; o bot reinicia no novo modelo quando nada estiver em andamento (7.4) | | `bots.restart` | `botId, fresh?` | `Bot` | | `bots.archive` | `botId` | `Bot` | | `chat.history` | `botId, before?, limit?` | `ChatItem[]`, mais novo primeiro; `limit` de 1 a 200, 50 se ausente | -| `approvals.answer` | `approvalId, allow, note?` | `Approval` | +| `approvals.answer` | `approvalId, allow, note?, input?` (`input`: a sugestão de bot como o dono a deixou, 10.2) | `Approval` | | `messages.send` | `botId, body, attachments?` (`[{name, mediaType, data}]`, data em base64) | `Message` | | `messages.list` | `crewId?, botId?, before?, limit?` | `Message[]` | | `attachments.read` | `attachmentId` | `{mediaType, data}`, data em base64 (9.5) | @@ -448,7 +477,7 @@ Endpoint: `ws://127.0.0.1:45710/rpc`. Mensagens seguem JSON-RPC 2.0: requests co | `deliveries.retry` | `deliveryId` | `Delivery` | | `tasks.list` | `crewId?, status?` | `Task[]` | -`Bot` traz também `lastActivity`: o último item do chat resumido em uma linha, para a lista de conversas: `kind` (`owner`, `message`, `reply`, `tool`, `approval`, `notice`), `text` e `at`. O `text` não tem palavras do daemon: a mensagem do dono vem sem "You:" e a aprovação só com o nome da ferramenta, e o app completa no idioma do dono. +`Crew` traz `workFolder`, o caminho da pasta de trabalho (a escolhida ou a `shared\`), `workFolderChosen` e `leadBotId`, o chefe (10.2). `Bot` traz também `permissionMode`, `model` e `modelInUse` (7.4) e `lastActivity`: o último item do chat resumido em uma linha, para a lista de conversas: `kind` (`owner`, `message`, `reply`, `tool`, `approval`, `notice`), `text` e `at`. O `text` não tem palavras do daemon: a mensagem do dono vem sem "You:" e a aprovação só com o nome da ferramenta, e o app completa no idioma do dono. ### 11.3 Notificações do servidor @@ -472,8 +501,8 @@ Pragmas: `journal_mode=WAL`, `foreign_keys=ON`, `busy_timeout=5000`. Migrations | Tabela | Colunas principais | |---|---| -| `crews` | `id, name, slug, paused, created_at, archived_at` | -| `bots` | `id, crew_id, name, handle, slug, role, instructions, color, paused, token_hash, session_id, created_at, archived_at` | +| `crews` | `id, name, slug, paused, work_dir, lead_bot_id, created_at, archived_at` (`work_dir` é a pasta escolhida; `NULL` usa a `shared`. `lead_bot_id` é o chefe, sem chave estrangeira: ele é gravado junto com a crew) | +| `bots` | `id, crew_id, name, handle, slug, role, instructions, color, paused, permission_mode, model, model_in_use, token_hash, session_id, created_at, archived_at` | | `messages` | `id, crew_id, from_kind (owner/bot/system), from_bot_id, to_bot_id, kind (note/task/result/system), body, task_id, created_at` | | `attachments` | `id, message_id, name, media_type, size, path, created_at` | | `deliveries` | `id, message_id, bot_id, state, attempts, next_attempt_at, lease_until, last_error, sent_generation, turn_uuid, read_at, updated_at` | @@ -493,6 +522,8 @@ Pragmas: `journal_mode=WAL`, `foreign_keys=ON`, `busy_timeout=5000`. Migrations - `log_level` vale só para os crates do Botloft; dependências ficam em `warn`, porque em `debug`/`trace` a pilha de WebSocket registra frames, que podem conter mensagens. `RUST_LOG` sobrepõe tudo e é só para depuração local. - Nome de anexo vira só o nome do arquivo (sem `..`, sem pasta, sem caracteres proibidos no Windows) antes de ir para o disco. - Isolamento entre bots é cooperativo (mesmo usuário do Windows). Documentar isso no README sem prometer sandbox. +- Pasta de trabalho escolhida (5): todos os bots da crew a editam como a própria pasta. Por isso ela não pode tocar a pasta de dados do Botloft (segredos, banco) nem conter os workspaces de todos os bots, e não pode ser um disco inteiro. +- Modo `bypass_permissions` (7.4): o bot faz tudo sem perguntar. As regras `deny` de leitura só cobrem as ferramentas de arquivo do Claude Code, alguns comandos do Bash (`cat`, `head`, `tail`, `sed`, `tee`) e redirecionamentos, não um script em Python ou Node, e o Windows nativo não tem sandbox. Um bot nesse modo pode ler `secrets\owner.token`, o banco e as pastas de outros bots, e uma mensagem de outra pessoa pode levá-lo a isso. O app só liga o modo depois de uma confirmação que diz isso, e o bot fica marcado em vermelho (15.1). Um chefe nesse modo também cria bots sem perguntar (10.2), e a confirmação diz isso quando o bot é o chefe. ## 14. Integração com o Windows @@ -550,9 +581,15 @@ O store recarrega crews, bots e `system.status` a cada (re)conexão e depois seg Layout, como um app de mensagens: -- **Barra lateral:** crews como seções, com os bots como conversas. Cada conversa mostra avatar, nome, estado (cor, ícone e texto) e a prévia da última atividade (`lastActivity`) com a hora. -- **Área principal com um bot:** cabeçalho com nome, estado e ações; o chat; o compositor embaixo. O compositor aceita texto, colar imagem e arrastar ou escolher arquivos. Enter envia e Shift+Enter quebra linha. -- **Área principal com uma crew:** a timeline (messages entre os bots e do dono) e as tasks. +- **Barra lateral:** crews como seções, com os bots como conversas. Cada conversa mostra avatar, nome, estado (cor, ícone e texto) e a prévia da última atividade (`lastActivity`) com a hora. Ela aparece desde a conexão, também na tela de boas-vindas antes da primeira crew. +- **Área da conta**, no pé da barra lateral, como nos apps de chat: um círculo com a inicial, o nome do dono (do Windows) e o plano do Claude ("Plano Max"; sem plano, a organização ou o e-mail; desconectado, "Sem conta do Claude conectada"). Um clique abre um menu para cima com o e-mail e: **Uso** (as janelas de uso do plano, 8.1, com a parte usada e quando renovam; antes da primeira resposta de um bot, um aviso de que ainda não há dados), **Configurações** (tema, tamanho, idioma e as versões do Botloft e do Claude Code), **Idioma** (submenu ao lado, com a escolha na hora), **Novidades** (a página de releases no navegador) e **Ajuda** (o README no navegador). Tema, tamanho e idioma saíram da barra de título; ela só mostra o idioma nas telas de preparo, que ainda não têm barra lateral. +- **Área principal com um bot:** cabeçalho com nome, estado e ações; o chat; o compositor embaixo. O compositor aceita texto, colar imagem e arrastar ou escolher arquivos. Enter envia e Shift+Enter quebra linha (a dica aparece enquanto o dono escreve). +- **Modo do bot**, no compositor, ao lado do clipe, como no Claude Code: um botão com o modo atual abre um menu para cima, "Modo", com Automático, Manual, Aceitar edições e Plano, cada um com uma linha que fala do bot pelo nome ("Scout decide o que precisa do seu OK") e a marca no atual. Separado, "Ignorar permissões" com o botão Ativar, que abre uma confirmação dizendo que o bot não fica preso à pasta dele (13). Nesse modo o botão fica vermelho e o cabeçalho mostra "Não pergunta nada" em vermelho. Com o bot ocupado, uma linha acima do compositor avisa que ele muda de modo quando terminar o que está fazendo. +- **Modelo do bot**, no compositor, ao lado do botão de enviar: mostra o modelo em uso ("Opus 5.5"; antes do primeiro turno, o nome escolhido ou "Padrão") e abre um menu para cima, "Modelo", com Padrão do plano, Fable, Opus, Sonnet e Haiku. Cada um tem uma linha que fala do bot pelo nome ("Scout fica rápido e capaz, bom para quase tudo"; o padrão diz qual modelo é hoje), e o pé do menu lembra que modelos mais capazes gastam o limite do plano mais rápido. A janela de criar e editar bot tem a mesma escolha. Com o bot ocupado, a mesma linha acima do compositor avisa que ele troca quando terminar. +- **Área principal com uma crew:** a timeline (messages entre os bots e do dono) e as tasks. Embaixo do nome, "Trabalha em <pasta>", que abre a pasta no Explorer; o menu da crew tem "Abrir pasta de trabalho" e "Mudar pasta de trabalho…", que abre o seletor de pastas do Windows e confirma antes de mudar, avisando que cada bot reinicia quando terminar o que está fazendo. +- **Nova crew:** nome; "Para que é esta equipe?", o objetivo que vira as instruções do chefe, com a explicação de que a equipe começa com um Chefe que planeja o trabalho e sugere os bots de que precisa; "Pasta de trabalho", com "Escolher pasta…" (o seletor do Windows; sem escolha, "Uma pasta nova dentro do Botloft", a `shared\`); e "Modelo do Chefe". Criada, o app abre o chat do chefe. +- **Chefe:** uma coroa ao lado do nome na barra lateral e nos cartões da crew, e "Chefe" no cabeçalho do bot, com a dica "Lidera <crew>: planeja o trabalho e sugere bots novos". O menu do bot tem "Tornar chefe da equipe" ou "Deixar de ser chefe". +- **Sugestão de bot** (10.2): um cartão no chat do chefe, "<chefe> sugere um bot novo", com o porquê e os campos editáveis Nome, Modelo, Função e Instruções, a linha de que o bot começa na hora e recebe o trabalho do chefe, um campo para dizer ao chefe por que não, e os botões Criar bot e Agora não. Respondido, vira uma linha ("Você criou Designer", "Você recusou Designer") que abre o que foi sugerido. - **Detalhes do bot** (pasta, instruções, sessão) ficam num painel, fora do caminho da conversa. ### 15.2 Comandos Tauri @@ -565,6 +602,7 @@ Layout, como um app de mensagens: | `claude_sign_in` | abre `claude auth login` numa janela de console própria (`CREATE_NEW_CONSOLE`) com o `claudePath` do `system.status` e espera; responde se saiu com 0. Só roda um caminho absoluto de arquivo existente chamado `claude.exe`. Tira do ambiente `CLAUDECODE` e `CLAUDE_CODE_*`, que um app aberto de dentro de uma sessão do Claude Code herdaria. Quem abre é o app, e não o daemon, porque a janela aberta pelo app em primeiro plano vem para a frente. Na janela o dono vê o que acontece e pode colar um código se o navegador pedir | | `read_owner_token` | lê `secrets\owner.token` (só no app local) | | `open_path` | abre uma pasta no Explorer; recusa arquivos, que o Explorer executaria | +| seletor de pastas | não é comando próprio: o app usa o `tauri-plugin-dialog` (`open({directory: true})`, permissão `dialog:allow-open`) para a pasta de trabalho da crew (5) | | `open_url` | abre no navegador padrão um link de uma resposta do bot; só `http` e `https`, porque qualquer outro esquema pode iniciar um programa. Seguir o link dentro do app trocaria a janela pela página | | overlay na taskbar | não é comando próprio: o app usa `setOverlayIcon` da janela (permissão `core:window:allow-set-overlay-icon`) e marca o ícone com um ponto enquanto algo espera o dono: aprovação pendente, bot em `auth_error`, ou mensagem não entregue a um bot ativo. Entregas mortas para bot arquivado não contam: foram abandonadas de propósito | @@ -586,17 +624,29 @@ Em dev, `pnpm tauri dev` usa o `target\debug\botloftd.exe` como sidecar e instal ### 15.3 Direção visual -Ferramenta de trabalho densa e calma: tipografia forte, grid firme, estados dos bots legíveis de longe (cor + ícone + texto, nunca só cor). Sem gradiente, sem sombra pesada, sem visual de template. Tema escuro e claro. Barra de título própria (`decorations: false`) com controles de janela do Windows. +Ferramenta de trabalho densa e calma: tipografia forte, grid firme, estados dos bots legíveis de longe (cor + ícone + texto, nunca só cor). Sem gradiente, sem sombra pesada, sem visual de template. Cantos arredondados, como nos apps de chat: botões, campos e linhas de menu com 8 px; cartões, avisos e menus com 12 px; compositor, diálogos e cartões do chat com 16 px. Menus e diálogos flutuam com uma sombra leve (`shadow-lift`, mais forte no tema escuro). Na barra lateral, a conversa aberta é um bloco arredondado recuado das bordas. Tema escuro e claro. Barra de título própria (`decorations: false`) com controles de janela do Windows. + +Tamanho: a janela inteira é desenhada numa escala (zoom do webview, `setZoom`), então texto, espaçamento, ícones e avatares crescem juntos. Níveis 100%, 110%, 125% e 150%; o padrão é **125%**, porque o desenho a 100% ficava miúdo num monitor sem ampliação do Windows. Quem já usa a ampliação alta volta para 100% em Configurações (área da conta) ou com Ctrl+-; Ctrl+= aumenta e Ctrl+0 volta ao padrão. A escolha fica no `localStorage` (`botloft.zoom`) e é aplicada antes da primeira pintura, para a janela não piscar pequena. Acima de 150% a janela mínima (900 px) não cabe o layout. + +Movimento: o app se mexe para parecer vivo, sem atrapalhar o trabalho. Animações curtas (150 a 400 ms, saída suave) em CSS, sem biblioteca (`motion.css`), e todas param quando o Windows desliga os efeitos de animação (`prefers-reduced-motion`). + +- **Mascote:** cada bot tem um humor que segue o estado. Ele pisca de vez em quando (cada bot num ritmo, para uma equipe não piscar junta), tremula como chama enquanto trabalha (`busy`, `launching`), dá pulinhos enquanto espera o dono (`needs_approval`), fica de olhos cansados no limite de uso e dorme, de olhos fechados, pausado ou parado. Mexem-se os mascotes da barra lateral, do cabeçalho, dos cartões da crew e da resposta em andamento; o histórico do chat fica parado. O humor soma ao estado, que continua com cor, ícone e texto. +- **Chegadas:** o que chega enquanto o dono olha entra subindo e aparecendo: mensagens, ferramentas, pedidos, avisos e bots novos na barra lateral. O que já estava lá quando ele abriu o chat (ou o app) aparece parado, e páginas antigas carregadas em cima não se mexem. A resposta já aparece enquanto é escrita, então não anima de novo ao terminar. +- **Trabalhando:** os três pontos pulam em sequência; o texto sendo escrito tem um cursor piscando no fim; a mão de "Precisa de aprovação" acena; um pedido pendente pulsa uma vez ao aparecer. +- **Trocar de bot ou de crew:** o painel principal some rápido e o novo sobe (View Transitions do webview); a barra lateral fica onde está. +- **Superfícies:** menus e seletores abrem a partir de onde estão presos; diálogos aparecem com o fundo escurecendo; avisos entram deslizando; `<details>` abre deslizando; a linha da aba selecionada desliza até a nova; as barras de uso enchem ao abrir; botões afundam um pouco ao clicar; o mascote da tela de boas-vindas e do chat vazio flutua. No chat: +- O chat é uma coluna centralizada (48rem), com o compositor na mesma largura; o dia é uma pílula no meio. - O dono fala em balões à direita; o bot, à esquerda, com markdown. - Mensagens de outros bots aparecem à esquerda, com o avatar e o nome de quem mandou. - O que o bot faz com as ferramentas aparece em linhas compactas (ícone, ferramenta, resumo e estado), agrupadas por turno, que abrem para mostrar entrada e saída. - Pedido de aprovação é um cartão com o que o bot quer fazer e os botões Permitir e Negar. +- Pedido para seguir com um plano (10.1) é um cartão com o plano em markdown, um campo para o que deve mudar e os botões Aprovar plano e Pedir mudanças. Respondido, vira uma linha que abre o plano de novo. - Anexos aparecem como miniatura (imagem) ou cartão com nome, tipo e tamanho. -Identidade: o mascote do Botloft é uma chama com olhos, desenhada em vetor em `app/app-icon.svg`. O ícone do app é o mascote branco sobre fundo preto. Cada bot usa o mesmo personagem como avatar, com uma cor própria escolhida na criação. A cor do avatar identifica o bot e não comunica estado: estado continua sendo cor + ícone + texto, como descrito acima. +Identidade: o mascote do Botloft é uma chama com olhos, desenhada em vetor em `app/app-icon.svg`. O ícone do app é o mascote branco sobre fundo preto. Cada bot usa o mesmo personagem como avatar, com uma cor própria escolhida na criação, sem fundo e com um contorno fino e discreto (escuro no tema claro, claro no escuro) para as cores claras não sumirem. O mascote branco do próprio Botloft (barra de título, mensagens do daemon) fica sobre o quadrado preto do ícone do app, que é o que o torna visível no tema claro. A cor do avatar identifica o bot e não comunica estado: estado continua sendo cor + ícone + texto, como descrito acima. O mascote se mexe conforme o que o bot faz (ver Movimento), sem substituir isso. ### 15.4 Instalador e sidecar @@ -617,7 +667,7 @@ Identidade: o mascote do Botloft é uma chama com olhos, desenhada em vetor em ` - O app fala **inglês, português (Brasil) e espanhol**. Todo texto que o dono lê fica em `app/src/i18n/<idioma>/`, um arquivo por área (`common`, `shell`, `onboarding`, `updates`, `bots`, `chat`, `crews`, `messages`). O inglês é a referência: o formato dele é o tipo `Messages`, e um texto que falte ou sobre em outro idioma não compila. Texto com valores é função (`ready(version)`), com o plural escrito para cada idioma. - Componentes leem com `useT()`; código fora do React (toasts, formatação, erros da conexão) com `t()` na hora do uso. -- Escolha no botão de idioma da barra de título (também nas telas de preparo): "Idioma do sistema" segue o Windows (o primeiro idioma suportado entre os preferidos; `pt-PT` vira `pt-BR`; nenhum, inglês) ou um idioma fixo. A escolha fica no `localStorage` do app (`botloft.locale`) e marca `<html lang>`. +- Escolha na área da conta (Idioma, ou Configurações), e no botão de idioma da barra de título só nas telas de preparo: "Idioma do sistema" segue o Windows (o primeiro idioma suportado entre os preferidos; `pt-PT` vira `pt-BR`; nenhum, inglês) ou um idioma fixo. A escolha fica no `localStorage` do app (`botloft.locale`) e marca `<html lang>`. - Datas e horas (`lib/format.ts`) usam o idioma escolhido. - O daemon não escreve texto para o dono: avisos vêm com `code` e a linha da conversa com `kind` (8.2, 11.2), e o app escreve. Continuam como vêm: nomes, mensagens, respostas e saídas de ferramenta; o resumo de ferramenta que o daemon faz a partir da entrada (o comando, o arquivo); e as mensagens de erro do daemon (validação, falhas), mostradas como texto técnico. - O instalador NSIS também traz os três idiomas e escolhe pelo idioma do Windows. @@ -673,6 +723,12 @@ Conferência na documentação oficial (code.claude.com/docs) em 2026-09-28. "Co | `--setting-sources project,local` | 7.4 | Confirmado (`cli-reference`). **Testado com 2.1.284**: sem os hooks, skills e agents do usuário; modo `default`; login da assinatura continua valendo | feito (M4.1) | | `claude auth status` | 7.3 | Confirmado (`cli-reference`): JSON por padrão, sai com 0 conectado e 1 desconectado. **Testado com 2.1.284**: conectado traz `"loggedIn": true`; com `CLAUDE_CONFIG_DIR` vazio, `"loggedIn": false`, `"authMethod": "none"` e saída 1. As credenciais ficam em `%USERPROFILE%\.claude\.credentials.json` (`authentication`) | feito | | `claude auth login` | 15.2 | Confirmado (`cli-reference`, `authentication`): abre o navegador e volta por um servidor local; se o navegador não alcançar esse servidor, mostra um código para colar no terminal. Se o subcomando sai sozinho depois do login ainda não foi visto: o app só depende do código de saída | manual (PR) | +| `permissionMode` no `system/init` | 7.4 | **Visto com 2.1.284**: o `system/init` de cada turno traz `permissionMode` com o valor da CLI (`default`, `acceptEdits`, `plan`, `auto`, `bypassPermissions`) | feito | +| Modos de permissão em `-p` | 7.4 | Confirmado (`permission-modes`): `deny` vale em todos os modos, inclusive `bypassPermissions`, que não pode ser ligado no meio da sessão; em `-p`, `auto` manda para a tool de aprovação o que o classificador não libera e `plan` continua bloqueando edições. O `auto` depende do plano e do modelo; o que `--permission-mode auto` faz sem ele ainda não foi visto | manual (PR) | +| `ExitPlanMode` em `-p` | 10.1 | A lista de ferramentas diz que ele pede permissão. Não visto: se o pedido chega à tool de aprovação com `{plan}` na entrada, e para qual modo o bot vai depois de aprovado (o daemon segue o `system/init` do turno seguinte) | manual (PR) | +| Modelo em `-p` | 7.4 | Confirmado (`model-config`, `sessions`): apelidos `fable`, `opus`, `sonnet`, `haiku` (e `best`, `opusplan`, `[1m]`, não usados); sem `model` nas settings, vale o padrão da conta; `--resume` mantém o modelo da sessão, a menos que `--model` escolha outro. **Visto com 2.1.284** (plano Max): sem `--model`, o `system/init` traz `"model": "claude-opus-5-5"`; um modelo inexistente sobe o processo, o init o repete, e cada turno termina com `assistant.error: "model_not_found"` e `result.is_error`; `/model haiku` mandado como mensagem troca o modelo no meio da sessão, com uma resposta sintética e sem custo, mas o daemon reinicia o processo em vez disso, como na troca de modo. Qual é o padrão em cada plano, e quais modelos cada plano tem, não está documentado | feito | +| `--add-dir` em `-p` | 5, 7.4 | Confirmado (`cli-reference`, `memory`): pastas a mais que o Claude Code trata como de trabalho; o `CLAUDE.md` delas só carrega com `CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD=1`. **Testado com 2.1.284** (`--setting-sources project,local`, `acceptEdits`): com a flag e a variável, o bot citou o `CLAUDE.md` da pasta sem abrir arquivo e gravou nela sem pedir; sem a flag, o `Write` na mesma pasta foi negado (`permission_denials`). A flag aceita vários valores: a linha de comando do daemon não tem prompt posicional, então nada é engolido | feito | +| Chefe e `suggest_bot` com o Claude Code real | 10.2 | **Testado com 2.1.284** (daemon e app de dev): a crew criada pelo app subiu o chefe com `--model sonnet` e `--add-dir` na pasta da crew. Pedido um site, o chefe carregou `crew_roster`, `suggest_bot` e `send_message` pelo `ToolSearch` e sugeriu um Designer com papel, instruções, modelo e porquê; a chamada esperou o cartão. Com o modelo trocado para `haiku` no cartão, o bot subiu com `--model haiku`, e o chefe citou a troca. O chefe mandou uma task, o Designer entregou com `complete_task`, e o chefe conferiu o resultado e corrigiu o HTML. O log de `debug` não teve texto de mensagem | feito | | Regras `allow` do projeto em `-p` sem confiança | 7.4 | Confirmado (`permissions`): não são aplicadas numa pasta nunca confiada; `deny` vale sempre. Por isso `--allowedTools mcp__botloft` | M4.1 | | `--session-id`, `--resume` em `-p` | 7.3 | Confirmado (`cli-reference`, `sessions`): a sessão retoma histórico e modelo; flags como `--mcp-config` têm de ser passadas de novo. **Testado com 2.1.284**: depois de reiniciar o bot e depois de reiniciar o daemon, o bot lembrou arquivos, a imagem e a mensagem de outro bot | feito (M4.1) | | Tools MCP adiadas | 10 | **Visto com 2.1.284**: as tools do `botloft` chegam adiadas; antes da primeira `send_message` o bot chama `ToolSearch` com `select:mcp__botloft__send_message`. O chat mostra isso como "load send_message" | feito (M4.1) |
@@ -64,7 +64,7 @@ function FileCard({ host.openPath(attachmentFolder(workspace, attachment)), ) } - className="grid h-7 w-7 shrink-0 place-items-center rounded-[3px] text-muted hover:bg-sunken hover:text-ink" + className="grid h-7 w-7 shrink-0 place-items-center rounded-lg text-muted hover:bg-sunken hover:text-ink" > @@ -93,7 +93,7 @@ function Thumbnail({ } if (source.kind === "loading") { return ( -
{t.chat.composer.paused(bot.name)}
+ {later} +
{t.chat.view.emptyTitle(bot.name)}
{bot.role}
{t.chat.view.emptyBody}
{t.chat.view.dropToAttach} diff --git a/app/src/features/chat/InboundRow.tsx b/app/src/features/chat/InboundRow.tsx index 39eb95a1..84e41f93 100644 --- a/app/src/features/chat/InboundRow.tsx +++ b/app/src/features/chat/InboundRow.tsx @@ -6,6 +6,7 @@ import { useT } from "../../i18n"; import { when } from "../../lib/format"; import type { Bot, Message } from "../../lib/protocol.gen"; import { useApp } from "../../store/context"; +import { useArrival } from "../../ui/motion"; import { BotAvatar } from "../bots/BotAvatar"; import { DeliveryStatus } from "../messages/DeliveryStatus"; import { AttachmentList } from "./AttachmentList"; @@ -20,12 +21,13 @@ function Time({ at }: { at: number }) { function OwnerMessage({ message, bot }: { message: Message; bot: Bot }) { const delivery = useApp((state) => state.deliveries[message.id]); + const arrival = useArrival(message.createdAt); return ( -
{message.body} @@ -46,7 +48,7 @@ function TaskTag({ message }: { message: Message }) { } const Icon = message.kind === "task" ? ListTodo : Reply; return ( - + {message.kind === "task" ? t.chat.inbound.task : t.chat.inbound.result} @@ -59,9 +61,14 @@ function OtherMessage({ message }: { message: Message }) { const delivery = useApp((state) => state.deliveries[message.id]); const system = message.fromKind === "system"; const name = system ? "Botloft" : (sender?.name ?? t.chat.inbound.archivedBot); + const arrival = useArrival(message.createdAt); return ( - - + + {name} @@ -70,7 +77,7 @@ function OtherMessage({ message }: { message: Message }) { {message.body} diff --git a/app/src/features/chat/Markdown.tsx b/app/src/features/chat/Markdown.tsx index 0f659c72..f1cdaaca 100644 --- a/app/src/features/chat/Markdown.tsx +++ b/app/src/features/chat/Markdown.tsx @@ -60,9 +60,16 @@ const components: Components = { img: ({ src, alt }) => , }; -export const Markdown = memo(function Markdown({ text }: { text: string }) { +/** `streaming` shows a caret after the text, while the bot still writes it. */ +export const Markdown = memo(function Markdown({ + text, + streaming = false, +}: { + text: string; + streaming?: boolean; +}) { return ( - + {text} diff --git a/app/src/features/chat/ModePicker.tsx b/app/src/features/chat/ModePicker.tsx new file mode 100644 index 00000000..22b6f0af --- /dev/null +++ b/app/src/features/chat/ModePicker.tsx @@ -0,0 +1,137 @@ +// How much the bot may do without asking (spec 7.4), picked below the chat +// as in Claude Code. Bypassing permissions asks first: the bot is then not +// held to its folder. + +import { + ChevronDown, + FilePen, + Hand, + ListTodo, + type LucideIcon, + ShieldOff, + WandSparkles, +} from "lucide-react"; +import { useCallback, useRef, useState } from "react"; +import { useT } from "../../i18n"; +import type { Bot, PermissionMode } from "../../lib/protocol.gen"; +import { useApi, useApp } from "../../store/context"; +import { Confirm } from "../../ui/Confirm"; +import { POPOVER } from "../../ui/surface"; +import { attempt } from "../../ui/toast"; +import { useDismiss } from "../../ui/useDismiss"; +import { PickerOption } from "./PickerOption"; + +const MODES: { mode: PermissionMode; icon: LucideIcon }[] = [ + { mode: "auto", icon: WandSparkles }, + { mode: "default", icon: Hand }, + { mode: "accept_edits", icon: FilePen }, + { mode: "plan", icon: ListTodo }, +]; + +export function ModePicker({ bot, onLater }: { bot: Bot; onLater(text: string): void }) { + const api = useApi(); + const putBot = useApp((state) => state.putBot); + const chief = useApp((state) => state.crews[bot.crewId]?.leadBotId === bot.id); + const m = useT().chat.mode; + const [open, setOpen] = useState(false); + const [confirming, setConfirming] = useState(false); + const root = useRef(null); + const close = useCallback(() => setOpen(false), []); + useDismiss(open, root, close); + + const current = bot.permissionMode; + const bypass = current === "bypass_permissions"; + const Icon = bypass ? ShieldOff : (MODES.find((entry) => entry.mode === current)?.icon ?? Hand); + + const choose = async (mode: PermissionMode) => { + setOpen(false); + if (mode === current) { + return; + } + // The bot restarts into the new mode once nothing is in progress. + const working = bot.state === "busy" || bot.state === "needs_approval"; + await attempt(m.failed, async () => { + putBot(await api.call("bots.setPermissionMode", { botId: bot.id, mode })); + if (working) { + onLater(m.later(bot.name, m.names[mode])); + } + }); + }; + + return ( + + {open && ( + + {m.title} + {MODES.map(({ mode, icon }) => ( + choose(mode)} + /> + ))} + + { + setOpen(false); + if (!bypass) { + setConfirming(true); + } + }} + trailing={ + + {m.turnOn} + + } + /> + + )} + setOpen(!open)} + className={`flex h-8 items-center gap-1.5 rounded-full px-2.5 text-sm transition-colors ${ + bypass + ? "bg-danger/10 text-danger hover:bg-danger/15" + : `text-ink-soft hover:bg-sunken hover:text-ink ${open ? "bg-sunken text-ink" : ""}` + }`} + > + + {m.names[current]} + + + {confirming && ( + choose("bypass_permissions")} + onClose={() => setConfirming(false)} + > + {m.bypassBody(bot.name)} + {m.bypassRisk} + {chief && {m.bypassChief(bot.name)}} + {m.bypassAdvice} + + )} + + ); +} diff --git a/app/src/features/chat/ModelPicker.tsx b/app/src/features/chat/ModelPicker.tsx new file mode 100644 index 00000000..f0d37a12 --- /dev/null +++ b/app/src/features/chat/ModelPicker.tsx @@ -0,0 +1,97 @@ +// Which Claude model the bot runs on (spec 7.4), picked below the chat as +// in Claude's apps. The plan's default shows the model Claude Code named. + +import { ChevronDown } from "lucide-react"; +import { useCallback, useRef, useState } from "react"; +import { useT } from "../../i18n"; +import { modelFamily, modelName } from "../../lib/models"; +import type { Bot, BotModel } from "../../lib/protocol.gen"; +import { useApi, useApp } from "../../store/context"; +import { POPOVER } from "../../ui/surface"; +import { attempt } from "../../ui/toast"; +import { useDismiss } from "../../ui/useDismiss"; +import { PickerOption } from "./PickerOption"; + +const MODELS: BotModel[] = ["default", "fable", "opus", "sonnet", "haiku"]; + +export function ModelPicker({ bot, onLater }: { bot: Bot; onLater(text: string): void }) { + const api = useApi(); + const putBot = useApp((state) => state.putBot); + const m = useT().chat.model; + const [open, setOpen] = useState(false); + const root = useRef(null); + const close = useCallback(() => setOpen(false), []); + useDismiss(open, root, close); + + const current = bot.model; + const inUse = bot.modelInUse ? modelName(bot.modelInUse) : null; + // The version once Claude Code has named it; until then, the choice. + const label = + current === "default" + ? (inUse ?? m.short) + : bot.modelInUse && modelFamily(bot.modelInUse) === current && inUse + ? inUse + : m.names[current]; + + const choose = async (model: BotModel) => { + setOpen(false); + if (model === current) { + return; + } + // The bot restarts on the new model once nothing is in progress. + const working = bot.state === "busy" || bot.state === "needs_approval"; + await attempt(m.failed, async () => { + putBot(await api.call("bots.setModel", { botId: bot.id, model })); + if (working) { + onLater(m.later(bot.name, m.names[model])); + } + }); + }; + + const hint = (model: BotModel) => + model === "default" ? m.hints.default(bot.name, inUse) : m.hints[model](bot.name); + + return ( + + {open && ( + + {m.title} + {MODELS.map((model) => ( + choose(model)} + /> + ))} + + {m.cost} + + + )} + setOpen(!open)} + className={`flex h-8 items-center gap-1 rounded-full px-2.5 text-sm text-ink-soft transition-colors hover:bg-sunken hover:text-ink ${ + open ? "bg-sunken text-ink" : "" + }`} + > + {label} + + + + ); +} diff --git a/app/src/features/chat/NoticeRow.tsx b/app/src/features/chat/NoticeRow.tsx index c9ef6526..8a0f2d67 100644 --- a/app/src/features/chat/NoticeRow.tsx +++ b/app/src/features/chat/NoticeRow.tsx @@ -4,20 +4,23 @@ import { CircleAlert, Info, TriangleAlert } from "lucide-react"; import { type Messages, useT } from "../../i18n"; import type { NoticeItem } from "../../lib/protocol.gen"; +import { useArrival } from "../../ui/motion"; const LOOK = { - info: { icon: Info, tone: "text-work", frame: "border-line" }, - warning: { icon: TriangleAlert, tone: "text-warn", frame: "border-warn/50" }, - error: { icon: CircleAlert, tone: "text-danger", frame: "border-danger/50" }, + info: { icon: Info, tone: "text-work", frame: "border-line bg-panel" }, + warning: { icon: TriangleAlert, tone: "text-warn", frame: "border-warn/40 bg-warn/6" }, + error: { icon: CircleAlert, tone: "text-danger", frame: "border-danger/40 bg-danger/6" }, } as const; -export function NoticeRow({ notice }: { notice: NoticeItem }) { +/** `at` is when the notice came, so a new one animates in. */ +export function NoticeRow({ notice, at = 0 }: { notice: NoticeItem; at?: number }) { const t = useT(); const { icon: Icon, tone, frame } = LOOK[notice.level]; + const arrival = useArrival(at); return ( @@ -36,6 +39,8 @@ function noticeText(notice: NoticeItem, words: Messages["chat"]["notice"]): stri return words.usageLimit; case "turn_failed": return words.turnFailed(notice.text); + case "model_unavailable": + return words.modelUnavailable; default: return notice.text; } diff --git a/app/src/features/chat/PickerOption.tsx b/app/src/features/chat/PickerOption.tsx new file mode 100644 index 00000000..6c6a843e --- /dev/null +++ b/app/src/features/chat/PickerOption.tsx @@ -0,0 +1,47 @@ +// One choice in a picker below the chat (mode, model): a name, a line +// about what it means for the bot, and a check on the current one. + +import { Check, type LucideIcon } from "lucide-react"; +import type { ReactNode } from "react"; +import { POPOVER_ITEM } from "../../ui/surface"; + +export function PickerOption({ + icon: Icon, + name, + hint, + checked, + danger = false, + trailing, + onSelect, +}: { + icon?: LucideIcon; + name: string; + hint: string; + checked: boolean; + danger?: boolean; + trailing?: ReactNode; + onSelect(): void; +}) { + return ( + + {Icon && ( + + )} + + {name} + {hint} + + {checked ? : trailing} + + ); +} diff --git a/app/src/features/chat/PlanCard.tsx b/app/src/features/chat/PlanCard.tsx new file mode 100644 index 00000000..44157ecd --- /dev/null +++ b/app/src/features/chat/PlanCard.tsx @@ -0,0 +1,110 @@ +// A bot in plan mode asking to go ahead (spec 10.1): Claude Code asks for +// it as the ExitPlanMode tool, with the plan. Approving lets the bot work; +// sending it back keeps it planning, with what should change. + +import { Check, ChevronRight, ListTodo, PencilLine, TimerOff } from "lucide-react"; +import { useId } from "react"; +import { useT } from "../../i18n"; +import type { ApprovalItem, Bot } from "../../lib/protocol.gen"; +import { Button } from "../../ui/Button"; +import { Markdown } from "./Markdown"; +import { useAnswer } from "./useAnswer"; + +export const PLAN_TOOL = "ExitPlanMode"; + +/** The plan in the request's input; the input itself if it is not JSON. */ +export function planText(input: string): string { + try { + const parsed: unknown = JSON.parse(input); + if (typeof parsed === "object" && parsed !== null && "plan" in parsed) { + const { plan } = parsed; + if (typeof plan === "string") { + return plan; + } + } + } catch { + // Cut short or not JSON: show it as it came. + } + return input; +} + +export function PlanCard({ approval, bot }: { approval: ApprovalItem; bot: Bot }) { + const p = useT().chat.plan; + const { note, setNote, busy, answer } = useAnswer(approval, { + allow: p.approveFailed, + deny: p.keepFailed, + }); + const noteId = useId(); + const plan = planText(approval.input); + if (approval.status !== "pending") { + return ; + } + + return ( + + + + + + {p.ready(bot.name)} + + + + + + + {p.noteLabel(bot.name)} + + setNote(event.target.value)} + placeholder={p.notePlaceholder} + className="block w-full resize-none rounded-xl border border-line-strong bg-panel px-3 py-2 text-sm outline-none placeholder:text-muted focus:border-muted" + /> + <div className="mt-2.5 flex flex-wrap gap-2"> + <Button variant="primary" icon={Check} disabled={busy} onClick={() => answer(true)}> + {p.approve} + </Button> + <Button icon={PencilLine} disabled={busy} onClick={() => answer(false)}> + {p.keepPlanning} + </Button> + </div> + </div> + </section> + ); +} + +/** One line once answered; the plan stays a click away. */ +function Answered({ approval, plan }: { approval: ApprovalItem; plan: string }) { + const p = useT().chat.plan; + const [Icon, text, tone] = + approval.status === "allowed" + ? [Check, p.approved, "text-ok"] + : approval.status === "denied" + ? [PencilLine, p.sentBack, "text-work"] + : [TimerOff, p.expired, "text-quiet"]; + return ( + <details className="group"> + <summary className="flex min-w-0 cursor-default items-center gap-2 rounded-lg px-1.5 py-1 text-sm hover:bg-sunken"> + <Icon aria-hidden size={14} className={`shrink-0 ${tone}`} /> + <span className="shrink-0 font-medium">{text}</span> + {approval.note && ( + <span className="truncate text-muted text-xs">{`“${approval.note}”`}</span> + )} + <ChevronRight + aria-hidden + size={13} + className="shrink-0 text-muted transition-transform group-open:rotate-90" + /> + </summary> + <div className="mt-1.5 ml-6 rounded-xl border border-line bg-panel px-4 py-3" data-selectable> + <Markdown text={plan} /> + </div> + </details> + ); +} diff --git a/app/src/features/chat/SuggestionCard.tsx b/app/src/features/chat/SuggestionCard.tsx new file mode 100644 index 00000000..1d87109b --- /dev/null +++ b/app/src/features/chat/SuggestionCard.tsx @@ -0,0 +1,171 @@ +// The crew's chief suggesting a new bot (spec 10.2). The owner can change +// the name, role, model and instructions before creating it, or say no +// with a note for the chief. Once answered it shrinks to one line. + +import { Ban, Check, ChevronRight, TimerOff, UserPlus } from "lucide-react"; +import { useId, useState } from "react"; +import { useT } from "../../i18n"; +import type { ApprovalItem, Bot, BotModel } from "../../lib/protocol.gen"; +import { Button } from "../../ui/Button"; +import { SelectField, TextArea, TextField } from "../../ui/Field"; +import { useAnswer } from "./useAnswer"; + +export const SUGGEST_TOOL = "mcp__botloft__suggest_bot"; + +const MODELS: BotModel[] = ["default", "fable", "opus", "sonnet", "haiku"]; + +interface Suggestion { + name: string; + role: string; + instructions: string; + model?: BotModel; + reason: string; +} + +/** The suggestion in the request's input; empty fields if it is cut short. */ +export function suggestionOf(input: string): Suggestion { + try { + const parsed = JSON.parse(input) as Partial<Suggestion>; + return { + name: parsed.name ?? "", + role: parsed.role ?? "", + instructions: parsed.instructions ?? "", + ...(parsed.model && { model: parsed.model }), + reason: parsed.reason ?? "", + }; + } catch { + return { name: "", role: "", instructions: input, reason: "" }; + } +} + +export function SuggestionCard({ approval, bot }: { approval: ApprovalItem; bot: Bot }) { + const t = useT(); + const s = t.chat.suggestion; + const asked = suggestionOf(approval.input); + const [edited, setEdited] = useState<Suggestion>(asked); + const { note, setNote, busy, answer } = useAnswer(approval, { + allow: s.createFailed, + deny: s.declineFailed, + }); + const noteId = useId(); + if (approval.status !== "pending") { + return <Answered approval={approval} />; + } + const changed = JSON.stringify(edited) !== JSON.stringify(asked); + const set = (field: keyof Suggestion) => (value: string) => + setEdited((current) => ({ ...current, [field]: value })); + + return ( + <section + aria-label={s.title(bot.name)} + className="my-1 overflow-hidden rounded-2xl border border-line bg-panel shadow-sm animate-attention" + > + <p className="flex items-center gap-2.5 border-line border-b px-4 py-3 font-semibold text-sm"> + <span className="grid h-7 w-7 place-items-center rounded-full bg-accent/12 text-accent"> + <UserPlus aria-hidden size={15} /> + </span> + {s.title(bot.name)} + </p> + <div className="flex flex-col gap-3 px-4 py-3"> + {asked.reason && ( + <p className="text-ink-soft text-sm" data-selectable> + <span className="font-medium text-ink">{s.why}: </span> + {asked.reason} + </p> + )} + <div className="grid grid-cols-[1fr_12rem] gap-3"> + <TextField + label={s.name} + value={edited.name} + onChange={(event) => set("name")(event.target.value)} + /> + <SelectField + label={s.model} + value={edited.model ?? "default"} + onChange={(event) => set("model")(event.target.value)} + options={MODELS.map((value) => ({ value, label: t.chat.model.names[value] }))} + /> + </div> + <TextField + label={s.role} + value={edited.role} + onChange={(event) => set("role")(event.target.value)} + /> + <TextArea + label={s.instructions} + value={edited.instructions} + rows={5} + onChange={(event) => set("instructions")(event.target.value)} + /> + <p className="text-muted text-xs">{s.startsNow(bot.name)}</p> + </div> + <div className="border-line border-t bg-canvas/40 px-4 py-3"> + <label htmlFor={noteId} className="sr-only"> + {s.noteLabel(bot.name)} + </label> + <textarea + id={noteId} + rows={2} + value={note} + onChange={(event) => setNote(event.target.value)} + placeholder={s.notePlaceholder(bot.name)} + className="block w-full resize-none rounded-xl border border-line-strong bg-panel px-3 py-2 text-sm outline-none placeholder:text-muted focus:border-muted" + /> + <div className="mt-2.5 flex flex-wrap gap-2"> + <Button + variant="primary" + icon={Check} + disabled={busy || !edited.name.trim()} + onClick={() => answer(true, changed ? JSON.stringify(edited) : undefined)} + > + {s.create} + </Button> + <Button icon={Ban} disabled={busy} onClick={() => answer(false)}> + {s.decline} + </Button> + </div> + </div> + </section> + ); +} + +/** One line once answered; what was suggested stays a click away. */ +function Answered({ approval }: { approval: ApprovalItem }) { + const t = useT(); + const s = t.chat.suggestion; + const suggestion = suggestionOf(approval.input); + const name = suggestion.name || s.name; + const [Icon, text, tone] = + approval.status === "allowed" + ? [Check, s.created(name), "text-ok"] + : approval.status === "denied" + ? [Ban, s.declined(name), "text-danger"] + : [TimerOff, s.expired(name), "text-quiet"]; + return ( + <details className="group"> + <summary className="flex min-w-0 cursor-default items-center gap-2 rounded-lg px-1.5 py-1 text-sm hover:bg-sunken"> + <Icon aria-hidden size={14} className={`shrink-0 ${tone}`} /> + <span className="shrink-0 font-medium">{text}</span> + {approval.note && ( + <span className="truncate text-muted text-xs">{`“${approval.note}”`}</span> + )} + <ChevronRight + aria-hidden + size={13} + className="shrink-0 text-muted transition-transform group-open:rotate-90" + /> + </summary> + <dl + className="mt-1.5 ml-6 grid grid-cols-[auto_1fr] gap-x-3 gap-y-1 rounded-xl border border-line bg-panel px-4 py-3 text-sm" + data-selectable + > + <dt className="text-muted">{s.role}</dt> + <dd>{suggestion.role}</dd> + <dt className="text-muted">{s.model}</dt> + <dd>{t.chat.model.names[suggestion.model ?? "default"]}</dd> + <dt className="text-muted">{s.instructions}</dt> + <dd className="whitespace-pre-wrap">{suggestion.instructions}</dd> + </dl> + </details> + ); +} diff --git a/app/src/features/chat/ToolLines.tsx b/app/src/features/chat/ToolLines.tsx index 1cbecb96..dcc8a53a 100644 --- a/app/src/features/chat/ToolLines.tsx +++ b/app/src/features/chat/ToolLines.tsx @@ -9,10 +9,12 @@ import { FileText, Globe, ListChecks, + ListTodo, LoaderCircle, type LucideIcon, Send, SquareTerminal, + UserPlus, Users, Wrench, X, @@ -20,6 +22,7 @@ import { import { useState } from "react"; import { useT } from "../../i18n"; import type { ChatItem, ToolItem } from "../../lib/protocol.gen"; +import { useArrival } from "../../ui/motion"; const ICONS: Record<string, LucideIcon> = { Bash: SquareTerminal, @@ -34,9 +37,11 @@ const ICONS: Record<string, LucideIcon> = { WebFetch: Globe, WebSearch: Globe, TodoWrite: ListChecks, + ExitPlanMode: ListTodo, Task: Users, Agent: Users, send_message: Send, + suggest_bot: UserPlus, }; /** `mcp__botloft__send_message` reads as `send_message`. */ @@ -71,20 +76,21 @@ function Status({ status }: { status: ToolItem["status"] }) { } } -function ToolLine({ tool }: { tool: ToolItem }) { +function ToolLine({ tool, createdAt }: { tool: ToolItem; createdAt: number }) { const t = useT(); const [open, setOpen] = useState(false); + const arrival = useArrival(createdAt); const label = toolLabel(tool.name); const Icon = ICONS[label] ?? Wrench; const block = - "max-h-64 overflow-auto whitespace-pre-wrap break-all rounded-[3px] border border-line bg-sunken px-2.5 py-1.5 font-mono text-xs leading-relaxed"; + "max-h-64 overflow-auto whitespace-pre-wrap break-all rounded-lg border border-line bg-sunken px-2.5 py-1.5 font-mono text-xs leading-relaxed"; return ( - <li> + <li className={arrival}> <button type="button" aria-expanded={open} onClick={() => setOpen(!open)} - className="group flex w-full min-w-0 items-center gap-2 rounded-[3px] px-1.5 py-1 text-left text-sm hover:bg-sunken" + className="group flex w-full min-w-0 items-center gap-2 rounded-lg px-1.5 py-1 text-left text-sm transition-colors hover:bg-sunken" > <Icon aria-hidden size={14} className="shrink-0 text-muted" /> <span className="shrink-0 font-medium">{label}</span> @@ -99,7 +105,7 @@ function ToolLine({ tool }: { tool: ToolItem }) { /> </button> {open && ( - <div className="mt-1 mb-2 ml-7 flex flex-col gap-1.5" data-selectable> + <div className="mt-1 mb-2 ml-7 flex animate-rise flex-col gap-1.5" data-selectable> <p className="text-muted text-xs">{t.chat.tools.input}</p> <pre className={block}>{pretty(tool.input)}</pre> {tool.output !== null && ( @@ -121,7 +127,9 @@ export function ToolLines({ items }: { items: ChatItem[] }) { return ( <ul aria-label={t.chat.tools.label} className="-mx-1.5 flex flex-col"> {items.map((item) => - item.body.kind === "tool" ? <ToolLine key={item.id} tool={item.body} /> : null, + item.body.kind === "tool" ? ( + <ToolLine key={item.id} tool={item.body} createdAt={item.createdAt} /> + ) : null, )} </ul> ); diff --git a/app/src/features/chat/models.test.tsx b/app/src/features/chat/models.test.tsx new file mode 100644 index 00000000..50bf6038 --- /dev/null +++ b/app/src/features/chat/models.test.tsx @@ -0,0 +1,94 @@ +import { act, cleanup, fireEvent, screen, within } from "@testing-library/react"; +import { afterEach, describe, expect, test } from "vitest"; +import { FakeBotloft } from "../../lib/fake"; +import { crewOpened, openBot, renderApp } from "../../test/app"; + +afterEach(cleanup); + +/** A crew "Ops" with @scout, open on its chat. */ +async function openScout(setup?: (fake: FakeBotloft, botId: string) => void) { + const fake = new FakeBotloft(); + const ops = fake.addCrew("Ops"); + const scout = fake.addBot(ops.id, "Scout", "Finds sources"); + fake.setBotState(scout.id, "idle"); + setup?.(fake, scout.id); + renderApp(fake); + await crewOpened("Ops"); + openBot("Scout"); + await screen.findByRole("list", { name: "Messages" }); + return { fake, scout }; +} + +const picker = () => screen.getByRole("button", { name: /^Model: / }); +const modelCalls = (fake: FakeBotloft) => + fake.calls.filter((call) => call.method === "bots.setModel"); + +function choose(name: RegExp) { + fireEvent.click(picker()); + const menu = screen.getByRole("menu", { name: "Model" }); + fireEvent.click(within(menu).getByRole("menuitemradio", { name })); +} + +describe("models", () => { + test("a bot runs on the plan's default until the owner picks a model", async () => { + const { fake, scout } = await openScout(); + expect(picker().getAttribute("aria-label")).toBe("Model: Default"); + fireEvent.click(picker()); + const menu = screen.getByRole("menu", { name: "Model" }); + const plan = within(menu).getByRole("menuitemradio", { name: /Plan default/ }); + expect(plan.getAttribute("aria-checked")).toBe("true"); + expect(within(menu).getByText(/use up your plan's limit faster/)).toBeDefined(); + fireEvent.click(within(menu).getByRole("menuitemradio", { name: /Haiku/ })); + + await screen.findByRole("button", { name: "Model: Haiku" }); + expect(modelCalls(fake).at(-1)?.params).toEqual({ botId: scout.id, model: "haiku" }); + expect(screen.queryByText(/switches to/)).toBeNull(); + }); + + test("the plan's default is named once Claude Code reported it", async () => { + await openScout((fake, botId) => { + fake.bot(botId).modelInUse = "claude-opus-5-5"; + }); + expect(picker().getAttribute("aria-label")).toBe("Model: Opus 5.5"); + fireEvent.click(picker()); + expect(screen.getByText("Scout uses your plan's default model, now Opus 5.5")).toBeDefined(); + }); + + test("a busy bot changes model when it finishes what it is doing", async () => { + const { fake, scout } = await openScout(); + act(() => fake.setBotState(scout.id, "busy")); + choose(/Sonnet/); + expect( + await screen.findByText("Scout switches to Sonnet when it finishes what it's doing."), + ).toBeDefined(); + }); + + test("a model the plan does not have is told in the owner's words", async () => { + const { fake, scout } = await openScout(); + act(() => { + fake.chat.add(scout.id, { + kind: "notice", + level: "error", + code: "model_unavailable", + text: "Claude Code could not use this bot's model.", + }); + }); + expect(await screen.findByText(/may not be on your Claude plan/)).toBeDefined(); + }); + + test("a new bot can start on a chosen model", async () => { + const fake = new FakeBotloft(); + fake.addCrew("Ops"); + renderApp(fake); + await crewOpened("Ops"); + const [headerButton] = await screen.findAllByRole("button", { name: "New bot" }); + fireEvent.click(headerButton as HTMLElement); + const dialog = screen.getByRole("dialog", { name: "New bot" }); + fireEvent.change(within(dialog).getByLabelText("Name"), { target: { value: "Writer" } }); + fireEvent.change(within(dialog).getByLabelText("Model"), { target: { value: "sonnet" } }); + fireEvent.click(within(dialog).getByRole("button", { name: "Create bot" })); + await screen.findByRole("button", { name: "Model: Sonnet" }); + const create = fake.calls.find((call) => call.method === "bots.create"); + expect(create?.params).toMatchObject({ name: "Writer", model: "sonnet" }); + }); +}); diff --git a/app/src/features/chat/modes.test.tsx b/app/src/features/chat/modes.test.tsx new file mode 100644 index 00000000..9cfff293 --- /dev/null +++ b/app/src/features/chat/modes.test.tsx @@ -0,0 +1,113 @@ +import { act, cleanup, fireEvent, screen, within } from "@testing-library/react"; +import { afterEach, describe, expect, test } from "vitest"; +import { FakeBotloft } from "../../lib/fake"; +import { crewOpened, openBot, renderApp } from "../../test/app"; + +afterEach(cleanup); + +/** A crew "Ops" with @scout, open on its chat. */ +async function openScout() { + const fake = new FakeBotloft(); + const ops = fake.addCrew("Ops"); + const scout = fake.addBot(ops.id, "Scout", "Finds sources"); + fake.setBotState(scout.id, "idle"); + renderApp(fake); + await crewOpened("Ops"); + openBot("Scout"); + await screen.findByRole("list", { name: "Messages" }); + return { fake, scout }; +} + +const picker = () => screen.getByRole("button", { name: /^Mode: / }); +const modeCalls = (fake: FakeBotloft) => + fake.calls.filter((call) => call.method === "bots.setPermissionMode"); + +function choose(name: RegExp) { + fireEvent.click(picker()); + const menu = screen.getByRole("menu", { name: "Mode" }); + fireEvent.click(within(menu).getByRole("menuitemradio", { name: name })); +} + +describe("permission modes", () => { + test("a bot starts in Manual and the owner picks another mode", async () => { + const { fake, scout } = await openScout(); + expect(picker().getAttribute("aria-label")).toBe("Mode: Manual"); + fireEvent.click(picker()); + const menu = screen.getByRole("menu", { name: "Mode" }); + const manual = within(menu).getByRole("menuitemradio", { name: /Manual/ }); + expect(manual.getAttribute("aria-checked")).toBe("true"); + fireEvent.click(within(menu).getByRole("menuitemradio", { name: /Accept edits/ })); + + await screen.findByRole("button", { name: "Mode: Accept edits" }); + expect(screen.queryByRole("menu", { name: "Mode" })).toBeNull(); + expect(modeCalls(fake).at(-1)?.params).toEqual({ botId: scout.id, mode: "accept_edits" }); + // Nothing was running: no note about waiting. + expect(screen.queryByText(/switches to/)).toBeNull(); + }); + + test("bypassing permissions asks first, then marks the bot in red", async () => { + const { fake } = await openScout(); + choose(/Bypass permissions/); + const dialog = screen.getByRole("dialog", { name: "Let Scout do anything without asking?" }); + expect(within(dialog).getByText(/other bots' files/)).toBeDefined(); + fireEvent.click(within(dialog).getByRole("button", { name: "Cancel" })); + expect(modeCalls(fake)).toHaveLength(0); + expect(screen.queryByText("Asks nothing")).toBeNull(); + + choose(/Bypass permissions/); + fireEvent.click(screen.getByRole("button", { name: "Turn on" })); + await screen.findByRole("button", { name: "Mode: Bypass permissions" }); + expect(screen.getByText("Asks nothing")).toBeDefined(); + expect(modeCalls(fake).at(-1)?.params).toMatchObject({ mode: "bypass_permissions" }); + }); + + test("a busy bot changes mode when it finishes what it is doing", async () => { + const { fake, scout } = await openScout(); + act(() => fake.setBotState(scout.id, "busy")); + choose(/Plan/); + expect( + await screen.findByText("Scout switches to Plan when it finishes what it's doing."), + ).toBeDefined(); + act(() => fake.setBotState(scout.id, "idle")); + expect(screen.queryByText(/switches to Plan/)).toBeNull(); + }); +}); + +describe("plans", () => { + const PLAN = "## Cache the report\n\n1. Save it once a week"; + + function askToGoAhead(fake: FakeBotloft, botId: string) { + act(() => { + fake.chat.ask(botId, "ExitPlanMode", "Cache the report", JSON.stringify({ plan: PLAN })); + }); + return screen.getByRole("region", { name: "Scout made a plan and wants to go ahead" }); + } + + test("the plan shows in full and approving it lets the bot go ahead", async () => { + const { fake, scout } = await openScout(); + await act(() => fake.call("bots.setPermissionMode", { botId: scout.id, mode: "plan" })); + const card = askToGoAhead(fake, scout.id); + expect(within(card).getByRole("heading", { name: "Cache the report" })).toBeDefined(); + expect(within(card).getByText("Save it once a week")).toBeDefined(); + + fireEvent.click(within(card).getByRole("button", { name: "Approve plan" })); + expect(await screen.findByText("You approved the plan")).toBeDefined(); + const answer = fake.calls.find((call) => call.method === "approvals.answer"); + expect(answer?.params).toMatchObject({ allow: true }); + // As Claude Code does, the bot left plan mode. + expect(await screen.findByRole("button", { name: "Mode: Manual" })).toBeDefined(); + }); + + test("keeping on planning sends back what should change", async () => { + const { fake, scout } = await openScout(); + const card = askToGoAhead(fake, scout.id); + fireEvent.change(within(card).getByLabelText("What Scout should change in the plan"), { + target: { value: "Keep the cache in memory" }, + }); + fireEvent.click(within(card).getByRole("button", { name: "Keep planning" })); + expect(await screen.findByText("You asked for changes to the plan")).toBeDefined(); + expect(screen.getByText("“Keep the cache in memory”")).toBeDefined(); + const answer = fake.calls.find((call) => call.method === "approvals.answer"); + expect(answer?.params).toMatchObject({ allow: false, note: "Keep the cache in memory" }); + }); +}); diff --git a/app/src/features/chat/useAnswer.ts b/app/src/features/chat/useAnswer.ts new file mode 100644 index 00000000..1f249343 --- /dev/null +++ b/app/src/features/chat/useAnswer.ts @@ -0,0 +1,28 @@ +import { useState } from "react"; +import type { ApprovalItem } from "../../lib/protocol.gen"; +import { useApi } from "../../store/context"; +import { attempt } from "../../ui/toast"; + +/** + * Answering a request; the note goes to the bot on a denial. `input` is a + * bot suggestion as the owner changed it (spec 10.2). + */ +export function useAnswer(approval: ApprovalItem, failed: { allow: string; deny: string }) { + const api = useApi(); + const [note, setNote] = useState(""); + const [busy, setBusy] = useState(false); + const answer = async (allow: boolean, input?: string) => { + setBusy(true); + const trimmed = note.trim(); + await attempt(allow ? failed.allow : failed.deny, () => + api.call("approvals.answer", { + approvalId: approval.approvalId, + allow, + ...(allow || !trimmed ? {} : { note: trimmed }), + ...(allow && input !== undefined ? { input } : {}), + }), + ); + setBusy(false); + }; + return { note, setNote, busy, answer }; +} diff --git a/app/src/features/crews/CrewBots.tsx b/app/src/features/crews/CrewBots.tsx index 22fdfbf1..fb35bd5e 100644 --- a/app/src/features/crews/CrewBots.tsx +++ b/app/src/features/crews/CrewBots.tsx @@ -3,8 +3,9 @@ import { useT } from "../../i18n"; import type { Bot, Crew } from "../../lib/protocol.gen"; import { useApp } from "../../store/context"; import { Button } from "../../ui/Button"; -import { BotAvatar } from "../bots/BotAvatar"; +import { BotAvatar, moodOf } from "../bots/BotAvatar"; import { BotStateBadge } from "../bots/BotStateBadge"; +import { ChiefBadge, isChief } from "../bots/ChiefBadge"; /** The crew's bots as cards; a card opens the bot. */ export function CrewBots({ crew, bots, onNewBot }: { crew: Crew; bots: Bot[]; onNewBot(): void }) { @@ -12,7 +13,7 @@ export function CrewBots({ crew, bots, onNewBot }: { crew: Crew; bots: Bot[]; on const selectBot = useApp((state) => state.selectBot); if (bots.length === 0) { return ( - <div className="border border-line border-dashed px-6 py-10 text-center"> + <div className="rounded-2xl border border-line border-dashed px-6 py-10 text-center"> <p className="font-medium">{t.crews.bots.empty(crew.name)}</p> <p className="mt-1 text-muted text-sm">{t.crews.bots.emptyHint}</p> <Button className="mt-4" variant="primary" icon={Plus} onClick={onNewBot}> @@ -28,12 +29,15 @@ export function CrewBots({ crew, bots, onNewBot }: { crew: Crew; bots: Bot[]; on <button type="button" onClick={() => selectBot(bot.id)} - className="flex h-full w-full flex-col gap-2 border border-line bg-panel p-3 text-left hover:border-line-strong" + className="flex h-full w-full flex-col gap-2 rounded-xl border border-line bg-panel p-3.5 text-left transition-[border-color,transform,box-shadow] duration-200 hover:-translate-y-0.5 hover:border-line-strong hover:shadow-sm" > <div className="flex w-full items-center gap-2.5"> - <BotAvatar color={bot.color} size={32} /> + <BotAvatar color={bot.color} size={32} mood={moodOf(bot, crew.paused)} /> <div className="min-w-0 flex-1"> - <p className="truncate font-semibold">{bot.name}</p> + <p className="flex items-center gap-1.5"> + <span className="truncate font-semibold">{bot.name}</span> + {isChief(bot, crew) && <ChiefBadge crew={crew} compact />} + </p> <p className="truncate font-mono text-muted text-xs">@{bot.handle}</p> </div> </div> diff --git a/app/src/features/crews/CrewDialog.tsx b/app/src/features/crews/CrewDialog.tsx index c73a5f92..1703010a 100644 --- a/app/src/features/crews/CrewDialog.tsx +++ b/app/src/features/crews/CrewDialog.tsx @@ -1,19 +1,27 @@ import { type FormEvent, useState } from "react"; import { useT } from "../../i18n"; import { errorText } from "../../lib/api"; -import { type Crew, FIELD_LIMITS } from "../../lib/protocol.gen"; +import { type BotModel, type Crew, FIELD_LIMITS } from "../../lib/protocol.gen"; import { useApi, useApp } from "../../store/context"; import { Button } from "../../ui/Button"; import { Dialog } from "../../ui/Dialog"; -import { TextField } from "../../ui/Field"; +import { SelectField, TextArea, TextField } from "../../ui/Field"; +import { WorkFolderField } from "./WorkFolderField"; -/** Creates a crew, or renames `crew`. */ +const MODELS: BotModel[] = ["default", "fable", "opus", "sonnet", "haiku"]; + +/** Creates a crew with its chief, or renames `crew`. */ export function CrewDialog({ crew, onClose }: { crew?: Crew; onClose(): void }) { const t = useT(); const api = useApi(); const putCrew = useApp((state) => state.putCrew); const selectCrew = useApp((state) => state.selectCrew); const [name, setName] = useState(crew?.name ?? ""); + const [folder, setFolder] = useState<string | null>(null); + const [goal, setGoal] = useState(""); + const [chiefModel, setChiefModel] = useState<BotModel>("default"); + const selectBot = useApp((state) => state.selectBot); + const putBot = useApp((state) => state.putBot); const [error, setError] = useState<string | null>(null); const [busy, setBusy] = useState(false); @@ -22,12 +30,31 @@ export function CrewDialog({ crew, onClose }: { crew?: Crew; onClose(): void }) setBusy(true); setError(null); try { + const d = t.crews.dialog; const saved = crew ? await api.call("crews.rename", { crewId: crew.id, name }) - : await api.call("crews.create", { name }); + : await api.call("crews.create", { + name, + ...(folder && { workFolder: folder }), + // Every new crew starts with its chief (spec 10.2). + lead: { + name: d.chiefName, + role: d.chiefRole, + instructions: goal.trim(), + ...(chiefModel !== "default" && { model: chiefModel }), + }, + }); putCrew(saved); if (!crew) { selectCrew(saved.id); + // Straight to the chief's chat, to say what the crew should do. + const bots = await api.call("bots.list", { crewId: saved.id }); + for (const bot of bots) { + putBot(bot); + } + if (saved.leadBotId) { + selectBot(saved.leadBotId); + } } onClose(); } catch (failure) { @@ -61,6 +88,26 @@ export function CrewDialog({ crew, onClose }: { crew?: Crew; onClose(): void }) autoFocus required /> + {!crew && ( + <> + <TextArea + label={t.crews.dialog.goal} + value={goal} + rows={3} + max={FIELD_LIMITS.instructions} + onChange={(event) => setGoal(event.target.value)} + placeholder={t.crews.dialog.goalPlaceholder} + hint={t.crews.dialog.goalHint} + /> + <WorkFolderField value={folder} onChange={setFolder} /> + <SelectField + label={t.crews.dialog.chiefModel} + value={chiefModel} + onChange={(event) => setChiefModel(event.target.value as BotModel)} + options={MODELS.map((value) => ({ value, label: t.chat.model.names[value] }))} + /> + </> + )} {error && ( <p role="alert" className="text-danger text-sm"> {error} diff --git a/app/src/features/crews/CrewView.tsx b/app/src/features/crews/CrewView.tsx index 22d63e04..ce4fb906 100644 --- a/app/src/features/crews/CrewView.tsx +++ b/app/src/features/crews/CrewView.tsx @@ -1,8 +1,18 @@ -import { Archive, Ellipsis, FolderOpen, Pause, Pencil, Play, Plus } from "lucide-react"; +import { + Archive, + Ellipsis, + Folder, + FolderInput, + FolderOpen, + Pause, + Pencil, + Play, + Plus, +} from "lucide-react"; import { useState } from "react"; import { useShallow } from "zustand/react/shallow"; import { useT } from "../../i18n"; -import type { Bot, Crew } from "../../lib/protocol.gen"; +import type { Crew } from "../../lib/protocol.gen"; import { botsOf } from "../../store/app"; import { useApi, useApp, useHost } from "../../store/context"; import { Button } from "../../ui/Button"; @@ -17,13 +27,7 @@ import { TaskList } from "../tasks/TaskList"; import { CrewBots } from "./CrewBots"; import { CrewDialog } from "./CrewDialog"; -/** The crew's `shared` folder, next to its bots' workspaces (spec 5). */ -export function sharedFolder(bots: Bot[]): string | null { - const workspace = bots[0]?.workspace; - return workspace ? workspace.replace(/[\\/][^\\/]+$/, "\\shared") : null; -} - -type Open = "bot" | "rename" | "archive" | null; +type Open = "bot" | "rename" | "archive" | { move: string } | null; type Pane = "bots" | "timeline" | "tasks"; export function CrewView({ crew }: { crew: Crew }) { @@ -35,7 +39,6 @@ export function CrewView({ crew }: { crew: Crew }) { const bots = useApp(useShallow((state) => botsOf(state, crew.id))); const [open, setOpen] = useState<Open>(null); const [pane, setPane] = useState<Pane>("bots"); - const shared = sharedFolder(bots); const close = () => setOpen(null); const tabs: Tab<Pane>[] = [ { id: "bots", label: words.tabs.bots }, @@ -43,6 +46,15 @@ export function CrewView({ crew }: { crew: Crew }) { { id: "tasks", label: words.tabs.tasks }, ]; + const openFolder = () => attempt(words.failed.openFolder, () => host.openPath(crew.workFolder)); + const pickFolder = () => + attempt(words.failed.changeFolder, async () => { + const folder = await host.pickFolder(t.crews.dialog.pickTitle, crew.workFolder); + if (folder && folder !== crew.workFolder) { + setOpen({ move: folder }); + } + }); + const setPaused = (paused: boolean) => attempt(paused ? words.failed.pause : words.failed.resume, async () => putCrew(await api.call("crews.setPaused", { crewId: crew.id, paused })), @@ -53,9 +65,21 @@ export function CrewView({ crew }: { crew: Crew }) { <header className="flex items-center gap-3 border-line border-b px-5 py-3.5"> <div className="min-w-0 flex-1"> <h1 className="truncate font-semibold text-xl tracking-tight">{crew.name}</h1> - <p className="mt-0.5 text-muted text-sm"> - {words.bots(bots.length)} - {crew.paused && ` · ${words.pausedNote}`} + <p className="mt-0.5 flex min-w-0 items-center gap-1.5 text-muted text-sm"> + <span className="shrink-0"> + {words.bots(bots.length)} + {crew.paused && ` · ${words.pausedNote}`} + </span> + <span aria-hidden>·</span> + <button + type="button" + onClick={openFolder} + title={words.openFolder} + className="flex min-w-0 items-center gap-1 rounded-md px-1 hover:bg-sunken hover:text-ink" + > + <Folder aria-hidden size={13} className="shrink-0" /> + <span className="truncate">{words.folder(crew.workFolder)}</span> + </button> </p> </div> <Button variant="primary" icon={Plus} onClick={() => setOpen("bot")}> @@ -75,13 +99,8 @@ export function CrewView({ crew }: { crew: Crew }) { icon={Ellipsis} items={[ { label: t.crews.rename, icon: Pencil, onSelect: () => setOpen("rename") }, - { - label: words.openShared, - icon: FolderOpen, - disabled: !shared, - onSelect: () => - shared && attempt(words.failed.openFolder, () => host.openPath(shared)), - }, + { label: words.openFolder, icon: FolderOpen, onSelect: openFolder }, + { label: words.changeFolder, icon: FolderInput, onSelect: pickFolder }, { label: words.archive, icon: Archive, @@ -127,6 +146,22 @@ export function CrewView({ crew }: { crew: Crew }) { {open === "bot" && <BotDialog crewId={crew.id} onClose={close} />} {open === "rename" && <CrewDialog crew={crew} onClose={close} />} + {typeof open === "object" && open !== null && ( + <Confirm + title={words.moveTitle(crew.name)} + confirmLabel={words.move} + onClose={close} + onConfirm={() => + attempt(words.failed.changeFolder, async () => + putCrew( + await api.call("crews.setWorkFolder", { crewId: crew.id, workFolder: open.move }), + ), + ) + } + > + {words.moveBody(open.move)} + </Confirm> + )} {open === "archive" && ( <Confirm title={words.archiveTitle(crew.name)} diff --git a/app/src/features/crews/Sidebar.tsx b/app/src/features/crews/Sidebar.tsx index eb2239bb..1d894481 100644 --- a/app/src/features/crews/Sidebar.tsx +++ b/app/src/features/crews/Sidebar.tsx @@ -7,8 +7,11 @@ import type { Activity, Bot, Crew } from "../../lib/protocol.gen"; import { botsOf, crewList } from "../../store/app"; import { useApp } from "../../store/context"; import { Button } from "../../ui/Button"; -import { BotAvatar } from "../bots/BotAvatar"; +import { APP_OPENED } from "../../ui/motion"; +import { AccountArea } from "../account/AccountArea"; +import { BotAvatar, moodOf } from "../bots/BotAvatar"; import { BotStateBadge, stateView } from "../bots/BotStateBadge"; +import { ChiefBadge, isChief } from "../bots/ChiefBadge"; import { CrewDialog } from "./CrewDialog"; /** Crews as sections and their bots as conversations (spec 15.1). */ @@ -17,34 +20,34 @@ export function Sidebar() { const crews = useApp(useShallow(crewList)); const [creating, setCreating] = useState(false); return ( - <nav - aria-label={t.crews.sidebar.label} - className="flex w-72 shrink-0 flex-col border-line border-r bg-panel" - > - <div className="flex h-10 shrink-0 items-center justify-between pr-1.5 pl-4"> - <h2 className="font-semibold text-muted text-xs uppercase tracking-[0.12em]"> - {t.crews.sidebar.label} - </h2> - <Button - variant="ghost" - size="sm" - icon={Plus} - label={t.crews.newCrew} - onClick={() => setCreating(true)} - /> - </div> - <ul className="min-h-0 flex-1 overflow-y-auto pb-3"> - {crews.map((crew) => ( - <CrewEntry key={crew.id} crew={crew} /> - ))} - </ul> + <div className="flex w-72 shrink-0 flex-col border-line border-r bg-panel"> + <nav aria-label={t.crews.sidebar.label} className="flex min-h-0 flex-1 flex-col"> + <div className="flex h-10 shrink-0 items-center justify-between pr-1.5 pl-4"> + <h2 className="font-semibold text-muted text-xs uppercase tracking-[0.12em]"> + {t.crews.sidebar.label} + </h2> + <Button + variant="ghost" + size="sm" + icon={Plus} + label={t.crews.newCrew} + onClick={() => setCreating(true)} + /> + </div> + <ul className="min-h-0 flex-1 overflow-y-auto px-2 pb-3"> + {crews.map((crew) => ( + <CrewEntry key={crew.id} crew={crew} /> + ))} + </ul> + </nav> + <AccountArea /> {creating && <CrewDialog onClose={() => setCreating(false)} />} - </nav> + </div> ); } -const row = "relative flex w-full items-center text-left hover:bg-sunken"; -const marker = "before:absolute before:inset-y-0 before:left-0 before:w-[3px] before:bg-accent"; +const row = + "relative flex w-full items-center rounded-lg text-left transition-colors duration-150 hover:bg-sunken"; function CrewEntry({ crew }: { crew: Crew }) { const t = useT(); @@ -58,7 +61,7 @@ function CrewEntry({ crew }: { crew: Crew }) { type="button" aria-current={selected ? "page" : undefined} onClick={() => selectCrew(crew.id)} - className={`${row} h-8 gap-2 pr-3 pl-4 font-semibold text-sm ${selected ? `bg-sunken ${marker}` : ""}`} + className={`${row} h-8 gap-2 px-2.5 font-semibold text-sm ${selected ? "bg-sunken" : ""}`} > <span className="min-w-0 flex-1 truncate">{crew.name}</span> {crew.paused && ( @@ -83,18 +86,21 @@ function Conversation({ bot, crew }: { bot: Bot; crew: Crew }) { const selectBot = useApp((state) => state.selectBot); const activity = bot.lastActivity; return ( - <li> + <li className={bot.createdAt > APP_OPENED ? "animate-rise" : undefined}> <button type="button" aria-current={selected ? "page" : undefined} aria-label={`${bot.name}, ${stateView(bot, crew.paused).label}`} onClick={() => selectBot(bot.id)} - className={`${row} gap-2.5 py-2 pr-3 pl-4 ${selected ? `bg-sunken ${marker}` : ""}`} + className={`${row} gap-2.5 px-2.5 py-2 ${selected ? "bg-sunken" : ""}`} > - <BotAvatar color={bot.color} size={32} /> + <BotAvatar color={bot.color} size={32} mood={moodOf(bot, crew.paused)} /> <span className="min-w-0 flex-1"> <span className="flex items-baseline gap-2"> - <span className="min-w-0 flex-1 truncate font-medium text-sm">{bot.name}</span> + <span className="flex min-w-0 flex-1 items-center gap-1"> + <span className="truncate font-medium text-sm">{bot.name}</span> + {isChief(bot, crew) && <ChiefBadge crew={crew} compact />} + </span> {activity && ( <time className="shrink-0 text-muted text-xs" diff --git a/app/src/features/crews/WorkFolderField.tsx b/app/src/features/crews/WorkFolderField.tsx new file mode 100644 index 00000000..370d22ad --- /dev/null +++ b/app/src/features/crews/WorkFolderField.tsx @@ -0,0 +1,58 @@ +// Where a new crew works (spec 5): a folder the owner picks with Windows' +// folder picker, or a new one inside Botloft. + +import { Folder, X } from "lucide-react"; +import { useT } from "../../i18n"; +import { useHost } from "../../store/context"; +import { Button } from "../../ui/Button"; +import { attempt } from "../../ui/toast"; + +export function WorkFolderField({ + value, + onChange, +}: { + value: string | null; + onChange(folder: string | null): void; +}) { + const words = useT().crews.dialog; + const failed = useT().crews.view.failed.changeFolder; + const host = useHost(); + + const pick = () => + attempt(failed, async () => { + const folder = await host.pickFolder(words.pickTitle, value ?? undefined); + if (folder) { + onChange(folder); + } + }); + + return ( + <fieldset className="flex flex-col gap-1"> + <legend className="mb-1 font-medium text-ink-soft text-sm">{words.folder}</legend> + <div className="flex items-center gap-2"> + <p + className="flex h-8 min-w-0 flex-1 items-center gap-2 rounded-lg border border-line-strong bg-canvas px-2.5 text-sm" + title={value ?? undefined} + > + <Folder aria-hidden size={15} className="shrink-0 text-muted" /> + <span className={`truncate ${value ? "text-ink" : "text-muted"}`}> + {value ?? words.folderDefault} + </span> + </p> + {value && ( + <button + type="button" + aria-label={words.useDefault} + title={words.useDefault} + onClick={() => onChange(null)} + className="grid h-8 w-8 shrink-0 place-items-center rounded-lg text-muted hover:bg-sunken hover:text-ink" + > + <X aria-hidden size={15} /> + </button> + )} + <Button onClick={pick}>{words.chooseFolder}</Button> + </div> + <p className="text-muted text-xs">{words.folderHint}</p> + </fieldset> + ); +} diff --git a/app/src/features/crews/chief.test.tsx b/app/src/features/crews/chief.test.tsx new file mode 100644 index 00000000..a7116b4f --- /dev/null +++ b/app/src/features/crews/chief.test.tsx @@ -0,0 +1,127 @@ +import { act, cleanup, fireEvent, screen, within } from "@testing-library/react"; +import { afterEach, describe, expect, test } from "vitest"; +import { FakeBotloft } from "../../lib/fake"; +import { SUGGEST_TOOL } from "../../lib/fakeChat"; +import { crewOpened, openBot, renderApp, sidebar } from "../../test/app"; + +afterEach(cleanup); + +const DESIGNER = { + name: "Designer", + role: "Draws each page", + instructions: "Design the pages in shared/design.", + model: "sonnet", + reason: "The site needs a look before anyone builds it.", +}; + +/** A crew "Site" with its chief, open on the chief's chat. */ +async function openChief() { + const fake = new FakeBotloft(); + const site = fake.call("crews.create", { + name: "Site", + lead: { name: "Chief", role: "Leads the crew", instructions: "Build the site" }, + }); + const crew = await site; + const chiefId = crew.leadBotId as string; + fake.setBotState(chiefId, "idle"); + renderApp(fake); + await crewOpened("Site"); + openBot("Chief"); + await screen.findByRole("list", { name: "Messages" }); + return { fake, crew, chiefId }; +} + +function suggest(fake: FakeBotloft, chiefId: string) { + act(() => { + fake.chat.ask(chiefId, SUGGEST_TOOL, "Designer", JSON.stringify(DESIGNER)); + }); + return screen.getByRole("region", { name: "Chief suggests a new bot" }); +} + +const answer = (fake: FakeBotloft) => + fake.calls.find((call) => call.method === "approvals.answer")?.params; + +describe("the crew's chief", () => { + test("a new crew starts with a chief, from the crew's goal", async () => { + const fake = new FakeBotloft(); + fake.addCrew("Ops"); + renderApp(fake); + await crewOpened("Ops"); + fireEvent.click(screen.getByRole("button", { name: "New crew" })); + const dialog = screen.getByRole("dialog", { name: "New crew" }); + fireEvent.change(within(dialog).getByLabelText("Name"), { target: { value: "Bakery" } }); + fireEvent.change(within(dialog).getByLabelText("What is this crew for?"), { + target: { value: "Build my bakery's website" }, + }); + fireEvent.change(within(dialog).getByLabelText("Chief's model"), { + target: { value: "opus" }, + }); + fireEvent.click(within(dialog).getByRole("button", { name: "Create crew" })); + + expect(await screen.findByRole("heading", { level: 1, name: "Chief" })).toBeDefined(); + const create = fake.calls.find((call) => call.method === "crews.create"); + expect(create?.params).toMatchObject({ + name: "Bakery", + lead: { name: "Chief", instructions: "Build my bakery's website", model: "opus" }, + }); + // The crown, in the header and the conversation list. + expect(screen.getAllByTitle(/^Leads Bakery/)).toHaveLength(2); + }); + + test("the owner creates the bot the chief suggests", async () => { + const { fake, chiefId } = await openChief(); + const card = suggest(fake, chiefId); + expect(within(card).getByText(DESIGNER.reason)).toBeDefined(); + expect((within(card).getByLabelText("Name") as HTMLInputElement).value).toBe("Designer"); + fireEvent.click(within(card).getByRole("button", { name: "Create bot" })); + + expect(await screen.findByText("You created Designer")).toBeDefined(); + expect(answer(fake)).toEqual({ approvalId: expect.any(String), allow: true }); + expect(within(sidebar()).getByRole("button", { name: /^Designer/ })).toBeDefined(); + }); + + test("the owner can change the suggestion before creating it", async () => { + const { fake, chiefId } = await openChief(); + const card = suggest(fake, chiefId); + fireEvent.change(within(card).getByLabelText("Name"), { target: { value: "Illustrator" } }); + fireEvent.change(within(card).getByLabelText("Model"), { target: { value: "haiku" } }); + fireEvent.click(within(card).getByRole("button", { name: "Create bot" })); + + expect(await screen.findByText("You created Illustrator")).toBeDefined(); + const sent = answer(fake) as { input: string }; + expect(JSON.parse(sent.input)).toMatchObject({ name: "Illustrator", model: "haiku" }); + const illustrator = [...fake.bots.values()].find((bot) => bot.name === "Illustrator"); + expect(illustrator?.model).toBe("haiku"); + }); + + test("saying no tells the chief why", async () => { + const { fake, chiefId } = await openChief(); + const card = suggest(fake, chiefId); + fireEvent.change(within(card).getByLabelText("What to tell Chief if you say no"), { + target: { value: "The writer can do it" }, + }); + fireEvent.click(within(card).getByRole("button", { name: "Not now" })); + + expect(await screen.findByText("You said no to Designer")).toBeDefined(); + expect(answer(fake)).toMatchObject({ allow: false, note: "The writer can do it" }); + expect([...fake.bots.values()].some((bot) => bot.name === "Designer")).toBe(false); + }); + + test("the owner moves the chief to another bot", async () => { + const { fake, crew } = await openChief(); + act(() => { + fake.setBotState(fake.addBot(crew.id, "Writer").id, "idle"); + }); + openBot("Writer"); + await screen.findByRole("heading", { level: 1, name: "Writer" }); + fireEvent.click(screen.getByRole("button", { name: "More bot actions" })); + fireEvent.click(screen.getByRole("menuitem", { name: "Make crew chief" })); + + // The header and the conversation list of the new chief. + await screen.findByText("Chief", { selector: "header span" }); + const moved = fake.calls.find((call) => call.method === "crews.setLead"); + expect(moved?.params).toMatchObject({ crewId: crew.id }); + fireEvent.click(screen.getByRole("button", { name: "More bot actions" })); + expect(screen.getByRole("menuitem", { name: "Stop being chief" })).toBeDefined(); + }); +}); diff --git a/app/src/features/crews/folders.test.tsx b/app/src/features/crews/folders.test.tsx new file mode 100644 index 00000000..87b15cd2 --- /dev/null +++ b/app/src/features/crews/folders.test.tsx @@ -0,0 +1,95 @@ +import { cleanup, fireEvent, screen, within } from "@testing-library/react"; +import { afterEach, describe, expect, test } from "vitest"; +import { FakeBotloft } from "../../lib/fake"; +import { FakeHost } from "../../lib/fakeHost"; +import { crewOpened, renderApp } from "../../test/app"; + +afterEach(cleanup); + +const PROJECT = "D:\\Projects\\Bakery site"; + +describe("work folders", () => { + test("a new crew can work in a folder the owner picks", async () => { + const fake = new FakeBotloft(); + fake.addCrew("Ops"); + const host = new FakeHost(); + host.nextFolder = PROJECT; + renderApp(fake, host); + await crewOpened("Ops"); + + fireEvent.click(screen.getByRole("button", { name: "New crew" })); + const dialog = screen.getByRole("dialog", { name: "New crew" }); + fireEvent.change(within(dialog).getByLabelText("Name"), { target: { value: "Bakery" } }); + expect(within(dialog).getByText("A new folder inside Botloft")).toBeDefined(); + fireEvent.click(within(dialog).getByRole("button", { name: "Choose folder…" })); + expect(await within(dialog).findByText(PROJECT)).toBeDefined(); + fireEvent.click(within(dialog).getByRole("button", { name: "Create crew" })); + + // The new crew opens on its chief's chat. + await screen.findByRole("heading", { level: 1, name: "Chief" }); + const create = fake.calls.find((call) => call.method === "crews.create"); + expect(create?.params).toMatchObject({ name: "Bakery", workFolder: PROJECT }); + const bakery = [...fake.crews.values()].find((crew) => crew.name === "Bakery"); + expect(bakery?.workFolder).toBe(PROJECT); + }); + + test("without a choice the crew gets a new folder", async () => { + const fake = new FakeBotloft(); + fake.addCrew("Ops"); + const host = new FakeHost(); + host.nextFolder = PROJECT; + renderApp(fake, host); + await crewOpened("Ops"); + + fireEvent.click(screen.getByRole("button", { name: "New crew" })); + const dialog = screen.getByRole("dialog", { name: "New crew" }); + fireEvent.change(within(dialog).getByLabelText("Name"), { target: { value: "Bakery" } }); + fireEvent.click(within(dialog).getByRole("button", { name: "Choose folder…" })); + await within(dialog).findByText(PROJECT); + fireEvent.click(within(dialog).getByRole("button", { name: "Use a new folder" })); + fireEvent.click(within(dialog).getByRole("button", { name: "Create crew" })); + + await screen.findByRole("heading", { level: 1, name: "Chief" }); + const create = fake.calls.find((call) => call.method === "crews.create"); + expect(create?.params).not.toHaveProperty("workFolder"); + const bakery = [...fake.crews.values()].find((crew) => crew.name === "Bakery"); + expect(bakery?.workFolderChosen).toBe(false); + }); + + test("the owner opens the folder and moves the crew to another one", async () => { + const fake = new FakeBotloft(); + const ops = fake.addCrew("Ops"); + const host = new FakeHost(); + renderApp(fake, host); + await crewOpened("Ops"); + + fireEvent.click(screen.getByRole("button", { name: /^Works in / })); + expect(host.opened).toEqual([ops.workFolder]); + + host.nextFolder = PROJECT; + fireEvent.click(screen.getByRole("button", { name: "More crew actions" })); + fireEvent.click(screen.getByRole("menuitem", { name: "Change work folder…" })); + const confirm = await screen.findByRole("dialog", { name: "Move Ops to another folder?" }); + expect(host.pickerStarts).toEqual([ops.workFolder]); + expect(within(confirm).getByText(/restarts when it finishes/)).toBeDefined(); + fireEvent.click(within(confirm).getByRole("button", { name: "Move" })); + + expect(await screen.findByText(`Works in ${PROJECT}`)).toBeDefined(); + const move = fake.calls.find((call) => call.method === "crews.setWorkFolder"); + expect(move?.params).toEqual({ crewId: ops.id, workFolder: PROJECT }); + }); + + test("cancelling the picker changes nothing", async () => { + const fake = new FakeBotloft(); + fake.addCrew("Ops"); + const host = new FakeHost(); + host.nextFolder = null; + renderApp(fake, host); + await crewOpened("Ops"); + fireEvent.click(screen.getByRole("button", { name: "More crew actions" })); + fireEvent.click(screen.getByRole("menuitem", { name: "Change work folder…" })); + await Promise.resolve(); + expect(screen.queryByRole("dialog")).toBeNull(); + expect(fake.calls.some((call) => call.method === "crews.setWorkFolder")).toBe(false); + }); +}); diff --git a/app/src/features/messages/Composer.tsx b/app/src/features/messages/Composer.tsx index 25d4c243..8ed6dd85 100644 --- a/app/src/features/messages/Composer.tsx +++ b/app/src/features/messages/Composer.tsx @@ -73,7 +73,7 @@ export function Composer({ aria-label={t.messages.composer.recipient} value={to ?? ""} onChange={(event) => setChosen(event.target.value)} - className="h-7 rounded-[3px] border border-line-strong bg-canvas px-1.5 text-sm" + className="h-7 rounded-lg border border-line-strong bg-canvas px-1.5 text-sm" > {bots.map((bot) => ( <option key={bot.id} value={bot.id}> @@ -94,7 +94,7 @@ export function Composer({ onChange={(event) => setBody(event.target.value)} onKeyDown={onKeyDown} placeholder={t.messages.composer.placeholder(recipient?.handle)} - className="min-h-16 flex-1 resize-y rounded-[3px] border border-line-strong bg-canvas px-2.5 py-2 text-sm leading-relaxed outline-none placeholder:text-muted focus:border-accent" + className="min-h-16 flex-1 resize-y rounded-xl border border-line-strong bg-canvas px-2.5 py-2 text-sm leading-relaxed outline-none placeholder:text-muted focus:border-accent" /> <Button variant="primary" diff --git a/app/src/features/messages/FailedDeliveries.tsx b/app/src/features/messages/FailedDeliveries.tsx index aad7658d..52ebeeec 100644 --- a/app/src/features/messages/FailedDeliveries.tsx +++ b/app/src/features/messages/FailedDeliveries.tsx @@ -99,7 +99,7 @@ function FailedDialog({ dead, onClose }: { dead: Delivery[]; onClose(): void }) } > <p className="mb-3 text-ink-soft text-sm">{text.explanation}</p> - <ul className="flex flex-col border border-line"> + <ul className="flex flex-col overflow-hidden rounded-xl border border-line"> {dead.map((delivery) => { const bot = bots[delivery.botId]; const message = bodies[delivery.messageId]; diff --git a/app/src/features/messages/MessageRow.tsx b/app/src/features/messages/MessageRow.tsx index d917abad..835adeb6 100644 --- a/app/src/features/messages/MessageRow.tsx +++ b/app/src/features/messages/MessageRow.tsx @@ -32,7 +32,7 @@ function Sender({ message, bots }: { message: Message; bots: Record<BotId, Bot> case "system": return ( <span className="inline-flex items-center gap-1.5 font-medium"> - <BotAvatar color="#ffffff" size={14} /> + <BotAvatar color="#ffffff" size={14} framed /> {t.messages.row.system} </span> ); @@ -56,7 +56,7 @@ function TaskTag({ message, task }: { message: Message; task: Task | undefined } : text.taskStatus[task.status]; } return ( - <span className="inline-flex items-center gap-1 border border-line px-1.5 text-muted text-xs"> + <span className="inline-flex items-center gap-1 rounded-md border border-line px-1.5 text-muted text-xs"> <Icon aria-hidden size={11} /> {message.kind === "task" ? text.task : text.result} {detail && <span>· {detail}</span>} diff --git a/app/src/features/onboarding/Welcome.tsx b/app/src/features/onboarding/Welcome.tsx index 3ecb421d..5d9e803b 100644 --- a/app/src/features/onboarding/Welcome.tsx +++ b/app/src/features/onboarding/Welcome.tsx @@ -3,6 +3,7 @@ import { type ReactNode, useState } from "react"; import { useT } from "../../i18n"; import { useApp } from "../../store/context"; import { Button } from "../../ui/Button"; +import { BotAvatar } from "../bots/BotAvatar"; import { CrewDialog } from "../crews/CrewDialog"; import { ClaudeCodeHelp } from "./ClaudeCodeHelp"; import { SignInButton } from "./SignIn"; @@ -56,14 +57,17 @@ export function Welcome() { return ( <main className="min-h-0 flex-1 overflow-y-auto p-8"> <div className="mx-auto max-w-xl"> + <span className="mb-3 inline-block animate-float"> + <BotAvatar color="#ff7a59" size={56} mood="idle" /> + </span> <h1 className="font-semibold text-2xl tracking-tight">{w.title}</h1> <p className="mt-1 text-ink-soft leading-relaxed">{w.intro}</p> - <ul className="mt-6 flex flex-col border border-line bg-panel"> + <ul className="mt-6 flex flex-col overflow-hidden rounded-xl border border-line bg-panel"> <Check state="ok" title={w.botloft} detail={w.running} /> {claude} {account} </ul> - <div className="mt-4 border border-line bg-panel p-4 text-sm leading-relaxed"> + <div className="mt-4 rounded-xl border border-line bg-panel p-4 text-sm leading-relaxed"> <p className="font-semibold">{w.askFirstTitle}</p> <p className="mt-1 text-ink-soft">{w.askFirstBody}</p> </div> diff --git a/app/src/features/tasks/TaskList.tsx b/app/src/features/tasks/TaskList.tsx index f6281a5d..f6912a24 100644 --- a/app/src/features/tasks/TaskList.tsx +++ b/app/src/features/tasks/TaskList.tsx @@ -58,7 +58,7 @@ export function TaskList({ crewId }: { crewId: CrewId }) { type="button" aria-pressed={show === option} onClick={() => setShow(option)} - className={`h-7 rounded-[3px] px-2.5 font-medium text-sm ${show === option ? "bg-ink text-canvas" : "text-ink-soft hover:bg-sunken"}`} + className={`h-7 rounded-lg px-2.5 font-medium text-sm ${show === option ? "bg-ink text-canvas" : "text-ink-soft hover:bg-sunken"}`} > {option === "open" ? words.open : words.all} </button> diff --git a/app/src/i18n/en/account.ts b/app/src/i18n/en/account.ts new file mode 100644 index 00000000..da35e870 --- /dev/null +++ b/app/src/i18n/en/account.ts @@ -0,0 +1,43 @@ +// The account area at the bottom of the sidebar: who the owner is, the +// plan's usage, settings, language, what's new and help. + +export const account = { + open: (name: string) => `${name}: account and settings`, + plan: (plan: string) => `${plan} plan`, + notSignedIn: "Not signed in to Claude", + menu: { + usage: "Usage", + settings: "Settings", + language: "Language", + whatsNew: "What's new", + help: "Help", + openFailed: "Could not open the page", + }, + usage: { + title: "Usage", + intro: "How much of your Claude plan your bots have used. It updates whenever a bot works.", + empty: "Usage shows up after a bot's first reply.", + windows: { + five_hour: "5-hour window", + seven_day: "This week", + seven_day_opus: "This week, Opus", + seven_day_sonnet: "This week, Sonnet", + } as Record<string, string>, + used: (percent: number) => `${percent}% used`, + resets: (relative: string) => `Resets ${relative}`, + limited: "Limit reached. Your bots wait until it resets.", + updated: (relative: string) => `Updated ${relative}`, + }, + settings: { + title: "Settings", + appearance: "Appearance", + theme: "Theme", + themes: { system: "System", light: "Light", dark: "Dark" }, + size: "Size", + sizeHint: "Ctrl+= and Ctrl+- change the size too, and Ctrl+0 goes back to the default.", + language: "Language", + about: "About", + claudeCode: (version: string) => `Claude Code ${version}`, + botloft: (version: string) => `Botloft ${version}`, + }, +}; diff --git a/app/src/i18n/en/bots.ts b/app/src/i18n/en/bots.ts index 25c5c338..14d5b269 100644 --- a/app/src/i18n/en/bots.ts +++ b/app/src/i18n/en/bots.ts @@ -29,6 +29,10 @@ export const bots = { /** Paused (the bot or its crew) and not running. */ paused: { label: "Paused", hint: "Paused; resume to start it." }, }, + chief: { + badge: "Chief", + hint: (crew: string) => `Leads ${crew}: plans the work and suggests new bots`, + }, header: { noRole: "No role", pause: "Pause", @@ -40,12 +44,15 @@ export const bots = { edit: "Edit", restartFresh: "Restart with a new conversation", openFolder: "Open folder", + makeChief: "Make crew chief", + stopChief: "Stop being chief", archive: "Archive bot", failed: { pause: "Could not pause the bot", resume: "Could not resume the bot", restart: "Could not restart the bot", openFolder: "Could not open the folder", + chief: "Could not change the chief", archive: "Could not archive the bot", }, fresh: { diff --git a/app/src/i18n/en/chat.ts b/app/src/i18n/en/chat.ts index d1c83aed..c718682b 100644 --- a/app/src/i18n/en/chat.ts +++ b/app/src/i18n/en/chat.ts @@ -74,6 +74,96 @@ export const chat = { denied: (tool: string) => `You denied ${tool}`, expired: (tool: string) => `${tool} was not approved in time`, }, + mode: { + title: "Mode", + button: (mode: string) => `Mode: ${mode}`, + names: { + auto: "Auto", + default: "Manual", + accept_edits: "Accept edits", + plan: "Plan", + bypass_permissions: "Bypass permissions", + }, + hints: { + auto: (bot: string) => `${bot} decides what needs your OK`, + default: (bot: string) => `${bot} always asks before making changes`, + accept_edits: (bot: string) => `${bot} edits files without asking`, + plan: (bot: string) => `${bot} makes a plan before making changes`, + bypass_permissions: (bot: string) => `${bot} does everything without asking`, + }, + turnOn: "Turn on", + failed: "Could not change the mode", + later: (bot: string, mode: string) => + `${bot} switches to ${mode} when it finishes what it's doing.`, + bypassTitle: (bot: string) => `Let ${bot} do anything without asking?`, + bypassBody: (bot: string) => + `${bot} will edit files, run commands and use the internet on this computer without asking you first.`, + bypassRisk: + "It is not limited to its folder: it can read and change your other files, other bots' files and Botloft's own files. A message from someone else could get it to do something you did not want.", + bypassChief: (bot: string) => + `${bot} leads its crew, so it will also create new bots without asking you.`, + bypassAdvice: + "Turn this on only for a bot you trust with everything, and only while you need it.", + badge: "Asks nothing", + badgeHint: + "This bot does everything without asking. Change it in the mode picker below the chat.", + }, + model: { + title: "Model", + button: (model: string) => `Model: ${model}`, + names: { + default: "Plan default", + fable: "Fable", + opus: "Opus", + sonnet: "Sonnet", + haiku: "Haiku", + }, + short: "Default", + hints: { + default: (bot: string, inUse: string | null) => + inUse + ? `${bot} uses your plan's default model, now ${inUse}` + : `${bot} uses your plan's default model`, + fable: (bot: string) => `${bot} is at its most capable, for the hardest work`, + opus: (bot: string) => `${bot} handles long, complex tasks well`, + sonnet: (bot: string) => `${bot} is fast and capable, good for most work`, + haiku: (bot: string) => `${bot} is quickest and uses less of your plan, for simple tasks`, + }, + cost: "More capable models use up your plan's limit faster.", + failed: "Could not change the model", + later: (bot: string, model: string) => + `${bot} switches to ${model} when it finishes what it's doing.`, + }, + suggestion: { + title: (bot: string) => `${bot} suggests a new bot`, + why: "Why", + name: "Name", + role: "Role", + model: "Model", + instructions: "Instructions", + startsNow: (bot: string) => `It starts right away and gets its work from ${bot}.`, + noteLabel: (bot: string) => `What to tell ${bot} if you say no`, + notePlaceholder: (bot: string) => `If you say no, tell ${bot} why (optional)`, + create: "Create bot", + decline: "Not now", + createFailed: "Could not create the bot", + declineFailed: "Could not send the answer", + created: (name: string) => `You created ${name}`, + declined: (name: string) => `You said no to ${name}`, + expired: (name: string) => `${name} was not answered in time`, + }, + plan: { + ready: (bot: string) => `${bot} made a plan and wants to go ahead`, + noteLabel: (bot: string) => `What ${bot} should change in the plan`, + notePlaceholder: "What should change? Sent to the bot if you keep planning (optional)", + approve: "Approve plan", + keepPlanning: "Keep planning", + approveFailed: "Could not approve the plan", + keepFailed: "Could not send it back", + approved: "You approved the plan", + sentBack: "You asked for changes to the plan", + expired: "The plan was not approved in time", + }, markdown: { image: "image", openLinkFailed: "Could not open the link", @@ -82,6 +172,8 @@ export const chat = { signedOut: "Claude Code is not signed in, or the account can't be used right now. Sign in to Claude, or check your Claude plan.", usageLimit: "Your Claude plan reached its usage limit. Messages wait until it resets.", + modelUnavailable: + "This bot's model isn't available: it may not be on your Claude plan. Pick another model below the chat.", turnFailed: (detail: string) => `The bot couldn't finish this: ${detail}`, }, }; diff --git a/app/src/i18n/en/crews.ts b/app/src/i18n/en/crews.ts index e97a1efa..0ea025b5 100644 --- a/app/src/i18n/en/crews.ts +++ b/app/src/i18n/en/crews.ts @@ -15,6 +15,19 @@ export const crews = { awaitingApproval: (text: string) => `Waiting for approval: ${text}`, }, dialog: { + folder: "Work folder", + folderHint: "Where the bots put what they make. It can be a folder you already use.", + folderDefault: "A new folder inside Botloft", + chooseFolder: "Choose folder…", + pickTitle: "Choose where the crew works", + useDefault: "Use a new folder", + goal: "What is this crew for?", + goalPlaceholder: "Build and keep up my bakery's website", + goalHint: + "The crew starts with a chief, who reads this, plans the work and suggests the bots it needs.", + chiefModel: "Chief's model", + chiefName: "Chief", + chiefRole: "Leads the crew: plans the work, suggests new bots and hands out tasks", renameTitle: "Rename crew", create: "Create crew", name: "Name", @@ -28,7 +41,13 @@ export const crews = { pause: "Pause crew", resume: "Resume crew", moreActions: "More crew actions", - openShared: "Open shared folder", + folder: (path: string) => `Works in ${path}`, + openFolder: "Open work folder", + changeFolder: "Change work folder…", + moveTitle: (crew: string) => `Move ${crew} to another folder?`, + moveBody: (path: string) => + `The bots will work in ${path}. Each one restarts when it finishes what it's doing. Files already made stay where they are.`, + move: "Move", archive: "Archive crew", tabs: { label: "Crew views", @@ -46,6 +65,7 @@ export const crews = { failed: { pause: "Could not pause the crew", resume: "Could not resume the crew", + changeFolder: "Could not change the folder", openFolder: "Could not open the folder", archive: "Could not archive the crew", }, diff --git a/app/src/i18n/en/index.ts b/app/src/i18n/en/index.ts index 7e0ceee4..774883e6 100644 --- a/app/src/i18n/en/index.ts +++ b/app/src/i18n/en/index.ts @@ -1,5 +1,6 @@ // English, the reference: every other language has exactly this shape. +import { account } from "./account"; import { bots } from "./bots"; import { chat } from "./chat"; import { common } from "./common"; @@ -9,6 +10,16 @@ import { onboarding } from "./onboarding"; import { shell } from "./shell"; import { updates } from "./updates"; -export const en = { common, shell, onboarding, updates, bots, chat, crews, messages }; +export const en = { + common, + shell, + onboarding, + updates, + account, + bots, + chat, + crews, + messages, +}; export type Messages = typeof en; diff --git a/app/src/i18n/en/onboarding.ts b/app/src/i18n/en/onboarding.ts index a7401a55..05fe3a18 100644 --- a/app/src/i18n/en/onboarding.ts +++ b/app/src/i18n/en/onboarding.ts @@ -45,7 +45,7 @@ export const onboarding = { welcome: { title: "Welcome to Botloft", intro: - "A crew is a group of Claude Code bots that keep running, message each other and share a folder. Start with one crew and a bot or two.", + "A crew is a group of Claude Code bots that keep running, message each other and share a folder. Each crew starts with a chief: tell it what the crew is for, and it plans the work and suggests the bots it needs.", botloft: "Botloft", running: "Running in the background. It starts with Windows, so your bots keep working after you close this window.", diff --git a/app/src/i18n/en/shell.ts b/app/src/i18n/en/shell.ts index 8beff70e..745c3686 100644 --- a/app/src/i18n/en/shell.ts +++ b/app/src/i18n/en/shell.ts @@ -8,12 +8,9 @@ export const shell = { restore: "Restore", close: "Close", }, - theme: { - system: "system", - light: "light", - dark: "dark", - label: (theme: string) => `Theme: ${theme}`, - hint: (theme: string) => `Theme: ${theme} (click to change)`, + zoom: { + level: (percent: number, isDefault: boolean) => + isDefault ? `${percent}% (default)` : `${percent}%`, }, language: { label: "Language", diff --git a/app/src/i18n/es/account.ts b/app/src/i18n/es/account.ts new file mode 100644 index 00000000..8a18cf30 --- /dev/null +++ b/app/src/i18n/es/account.ts @@ -0,0 +1,43 @@ +import type { Messages } from "../en"; + +export const account: Messages["account"] = { + open: (name: string) => `${name}: cuenta y configuración`, + plan: (plan: string) => `Plan ${plan}`, + notSignedIn: "Sin sesión en Claude", + menu: { + usage: "Uso", + settings: "Configuración", + language: "Idioma", + whatsNew: "Novedades", + help: "Ayuda", + openFailed: "No se pudo abrir la página", + }, + usage: { + title: "Uso", + intro: + "Cuánto de tu plan de Claude han usado tus bots. Se actualiza cada vez que un bot trabaja.", + empty: "El uso aparece después de la primera respuesta de un bot.", + windows: { + five_hour: "Ventana de 5 horas", + seven_day: "Esta semana", + seven_day_opus: "Esta semana, Opus", + seven_day_sonnet: "Esta semana, Sonnet", + }, + used: (percent: number) => `${percent}% usado`, + resets: (relative: string) => `Se renueva ${relative}`, + limited: "Límite alcanzado. Tus bots esperan hasta que se renueve.", + updated: (relative: string) => `Actualizado ${relative}`, + }, + settings: { + title: "Configuración", + appearance: "Apariencia", + theme: "Tema", + themes: { system: "Sistema", light: "Claro", dark: "Oscuro" }, + size: "Tamaño", + sizeHint: "Ctrl+= y Ctrl+- también cambian el tamaño, y Ctrl+0 vuelve al predeterminado.", + language: "Idioma", + about: "Acerca de", + claudeCode: (version: string) => `Claude Code ${version}`, + botloft: (version: string) => `Botloft ${version}`, + }, +}; diff --git a/app/src/i18n/es/bots.ts b/app/src/i18n/es/bots.ts index 178ab7fe..b4dcfab9 100644 --- a/app/src/i18n/es/bots.ts +++ b/app/src/i18n/es/bots.ts @@ -25,6 +25,10 @@ export const bots: Messages["bots"] = { archived: { label: "Archivado", hint: "Archivado." }, paused: { label: "En pausa", hint: "En pausa; reanúdalo para iniciarlo." }, }, + chief: { + badge: "Jefe", + hint: (crew: string) => `Dirige ${crew}: planea el trabajo y sugiere bots nuevos`, + }, header: { noRole: "Sin rol", pause: "Pausar", @@ -36,12 +40,15 @@ export const bots: Messages["bots"] = { edit: "Editar", restartFresh: "Reiniciar con una conversación nueva", openFolder: "Abrir carpeta", + makeChief: "Hacer jefe del equipo", + stopChief: "Dejar de ser jefe", archive: "Archivar bot", failed: { pause: "No se pudo pausar el bot", resume: "No se pudo reanudar el bot", restart: "No se pudo reiniciar el bot", openFolder: "No se pudo abrir la carpeta", + chief: "No se pudo cambiar el jefe", archive: "No se pudo archivar el bot", }, fresh: { diff --git a/app/src/i18n/es/chat.ts b/app/src/i18n/es/chat.ts index 5a5af18f..55ea3aa0 100644 --- a/app/src/i18n/es/chat.ts +++ b/app/src/i18n/es/chat.ts @@ -79,6 +79,97 @@ export const chat: Messages["chat"] = { denied: (tool: string) => `Denegaste ${tool}`, expired: (tool: string) => `${tool} no se aprobó a tiempo`, }, + mode: { + title: "Modo", + button: (mode: string) => `Modo: ${mode}`, + names: { + auto: "Automático", + default: "Manual", + accept_edits: "Aceptar ediciones", + plan: "Plan", + bypass_permissions: "Omitir permisos", + }, + hints: { + auto: (bot: string) => `${bot} decide qué necesita tu aprobación`, + default: (bot: string) => `${bot} siempre pregunta antes de hacer cambios`, + accept_edits: (bot: string) => `${bot} edita archivos sin preguntar`, + plan: (bot: string) => `${bot} crea un plan antes de hacer cambios`, + bypass_permissions: (bot: string) => `${bot} lo hace todo sin preguntar`, + }, + turnOn: "Activar", + failed: "No se pudo cambiar el modo", + later: (bot: string, mode: string) => + `${bot} cambiará a ${mode} cuando termine lo que está haciendo.`, + bypassTitle: (bot: string) => `¿Dejar que ${bot} haga todo sin preguntar?`, + bypassBody: (bot: string) => + `${bot} editará archivos, ejecutará comandos y usará internet en este equipo sin pedirte permiso antes.`, + bypassRisk: + "No se limita a su carpeta: puede leer y cambiar tus otros archivos, los de otros bots y los del propio Botloft. Un mensaje de otra persona podría llevarlo a hacer algo que no querías.", + bypassChief: (bot: string) => + `${bot} es el jefe del equipo, así que también creará bots nuevos sin preguntar.`, + bypassAdvice: + "Actívalo solo para un bot en el que confíes para todo, y solo mientras lo necesites.", + badge: "No pregunta nada", + badgeHint: + "Este bot lo hace todo sin preguntar. Cámbialo en el selector de modo, debajo del chat.", + }, + model: { + title: "Modelo", + button: (model: string) => `Modelo: ${model}`, + names: { + default: "Predeterminado del plan", + fable: "Fable", + opus: "Opus", + sonnet: "Sonnet", + haiku: "Haiku", + }, + short: "Predeterminado", + hints: { + default: (bot: string, inUse: string | null) => + inUse + ? `${bot} usa el modelo predeterminado de tu plan, ahora ${inUse}` + : `${bot} usa el modelo predeterminado de tu plan`, + fable: (bot: string) => `${bot} rinde al máximo, para el trabajo más difícil`, + opus: (bot: string) => `${bot} maneja bien tareas largas y complejas`, + sonnet: (bot: string) => `${bot} es rápido y capaz, bueno para casi todo`, + haiku: (bot: string) => + `${bot} es el más rápido y gasta menos de tu plan, para tareas simples`, + }, + cost: "Los modelos más capaces gastan el límite de tu plan más rápido.", + failed: "No se pudo cambiar el modelo", + later: (bot: string, model: string) => + `${bot} cambia a ${model} cuando termine lo que está haciendo.`, + }, + suggestion: { + title: (bot: string) => `${bot} sugiere un bot nuevo`, + why: "Por qué", + name: "Nombre", + role: "Rol", + model: "Modelo", + instructions: "Instrucciones", + startsNow: (bot: string) => `Empieza enseguida y recibe el trabajo de ${bot}.`, + noteLabel: (bot: string) => `Qué decirle a ${bot} si dices que no`, + notePlaceholder: (bot: string) => `Si dices que no, dile a ${bot} por qué (opcional)`, + create: "Crear bot", + decline: "Ahora no", + createFailed: "No se pudo crear el bot", + declineFailed: "No se pudo enviar la respuesta", + created: (name: string) => `Creaste ${name}`, + declined: (name: string) => `Rechazaste ${name}`, + expired: (name: string) => `${name} no se respondió a tiempo`, + }, + plan: { + ready: (bot: string) => `${bot} hizo un plan y quiere seguir con él`, + noteLabel: (bot: string) => `Qué debe cambiar ${bot} en el plan`, + notePlaceholder: "¿Qué debe cambiar? Se envía al bot si pides cambios (opcional)", + approve: "Aprobar plan", + keepPlanning: "Pedir cambios", + approveFailed: "No se pudo aprobar el plan", + keepFailed: "No se pudo devolver el plan", + approved: "Aprobaste el plan", + sentBack: "Pediste cambios en el plan", + expired: "El plan no se aprobó a tiempo", + }, markdown: { image: "imagen", openLinkFailed: "No se pudo abrir el enlace", @@ -88,6 +179,8 @@ export const chat: Messages["chat"] = { "Claude Code no tiene una sesión iniciada, o la cuenta no se puede usar ahora. Inicia sesión en Claude o revisa tu plan de Claude.", usageLimit: "Tu plan de Claude alcanzó su límite de uso. Los mensajes esperarán hasta que se restablezca.", + modelUnavailable: + "El modelo de este bot no está disponible: quizá no esté en tu plan de Claude. Elige otro modelo debajo del chat.", turnFailed: (detail: string) => `El bot no pudo terminar esto: ${detail}`, }, }; diff --git a/app/src/i18n/es/crews.ts b/app/src/i18n/es/crews.ts index 2ad18604..b5b164f4 100644 --- a/app/src/i18n/es/crews.ts +++ b/app/src/i18n/es/crews.ts @@ -12,6 +12,19 @@ export const crews: Messages["crews"] = { awaitingApproval: (text: string) => `Esperando aprobación: ${text}`, }, dialog: { + folder: "Carpeta de trabajo", + folderHint: "Donde los bots guardan lo que hacen. Puede ser una carpeta que ya usas.", + folderDefault: "Una carpeta nueva dentro de Botloft", + chooseFolder: "Elegir carpeta…", + pickTitle: "Elige dónde trabaja el equipo", + useDefault: "Usar una carpeta nueva", + goal: "¿Para qué es este equipo?", + goalPlaceholder: "Crear y mantener la web de mi panadería", + goalHint: + "El equipo empieza con un jefe, que lee esto, planea el trabajo y sugiere los bots que necesita.", + chiefModel: "Modelo del jefe", + chiefName: "Jefe", + chiefRole: "Dirige el equipo: planea el trabajo, sugiere bots nuevos y reparte las tareas", renameTitle: "Renombrar equipo", create: "Crear equipo", name: "Nombre", @@ -25,7 +38,13 @@ export const crews: Messages["crews"] = { pause: "Pausar equipo", resume: "Reanudar equipo", moreActions: "Más acciones del equipo", - openShared: "Abrir carpeta compartida", + folder: (path: string) => `Trabaja en ${path}`, + openFolder: "Abrir carpeta de trabajo", + changeFolder: "Cambiar carpeta de trabajo…", + moveTitle: (crew: string) => `¿Mover ${crew} a otra carpeta?`, + moveBody: (path: string) => + `Los bots trabajarán en ${path}. Cada uno se reinicia cuando termine lo que está haciendo. Lo que ya hicieron se queda donde está.`, + move: "Mover", archive: "Archivar equipo", tabs: { label: "Vistas del equipo", @@ -43,6 +62,7 @@ export const crews: Messages["crews"] = { failed: { pause: "No se pudo pausar el equipo", resume: "No se pudo reanudar el equipo", + changeFolder: "No se pudo cambiar la carpeta", openFolder: "No se pudo abrir la carpeta", archive: "No se pudo archivar el equipo", }, diff --git a/app/src/i18n/es/index.ts b/app/src/i18n/es/index.ts index 2da37bda..45a4b409 100644 --- a/app/src/i18n/es/index.ts +++ b/app/src/i18n/es/index.ts @@ -1,6 +1,7 @@ // Spanish. import type { Messages } from "../en"; +import { account } from "./account"; import { bots } from "./bots"; import { chat } from "./chat"; import { common } from "./common"; @@ -10,4 +11,14 @@ import { onboarding } from "./onboarding"; import { shell } from "./shell"; import { updates } from "./updates"; -export const es: Messages = { common, shell, onboarding, updates, bots, chat, crews, messages }; +export const es: Messages = { + common, + shell, + onboarding, + updates, + account, + bots, + chat, + crews, + messages, +}; diff --git a/app/src/i18n/es/onboarding.ts b/app/src/i18n/es/onboarding.ts index a5d66198..f25217f7 100644 --- a/app/src/i18n/es/onboarding.ts +++ b/app/src/i18n/es/onboarding.ts @@ -44,7 +44,7 @@ export const onboarding: Messages["onboarding"] = { welcome: { title: "Te damos la bienvenida a Botloft", intro: - "Un equipo es un grupo de bots de Claude Code que siguen funcionando, se envían mensajes y comparten una carpeta. Empieza con un equipo y uno o dos bots.", + "Un equipo es un grupo de bots de Claude Code que siguen funcionando, se envían mensajes y comparten una carpeta. Cada equipo empieza con un jefe: dile para qué es el equipo, y planea el trabajo y sugiere los bots que necesita.", botloft: "Botloft", running: "Funcionando en segundo plano. Se inicia con Windows, así que tus bots siguen trabajando después de cerrar esta ventana.", diff --git a/app/src/i18n/es/shell.ts b/app/src/i18n/es/shell.ts index c36d0857..8020d799 100644 --- a/app/src/i18n/es/shell.ts +++ b/app/src/i18n/es/shell.ts @@ -7,12 +7,9 @@ export const shell: Messages["shell"] = { restore: "Restaurar", close: "Cerrar", }, - theme: { - system: "sistema", - light: "claro", - dark: "oscuro", - label: (theme: string) => `Tema: ${theme}`, - hint: (theme: string) => `Tema: ${theme} (haz clic para cambiarlo)`, + zoom: { + level: (percent: number, isDefault: boolean) => + isDefault ? `${percent}% (predeterminado)` : `${percent}%`, }, language: { label: "Idioma", diff --git a/app/src/i18n/i18n.test.tsx b/app/src/i18n/i18n.test.tsx index 5deb2fa5..d033b37b 100644 --- a/app/src/i18n/i18n.test.tsx +++ b/app/src/i18n/i18n.test.tsx @@ -56,13 +56,13 @@ describe("languages", () => { render(<App host={new FakeHost()} connect={() => fake as Client} />); expect(await screen.findByRole("heading", { name: "Welcome to Botloft" })).toBeDefined(); - fireEvent.click(screen.getByRole("button", { name: "Language" })); + // The language lives in the account menu at the bottom of the sidebar. + fireEvent.click(screen.getByRole("button", { name: /Ana Lima/ })); + fireEvent.click(screen.getByRole("menuitem", { name: "Language" })); fireEvent.click(screen.getByRole("menuitemradio", { name: /Português/ })); expect(screen.getByRole("heading", { name: "Boas-vindas ao Botloft" })).toBeDefined(); expect(document.documentElement.lang).toBe("pt-BR"); expect(localStorage.getItem("botloft.locale")).toBe("pt-BR"); - - fireEvent.click(screen.getByRole("button", { name: "Idioma" })); expect( screen.getByRole("menuitemradio", { name: /Português/ }).getAttribute("aria-checked"), ).toBe("true"); diff --git a/app/src/i18n/pt-BR/account.ts b/app/src/i18n/pt-BR/account.ts new file mode 100644 index 00000000..aaa52320 --- /dev/null +++ b/app/src/i18n/pt-BR/account.ts @@ -0,0 +1,43 @@ +import type { Messages } from "../en"; + +export const account: Messages["account"] = { + open: (name: string) => `${name}: conta e configurações`, + plan: (plan: string) => `Plano ${plan}`, + notSignedIn: "Sem conta do Claude conectada", + menu: { + usage: "Uso", + settings: "Configurações", + language: "Idioma", + whatsNew: "Novidades", + help: "Ajuda", + openFailed: "Não foi possível abrir a página", + }, + usage: { + title: "Uso", + intro: + "Quanto do seu plano do Claude os seus bots já usaram. Atualiza sempre que um bot trabalha.", + empty: "O uso aparece depois da primeira resposta de um bot.", + windows: { + five_hour: "Janela de 5 horas", + seven_day: "Esta semana", + seven_day_opus: "Esta semana, Opus", + seven_day_sonnet: "Esta semana, Sonnet", + }, + used: (percent: number) => `${percent}% usado`, + resets: (relative: string) => `Renova ${relative}`, + limited: "Limite atingido. Seus bots esperam até ele renovar.", + updated: (relative: string) => `Atualizado ${relative}`, + }, + settings: { + title: "Configurações", + appearance: "Aparência", + theme: "Tema", + themes: { system: "Sistema", light: "Claro", dark: "Escuro" }, + size: "Tamanho", + sizeHint: "Ctrl+= e Ctrl+- também mudam o tamanho, e Ctrl+0 volta ao padrão.", + language: "Idioma", + about: "Sobre", + claudeCode: (version: string) => `Claude Code ${version}`, + botloft: (version: string) => `Botloft ${version}`, + }, +}; diff --git a/app/src/i18n/pt-BR/bots.ts b/app/src/i18n/pt-BR/bots.ts index ebddc4b0..9cad8fc3 100644 --- a/app/src/i18n/pt-BR/bots.ts +++ b/app/src/i18n/pt-BR/bots.ts @@ -25,6 +25,10 @@ export const bots: Messages["bots"] = { archived: { label: "Arquivado", hint: "Arquivado." }, paused: { label: "Pausado", hint: "Pausado; retome para iniciar." }, }, + chief: { + badge: "Chefe", + hint: (crew: string) => `Lidera ${crew}: planeja o trabalho e sugere bots novos`, + }, header: { noRole: "Sem função definida", pause: "Pausar", @@ -36,12 +40,15 @@ export const bots: Messages["bots"] = { edit: "Editar", restartFresh: "Reiniciar com uma nova conversa", openFolder: "Abrir pasta", + makeChief: "Tornar chefe da equipe", + stopChief: "Deixar de ser chefe", archive: "Arquivar bot", failed: { pause: "Não foi possível pausar o bot", resume: "Não foi possível retomar o bot", restart: "Não foi possível reiniciar o bot", openFolder: "Não foi possível abrir a pasta", + chief: "Não foi possível trocar o chefe", archive: "Não foi possível arquivar o bot", }, fresh: { diff --git a/app/src/i18n/pt-BR/chat.ts b/app/src/i18n/pt-BR/chat.ts index b4657f15..e01756e2 100644 --- a/app/src/i18n/pt-BR/chat.ts +++ b/app/src/i18n/pt-BR/chat.ts @@ -79,6 +79,95 @@ export const chat: Messages["chat"] = { denied: (tool: string) => `Você negou ${tool}`, expired: (tool: string) => `${tool} não foi aprovado a tempo`, }, + mode: { + title: "Modo", + button: (mode: string) => `Modo: ${mode}`, + names: { + auto: "Automático", + default: "Manual", + accept_edits: "Aceitar edições", + plan: "Plano", + bypass_permissions: "Ignorar permissões", + }, + hints: { + auto: (bot: string) => `${bot} decide o que precisa do seu OK`, + default: (bot: string) => `${bot} sempre pergunta antes de fazer alterações`, + accept_edits: (bot: string) => `${bot} edita arquivos sem perguntar`, + plan: (bot: string) => `${bot} cria um plano antes de fazer alterações`, + bypass_permissions: (bot: string) => `${bot} faz tudo sem perguntar`, + }, + turnOn: "Ativar", + failed: "Não foi possível mudar o modo", + later: (bot: string, mode: string) => + `${bot} muda para ${mode} quando terminar o que está fazendo.`, + bypassTitle: (bot: string) => `Deixar ${bot} fazer tudo sem perguntar?`, + bypassBody: (bot: string) => + `${bot} vai editar arquivos, rodar comandos e usar a internet neste computador sem pedir sua permissão antes.`, + bypassRisk: + "Ele não fica preso à pasta dele: pode ler e alterar seus outros arquivos, os arquivos de outros bots e os do próprio Botloft. Uma mensagem de outra pessoa pode levá-lo a fazer algo que você não queria.", + bypassChief: (bot: string) => + `${bot} é o chefe da equipe, então também vai criar bots novos sem perguntar.`, + bypassAdvice: "Ative só para um bot em quem você confia para tudo, e só enquanto precisar.", + badge: "Não pergunta nada", + badgeHint: "Este bot faz tudo sem perguntar. Mude isso no seletor de modo, embaixo do chat.", + }, + model: { + title: "Modelo", + button: (model: string) => `Modelo: ${model}`, + names: { + default: "Padrão do plano", + fable: "Fable", + opus: "Opus", + sonnet: "Sonnet", + haiku: "Haiku", + }, + short: "Padrão", + hints: { + default: (bot: string, inUse: string | null) => + inUse + ? `${bot} usa o modelo padrão do seu plano, hoje o ${inUse}` + : `${bot} usa o modelo padrão do seu plano`, + fable: (bot: string) => `${bot} fica no máximo, para o trabalho mais difícil`, + opus: (bot: string) => `${bot} vai bem em tarefas longas e complexas`, + sonnet: (bot: string) => `${bot} fica rápido e capaz, bom para quase tudo`, + haiku: (bot: string) => + `${bot} fica mais rápido e gasta menos do seu plano, para tarefas simples`, + }, + cost: "Modelos mais capazes gastam o limite do seu plano mais rápido.", + failed: "Não foi possível trocar o modelo", + later: (bot: string, model: string) => + `${bot} muda para ${model} quando terminar o que está fazendo.`, + }, + suggestion: { + title: (bot: string) => `${bot} sugere um bot novo`, + why: "Por quê", + name: "Nome", + role: "Função", + model: "Modelo", + instructions: "Instruções", + startsNow: (bot: string) => `Ele começa na hora e recebe o trabalho de ${bot}.`, + noteLabel: (bot: string) => `O que dizer a ${bot} se você recusar`, + notePlaceholder: (bot: string) => `Se recusar, diga a ${bot} o porquê (opcional)`, + create: "Criar bot", + decline: "Agora não", + createFailed: "Não foi possível criar o bot", + declineFailed: "Não foi possível enviar a resposta", + created: (name: string) => `Você criou ${name}`, + declined: (name: string) => `Você recusou ${name}`, + expired: (name: string) => `${name} não foi respondido a tempo`, + }, + plan: { + ready: (bot: string) => `${bot} fez um plano e quer seguir com ele`, + noteLabel: (bot: string) => `O que ${bot} deve mudar no plano`, + notePlaceholder: "O que deve mudar? Vai para o bot se você pedir mudanças (opcional)", + approve: "Aprovar plano", + keepPlanning: "Pedir mudanças", + approveFailed: "Não foi possível aprovar o plano", + keepFailed: "Não foi possível devolver o plano", + approved: "Você aprovou o plano", + sentBack: "Você pediu mudanças no plano", + expired: "O plano não foi aprovado a tempo", + }, markdown: { image: "imagem", openLinkFailed: "Não foi possível abrir o link", @@ -88,6 +177,8 @@ export const chat: Messages["chat"] = { "O Claude Code não está conectado a uma conta, ou a conta não pode ser usada agora. Entre no Claude ou confira o seu plano do Claude.", usageLimit: "Seu plano do Claude atingiu o limite de uso. As mensagens ficam esperando até o limite renovar.", + modelUnavailable: + "O modelo deste bot não está disponível: talvez não faça parte do seu plano do Claude. Escolha outro modelo abaixo do chat.", turnFailed: (detail: string) => `O bot não conseguiu terminar isto: ${detail}`, }, }; diff --git a/app/src/i18n/pt-BR/crews.ts b/app/src/i18n/pt-BR/crews.ts index 3acaf0c9..526e27ed 100644 --- a/app/src/i18n/pt-BR/crews.ts +++ b/app/src/i18n/pt-BR/crews.ts @@ -12,6 +12,19 @@ export const crews: Messages["crews"] = { awaitingApproval: (text: string) => `Aguardando aprovação: ${text}`, }, dialog: { + folder: "Pasta de trabalho", + folderHint: "Onde os bots guardam o que fazem. Pode ser uma pasta que você já usa.", + folderDefault: "Uma pasta nova dentro do Botloft", + chooseFolder: "Escolher pasta…", + pickTitle: "Escolha onde a equipe trabalha", + useDefault: "Usar uma pasta nova", + goal: "Para que é esta equipe?", + goalPlaceholder: "Criar e manter o site da minha padaria", + goalHint: + "A equipe começa com um Chefe, que lê isto, planeja o trabalho e sugere os bots de que precisa.", + chiefModel: "Modelo do Chefe", + chiefName: "Chefe", + chiefRole: "Lidera a equipe: planeja o trabalho, sugere bots novos e distribui as tarefas", renameTitle: "Renomear equipe", create: "Criar equipe", name: "Nome", @@ -26,7 +39,13 @@ export const crews: Messages["crews"] = { pause: "Pausar equipe", resume: "Retomar equipe", moreActions: "Mais ações da equipe", - openShared: "Abrir pasta compartilhada", + folder: (path: string) => `Trabalha em ${path}`, + openFolder: "Abrir pasta de trabalho", + changeFolder: "Mudar pasta de trabalho…", + moveTitle: (crew: string) => `Mudar ${crew} para outra pasta?`, + moveBody: (path: string) => + `Os bots vão trabalhar em ${path}. Cada um reinicia quando terminar o que está fazendo. O que já foi feito fica onde está.`, + move: "Mudar", archive: "Arquivar equipe", tabs: { label: "Visões da equipe", @@ -44,6 +63,7 @@ export const crews: Messages["crews"] = { failed: { pause: "Não foi possível pausar a equipe", resume: "Não foi possível retomar a equipe", + changeFolder: "Não foi possível mudar a pasta", openFolder: "Não foi possível abrir a pasta", archive: "Não foi possível arquivar a equipe", }, diff --git a/app/src/i18n/pt-BR/index.ts b/app/src/i18n/pt-BR/index.ts index e15ad594..a3aa413b 100644 --- a/app/src/i18n/pt-BR/index.ts +++ b/app/src/i18n/pt-BR/index.ts @@ -1,6 +1,7 @@ // Brazilian Portuguese. import type { Messages } from "../en"; +import { account } from "./account"; import { bots } from "./bots"; import { chat } from "./chat"; import { common } from "./common"; @@ -10,4 +11,14 @@ import { onboarding } from "./onboarding"; import { shell } from "./shell"; import { updates } from "./updates"; -export const ptBR: Messages = { common, shell, onboarding, updates, bots, chat, crews, messages }; +export const ptBR: Messages = { + common, + shell, + onboarding, + updates, + account, + bots, + chat, + crews, + messages, +}; diff --git a/app/src/i18n/pt-BR/onboarding.ts b/app/src/i18n/pt-BR/onboarding.ts index f7058f32..1e699416 100644 --- a/app/src/i18n/pt-BR/onboarding.ts +++ b/app/src/i18n/pt-BR/onboarding.ts @@ -44,7 +44,7 @@ export const onboarding: Messages["onboarding"] = { welcome: { title: "Boas-vindas ao Botloft", intro: - "Uma equipe é um grupo de bots do Claude Code que ficam rodando, trocam mensagens entre si e compartilham uma pasta. Comece com uma equipe e um ou dois bots.", + "Uma equipe é um grupo de bots do Claude Code que ficam rodando, trocam mensagens entre si e compartilham uma pasta. Cada equipe começa com um Chefe: diga a ele para que é a equipe, e ele planeja o trabalho e sugere os bots de que precisa.", botloft: "Botloft", running: "Rodando em segundo plano. Inicia com o Windows, então seus bots continuam trabalhando depois que você fecha esta janela.", diff --git a/app/src/i18n/pt-BR/shell.ts b/app/src/i18n/pt-BR/shell.ts index 6abb735e..bb82a25a 100644 --- a/app/src/i18n/pt-BR/shell.ts +++ b/app/src/i18n/pt-BR/shell.ts @@ -7,12 +7,9 @@ export const shell: Messages["shell"] = { restore: "Restaurar", close: "Fechar", }, - theme: { - system: "sistema", - light: "claro", - dark: "escuro", - label: (theme: string) => `Tema: ${theme}`, - hint: (theme: string) => `Tema: ${theme} (clique para trocar)`, + zoom: { + level: (percent: number, isDefault: boolean) => + isDefault ? `${percent}% (padrão)` : `${percent}%`, }, language: { label: "Idioma", diff --git a/app/src/index.css b/app/src/index.css index 5cc62aa2..2efd28f9 100644 --- a/app/src/index.css +++ b/app/src/index.css @@ -4,6 +4,7 @@ @import "@fontsource/ibm-plex-sans/600.css"; @import "@fontsource/ibm-plex-mono/400.css"; @import "@fontsource/ibm-plex-mono/500.css"; +@import "./motion.css"; /* Colors are tokens so the light and dark themes swap in one place (spec 15.3). State colors always go with an icon and a label. */ @@ -23,6 +24,10 @@ --warn: #a35f00; --danger: #c2372a; --idle-state: #6f6f69; + /* The thin edge around a bot's avatar, so light colors hold their shape. */ + --avatar-edge: rgb(0 0 0 / 0.2); + /* Under menus, pickers and dialogs. */ + --lift: rgb(0 0 0 / 0.12); } [data-theme="dark"] { @@ -41,6 +46,8 @@ --warn: #f0b24a; --danger: #ff6d60; --idle-state: #8c8c86; + --avatar-edge: rgb(255 255 255 / 0.14); + --lift: rgb(0 0 0 / 0.5); } @theme inline { @@ -58,6 +65,7 @@ --color-warn: var(--warn); --color-danger: var(--danger); --color-quiet: var(--idle-state); + --shadow-lift: 0 12px 32px -8px var(--lift), 0 2px 8px -2px var(--lift); } @theme { @@ -121,6 +129,10 @@ margin-top: 0.6em; } + .chat-md > :first-child { + margin-top: 0; + } + .chat-md :is(h1, h2, h3, h4) { font-weight: 600; letter-spacing: -0.01em; @@ -160,7 +172,7 @@ font-size: 0.9em; background: var(--sunken); padding: 0.1em 0.35em; - border-radius: 3px; + border-radius: 5px; } .chat-md pre { @@ -169,8 +181,8 @@ line-height: 1.5; background: var(--sunken); border: 1px solid var(--line); - border-radius: 4px; - padding: 0.7em 0.9em; + border-radius: 10px; + padding: 0.75em 1em; overflow-x: auto; overflow-wrap: normal; } @@ -187,18 +199,31 @@ } .chat-md table { - border-collapse: collapse; + border-collapse: separate; + border-spacing: 0; display: block; + width: fit-content; + max-width: 100%; overflow-x: auto; font-size: 0.8125rem; + border: 1px solid var(--line); + border-radius: 10px; } .chat-md :is(th, td) { - border: 1px solid var(--line); - padding: 0.3em 0.6em; + border-bottom: 1px solid var(--line); + padding: 0.4em 0.75em; text-align: left; } + .chat-md :is(th, td) + :is(th, td) { + border-left: 1px solid var(--line); + } + + .chat-md tbody tr:last-child > td { + border-bottom: 0; + } + .chat-md th { background: var(--sunken); font-weight: 600; diff --git a/app/src/lib/fake.ts b/app/src/lib/fake.ts index c8d9a0b1..5492ed29 100644 --- a/app/src/lib/fake.ts +++ b/app/src/lib/fake.ts @@ -3,11 +3,12 @@ // handles, archiving, and the notifications each change sends. import type { BotloftApi } from "./api"; +import { botHandlers } from "./fakeBots"; import { FakeChat } from "./fakeChat"; import { FakeConversation } from "./fakeConversation"; -import { checkName, conflict, invalid, notFound, slugify } from "./fakeRules"; +import { crewHandlers } from "./fakeCrews"; +import { conflict, invalid, notFound, slugify } from "./fakeRules"; import { - AVATAR_PALETTE, type Bot, type BotId, type BotState, @@ -42,6 +43,10 @@ export class FakeBotloft implements BotloftApi { runtimeError: null, claudePath: "C:\\Users\\owner\\.local\\bin\\claude.exe", claudeSignedIn: true, + account: { + name: "Ana Lima", + claude: { email: "ana@example.com", plan: "max", organization: null }, + }, deliveries: { pending: 0, dead: 0 }, usage: null, }; @@ -138,7 +143,8 @@ export class FakeBotloft implements BotloftApi { return `${prefix}_${String(counter).padStart(4, "0")}`; } - private crew(crewId: CrewId, active = true): Crew { + /** The crew; archived ones only when `active` is false. */ + crew(crewId: CrewId, active = true): Crew { const crew = this.crews.get(crewId); if (!crew) { throw notFound(`crew ${crewId}`); @@ -161,23 +167,23 @@ export class FakeBotloft implements BotloftApi { return bot; } - private activeBots(crewId?: CrewId): Bot[] { + activeBots(crewId?: CrewId): Bot[] { return [...this.bots.values()].filter( (bot) => bot.archivedAt === null && (crewId === undefined || bot.crewId === crewId), ); } - private changedCrew(crew: Crew): Crew { + changedCrew(crew: Crew): Crew { this.emit({ name: "crew.changed", params: crew }); return crew; } - private changedBot(bot: Bot): Bot { + changedBot(bot: Bot): Bot { this.emit({ name: "bot.changed", params: bot }); return bot; } - private handle(name: string, crewId: CrewId, except?: BotId): string { + handle(name: string, crewId: CrewId, except?: BotId): string { const handle = slugify(name, "bot"); const taken = this.activeBots(crewId).some((bot) => bot.handle === handle && bot.id !== except); if (taken) { @@ -196,104 +202,8 @@ export class FakeBotloft implements BotloftApi { this.refreshes += 1; return this.system; }, - "crews.list": () => [...this.crews.values()].filter((crew) => crew.archivedAt === null), - "crews.create": ({ name }) => { - const checked = checkName(name); - const crew: Crew = { - id: this.id("crw"), - name: checked, - slug: slugify(checked, "crew"), - paused: false, - createdAt: this.now, - archivedAt: null, - }; - this.crews.set(crew.id, crew); - return this.changedCrew(crew); - }, - "crews.rename": ({ crewId, name }) => { - const crew = this.crew(crewId); - crew.name = checkName(name); - return this.changedCrew(crew); - }, - "crews.setPaused": ({ crewId, paused }) => { - const crew = this.crew(crewId); - crew.paused = paused; - return this.changedCrew(crew); - }, - "crews.archive": ({ crewId }) => { - const crew = this.crew(crewId, false); - if (crew.archivedAt === null) { - crew.archivedAt = this.now; - for (const bot of this.activeBots(crewId)) { - bot.archivedAt = this.now; - bot.state = "archived"; - this.changedBot(bot); - } - this.changedCrew(crew); - } - return crew; - }, - "bots.list": ({ crewId }) => { - if (crewId !== undefined) { - this.crew(crewId); - } - return this.activeBots(crewId); - }, - "bots.create": ({ crewId, name, role, instructions, color }) => { - const crew = this.crew(crewId); - const checked = checkName(name); - const handle = this.handle(checked, crewId); - const index = [...this.bots.values()].filter((bot) => bot.crewId === crewId).length; - const bot: Bot = { - id: this.id("bot"), - crewId, - name: checked, - handle, - slug: handle, - role: role.trim(), - instructions, - color: color ?? AVATAR_PALETTE[index % AVATAR_PALETTE.length] ?? "#FF7A59", - paused: false, - state: crew.paused ? "offline" : "launching", - generation: crew.paused ? null : 1, - workspace: `C:\\Users\\owner\\Botloft\\${crew.slug}\\${handle}`, - lastActivity: null, - createdAt: this.now, - archivedAt: null, - }; - this.bots.set(bot.id, bot); - return this.changedBot(bot); - }, - "bots.update": ({ botId, name, role, instructions, color }) => { - const bot = this.bot(botId); - if (name !== undefined) { - bot.name = checkName(name); - bot.handle = this.handle(bot.name, bot.crewId, botId); - } - bot.role = role?.trim() ?? bot.role; - bot.instructions = instructions ?? bot.instructions; - bot.color = color ?? bot.color; - return this.changedBot(bot); - }, - "bots.setPaused": ({ botId, paused }) => { - const bot = this.bot(botId); - bot.paused = paused; - return this.changedBot(bot); - }, - "bots.restart": ({ botId }) => { - const bot = this.bot(botId); - this.setBotState(botId, "launching", (bot.generation ?? 0) + 1); - return bot; - }, - "bots.archive": ({ botId }) => { - const bot = this.bot(botId, false); - if (bot.archivedAt === null) { - bot.archivedAt = this.now; - bot.state = "archived"; - this.changedBot(bot); - } - return bot; - }, + ...crewHandlers(this), + ...botHandlers(this), ...this.chat.handlers(), ...this.conversation.handlers(), }; diff --git a/app/src/lib/fakeBots.ts b/app/src/lib/fakeBots.ts new file mode 100644 index 00000000..914fa21b --- /dev/null +++ b/app/src/lib/fakeBots.ts @@ -0,0 +1,93 @@ +// The fake daemon's `bots.*` methods, following the daemon's rules for +// handles, colors, archiving and the notifications each change sends. + +import type { FakeBotloft, Handlers } from "./fake"; +import { checkName } from "./fakeRules"; +import { AVATAR_PALETTE, type Bot } from "./protocol.gen"; + +type BotMethods = Extract<keyof Handlers, `bots.${string}`>; + +export function botHandlers(fake: FakeBotloft): Pick<Handlers, BotMethods> { + return { + "bots.list": ({ crewId }) => { + if (crewId !== undefined) { + fake.crew(crewId); + } + return fake.activeBots(crewId); + }, + "bots.create": ({ crewId, name, role, instructions, color, model }) => { + const crew = fake.crew(crewId); + const checked = checkName(name); + const handle = fake.handle(checked, crewId); + const index = [...fake.bots.values()].filter((bot) => bot.crewId === crewId).length; + const bot: Bot = { + id: fake.id("bot"), + crewId, + name: checked, + handle, + slug: handle, + role: role.trim(), + instructions, + color: color ?? AVATAR_PALETTE[index % AVATAR_PALETTE.length] ?? "#FF7A59", + paused: false, + permissionMode: "default", + model: model ?? "default", + modelInUse: null, + state: crew.paused ? "offline" : "launching", + generation: crew.paused ? null : 1, + workspace: `C:\\Users\\owner\\Botloft\\${crew.slug}\\${handle}`, + lastActivity: null, + createdAt: fake.now, + archivedAt: null, + }; + fake.bots.set(bot.id, bot); + return fake.changedBot(bot); + }, + "bots.update": ({ botId, name, role, instructions, color }) => { + const bot = fake.bot(botId); + if (name !== undefined) { + bot.name = checkName(name); + bot.handle = fake.handle(bot.name, bot.crewId, botId); + } + bot.role = role?.trim() ?? bot.role; + bot.instructions = instructions ?? bot.instructions; + bot.color = color ?? bot.color; + return fake.changedBot(bot); + }, + "bots.setPaused": ({ botId, paused }) => { + const bot = fake.bot(botId); + bot.paused = paused; + return fake.changedBot(bot); + }, + "bots.setPermissionMode": ({ botId, mode }) => { + const bot = fake.bot(botId); + bot.permissionMode = mode; + return fake.changedBot(bot); + }, + "bots.setModel": ({ botId, model }) => { + const bot = fake.bot(botId); + bot.model = model; + return fake.changedBot(bot); + }, + "bots.restart": ({ botId }) => { + const bot = fake.bot(botId); + fake.setBotState(botId, "launching", (bot.generation ?? 0) + 1); + return bot; + }, + "bots.archive": ({ botId }) => { + const bot = fake.bot(botId, false); + if (bot.archivedAt === null) { + bot.archivedAt = fake.now; + bot.state = "archived"; + fake.changedBot(bot); + // An archived chief leaves its crew without one. + const crew = fake.crews.get(bot.crewId); + if (crew?.leadBotId === botId) { + crew.leadBotId = null; + fake.changedCrew(crew); + } + } + return bot; + }, + }; +} diff --git a/app/src/lib/fakeChat.ts b/app/src/lib/fakeChat.ts index db390b1d..0912bb7e 100644 --- a/app/src/lib/fakeChat.ts +++ b/app/src/lib/fakeChat.ts @@ -9,11 +9,15 @@ import type { Approval, ApprovalItem, BotId, + BotModel, ChatBody, ChatItem, ToolItem, } from "./protocol.gen"; +/** The chief's tool to suggest a bot (spec 10.2). */ +export const SUGGEST_TOOL = "mcp__botloft__suggest_bot"; + /** The conversation-list line for an item, like the daemon's (spec 8.3). */ export function activityLine(body: ChatBody): { kind: ActivityKind; text: string } | null { const label = (name: string) => name.split("__").at(-1) ?? name; @@ -138,7 +142,7 @@ export class FakeChat { .reverse() .slice(0, limit ?? 50); }, - "approvals.answer": ({ approvalId, allow, note }) => { + "approvals.answer": ({ approvalId, allow, note, input }) => { const approval = this.approvals.get(approvalId); if (!approval) { throw notFound(`approval ${approvalId}`); @@ -149,12 +153,41 @@ export class FakeChat { approval.status = allow ? "allowed" : "denied"; approval.note = allow ? null : (note ?? null); approval.answeredAt = this.fake.now; + // Claude Code leaves plan mode once the plan is approved. + const bot = this.fake.bots.get(approval.botId); + if (allow && approval.toolName === "ExitPlanMode" && bot?.permissionMode === "plan") { + void this.fake.call("bots.setPermissionMode", { botId: bot.id, mode: "default" }); + } + // An allowed suggestion becomes a bot, as the owner left it. + if (allow && approval.toolName === SUGGEST_TOOL && bot) { + if (input !== undefined) { + approval.input = input; + } + const { name, role, instructions, model } = JSON.parse(approval.input) as { + name: string; + role: string; + instructions: string; + model?: BotModel; + }; + void this.fake.call("bots.create", { + crewId: bot.crewId, + name, + role, + instructions, + ...(model && { model }), + }); + } const item = this.items.find( (entry) => entry.body.kind === "approval" && entry.body.approvalId === approvalId, ); if (item) { const body = item.body as { kind: "approval" } & ApprovalItem; - this.update(item.id, { ...body, status: approval.status, note: approval.note }); + this.update(item.id, { + ...body, + input: approval.input, + status: approval.status, + note: approval.note, + }); } return approval; }, diff --git a/app/src/lib/fakeCrews.ts b/app/src/lib/fakeCrews.ts new file mode 100644 index 00000000..72706174 --- /dev/null +++ b/app/src/lib/fakeCrews.ts @@ -0,0 +1,85 @@ +// The fake daemon's `crews.*` methods: names, slugs, the work folder, +// pausing and archiving, with the notifications each change sends. + +import type { FakeBotloft, Handlers } from "./fake"; +import { botHandlers } from "./fakeBots"; +import { checkName, invalid, slugify } from "./fakeRules"; +import type { Crew } from "./protocol.gen"; + +type CrewMethods = Extract<keyof Handlers, `crews.${string}`>; + +/** The crew's `shared` folder, where it works unless the owner chose another. */ +const sharedFolder = (slug: string) => `C:\\Users\\owner\\Botloft\\${slug}\\shared`; + +function checkFolder(folder: string): string { + if (!/^[A-Za-z]:\\./.test(folder)) { + throw invalid("the work folder must be a full path, like C:\\Projects\\Site"); + } + return folder; +} + +export function crewHandlers(fake: FakeBotloft): Pick<Handlers, CrewMethods> { + return { + "crews.list": () => [...fake.crews.values()].filter((crew) => crew.archivedAt === null), + "crews.create": ({ name, workFolder, lead }) => { + const checked = checkName(name); + const slug = slugify(checked, "crew"); + const crew: Crew = { + id: fake.id("crw"), + name: checked, + slug, + workFolder: workFolder === undefined ? sharedFolder(slug) : checkFolder(workFolder), + workFolderChosen: workFolder !== undefined, + leadBotId: null, + paused: false, + createdAt: fake.now, + archivedAt: null, + }; + fake.crews.set(crew.id, crew); + fake.changedCrew(crew); + if (lead) { + const chief = botHandlers(fake)["bots.create"]({ crewId: crew.id, ...lead }); + crew.leadBotId = chief.id; + fake.changedCrew(crew); + } + return crew; + }, + "crews.setLead": ({ crewId, botId }) => { + const crew = fake.crew(crewId); + if (botId !== null && fake.bot(botId).crewId !== crewId) { + throw invalid(`bot ${botId} is not in crew ${crewId}`); + } + crew.leadBotId = botId; + return fake.changedCrew(crew); + }, + "crews.rename": ({ crewId, name }) => { + const crew = fake.crew(crewId); + crew.name = checkName(name); + return fake.changedCrew(crew); + }, + "crews.setPaused": ({ crewId, paused }) => { + const crew = fake.crew(crewId); + crew.paused = paused; + return fake.changedCrew(crew); + }, + "crews.setWorkFolder": ({ crewId, workFolder }) => { + const crew = fake.crew(crewId); + crew.workFolder = workFolder === null ? sharedFolder(crew.slug) : checkFolder(workFolder); + crew.workFolderChosen = workFolder !== null; + return fake.changedCrew(crew); + }, + "crews.archive": ({ crewId }) => { + const crew = fake.crew(crewId, false); + if (crew.archivedAt === null) { + crew.archivedAt = fake.now; + for (const bot of fake.activeBots(crewId)) { + bot.archivedAt = fake.now; + bot.state = "archived"; + fake.changedBot(bot); + } + fake.changedCrew(crew); + } + return crew; + }, + }; +} diff --git a/app/src/lib/fakeHost.ts b/app/src/lib/fakeHost.ts index f4190df1..957b18d4 100644 --- a/app/src/lib/fakeHost.ts +++ b/app/src/lib/fakeHost.ts @@ -23,6 +23,10 @@ export class FakeHost implements Host { afterInstall: DaemonStatus | Error = running(); token: string | Error = "a".repeat(64); readonly opened: string[] = []; + /** What the folder picker gives back; null is a cancel. */ + nextFolder: string | null = null; + /** Where each folder picker started. */ + readonly pickerStarts: (string | null)[] = []; readonly installs: ("install" | "restart")[] = []; /** Paths `signInToClaude` ran, and what it answers. */ readonly signIns: string[] = []; @@ -32,6 +36,8 @@ export class FakeHost implements Host { /** What `checkForUpdate` finds, or its error. */ update: AppUpdate | null | Error = null; updateChecks = 0; + /** The window's size, as the app last set it. */ + zoom = 1; maximized = false; closed = false; attention = false; @@ -57,6 +63,11 @@ export class FakeHost implements Host { return Promise.resolve(this.signInResult); } + setZoom(factor: number): Promise<void> { + this.zoom = factor; + return Promise.resolve(); + } + checkForUpdate(): Promise<AppUpdate | null> { this.updateChecks += 1; return this.update instanceof Error @@ -82,6 +93,11 @@ export class FakeHost implements Host { return Promise.resolve(); } + pickFolder(_title: string, start?: string): Promise<string | null> { + this.pickerStarts.push(start ?? null); + return Promise.resolve(this.nextFolder); + } + openUrl(url: string): Promise<void> { this.opened.push(url); return Promise.resolve(); diff --git a/app/src/lib/host.ts b/app/src/lib/host.ts index 2c9b3150..c41b33b0 100644 --- a/app/src/lib/host.ts +++ b/app/src/lib/host.ts @@ -57,11 +57,18 @@ export interface Host { * waits for it to end. Resolves whether it signed in. */ signInToClaude(claudePath: string): Promise<boolean>; + /** Draws the whole window at `factor` times its size (1 = 100%). */ + setZoom(factor: number): Promise<void>; /** A newer version of the app, or null when this one is the latest. */ checkForUpdate(): Promise<AppUpdate | null>; readOwnerToken(): Promise<string>; /** Opens a folder in Explorer. */ openPath(path: string): Promise<void>; + /** + * Asks the owner for a folder with Windows' folder picker, starting at + * `start` if given. Resolves null if they cancel. + */ + pickFolder(title: string, start?: string): Promise<string | null>; /** Opens an http(s) link in the default browser. */ openUrl(url: string): Promise<void>; window: AppWindow; diff --git a/app/src/lib/models.test.ts b/app/src/lib/models.test.ts new file mode 100644 index 00000000..b1777f26 --- /dev/null +++ b/app/src/lib/models.test.ts @@ -0,0 +1,17 @@ +import { describe, expect, test } from "vitest"; +import { modelFamily, modelName } from "./models"; + +describe("model names", () => { + test("Claude ids read as their family and version", () => { + expect(modelName("claude-opus-5-5")).toBe("Opus 5.5"); + expect(modelName("claude-haiku-4-5-20251001")).toBe("Haiku 4.5"); + expect(modelName("claude-fable-5-1")).toBe("Fable 5.1"); + expect(modelName("claude-sonnet-5")).toBe("Sonnet 5"); + expect(modelFamily("claude-sonnet-5-5")).toBe("sonnet"); + }); + + test("other ids stay as they are", () => { + expect(modelName("gpt-oss")).toBe("gpt-oss"); + expect(modelFamily("claude-opus-5-5[1m]")).toBeNull(); + }); +}); diff --git a/app/src/lib/models.ts b/app/src/lib/models.ts new file mode 100644 index 00000000..78f72bb4 --- /dev/null +++ b/app/src/lib/models.ts @@ -0,0 +1,19 @@ +// Names for the Claude model ids Claude Code reports (spec 7.4). + +const FAMILY = /^claude-(fable|opus|sonnet|haiku)-(\d+)(?:-(\d{1,2}))?(?:-\d{8})?$/; + +/** "claude-opus-5-5" -> "Opus 5.5"; an id it does not know stays as it is. */ +export function modelName(id: string): string { + const match = FAMILY.exec(id); + if (!match) { + return id; + } + const [, family = "", major, minor] = match; + const name = family.charAt(0).toUpperCase() + family.slice(1); + return minor === undefined ? `${name} ${major}` : `${name} ${major}.${minor}`; +} + +/** The family of a model id ("opus"), if it is one of Claude's. */ +export function modelFamily(id: string): string | null { + return FAMILY.exec(id)?.[1] ?? null; +} diff --git a/app/src/lib/protocol.gen.ts b/app/src/lib/protocol.gen.ts index 9fb5ac0c..bf236f1f 100644 --- a/app/src/lib/protocol.gen.ts +++ b/app/src/lib/protocol.gen.ts @@ -62,7 +62,21 @@ export type Crew = { id: CrewId, name: string, /** * Folder name under the workspaces root. Set at creation, never changes. */ -slug: string, paused: boolean, +slug: string, +/** + * Absolute path of the folder the crew works in (spec 5): one the owner + * chose, or the crew's `shared` folder. + */ +workFolder: string, +/** + * Whether the owner chose `work_folder`. + */ +workFolderChosen: boolean, +/** + * The bot that leads the crew and may suggest new bots (spec 10.2); + * `null` when the crew has no chief. + */ +leadBotId: BotId | null, paused: boolean, /** * Unix time in milliseconds. */ @@ -77,6 +91,18 @@ archivedAt: number | null, }; */ export type BotState = "offline" | "launching" | "idle" | "busy" | "needs_approval" | "rate_limited" | "auth_error" | "backoff" | "archived"; +/** + * How much a bot may do without asking the owner: Claude Code's + * permission modes (spec 7.4). + */ +export type PermissionMode = "default" | "accept_edits" | "plan" | "auto" | "bypass_permissions"; + +/** + * Which Claude model a bot runs on (spec 7.4): Claude Code's `--model` + * aliases, or the account's default. + */ +export type BotModel = "default" | "fable" | "opus" | "sonnet" | "haiku"; + /** * What the conversation-list line shows; the app words it. */ @@ -111,7 +137,12 @@ slug: string, role: string, instructions: string, /** * Avatar color, `#RRGGBB`. */ -color: string, paused: boolean, state: BotState, +color: string, paused: boolean, permissionMode: PermissionMode, model: BotModel, +/** + * The model id Claude Code reported when the bot last started a turn + * (`claude-opus-5-5`); `null` before its first turn. + */ +modelInUse: string | null, state: BotState, /** * Current process generation; `null` if the bot has not started since * the daemon did. Changes on every (re)start. @@ -190,6 +221,29 @@ resetsAt: number | null, windows: Array<UsageWindow>, */ observedAt: number, }; +/** + * What `claude auth status` says about the account (spec 7.3). + */ +export type ClaudeAccount = { email: string | null, +/** + * As Claude Code says it: `max`, `pro`, `team`, `enterprise`... + */ +plan: string | null, organization: string | null, }; + +/** + * The owner, as the app shows them in its account area (spec 15.1). + */ +export type OwnerAccount = { +/** + * The Windows account's display name, or the user name without one. + */ +name: string, +/** + * The Claude account Claude Code is signed in to; `null` when signed out + * or not checked yet. + */ +claude: ClaudeAccount | null, }; + export type SystemStatus = { daemonVersion: string, protocol: number, uptimeMs: number, /** * Version reported by `claude --version`; `null` until the runtime probe runs. @@ -206,18 +260,49 @@ claudePath: string | null, /** * Whether Claude Code is signed in (`claude auth status`); `null` until checked. */ -claudeSignedIn: boolean | null, deliveries: DeliveryBacklog, +claudeSignedIn: boolean | null, +/** + * Who the owner is, for the account area of the app. + */ +account: OwnerAccount, deliveries: DeliveryBacklog, /** * The Claude account's usage as last reported; `null` before any turn. */ usage: AccountUsage | null, }; -export type CrewsCreateParams = { name: string, }; +export type CrewsCreateParams = { name: string, +/** + * Absolute path of the folder the crew works in; the crew's `shared` + * folder when absent. + */ +workFolder?: string, +/** + * The chief, created with the crew (spec 10.2). + */ +lead?: NewLead, }; export type CrewsRenameParams = { crewId: CrewId, name: string, }; export type CrewsSetPausedParams = { crewId: CrewId, paused: boolean, }; +export type CrewsSetWorkFolderParams = { crewId: CrewId, +/** + * `null` goes back to the crew's `shared` folder. + */ +workFolder: string | null, }; + +/** + * The bot that leads a new crew. The app writes its name and role in the + * owner's language; the instructions carry the crew's goal. + */ +export type NewLead = { name: string, role: string, instructions: string, model?: BotModel, }; + +export type CrewsSetLeadParams = { crewId: CrewId, +/** + * `null` leaves the crew without a chief. + */ +botId: BotId | null, }; + export type CrewIdParams = { crewId: CrewId, }; export type BotsListParams = { @@ -230,7 +315,11 @@ export type BotsCreateParams = { crewId: CrewId, name: string, role: string, ins /** * Avatar color `#RRGGBB`; the next palette color when absent. */ -color?: string, }; +color?: string, +/** + * The account's default when absent. + */ +model?: BotModel, }; /** * Fields left out stay unchanged. @@ -239,6 +328,10 @@ export type BotsUpdateParams = { botId: BotId, name?: string, role?: string, ins export type BotsSetPausedParams = { botId: BotId, paused: boolean, }; +export type BotsSetPermissionModeParams = { botId: BotId, mode: PermissionMode, }; + +export type BotsSetModelParams = { botId: BotId, model: BotModel, }; + export type BotIdParams = { botId: BotId, }; export type BotsRestartParams = { botId: BotId, @@ -427,7 +520,7 @@ export type NoticeLevel = "info" | "warning" | "error"; /** * What a notice is about, so the app can say it in the owner's language. */ -export type NoticeCode = "signed_out" | "usage_limit" | "turn_failed"; +export type NoticeCode = "signed_out" | "usage_limit" | "turn_failed" | "model_unavailable"; export type InboundItem = { message: Message, }; @@ -532,7 +625,12 @@ export type ApprovalsAnswerParams = { approvalId: ApprovalId, allow: boolean, /** * Passed to the bot with a denial. */ -note?: string, }; +note?: string, +/** + * A bot suggestion as the owner changed it before allowing it, in the + * JSON of the tool's input (spec 10.2). Ignored for other requests. + */ +input?: string, }; /** Params and result of every request method. */ export interface RpcMethods { @@ -543,11 +641,15 @@ export interface RpcMethods { "crews.create": { params: CrewsCreateParams; result: Crew }; "crews.rename": { params: CrewsRenameParams; result: Crew }; "crews.setPaused": { params: CrewsSetPausedParams; result: Crew }; + "crews.setWorkFolder": { params: CrewsSetWorkFolderParams; result: Crew }; + "crews.setLead": { params: CrewsSetLeadParams; result: Crew }; "crews.archive": { params: CrewIdParams; result: Crew }; "bots.list": { params: BotsListParams; result: Array<Bot> }; "bots.create": { params: BotsCreateParams; result: Bot }; "bots.update": { params: BotsUpdateParams; result: Bot }; "bots.setPaused": { params: BotsSetPausedParams; result: Bot }; + "bots.setPermissionMode": { params: BotsSetPermissionModeParams; result: Bot }; + "bots.setModel": { params: BotsSetModelParams; result: Bot }; "bots.archive": { params: BotIdParams; result: Bot }; "bots.restart": { params: BotsRestartParams; result: Bot }; "chat.history": { params: ChatHistoryParams; result: Array<ChatItem> }; diff --git a/app/src/lib/tauriHost.ts b/app/src/lib/tauriHost.ts index b3630472..8c61491a 100644 --- a/app/src/lib/tauriHost.ts +++ b/app/src/lib/tauriHost.ts @@ -2,7 +2,9 @@ import { invoke } from "@tauri-apps/api/core"; import { Image } from "@tauri-apps/api/image"; +import { getCurrentWebview } from "@tauri-apps/api/webview"; import { getCurrentWindow } from "@tauri-apps/api/window"; +import { open } from "@tauri-apps/plugin-dialog"; import { check } from "@tauri-apps/plugin-updater"; import type { AppUpdate, DaemonStatus, Host } from "./host"; @@ -70,9 +72,19 @@ export function tauriHost(): Host { installDaemon: () => invoke<DaemonStatus>("daemon_install"), restartDaemon: () => invoke<DaemonStatus>("daemon_restart"), signInToClaude: (path) => invoke<boolean>("claude_sign_in", { path }), + setZoom: (factor) => getCurrentWebview().setZoom(factor), checkForUpdate, readOwnerToken: () => invoke<string>("read_owner_token"), openPath: (path) => invoke<void>("open_path", { path }), + pickFolder: async (title, start) => { + const picked = await open({ + directory: true, + multiple: false, + title, + ...(start ? { defaultPath: start } : {}), + }); + return typeof picked === "string" ? picked : null; + }, openUrl: (url) => invoke<void>("open_url", { url }), window: { minimize: () => window.minimize(), diff --git a/app/src/main.tsx b/app/src/main.tsx index 3b1f9880..76bde7fa 100644 --- a/app/src/main.tsx +++ b/app/src/main.tsx @@ -6,6 +6,7 @@ import type { Connect } from "./features/onboarding/link"; import { connect, rpcUrl } from "./lib/client"; import type { Host } from "./lib/host"; import { tauriHost } from "./lib/tauriHost"; +import { currentZoom } from "./shell/zoom"; import "./index.css"; const root = document.getElementById("root"); @@ -28,10 +29,12 @@ async function props(): Promise<{ host: Host; connect: Connect }> { throw new Error("Botloft runs inside its desktop app"); } -props().then(({ host, connect: open }) => +props().then(({ host, connect: open }) => { + // Before the first paint, so the window never flashes at the small size. + host.setZoom(currentZoom()).catch(() => {}); createRoot(root).render( <StrictMode> <App host={host} connect={open} /> </StrictMode>, - ), -); + ); +}); diff --git a/app/src/motion.css b/app/src/motion.css new file mode 100644 index 00000000..b72ad6b5 --- /dev/null +++ b/app/src/motion.css @@ -0,0 +1,283 @@ +/* Motion (spec 15.3): short and calm, so the app feels alive without + getting in the way. Everything stops when Windows turns animations off + (prefers-reduced-motion). */ + +:root { + --ease-out: cubic-bezier(0.2, 0.8, 0.2, 1); + --ease-spring: cubic-bezier(0.34, 1.45, 0.64, 1); + /* Lets heights animate to and from `auto` (details, collapsing rows). */ + interpolate-size: allow-keywords; +} + +@theme { + /* Something new in a list: a message, a tool call, a bot. */ + --animate-rise: rise 300ms var(--ease-out) both; + /* A menu or a dialog opening. */ + --animate-pop: pop 170ms var(--ease-out) both; + --animate-fade: fade 180ms ease-out both; + /* A notice sliding in from the side. */ + --animate-toast: toast 380ms var(--ease-spring) both; + /* The three dots of a bot thinking. */ + --animate-dot: dot 1.3s ease-in-out infinite; + /* A request that waits for the owner: one ring, once. */ + --animate-attention: attention 1.4s var(--ease-out) 1 both; + /* The hand of "needs approval", waving now and then. */ + --animate-wave: wave 2.4s ease-in-out infinite; + /* A gauge filling up. */ + --animate-grow: grow 800ms var(--ease-out) both; + /* A mascot floating on an empty page. */ + --animate-float: float 4s ease-in-out infinite; + + @keyframes rise { + from { + opacity: 0; + transform: translateY(10px); + } + } + + @keyframes pop { + from { + opacity: 0; + transform: scale(0.96) translateY(4px); + } + } + + @keyframes fade { + from { + opacity: 0; + } + } + + @keyframes toast { + from { + opacity: 0; + transform: translateX(28px) scale(0.98); + } + } + + @keyframes dot { + 0%, + 60%, + 100% { + transform: translateY(0); + opacity: 0.4; + } + 30% { + transform: translateY(-4px); + opacity: 1; + } + } + + @keyframes attention { + 0% { + box-shadow: 0 0 0 0 color-mix(in srgb, var(--warn) 40%, transparent); + } + 100% { + box-shadow: 0 0 0 14px color-mix(in srgb, var(--warn) 0%, transparent); + } + } + + @keyframes wave { + 0%, + 50%, + 100% { + transform: rotate(0); + } + 10%, + 30% { + transform: rotate(16deg); + } + 20%, + 40% { + transform: rotate(-10deg); + } + } + + @keyframes grow { + from { + transform: scaleX(0); + } + } + + @keyframes float { + 0%, + 100% { + transform: translateY(0); + } + 50% { + transform: translateY(-6px); + } + } +} + +@layer components { + /* The mascot (features/bots/BotAvatar.tsx). Its mood follows what the + bot does: it blinks, flickers while it works, hops while it waits for + the owner, and sleeps while paused. The state still has its own icon + and label. */ + .avatar-flame, + .avatar-eye { + transform-box: fill-box; + } + + .avatar-flame { + transform-origin: 50% 100%; + } + + .avatar-eye { + transform-origin: 50% 55%; + transition: transform 400ms var(--ease-out); + } + + [data-mood] .avatar-eye { + animation: blink 7s infinite; + animation-delay: var(--blink-delay, 0s); + } + + [data-mood="working"] .avatar-flame { + animation: flicker 1.5s ease-in-out infinite; + animation-delay: var(--blink-delay, 0s); + } + + [data-mood="waiting"] .avatar-flame { + animation: hop 2.6s var(--ease-out) infinite; + } + + [data-mood="sleeping"] .avatar-eye { + animation: none; + transform: scaleY(0.12); + } + + [data-mood="tired"] .avatar-eye { + animation: none; + transform: scaleY(0.45); + } + + /* Text still being written: a caret after the last line. */ + .chat-md.is-streaming > :is(p, h1, h2, h3, h4):last-child::after, + .chat-md.is-streaming > :is(ul, ol):last-child > li:last-child::after { + content: ""; + display: inline-block; + width: 0.5em; + height: 1.05em; + margin-left: 0.2em; + vertical-align: -0.2em; + border-radius: 2px; + background: var(--accent); + animation: caret 1.1s steps(2, jump-none) infinite; + } + + /* Opening and closing a <details> slides instead of jumping. */ + details::details-content { + block-size: 0; + overflow-y: clip; + transition: + block-size 240ms var(--ease-out), + content-visibility 240ms allow-discrete; + } + + details[open]::details-content { + block-size: auto; + } +} + +@keyframes blink { + 0%, + 45%, + 49%, + 100% { + transform: scaleY(1); + } + 47% { + transform: scaleY(0.1); + } +} + +@keyframes flicker { + 0%, + 100% { + transform: scale(1, 1) skewX(0deg); + } + 25% { + transform: scale(0.97, 1.04) skewX(-2deg); + } + 50% { + transform: scale(1.02, 0.98) skewX(1.5deg); + } + 75% { + transform: scale(0.99, 1.03) skewX(-1deg); + } +} + +@keyframes hop { + 0%, + 45%, + 100% { + transform: translateY(0) scale(1, 1); + } + 10% { + transform: translateY(0) scale(1.08, 0.92); + } + 22% { + transform: translateY(-12%) scale(0.96, 1.05); + } + 34% { + transform: translateY(0) scale(1.05, 0.95); + } +} + +@keyframes caret { + 0% { + opacity: 1; + } + 100% { + opacity: 0; + } +} + +/* Switching bots or crews: the main pane fades out and the new one rises + in; the rest of the window stays put (ui/motion.ts). */ +::view-transition-old(root), +::view-transition-new(root) { + animation: none; +} + +::view-transition-old(main-pane) { + animation: 110ms ease-out both view-out; +} + +::view-transition-new(main-pane) { + animation: 240ms var(--ease-out) both view-in; +} + +@keyframes view-out { + to { + opacity: 0; + } +} + +@keyframes view-in { + from { + opacity: 0; + transform: translateY(8px); + } +} + +/* biome-ignore-start lint/complexity/noImportantStyles: less motion must win over every animation, inline delays included */ +@media (prefers-reduced-motion: reduce) { + *, + *::before, + *::after, + ::details-content { + animation-duration: 0.01ms !important; + animation-iteration-count: 1 !important; + transition-duration: 0.01ms !important; + } + + ::view-transition-group(*), + ::view-transition-old(*), + ::view-transition-new(*) { + animation: none !important; + } +} +/* biome-ignore-end lint/complexity/noImportantStyles: less motion must win over every animation, inline delays included */ diff --git a/app/src/shell/TitleBar.tsx b/app/src/shell/TitleBar.tsx index 61874ef6..52bff414 100644 --- a/app/src/shell/TitleBar.tsx +++ b/app/src/shell/TitleBar.tsx @@ -1,33 +1,31 @@ // The window's own title bar (spec 15.3: `decorations: false`), with the -// Windows controls on the right. Empty space drags the window. +// Windows controls on the right. Empty space drags the window. Theme, size +// and language live in the account area of the sidebar (spec 15.1). -import { Copy, Languages, Minus, Monitor, Moon, Square, Sun, X } from "lucide-react"; +import { Copy, Languages, Minus, Square, X } from "lucide-react"; import { type ReactNode, useEffect, useState } from "react"; import { BotAvatar } from "../features/bots/BotAvatar"; import { LOCALES, setLocaleChoice, systemLocale, useLocale, useT } from "../i18n"; import { useHost } from "../store/context"; import { Menu } from "../ui/Menu"; -import { setTheme, type ThemeChoice, useTheme } from "./theme"; -const NEXT_THEME: Record<ThemeChoice, ThemeChoice> = { - system: "light", - light: "dark", - dark: "system", -}; -const THEME_ICON = { system: Monitor, light: Sun, dark: Moon }; - -export function TitleBar({ children, status }: { children?: ReactNode; status?: ReactNode }) { - const t = useT(); - const { choice } = useTheme(); - const ThemeIcon = THEME_ICON[choice]; - const themeName = t.shell.theme[choice]; +export function TitleBar({ + children, + status, + language = false, +}: { + children?: ReactNode; + status?: ReactNode; + /** Shows the language menu, for the setup screens that have no sidebar. */ + language?: boolean; +}) { return ( <header data-tauri-drag-region className="flex h-9 shrink-0 items-center border-line border-b bg-panel" > <div data-tauri-drag-region className="flex items-center gap-2 pr-4 pl-3"> - <BotAvatar color="#ffffff" size={18} /> + <BotAvatar color="#ffffff" size={18} framed /> <span data-tauri-drag-region className="font-semibold text-sm tracking-tight"> Botloft </span> @@ -37,16 +35,7 @@ export function TitleBar({ children, status }: { children?: ReactNode; status?: </div> <div className="flex items-center gap-1 pr-2"> {status} - <LanguageMenu /> - <button - type="button" - aria-label={t.shell.theme.label(themeName)} - title={t.shell.theme.hint(themeName)} - onClick={() => setTheme(NEXT_THEME[choice])} - className="grid h-7 w-7 place-items-center text-muted hover:bg-sunken hover:text-ink" - > - <ThemeIcon aria-hidden size={14} /> - </button> + {language && <LanguageMenu />} </div> <WindowControls /> </header> diff --git a/app/src/shell/Workspace.tsx b/app/src/shell/Workspace.tsx index 4bf49ca5..bef1788d 100644 --- a/app/src/shell/Workspace.tsx +++ b/app/src/shell/Workspace.tsx @@ -39,12 +39,18 @@ export function Workspace() { } else if (!loaded) { main = null; } else if (!hasCrews) { - main = <Welcome />; + // The sidebar stays, with the account area, before the first crew too. + main = ( + <div className="flex min-h-0 flex-1"> + <Sidebar /> + <Welcome /> + </div> + ); } else { main = ( <div className="flex min-h-0 flex-1"> <Sidebar /> - <main className="flex min-w-0 flex-1 flex-col"> + <main className="flex min-w-0 flex-1 flex-col [view-transition-name:main-pane]"> {runtimeError ? ( <div className="border-line border-b p-3"> <Callout tone="danger" title={t.shell.botsCantStart}> diff --git a/app/src/shell/zoom.test.tsx b/app/src/shell/zoom.test.tsx new file mode 100644 index 00000000..f9c611bb --- /dev/null +++ b/app/src/shell/zoom.test.tsx @@ -0,0 +1,67 @@ +import { cleanup, fireEvent, render, screen, waitFor, within } from "@testing-library/react"; +import { afterEach, describe, expect, test } from "vitest"; +import { App } from "../App"; +import type { Client } from "../lib/client"; +import { FakeBotloft } from "../lib/fake"; +import { FakeHost } from "../lib/fakeHost"; +import { currentZoom, DEFAULT_ZOOM, setZoom, stepZoom } from "./zoom"; + +afterEach(() => { + cleanup(); + setZoom(DEFAULT_ZOOM); +}); + +function renderApp() { + const host = new FakeHost(); + render(<App host={host} connect={() => new FakeBotloft() as Client} />); + return host; +} + +const key = (options: KeyboardEventInit) => fireEvent.keyDown(window, options); + +describe("app size", () => { + test("the app opens at the default size, bigger than the compact one", async () => { + const host = renderApp(); + await screen.findByRole("heading", { name: "Welcome to Botloft" }); + expect(DEFAULT_ZOOM).toBe(1.25); + expect(host.zoom).toBe(1.25); + }); + + test("settings set the size and remember it", async () => { + const host = renderApp(); + await screen.findByRole("heading", { name: "Welcome to Botloft" }); + fireEvent.click(screen.getByRole("button", { name: /Ana Lima/ })); + fireEvent.click(screen.getByRole("menuitem", { name: "Settings" })); + const sizes = screen.getByRole("radiogroup", { name: "Size" }); + expect( + (within(sizes).getByRole("radio", { name: "125% (default)" }) as HTMLInputElement).checked, + ).toBe(true); + fireEvent.click(within(sizes).getByRole("radio", { name: "150%" })); + await waitFor(() => expect(host.zoom).toBe(1.5)); + expect(localStorage.getItem("botloft.zoom")).toBe("1.5"); + }); + + test("Ctrl+= and Ctrl+- step through the sizes and Ctrl+0 goes back", async () => { + const host = renderApp(); + await screen.findByRole("heading", { name: "Welcome to Botloft" }); + key({ key: "=", ctrlKey: true }); + await waitFor(() => expect(host.zoom).toBe(1.5)); + key({ key: "-", ctrlKey: true }); + key({ key: "-", ctrlKey: true }); + key({ key: "-", ctrlKey: true }); + await waitFor(() => expect(host.zoom).toBe(1)); + key({ key: "0", ctrlKey: true }); + await waitFor(() => expect(host.zoom).toBe(1.25)); + key({ key: "=" }); + expect(currentZoom()).toBe(1.25); + }); + + test("the size stays within the levels", () => { + setZoom(1.5); + stepZoom(1); + expect(currentZoom()).toBe(1.5); + setZoom(1); + stepZoom(-1); + expect(currentZoom()).toBe(1); + }); +}); diff --git a/app/src/shell/zoom.ts b/app/src/shell/zoom.ts new file mode 100644 index 00000000..a3c04658 --- /dev/null +++ b/app/src/shell/zoom.ts @@ -0,0 +1,88 @@ +// How big the app is drawn (spec 15.3). The whole window scales, text, +// spacing and icons alike, like zooming a browser. 100% is the compact +// size the app was first drawn at; 125% is the default. Ctrl+= and Ctrl+- +// step through the levels and Ctrl+0 goes back to the default. The choice +// is a per-machine convenience kept in localStorage. + +import { useEffect, useSyncExternalStore } from "react"; +import type { Host } from "../lib/host"; + +export const ZOOM_LEVELS = [1, 1.1, 1.25, 1.5] as const; +export type ZoomLevel = (typeof ZOOM_LEVELS)[number]; +export const DEFAULT_ZOOM: ZoomLevel = 1.25; + +const KEY = "botloft.zoom"; +const listeners = new Set<() => void>(); + +function stored(): ZoomLevel { + try { + const value = Number(localStorage.getItem(KEY)); + return ZOOM_LEVELS.find((level) => level === value) ?? DEFAULT_ZOOM; + } catch { + return DEFAULT_ZOOM; + } +} + +let zoom: ZoomLevel = stored(); + +export function currentZoom(): ZoomLevel { + return zoom; +} + +export function setZoom(next: ZoomLevel): void { + zoom = next; + try { + localStorage.setItem(KEY, String(next)); + } catch { + // Private storage off: the choice lasts for this window. + } + for (const listener of listeners) { + listener(); + } +} + +/** One level bigger (1) or smaller (-1), staying within the levels. */ +export function stepZoom(direction: 1 | -1): void { + const index = ZOOM_LEVELS.indexOf(zoom) + direction; + const next = ZOOM_LEVELS[Math.min(ZOOM_LEVELS.length - 1, Math.max(0, index))]; + if (next !== undefined) { + setZoom(next); + } +} + +function subscribe(listener: () => void): () => void { + listeners.add(listener); + return () => listeners.delete(listener); +} + +export function useZoom(): ZoomLevel { + return useSyncExternalStore(subscribe, () => zoom); +} + +/** Draws the window at the chosen size and handles the zoom shortcuts. */ +export function useZoomRoot(host: Host): void { + const level = useZoom(); + useEffect(() => { + host.setZoom(level).catch(() => {}); + }, [host, level]); + + useEffect(() => { + const onKey = (event: KeyboardEvent) => { + if (!event.ctrlKey || event.altKey || event.metaKey) { + return; + } + if (event.key === "=" || event.key === "+") { + stepZoom(1); + } else if (event.key === "-") { + stepZoom(-1); + } else if (event.key === "0") { + setZoom(DEFAULT_ZOOM); + } else { + return; + } + event.preventDefault(); + }; + window.addEventListener("keydown", onKey); + return () => window.removeEventListener("keydown", onKey); + }, []); +} diff --git a/app/src/store/app.ts b/app/src/store/app.ts index b1ccb270..1ab7f709 100644 --- a/app/src/store/app.ts +++ b/app/src/store/app.ts @@ -15,6 +15,7 @@ import type { Task, TaskId, } from "../lib/protocol.gen"; +import { viewTransition } from "../ui/motion"; export interface AppState { connection: ConnectionState; @@ -80,11 +81,16 @@ export function createAppStore(api: BotloftApi): AppStore { tasks: {}, selectedCrewId: null, selectedBotId: null, - selectCrew: (crewId) => set({ selectedCrewId: crewId, selectedBotId: null }), + selectCrew: (crewId) => { + const { selectedCrewId, selectedBotId } = get(); + if (selectedCrewId !== crewId || selectedBotId !== null) { + viewTransition(() => set({ selectedCrewId: crewId, selectedBotId: null })); + } + }, selectBot: (botId) => { const bot = get().bots[botId]; - if (bot) { - set({ selectedCrewId: bot.crewId, selectedBotId: botId }); + if (bot && get().selectedBotId !== botId) { + viewTransition(() => set({ selectedCrewId: bot.crewId, selectedBotId: botId })); } }, putCrew: (crew) => set((state) => withCrew(state, crew)), diff --git a/app/src/ui/Button.tsx b/app/src/ui/Button.tsx index 58644b1f..c354a95a 100644 --- a/app/src/ui/Button.tsx +++ b/app/src/ui/Button.tsx @@ -35,7 +35,7 @@ export function Button({ type={type} aria-label={label} title={label} - className={`inline-flex shrink-0 items-center justify-center gap-1.5 rounded-[3px] font-medium transition-colors disabled:pointer-events-none disabled:opacity-45 ${height} ${padding} ${variants[variant]} ${className}`} + className={`inline-flex shrink-0 items-center justify-center gap-1.5 rounded-lg font-medium transition-[color,background-color,border-color,transform] duration-150 active:scale-[0.97] disabled:pointer-events-none disabled:opacity-45 ${height} ${padding} ${variants[variant]} ${className}`} {...rest} > {Icon && <Icon aria-hidden size={size === "sm" ? 14 : 15} strokeWidth={2} />} diff --git a/app/src/ui/Callout.tsx b/app/src/ui/Callout.tsx index 661df278..49891ec1 100644 --- a/app/src/ui/Callout.tsx +++ b/app/src/ui/Callout.tsx @@ -4,9 +4,9 @@ import type { ReactNode } from "react"; type Tone = "info" | "warn" | "danger"; const tones: Record<Tone, { icon: typeof Info; frame: string; mark: string }> = { - info: { icon: Info, frame: "border-line-strong", mark: "text-work" }, - warn: { icon: TriangleAlert, frame: "border-warn/60", mark: "text-warn" }, - danger: { icon: CircleAlert, frame: "border-danger/60", mark: "text-danger" }, + info: { icon: Info, frame: "border-line bg-panel", mark: "text-work" }, + warn: { icon: TriangleAlert, frame: "border-warn/45 bg-warn/6", mark: "text-warn" }, + danger: { icon: CircleAlert, frame: "border-danger/45 bg-danger/6", mark: "text-danger" }, }; export function Callout({ @@ -24,7 +24,7 @@ export function Callout({ return ( <div role={tone === "info" ? "status" : "alert"} - className={`flex items-start gap-3 border border-l-4 bg-panel px-3 py-2.5 ${frame}`} + className={`flex items-start gap-3 rounded-xl border px-3.5 py-3 ${frame}`} > <Icon aria-hidden size={16} className={`mt-0.5 shrink-0 ${mark}`} /> <div className="min-w-0 flex-1 text-sm"> diff --git a/app/src/ui/Choices.tsx b/app/src/ui/Choices.tsx new file mode 100644 index 00000000..3fcf409e --- /dev/null +++ b/app/src/ui/Choices.tsx @@ -0,0 +1,45 @@ +import { useId } from "react"; + +/** + * A short set of options where one is chosen, shown side by side. Real + * radio buttons underneath, so the arrow keys and screen readers work. + */ +export function Choices<T extends string | number>({ + label, + value, + options, + onChange, +}: { + label: string; + value: T; + options: readonly { value: T; label: string }[]; + onChange(value: T): void; +}) { + const name = useId(); + return ( + <div role="radiogroup" aria-label={label} className="flex flex-wrap gap-1.5"> + {options.map((option) => { + const chosen = option.value === value; + return ( + <label + key={String(option.value)} + className={`flex h-8 cursor-pointer items-center rounded-lg border px-3 text-sm has-[input:focus-visible]:outline-2 has-[input:focus-visible]:outline-accent ${ + chosen + ? "border-ink bg-ink text-canvas" + : "border-line-strong bg-panel text-ink hover:bg-sunken" + }`} + > + <input + type="radio" + name={name} + className="sr-only" + checked={chosen} + onChange={() => onChange(option.value)} + /> + {option.label} + </label> + ); + })} + </div> + ); +} diff --git a/app/src/ui/Dialog.tsx b/app/src/ui/Dialog.tsx index a4c3cf32..faf36925 100644 --- a/app/src/ui/Dialog.tsx +++ b/app/src/ui/Dialog.tsx @@ -28,22 +28,22 @@ export function Dialog({ title, onClose, children, footer, width = "md" }: Dialo }, [onClose]); return ( - <div className="fixed inset-0 z-40 grid place-items-center bg-black/55 p-6"> + <div className="fixed inset-0 z-40 grid animate-fade place-items-center bg-black/50 p-6"> <div role="dialog" aria-modal="true" aria-labelledby={titleId} - className={`flex max-h-full w-full flex-col border border-line-strong bg-panel ${width === "lg" ? "max-w-2xl" : "max-w-md"}`} + className={`flex max-h-full w-full animate-pop flex-col overflow-hidden rounded-2xl border border-line bg-panel shadow-lift ${width === "lg" ? "max-w-2xl" : "max-w-md"}`} > - <header className="flex h-11 shrink-0 items-center justify-between border-line border-b pr-1.5 pl-4"> + <header className="flex h-12 shrink-0 items-center justify-between border-line border-b pr-2 pl-5"> <h2 id={titleId} className="font-semibold text-base tracking-tight"> {title} </h2> <Button variant="ghost" icon={X} label={t.common.close} onClick={onClose} /> </header> - <div className="min-h-0 overflow-y-auto p-4">{children}</div> + <div className="min-h-0 overflow-y-auto px-5 py-4">{children}</div> {footer && ( - <footer className="flex shrink-0 justify-end gap-2 border-line border-t px-4 py-3"> + <footer className="flex shrink-0 justify-end gap-2 border-line border-t px-5 py-3"> {footer} </footer> )} diff --git a/app/src/ui/Field.tsx b/app/src/ui/Field.tsx index 0de24c9a..419edf8a 100644 --- a/app/src/ui/Field.tsx +++ b/app/src/ui/Field.tsx @@ -1,6 +1,7 @@ import { type InputHTMLAttributes, type ReactNode, + type SelectHTMLAttributes, type TextareaHTMLAttributes, useId, } from "react"; @@ -41,7 +42,7 @@ function Frame({ } const control = - "w-full rounded-[3px] border border-line-strong bg-canvas px-2.5 text-ink text-sm outline-none placeholder:text-muted focus:border-accent"; + "w-full rounded-lg border border-line-strong bg-canvas px-2.5 text-ink text-sm outline-none placeholder:text-muted focus:border-accent"; export function TextField({ label, @@ -72,3 +73,25 @@ export function TextArea({ </Frame> ); } + +export function SelectField({ + label, + hint, + options, + ...select +}: Framing & { + options: { value: string; label: string }[]; +} & SelectHTMLAttributes<HTMLSelectElement>) { + const id = useId(); + return ( + <Frame id={id} label={label} hint={hint}> + <select id={id} className={`${control} h-8`} {...select}> + {options.map((option) => ( + <option key={option.value} value={option.value}> + {option.label} + </option> + ))} + </select> + </Frame> + ); +} diff --git a/app/src/ui/Menu.tsx b/app/src/ui/Menu.tsx index 72c48006..8341378f 100644 --- a/app/src/ui/Menu.tsx +++ b/app/src/ui/Menu.tsx @@ -1,6 +1,8 @@ import { Check, type LucideIcon } from "lucide-react"; -import { useEffect, useRef, useState } from "react"; +import { useCallback, useRef, useState } from "react"; import { Button } from "./Button"; +import { POPOVER, POPOVER_ITEM } from "./surface"; +import { useDismiss } from "./useDismiss"; export interface MenuItem { label: string; @@ -25,23 +27,11 @@ export function Menu({ const [open, setOpen] = useState(false); const root = useRef<HTMLDivElement>(null); - useEffect(() => { - if (!open) { - return; - } - const onPointer = (event: PointerEvent) => { - if (!root.current?.contains(event.target as Node)) { - setOpen(false); - } - }; - const onKey = (event: KeyboardEvent) => event.key === "Escape" && setOpen(false); - window.addEventListener("pointerdown", onPointer); - window.addEventListener("keydown", onKey); - return () => { - window.removeEventListener("pointerdown", onPointer); - window.removeEventListener("keydown", onKey); - }; - }, [open]); + useDismiss( + open, + root, + useCallback(() => setOpen(false), []), + ); return ( <div ref={root} className="relative"> @@ -56,7 +46,7 @@ export function Menu({ {open && ( <div role="menu" - className="absolute top-full right-0 z-30 mt-1 min-w-60 border border-line-strong bg-panel py-1" + className={`absolute top-full right-0 mt-1 min-w-60 origin-top-right ${POPOVER}`} > {items.map(({ label: itemLabel, icon: Icon, danger, disabled, checked, onSelect }) => ( <button @@ -70,7 +60,7 @@ export function Menu({ setOpen(false); onSelect(); }} - className={`flex h-8 w-full items-center gap-2 whitespace-nowrap px-3 text-left text-sm hover:bg-sunken disabled:opacity-45 ${danger ? "text-danger" : "text-ink"}`} + className={`h-8 whitespace-nowrap ${POPOVER_ITEM} ${danger ? "text-danger" : "text-ink"}`} > {Icon && <Icon aria-hidden size={14} />} {checked !== undefined && ( diff --git a/app/src/ui/Tabs.tsx b/app/src/ui/Tabs.tsx index 11a0af98..5b37df5e 100644 --- a/app/src/ui/Tabs.tsx +++ b/app/src/ui/Tabs.tsx @@ -1,9 +1,14 @@ +import { useLayoutEffect, useRef, useState } from "react"; + export interface Tab<T extends string> { id: T; label: string; } -/** A row of tabs; the panels are the caller's, labelled by `tabId(id)`. */ +/** + * A row of tabs; the panels are the caller's, labelled by `tabId(id)`. The + * accent line under the selected tab slides to the next one. + */ export function Tabs<T extends string>({ label, tabs, @@ -15,11 +20,23 @@ export function Tabs<T extends string>({ value: T; onChange(value: T): void; }) { + const list = useRef<HTMLDivElement>(null); + const [line, setLine] = useState<{ left: number; width: number } | null>(null); + + // biome-ignore lint/correctness/useExhaustiveDependencies: re-measured when the selection or the tabs change + useLayoutEffect(() => { + const selected = list.current?.querySelector<HTMLElement>('[aria-selected="true"]'); + if (selected) { + setLine({ left: selected.offsetLeft + 4, width: selected.offsetWidth - 8 }); + } + }, [value, tabs]); + return ( <div + ref={list} role="tablist" aria-label={label} - className="flex h-9 shrink-0 gap-1 border-line border-b px-3" + className="relative flex h-9 shrink-0 gap-1 border-line border-b px-3" > {tabs.map((tab) => { const selected = tab.id === value; @@ -31,12 +48,19 @@ export function Tabs<T extends string>({ role="tab" aria-selected={selected} onClick={() => onChange(tab.id)} - className={`relative px-2.5 font-medium text-sm ${selected ? "text-ink after:absolute after:inset-x-1 after:bottom-0 after:h-0.5 after:bg-accent" : "text-muted hover:text-ink"}`} + className={`px-2.5 font-medium text-sm transition-colors ${selected ? "text-ink" : "text-muted hover:text-ink"}`} > {tab.label} </button> ); })} + {line && ( + <span + aria-hidden + className="absolute bottom-0 h-0.5 rounded-full bg-accent transition-[left,width] duration-300 ease-[var(--ease-out)]" + style={{ left: line.left, width: line.width }} + /> + )} </div> ); } diff --git a/app/src/ui/motion.test.tsx b/app/src/ui/motion.test.tsx new file mode 100644 index 00000000..fe9218fb --- /dev/null +++ b/app/src/ui/motion.test.tsx @@ -0,0 +1,93 @@ +import { act, cleanup, render, screen, within } from "@testing-library/react"; +import { afterEach, describe, expect, test, vi } from "vitest"; +import { moodOf } from "../features/bots/BotAvatar"; +import { FakeBotloft } from "../lib/fake"; +import { crewOpened, openBot, renderApp } from "../test/app"; +import { SeenSince, useArrival, viewTransition } from "./motion"; + +afterEach(() => { + cleanup(); + vi.unstubAllGlobals(); + Reflect.deleteProperty(document, "startViewTransition"); +}); + +describe("the mascot's mood", () => { + test("follows what the bot does", () => { + const bot = (state: Parameters<typeof moodOf>[0]["state"], paused = false) => + moodOf({ state, paused }); + expect(bot("idle")).toBe("idle"); + expect(bot("busy")).toBe("working"); + expect(bot("launching")).toBe("working"); + expect(bot("needs_approval")).toBe("waiting"); + expect(bot("rate_limited")).toBe("tired"); + expect(bot("offline")).toBe("sleeping"); + expect(bot("idle", true)).toBe("sleeping"); + expect(moodOf({ state: "busy", paused: false }, true)).toBe("sleeping"); + }); +}); + +describe("arrivals", () => { + function Item({ at }: { at: number }) { + return <p className={useArrival(at)}>{`item ${at}`}</p>; + } + + test("only what came after the owner started looking animates", () => { + render( + <SeenSince.Provider value={100}> + <Item at={50} /> + <Item at={150} /> + </SeenSince.Provider>, + ); + expect(screen.getByText("item 50").className).toBe(""); + expect(screen.getByText("item 150").className).toBe("animate-rise"); + }); + + test("a chat's history stays still and a new message rises in", async () => { + const fake = new FakeBotloft(); + const ops = fake.addCrew("Ops"); + const scout = fake.addBot(ops.id, "Scout"); + fake.setBotState(scout.id, "idle"); + fake.chat.add(scout.id, { kind: "reply", text: "From before" }); + fake.chat.turn(scout.id); + renderApp(fake); + await crewOpened("Ops"); + openBot("Scout"); + const messages = await screen.findByRole("list", { name: "Messages" }); + const before = within(messages).getByText("From before").closest("li"); + expect(before?.className).not.toContain("animate-rise"); + + act(() => { + fake.now = Date.now() + 1000; + void fake.call("messages.send", { botId: scout.id, body: "Something new" }); + }); + const fresh = await within(messages).findByText("Something new"); + expect(fresh.closest("li")?.className).toContain("animate-rise"); + }); +}); + +describe("view transitions", () => { + test("run the change at once where the webview has none", () => { + const update = vi.fn(); + viewTransition(update); + expect(update).toHaveBeenCalledOnce(); + }); + + test("go through the webview's transition when it has one", () => { + const start = vi.fn((run: () => void) => run()); + Object.assign(document, { startViewTransition: start }); + const update = vi.fn(); + viewTransition(update); + expect(start).toHaveBeenCalledOnce(); + expect(update).toHaveBeenCalledOnce(); + }); + + test("skip the transition when Windows asks for less motion", () => { + const start = vi.fn((run: () => void) => run()); + Object.assign(document, { startViewTransition: start }); + vi.stubGlobal("matchMedia", (query: string) => ({ matches: query.includes("reduce") })); + const update = vi.fn(); + viewTransition(update); + expect(start).not.toHaveBeenCalled(); + expect(update).toHaveBeenCalledOnce(); + }); +}); diff --git a/app/src/ui/motion.ts b/app/src/ui/motion.ts new file mode 100644 index 00000000..f1f26b3a --- /dev/null +++ b/app/src/ui/motion.ts @@ -0,0 +1,43 @@ +// Helpers for motion (spec 15.3): switching views with a short transition, +// and telling what is new since the owner started looking, so only that +// animates in. + +import { createContext, useContext } from "react"; +import { flushSync } from "react-dom"; + +/** Whether Windows asked for less motion ("Animation effects" off). */ +export function reducedMotion(): boolean { + return ( + typeof window.matchMedia === "function" && + window.matchMedia("(prefers-reduced-motion: reduce)").matches + ); +} + +type WithTransitions = Document & { startViewTransition?(update: () => void): unknown }; + +/** + * Applies a change of view (another bot or crew) as a short transition of + * the main pane, where the webview can; otherwise at once. + */ +export function viewTransition(update: () => void): void { + const doc = document as WithTransitions; + if (typeof doc.startViewTransition !== "function" || reducedMotion()) { + update(); + return; + } + doc.startViewTransition(() => flushSync(update)); +} + +/** When the app opened: a bot created after it is new to the owner. */ +export const APP_OPENED = Date.now(); + +/** + * When the owner opened what they look at (a chat). Items created before + * it were already there and stay still; later ones animate in. + */ +export const SeenSince = createContext<number>(Number.POSITIVE_INFINITY); + +/** The class that animates an item in, if it is new. */ +export function useArrival(createdAt: number): string { + return createdAt > useContext(SeenSince) ? "animate-rise" : ""; +} diff --git a/app/src/ui/surface.ts b/app/src/ui/surface.ts new file mode 100644 index 00000000..4b83045a --- /dev/null +++ b/app/src/ui/surface.ts @@ -0,0 +1,8 @@ +// Shared looks for floating panels, so menus and pickers match. + +/** A menu or picker floating over the page; add the `origin-*` it opens from. */ +export const POPOVER = "z-30 animate-pop rounded-xl border border-line bg-panel p-1 shadow-lift"; + +/** One row of a popover. */ +export const POPOVER_ITEM = + "flex w-full items-center gap-2 rounded-lg px-2.5 text-left text-sm hover:bg-sunken disabled:opacity-45"; diff --git a/app/src/ui/toast.tsx b/app/src/ui/toast.tsx index a513d3de..5689756c 100644 --- a/app/src/ui/toast.tsx +++ b/app/src/ui/toast.tsx @@ -46,7 +46,7 @@ export function Toaster() { <div key={toast.id} role="alert" - className="pointer-events-auto flex items-start gap-2 border border-danger/60 border-l-4 bg-panel py-2 pr-1.5 pl-3 text-sm" + className="pointer-events-auto flex animate-toast items-start gap-2 rounded-xl border border-danger/45 bg-panel py-2.5 pr-2 pl-3.5 text-sm shadow-lift" > <p className="min-w-0 flex-1 break-words" data-selectable> {toast.text} @@ -55,7 +55,7 @@ export function Toaster() { type="button" aria-label={t.common.dismiss} onClick={() => dismiss(toast.id)} - className="grid h-6 w-6 shrink-0 place-items-center text-muted hover:text-ink" + className="grid h-6 w-6 shrink-0 place-items-center rounded-md text-muted hover:bg-sunken hover:text-ink" > <X aria-hidden size={14} /> </button> diff --git a/app/src/ui/useDismiss.ts b/app/src/ui/useDismiss.ts new file mode 100644 index 00000000..4d9455ec --- /dev/null +++ b/app/src/ui/useDismiss.ts @@ -0,0 +1,22 @@ +import { type RefObject, useEffect } from "react"; + +/** Closes a popover on Escape or a click outside `root`, while it is open. */ +export function useDismiss(open: boolean, root: RefObject<HTMLElement | null>, close: () => void) { + useEffect(() => { + if (!open) { + return; + } + const onPointer = (event: PointerEvent) => { + if (!root.current?.contains(event.target as Node)) { + close(); + } + }; + const onKey = (event: KeyboardEvent) => event.key === "Escape" && close(); + window.addEventListener("pointerdown", onPointer); + window.addEventListener("keydown", onKey); + return () => { + window.removeEventListener("pointerdown", onPointer); + window.removeEventListener("keydown", onKey); + }; + }, [open, root, close]); +} diff --git a/crates/botloft-core/src/chat.rs b/crates/botloft-core/src/chat.rs index 3c8405e9..779ffcfa 100644 --- a/crates/botloft-core/src/chat.rs +++ b/crates/botloft-core/src/chat.rs @@ -7,6 +7,14 @@ use crate::protocol::{ActivityKind, ChatBody, SenderKind}; /// Longest tool input kept, in bytes. pub const TOOL_INPUT_MAX: usize = 4 * 1024; +/// Longest plan kept, in bytes: the owner reads all of it to approve it. +pub const PLAN_INPUT_MAX: usize = 32 * 1024; +/// The tool Claude Code uses to leave plan mode with a plan (spec 10.1). +pub const PLAN_TOOL: &str = "ExitPlanMode"; +/// The chief's tool to suggest a new bot (spec 10.2). +pub const SUGGEST_TOOL: &str = "mcp__botloft__suggest_bot"; +/// Longest suggestion kept, in bytes: the owner reads and edits all of it. +pub const SUGGESTION_INPUT_MAX: usize = 64 * 1024; /// Longest tool output kept, in bytes. pub const TOOL_OUTPUT_MAX: usize = 8 * 1024; /// Longest activity line, in characters. @@ -37,6 +45,15 @@ pub fn one_line(text: &str, max: usize) -> String { format!("{}…", cut.trim_end()) } +/// Longest input kept for `tool`, in bytes. +pub fn tool_input_max(tool: &str) -> usize { + match tool { + PLAN_TOOL => PLAN_INPUT_MAX, + SUGGEST_TOOL => SUGGESTION_INPUT_MAX, + _ => TOOL_INPUT_MAX, + } +} + fn field<'a>(input: &'a Value, name: &str) -> Option<&'a str> { input.get(name).and_then(Value::as_str) } @@ -59,6 +76,13 @@ pub fn tool_summary(name: &str, input: &Value) -> String { "WebSearch" => field(input, "query").map(str::to_owned), "Task" | "Agent" => field(input, "description").map(str::to_owned), "TodoWrite" => Some("Updated the plan".to_owned()), + // The plan's first line, usually its title. + PLAN_TOOL => field(input, "plan").and_then(|plan| { + plan.lines() + .map(|line| line.trim_start_matches('#').trim()) + .find(|line| !line.is_empty()) + .map(str::to_owned) + }), // Claude Code loads deferred tools (such as ours) by name first. "ToolSearch" => field(input, "query").map(|query| match query.strip_prefix("select:") { Some(names) => { @@ -71,6 +95,7 @@ pub fn tool_summary(name: &str, input: &Value) -> String { field(input, "to").map(|to| format!("to @{}", to.trim_start_matches('@'))) } "mcp__botloft__complete_task" => field(input, "task_id").map(|id| format!("task {id}")), + SUGGEST_TOOL => field(input, "name").map(str::to_owned), _ => None, }; one_line(&summary.unwrap_or_default(), SUMMARY_MAX_CHARS) @@ -171,6 +196,16 @@ mod tests { "notebook jupyter" ); assert_eq!(tool_summary("SomethingNew", &json!({ "a": 1 })), ""); + assert_eq!( + tool_summary( + PLAN_TOOL, + &json!({ "plan": " +## Move the cache + +1. Read" }) + ), + "Move the cache" + ); assert_eq!(tool_label("mcp__botloft__send_message"), "send_message"); assert_eq!(tool_label("Bash"), "Bash"); } diff --git a/crates/botloft-core/src/protocol/chat.rs b/crates/botloft-core/src/protocol/chat.rs index b7676717..f8ac8ad4 100644 --- a/crates/botloft-core/src/protocol/chat.rs +++ b/crates/botloft-core/src/protocol/chat.rs @@ -42,6 +42,8 @@ text_enum!( UsageLimit => "usage_limit", /// The turn failed; `text` holds Claude Code's detail or error code. TurnFailed => "turn_failed", + /// The bot's model does not exist or the account cannot use it. + ModelUnavailable => "model_unavailable", } ); @@ -220,6 +222,11 @@ pub struct ApprovalsAnswerParams { #[serde(default)] #[cfg_attr(test, ts(optional))] pub note: Option<String>, + /// A bot suggestion as the owner changed it before allowing it, in the + /// JSON of the tool's input (spec 10.2). Ignored for other requests. + #[serde(default)] + #[cfg_attr(test, ts(optional))] + pub input: Option<String>, } /// The last thing in a bot's chat, for the conversation list. diff --git a/crates/botloft-core/src/protocol/export.rs b/crates/botloft-core/src/protocol/export.rs index db1db5a5..fd49d7aa 100644 --- a/crates/botloft-core/src/protocol/export.rs +++ b/crates/botloft-core/src/protocol/export.rs @@ -87,6 +87,8 @@ fn export_bindings() { out.decl::<AttachmentId>(); out.decl::<Crew>(); out.decl::<BotState>(); + out.decl::<PermissionMode>(); + out.decl::<BotModel>(); out.decl::<ActivityKind>(); out.decl::<Activity>(); out.decl::<Bot>(); @@ -96,15 +98,22 @@ fn export_bindings() { out.decl::<DeliveryBacklog>(); out.decl::<UsageWindow>(); out.decl::<AccountUsage>(); + out.decl::<ClaudeAccount>(); + out.decl::<OwnerAccount>(); out.decl::<SystemStatus>(); out.decl::<CrewsCreateParams>(); out.decl::<CrewsRenameParams>(); out.decl::<CrewsSetPausedParams>(); + out.decl::<CrewsSetWorkFolderParams>(); + out.decl::<NewLead>(); + out.decl::<CrewsSetLeadParams>(); out.decl::<CrewIdParams>(); out.decl::<BotsListParams>(); out.decl::<BotsCreateParams>(); out.decl::<BotsUpdateParams>(); out.decl::<BotsSetPausedParams>(); + out.decl::<BotsSetPermissionModeParams>(); + out.decl::<BotsSetModelParams>(); out.decl::<BotIdParams>(); out.decl::<BotsRestartParams>(); out.decl::<BotStateChanged>(); @@ -181,6 +190,16 @@ fn export_bindings() { &out.name::<CrewsSetPausedParams>(), &crew, ); + out.method( + method::CREWS_SET_WORK_FOLDER, + &out.name::<CrewsSetWorkFolderParams>(), + &crew, + ); + out.method( + method::CREWS_SET_LEAD, + &out.name::<CrewsSetLeadParams>(), + &crew, + ); out.method(method::CREWS_ARCHIVE, &out.name::<CrewIdParams>(), &crew); out.method(method::BOTS_LIST, &out.name::<BotsListParams>(), &bots); out.method(method::BOTS_CREATE, &out.name::<BotsCreateParams>(), &bot); @@ -190,6 +209,16 @@ fn export_bindings() { &out.name::<BotsSetPausedParams>(), &bot, ); + out.method( + method::BOTS_SET_PERMISSION_MODE, + &out.name::<BotsSetPermissionModeParams>(), + &bot, + ); + out.method( + method::BOTS_SET_MODEL, + &out.name::<BotsSetModelParams>(), + &bot, + ); out.method(method::BOTS_ARCHIVE, &out.name::<BotIdParams>(), &bot); out.method(method::BOTS_RESTART, &out.name::<BotsRestartParams>(), &bot); out.method( diff --git a/crates/botloft-core/src/protocol/methods.rs b/crates/botloft-core/src/protocol/methods.rs index 342c2df9..db17f0d3 100644 --- a/crates/botloft-core/src/protocol/methods.rs +++ b/crates/botloft-core/src/protocol/methods.rs @@ -4,7 +4,7 @@ use std::fmt; use serde::{Deserialize, Serialize}; -use super::DeliveryBacklog; +use super::{BotModel, DeliveryBacklog, PermissionMode}; use crate::ids::{BotId, CrewId}; /// Identifies the connecting app in `session.hello`. @@ -60,11 +60,36 @@ pub struct SystemStatus { pub claude_path: Option<String>, /// Whether Claude Code is signed in (`claude auth status`); `null` until checked. pub claude_signed_in: Option<bool>, + /// Who the owner is, for the account area of the app. + pub account: OwnerAccount, pub deliveries: DeliveryBacklog, /// The Claude account's usage as last reported; `null` before any turn. pub usage: Option<AccountUsage>, } +/// The owner, as the app shows them in its account area (spec 15.1). +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +#[cfg_attr(test, derive(ts_rs::TS))] +pub struct OwnerAccount { + /// The Windows account's display name, or the user name without one. + pub name: String, + /// The Claude account Claude Code is signed in to; `null` when signed out + /// or not checked yet. + pub claude: Option<ClaudeAccount>, +} + +/// What `claude auth status` says about the account (spec 7.3). +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +#[cfg_attr(test, derive(ts_rs::TS))] +pub struct ClaudeAccount { + pub email: Option<String>, + /// As Claude Code says it: `max`, `pro`, `team`, `enterprise`... + pub plan: Option<String>, + pub organization: Option<String>, +} + /// The account's usage, from Claude Code's `rate_limit_event` (spec 8.1). #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] @@ -96,6 +121,47 @@ pub struct UsageWindow { #[cfg_attr(test, derive(ts_rs::TS))] pub struct CrewsCreateParams { pub name: String, + /// Absolute path of the folder the crew works in; the crew's `shared` + /// folder when absent. + #[serde(default)] + #[cfg_attr(test, ts(optional))] + pub work_folder: Option<String>, + /// The chief, created with the crew (spec 10.2). + #[serde(default)] + #[cfg_attr(test, ts(optional))] + pub lead: Option<NewLead>, +} + +/// The bot that leads a new crew. The app writes its name and role in the +/// owner's language; the instructions carry the crew's goal. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +#[cfg_attr(test, derive(ts_rs::TS))] +pub struct NewLead { + pub name: String, + pub role: String, + pub instructions: String, + #[serde(default)] + #[cfg_attr(test, ts(optional))] + pub model: Option<BotModel>, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +#[cfg_attr(test, derive(ts_rs::TS))] +pub struct CrewsSetLeadParams { + pub crew_id: CrewId, + /// `null` leaves the crew without a chief. + pub bot_id: Option<BotId>, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +#[cfg_attr(test, derive(ts_rs::TS))] +pub struct CrewsSetWorkFolderParams { + pub crew_id: CrewId, + /// `null` goes back to the crew's `shared` folder. + pub work_folder: Option<String>, } #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] @@ -143,6 +209,10 @@ pub struct BotsCreateParams { #[serde(default)] #[cfg_attr(test, ts(optional))] pub color: Option<String>, + /// The account's default when absent. + #[serde(default)] + #[cfg_attr(test, ts(optional))] + pub model: Option<BotModel>, } /// Fields left out stay unchanged. @@ -173,6 +243,22 @@ pub struct BotsSetPausedParams { pub paused: bool, } +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +#[cfg_attr(test, derive(ts_rs::TS))] +pub struct BotsSetPermissionModeParams { + pub bot_id: BotId, + pub mode: PermissionMode, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +#[cfg_attr(test, derive(ts_rs::TS))] +pub struct BotsSetModelParams { + pub bot_id: BotId, + pub model: BotModel, +} + #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] #[cfg_attr(test, derive(ts_rs::TS))] diff --git a/crates/botloft-core/src/protocol/mod.rs b/crates/botloft-core/src/protocol/mod.rs index 00883bb4..d4f70d9e 100644 --- a/crates/botloft-core/src/protocol/mod.rs +++ b/crates/botloft-core/src/protocol/mod.rs @@ -74,11 +74,15 @@ pub mod method { pub const CREWS_CREATE: &str = "crews.create"; pub const CREWS_RENAME: &str = "crews.rename"; pub const CREWS_SET_PAUSED: &str = "crews.setPaused"; + pub const CREWS_SET_WORK_FOLDER: &str = "crews.setWorkFolder"; + pub const CREWS_SET_LEAD: &str = "crews.setLead"; pub const CREWS_ARCHIVE: &str = "crews.archive"; pub const BOTS_LIST: &str = "bots.list"; pub const BOTS_CREATE: &str = "bots.create"; pub const BOTS_UPDATE: &str = "bots.update"; pub const BOTS_SET_PAUSED: &str = "bots.setPaused"; + pub const BOTS_SET_PERMISSION_MODE: &str = "bots.setPermissionMode"; + pub const BOTS_SET_MODEL: &str = "bots.setModel"; pub const BOTS_ARCHIVE: &str = "bots.archive"; pub const BOTS_RESTART: &str = "bots.restart"; pub const CHAT_HISTORY: &str = "chat.history"; diff --git a/crates/botloft-core/src/protocol/model.rs b/crates/botloft-core/src/protocol/model.rs index 5311dd63..7d890865 100644 --- a/crates/botloft-core/src/protocol/model.rs +++ b/crates/botloft-core/src/protocol/model.rs @@ -14,6 +14,14 @@ pub struct Crew { pub name: String, /// Folder name under the workspaces root. Set at creation, never changes. pub slug: String, + /// Absolute path of the folder the crew works in (spec 5): one the owner + /// chose, or the crew's `shared` folder. + pub work_folder: String, + /// Whether the owner chose `work_folder`. + pub work_folder_chosen: bool, + /// The bot that leads the crew and may suggest new bots (spec 10.2); + /// `null` when the crew has no chief. + pub lead_bot_id: Option<BotId>, pub paused: bool, /// Unix time in milliseconds. pub created_at: i64, @@ -37,6 +45,75 @@ pub enum BotState { Archived, } +text_enum!( + /// How much a bot may do without asking the owner: Claude Code's + /// permission modes (spec 7.4). + PermissionMode, "permission mode" { + /// Asks before edits, commands and the network ("Manual"). + Default => "default", + /// Edits files and runs common file commands without asking. + AcceptEdits => "accept_edits", + /// Plans first, then asks to go ahead with the plan. + Plan => "plan", + /// A classifier reviews each action; what it does not allow is asked. + Auto => "auto", + /// Does everything without asking. + BypassPermissions => "bypass_permissions", + } +); + +impl PermissionMode { + /// The value of Claude Code's `--permission-mode`, and what it reports + /// in `system/init`. + pub fn cli_value(self) -> &'static str { + match self { + Self::Default => "default", + Self::AcceptEdits => "acceptEdits", + Self::Plan => "plan", + Self::Auto => "auto", + Self::BypassPermissions => "bypassPermissions", + } + } + + pub fn from_cli(value: &str) -> Option<Self> { + [ + Self::Default, + Self::AcceptEdits, + Self::Plan, + Self::Auto, + Self::BypassPermissions, + ] + .into_iter() + .find(|mode| mode.cli_value() == value) + } +} + +text_enum!( + /// Which Claude model a bot runs on (spec 7.4): Claude Code's `--model` + /// aliases, or the account's default. + BotModel, "model" { + /// No `--model`: the default of the owner's Claude plan. + Default => "default", + Fable => "fable", + Opus => "opus", + Sonnet => "sonnet", + Haiku => "haiku", + } +); + +impl BotModel { + /// The value of Claude Code's `--model`; `None` leaves the flag out. + pub fn cli_value(self) -> Option<&'static str> { + match self { + Self::Default => None, + Self::Fable => Some("fable"), + Self::Opus => Some("opus"), + Self::Sonnet => Some("sonnet"), + Self::Haiku => Some("haiku"), + } + } +} + /// A persistent Claude Code session with a name, a role and instructions. #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] @@ -55,6 +132,11 @@ pub struct Bot { /// Avatar color, `#RRGGBB`. pub color: String, pub paused: bool, + pub permission_mode: PermissionMode, + pub model: BotModel, + /// The model id Claude Code reported when the bot last started a turn + /// (`claude-opus-5-5`); `null` before its first turn. + pub model_in_use: Option<String>, pub state: BotState, /// Current process generation; `null` if the bot has not started since /// the daemon did. Changes on every (re)start. diff --git a/crates/botloft-store/migrations/0004_permission_mode.sql b/crates/botloft-store/migrations/0004_permission_mode.sql new file mode 100644 index 00000000..ccc2fe85 --- /dev/null +++ b/crates/botloft-store/migrations/0004_permission_mode.sql @@ -0,0 +1,3 @@ +-- How much each bot may do without asking (spec 7.4). Existing bots keep +-- asking before everything, as they did. +ALTER TABLE bots ADD COLUMN permission_mode TEXT NOT NULL DEFAULT 'default'; diff --git a/crates/botloft-store/migrations/0005_bot_model.sql b/crates/botloft-store/migrations/0005_bot_model.sql new file mode 100644 index 00000000..2c93cd73 --- /dev/null +++ b/crates/botloft-store/migrations/0005_bot_model.sql @@ -0,0 +1,4 @@ +-- Which Claude model each bot runs on (spec 7.4), and the model Claude Code +-- last reported. Existing bots keep the account's default, as they did. +ALTER TABLE bots ADD COLUMN model TEXT NOT NULL DEFAULT 'default'; +ALTER TABLE bots ADD COLUMN model_in_use TEXT; diff --git a/crates/botloft-store/migrations/0006_crew_work_folder.sql b/crates/botloft-store/migrations/0006_crew_work_folder.sql new file mode 100644 index 00000000..62bae47a --- /dev/null +++ b/crates/botloft-store/migrations/0006_crew_work_folder.sql @@ -0,0 +1,3 @@ +-- The folder a crew works in, when the owner chose one (spec 5). NULL keeps +-- the crew's shared folder, as before. +ALTER TABLE crews ADD COLUMN work_dir TEXT; diff --git a/crates/botloft-store/migrations/0007_crew_lead.sql b/crates/botloft-store/migrations/0007_crew_lead.sql new file mode 100644 index 00000000..886911e2 --- /dev/null +++ b/crates/botloft-store/migrations/0007_crew_lead.sql @@ -0,0 +1,4 @@ +-- The bot that leads each crew (spec 10.2). No foreign key: the chief of a +-- new crew is saved in the same transaction as its bot, and an archived +-- chief simply no longer counts. +ALTER TABLE crews ADD COLUMN lead_bot_id TEXT; diff --git a/crates/botloft-store/src/approvals.rs b/crates/botloft-store/src/approvals.rs index ff0a3704..72574322 100644 --- a/crates/botloft-store/src/approvals.rs +++ b/crates/botloft-store/src/approvals.rs @@ -71,22 +71,25 @@ impl Store { .optional()?) } - /// Answers a pending approval. `None` if it was already settled. + /// Answers a pending approval; `input` replaces what was asked, when the + /// owner changed it. `None` if it was already settled. pub fn settle_approval( &self, id: &ApprovalId, status: ApprovalStatus, note: Option<&str>, + input: Option<&str>, now: i64, ) -> Result<Option<ApprovalRecord>> { Ok(self .conn .query_row( &format!( - "UPDATE approvals SET status = ?2, note = ?3, answered_at = ?4 \ + "UPDATE approvals SET status = ?2, note = ?3, answered_at = ?4, \ + input = COALESCE(?5, input) \ WHERE id = ?1 AND status = 'pending' RETURNING {COLUMNS}, tool_use_id" ), - params![id.as_str(), status.as_str(), note, now], + params![id.as_str(), status.as_str(), note, now, input], from_row, ) .optional()?) @@ -163,6 +166,7 @@ mod tests { &record.approval.id, ApprovalStatus::Denied, Some("not now"), + None, 20, ) .expect("settle") @@ -172,11 +176,29 @@ mod tests { assert_eq!(denied.approval.answered_at, Some(20)); let again = fx .store - .settle_approval(&record.approval.id, ApprovalStatus::Allowed, None, 30) + .settle_approval(&record.approval.id, ApprovalStatus::Allowed, None, None, 30) .expect("settle"); assert_eq!(again, None); } + #[test] + fn an_answer_can_replace_what_was_asked() { + let fx = Fixture::new(); + let record = pending(&fx, 0); + let allowed = fx + .store + .settle_approval( + &record.approval.id, + ApprovalStatus::Allowed, + None, + Some(r#"{"name":"Designer"}"#), + 40, + ) + .expect("settle") + .expect("was pending"); + assert_eq!(allowed.approval.input, r#"{"name":"Designer"}"#); + } + #[test] fn a_bots_pending_approvals_expire_together() { let fx = Fixture::new(); diff --git a/crates/botloft-store/src/bots.rs b/crates/botloft-store/src/bots.rs index e26804fe..59e5e5ac 100644 --- a/crates/botloft-store/src/bots.rs +++ b/crates/botloft-store/src/bots.rs @@ -1,6 +1,7 @@ //! `bots` table. use botloft_core::ids::{BotId, CrewId}; +use botloft_core::protocol::{BotModel, PermissionMode}; use rusqlite::{OptionalExtension, Row, params}; use crate::{Result, Store, parse_column, unique_as_duplicate}; @@ -18,12 +19,17 @@ pub struct BotRecord { pub instructions: String, pub color: String, pub paused: bool, + pub permission_mode: PermissionMode, + pub model: BotModel, + /// What Claude Code last reported; written by [`Store::set_model_in_use`] + /// and left alone by [`Store::update_bot`]. + pub model_in_use: Option<String>, pub created_at: i64, pub archived_at: Option<i64>, } -const COLUMNS: &str = - "id, crew_id, name, handle, slug, role, instructions, color, paused, created_at, archived_at"; +const COLUMNS: &str = "id, crew_id, name, handle, slug, role, instructions, color, paused, created_at, archived_at, \ + permission_mode, model, model_in_use"; fn from_row(row: &Row<'_>) -> rusqlite::Result<BotRecord> { Ok(BotRecord { @@ -38,6 +44,9 @@ fn from_row(row: &Row<'_>) -> rusqlite::Result<BotRecord> { paused: row.get(8)?, created_at: row.get(9)?, archived_at: row.get(10)?, + permission_mode: parse_column(row, 11)?, + model: parse_column(row, 12)?, + model_in_use: row.get(13)?, }) } @@ -47,7 +56,7 @@ impl Store { .execute( &format!( "INSERT INTO bots ({COLUMNS}) \ - VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11)" + VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14)" ), params![ bot.id.as_str(), @@ -60,7 +69,10 @@ impl Store { bot.color, bot.paused, bot.created_at, - bot.archived_at + bot.archived_at, + bot.permission_mode.as_str(), + bot.model.as_str(), + bot.model_in_use ], ) .map_err(|err| unique_as_duplicate(err, "bot handle or slug"))?; @@ -128,7 +140,7 @@ impl Store { self.conn .execute( "UPDATE bots SET name = ?2, handle = ?3, role = ?4, instructions = ?5, \ - color = ?6, paused = ?7, archived_at = ?8 WHERE id = ?1", + color = ?6, paused = ?7, archived_at = ?8, permission_mode = ?9, model = ?10 WHERE id = ?1", params![ bot.id.as_str(), bot.name, @@ -137,13 +149,24 @@ impl Store { bot.instructions, bot.color, bot.paused, - bot.archived_at + bot.archived_at, + bot.permission_mode.as_str(), + bot.model.as_str() ], ) .map_err(|err| unique_as_duplicate(err, "bot handle"))?; Ok(()) } + /// The model Claude Code reported at the start of a turn (spec 7.4). + pub fn set_model_in_use(&self, id: &BotId, model: &str) -> Result<()> { + self.conn.execute( + "UPDATE bots SET model_in_use = ?2 WHERE id = ?1", + params![id.as_str(), model], + )?; + Ok(()) + } + /// The Claude Code conversation the bot resumes (spec 7.3). pub fn session_id(&self, id: &BotId) -> Result<Option<String>> { Ok(self @@ -180,6 +203,9 @@ mod tests { id: CrewId::generate(), name: "Docs".to_owned(), slug: "docs".to_owned(), + work_folder: String::new(), + work_folder_chosen: false, + lead_bot_id: None, paused: false, created_at: 1, archived_at: None, @@ -199,6 +225,9 @@ mod tests { instructions: "Be brief.\nCite sources.".to_owned(), color: "#FF7A59".to_owned(), paused: false, + permission_mode: PermissionMode::Default, + model: BotModel::Default, + model_in_use: None, created_at, archived_at: None, } diff --git a/crates/botloft-store/src/crews.rs b/crates/botloft-store/src/crews.rs index e56c8061..8ad96163 100644 --- a/crates/botloft-store/src/crews.rs +++ b/crates/botloft-store/src/crews.rs @@ -6,31 +6,45 @@ use rusqlite::{OptionalExtension, Row, params}; use crate::{Result, Store, parse_column, unique_as_duplicate}; -const COLUMNS: &str = "id, name, slug, paused, created_at, archived_at"; +const COLUMNS: &str = "id, name, slug, paused, created_at, archived_at, work_dir, lead_bot_id"; +/// A crew without a chosen folder comes back with an empty `work_folder`; +/// the daemon fills in the `shared` folder, which depends on its paths. fn from_row(row: &Row<'_>) -> rusqlite::Result<Crew> { + let work_dir: Option<String> = row.get(6)?; Ok(Crew { id: parse_column(row, 0)?, name: row.get(1)?, slug: row.get(2)?, + work_folder_chosen: work_dir.is_some(), + work_folder: work_dir.unwrap_or_default(), + lead_bot_id: row + .get::<_, Option<String>>(7)? + .and_then(|id| id.parse().ok()), paused: row.get(3)?, created_at: row.get(4)?, archived_at: row.get(5)?, }) } +fn work_dir(crew: &Crew) -> Option<&str> { + crew.work_folder_chosen.then_some(crew.work_folder.as_str()) +} + impl Store { pub fn insert_crew(&self, crew: &Crew) -> Result<()> { self.conn .execute( - &format!("INSERT INTO crews ({COLUMNS}) VALUES (?1, ?2, ?3, ?4, ?5, ?6)"), + &format!("INSERT INTO crews ({COLUMNS}) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)"), params![ crew.id.as_str(), crew.name, crew.slug, crew.paused, crew.created_at, - crew.archived_at + crew.archived_at, + work_dir(crew), + crew.lead_bot_id.as_ref().map(|id| id.as_str()) ], ) .map_err(|err| unique_as_duplicate(err, "crew slug"))?; @@ -66,11 +80,20 @@ impl Store { )?) } - /// Saves the mutable fields: name, paused and archived_at. + /// Saves the mutable fields: name, paused, archived_at, the chosen work + /// folder and the chief. pub fn update_crew(&self, crew: &Crew) -> Result<()> { self.conn.execute( - "UPDATE crews SET name = ?2, paused = ?3, archived_at = ?4 WHERE id = ?1", - params![crew.id.as_str(), crew.name, crew.paused, crew.archived_at], + "UPDATE crews SET name = ?2, paused = ?3, archived_at = ?4, work_dir = ?5, \ + lead_bot_id = ?6 WHERE id = ?1", + params![ + crew.id.as_str(), + crew.name, + crew.paused, + crew.archived_at, + work_dir(crew), + crew.lead_bot_id.as_ref().map(|id| id.as_str()) + ], )?; Ok(()) } @@ -101,6 +124,9 @@ mod tests { id: CrewId::generate(), name: slug.to_uppercase(), slug: slug.to_owned(), + work_folder: String::new(), + work_folder_chosen: false, + lead_bot_id: None, paused: false, created_at, archived_at: None, diff --git a/crates/botloft-store/src/lib.rs b/crates/botloft-store/src/lib.rs index e89ea935..d145ae71 100644 --- a/crates/botloft-store/src/lib.rs +++ b/crates/botloft-store/src/lib.rs @@ -122,6 +122,9 @@ pub(crate) mod tests { id: CrewId::generate(), name: "Ops".to_owned(), slug: "ops".to_owned(), + work_folder: String::new(), + work_folder_chosen: false, + lead_bot_id: None, paused: false, created_at: 0, archived_at: None, @@ -140,6 +143,9 @@ pub(crate) mod tests { instructions: String::new(), color: "#FF7A59".to_owned(), paused: false, + permission_mode: botloft_core::protocol::PermissionMode::Default, + model: botloft_core::protocol::BotModel::Default, + model_in_use: None, created_at: 0, archived_at: None, }; diff --git a/crates/botloft-store/src/migrate.rs b/crates/botloft-store/src/migrate.rs index 5b8a68a1..7d15649c 100644 --- a/crates/botloft-store/src/migrate.rs +++ b/crates/botloft-store/src/migrate.rs @@ -10,6 +10,10 @@ const MIGRATIONS: &[(u32, &str)] = &[ (1, include_str!("../migrations/0001_init.sql")), (2, include_str!("../migrations/0002_messages.sql")), (3, include_str!("../migrations/0003_chat.sql")), + (4, include_str!("../migrations/0004_permission_mode.sql")), + (5, include_str!("../migrations/0005_bot_model.sql")), + (6, include_str!("../migrations/0006_crew_work_folder.sql")), + (7, include_str!("../migrations/0007_crew_lead.sql")), ]; /// Schema version after every migration has run. diff --git a/crates/botloftd/Cargo.toml b/crates/botloftd/Cargo.toml index 7b4a6488..98cd9b40 100644 --- a/crates/botloftd/Cargo.toml +++ b/crates/botloftd/Cargo.toml @@ -33,7 +33,7 @@ tracing-subscriber = { version = "0.3.23", features = ["env-filter"] } workspace = true [target."cfg(windows)".dependencies] -windows = { version = "0.62.2", features = ["Win32_Foundation", "Win32_Security", "Win32_Security_Authorization", "Win32_System_Threading", "Win32_System_Memory", "Win32_System_JobObjects", "Win32_System_Environment", "Win32_System_Power", "Win32_System_Console", "Win32_System_Com", "Win32_System_Ole", "Win32_System_Variant", "Win32_System_TaskScheduler"] } +windows = { version = "0.62.2", features = ["Win32_Foundation", "Win32_Security", "Win32_Security_Authorization", "Win32_System_Threading", "Win32_System_Memory", "Win32_System_JobObjects", "Win32_System_Environment", "Win32_System_Power", "Win32_System_Console", "Win32_System_Com", "Win32_System_Ole", "Win32_System_Variant", "Win32_System_TaskScheduler", "Win32_Security_Authentication_Identity"] } [target."cfg(windows)".build-dependencies] embed-resource = "3.0.11" diff --git a/crates/botloftd/src/approvals.rs b/crates/botloftd/src/approvals/mod.rs similarity index 66% rename from crates/botloftd/src/approvals.rs rename to crates/botloftd/src/approvals/mod.rs index 0674a880..e7626cd0 100644 --- a/crates/botloftd/src/approvals.rs +++ b/crates/botloftd/src/approvals/mod.rs @@ -1,30 +1,28 @@ -//! Permission requests (spec 10.1). Claude Code calls the MCP tool -//! `permission_prompt`; the call waits here until the owner answers in the -//! chat, the request times out, or the bot's process ends. +//! Requests that wait for the owner in the chat: Claude Code's permission +//! requests (spec 10.1) and the chief's bot suggestions (spec 10.2). The +//! MCP call waits here until the owner answers, the request times out, or +//! the bot's process ends. + +mod prompt; use std::collections::HashMap; use std::sync::{Mutex, MutexGuard}; -use std::time::Duration; -use botloft_core::chat::{TOOL_INPUT_MAX, clip, tool_summary}; +use botloft_core::chat::{SUGGEST_TOOL, clip, tool_input_max, tool_summary}; use botloft_core::ids::{ApprovalId, BotId, ChatItemId}; use botloft_core::protocol::{ - Approval, ApprovalItem, ApprovalStatus, ApprovalsAnswerParams, ChatBody, ToolStatus, + Approval, ApprovalItem, ApprovalStatus, ApprovalsAnswerParams, ChatBody, }; use botloft_store::ApprovalRecord; -use serde_json::{Value, json}; +use serde_json::Value; use tokio::sync::oneshot; use tracing::{debug, warn}; +pub use self::prompt::{PromptArgs, prompt}; use crate::chat::items; use crate::service::{ApiError, ApiResult}; use crate::state::Daemon; -/// How long to wait for the `tool_use` event that the request is about; -/// it can arrive a moment after the MCP call. -const MATCH_WINDOW: Duration = Duration::from_secs(2); -const MATCH_POLL: Duration = Duration::from_millis(50); - /// Requests waiting for an answer, in memory: they cannot outlive the /// daemon, since the bots' processes do not either. #[derive(Default)] @@ -36,6 +34,21 @@ pub struct Approvals { struct Decision { allow: bool, note: Option<String>, + input: Option<String>, +} + +/// How the owner answered a request. +#[derive(Debug, Clone, PartialEq, Eq)] +pub(crate) enum Answer { + /// `input` is the request as the owner changed it, if they did. + Allowed { + input: Option<String>, + }, + Denied { + note: Option<String>, + }, + /// No answer in time, or the process ended. + Expired, } impl Approvals { @@ -46,26 +59,17 @@ impl Approvals { } } -/// Arguments Claude Code sends to the permission tool. -#[derive(Debug, Clone, serde::Deserialize)] -pub struct PromptArgs { - pub tool_name: String, - #[serde(default)] - pub input: Value, - #[serde(default)] - pub tool_use_id: String, -} - -/// Handles one `permission_prompt` call and returns the text of the tool -/// result: `{"behavior": "allow" | "deny", ...}`. -pub async fn prompt(daemon: &Daemon, bot: &BotId, generation: u64, args: PromptArgs) -> String { - if !matches_running_tool(daemon, bot, &args.tool_use_id).await { - debug!(bot = %bot, "permission request for no running tool; denied"); - return deny("There is no pending tool call with that id."); - } - let Some(pending) = open(daemon, bot, &args) else { - return deny("Botloft could not ask the owner."); - }; +/// Puts a request in the bot's chat and waits for the owner. `None` if it +/// could not be saved. +pub(crate) async fn ask( + daemon: &Daemon, + bot: &BotId, + generation: u64, + tool_name: &str, + input: &Value, + tool_use_id: &str, +) -> Option<Answer> { + let pending = open(daemon, bot, tool_name, input, tool_use_id)?; let (answer, waiting) = oneshot::channel(); daemon .approvals @@ -83,20 +87,17 @@ pub async fn prompt(daemon: &Daemon, bot: &BotId, generation: u64, args: PromptA guard.settled = true; daemon.approvals.lock().remove(&pending.record.approval.id); daemon.supervisor.approval_closed(bot, generation); - match decision { - Ok(Ok(Decision { allow: true, .. })) => { - json!({ "behavior": "allow", "updatedInput": args.input }).to_string() - } - Ok(Ok(Decision { allow: false, note })) => match note { - Some(note) => deny(&format!("The owner denied this: {note}")), - None => deny("The owner denied this."), - }, + Some(match decision { + Ok(Ok(Decision { + allow: true, input, .. + })) => Answer::Allowed { input }, + Ok(Ok(Decision { note, .. })) => Answer::Denied { note }, // Timed out, or the answer was dropped (the process ended). Ok(Err(_)) | Err(_) => { - settle(daemon, &pending.record, ApprovalStatus::Expired, None); - deny("The owner did not answer in time.") + settle(daemon, &pending.record, ApprovalStatus::Expired, None, None); + Answer::Expired } - } + }) } /// The owner's answer (`approvals.answer`). @@ -114,7 +115,16 @@ pub fn answer(daemon: &Daemon, params: ApprovalsAnswerParams) -> ApiResult<Appro .store() .approval(¶ms.approval_id)? .ok_or_else(|| ApiError::NotFound(format!("approval {}", params.approval_id)))?; - let Some(record) = settle(daemon, &existing, status, note.as_deref()) else { + // Only a bot suggestion can be changed before it is allowed (spec 10.2). + let input = match params.input { + Some(input) if params.allow && existing.approval.tool_name == SUGGEST_TOOL => { + let value: Value = serde_json::from_str(&input) + .map_err(|_| ApiError::validation("the changed suggestion is not valid JSON"))?; + Some(value.to_string()) + } + _ => None, + }; + let Some(record) = settle(daemon, &existing, status, note.as_deref(), input.as_deref()) else { return Err(ApiError::Conflict(format!( "approval {} was already answered or expired", params.approval_id @@ -124,6 +134,7 @@ pub fn answer(daemon: &Daemon, params: ApprovalsAnswerParams) -> ApiResult<Appro let _ = waiter.send(Decision { allow: params.allow, note, + input, }); } Ok(record.approval) @@ -160,44 +171,25 @@ pub fn expire_all(daemon: &Daemon) { } } -fn deny(message: &str) -> String { - json!({ "behavior": "deny", "message": message }).to_string() -} - -/// Whether the bot's chat shows `tool_use_id` running, waiting briefly for -/// the event if it has not been read yet. -async fn matches_running_tool(daemon: &Daemon, bot: &BotId, tool_use_id: &str) -> bool { - if tool_use_id.is_empty() { - return false; - } - let deadline = tokio::time::Instant::now() + MATCH_WINDOW; - loop { - let found = daemon.store().tool_item(bot, tool_use_id); - if let Ok(Some(item)) = found - && matches!(&item.body, ChatBody::Tool(tool) if tool.status == ToolStatus::Running) - { - return true; - } - if tokio::time::Instant::now() >= deadline { - return false; - } - tokio::time::sleep(MATCH_POLL).await; - } -} - struct Pending { record: ApprovalRecord, } /// Saves the request and puts it in the chat. -fn open(daemon: &Daemon, bot: &BotId, args: &PromptArgs) -> Option<Pending> { +fn open( + daemon: &Daemon, + bot: &BotId, + tool_name: &str, + input: &Value, + tool_use_id: &str, +) -> Option<Pending> { let now = daemon.clock.now_ms(); let approval = Approval { id: ApprovalId::generate(), bot_id: bot.clone(), - tool_name: args.tool_name.clone(), - summary: tool_summary(&args.tool_name, &args.input), - input: clip(&args.input.to_string(), TOOL_INPUT_MAX), + tool_name: tool_name.to_owned(), + summary: tool_summary(tool_name, input), + input: clip(&input.to_string(), tool_input_max(tool_name)), status: ApprovalStatus::Pending, note: None, created_at: now, @@ -207,7 +199,7 @@ fn open(daemon: &Daemon, bot: &BotId, args: &PromptArgs) -> Option<Pending> { let record = ApprovalRecord { approval, chat_item_id: item.id, - tool_use_id: args.tool_use_id.clone(), + tool_use_id: tool_use_id.to_owned(), }; if let Err(err) = daemon.store().insert_approval(&record) { warn!(bot = %bot, "could not save an approval: {err}"); @@ -234,11 +226,12 @@ fn settle( record: &ApprovalRecord, status: ApprovalStatus, note: Option<&str>, + input: Option<&str>, ) -> Option<ApprovalRecord> { let now = daemon.clock.now_ms(); let settled = daemon .store() - .settle_approval(&record.approval.id, status, note, now); + .settle_approval(&record.approval.id, status, note, input, now); match settled { Ok(Some(settled)) => { show(daemon, &settled); @@ -276,7 +269,13 @@ impl Drop for Guard<'_> { .approvals .lock() .remove(&self.record.approval.id); - settle(self.daemon, self.record, ApprovalStatus::Expired, None); + settle( + self.daemon, + self.record, + ApprovalStatus::Expired, + None, + None, + ); self.daemon .supervisor .approval_closed(self.bot, self.generation); diff --git a/crates/botloftd/src/approvals/prompt.rs b/crates/botloftd/src/approvals/prompt.rs new file mode 100644 index 00000000..f9a9af59 --- /dev/null +++ b/crates/botloftd/src/approvals/prompt.rs @@ -0,0 +1,82 @@ +//! Claude Code's permission requests (spec 10.1): the MCP tool +//! `permission_prompt`, named with `--permission-prompt-tool`. + +use std::time::Duration; + +use botloft_core::ids::BotId; +use botloft_core::protocol::{ChatBody, ToolStatus}; +use serde_json::{Value, json}; +use tracing::debug; + +use super::{Answer, ask}; +use crate::state::Daemon; + +/// How long to wait for the `tool_use` event that the request is about; +/// it can arrive a moment after the MCP call. +const MATCH_WINDOW: Duration = Duration::from_secs(2); +const MATCH_POLL: Duration = Duration::from_millis(50); + +/// Arguments Claude Code sends to the permission tool. +#[derive(Debug, Clone, serde::Deserialize)] +pub struct PromptArgs { + pub tool_name: String, + #[serde(default)] + pub input: Value, + #[serde(default)] + pub tool_use_id: String, +} + +/// Handles one `permission_prompt` call and returns the text of the tool +/// result: `{"behavior": "allow" | "deny", ...}`. +pub async fn prompt(daemon: &Daemon, bot: &BotId, generation: u64, args: PromptArgs) -> String { + if !matches_running_tool(daemon, bot, &args.tool_use_id).await { + debug!(bot = %bot, "permission request for no running tool; denied"); + return deny("There is no pending tool call with that id."); + } + let asked = ask( + daemon, + bot, + generation, + &args.tool_name, + &args.input, + &args.tool_use_id, + ) + .await; + match asked { + // What runs is what was asked: the owner cannot edit a tool call. + Some(Answer::Allowed { .. }) => { + json!({ "behavior": "allow", "updatedInput": args.input }).to_string() + } + Some(Answer::Denied { note: Some(note) }) => { + deny(&format!("The owner denied this: {note}")) + } + Some(Answer::Denied { note: None }) => deny("The owner denied this."), + Some(Answer::Expired) => deny("The owner did not answer in time."), + None => deny("Botloft could not ask the owner."), + } +} + +fn deny(message: &str) -> String { + json!({ "behavior": "deny", "message": message }).to_string() +} + +/// Whether the bot's chat shows `tool_use_id` running, waiting briefly for +/// the event if it has not been read yet. +async fn matches_running_tool(daemon: &Daemon, bot: &BotId, tool_use_id: &str) -> bool { + if tool_use_id.is_empty() { + return false; + } + let deadline = tokio::time::Instant::now() + MATCH_WINDOW; + loop { + let found = daemon.store().tool_item(bot, tool_use_id); + if let Ok(Some(item)) = found + && matches!(&item.body, ChatBody::Tool(tool) if tool.status == ToolStatus::Running) + { + return true; + } + if tokio::time::Instant::now() >= deadline { + return false; + } + tokio::time::sleep(MATCH_POLL).await; + } +} diff --git a/crates/botloftd/src/chat/events.rs b/crates/botloftd/src/chat/events.rs index ea5b644d..95db46f9 100644 --- a/crates/botloftd/src/chat/events.rs +++ b/crates/botloftd/src/chat/events.rs @@ -2,7 +2,7 @@ //! (spec 8.1). Fields are read defensively: the format is not documented //! and grows between Claude Code versions. -use botloft_core::chat::{TOOL_INPUT_MAX, TOOL_OUTPUT_MAX, clip, tool_summary}; +use botloft_core::chat::{TOOL_OUTPUT_MAX, clip, tool_input_max, tool_summary}; use botloft_core::ids::BotId; use botloft_core::protocol::{ AccountUsage, ChatBody, ChatDelta, NoticeCode, NoticeItem, NoticeLevel, ReplyItem, ToolItem, @@ -12,6 +12,7 @@ use serde_json::Value; use tracing::{debug, warn}; use super::items; +use crate::service; use crate::state::{Daemon, Event}; /// Errors that restarting cannot fix: Claude Code needs the owner. @@ -21,6 +22,8 @@ const SIGN_IN_ERRORS: &[&str] = &[ "billing_error", "account_on_hold", ]; +/// The model does not exist or the account cannot use it (spec 7.4). +const MODEL_NOT_FOUND: &str = "model_not_found"; /// When a rate limit gives no reset time. const DEFAULT_LIMIT_MS: i64 = 5 * 60 * 1000; @@ -59,6 +62,12 @@ fn session(daemon: &Daemon, bot: &BotId, event: &Value) { } drop(store); daemon.supervisor.remember_session(bot, session); + if let Some(mode) = event["permissionMode"].as_str() { + service::modes::reported(daemon, bot, mode); + } + if let Some(model) = event["model"].as_str() { + service::models::reported(daemon, bot, model); + } } fn delta(daemon: &Daemon, bot: &BotId, event: &Value) { @@ -111,7 +120,7 @@ fn assistant(daemon: &Daemon, bot: &BotId, generation: u64, event: &Value) { tool_use_id: block["id"].as_str().unwrap_or_default().to_owned(), name: name.to_owned(), summary: tool_summary(name, input), - input: clip(&input.to_string(), TOOL_INPUT_MAX), + input: clip(&input.to_string(), tool_input_max(name)), status: ToolStatus::Running, output: None, }), @@ -144,6 +153,12 @@ fn failed_turn(daemon: &Daemon, bot: &BotId, generation: u64, error: &str, event NoticeCode::UsageLimit, "The account reached its usage limit. Messages wait until it resets.".to_owned(), ) + } else if error == MODEL_NOT_FOUND { + ( + NoticeCode::ModelUnavailable, + "Claude Code could not use this bot's model: it may not exist or not be on the account's plan. Pick another model." + .to_owned(), + ) } else if detail.is_empty() { (NoticeCode::TurnFailed, error.to_owned()) } else { diff --git a/crates/botloftd/src/config.rs b/crates/botloftd/src/config.rs index 692a602b..d0085e5f 100644 --- a/crates/botloftd/src/config.rs +++ b/crates/botloftd/src/config.rs @@ -85,6 +85,8 @@ pub struct BotsConfig { pub approval_timeout_minutes: u64, /// Largest attachment, per file (spec 9.5). pub attachment_max_mb: u64, + /// Most bots a chief's suggestions can bring a crew to (spec 10.2). + pub max_per_crew: usize, } impl Default for BotsConfig { @@ -92,6 +94,7 @@ impl Default for BotsConfig { Self { approval_timeout_minutes: 60, attachment_max_mb: 20, + max_per_crew: 12, } } } diff --git a/crates/botloftd/src/paths.rs b/crates/botloftd/src/paths.rs index 60286db9..a8bcc105 100644 --- a/crates/botloftd/src/paths.rs +++ b/crates/botloftd/src/paths.rs @@ -3,6 +3,8 @@ use std::io; use std::path::{Path, PathBuf}; +use botloft_core::protocol::Crew; + use crate::config::Config; /// Environment variable that moves the daemon's data directory, so a dev @@ -60,6 +62,15 @@ impl Paths { pub fn bot_workspace(&self, crew_slug: &str, bot_slug: &str) -> PathBuf { self.crew_dir(crew_slug).join(bot_slug) } + + /// The folder the crew works in: the one the owner chose, or `shared`. + pub fn work_folder(&self, crew: &Crew) -> PathBuf { + if crew.work_folder_chosen { + PathBuf::from(&crew.work_folder) + } else { + self.shared_dir(&crew.slug) + } + } } /// `--home` when given (the scheduled task passes it, spec 14), else diff --git a/crates/botloftd/src/platform/mod.rs b/crates/botloftd/src/platform/mod.rs index 1440b7d4..5fb51a5e 100644 --- a/crates/botloftd/src/platform/mod.rs +++ b/crates/botloftd/src/platform/mod.rs @@ -12,12 +12,12 @@ use std::path::{Path, PathBuf}; #[cfg(unix)] pub use unix::{ - KeepAwake, ProcessJob, delete_task, find_task, leave_own_console, register_task, + KeepAwake, ProcessJob, delete_task, find_task, leave_own_console, owner_name, register_task, restrict_to_current_user, run_task, stop_task, user_environment, }; #[cfg(windows)] pub use windows::{ - KeepAwake, ProcessJob, delete_task, find_task, leave_own_console, register_task, + KeepAwake, ProcessJob, delete_task, find_task, leave_own_console, owner_name, register_task, restrict_to_current_user, run_task, stop_task, user_environment, }; @@ -98,6 +98,11 @@ mod tests { assert!(!has("CLAUDE_CODE_MESSAGING_SOCKET")); } + #[test] + fn the_owner_has_a_name() { + assert!(!owner_name().trim().is_empty()); + } + #[test] fn a_job_can_be_created_and_terminated_empty() { let job = ProcessJob::new().expect("job"); diff --git a/crates/botloftd/src/platform/unix.rs b/crates/botloftd/src/platform/unix.rs index de9772d8..738a38e0 100644 --- a/crates/botloftd/src/platform/unix.rs +++ b/crates/botloftd/src/platform/unix.rs @@ -68,6 +68,11 @@ pub fn user_environment() -> io::Result<Vec<(OsString, OsString)>> { .collect()) } +/// The login name; Unix has no display name to ask for. +pub fn owner_name() -> String { + std::env::var("USER").unwrap_or_default() +} + /// Nothing to leave: Unix never opens a console for the daemon. pub fn leave_own_console() {} diff --git a/crates/botloftd/src/platform/windows.rs b/crates/botloftd/src/platform/windows.rs index fce4924d..426b9876 100644 --- a/crates/botloftd/src/platform/windows.rs +++ b/crates/botloftd/src/platform/windows.rs @@ -4,6 +4,7 @@ mod console; mod env; mod job; +mod owner; mod power; mod task; mod task_xml; @@ -11,6 +12,7 @@ mod task_xml; pub use console::leave_own_console; pub use env::user_environment; pub use job::ProcessJob; +pub use owner::owner_name; pub use power::KeepAwake; pub use task::{delete_task, find_task, register_task, run_task, stop_task}; diff --git a/crates/botloftd/src/platform/windows/owner.rs b/crates/botloftd/src/platform/windows/owner.rs new file mode 100644 index 00000000..8b97666d --- /dev/null +++ b/crates/botloftd/src/platform/windows/owner.rs @@ -0,0 +1,26 @@ +//! The owner's name as Windows shows it, for the app's account area. + +use windows::Win32::Security::Authentication::Identity::{GetUserNameExW, NameDisplay}; +use windows::core::PWSTR; + +/// The account's display name ("Ana Lima"), or the user name without one. +pub fn owner_name() -> String { + display_name() + .filter(|name| !name.trim().is_empty()) + .unwrap_or_else(|| std::env::var("USERNAME").unwrap_or_default()) +} + +fn display_name() -> Option<String> { + let mut len = 0u32; + // SAFETY: a size query with no buffer; it fails and sets `len` to the + // size needed, counting the final NUL. + let _ = unsafe { GetUserNameExW(NameDisplay, None, &mut len) }; + if len == 0 { + return None; + } + let mut buf = vec![0u16; len as usize]; + // SAFETY: `buf` holds `len` UTF-16 units; on success `len` becomes the + // length of the name without the NUL. + let found = unsafe { GetUserNameExW(NameDisplay, Some(PWSTR(buf.as_mut_ptr())), &mut len) }; + found.then(|| String::from_utf16_lossy(&buf[..len as usize])) +} diff --git a/crates/botloftd/src/rpc/dispatch.rs b/crates/botloftd/src/rpc/dispatch.rs index b7a6774f..75bbcc15 100644 --- a/crates/botloftd/src/rpc/dispatch.rs +++ b/crates/botloftd/src/rpc/dispatch.rs @@ -8,7 +8,8 @@ use serde_json::Value; use super::jsonrpc::{RpcError, empty_params}; use crate::approvals; use crate::service::{ - self, ApiResult, attachments, bots, chat, crews, deliveries, messages, tasks, + self, ApiResult, attachments, bots, chat, crews, deliveries, lead, messages, models, modes, + tasks, }; use crate::state::Daemon; @@ -24,11 +25,17 @@ pub fn dispatch(daemon: &Daemon, name: &str, params: Option<Value>) -> Result<Va method::CREWS_CREATE => reply(crews::create(daemon, parse(params)?)), method::CREWS_RENAME => reply(crews::rename(daemon, parse(params)?)), method::CREWS_SET_PAUSED => reply(crews::set_paused(daemon, parse(params)?)), + method::CREWS_SET_WORK_FOLDER => reply(crews::set_work_folder(daemon, parse(params)?)), + method::CREWS_SET_LEAD => reply(lead::set_lead(daemon, parse(params)?)), method::CREWS_ARCHIVE => reply(crews::archive(daemon, parse(params)?)), method::BOTS_LIST => reply(bots::list(daemon, parse(params)?)), method::BOTS_CREATE => reply(bots::create(daemon, parse(params)?)), method::BOTS_UPDATE => reply(bots::update(daemon, parse(params)?)), method::BOTS_SET_PAUSED => reply(bots::set_paused(daemon, parse(params)?)), + method::BOTS_SET_PERMISSION_MODE => { + reply(modes::set_permission_mode(daemon, parse(params)?)) + } + method::BOTS_SET_MODEL => reply(models::set_model(daemon, parse(params)?)), method::BOTS_ARCHIVE => reply(bots::archive(daemon, parse(params)?)), method::BOTS_RESTART => reply(bots::restart(daemon, parse(params)?)), method::CHAT_HISTORY => reply(chat::history(daemon, parse(params)?)), diff --git a/crates/botloftd/src/runtime/claude.rs b/crates/botloftd/src/runtime/claude.rs index 68509653..08ec832a 100644 --- a/crates/botloftd/src/runtime/claude.rs +++ b/crates/botloftd/src/runtime/claude.rs @@ -6,6 +6,10 @@ use std::path::{Path, PathBuf}; use std::process::{Command, Output, Stdio}; use std::time::{Duration, Instant}; +use botloft_core::protocol::ClaudeAccount; + +use super::AuthStatus; + /// First version with the inbox as a named pipe on native Windows. pub const MIN_VERSION: (u32, u32, u32) = (2, 1, 234); const PROBE_TIMEOUT: Duration = Duration::from_secs(15); @@ -108,16 +112,34 @@ pub fn probe(path: &Path, env: &[(OsString, OsString)]) -> Result<Claude, Claude /// Runs `claude auth status`, documented to print JSON with `loggedIn` and /// to exit with 0 when signed in and 1 when not (spec 19). -pub fn signed_in(path: &Path, env: &[(OsString, OsString)]) -> io::Result<bool> { +pub fn auth_status(path: &Path, env: &[(OsString, OsString)]) -> io::Result<AuthStatus> { let output = run(path, &["auth", "status", "--json"], env)?; - Ok(parse_signed_in(&output.stdout).unwrap_or(output.status.success())) + Ok(parse_auth_status(&output.stdout).unwrap_or(AuthStatus { + signed_in: output.status.success(), + account: None, + })) } -fn parse_signed_in(stdout: &[u8]) -> Option<bool> { - serde_json::from_slice::<serde_json::Value>(stdout) - .ok()? - .get("loggedIn")? - .as_bool() +/// Reads `loggedIn`, and when signed in `email`, `subscriptionType` and +/// `orgName` (seen with 2.1.284). +fn parse_auth_status(stdout: &[u8]) -> Option<AuthStatus> { + let json = serde_json::from_slice::<serde_json::Value>(stdout).ok()?; + let signed_in = json.get("loggedIn")?.as_bool()?; + let text = |key: &str| { + json.get(key) + .and_then(|value| value.as_str()) + .map(str::trim) + .filter(|value| !value.is_empty()) + .map(str::to_owned) + }; + Some(AuthStatus { + signed_in, + account: signed_in.then(|| ClaudeAccount { + email: text("email"), + plan: text("subscriptionType"), + organization: text("orgName"), + }), + }) } /// Runs Claude Code without a window and with `env` only, giving up after @@ -176,16 +198,31 @@ mod tests { } #[test] - fn reads_the_sign_in_from_auth_status() { + fn reads_the_sign_in_and_account_from_auth_status() { + let signed_in = parse_auth_status( + br#"{"loggedIn": true, "authMethod": "claude.ai", "email": "ana@example.com", + "orgName": "Exemplo", "subscriptionType": "max"}"#, + ) + .expect("parsed"); + assert!(signed_in.signed_in); assert_eq!( - parse_signed_in(br#"{"loggedIn": true, "authMethod": "claude.ai"}"#), - Some(true) + signed_in.account, + Some(ClaudeAccount { + email: Some("ana@example.com".into()), + plan: Some("max".into()), + organization: Some("Exemplo".into()), + }) ); + let signed_out = + parse_auth_status(br#"{"loggedIn": false, "authMethod": "none"}"#).expect("parsed"); assert_eq!( - parse_signed_in(br#"{"loggedIn": false, "authMethod": "none"}"#), - Some(false) + signed_out, + AuthStatus { + signed_in: false, + account: None + } ); - assert_eq!(parse_signed_in(b"Logged in"), None); + assert_eq!(parse_auth_status(b"Logged in"), None); } #[test] diff --git a/crates/botloftd/src/runtime/fake.rs b/crates/botloftd/src/runtime/fake.rs index 0a2a158c..c7f95b4e 100644 --- a/crates/botloftd/src/runtime/fake.rs +++ b/crates/botloftd/src/runtime/fake.rs @@ -12,7 +12,11 @@ use tokio::sync::{Notify, mpsc}; use serde_json::Value; -use super::{EVENT_BUFFER, Process, ProcessControl, ProcessEvent, Runtime, SignInCheck, SpawnSpec}; +use botloft_core::protocol::ClaudeAccount; + +use super::{ + AuthCheck, AuthStatus, EVENT_BUFFER, Process, ProcessControl, ProcessEvent, Runtime, SpawnSpec, +}; #[derive(Clone, Default)] pub struct FakeRuntime { @@ -93,10 +97,18 @@ impl FakeRuntime { } impl Runtime for FakeRuntime { - fn signed_in(&self, _program: std::path::PathBuf) -> SignInCheck { + fn auth_status(&self, _program: std::path::PathBuf) -> AuthCheck { let mut state = lock(&self.state); state.sign_in_checks += 1; - Box::pin(std::future::ready(Ok(state.signed_in))) + let signed_in = state.signed_in; + Box::pin(std::future::ready(Ok(AuthStatus { + signed_in, + account: signed_in.then(|| ClaudeAccount { + email: Some("owner@example.com".into()), + plan: Some("max".into()), + organization: None, + }), + }))) } fn spawn(&self, spec: SpawnSpec) -> io::Result<Process> { diff --git a/crates/botloftd/src/runtime/mod.rs b/crates/botloftd/src/runtime/mod.rs index 54ffe902..49591ac9 100644 --- a/crates/botloftd/src/runtime/mod.rs +++ b/crates/botloftd/src/runtime/mod.rs @@ -12,6 +12,7 @@ use std::io; use std::path::PathBuf; use std::pin::Pin; +use botloft_core::protocol::ClaudeAccount; use bytes::Bytes; use tokio::sync::mpsc; @@ -49,13 +50,21 @@ pub struct Process { pub control: Box<dyn ProcessControl>, } -/// The answer to "is Claude Code signed in?", computed off the async workers. -pub type SignInCheck = Pin<Box<dyn Future<Output = io::Result<bool>> + Send>>; +/// What `claude auth status` says: signed in or not, and to which account. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct AuthStatus { + pub signed_in: bool, + pub account: Option<ClaudeAccount>, +} + +/// An [`AuthStatus`], computed off the async workers. +pub type AuthCheck = Pin<Box<dyn Future<Output = io::Result<AuthStatus>> + Send>>; pub trait Runtime: Send + Sync + 'static { fn spawn(&self, spec: SpawnSpec) -> io::Result<Process>; - /// Whether the Claude Code at `program` is signed in (`claude auth status`). - fn signed_in(&self, program: PathBuf) -> SignInCheck; + /// Whether the Claude Code at `program` is signed in, and to which + /// account (`claude auth status`). + fn auth_status(&self, program: PathBuf) -> AuthCheck; } /// Capacity of the event channel between a process and the daemon. When it diff --git a/crates/botloftd/src/runtime/pipe.rs b/crates/botloftd/src/runtime/pipe.rs index 66a344b8..67ffd4d0 100644 --- a/crates/botloftd/src/runtime/pipe.rs +++ b/crates/botloftd/src/runtime/pipe.rs @@ -13,7 +13,7 @@ use tokio::sync::mpsc; use tracing::debug; use super::{ - EVENT_BUFFER, Process, ProcessControl, ProcessEvent, Runtime, SignInCheck, SpawnSpec, claude, + AuthCheck, EVENT_BUFFER, Process, ProcessControl, ProcessEvent, Runtime, SpawnSpec, claude, }; use crate::platform::{self, ProcessJob}; @@ -24,11 +24,11 @@ const STDERR_LINE_MAX: usize = 300; pub struct PipeRuntime; impl Runtime for PipeRuntime { - fn signed_in(&self, program: std::path::PathBuf) -> SignInCheck { + fn auth_status(&self, program: std::path::PathBuf) -> AuthCheck { Box::pin(async move { tokio::task::spawn_blocking(move || { let env = platform::user_environment()?; - claude::signed_in(&program, &env) + claude::auth_status(&program, &env) }) .await .map_err(io::Error::other)? diff --git a/crates/botloftd/src/service/bots.rs b/crates/botloftd/src/service/bots.rs index c69262b5..3b3f57f1 100644 --- a/crates/botloftd/src/service/bots.rs +++ b/crates/botloftd/src/service/bots.rs @@ -2,8 +2,8 @@ use botloft_core::ids::{BotId, CrewId}; use botloft_core::protocol::{ - Bot, BotIdParams, BotState, BotsCreateParams, BotsListParams, BotsRestartParams, - BotsSetPausedParams, BotsUpdateParams, Crew, + Bot, BotIdParams, BotModel, BotState, BotsCreateParams, BotsListParams, BotsRestartParams, + BotsSetPausedParams, BotsUpdateParams, Crew, PermissionMode, }; use botloft_core::{avatar, now_ms, slug, validate}; use botloft_store::{BotRecord, Store}; @@ -32,16 +32,62 @@ pub fn list(daemon: &Daemon, params: BotsListParams) -> ApiResult<Vec<Bot>> { } pub fn create(daemon: &Daemon, params: BotsCreateParams) -> ApiResult<Bot> { - let name = validate::name("name", ¶ms.name)?; - let role = validate::role(¶ms.role)?; - let instructions = validate::instructions(¶ms.instructions)?; + let new = NewBot::check( + ¶ms.name, + ¶ms.role, + ¶ms.instructions, + params.color, + params.model, + )?; let store = daemon.store(); let crew = crews::active(&store, ¶ms.crew_id)?; + let record = insert(daemon, &store, &crew, BotId::generate(), new)?; + let bot = changed(daemon, &store, &crew, record); + daemon.supervisor.wake(); + Ok(bot) +} + +/// The fields of a new bot, checked. +pub(crate) struct NewBot { + pub name: String, + pub role: String, + pub instructions: String, + pub color: Option<String>, + pub model: BotModel, +} + +impl NewBot { + pub(crate) fn check( + name: &str, + role: &str, + instructions: &str, + color: Option<String>, + model: Option<BotModel>, + ) -> ApiResult<Self> { + Ok(Self { + name: validate::name("name", name)?, + role: validate::role(role)?, + instructions: validate::instructions(instructions)?, + color: color.as_deref().map(parse_color).transpose()?, + model: model.unwrap_or(BotModel::Default), + }) + } +} - let handle = slug::slugify(&name, "bot"); - ensure_handle_free(&store, &crew.id, &handle, None)?; - let color = match params.color { - Some(color) => parse_color(&color)?, +/// Saves a bot in `crew` and writes its workspace, under the caller's lock +/// on the store; the caller announces it and wakes the supervisor. When +/// `crew.lead_bot_id` already names `id`, its rules say it leads. +pub(crate) fn insert( + daemon: &Daemon, + store: &Store, + crew: &Crew, + id: BotId, + new: NewBot, +) -> ApiResult<BotRecord> { + let handle = slug::slugify(&new.name, "bot"); + ensure_handle_free(store, &crew.id, &handle, None)?; + let color = match new.color { + Some(color) => color, None => avatar::palette_color(store.count_bots(&crew.id)?).to_owned(), }; let slug = pick_slug(&handle, |candidate| { @@ -51,23 +97,24 @@ pub fn create(daemon: &Daemon, params: BotsCreateParams) -> ApiResult<Bot> { })?; let record = BotRecord { - id: BotId::generate(), + id, crew_id: crew.id.clone(), - name, + name: new.name, handle, slug, - role, - instructions, + role: new.role, + instructions: new.instructions, color, paused: false, + permission_mode: PermissionMode::Default, + model: new.model, + model_in_use: None, created_at: now_ms(), archived_at: None, }; - workspace::prepare_bot(daemon.workspace_env(), &crew, &record).map_err(ApiError::Workspace)?; + workspace::prepare_bot(daemon.workspace_env(), crew, &record).map_err(ApiError::Workspace)?; store.insert_bot(&record)?; - let bot = changed(daemon, &store, &crew, record); - daemon.supervisor.wake(); - Ok(bot) + Ok(record) } pub fn update(daemon: &Daemon, params: BotsUpdateParams) -> ApiResult<Bot> { @@ -135,6 +182,7 @@ pub fn archive(daemon: &Daemon, params: BotIdParams) -> ApiResult<Bot> { } record.archived_at = Some(now_ms()); store.update_bot(&record)?; + super::lead::forget_archived(daemon, &store, &crew, &record.id)?; let bot = changed(daemon, &store, &crew, record); daemon.supervisor.wake(); Ok(bot) @@ -166,6 +214,9 @@ pub(crate) fn to_protocol(daemon: &Daemon, store: &Store, crew: &Crew, record: B instructions: record.instructions, color: record.color, paused: record.paused, + permission_mode: record.permission_mode, + model: record.model, + model_in_use: record.model_in_use, state, generation, workspace: workspace.to_string_lossy().into_owned(), @@ -175,7 +226,7 @@ pub(crate) fn to_protocol(daemon: &Daemon, store: &Store, crew: &Crew, record: B } } -fn changed(daemon: &Daemon, store: &Store, crew: &Crew, record: BotRecord) -> Bot { +pub(crate) fn changed(daemon: &Daemon, store: &Store, crew: &Crew, record: BotRecord) -> Bot { let bot = to_protocol(daemon, store, crew, record); daemon.emit(Event::BotChanged(bot.clone())); bot @@ -197,7 +248,7 @@ pub(crate) fn active(store: &Store, id: &BotId) -> ApiResult<(Crew, BotRecord)> Ok((crew, record)) } -fn ensure_handle_free( +pub(crate) fn ensure_handle_free( store: &Store, crew: &CrewId, handle: &str, diff --git a/crates/botloftd/src/service/crews.rs b/crates/botloftd/src/service/crews.rs index b9bc65e7..67e4d8ae 100644 --- a/crates/botloftd/src/service/crews.rs +++ b/crates/botloftd/src/service/crews.rs @@ -3,17 +3,23 @@ use botloft_core::ids::CrewId; use botloft_core::protocol::{ Crew, CrewIdParams, CrewsCreateParams, CrewsRenameParams, CrewsSetPausedParams, + CrewsSetWorkFolderParams, }; use botloft_core::{now_ms, slug, validate}; use botloft_store::Store; use tracing::warn; +use super::bots::NewBot; use super::{ApiError, ApiResult, bots, pick_slug}; use crate::state::{Daemon, Event}; use crate::workspace; pub fn list(daemon: &Daemon) -> ApiResult<Vec<Crew>> { - Ok(daemon.store().crews(false)?) + let crews = daemon.store().crews(false)?; + Ok(crews + .into_iter() + .map(|crew| present(daemon, crew)) + .collect()) } pub fn create(daemon: &Daemon, params: CrewsCreateParams) -> ApiResult<Crew> { @@ -23,18 +29,40 @@ pub fn create(daemon: &Daemon, params: CrewsCreateParams) -> ApiResult<Crew> { let slug = pick_slug(&slug::slugify(&name, "crew"), |candidate| { Ok(store.crew_slug_exists(candidate)? || daemon.paths.crew_dir(candidate).exists()) })?; - workspace::prepare_crew(&daemon.paths, &slug).map_err(ApiError::Workspace)?; + let chosen = params + .work_folder + .as_deref() + .map(|input| choose_folder(daemon, input)) + .transpose()?; - let crew = Crew { + let lead = params + .lead + .map(|lead| NewBot::check(&lead.name, &lead.role, &lead.instructions, None, lead.model)) + .transpose()?; + + let mut crew = Crew { id: CrewId::generate(), name, slug, + work_folder_chosen: chosen.is_some(), + work_folder: chosen.unwrap_or_default(), + lead_bot_id: None, paused: false, created_at: now_ms(), archived_at: None, }; + workspace::prepare_crew(&daemon.paths, &crew).map_err(ApiError::Workspace)?; store.insert_crew(&crew)?; - daemon.emit(Event::CrewChanged(crew.clone())); + // The chief is saved before the store is let go, so it starts as one. + let chief = match lead { + Some(lead) => Some(super::lead::create_chief(daemon, &store, &mut crew, lead)?), + None => None, + }; + let crew = changed(daemon, crew); + if let Some(chief) = chief { + bots::changed(daemon, &store, &crew, chief); + daemon.supervisor.wake(); + } Ok(crew) } @@ -51,8 +79,41 @@ pub fn rename(daemon: &Daemon, params: CrewsRenameParams) -> ApiResult<Crew> { warn!(bot = %bot.id, "could not refresh the bot rules after a crew rename: {err}"); } } - daemon.emit(Event::CrewChanged(crew.clone())); - Ok(crew) + Ok(changed(daemon, crew)) +} + +/// Moves the crew to another work folder, or back to `shared`. Each bot +/// restarts to reach it once nothing is in progress (spec 7.4). +pub fn set_work_folder(daemon: &Daemon, params: CrewsSetWorkFolderParams) -> ApiResult<Crew> { + let chosen = params + .work_folder + .as_deref() + .map(|input| choose_folder(daemon, input)) + .transpose()?; + let store = daemon.store(); + let mut crew = active(&store, ¶ms.crew_id)?; + if crew.work_folder_chosen == chosen.is_some() + && chosen + .as_deref() + .is_none_or(|path| path == crew.work_folder) + { + return Ok(present(daemon, crew)); + } + crew.work_folder_chosen = chosen.is_some(); + crew.work_folder = chosen.unwrap_or_default(); + workspace::prepare_crew(&daemon.paths, &crew).map_err(ApiError::Workspace)?; + store.update_crew(&crew)?; + + let bots = store.bots(Some(&crew.id), false)?; + drop(store); + for bot in &bots { + if let Err(err) = workspace::write_rules(&daemon.paths, &crew, bot) { + warn!(bot = %bot.id, "could not refresh the bot rules after a folder change: {err}"); + } + daemon.supervisor.launch_settings_changed(&bot.id); + } + tracing::info!(crew = %crew.id, "work folder changed"); + Ok(changed(daemon, crew)) } pub fn set_paused(daemon: &Daemon, params: CrewsSetPausedParams) -> ApiResult<Crew> { @@ -61,10 +122,11 @@ pub fn set_paused(daemon: &Daemon, params: CrewsSetPausedParams) -> ApiResult<Cr if crew.paused != params.paused { crew.paused = params.paused; store.update_crew(&crew)?; - daemon.emit(Event::CrewChanged(crew.clone())); + let crew = changed(daemon, crew); daemon.supervisor.wake(); + return Ok(crew); } - Ok(crew) + Ok(present(daemon, crew)) } /// Archives the crew and its bots. Archiving twice is not an error. @@ -72,7 +134,7 @@ pub fn archive(daemon: &Daemon, params: CrewIdParams) -> ApiResult<Crew> { let store = daemon.store(); let crew = find(&store, ¶ms.crew_id)?; if crew.archived_at.is_some() { - return Ok(crew); + return Ok(present(daemon, crew)); } let bots = store.bots(Some(&crew.id), false)?; store.archive_crew(&crew.id, now_ms())?; @@ -85,11 +147,31 @@ pub fn archive(daemon: &Daemon, params: CrewIdParams) -> ApiResult<Crew> { ))); } } - daemon.emit(Event::CrewChanged(crew.clone())); + let crew = changed(daemon, crew); daemon.supervisor.wake(); Ok(crew) } +/// The crew as the app sees it: with the path of its `shared` folder when +/// the owner chose none. +pub(crate) fn present(daemon: &Daemon, mut crew: Crew) -> Crew { + if !crew.work_folder_chosen { + crew.work_folder = daemon.paths.work_folder(&crew).display().to_string(); + } + crew +} + +pub(crate) fn changed(daemon: &Daemon, crew: Crew) -> Crew { + let crew = present(daemon, crew); + daemon.emit(Event::CrewChanged(crew.clone())); + crew +} + +fn choose_folder(daemon: &Daemon, input: &str) -> ApiResult<String> { + let path = workspace::folder::choose(&daemon.paths, input).map_err(ApiError::validation)?; + Ok(path.display().to_string()) +} + pub(crate) fn find(store: &Store, id: &CrewId) -> ApiResult<Crew> { store .crew(id)? diff --git a/crates/botloftd/src/service/lead.rs b/crates/botloftd/src/service/lead.rs new file mode 100644 index 00000000..c288fa87 --- /dev/null +++ b/crates/botloftd/src/service/lead.rs @@ -0,0 +1,132 @@ +//! A crew's chief (spec 10.2): created with the crew, moved by the owner, +//! and the only bot that may suggest new ones. + +use botloft_core::ids::BotId; +use botloft_core::protocol::{Bot, Crew, CrewsSetLeadParams}; +use botloft_store::{BotRecord, Store}; +use tracing::{info, warn}; + +use super::bots::{self, NewBot}; +use super::{ApiError, ApiResult, crews}; +use crate::state::Daemon; +use crate::workspace; + +pub(crate) fn is_lead(crew: &Crew, bot: &BotId) -> bool { + crew.lead_bot_id.as_ref() == Some(bot) +} + +/// Saves the chief of a crew being created, under the caller's lock, so its +/// first start already reads that it leads. +pub(crate) fn create_chief( + daemon: &Daemon, + store: &Store, + crew: &mut Crew, + lead: NewBot, +) -> ApiResult<BotRecord> { + let id = BotId::generate(); + crew.lead_bot_id = Some(id.clone()); + let record = bots::insert(daemon, store, crew, id, lead)?; + store.update_crew(crew)?; + Ok(record) +} + +/// Makes a bot of the crew its chief, or leaves the crew without one. The +/// old and the new chief restart to read their rules once idle. +pub fn set_lead(daemon: &Daemon, params: CrewsSetLeadParams) -> ApiResult<Crew> { + let store = daemon.store(); + let mut crew = crews::active(&store, ¶ms.crew_id)?; + if let Some(bot) = ¶ms.bot_id { + let (bot_crew, _) = bots::active(&store, bot)?; + if bot_crew.id != crew.id { + return Err(ApiError::validation(format!( + "bot {bot} is not in crew {}", + crew.id + ))); + } + } + if crew.lead_bot_id == params.bot_id { + return Ok(crews::present(daemon, crew)); + } + let old = std::mem::replace(&mut crew.lead_bot_id, params.bot_id.clone()); + store.update_crew(&crew)?; + + let touched: Vec<BotId> = old.into_iter().chain(params.bot_id).collect(); + for id in &touched { + match store.bot(id) { + Ok(Some(record)) if record.archived_at.is_none() => { + if let Err(err) = workspace::write_rules(&daemon.paths, &crew, &record) { + warn!(bot = %id, "could not refresh the rules of a chief: {err}"); + } + } + Ok(_) => {} + Err(err) => warn!(bot = %id, "could not read a chief: {err}"), + } + } + drop(store); + for id in &touched { + daemon.supervisor.launch_settings_changed(id); + } + info!(crew = %crew.id, "chief changed"); + Ok(crews::changed(daemon, crew)) +} + +/// An archived chief leaves its crew without one. +pub(crate) fn forget_archived( + daemon: &Daemon, + store: &Store, + crew: &Crew, + bot: &BotId, +) -> ApiResult<()> { + if !is_lead(crew, bot) { + return Ok(()); + } + let mut crew = crew.clone(); + crew.lead_bot_id = None; + store.update_crew(&crew)?; + crews::changed(daemon, crew); + Ok(()) +} + +/// Whether the chief `lead` may add `new` to its crew now: it still leads, +/// the name is free and the crew has room. Checked before asking the owner +/// and again when creating. +pub(crate) fn check_suggestion(daemon: &Daemon, lead: &BotId, new: &NewBot) -> ApiResult<()> { + let store = daemon.store(); + room_for(daemon, &store, lead, new).map(drop) +} + +/// Creates a bot the chief suggested and the owner allowed (spec 10.2). +pub(crate) fn create_suggested(daemon: &Daemon, lead: &BotId, new: NewBot) -> ApiResult<Bot> { + let store = daemon.store(); + let crew = room_for(daemon, &store, lead, &new)?; + let record = bots::insert(daemon, &store, &crew, BotId::generate(), new)?; + let bot = bots::changed(daemon, &store, &crew, record); + drop(store); + daemon.supervisor.wake(); + info!(crew = %crew.id, bot = %bot.id, "the chief's suggested bot was created"); + Ok(bot) +} + +fn room_for(daemon: &Daemon, store: &Store, lead: &BotId, new: &NewBot) -> ApiResult<Crew> { + let (crew, _) = bots::active(store, lead)?; + if !is_lead(&crew, lead) { + return Err(ApiError::Conflict( + "only the crew's chief can suggest new bots; ask the chief with send_message".into(), + )); + } + let size = store.bots(Some(&crew.id), false)?.len(); + let max = daemon.bots.max_per_crew; + if size >= max { + return Err(ApiError::Conflict(format!( + "the crew already has {size} bots, the most a chief can reach ({max}); \ + use the bots you have, or ask the owner to archive one" + ))); + } + bots::ensure_handle_free( + store, + &crew.id, + &botloft_core::slug::slugify(&new.name, "bot"), + None, + )?; + Ok(crew) +} diff --git a/crates/botloftd/src/service/mod.rs b/crates/botloftd/src/service/mod.rs index b3c42fe4..108e5c7f 100644 --- a/crates/botloftd/src/service/mod.rs +++ b/crates/botloftd/src/service/mod.rs @@ -6,10 +6,13 @@ pub mod bots; pub mod chat; pub mod crews; pub mod deliveries; +pub mod lead; pub mod messages; +pub mod models; +pub mod modes; pub mod tasks; -use botloft_core::protocol::{PROTOCOL_VERSION, SystemStatus, error_code}; +use botloft_core::protocol::{OwnerAccount, PROTOCOL_VERSION, SystemStatus, error_code}; use botloft_core::slug; use botloft_core::validate::ValidationError; use botloft_store::StoreError; @@ -58,6 +61,13 @@ impl From<StoreError> for ApiError { pub type ApiResult<T> = Result<T, ApiError>; +/// The owner's name, asked of Windows once: it does not change while the +/// daemon runs. +fn owner_name() -> String { + static NAME: std::sync::OnceLock<String> = std::sync::OnceLock::new(); + NAME.get_or_init(crate::platform::owner_name).clone() +} + pub fn status(daemon: &Daemon) -> ApiResult<SystemStatus> { let deliveries = daemon.store().delivery_backlog()?; Ok(SystemStatus { @@ -71,6 +81,10 @@ pub fn status(daemon: &Daemon) -> ApiResult<SystemStatus> { .claude_path() .map(|path| path.display().to_string()), claude_signed_in: daemon.supervisor.claude_signed_in(), + account: OwnerAccount { + name: owner_name(), + claude: daemon.supervisor.claude_account(), + }, deliveries, usage: daemon.usage(), }) diff --git a/crates/botloftd/src/service/models.rs b/crates/botloftd/src/service/models.rs new file mode 100644 index 00000000..3a1b76a0 --- /dev/null +++ b/crates/botloftd/src/service/models.rs @@ -0,0 +1,44 @@ +//! A bot's model (spec 7.4): what the owner picks, and the model Claude +//! Code reports at the start of each turn. + +use botloft_core::ids::BotId; +use botloft_core::protocol::{Bot, BotsSetModelParams}; +use tracing::{info, warn}; + +use super::ApiResult; +use super::bots::{active, changed, to_protocol}; +use crate::state::Daemon; + +/// Saves the model; the bot restarts on it when nothing is in progress. +pub fn set_model(daemon: &Daemon, params: BotsSetModelParams) -> ApiResult<Bot> { + let store = daemon.store(); + let (crew, mut record) = active(&store, ¶ms.bot_id)?; + if record.model == params.model { + return Ok(to_protocol(daemon, &store, &crew, record)); + } + record.model = params.model; + store.update_bot(&record)?; + let bot = changed(daemon, &store, &crew, record); + drop(store); + info!(bot = %params.bot_id, model = params.model.as_str(), "model changed"); + daemon.supervisor.launch_settings_changed(¶ms.bot_id); + Ok(bot) +} + +/// The model id in `system/init`, so the app can name the model a bot +/// really runs on, the plan's default included. +pub(crate) fn reported(daemon: &Daemon, bot: &BotId, model: &str) { + let store = daemon.store(); + let Ok((crew, mut record)) = active(&store, bot) else { + return; + }; + if model.is_empty() || record.model_in_use.as_deref() == Some(model) { + return; + } + if let Err(err) = store.set_model_in_use(bot, model) { + warn!(bot = %bot, "could not save the model in use: {err}"); + return; + } + record.model_in_use = Some(model.to_owned()); + changed(daemon, &store, &crew, record); +} diff --git a/crates/botloftd/src/service/modes.rs b/crates/botloftd/src/service/modes.rs new file mode 100644 index 00000000..85a02c91 --- /dev/null +++ b/crates/botloftd/src/service/modes.rs @@ -0,0 +1,55 @@ +//! A bot's permission mode (spec 7.4): what the owner picks in the chat, +//! and what Claude Code reports when it changes the mode by itself. + +use botloft_core::ids::BotId; +use botloft_core::protocol::{Bot, BotsSetPermissionModeParams, PermissionMode}; +use tracing::{info, warn}; + +use super::ApiResult; +use super::bots::{active, changed, to_protocol}; +use crate::state::Daemon; + +/// Saves the mode; the bot restarts into it when nothing is in progress. +pub fn set_permission_mode(daemon: &Daemon, params: BotsSetPermissionModeParams) -> ApiResult<Bot> { + let store = daemon.store(); + let (crew, mut record) = active(&store, ¶ms.bot_id)?; + if record.permission_mode == params.mode { + return Ok(to_protocol(daemon, &store, &crew, record)); + } + record.permission_mode = params.mode; + store.update_bot(&record)?; + let bot = changed(daemon, &store, &crew, record); + drop(store); + info!(bot = %params.bot_id, mode = params.mode.as_str(), "permission mode changed"); + daemon.supervisor.launch_settings_changed(¶ms.bot_id); + Ok(bot) +} + +/// The mode Claude Code reports in `system/init`. It leaves plan mode by +/// itself when the owner approves a plan; the stored mode follows, so the +/// app shows what the bot does and a restart keeps it. Any other difference +/// comes from a process that is about to restart into the mode the owner +/// just picked, and is ignored. +pub(crate) fn reported(daemon: &Daemon, bot: &BotId, reported: &str) { + let Some(mode) = PermissionMode::from_cli(reported) else { + return; + }; + if mode == PermissionMode::Plan + || daemon.supervisor.launched_mode(bot) != Some(PermissionMode::Plan) + { + return; + } + let store = daemon.store(); + let Ok((crew, mut record)) = active(&store, bot) else { + return; + }; + if record.permission_mode != PermissionMode::Plan { + return; + } + record.permission_mode = mode; + if let Err(err) = store.update_bot(&record) { + warn!(bot = %bot, "could not save the mode after the plan: {err}"); + return; + } + changed(daemon, &store, &crew, record); +} diff --git a/crates/botloftd/src/state.rs b/crates/botloftd/src/state.rs index bbba196a..318b18b0 100644 --- a/crates/botloftd/src/state.rs +++ b/crates/botloftd/src/state.rs @@ -44,6 +44,8 @@ pub struct BotSettings { pub approval_timeout: Duration, /// Largest attachment, per file (spec 9.5). pub attachment_max_bytes: u64, + /// Most bots a chief's suggestions can bring a crew to (spec 10.2). + pub max_per_crew: usize, } impl BotSettings { @@ -51,6 +53,7 @@ impl BotSettings { Self { approval_timeout: Duration::from_secs(config.bots.approval_timeout_minutes * 60), attachment_max_bytes: config.bots.attachment_max_mb * 1024 * 1024, + max_per_crew: config.bots.max_per_crew, } } } diff --git a/crates/botloftd/src/supervisor/mod.rs b/crates/botloftd/src/supervisor/mod.rs index 8724f696..0a4f83c0 100644 --- a/crates/botloftd/src/supervisor/mod.rs +++ b/crates/botloftd/src/supervisor/mod.rs @@ -6,6 +6,7 @@ //! (service calls read states), never the other way around. mod reconcile; +mod relaunch; mod settings; mod sign_in; mod slot; diff --git a/crates/botloftd/src/supervisor/relaunch.rs b/crates/botloftd/src/supervisor/relaunch.rs new file mode 100644 index 00000000..21f9626c --- /dev/null +++ b/crates/botloftd/src/supervisor/relaunch.rs @@ -0,0 +1,65 @@ +//! A new launch setting reaches the bot (spec 7.4): its permission mode or +//! its model. Claude Code only reads `--permission-mode` and `--model` when +//! it starts, so the process restarts, resuming the conversation, as soon +//! as nothing is in progress: at once when idle, or when the turn that is +//! running (and its approvals) ends. + +use botloft_core::ids::BotId; +use botloft_core::protocol::PermissionMode; +use tracing::warn; + +use super::Supervisor; +use super::slot::{Slot, StopIntent}; + +impl Supervisor { + pub fn launch_settings_changed(&self, bot: &BotId) { + let mut inner = self.lock(); + let Some(slot) = inner.slots.get_mut(bot) else { + return; + }; + if slot.running.is_none() || slot.stop.is_some() { + // The next start reads the new settings anyway. + return; + } + if slot.turns == 0 && slot.approvals == 0 { + self.relaunch(bot, slot); + } else { + slot.restart_when_idle = true; + } + } + + /// Whether new settings wait for the running turn to end. + pub fn relaunch_pending(&self, bot: &BotId) -> bool { + self.lock() + .slots + .get(bot) + .is_some_and(|slot| slot.restart_when_idle) + } + + /// The `--permission-mode` the running process started with. + pub fn launched_mode(&self, bot: &BotId) -> Option<PermissionMode> { + self.lock() + .slots + .get(bot) + .and_then(|slot| slot.running.as_ref()) + .map(|running| running.permission_mode) + } + + /// Called when a turn or an approval ends. + pub(super) fn relaunch_if_idle(&self, bot: &BotId, slot: &mut Slot) { + if slot.restart_when_idle && slot.turns == 0 && slot.approvals == 0 && slot.stop.is_none() { + self.relaunch(bot, slot); + } + } + + fn relaunch(&self, bot: &BotId, slot: &mut Slot) { + slot.restart_when_idle = false; + slot.stop = Some(StopIntent::Restart { fresh: false }); + if let Some(running) = &slot.running + && let Err(err) = running.control.kill() + { + warn!(bot = %bot, "could not restart the bot for its new settings: {err}"); + } + self.wake(); + } +} diff --git a/crates/botloftd/src/supervisor/sign_in.rs b/crates/botloftd/src/supervisor/sign_in.rs index f1afec03..d9170e2d 100644 --- a/crates/botloftd/src/supervisor/sign_in.rs +++ b/crates/botloftd/src/supervisor/sign_in.rs @@ -4,7 +4,7 @@ //! When it turns from signed out to signed in, the bots a sign-in error //! stopped start again by themselves: the owner just signed in. -use botloft_core::protocol::BotState; +use botloft_core::protocol::{BotState, ClaudeAccount}; use tokio::time::Instant; use tracing::{debug, info}; @@ -13,6 +13,7 @@ use super::{ClaudeStatus, Inner, REPROBE_AFTER, Supervisor}; #[derive(Debug, Default)] pub(super) struct SignIn { known: Option<bool>, + account: Option<ClaudeAccount>, checked_at: Option<Instant>, recheck: bool, } @@ -36,6 +37,11 @@ impl Supervisor { self.lock().sign_in.known } + /// The Claude account Claude Code is signed in to, once checked. + pub fn claude_account(&self) -> Option<ClaudeAccount> { + self.lock().sign_in.account.clone() + } + /// Checks Claude Code again now: the sign-in, and the executable if it /// was missing or too old (after the owner signed in or installed it). pub fn refresh_claude(&self) { @@ -64,12 +70,14 @@ impl Supervisor { _ => return, } }; - let checked = self.runtime.signed_in(program).await; + let checked = self.runtime.auth_status(program).await; let mut inner = self.lock(); inner.sign_in.recheck = false; inner.sign_in.checked_at = Some(Instant::now()); match checked { - Ok(signed_in) => { + Ok(status) => { + let signed_in = status.signed_in; + inner.sign_in.account = status.account; let was = inner.sign_in.known.replace(signed_in); if signed_in && was == Some(false) { info!("Claude Code is signed in again; starting the bots it stopped"); diff --git a/crates/botloftd/src/supervisor/slot.rs b/crates/botloftd/src/supervisor/slot.rs index 2f911930..7b1b605e 100644 --- a/crates/botloftd/src/supervisor/slot.rs +++ b/crates/botloftd/src/supervisor/slot.rs @@ -2,7 +2,7 @@ use std::time::Duration; -use botloft_core::protocol::BotState; +use botloft_core::protocol::{BotState, PermissionMode}; use tokio::time::Instant; use crate::runtime::ProcessControl; @@ -24,6 +24,9 @@ pub(super) struct Slot { pub approvals: u32, /// While `rate_limited`: Unix ms when the limit resets. pub limited_until: Option<i64>, + /// A new permission mode or model waits for the running turn to end + /// (spec 7.4). + pub restart_when_idle: bool, } impl Slot { @@ -39,6 +42,7 @@ impl Slot { turns: 0, approvals: 0, limited_until: None, + restart_when_idle: false, } } @@ -69,6 +73,8 @@ pub(super) struct Running { /// Started with `--resume`. pub resumed: bool, pub token_hash: String, + /// The `--permission-mode` it started with. + pub permission_mode: PermissionMode, } #[derive(Debug, Clone, Copy, PartialEq, Eq)] diff --git a/crates/botloftd/src/supervisor/spawn.rs b/crates/botloftd/src/supervisor/spawn.rs index 00757a4b..911e710b 100644 --- a/crates/botloftd/src/supervisor/spawn.rs +++ b/crates/botloftd/src/supervisor/spawn.rs @@ -23,6 +23,8 @@ use crate::{approvals, courier, workspace}; /// Tools the bot uses without asking: its crew tools (spec 7.4). const ALLOWED_TOOLS: &str = "mcp__botloft"; +/// Makes Claude Code load `CLAUDE.md` from `--add-dir` folders (spec 5). +const ADDITIONAL_MEMORY: &str = "CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD"; /// Where permission requests go (spec 10.1). const PERMISSION_TOOL: &str = "mcp__botloft__permission_prompt"; @@ -67,12 +69,14 @@ impl Supervisor { slot.turns = 0; slot.approvals = 0; slot.limited_until = None; + slot.restart_when_idle = false; tokens.insert(launch.token_hash.clone(), (bot.id.clone(), generation)); slot.running = Some(Running { control: process.control, started: Instant::now(), resumed: launch.resumed, token_hash: launch.token_hash, + permission_mode: bot.permission_mode, }); self.count_busy(slot.state, BotState::Launching); slot.state = BotState::Launching; @@ -197,7 +201,7 @@ fn launch_spec( "project,local", "--strict-mcp-config", "--permission-mode", - "default", + bot.permission_mode.cli_value(), "--permission-prompt-tool", PERMISSION_TOOL, "--allowedTools", @@ -207,6 +211,14 @@ fn launch_spec( args.push(arg.into()); } args.push(mcp.into_os_string()); + // The crew's work folder, which the bot edits like its own (spec 5). + args.push("--add-dir".into()); + args.push(daemon.paths.work_folder(crew).into_os_string()); + // Without the flag, Claude Code uses the default of the owner's plan. + if let Some(model) = bot.model.cli_value() { + args.push("--model".into()); + args.push(model.into()); + } let mut env = platform::user_environment()?; env.retain(|(name, _)| { @@ -219,6 +231,8 @@ fn launch_spec( ("BOTLOFT_BOT_ID", OsString::from(bot.id.as_str())), ("BOTLOFT_BOT_TOKEN", OsString::from(&token)), ("BOTLOFT_PORT", OsString::from(daemon.port.to_string())), + // Loads the work folder's CLAUDE.md with the bot's memory. + (ADDITIONAL_MEMORY, OsString::from("1")), ] { env.push((OsString::from(name), value)); } diff --git a/crates/botloftd/src/supervisor/turns.rs b/crates/botloftd/src/supervisor/turns.rs index 88afbd99..cfab3617 100644 --- a/crates/botloftd/src/supervisor/turns.rs +++ b/crates/botloftd/src/supervisor/turns.rs @@ -44,6 +44,7 @@ impl Supervisor { if slot.is_working() { supervisor.set_state(bot, slot, slot.working_state()); } + supervisor.relaunch_if_idle(bot, slot); }); } diff --git a/crates/botloftd/src/tools/calls.rs b/crates/botloftd/src/tools/calls.rs index 313bae2f..6afe4f5d 100644 --- a/crates/botloftd/src/tools/calls.rs +++ b/crates/botloftd/src/tools/calls.rs @@ -17,7 +17,7 @@ use tracing::warn; use super::Failure; use super::catalog::{COMPLETE_TASK, CREW_ROSTER, MY_TASKS, SEND_MESSAGE}; use crate::service::tasks::{self, BotMessage}; -use crate::service::{ApiError, bots}; +use crate::service::{ApiError, bots, lead}; use crate::state::Daemon; /// What the bot reads when a tool fails. @@ -38,6 +38,11 @@ pub(super) fn call(daemon: &Daemon, bot: &BotId, params: &Value) -> Result<Value MY_TASKS => parse(arguments).and_then(|args| my_tasks(daemon, bot, args)), other => return Err(invalid(&format!("Unknown tool: {other}"))), }; + Ok(tool_result(outcome)) +} + +/// A tool result: the value as JSON text, or the error the bot reads. +pub(super) fn tool_result(outcome: Outcome) -> Value { let (text, is_error) = match outcome { Ok(value) => ( serde_json::to_string_pretty(&value).unwrap_or_default(), @@ -45,23 +50,23 @@ pub(super) fn call(daemon: &Daemon, bot: &BotId, params: &Value) -> Result<Value ), Err(message) => (message, true), }; - Ok(json!({ + json!({ "content": [{ "type": "text", "text": text }], "isError": is_error, - })) + }) } fn invalid(message: &str) -> Failure { Failure::new(StatusCode::OK, error_code::INVALID_PARAMS, message) } -fn parse<T: DeserializeOwned>(arguments: Value) -> Result<T, String> { +pub(super) fn parse<T: DeserializeOwned>(arguments: Value) -> Result<T, String> { serde_json::from_value(arguments).map_err(|err| format!("invalid arguments: {err}")) } /// The message a bot may see. Internal errors can name paths; they go to /// the log instead. -fn explain(err: ApiError) -> String { +pub(super) fn explain(err: ApiError) -> String { match err { ApiError::Internal(_) | ApiError::Workspace(_) => { warn!(error = %err, "a tool call failed"); @@ -81,10 +86,21 @@ fn roster(daemon: &Daemon, bot: &BotId) -> Outcome { .iter() .filter(|other| other.id != me.id) .map(|other| { - json!({ "handle": other.handle, "name": other.name, "role": other.role, "state": other.state }) + json!({ + "handle": other.handle, + "name": other.name, + "role": other.role, + "state": other.state, + "chief": lead::is_lead(&crew, &other.id), + }) }) .collect(); - Ok(json!({ "crew": crew.name, "you": me.handle, "bots": others })) + Ok(json!({ + "crew": crew.name, + "you": me.handle, + "you_lead": lead::is_lead(&crew, &me.id), + "bots": others, + })) } #[derive(Deserialize)] diff --git a/crates/botloftd/src/tools/catalog.rs b/crates/botloftd/src/tools/catalog.rs index 600073bb..ad9952ab 100644 --- a/crates/botloftd/src/tools/catalog.rs +++ b/crates/botloftd/src/tools/catalog.rs @@ -3,12 +3,16 @@ use serde_json::{Value, json}; +use super::suggest::{INSTRUCTIONS_MAX, REASON_MAX}; use crate::service::tasks::MAX_DEADLINE_MINUTES; +use botloft_core::validate::{NAME_MAX_CHARS, ROLE_MAX_CHARS}; pub const CREW_ROSTER: &str = "crew_roster"; pub const SEND_MESSAGE: &str = "send_message"; pub const COMPLETE_TASK: &str = "complete_task"; pub const MY_TASKS: &str = "my_tasks"; +/// The chief's tool (spec 10.2); Claude Code names it `mcp__botloft__suggest_bot`. +pub const SUGGEST_BOT: &str = "suggest_bot"; /// Claude Code's `--permission-prompt-tool` (spec 10.1). pub const PERMISSION_PROMPT: &str = "permission_prompt"; @@ -101,6 +105,50 @@ pub fn tools() -> Value { }, "annotations": { "readOnlyHint": true }, }, + { + "name": SUGGEST_BOT, + "title": "Suggest a new bot", + "description": "Only for the crew's chief (crew_roster marks it). Suggests a new bot \ + for work that needs a specialist the crew lacks. The owner sees the suggestion in \ + your chat, may change it, and approves or declines it; the call waits for that. \ + Once approved the bot starts at once: give it work with send_message. If the owner \ + declines, do the work yourself or with the bots you have.", + "inputSchema": { + "type": "object", + "properties": { + "name": { + "type": "string", + "maxLength": NAME_MAX_CHARS, + "description": "A short name, like \"Designer\". Its handle comes from it.", + }, + "role": { + "type": "string", + "maxLength": ROLE_MAX_CHARS, + "description": "One line: what the bot does in the crew.", + }, + "instructions": { + "type": "string", + "maxLength": INSTRUCTIONS_MAX, + "description": "Written to the new bot: what it works on, how, what it \ + hands back and when to ask.", + }, + "model": { + "type": "string", + "enum": ["default", "fable", "opus", "sonnet", "haiku"], + "description": "\"haiku\" for simple, repetitive work; \"sonnet\" for most \ + work; \"opus\" or \"fable\" for the hardest reasoning. The owner's \ + plan default when absent.", + }, + "reason": { + "type": "string", + "maxLength": REASON_MAX, + "description": "For the owner: why the crew needs this bot now.", + }, + }, + "required": ["name", "role", "instructions", "reason"], + "additionalProperties": false, + }, + }, { "name": PERMISSION_PROMPT, "title": "Permission prompt", diff --git a/crates/botloftd/src/tools/mod.rs b/crates/botloftd/src/tools/mod.rs index 9757df87..f2a00de6 100644 --- a/crates/botloftd/src/tools/mod.rs +++ b/crates/botloftd/src/tools/mod.rs @@ -9,6 +9,7 @@ mod calls; mod catalog; mod era; +mod suggest; use std::sync::Arc; @@ -30,8 +31,9 @@ use crate::state::Daemon; const CACHE_TTL_MS: u64 = 60 * 60 * 1000; const INSTRUCTIONS: &str = "Tools to work with your Botloft crew: see who is in it, send notes \ - or tasks to other bots, and report the result of tasks assigned to you. The owner writes to \ - you directly; messages from other bots and from Botloft start with [botloft]."; + or tasks to other bots, report the result of tasks assigned to you and, for the crew's chief, \ + suggest new bots. The owner writes to you directly; messages from other bots and from Botloft \ + start with [botloft]."; /// A JSON-RPC error with the HTTP status it goes out with. struct Failure { @@ -107,12 +109,16 @@ pub async fn handle( return StatusCode::ACCEPTED.into_response(); }; let answered = match era(&headers, &request) { - // Holds the request until the owner answers (spec 10.1). - Ok(era) if is_permission_prompt(&request) => { + // Both hold the request until the owner answers (spec 10.1, 10.2). + Ok(era) if called(&request) == Some(catalog::PERMISSION_PROMPT) => { permission(&daemon, &bot, generation, &request) .await .map(|result| decorate(era, &request, result)) } + Ok(era) if called(&request) == Some(catalog::SUGGEST_BOT) => { + let result = suggest::suggest(&daemon, &bot, generation, arguments(&request)).await; + Ok(decorate(era, &request, result)) + } Ok(era) => answer(&daemon, &bot, era, &request), Err(failure) => Err(failure), }; @@ -139,14 +145,25 @@ fn json_response(status: StatusCode, body: String) -> Response { (status, [(header::CONTENT_TYPE, "application/json")], body).into_response() } -fn is_permission_prompt(request: &Request) -> bool { - request.method == "tools/call" - && request - .params - .as_ref() - .and_then(|params| params.get("name")) - .and_then(Value::as_str) - == Some(catalog::PERMISSION_PROMPT) +/// The tool a `tools/call` names. +fn called(request: &Request) -> Option<&str> { + if request.method != "tools/call" { + return None; + } + request + .params + .as_ref() + .and_then(|params| params.get("name")) + .and_then(Value::as_str) +} + +fn arguments(request: &Request) -> Value { + request + .params + .as_ref() + .and_then(|params| params.get("arguments")) + .cloned() + .unwrap_or_else(|| json!({})) } async fn permission( @@ -155,19 +172,14 @@ async fn permission( generation: u64, request: &Request, ) -> Result<Value, Failure> { - let arguments = request - .params - .as_ref() - .and_then(|params| params.get("arguments")) - .cloned() - .unwrap_or_else(|| json!({})); - let args: approvals::PromptArgs = serde_json::from_value(arguments).map_err(|err| { - Failure::new( - StatusCode::OK, - error_code::INVALID_PARAMS, - format!("invalid arguments: {err}"), - ) - })?; + let args: approvals::PromptArgs = + serde_json::from_value(arguments(request)).map_err(|err| { + Failure::new( + StatusCode::OK, + error_code::INVALID_PARAMS, + format!("invalid arguments: {err}"), + ) + })?; let decision = approvals::prompt(daemon, bot, generation, args).await; Ok(json!({ "content": [{ "type": "text", "text": decision }], "isError": false })) } diff --git a/crates/botloftd/src/tools/suggest.rs b/crates/botloftd/src/tools/suggest.rs new file mode 100644 index 00000000..81887a37 --- /dev/null +++ b/crates/botloftd/src/tools/suggest.rs @@ -0,0 +1,144 @@ +//! `suggest_bot` (spec 10.2): the crew's chief asks for a new bot. The owner +//! sees the suggestion in the chief's chat, may change it, and allows or +//! declines it; the call waits for that, like a permission request. A chief +//! that bypasses permissions creates the bot at once. + +use botloft_core::chat::SUGGEST_TOOL; +use botloft_core::ids::BotId; +use botloft_core::protocol::{Bot, BotModel, PermissionMode}; +use serde::{Deserialize, Serialize}; +use serde_json::{Value, json}; + +use super::calls::{explain, parse, tool_result}; +use crate::approvals::{self, Answer}; +use crate::service::bots::{self, NewBot}; +use crate::service::lead; +use crate::state::Daemon; + +/// Longest instructions a chief may write for a new bot, in characters. +pub(super) const INSTRUCTIONS_MAX: usize = 8_000; +/// Longest reason, in characters. +pub(super) const REASON_MAX: usize = 1_000; + +/// The tool's input, and what the owner sends back when they change it. +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +struct Suggestion { + name: String, + role: String, + instructions: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + model: Option<String>, + reason: String, +} + +pub(super) async fn suggest( + daemon: &Daemon, + bot: &BotId, + generation: u64, + arguments: Value, +) -> Value { + tool_result(run(daemon, bot, generation, arguments).await) +} + +async fn run( + daemon: &Daemon, + bot: &BotId, + generation: u64, + arguments: Value, +) -> Result<Value, String> { + let suggestion: Suggestion = parse(arguments)?; + let new = check(&suggestion)?; + // Nothing impossible goes to the owner. + lead::check_suggestion(daemon, bot, &new).map_err(explain)?; + let mode = bots::find(&daemon.store(), bot) + .map_err(explain)? + .permission_mode; + if mode == PermissionMode::BypassPermissions { + let created = lead::create_suggested(daemon, bot, new).map_err(explain)?; + return Ok(created_note( + &created, + "You bypass permissions, so it was created without asking the owner.", + )); + } + + let input = serde_json::to_value(&suggestion).map_err(|err| err.to_string())?; + match approvals::ask(daemon, bot, generation, SUGGEST_TOOL, &input, "").await { + Some(Answer::Allowed { input: None }) => { + let created = lead::create_suggested(daemon, bot, new).map_err(explain)?; + Ok(created_note(&created, "The owner approved it.")) + } + Some(Answer::Allowed { + input: Some(changed), + }) => { + let changed: Suggestion = serde_json::from_str(&changed) + .map_err(|err| format!("the owner's changes could not be read: {err}"))?; + let created = lead::create_suggested(daemon, bot, check(&changed)?).map_err(explain)?; + Ok(created_note( + &created, + "The owner changed the suggestion before approving it: read the name, role \ + and model above.", + )) + } + Some(Answer::Denied { note }) => { + let why = note.map_or_else(String::new, |note| format!(" They said: {note}")); + Ok(json!({ + "created": false, + "note": format!( + "The owner declined this bot.{why} Do the work yourself or with the bots \ + you have." + ), + })) + } + Some(Answer::Expired) => Ok(json!({ + "created": false, + "note": "The owner did not answer in time. Do the work yourself or with the bots you \ + have, and suggest it again later if it still helps.", + })), + None => Err("Botloft could not ask the owner.".to_owned()), + } +} + +/// The suggestion as a new bot, with the limits of this tool on top of a +/// bot's own. +fn check(suggestion: &Suggestion) -> Result<NewBot, String> { + if suggestion.instructions.chars().count() > INSTRUCTIONS_MAX { + return Err(format!( + "instructions must be at most {INSTRUCTIONS_MAX} characters" + )); + } + let reason = suggestion.reason.trim(); + if reason.is_empty() || reason.chars().count() > REASON_MAX { + return Err(format!( + "reason must say, in at most {REASON_MAX} characters, why the crew needs this bot" + )); + } + let model = match suggestion.model.as_deref() { + None => None, + Some(model) => Some(model.parse::<BotModel>().map_err(|_| { + "model must be \"default\", \"fable\", \"opus\", \"sonnet\" or \"haiku\"".to_owned() + })?), + }; + NewBot::check( + &suggestion.name, + &suggestion.role, + &suggestion.instructions, + None, + model, + ) + .map_err(explain) +} + +fn created_note(bot: &Bot, how: &str) -> Value { + json!({ + "created": true, + "handle": bot.handle, + "name": bot.name, + "role": bot.role, + "model": bot.model, + "note": format!( + "{how} @{} is starting now. Give it work with send_message(to: \"{}\", kind: \"task\").", + bot.handle, bot.handle + ), + }) +} diff --git a/crates/botloftd/src/workspace/files.rs b/crates/botloftd/src/workspace/files.rs index 4c0370ff..ec24332d 100644 --- a/crates/botloftd/src/workspace/files.rs +++ b/crates/botloftd/src/workspace/files.rs @@ -50,9 +50,32 @@ session, including after restarts. Keep decisions, context about ongoing work and lessons learned here, and remove what is no longer true. "; +/// Added to the rules of the crew's chief (spec 10.2). +const LEAD_MD: &str = " +## You lead this crew + +The owner made you the chief of this crew: its goal is in your instructions. + +- Plan the work, split it into pieces that can run at the same time, and hand + them out with `send_message` and `kind: \"task\"`. Each bot works in + parallel; results come back as messages. Check them before you report. +- When a piece needs a specialist the crew lacks, call `suggest_bot`: a name, a + one-line role, instructions written to that bot, a model and why it helps. + The owner approves each new bot in your chat and may change it (unless you + bypass permissions). Then give it work with a task. +- Pick the model by the work: `haiku` for simple, repetitive tasks, `sonnet` + for most work, `opus` or `fable` only for the hardest reasoning. Leave it out + to use the owner's plan default. Stronger models use up the owner's plan + faster. +- Keep the crew small: do small jobs yourself and prefer a bot that already + exists (`crew_roster`). +- Tell the owner what each bot is doing, so they can follow and talk to each + one in its own chat. +"; + /// `.claude/rules/botloft.md`: who the bot is and how to work with its crew. /// Regenerated whenever the bot or its crew changes. -pub fn rules_md(crew: &Crew, bot: &BotRecord, shared_dir: &Path) -> String { +pub fn rules_md(crew: &Crew, bot: &BotRecord, work_folder: &Path) -> String { let role = if bot.role.is_empty() { "No role was given. Ask the owner if it is unclear what you should do." } else { @@ -63,6 +86,11 @@ pub fn rules_md(crew: &Crew, bot: &BotRecord, shared_dir: &Path) -> String { } else { bot.instructions.as_str() }; + let lead = if crew.lead_bot_id.as_ref() == Some(&bot.id) { + LEAD_MD + } else { + "" + }; format!( "<!-- Generated by Botloft. Edits are overwritten; change the bot in the Botloft app. --> @@ -91,8 +119,11 @@ app; the other bots of your crew send you messages too. ## Working with your crew -- This folder is your workspace. `CLAUDE.md` here is your memory across restarts. -- Files for the whole crew go in the shared folder: `{shared}`. +- The crew works in `{work}`: the owner reads what you make there, and so do + the other bots. Put the files you make for them in it. A `CLAUDE.md` in it + is loaded with your memory: follow it. +- This folder is yours: `CLAUDE.md` here is your memory across restarts, and + scratch files can stay here. - Messages from other bots and notices from Botloft start with `[botloft]`. The first line says who sent it; for a task it also has the task id and the deadline. @@ -107,11 +138,14 @@ app; the other bots of your crew send you messages too. (`status: \"failed\"` and why): the bot that asked is waiting for it. - Do not wait in a loop for a reply. Finish your turn; the reply arrives as a new message. -", +- If the crew needs another bot, ask its chief (`crew_roster` marks it with + `\"chief\": true`). Only the chief can suggest new bots. +{lead}", name = bot.name, handle = bot.handle, crew = crew.name, - shared = shared_dir.display(), + work = work_folder.display(), + lead = lead, ) } @@ -149,6 +183,9 @@ mod tests { id: CrewId::generate(), name: "Site".to_owned(), slug: "site".to_owned(), + work_folder: String::new(), + work_folder_chosen: false, + lead_bot_id: None, paused: false, created_at: 0, archived_at: None, @@ -163,6 +200,9 @@ mod tests { instructions: "Review every PR.".to_owned(), color: "#FF7A59".to_owned(), paused: false, + permission_mode: botloft_core::protocol::PermissionMode::Default, + model: botloft_core::protocol::BotModel::Default, + model_in_use: None, created_at: 0, archived_at: None, }; @@ -173,5 +213,14 @@ mod tests { assert!(rules.contains("Ask the owner")); assert!(rules.contains("/ws/site/shared")); assert!(rules.contains("attachments/")); + assert!(!rules.contains("You lead this crew")); + + let chief = Crew { + lead_bot_id: Some(bot.id.clone()), + ..crew + }; + let rules = rules_md(&chief, &bot, Path::new("/ws/site/shared")); + assert!(rules.contains("## You lead this crew")); + assert!(rules.contains("`suggest_bot`")); } } diff --git a/crates/botloftd/src/workspace/folder.rs b/crates/botloftd/src/workspace/folder.rs new file mode 100644 index 00000000..6271246f --- /dev/null +++ b/crates/botloftd/src/workspace/folder.rs @@ -0,0 +1,130 @@ +//! A work folder the owner picks for a crew (spec 5). Every bot of the crew +//! may edit it like its own folder, so it must not reach Botloft's data or +//! the other crews. + +use std::io; +use std::path::{Component, Path, PathBuf}; + +use crate::paths::Paths; + +/// Checks `input` and creates the folder if it is missing. The error is a +/// sentence for the owner. +pub fn choose(paths: &Paths, input: &str) -> Result<PathBuf, String> { + let input = input.trim(); + if input.is_empty() { + return Err("the work folder must not be empty".to_owned()); + } + let path = Path::new(input); + if !path.is_absolute() { + return Err(r"the work folder must be a full path, like C:\Projects\Site".to_owned()); + } + let path = + std::path::absolute(path).map_err(|err| format!("the work folder is not valid: {err}"))?; + if path.parent().is_none() { + return Err("pick a folder for the work folder, not a whole drive".to_owned()); + } + if overlaps(&path, &paths.home) { + return Err( + "the work folder cannot be inside Botloft's data folder or contain it".to_owned(), + ); + } + if contains(&path, &paths.workspaces_root) { + return Err("the work folder cannot contain the folders of every bot".to_owned()); + } + create(&path).map_err(|err| format!("could not create the work folder: {err}"))?; + Ok(path) +} + +fn create(path: &Path) -> io::Result<()> { + std::fs::create_dir_all(path)?; + if path.is_dir() { + Ok(()) + } else { + Err(io::Error::other("a file already has that name")) + } +} + +/// Windows paths ignore case; `\?\` and plain forms of a drive path match. +fn parts(path: &Path) -> Vec<String> { + path.components() + .filter_map(|component| match component { + Component::Prefix(prefix) => Some(match prefix.kind() { + std::path::Prefix::VerbatimDisk(drive) | std::path::Prefix::Disk(drive) => { + format!("{}:", char::from(drive).to_ascii_lowercase()) + } + _ => prefix.as_os_str().to_string_lossy().to_lowercase(), + }), + Component::RootDir | Component::CurDir => None, + Component::ParentDir => Some("..".to_owned()), + Component::Normal(part) => Some(part.to_string_lossy().to_lowercase()), + }) + .collect() +} + +/// Whether `outer` is `inner` or one of its parents. +fn contains(outer: &Path, inner: &Path) -> bool { + let (outer, inner) = (parts(outer), parts(inner)); + inner.len() >= outer.len() && inner[..outer.len()] == outer[..] +} + +fn overlaps(a: &Path, b: &Path) -> bool { + contains(a, b) || contains(b, a) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn paths(dir: &Path) -> Paths { + Paths::new(dir.join("Data").join("Botloft"), dir.join("Botloft")) + } + + #[test] + fn a_folder_of_the_owner_is_created_and_kept() { + let dir = tempfile::tempdir().expect("tempdir"); + let wanted = dir.path().join("Projects").join("Site"); + let chosen = choose(&paths(dir.path()), wanted.to_str().expect("utf-8")).expect("chosen"); + assert_eq!(chosen, wanted); + assert!(wanted.is_dir()); + } + + #[test] + fn botloft_data_the_bot_folders_and_drives_are_refused() { + let dir = tempfile::tempdir().expect("tempdir"); + let paths = paths(dir.path()); + let refused = [ + String::new(), + r"relative\folder".to_owned(), + paths.home.join("secrets").display().to_string(), + dir.path().join("Data").display().to_string(), + paths.workspaces_root.display().to_string(), + dir.path().display().to_string(), + ]; + for input in refused { + assert!(choose(&paths, &input).is_err(), "{input:?} was accepted"); + } + let root = dir.path().ancestors().last().expect("root"); + assert!(choose(&paths, root.to_str().expect("utf-8")).is_err()); + } + + #[test] + fn a_folder_inside_the_crew_folders_is_fine() { + let dir = tempfile::tempdir().expect("tempdir"); + let paths = paths(dir.path()); + let inside = paths.workspaces_root.join("site").join("out"); + assert!(choose(&paths, inside.to_str().expect("utf-8")).is_ok()); + } + + #[cfg(windows)] + #[test] + fn case_and_verbatim_prefixes_do_not_hide_an_overlap() { + assert!(contains( + Path::new(r"C:\Users\Ana"), + Path::new(r"\\?\c:\users\ana\AppData\Local\Botloft") + )); + assert!(!contains( + Path::new(r"C:\Users\Ana2"), + Path::new(r"C:\Users\Ana\x") + )); + } +} diff --git a/crates/botloftd/src/workspace/mod.rs b/crates/botloftd/src/workspace/mod.rs index 25c4779e..12bab010 100644 --- a/crates/botloftd/src/workspace/mod.rs +++ b/crates/botloftd/src/workspace/mod.rs @@ -3,6 +3,7 @@ //! bot's own `CLAUDE.md`. mod files; +pub mod folder; use std::io; use std::path::{Path, PathBuf}; @@ -22,14 +23,16 @@ pub struct WorkspaceEnv<'a> { pub approval_timeout: Duration, } -/// Creates the crew folder and its `shared` folder. -pub fn prepare_crew(paths: &Paths, crew_slug: &str) -> io::Result<()> { - std::fs::create_dir_all(paths.shared_dir(crew_slug)) +/// Creates the crew folder, its `shared` folder and the work folder the +/// owner chose, if it went missing. +pub fn prepare_crew(paths: &Paths, crew: &Crew) -> io::Result<()> { + std::fs::create_dir_all(paths.shared_dir(&crew.slug))?; + std::fs::create_dir_all(paths.work_folder(crew)) } /// Creates the workspace and writes every generated file. Returns the path. pub fn prepare_bot(env: WorkspaceEnv<'_>, crew: &Crew, bot: &BotRecord) -> io::Result<PathBuf> { - prepare_crew(env.paths, &crew.slug)?; + prepare_crew(env.paths, crew)?; let dir = env.paths.bot_workspace(&crew.slug, &bot.slug); std::fs::create_dir_all(dir.join(".claude").join("rules"))?; std::fs::create_dir_all(dir.join(".botloft"))?; @@ -55,7 +58,7 @@ pub fn write_rules(paths: &Paths, crew: &Crew, bot: &BotRecord) -> io::Result<() let dir = paths.bot_workspace(&crew.slug, &bot.slug); let rules_dir = dir.join(".claude").join("rules"); std::fs::create_dir_all(&rules_dir)?; - let text = files::rules_md(crew, bot, &paths.shared_dir(&crew.slug)); + let text = files::rules_md(crew, bot, &paths.work_folder(crew)); write_atomic(&rules_dir.join("botloft.md"), text.as_bytes()) } @@ -88,6 +91,9 @@ mod tests { id: CrewId::generate(), name: "Site".to_owned(), slug: "site".to_owned(), + work_folder: String::new(), + work_folder_chosen: false, + lead_bot_id: None, paused: false, created_at: 0, archived_at: None, @@ -102,6 +108,9 @@ mod tests { instructions: String::new(), color: "#FF7A59".to_owned(), paused: false, + permission_mode: botloft_core::protocol::PermissionMode::Default, + model: botloft_core::protocol::BotModel::Default, + model_in_use: None, created_at: 0, archived_at: None, }; diff --git a/crates/botloftd/tests/bot_models.rs b/crates/botloftd/tests/bot_models.rs new file mode 100644 index 00000000..3597f1b6 --- /dev/null +++ b/crates/botloftd/tests/bot_models.rs @@ -0,0 +1,129 @@ +//! A bot's model (spec 7.4): the flag it starts with, the restart onto a new +//! model once nothing is in progress, the model Claude Code reports and a +//! model the account cannot use. + +mod common; + +use std::time::Duration; + +use botloft_core::protocol::{BotModel, BotState, BotsSetModelParams, ChatBody, NoticeCode}; +use botloftd::service::{bots, models}; +use common::stream; +use common::supervised::{Setup, arg_after, setup}; +use serde_json::json; + +fn set_model(s: &Setup, model: BotModel) { + models::set_model( + &s.daemon, + BotsSetModelParams { + bot_id: s.bot.clone(), + model, + }, + ) + .expect("set model"); +} + +fn bot(s: &Setup) -> botloft_core::protocol::Bot { + bots::list(&s.daemon, Default::default()) + .expect("list") + .into_iter() + .find(|bot| bot.id == s.bot) + .expect("bot") +} + +#[tokio::test(start_paused = true)] +async fn a_new_bot_runs_on_the_plans_default_model() { + let s = setup().await; + let process = s.runtime.process(1).await; + assert!(!process.args().iter().any(|arg| arg == "--model")); + assert_eq!(bot(&s).model, BotModel::Default); + assert_eq!(bot(&s).model_in_use, None); +} + +#[tokio::test(start_paused = true)] +async fn an_idle_bot_restarts_on_its_new_model_in_the_same_conversation() { + let s = setup().await; + let first = s.runtime.process(1).await; + s.until(BotState::Idle).await; + let session = arg_after(&first, "--session-id").expect("session"); + + set_model(&s, BotModel::Haiku); + let second = s.runtime.process(2).await; + assert!(first.killed()); + assert_eq!(arg_after(&second, "--model").as_deref(), Some("haiku")); + assert_eq!(arg_after(&second, "--resume"), Some(session)); + + // Back to the plan's default: no flag at all. + s.until(BotState::Idle).await; + set_model(&s, BotModel::Default); + let third = s.runtime.process(3).await; + assert!(!third.args().iter().any(|arg| arg == "--model")); +} + +#[tokio::test(start_paused = true)] +async fn a_busy_bot_finishes_its_turn_before_changing_model() { + let s = setup().await; + let first = s.runtime.process(1).await; + s.until(BotState::Idle).await; + s.message("work"); + set_model(&s, BotModel::Opus); + tokio::time::sleep(Duration::from_secs(30)).await; + assert_eq!(s.runtime.processes().len(), 1, "the turn is not cut short"); + assert!(s.daemon.supervisor.relaunch_pending(&s.bot)); + + first.emit(stream::result(false)).await; + let second = s.runtime.process(2).await; + assert_eq!(arg_after(&second, "--model").as_deref(), Some("opus")); +} + +#[tokio::test(start_paused = true)] +async fn the_reported_model_is_kept_for_the_app() { + let s = setup().await; + let process = s.runtime.process(1).await; + s.until(BotState::Idle).await; + let session = arg_after(&process, "--session-id").expect("session"); + process + .emit(json!({ + "type": "system", "subtype": "init", "session_id": session, + "model": "claude-opus-5-5", "permissionMode": "default", + })) + .await; + tokio::time::sleep(Duration::from_millis(50)).await; + assert_eq!(bot(&s).model_in_use.as_deref(), Some("claude-opus-5-5")); + assert_eq!( + bot(&s).model, + BotModel::Default, + "the choice stays the owner's" + ); +} + +#[tokio::test(start_paused = true)] +async fn a_model_the_account_cannot_use_is_told_in_the_chat() { + let s = setup().await; + let process = s.runtime.process(1).await; + s.until(BotState::Idle).await; + s.message("hi"); + process + .emit(stream::api_error( + "model_not_found", + "There's an issue with the selected model (fable).", + )) + .await; + process.emit(stream::result(true)).await; + s.until(BotState::Idle).await; + + let items = s + .daemon + .store() + .chat_history(&s.bot, None, 50) + .expect("history"); + let notice = items + .iter() + .find_map(|item| match &item.body { + ChatBody::Notice(notice) => Some(notice.clone()), + _ => None, + }) + .expect("a notice"); + assert_eq!(notice.code, Some(NoticeCode::ModelUnavailable)); + assert_eq!(s.runtime.processes().len(), 1, "the bot keeps running"); +} diff --git a/crates/botloftd/tests/common/mod.rs b/crates/botloftd/tests/common/mod.rs index 0fd8ff64..75615f39 100644 --- a/crates/botloftd/tests/common/mod.rs +++ b/crates/botloftd/tests/common/mod.rs @@ -64,6 +64,7 @@ pub fn bot_settings() -> BotSettings { BotSettings { approval_timeout: Duration::from_secs(3), attachment_max_bytes: 1024 * 1024, + max_per_crew: 3, } } diff --git a/crates/botloftd/tests/common/supervised.rs b/crates/botloftd/tests/common/supervised.rs index 749c6d7c..abfc3fcf 100644 --- a/crates/botloftd/tests/common/supervised.rs +++ b/crates/botloftd/tests/common/supervised.rs @@ -26,7 +26,15 @@ pub struct Setup { pub async fn setup() -> Setup { let parts = new_daemon(test_settings()); let (daemon, runtime, clock, dir) = (parts.daemon, parts.runtime, parts.clock, parts.dir); - let crew = crews::create(&daemon, CrewsCreateParams { name: "Ops".into() }).expect("crew"); + let crew = crews::create( + &daemon, + CrewsCreateParams { + name: "Ops".into(), + work_folder: None, + lead: None, + }, + ) + .expect("crew"); let bot = bots::create( &daemon, BotsCreateParams { @@ -35,6 +43,7 @@ pub async fn setup() -> Setup { role: String::new(), instructions: String::new(), color: None, + model: None, }, ) .expect("bot"); diff --git a/crates/botloftd/tests/crew_chief.rs b/crates/botloftd/tests/crew_chief.rs new file mode 100644 index 00000000..b265d954 --- /dev/null +++ b/crates/botloftd/tests/crew_chief.rs @@ -0,0 +1,289 @@ +//! A crew's chief (spec 10.2): created with the crew, the only bot that can +//! suggest new ones, and the owner's say over each suggestion. + +mod common; + +use std::path::Path; + +use botloft_core::protocol::BotState; +use botloftd::runtime::fake::FakeProcess; +use common::bots::ready_bot; +use common::mcp::Mcp; +use common::{Client, TestDaemon}; +use serde_json::{Value, json}; +use tokio::task::JoinHandle; + +struct Chief { + t: TestDaemon, + app: Client, + crew: Value, + chief: Value, + mcp: Mcp, +} + +/// A crew "Site" created with its chief, whose process is ready. +async fn crew_with_chief() -> Chief { + let t = TestDaemon::start_supervised().await; + let mut app = t.session().await; + let crew = app + .call( + "crews.create", + json!({ + "name": "Site", + "lead": { "name": "Chefe", "role": "Leads the crew", "instructions": "Build the bakery's site" }, + }), + ) + .await + .expect("crew"); + let bots = app + .call("bots.list", json!({ "crewId": crew["id"] })) + .await + .expect("bots"); + let chief = bots[0].clone(); + assert_eq!(crew["leadBotId"], chief["id"]); + let (process, mcp) = ready(&t, &chief).await; + drop(process); + Chief { + t, + app, + crew, + chief, + mcp, + } +} + +async fn ready(t: &TestDaemon, bot: &Value) -> (FakeProcess, Mcp) { + let process = t.process_of(bot).await; + t.until_state(bot, BotState::Idle).await; + let mcp = Mcp::new(t.addr, process.env("BOTLOFT_BOT_TOKEN").expect("token")); + (process, mcp) +} + +fn designer() -> Value { + json!({ + "name": "Designer", + "role": "Draws each page", + "instructions": "Design the pages in shared/design and tell me when each is ready.", + "model": "sonnet", + "reason": "The site needs a look before anyone builds it.", + }) +} + +fn suggest(mcp: &Mcp, arguments: Value) -> JoinHandle<Result<Value, String>> { + let mut mcp = Mcp::new(mcp.addr, mcp.token.clone()); + tokio::spawn(async move { mcp.tool("suggest_bot", arguments).await }) +} + +/// Waits for the suggestion to show up in the chief's chat. +async fn pending_suggestion(app: &mut Client) -> Value { + loop { + let changed = app.notification("chat.item").await; + let body = &changed["item"]["body"]; + if body["kind"] == "approval" && body["status"] == "pending" { + assert_eq!(body["toolName"], "mcp__botloft__suggest_bot"); + return body.clone(); + } + } +} + +async fn crew_bots(c: &mut Chief) -> Vec<Value> { + c.app + .call("bots.list", json!({ "crewId": c.crew["id"] })) + .await + .expect("bots") + .as_array() + .expect("list") + .clone() +} + +fn rules(bot: &Value) -> String { + let workspace = bot["workspace"].as_str().expect("workspace"); + std::fs::read_to_string(Path::new(workspace).join(".claude/rules/botloft.md")).expect("rules") +} + +#[tokio::test] +async fn a_new_crew_comes_with_its_chief() { + let mut c = crew_with_chief().await; + assert_eq!(c.chief["name"], "Chefe"); + assert!(rules(&c.chief).contains("## You lead this crew")); + assert!(rules(&c.chief).contains("Build the bakery's site")); + + let roster = c.mcp.tool("crew_roster", json!({})).await.expect("roster"); + assert_eq!(roster["you_lead"], true); + let (_, _, mut writer) = ready_bot(&c.t, &mut c.app, &c.crew, "Writer").await; + let seen = writer.tool("crew_roster", json!({})).await.expect("roster"); + assert_eq!(seen["you_lead"], false); + assert_eq!(seen["bots"][0]["chief"], true); +} + +#[tokio::test] +async fn the_owner_approves_a_suggested_bot() { + let mut c = crew_with_chief().await; + let call = suggest(&c.mcp, designer()); + let asked = pending_suggestion(&mut c.app).await; + assert_eq!(asked["summary"], "Designer"); + c.t.until_state(&c.chief, BotState::NeedsApproval).await; + + c.app + .call( + "approvals.answer", + json!({ "approvalId": asked["approvalId"], "allow": true }), + ) + .await + .expect("answer"); + let created = call.await.expect("task").expect("created"); + assert_eq!(created["created"], true); + assert_eq!(created["handle"], "designer"); + assert!( + created["note"] + .as_str() + .expect("note") + .contains("send_message") + ); + + let bots = crew_bots(&mut c).await; + let new = bots + .iter() + .find(|bot| bot["handle"] == "designer") + .expect("designer"); + assert_eq!(new["model"], "sonnet"); + assert!(!rules(new).contains("You lead this crew")); + c.t.process_of(new).await; +} + +#[tokio::test] +async fn the_owner_can_change_a_suggestion_before_approving_it() { + let mut c = crew_with_chief().await; + let call = suggest(&c.mcp, designer()); + let asked = pending_suggestion(&mut c.app).await; + + let mut changed = designer(); + changed["name"] = json!("Illustrator"); + changed["model"] = json!("haiku"); + c.app + .call( + "approvals.answer", + json!({ "approvalId": asked["approvalId"], "allow": true, "input": changed.to_string() }), + ) + .await + .expect("answer"); + let created = call.await.expect("task").expect("created"); + assert_eq!(created["handle"], "illustrator"); + assert_eq!(created["model"], "haiku"); + assert!(created["note"].as_str().expect("note").contains("changed")); + // The card shows what was created. + let item = loop { + let changed = c.app.notification("chat.item").await; + if changed["item"]["body"]["status"] == "allowed" { + break changed["item"]["body"].clone(); + } + }; + assert!( + item["input"] + .as_str() + .expect("input") + .contains("Illustrator") + ); +} + +#[tokio::test] +async fn a_declined_suggestion_creates_nothing() { + let mut c = crew_with_chief().await; + let call = suggest(&c.mcp, designer()); + let asked = pending_suggestion(&mut c.app).await; + c.app + .call( + "approvals.answer", + json!({ "approvalId": asked["approvalId"], "allow": false, "note": "Use the writer" }), + ) + .await + .expect("answer"); + let declined = call.await.expect("task").expect("answered"); + assert_eq!(declined["created"], false); + assert!( + declined["note"] + .as_str() + .expect("note") + .contains("Use the writer") + ); + assert_eq!(crew_bots(&mut c).await.len(), 1); +} + +#[tokio::test] +async fn a_chief_that_bypasses_permissions_creates_at_once() { + let mut c = crew_with_chief().await; + c.app + .call( + "bots.setPermissionMode", + json!({ "botId": c.chief["id"], "mode": "bypass_permissions" }), + ) + .await + .expect("mode"); + // The chief restarts into the new mode, with a new token. + let old = c.mcp.token.clone(); + let mcp = loop { + let (_, mcp) = ready(&c.t, &c.chief).await; + if mcp.token != old { + break mcp; + } + tokio::time::sleep(std::time::Duration::from_millis(20)).await; + }; + let created = suggest(&mcp, designer()) + .await + .expect("task") + .expect("created"); + assert_eq!(created["created"], true); + assert!( + created["note"] + .as_str() + .expect("note") + .contains("without asking") + ); + assert_eq!(crew_bots(&mut c).await.len(), 2); +} + +#[tokio::test] +async fn only_the_chief_suggests_and_only_while_the_crew_has_room() { + let mut c = crew_with_chief().await; + let (_, _, writer) = ready_bot(&c.t, &mut c.app, &c.crew, "Writer").await; + let refused = suggest(&writer, designer()).await.expect("task"); + assert!( + refused + .expect_err("refused") + .contains("only the crew's chief") + ); + + // The tests allow three bots per crew. + ready_bot(&c.t, &mut c.app, &c.crew, "Reviewer").await; + let full = suggest(&c.mcp, designer()).await.expect("task"); + assert!(full.expect_err("full").contains("already has 3 bots")); + + let mut nameless = designer(); + nameless["reason"] = json!(" "); + let refused = suggest(&c.mcp, nameless).await.expect("task"); + assert!(refused.expect_err("no reason").contains("reason")); +} + +#[tokio::test] +async fn the_owner_moves_the_chief_and_an_archived_chief_leaves_none() { + let mut c = crew_with_chief().await; + let (writer, _, _) = ready_bot(&c.t, &mut c.app, &c.crew, "Writer").await; + let crew = c + .app + .call( + "crews.setLead", + json!({ "crewId": c.crew["id"], "botId": writer["id"] }), + ) + .await + .expect("move"); + assert_eq!(crew["leadBotId"], writer["id"]); + assert!(rules(&writer).contains("## You lead this crew")); + assert!(!rules(&c.chief).contains("## You lead this crew")); + + c.app + .call("bots.archive", json!({ "botId": writer["id"] })) + .await + .expect("archive"); + let crews = c.app.call("crews.list", json!({})).await.expect("crews"); + assert_eq!(crews[0]["leadBotId"], Value::Null); +} diff --git a/crates/botloftd/tests/crew_folders.rs b/crates/botloftd/tests/crew_folders.rs new file mode 100644 index 00000000..61c25e81 --- /dev/null +++ b/crates/botloftd/tests/crew_folders.rs @@ -0,0 +1,157 @@ +//! The folder a crew works in (spec 5): the `shared` folder by default, or +//! one the owner chose, handed to every bot with `--add-dir`. + +mod common; + +use std::path::Path; +use std::sync::Arc; + +use botloft_core::protocol::{ + BotState, BotsCreateParams, Crew, CrewsCreateParams, CrewsSetWorkFolderParams, +}; +use botloftd::service::{ApiError, bots, crews}; +use botloftd::supervisor; +use common::supervised::arg_after; +use common::{Parts, new_daemon, test_settings}; + +fn crew(parts: &Parts, work_folder: Option<&Path>) -> Result<Crew, ApiError> { + crews::create( + &parts.daemon, + CrewsCreateParams { + name: "Site".into(), + work_folder: work_folder.map(|path| path.display().to_string()), + lead: None, + }, + ) +} + +fn bot(parts: &Parts, crew: &Crew) -> botloft_core::protocol::Bot { + bots::create( + &parts.daemon, + BotsCreateParams { + crew_id: crew.id.clone(), + name: "Writer".into(), + role: String::new(), + instructions: String::new(), + color: None, + model: None, + }, + ) + .expect("bot") +} + +fn rules(bot: &botloft_core::protocol::Bot) -> String { + std::fs::read_to_string(Path::new(&bot.workspace).join(".claude/rules/botloft.md")) + .expect("rules") +} + +#[tokio::test(start_paused = true)] +async fn a_crew_works_in_its_shared_folder_by_default() { + let parts = new_daemon(test_settings()); + let crew = crew(&parts, None).expect("crew"); + let shared = parts.paths.shared_dir("site"); + assert!(!crew.work_folder_chosen); + assert_eq!(Path::new(&crew.work_folder), shared); + assert!(shared.is_dir()); + + let writer = bot(&parts, &crew); + tokio::spawn(supervisor::run(Arc::clone(&parts.daemon))); + let process = parts.runtime.process(1).await; + assert_eq!( + arg_after(&process, "--add-dir").map(std::path::PathBuf::from), + Some(shared.clone()) + ); + assert_eq!( + process + .env("CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD") + .as_deref(), + Some("1") + ); + assert!(rules(&writer).contains(&shared.display().to_string())); +} + +#[tokio::test(start_paused = true)] +async fn the_owner_can_choose_where_the_crew_works() { + let parts = new_daemon(test_settings()); + let chosen = parts.dir.path().join("Projects").join("Site"); + let crew = crew(&parts, Some(&chosen)).expect("crew"); + assert!(crew.work_folder_chosen); + assert_eq!(Path::new(&crew.work_folder), chosen); + assert!(chosen.is_dir(), "a missing folder is created"); + + let writer = bot(&parts, &crew); + tokio::spawn(supervisor::run(Arc::clone(&parts.daemon))); + let process = parts.runtime.process(1).await; + assert_eq!( + arg_after(&process, "--add-dir").map(std::path::PathBuf::from), + Some(chosen.clone()) + ); + assert!(rules(&writer).contains(&chosen.display().to_string())); + // The listing keeps the choice. + let listed = crews::list(&parts.daemon).expect("list"); + assert_eq!(listed[0].work_folder, crew.work_folder); +} + +#[tokio::test(start_paused = true)] +async fn moving_the_crew_restarts_its_bots_in_the_new_folder() { + let parts = new_daemon(test_settings()); + let crew = crew(&parts, None).expect("crew"); + let writer = bot(&parts, &crew); + tokio::spawn(supervisor::run(Arc::clone(&parts.daemon))); + let first = parts.runtime.process(1).await; + wait_idle(&parts, &writer.id).await; + + let moved = parts.dir.path().join("Elsewhere"); + let changed = crews::set_work_folder( + &parts.daemon, + CrewsSetWorkFolderParams { + crew_id: crew.id.clone(), + work_folder: Some(moved.display().to_string()), + }, + ) + .expect("move"); + assert_eq!(Path::new(&changed.work_folder), moved); + assert!(rules(&writer).contains(&moved.display().to_string())); + let second = parts.runtime.process(2).await; + assert!(first.killed()); + assert_eq!( + arg_after(&second, "--add-dir").map(std::path::PathBuf::from), + Some(moved) + ); + + wait_idle(&parts, &writer.id).await; + let back = crews::set_work_folder( + &parts.daemon, + CrewsSetWorkFolderParams { + crew_id: crew.id, + work_folder: None, + }, + ) + .expect("back"); + assert!(!back.work_folder_chosen); + assert_eq!(Path::new(&back.work_folder), parts.paths.shared_dir("site")); + parts.runtime.process(3).await; +} + +#[tokio::test(start_paused = true)] +async fn botlofts_own_folders_are_refused() { + let parts = new_daemon(test_settings()); + for folder in [ + parts.paths.home.join("secrets"), + parts.paths.workspaces_root.clone(), + ] { + let refused = crew(&parts, Some(&folder)).expect_err("refused"); + assert!(matches!(refused, ApiError::Validation(_)), "{refused:?}"); + } + assert!(crews::list(&parts.daemon).expect("list").is_empty()); +} + +async fn wait_idle(parts: &Parts, bot: &botloft_core::ids::BotId) { + for _ in 0..600 { + if parts.daemon.supervisor.status(bot).map(|(state, _)| state) == Some(BotState::Idle) { + return; + } + tokio::time::sleep(std::time::Duration::from_millis(10)).await; + } + panic!("the bot never became idle"); +} diff --git a/crates/botloftd/tests/mcp.rs b/crates/botloftd/tests/mcp.rs index f4fa1f9b..79e8327e 100644 --- a/crates/botloftd/tests/mcp.rs +++ b/crates/botloftd/tests/mcp.rs @@ -71,6 +71,7 @@ async fn claude_code_discovers_the_server_and_lists_the_tools() { "send_message", "complete_task", "my_tasks", + "suggest_bot", "permission_prompt" ] ); @@ -115,7 +116,7 @@ async fn earlier_revisions_start_with_initialize() { let listed = mcp::post(t.addr, &legacy, &list).await; assert_eq!( listed.body["result"]["tools"].as_array().map(Vec::len), - Some(5) + Some(6) ); let unknown = json!({ "jsonrpc": "2.0", "id": 2, "method": "prompts/list" }).to_string(); let unknown = mcp::post(t.addr, &legacy, &unknown).await; diff --git a/crates/botloftd/tests/permission_modes.rs b/crates/botloftd/tests/permission_modes.rs new file mode 100644 index 00000000..62b0f52b --- /dev/null +++ b/crates/botloftd/tests/permission_modes.rs @@ -0,0 +1,158 @@ +//! A bot's permission mode (spec 7.4): the flag it starts with, the restart +//! into a new mode once nothing is in progress, and leaving plan mode. + +mod common; + +use std::time::Duration; + +use botloft_core::protocol::{BotState, BotsSetPermissionModeParams, PermissionMode}; +use botloftd::runtime::fake::FakeProcess; +use botloftd::service::modes; +use common::stream; +use common::supervised::{Setup, setup}; +use serde_json::json; + +fn arg_after(process: &FakeProcess, flag: &str) -> Option<String> { + let args = process.args(); + let at = args.iter().position(|arg| arg == flag)?; + args.get(at + 1).cloned() +} + +fn set_mode(s: &Setup, mode: PermissionMode) { + modes::set_permission_mode( + &s.daemon, + BotsSetPermissionModeParams { + bot_id: s.bot.clone(), + mode, + }, + ) + .expect("set mode"); +} + +fn stored_mode(s: &Setup) -> PermissionMode { + s.daemon + .store() + .bot(&s.bot) + .expect("read") + .expect("bot") + .permission_mode +} + +fn init_with_mode(session: &str, mode: &str) -> serde_json::Value { + json!({ "type": "system", "subtype": "init", "session_id": session, "permissionMode": mode }) +} + +#[tokio::test(start_paused = true)] +async fn a_new_bot_asks_before_everything() { + let s = setup().await; + let process = s.runtime.process(1).await; + assert_eq!( + arg_after(&process, "--permission-mode").as_deref(), + Some("default") + ); + assert_eq!(stored_mode(&s), PermissionMode::Default); +} + +#[tokio::test(start_paused = true)] +async fn an_idle_bot_restarts_into_its_new_mode_in_the_same_conversation() { + let s = setup().await; + let first = s.runtime.process(1).await; + s.until(BotState::Idle).await; + let session = arg_after(&first, "--session-id").expect("session"); + + set_mode(&s, PermissionMode::AcceptEdits); + let second = s.runtime.process(2).await; + assert!(first.killed()); + assert_eq!( + arg_after(&second, "--permission-mode").as_deref(), + Some("acceptEdits") + ); + assert_eq!(arg_after(&second, "--resume"), Some(session)); +} + +#[tokio::test(start_paused = true)] +async fn a_busy_bot_finishes_its_turn_before_changing_mode() { + let s = setup().await; + let first = s.runtime.process(1).await; + s.until(BotState::Idle).await; + s.message("work"); + set_mode(&s, PermissionMode::Auto); + tokio::time::sleep(Duration::from_secs(30)).await; + assert_eq!(s.runtime.processes().len(), 1, "the turn is not cut short"); + assert!(s.daemon.supervisor.relaunch_pending(&s.bot)); + + first.emit(stream::result(false)).await; + let second = s.runtime.process(2).await; + assert_eq!( + arg_after(&second, "--permission-mode").as_deref(), + Some("auto") + ); + assert!(!s.daemon.supervisor.relaunch_pending(&s.bot)); +} + +#[tokio::test(start_paused = true)] +async fn approving_a_plan_moves_the_bot_out_of_plan_mode() { + let s = setup().await; + s.runtime.process(1).await; + s.until(BotState::Idle).await; + set_mode(&s, PermissionMode::Plan); + let planning = s.runtime.process(2).await; + s.until(BotState::Idle).await; + let session = arg_after(&planning, "--resume").expect("session"); + + // Claude Code left plan mode when the plan was approved. + planning.emit(init_with_mode(&session, "default")).await; + tokio::time::sleep(Duration::from_millis(50)).await; + assert_eq!(stored_mode(&s), PermissionMode::Default); + assert_eq!( + s.runtime.processes().len(), + 2, + "no restart: it already changed" + ); +} + +#[tokio::test(start_paused = true)] +async fn a_turn_of_the_old_process_does_not_undo_the_owners_choice() { + let s = setup().await; + let first = s.runtime.process(1).await; + s.until(BotState::Idle).await; + let session = arg_after(&first, "--session-id").expect("session"); + s.message("queued"); + set_mode(&s, PermissionMode::AcceptEdits); + + first.emit(init_with_mode(&session, "default")).await; + tokio::time::sleep(Duration::from_millis(50)).await; + assert_eq!(stored_mode(&s), PermissionMode::AcceptEdits); + first.emit(stream::init(&session)).await; + assert_eq!(stored_mode(&s), PermissionMode::AcceptEdits); +} + +#[tokio::test(start_paused = true)] +async fn a_plan_approved_while_a_new_model_waits_still_leaves_plan_mode() { + let s = setup().await; + s.runtime.process(1).await; + s.until(BotState::Idle).await; + set_mode(&s, PermissionMode::Plan); + let planning = s.runtime.process(2).await; + s.until(BotState::Idle).await; + let session = arg_after(&planning, "--resume").expect("session"); + s.message("plan it"); + botloftd::service::models::set_model( + &s.daemon, + botloft_core::protocol::BotsSetModelParams { + bot_id: s.bot.clone(), + model: botloft_core::protocol::BotModel::Sonnet, + }, + ) + .expect("set model"); + + planning.emit(init_with_mode(&session, "default")).await; + tokio::time::sleep(Duration::from_millis(50)).await; + assert_eq!(stored_mode(&s), PermissionMode::Default); + planning.emit(stream::result(false)).await; + let next = s.runtime.process(3).await; + assert_eq!( + arg_after(&next, "--permission-mode").as_deref(), + Some("default") + ); +} diff --git a/crates/botloftd/tests/sign_in.rs b/crates/botloftd/tests/sign_in.rs index 9a74f665..78ecfd7d 100644 --- a/crates/botloftd/tests/sign_in.rs +++ b/crates/botloftd/tests/sign_in.rs @@ -30,6 +30,13 @@ async fn the_status_says_whether_claude_code_is_signed_in() { let status = service::status(&s.daemon).expect("status"); assert_eq!(status.claude_signed_in, Some(true)); assert!(status.claude_path.is_some()); + assert!( + !status.account.name.is_empty(), + "the Windows account's name" + ); + let claude = status.account.claude.expect("the signed-in Claude account"); + assert_eq!(claude.email.as_deref(), Some("owner@example.com")); + assert_eq!(claude.plan.as_deref(), Some("max")); assert_eq!(s.runtime.sign_in_checks(), 1, "checked once, then trusted"); tokio::time::sleep(Duration::from_secs(300)).await; assert_eq!(s.runtime.sign_in_checks(), 1); @@ -43,6 +50,11 @@ async fn signing_in_again_brings_the_stopped_bots_back() { sign_in_error(&s).await; tokio::time::sleep(Duration::from_millis(50)).await; assert_eq!(s.daemon.supervisor.claude_signed_in(), Some(false)); + assert_eq!( + s.daemon.supervisor.claude_account(), + None, + "no account while signed out" + ); // Still signed out: checked every 30 s, the bot stays stopped. tokio::time::sleep(Duration::from_secs(40)).await; diff --git a/crates/botloftd/tests/supervisor.rs b/crates/botloftd/tests/supervisor.rs index 17a1322a..413d75d7 100644 --- a/crates/botloftd/tests/supervisor.rs +++ b/crates/botloftd/tests/supervisor.rs @@ -190,13 +190,22 @@ async fn a_failed_spawn_backs_off_and_retries() { let parts = new_daemon(test_settings()); let (daemon, runtime) = (parts.daemon, parts.runtime); runtime.fail_next_spawn(); - let crew = crews::create(&daemon, CrewsCreateParams { name: "Ops".into() }).expect("crew"); + let crew = crews::create( + &daemon, + CrewsCreateParams { + name: "Ops".into(), + work_folder: None, + lead: None, + }, + ) + .expect("crew"); let params = BotsCreateParams { crew_id: crew.id, name: "Scout".into(), role: String::new(), instructions: String::new(), color: None, + model: None, }; let bot = bots::create(&daemon, params).expect("bot"); tokio::spawn(supervisor::run(Arc::clone(&daemon))); diff --git a/crates/botloftd/tests/tasks.rs b/crates/botloftd/tests/tasks.rs index f2ef2a8e..56dca545 100644 --- a/crates/botloftd/tests/tasks.rs +++ b/crates/botloftd/tests/tasks.rs @@ -185,7 +185,7 @@ async fn mistakes_come_back_as_tool_errors() { assert_eq!(roster["you"], "lead"); assert_eq!( roster["bots"], - json!([{ "handle": "writer", "name": "Writer", "role": "Writer role", "state": "idle" }]) + json!([{ "handle": "writer", "name": "Writer", "role": "Writer role", "state": "idle", "chief": false }]) ); let err = |out: Result<Value, String>| out.expect_err("refused"); diff --git a/docs/spec.md b/docs/spec.md index 7150cf35..2847ac4d 100644 --- a/docs/spec.md +++ b/docs/spec.md @@ -24,8 +24,9 @@ Princípios: | Termo | Significado | |---|---| -| **Crew** | Grupo de bots que podem conversar entre si. Tem pasta compartilhada `shared/`. | +| **Crew** | Grupo de bots que podem conversar entre si. Trabalha numa pasta: a `shared/` dela ou uma que o dono escolhe. | | **Bot** | Uma sessão Claude Code persistente com nome, papel e instruções. | +| **Chefe** | O bot que lidera a crew (`Crew.leadBotId`): nasce com ela, planeja o trabalho, distribui tarefas e é o único que sugere bots novos (10.2). | | **Workspace** | Pasta de trabalho do bot, onde o Claude Code roda. | | **Message** | Texto enviado a um bot, pelo dono, por outro bot ou pelo daemon. Pode trazer anexos (só do dono). | | **Delivery** | Entrega de uma message ao processo do bot. Tem estado, tentativas e prazo. | @@ -101,7 +102,7 @@ Tipos do protocolo ficam em `botloft-core` e são exportados para TypeScript com | Logs | `%LOCALAPPDATA%\Botloft\logs\` (rotação diária, 14 dias) | | | Config | `%LOCALAPPDATA%\Botloft\config.toml` | `--config` | | Workspaces | `%USERPROFILE%\Botloft\<crew>\<bot>\` | `workspaces_root` na config | -| Pasta compartilhada da crew | `%USERPROFILE%\Botloft\<crew>\shared\` | | +| Pasta de trabalho da crew | `%USERPROFILE%\Botloft\<crew>\shared\` | uma pasta que o dono escolhe (`Crew.workFolder`) | | Binário do daemon | `%LOCALAPPDATA%\Botloft\bin\botloftd.exe` (seção 14) | `--home` | | App instalado | `%LOCALAPPDATA%\Botloft\` (`Botloft.exe`, o sidecar `botloftd.exe`, `uninstall.exe`; seção 15.4) | | @@ -111,6 +112,8 @@ O instalador por usuário do Tauri põe o app em `%LOCALAPPDATA%\<produto>`, a m Workspaces ficam num caminho curto e visível para o usuário abrir no Explorer e para reduzir estouro do limite de 260 caracteres (bots rodam `npm install`). +**Pasta de trabalho da crew.** É onde os bots põem o que fazem para o dono e para os outros bots. Por padrão é a `shared\` da crew; o dono pode escolher outra ao criar a crew ou depois (`crews.setWorkFolder`), como uma pasta de projeto que ele já usa. O workspace de cada bot continua onde está, com a memória, as regras e os anexos dele: o daemon nunca grava nada na pasta escolhida. Cada bot recebe a pasta com `--add-dir` (7.4), e o Claude Code a trata como a pasta do bot: lê e, em "Aceitar edições", edita sem perguntar, e carrega o `CLAUDE.md` dela junto com a memória do bot. A pasta escolhida precisa ser um caminho completo e não pode ser um disco inteiro, ficar dentro da pasta de dados do Botloft ou contê-la, nem conter `workspaces_root` (com os workspaces de todos os bots). Se não existe, é criada. Trocar a pasta regrava as regras e reinicia cada bot da crew quando nada estiver em andamento, como a troca de modo (7.4). Arquivar a crew não apaga pasta nenhuma. + Nomes de pasta de crew e bot são slugs gerados na criação e **não mudam** quando o nome de exibição muda. Slug: ASCII minúsculo com hífens, acentos transliterados (`Revisão` -> `revisao`), no máximo 32 caracteres, nunca um nome de dispositivo do Windows (`con`, `lpt1`...) e nunca `shared` para bot. Colisão ganha sufixo (`docs-2`), inclusive com slug de item arquivado ou pasta que já exista no disco. O **handle** do bot (`@revisao`) é derivado do nome pela mesma regra, acompanha renomeações e é único entre os bots ativos da crew; um nome que gere handle já usado é recusado com erro de validação. @@ -123,7 +126,7 @@ O **handle** do bot (`@revisao`) é derivado do nome pela mesma regra, acompanha attachments\<aaaa-mm-dd>\ arquivos que o dono mandou no chat (9.5) .claude\ settings.json regra de negação para os segredos (gerado pelo daemon, sobrescrito a cada start) - rules\botloft.md identidade, papel, crew e guia de uso das tools (gerado pelo daemon) + rules\botloft.md identidade, papel, crew, pasta de trabalho, guia de uso das tools e, no chefe, como liderar (gerado pelo daemon) .botloft\ mcp.json config MCP do bot (gerado pelo daemon) ``` @@ -154,6 +157,7 @@ retry_backoff_max_ms = 120000 [bots] approval_timeout_minutes = 60 # sem resposta do dono, a ferramenta é negada attachment_max_mb = 20 # por arquivo; no máximo 10 arquivos por message +max_per_crew = 12 # até onde as sugestões do chefe levam uma crew (10.2) [tasks] max_hops = 4 @@ -202,7 +206,7 @@ Eventos de uma generation antiga são ignorados. Todo processo novo emite `bot.s - **Sessão:** o daemon guarda em `bots.session_id` o id da conversa. O primeiro start usa `--session-id <uuid novo>`; os seguintes, `--resume <session_id>`. Se a sessão retomada morrer em menos de `fresh_start_if_dies_within_s`, o próximo start vem com um id novo. `bots.restart {fresh: true}` também começa conversa nova. O histórico do chat fica no banco do daemon (seção 8) e não depende do transcript do Claude Code. - Mudanças em nome, papel ou instruções regravam as regras na hora, mas o bot só as lê no próximo start; o daemon não reinicia o bot sozinho. - `auth_error` não entra em loop de restart: fica parado até o owner pedir `bots.restart` ou até o daemon ver o Claude Code conectado de novo. -- **Login do Claude Code:** o daemon roda `claude auth status` (JSON com `loggedIn`; sai com 0 conectado e 1 desconectado, seção 19) no ambiente do usuário, sem janela: quando acha o Claude Code, a cada 30 s enquanto desconectado ou desconhecido, na hora quando um bot cai em `auth_error` e quando o app pede (`system.refresh`). Conectado, não confere de novo sozinho. Quando o resultado passa de desconectado para conectado, os bots em `auth_error` sobem de novo sem o dono pedir. Um erro de conta com o login válido (`billing_error`, `account_on_hold`, organização bloqueada) não muda o resultado e por isso não vira loop. O resultado sai em `system.status.claudeSignedIn`. O login em si é feito pelo app (15.2). +- **Login do Claude Code:** o daemon roda `claude auth status` (JSON com `loggedIn` e, conectado, `email`, `subscriptionType` e `orgName`; sai com 0 conectado e 1 desconectado, seção 19) no ambiente do usuário, sem janela: quando acha o Claude Code, a cada 30 s enquanto desconectado ou desconhecido, na hora quando um bot cai em `auth_error` e quando o app pede (`system.refresh`). Conectado, não confere de novo sozinho. Quando o resultado passa de desconectado para conectado, os bots em `auth_error` sobem de novo sem o dono pedir. Um erro de conta com o login válido (`billing_error`, `account_on_hold`, organização bloqueada) não muda o resultado e por isso não vira loop. O resultado sai em `system.status.claudeSignedIn`, e a conta (e-mail, plano, organização) em `system.status.account.claude`. O login em si é feito pelo app (15.2). - Cada processo de bot entra num **Job Object** com `KILL_ON_JOB_CLOSE`. Se o daemon morrer, a árvore de processos dos bots morre junto e não sobra `claude.exe` órfão. ### 7.4 Spawn @@ -218,7 +222,9 @@ Eventos de uma generation antiga são ignorados. Todo processo novo emite `bot.s (--session-id <uuid> | --resume <session_id>) --setting-sources project,local --mcp-config <workspace>\.botloft\mcp.json --strict-mcp-config - --permission-mode default + --add-dir <pasta de trabalho da crew> + --permission-mode <modo do bot> + [--model <modelo do bot>] --permission-prompt-tool mcp__botloft__permission_prompt --allowedTools mcp__botloft ``` @@ -226,7 +232,12 @@ Eventos de uma generation antiga são ignorados. Todo processo novo emite `bot.s - `--setting-sources project,local` e `--strict-mcp-config` deixam de fora hooks, skills, agents, modo de permissão e servidores MCP pessoais do dono: o bot vê o que o Botloft gera. O login da conta não é uma fonte de settings e continua valendo. - `--allowedTools mcp__botloft` libera as tools da crew sem aprovação. Uma regra `allow` no `settings.json` do projeto não bastaria: em `-p`, numa pasta que nunca passou pelo diálogo de confiança, o Claude Code não aplica as regras `allow` do projeto (documentado em `permissions`). - Qualquer outra ferramenta que peça permissão passa pela tool de aprovação (10.1) e vira um pedido no chat. -5. Ambiente: o bloco padrão do usuário (`CreateEnvironmentBlock`, o mesmo de um logon novo), **não** o ambiente do daemon. Um daemon iniciado de dentro de uma sessão do Claude Code herda `CLAUDECODE`, `CLAUDE_CODE_MESSAGING_SOCKET`, `ANTHROPIC_BASE_URL` e outras variáveis da sessão, que fariam o bot se achar filho dela. Por cima vão `BOTLOFT_BOT_ID`, `BOTLOFT_BOT_TOKEN` e `BOTLOFT_PORT`. + - `--add-dir` põe a pasta de trabalho da crew (5) entre as pastas do bot. Sem ela, gravar na `shared\`, que fica fora do workspace, pedia aprovação até em "Aceitar edições" (19). + - `--permission-mode` vem do modo do bot (`Bot.permissionMode`), que o dono escolhe no chat (15.1): `default` (Manual: pergunta antes de editar, rodar comandos e usar a rede), `accept_edits` (`acceptEdits`: edita arquivos sem perguntar), `plan` (planeja e pede para seguir, 10.1), `auto` (um classificador libera o que é seguro e o resto vira pedido) e `bypass_permissions` (`bypassPermissions`: faz tudo sem perguntar, ver 13). Bot novo começa em `default`. `dontAsk` não é oferecido: nega o que não estiver liberado, e o bot não teria como pedir. Regras `deny` valem em todos os modos. + - O Claude Code só lê a flag ao iniciar e não entra em `bypassPermissions` no meio da sessão. Por isso mudar o modo reinicia o processo com `--resume`, e a conversa continua: na hora se o bot está parado, ou quando o turno em andamento e as aprovações dele terminam, sem cortar o trabalho. + - `--model` vem do modelo do bot (`Bot.model`), que o dono escolhe no chat ou ao criar o bot (15.1): `fable`, `opus`, `sonnet` ou `haiku`, os apelidos do Claude Code, que apontam sempre para a versão mais nova de cada família. `default` deixa a flag de fora, e o Claude Code usa o padrão da conta, que depende do plano (19). Bot novo começa em `default`. O Claude Code não troca de modelo sozinho conforme a tarefa. Mudar o modelo reinicia o processo como a troca de modo, e `--resume` com `--model` passa a usar o modelo novo. O `system/init` de cada turno traz o modelo em uso (`claude-opus-5-5`); o daemon o guarda em `Bot.modelInUse` para o app dizer qual é o padrão do plano. Um modelo que a conta não pode usar falha o turno com o erro `model_not_found` (8.1), e o processo continua vivo. + - O Claude Code sai do modo `plan` sozinho quando o dono aprova o plano. Cada turno começa com um `system/init` que traz `permissionMode` (19); se o processo começou em `plan`, o modo gravado ainda é `plan` e o init diz outro, o daemon grava o novo, sem reiniciar, para o app mostrar o que o bot faz e um reinício manter. Qualquer outra diferença vem de um processo que está para reiniciar no modo que o dono acabou de escolher, e é ignorada. +5. Ambiente: o bloco padrão do usuário (`CreateEnvironmentBlock`, o mesmo de um logon novo), **não** o ambiente do daemon. Um daemon iniciado de dentro de uma sessão do Claude Code herda `CLAUDECODE`, `CLAUDE_CODE_MESSAGING_SOCKET`, `ANTHROPIC_BASE_URL` e outras variáveis da sessão, que fariam o bot se achar filho dela. Por cima vão `BOTLOFT_BOT_ID`, `BOTLOFT_BOT_TOKEN`, `BOTLOFT_PORT` e `CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD=1`, que faz o Claude Code carregar o `CLAUDE.md` da pasta de trabalho (5). 6. stdin, stdout e stderr em pipes, sem console (`CREATE_NO_WINDOW`). O stdin fica aberto enquanto o processo vive; fechá-lo encerra o Claude Code com código 0. O stderr vai para o log em nível `debug`, sem conteúdo de mensagem. ### 7.5 `settings.json` gerado @@ -253,13 +264,13 @@ Uma linha JSON por evento, em UTF-8. Linha que não é JSON, ou maior que 8 MiB, | Evento | O que vira | |---|---| -| `system/init` | guarda `session_id` em `bots.session_id` (vem no começo de cada turno) | +| `system/init` | guarda `session_id` em `bots.session_id` (vem no começo de cada turno); segue `permissionMode` e guarda `model` (7.4) | | `user` com `isReplay: true` | a message com aquele `uuid` começou a ser processada: a delivery ganha `read_at` (9.1) | | `stream_event` com `text_delta` | texto ao vivo da resposta (`chat.delta`, 8.3); não é gravado | | `assistant`, bloco `text` | item `reply` com o texto (markdown) | | `assistant`, bloco `tool_use` | item `tool` em `running`, com resumo da entrada | | `user`, bloco `tool_result` | atualiza o item `tool` do mesmo `tool_use_id`: `done` ou `failed` e um trecho da saída | -| `assistant` com `error` | item `notice` e, conforme o erro, estado `rate_limited` ou `auth_error` (7.2) | +| `assistant` com `error` | item `notice` e, conforme o erro, estado `rate_limited` ou `auth_error` (7.2); `model_not_found` vira o aviso `model_unavailable` | | `rate_limit_event` | uso da conta (janelas de 5 h e 7 dias) em `system.status.usage`; status diferente de `allowed` leva a `rate_limited` | | `result` | item `turn` com duração, custo e erro (se houve); fecha um turno pendente | @@ -276,7 +287,7 @@ Todo item tem `id` (`cht_`), `botId`, `kind`, `createdAt` e `updatedAt`. | `tool` | `toolUseId`, `name`, `summary`, `input`, `status` (`running`, `done`, `failed`), `output` | ferramenta usada pelo bot | | `approval` | `approvalId`, `toolName`, `summary`, `input`, `status` (`pending`, `allowed`, `denied`, `expired`), `note` | pedido de permissão (10.1) | | `turn` | `durationMs`, `costUsd`, `error` | fim de um turno | -| `notice` | `level` (`info`, `warning`, `error`), `code` (`signed_out`, `usage_limit`, `turn_failed`; ausente em avisos antigos), `text` | avisos do daemon: limite de uso, login, turno com erro. O app escreve os avisos com `code` no idioma do dono; `text` fica em inglês para quem não conhece o código e, em `turn_failed`, traz o detalhe do erro | +| `notice` | `level` (`info`, `warning`, `error`), `code` (`signed_out`, `usage_limit`, `turn_failed`, `model_unavailable`; ausente em avisos antigos), `text` | avisos do daemon: limite de uso, login, turno com erro. O app escreve os avisos com `code` no idioma do dono; `text` fica em inglês para quem não conhece o código e, em `turn_failed`, traz o detalhe do erro | - `summary` é uma frase curta feita pelo daemon a partir da entrada: o comando do `Bash`, o arquivo do `Read`/`Edit`/`Write`, o padrão do `Grep`/`Glob`, a URL do `WebFetch`, a busca do `WebSearch`, o destinatário do `send_message`. Ferramenta desconhecida mostra só o nome. - `input` guarda o JSON da entrada até 4 KB; `output`, até 8 KB de texto. O resto fica só no transcript do próprio Claude Code. @@ -382,10 +393,11 @@ Transporte: Streamable HTTP, só POST e resposta `application/json`, sem sessão | Tool | Entrada | Saída (JSON em texto) | |---|---|---| -| `crew_roster` | nenhuma | `crew`, `you` e os outros bots da crew: handle, nome, papel, estado | +| `crew_roster` | nenhuma | `crew`, `you`, `you_lead` e os outros bots da crew: handle, nome, papel, estado e `chief` | | `send_message` | `to` (handle, com ou sem `@`), `body`, `kind?` (`note` padrão, `task`), `deadline_minutes?` (só task) | `message_id`, `task_id` e `due` (task), e um lembrete de que a resposta chega depois | | `complete_task` | `task_id`, `result`, `status?` (`done` padrão, `failed`) | `task_id`, `status` e quem recebe o resultado | | `my_tasks` | `role?` (`assigned`, `requested`) | tasks `open` e `expired`: id, de, para, status, prazo relativo, hops e o pedido original | +| `suggest_bot` | `name`, `role`, `instructions` (até 8 000 caracteres), `model?`, `reason` (até 1 000) | `created` e, criado, `handle`, `name`, `role`, `model` e um lembrete para mandar a primeira task; recusado ou sem resposta, o porquê (10.2). Só o chefe | | `permission_prompt` | `tool_name`, `input`, `tool_use_id` | decisão do dono (10.1). Chamada pelo Claude Code, não pelo modelo | - Erro que o modelo pode corrigir (handle desconhecido, argumento inválido, limite de hops, task de outro bot) volta como resultado com `isError: true` e uma frase explicando. Só tool desconhecida ou chamada malformada vira erro JSON-RPC (`-32602`). @@ -408,8 +420,21 @@ Com `--permission-prompt-tool mcp__botloft__permission_prompt`, toda ferramenta "Permitir sempre" (gravar uma regra para o bot) fica para depois do MVP. +**Plano.** No modo `plan`, o bot pede para seguir com a ferramenta `ExitPlanMode`, cuja entrada traz o plano em markdown (`{plan}`). O pedido passa pela mesma tool e vira no chat um cartão com o plano inteiro: a entrada dessa ferramenta é guardada até 32 KB (as outras, até 4 KB) e o resumo é a primeira linha do plano. "Aprovar plano" permite; "Pedir mudanças" nega com a nota do dono, e o bot continua planejando. Depois de aprovado, o Claude Code troca de modo sozinho (7.4). Que o pedido passa pela tool em `-p` e para qual modo o bot vai ainda precisam de teste real (19). + A aprovação só abre se `tool_use_id` for de uma ferramenta em `running` no chat daquele bot. O daemon espera até 2 s pelo evento, que às vezes chega depois da chamada. Senão nega na hora, sem incomodar o dono. Assim um bot que chame `permission_prompt` por conta própria não consegue pôr um pedido inventado na frente do dono. A descrição da tool também diz para não chamá-la. +### 10.2 Chefe e sugestões de bots + +Toda crew nova nasce com um **chefe**: `crews.create` com `lead` cria a crew e esse bot juntos, e `Crew.leadBotId` aponta para ele. O app escreve nome e papel no idioma do dono ("Chefe", "Lidera a equipe: planeja o trabalho, sugere bots novos e distribui as tarefas"); as instruções são o objetivo que o dono escreveu para a crew. O chefe é gravado antes de o supervisor poder subi-lo, então o primeiro start já lê que lidera. O dono troca o chefe (`crews.setLead`) ou deixa a crew sem nenhum; o chefe antigo e o novo têm as regras regravadas e reiniciam quando nada estiver em andamento (7.4). Arquivar o chefe deixa a crew sem chefe. Crews de antes não têm chefe até o dono escolher um. + +- **Regras do chefe:** além das de todo bot, uma seção "You lead this crew": planejar, dividir o trabalho em partes que rodam em paralelo e distribuí-las com `send_message` (`kind: "task"`); conferir os resultados antes de responder ao dono; quando faltar um especialista, sugerir um bot com `suggest_bot`; escolher o modelo pelo trabalho (`haiku` para o simples e repetitivo, `sonnet` para quase tudo, `opus` ou `fable` só para o raciocínio mais difícil, lembrando que gastam mais do plano); manter a crew pequena; e contar ao dono o que cada bot faz, para ele acompanhar e falar com cada um no chat dele. Os outros bots leem que, se a crew precisar de outro bot, devem pedir ao chefe, que o `crew_roster` marca com `chief`. +- **`suggest_bot`:** aparece para todos os bots, mas só o chefe pode usar; os outros recebem um erro que manda pedir ao chefe. Antes de incomodar o dono, o daemon confere os campos (os de um bot, mais o limite de instruções e o porquê), que o nome está livre na crew e que a crew tem menos de `max_per_crew` bots ativos. Um pedido impossível volta como erro ao chefe. +- **Aprovação:** a sugestão vira um pedido no chat do chefe, pelo mesmo caminho das aprovações (10.1): `approval` com `toolName: "mcp__botloft__suggest_bot"`, entrada até 64 KB e resumo com o nome sugerido. O chefe fica `needs_approval`, e a chamada MCP espera a resposta até `approval_timeout_minutes`. A tool vem liberada por `--allowedTools mcp__botloft`, então o Claude Code não pede permissão antes: quem decide é o dono, pelo cartão. +- **Resposta:** permitir cria o bot na crew do chefe, com modo Manual e o modelo sugerido. O dono pode mudar nome, papel, modelo e instruções antes: `approvals.answer` leva `input`, o JSON da sugestão como ele deixou, que substitui a entrada gravada (o cartão mostra o que foi criado); `input` só vale para sugestões. Negar volta ao chefe com a nota do dono, e nada é criado. Sem resposta no prazo, o chefe lê que pode sugerir de novo depois. O bot novo sobe na hora e aparece na barra lateral, com o próprio chat; o resultado da tool lembra o chefe de mandar a primeira task. +- **Chefe em `bypass_permissions`:** a sugestão cria o bot na hora, sem cartão, como tudo o que esse modo faz sem perguntar (13). O resultado diz ao chefe que foi criado sem pedir. +- Bots criados assim são bots comuns: o dono conversa, muda, pausa e arquiva cada um como qualquer outro. + ## 11. Protocolo do app (JSON-RPC 2.0 sobre WebSocket) Endpoint: `ws://127.0.0.1:45710/rpc`. Mensagens seguem JSON-RPC 2.0: requests com `id`, respostas com `result` ou `error`, notificações do servidor sem `id`. O maior frame aceito do app é de 32 MiB, por causa dos anexos. @@ -426,21 +451,25 @@ Endpoint: `ws://127.0.0.1:45710/rpc`. Mensagens seguem JSON-RPC 2.0: requests co | Método | Params | Result | |---|---|---| -| `system.status` | | versão, uptime, versão e caminho do claude (`claudeVersion`, `claudePath`), `runtimeError` (por que os bots não sobem), `claudeSignedIn` (7.3; `null` antes de conferir), backlog de entrega, `usage` (uso da conta, 8.1) | +| `system.status` | | versão, uptime, versão e caminho do claude (`claudeVersion`, `claudePath`), `runtimeError` (por que os bots não sobem), `claudeSignedIn` (7.3; `null` antes de conferir), `account` (o dono para a área da conta do app: `name`, o nome de exibição da conta do Windows, `GetUserNameExW(NameDisplay)`, ou o nome de usuário sem ele, lido uma vez; e `claude`, a conta do Claude com `email`, `plan` e `organization`, ou `null` desconectado), backlog de entrega, `usage` (uso da conta, 8.1) | | `system.refresh` | | pede uma nova conferência do Claude Code (login e, se falhou, o executável) e responde na hora com o `system.status` atual; o app relê o status até ver o resultado | | `crews.list` | | `Crew[]` | -| `crews.create` | `name` | `Crew` | +| `crews.create` | `name, workFolder?, lead?` (`{name, role, instructions, model?}`: o chefe, 10.2) | `Crew` | | `crews.rename` | `crewId, name` | `Crew` | | `crews.setPaused` | `crewId, paused` | `Crew` | +| `crews.setLead` | `crewId, botId` (ou `null`, sem chefe) | `Crew`; o chefe antigo e o novo reiniciam quando nada estiver em andamento (10.2) | +| `crews.setWorkFolder` | `crewId, workFolder` (caminho, ou `null` para voltar à `shared\`) | `Crew`; os bots reiniciam na pasta nova quando nada estiver em andamento (5) | | `crews.archive` | `crewId` | `Crew` | | `bots.list` | `crewId?` | `Bot[]` | -| `bots.create` | `crewId, name, role, instructions, color?` | `Bot` | +| `bots.create` | `crewId, name, role, instructions, color?, model?` | `Bot` | | `bots.update` | `botId, name?, role?, instructions?, color?` | `Bot` | | `bots.setPaused` | `botId, paused` | `Bot` | +| `bots.setPermissionMode` | `botId, mode` (`default`, `accept_edits`, `plan`, `auto`, `bypass_permissions`) | `Bot`; o bot reinicia no novo modo quando nada estiver em andamento (7.4) | +| `bots.setModel` | `botId, model` (`default`, `fable`, `opus`, `sonnet`, `haiku`) | `Bot`; o bot reinicia no novo modelo quando nada estiver em andamento (7.4) | | `bots.restart` | `botId, fresh?` | `Bot` | | `bots.archive` | `botId` | `Bot` | | `chat.history` | `botId, before?, limit?` | `ChatItem[]`, mais novo primeiro; `limit` de 1 a 200, 50 se ausente | -| `approvals.answer` | `approvalId, allow, note?` | `Approval` | +| `approvals.answer` | `approvalId, allow, note?, input?` (`input`: a sugestão de bot como o dono a deixou, 10.2) | `Approval` | | `messages.send` | `botId, body, attachments?` (`[{name, mediaType, data}]`, data em base64) | `Message` | | `messages.list` | `crewId?, botId?, before?, limit?` | `Message[]` | | `attachments.read` | `attachmentId` | `{mediaType, data}`, data em base64 (9.5) | @@ -448,7 +477,7 @@ Endpoint: `ws://127.0.0.1:45710/rpc`. Mensagens seguem JSON-RPC 2.0: requests co | `deliveries.retry` | `deliveryId` | `Delivery` | | `tasks.list` | `crewId?, status?` | `Task[]` | -`Bot` traz também `lastActivity`: o último item do chat resumido em uma linha, para a lista de conversas: `kind` (`owner`, `message`, `reply`, `tool`, `approval`, `notice`), `text` e `at`. O `text` não tem palavras do daemon: a mensagem do dono vem sem "You:" e a aprovação só com o nome da ferramenta, e o app completa no idioma do dono. +`Crew` traz `workFolder`, o caminho da pasta de trabalho (a escolhida ou a `shared\`), `workFolderChosen` e `leadBotId`, o chefe (10.2). `Bot` traz também `permissionMode`, `model` e `modelInUse` (7.4) e `lastActivity`: o último item do chat resumido em uma linha, para a lista de conversas: `kind` (`owner`, `message`, `reply`, `tool`, `approval`, `notice`), `text` e `at`. O `text` não tem palavras do daemon: a mensagem do dono vem sem "You:" e a aprovação só com o nome da ferramenta, e o app completa no idioma do dono. ### 11.3 Notificações do servidor @@ -472,8 +501,8 @@ Pragmas: `journal_mode=WAL`, `foreign_keys=ON`, `busy_timeout=5000`. Migrations | Tabela | Colunas principais | |---|---| -| `crews` | `id, name, slug, paused, created_at, archived_at` | -| `bots` | `id, crew_id, name, handle, slug, role, instructions, color, paused, token_hash, session_id, created_at, archived_at` | +| `crews` | `id, name, slug, paused, work_dir, lead_bot_id, created_at, archived_at` (`work_dir` é a pasta escolhida; `NULL` usa a `shared`. `lead_bot_id` é o chefe, sem chave estrangeira: ele é gravado junto com a crew) | +| `bots` | `id, crew_id, name, handle, slug, role, instructions, color, paused, permission_mode, model, model_in_use, token_hash, session_id, created_at, archived_at` | | `messages` | `id, crew_id, from_kind (owner/bot/system), from_bot_id, to_bot_id, kind (note/task/result/system), body, task_id, created_at` | | `attachments` | `id, message_id, name, media_type, size, path, created_at` | | `deliveries` | `id, message_id, bot_id, state, attempts, next_attempt_at, lease_until, last_error, sent_generation, turn_uuid, read_at, updated_at` | @@ -493,6 +522,8 @@ Pragmas: `journal_mode=WAL`, `foreign_keys=ON`, `busy_timeout=5000`. Migrations - `log_level` vale só para os crates do Botloft; dependências ficam em `warn`, porque em `debug`/`trace` a pilha de WebSocket registra frames, que podem conter mensagens. `RUST_LOG` sobrepõe tudo e é só para depuração local. - Nome de anexo vira só o nome do arquivo (sem `..`, sem pasta, sem caracteres proibidos no Windows) antes de ir para o disco. - Isolamento entre bots é cooperativo (mesmo usuário do Windows). Documentar isso no README sem prometer sandbox. +- Pasta de trabalho escolhida (5): todos os bots da crew a editam como a própria pasta. Por isso ela não pode tocar a pasta de dados do Botloft (segredos, banco) nem conter os workspaces de todos os bots, e não pode ser um disco inteiro. +- Modo `bypass_permissions` (7.4): o bot faz tudo sem perguntar. As regras `deny` de leitura só cobrem as ferramentas de arquivo do Claude Code, alguns comandos do Bash (`cat`, `head`, `tail`, `sed`, `tee`) e redirecionamentos, não um script em Python ou Node, e o Windows nativo não tem sandbox. Um bot nesse modo pode ler `secrets\owner.token`, o banco e as pastas de outros bots, e uma mensagem de outra pessoa pode levá-lo a isso. O app só liga o modo depois de uma confirmação que diz isso, e o bot fica marcado em vermelho (15.1). Um chefe nesse modo também cria bots sem perguntar (10.2), e a confirmação diz isso quando o bot é o chefe. ## 14. Integração com o Windows @@ -550,9 +581,15 @@ O store recarrega crews, bots e `system.status` a cada (re)conexão e depois seg Layout, como um app de mensagens: -- **Barra lateral:** crews como seções, com os bots como conversas. Cada conversa mostra avatar, nome, estado (cor, ícone e texto) e a prévia da última atividade (`lastActivity`) com a hora. -- **Área principal com um bot:** cabeçalho com nome, estado e ações; o chat; o compositor embaixo. O compositor aceita texto, colar imagem e arrastar ou escolher arquivos. Enter envia e Shift+Enter quebra linha. -- **Área principal com uma crew:** a timeline (messages entre os bots e do dono) e as tasks. +- **Barra lateral:** crews como seções, com os bots como conversas. Cada conversa mostra avatar, nome, estado (cor, ícone e texto) e a prévia da última atividade (`lastActivity`) com a hora. Ela aparece desde a conexão, também na tela de boas-vindas antes da primeira crew. +- **Área da conta**, no pé da barra lateral, como nos apps de chat: um círculo com a inicial, o nome do dono (do Windows) e o plano do Claude ("Plano Max"; sem plano, a organização ou o e-mail; desconectado, "Sem conta do Claude conectada"). Um clique abre um menu para cima com o e-mail e: **Uso** (as janelas de uso do plano, 8.1, com a parte usada e quando renovam; antes da primeira resposta de um bot, um aviso de que ainda não há dados), **Configurações** (tema, tamanho, idioma e as versões do Botloft e do Claude Code), **Idioma** (submenu ao lado, com a escolha na hora), **Novidades** (a página de releases no navegador) e **Ajuda** (o README no navegador). Tema, tamanho e idioma saíram da barra de título; ela só mostra o idioma nas telas de preparo, que ainda não têm barra lateral. +- **Área principal com um bot:** cabeçalho com nome, estado e ações; o chat; o compositor embaixo. O compositor aceita texto, colar imagem e arrastar ou escolher arquivos. Enter envia e Shift+Enter quebra linha (a dica aparece enquanto o dono escreve). +- **Modo do bot**, no compositor, ao lado do clipe, como no Claude Code: um botão com o modo atual abre um menu para cima, "Modo", com Automático, Manual, Aceitar edições e Plano, cada um com uma linha que fala do bot pelo nome ("Scout decide o que precisa do seu OK") e a marca no atual. Separado, "Ignorar permissões" com o botão Ativar, que abre uma confirmação dizendo que o bot não fica preso à pasta dele (13). Nesse modo o botão fica vermelho e o cabeçalho mostra "Não pergunta nada" em vermelho. Com o bot ocupado, uma linha acima do compositor avisa que ele muda de modo quando terminar o que está fazendo. +- **Modelo do bot**, no compositor, ao lado do botão de enviar: mostra o modelo em uso ("Opus 5.5"; antes do primeiro turno, o nome escolhido ou "Padrão") e abre um menu para cima, "Modelo", com Padrão do plano, Fable, Opus, Sonnet e Haiku. Cada um tem uma linha que fala do bot pelo nome ("Scout fica rápido e capaz, bom para quase tudo"; o padrão diz qual modelo é hoje), e o pé do menu lembra que modelos mais capazes gastam o limite do plano mais rápido. A janela de criar e editar bot tem a mesma escolha. Com o bot ocupado, a mesma linha acima do compositor avisa que ele troca quando terminar. +- **Área principal com uma crew:** a timeline (messages entre os bots e do dono) e as tasks. Embaixo do nome, "Trabalha em <pasta>", que abre a pasta no Explorer; o menu da crew tem "Abrir pasta de trabalho" e "Mudar pasta de trabalho…", que abre o seletor de pastas do Windows e confirma antes de mudar, avisando que cada bot reinicia quando terminar o que está fazendo. +- **Nova crew:** nome; "Para que é esta equipe?", o objetivo que vira as instruções do chefe, com a explicação de que a equipe começa com um Chefe que planeja o trabalho e sugere os bots de que precisa; "Pasta de trabalho", com "Escolher pasta…" (o seletor do Windows; sem escolha, "Uma pasta nova dentro do Botloft", a `shared\`); e "Modelo do Chefe". Criada, o app abre o chat do chefe. +- **Chefe:** uma coroa ao lado do nome na barra lateral e nos cartões da crew, e "Chefe" no cabeçalho do bot, com a dica "Lidera <crew>: planeja o trabalho e sugere bots novos". O menu do bot tem "Tornar chefe da equipe" ou "Deixar de ser chefe". +- **Sugestão de bot** (10.2): um cartão no chat do chefe, "<chefe> sugere um bot novo", com o porquê e os campos editáveis Nome, Modelo, Função e Instruções, a linha de que o bot começa na hora e recebe o trabalho do chefe, um campo para dizer ao chefe por que não, e os botões Criar bot e Agora não. Respondido, vira uma linha ("Você criou Designer", "Você recusou Designer") que abre o que foi sugerido. - **Detalhes do bot** (pasta, instruções, sessão) ficam num painel, fora do caminho da conversa. ### 15.2 Comandos Tauri @@ -565,6 +602,7 @@ Layout, como um app de mensagens: | `claude_sign_in` | abre `claude auth login` numa janela de console própria (`CREATE_NEW_CONSOLE`) com o `claudePath` do `system.status` e espera; responde se saiu com 0. Só roda um caminho absoluto de arquivo existente chamado `claude.exe`. Tira do ambiente `CLAUDECODE` e `CLAUDE_CODE_*`, que um app aberto de dentro de uma sessão do Claude Code herdaria. Quem abre é o app, e não o daemon, porque a janela aberta pelo app em primeiro plano vem para a frente. Na janela o dono vê o que acontece e pode colar um código se o navegador pedir | | `read_owner_token` | lê `secrets\owner.token` (só no app local) | | `open_path` | abre uma pasta no Explorer; recusa arquivos, que o Explorer executaria | +| seletor de pastas | não é comando próprio: o app usa o `tauri-plugin-dialog` (`open({directory: true})`, permissão `dialog:allow-open`) para a pasta de trabalho da crew (5) | | `open_url` | abre no navegador padrão um link de uma resposta do bot; só `http` e `https`, porque qualquer outro esquema pode iniciar um programa. Seguir o link dentro do app trocaria a janela pela página | | overlay na taskbar | não é comando próprio: o app usa `setOverlayIcon` da janela (permissão `core:window:allow-set-overlay-icon`) e marca o ícone com um ponto enquanto algo espera o dono: aprovação pendente, bot em `auth_error`, ou mensagem não entregue a um bot ativo. Entregas mortas para bot arquivado não contam: foram abandonadas de propósito | @@ -586,17 +624,29 @@ Em dev, `pnpm tauri dev` usa o `target\debug\botloftd.exe` como sidecar e instal ### 15.3 Direção visual -Ferramenta de trabalho densa e calma: tipografia forte, grid firme, estados dos bots legíveis de longe (cor + ícone + texto, nunca só cor). Sem gradiente, sem sombra pesada, sem visual de template. Tema escuro e claro. Barra de título própria (`decorations: false`) com controles de janela do Windows. +Ferramenta de trabalho densa e calma: tipografia forte, grid firme, estados dos bots legíveis de longe (cor + ícone + texto, nunca só cor). Sem gradiente, sem sombra pesada, sem visual de template. Cantos arredondados, como nos apps de chat: botões, campos e linhas de menu com 8 px; cartões, avisos e menus com 12 px; compositor, diálogos e cartões do chat com 16 px. Menus e diálogos flutuam com uma sombra leve (`shadow-lift`, mais forte no tema escuro). Na barra lateral, a conversa aberta é um bloco arredondado recuado das bordas. Tema escuro e claro. Barra de título própria (`decorations: false`) com controles de janela do Windows. + +Tamanho: a janela inteira é desenhada numa escala (zoom do webview, `setZoom`), então texto, espaçamento, ícones e avatares crescem juntos. Níveis 100%, 110%, 125% e 150%; o padrão é **125%**, porque o desenho a 100% ficava miúdo num monitor sem ampliação do Windows. Quem já usa a ampliação alta volta para 100% em Configurações (área da conta) ou com Ctrl+-; Ctrl+= aumenta e Ctrl+0 volta ao padrão. A escolha fica no `localStorage` (`botloft.zoom`) e é aplicada antes da primeira pintura, para a janela não piscar pequena. Acima de 150% a janela mínima (900 px) não cabe o layout. + +Movimento: o app se mexe para parecer vivo, sem atrapalhar o trabalho. Animações curtas (150 a 400 ms, saída suave) em CSS, sem biblioteca (`motion.css`), e todas param quando o Windows desliga os efeitos de animação (`prefers-reduced-motion`). + +- **Mascote:** cada bot tem um humor que segue o estado. Ele pisca de vez em quando (cada bot num ritmo, para uma equipe não piscar junta), tremula como chama enquanto trabalha (`busy`, `launching`), dá pulinhos enquanto espera o dono (`needs_approval`), fica de olhos cansados no limite de uso e dorme, de olhos fechados, pausado ou parado. Mexem-se os mascotes da barra lateral, do cabeçalho, dos cartões da crew e da resposta em andamento; o histórico do chat fica parado. O humor soma ao estado, que continua com cor, ícone e texto. +- **Chegadas:** o que chega enquanto o dono olha entra subindo e aparecendo: mensagens, ferramentas, pedidos, avisos e bots novos na barra lateral. O que já estava lá quando ele abriu o chat (ou o app) aparece parado, e páginas antigas carregadas em cima não se mexem. A resposta já aparece enquanto é escrita, então não anima de novo ao terminar. +- **Trabalhando:** os três pontos pulam em sequência; o texto sendo escrito tem um cursor piscando no fim; a mão de "Precisa de aprovação" acena; um pedido pendente pulsa uma vez ao aparecer. +- **Trocar de bot ou de crew:** o painel principal some rápido e o novo sobe (View Transitions do webview); a barra lateral fica onde está. +- **Superfícies:** menus e seletores abrem a partir de onde estão presos; diálogos aparecem com o fundo escurecendo; avisos entram deslizando; `<details>` abre deslizando; a linha da aba selecionada desliza até a nova; as barras de uso enchem ao abrir; botões afundam um pouco ao clicar; o mascote da tela de boas-vindas e do chat vazio flutua. No chat: +- O chat é uma coluna centralizada (48rem), com o compositor na mesma largura; o dia é uma pílula no meio. - O dono fala em balões à direita; o bot, à esquerda, com markdown. - Mensagens de outros bots aparecem à esquerda, com o avatar e o nome de quem mandou. - O que o bot faz com as ferramentas aparece em linhas compactas (ícone, ferramenta, resumo e estado), agrupadas por turno, que abrem para mostrar entrada e saída. - Pedido de aprovação é um cartão com o que o bot quer fazer e os botões Permitir e Negar. +- Pedido para seguir com um plano (10.1) é um cartão com o plano em markdown, um campo para o que deve mudar e os botões Aprovar plano e Pedir mudanças. Respondido, vira uma linha que abre o plano de novo. - Anexos aparecem como miniatura (imagem) ou cartão com nome, tipo e tamanho. -Identidade: o mascote do Botloft é uma chama com olhos, desenhada em vetor em `app/app-icon.svg`. O ícone do app é o mascote branco sobre fundo preto. Cada bot usa o mesmo personagem como avatar, com uma cor própria escolhida na criação. A cor do avatar identifica o bot e não comunica estado: estado continua sendo cor + ícone + texto, como descrito acima. +Identidade: o mascote do Botloft é uma chama com olhos, desenhada em vetor em `app/app-icon.svg`. O ícone do app é o mascote branco sobre fundo preto. Cada bot usa o mesmo personagem como avatar, com uma cor própria escolhida na criação, sem fundo e com um contorno fino e discreto (escuro no tema claro, claro no escuro) para as cores claras não sumirem. O mascote branco do próprio Botloft (barra de título, mensagens do daemon) fica sobre o quadrado preto do ícone do app, que é o que o torna visível no tema claro. A cor do avatar identifica o bot e não comunica estado: estado continua sendo cor + ícone + texto, como descrito acima. O mascote se mexe conforme o que o bot faz (ver Movimento), sem substituir isso. ### 15.4 Instalador e sidecar @@ -617,7 +667,7 @@ Identidade: o mascote do Botloft é uma chama com olhos, desenhada em vetor em ` - O app fala **inglês, português (Brasil) e espanhol**. Todo texto que o dono lê fica em `app/src/i18n/<idioma>/`, um arquivo por área (`common`, `shell`, `onboarding`, `updates`, `bots`, `chat`, `crews`, `messages`). O inglês é a referência: o formato dele é o tipo `Messages`, e um texto que falte ou sobre em outro idioma não compila. Texto com valores é função (`ready(version)`), com o plural escrito para cada idioma. - Componentes leem com `useT()`; código fora do React (toasts, formatação, erros da conexão) com `t()` na hora do uso. -- Escolha no botão de idioma da barra de título (também nas telas de preparo): "Idioma do sistema" segue o Windows (o primeiro idioma suportado entre os preferidos; `pt-PT` vira `pt-BR`; nenhum, inglês) ou um idioma fixo. A escolha fica no `localStorage` do app (`botloft.locale`) e marca `<html lang>`. +- Escolha na área da conta (Idioma, ou Configurações), e no botão de idioma da barra de título só nas telas de preparo: "Idioma do sistema" segue o Windows (o primeiro idioma suportado entre os preferidos; `pt-PT` vira `pt-BR`; nenhum, inglês) ou um idioma fixo. A escolha fica no `localStorage` do app (`botloft.locale`) e marca `<html lang>`. - Datas e horas (`lib/format.ts`) usam o idioma escolhido. - O daemon não escreve texto para o dono: avisos vêm com `code` e a linha da conversa com `kind` (8.2, 11.2), e o app escreve. Continuam como vêm: nomes, mensagens, respostas e saídas de ferramenta; o resumo de ferramenta que o daemon faz a partir da entrada (o comando, o arquivo); e as mensagens de erro do daemon (validação, falhas), mostradas como texto técnico. - O instalador NSIS também traz os três idiomas e escolhe pelo idioma do Windows. @@ -673,6 +723,12 @@ Conferência na documentação oficial (code.claude.com/docs) em 2026-09-28. "Co | `--setting-sources project,local` | 7.4 | Confirmado (`cli-reference`). **Testado com 2.1.284**: sem os hooks, skills e agents do usuário; modo `default`; login da assinatura continua valendo | feito (M4.1) | | `claude auth status` | 7.3 | Confirmado (`cli-reference`): JSON por padrão, sai com 0 conectado e 1 desconectado. **Testado com 2.1.284**: conectado traz `"loggedIn": true`; com `CLAUDE_CONFIG_DIR` vazio, `"loggedIn": false`, `"authMethod": "none"` e saída 1. As credenciais ficam em `%USERPROFILE%\.claude\.credentials.json` (`authentication`) | feito | | `claude auth login` | 15.2 | Confirmado (`cli-reference`, `authentication`): abre o navegador e volta por um servidor local; se o navegador não alcançar esse servidor, mostra um código para colar no terminal. Se o subcomando sai sozinho depois do login ainda não foi visto: o app só depende do código de saída | manual (PR) | +| `permissionMode` no `system/init` | 7.4 | **Visto com 2.1.284**: o `system/init` de cada turno traz `permissionMode` com o valor da CLI (`default`, `acceptEdits`, `plan`, `auto`, `bypassPermissions`) | feito | +| Modos de permissão em `-p` | 7.4 | Confirmado (`permission-modes`): `deny` vale em todos os modos, inclusive `bypassPermissions`, que não pode ser ligado no meio da sessão; em `-p`, `auto` manda para a tool de aprovação o que o classificador não libera e `plan` continua bloqueando edições. O `auto` depende do plano e do modelo; o que `--permission-mode auto` faz sem ele ainda não foi visto | manual (PR) | +| `ExitPlanMode` em `-p` | 10.1 | A lista de ferramentas diz que ele pede permissão. Não visto: se o pedido chega à tool de aprovação com `{plan}` na entrada, e para qual modo o bot vai depois de aprovado (o daemon segue o `system/init` do turno seguinte) | manual (PR) | +| Modelo em `-p` | 7.4 | Confirmado (`model-config`, `sessions`): apelidos `fable`, `opus`, `sonnet`, `haiku` (e `best`, `opusplan`, `[1m]`, não usados); sem `model` nas settings, vale o padrão da conta; `--resume` mantém o modelo da sessão, a menos que `--model` escolha outro. **Visto com 2.1.284** (plano Max): sem `--model`, o `system/init` traz `"model": "claude-opus-5-5"`; um modelo inexistente sobe o processo, o init o repete, e cada turno termina com `assistant.error: "model_not_found"` e `result.is_error`; `/model haiku` mandado como mensagem troca o modelo no meio da sessão, com uma resposta sintética e sem custo, mas o daemon reinicia o processo em vez disso, como na troca de modo. Qual é o padrão em cada plano, e quais modelos cada plano tem, não está documentado | feito | +| `--add-dir` em `-p` | 5, 7.4 | Confirmado (`cli-reference`, `memory`): pastas a mais que o Claude Code trata como de trabalho; o `CLAUDE.md` delas só carrega com `CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD=1`. **Testado com 2.1.284** (`--setting-sources project,local`, `acceptEdits`): com a flag e a variável, o bot citou o `CLAUDE.md` da pasta sem abrir arquivo e gravou nela sem pedir; sem a flag, o `Write` na mesma pasta foi negado (`permission_denials`). A flag aceita vários valores: a linha de comando do daemon não tem prompt posicional, então nada é engolido | feito | +| Chefe e `suggest_bot` com o Claude Code real | 10.2 | **Testado com 2.1.284** (daemon e app de dev): a crew criada pelo app subiu o chefe com `--model sonnet` e `--add-dir` na pasta da crew. Pedido um site, o chefe carregou `crew_roster`, `suggest_bot` e `send_message` pelo `ToolSearch` e sugeriu um Designer com papel, instruções, modelo e porquê; a chamada esperou o cartão. Com o modelo trocado para `haiku` no cartão, o bot subiu com `--model haiku`, e o chefe citou a troca. O chefe mandou uma task, o Designer entregou com `complete_task`, e o chefe conferiu o resultado e corrigiu o HTML. O log de `debug` não teve texto de mensagem | feito | | Regras `allow` do projeto em `-p` sem confiança | 7.4 | Confirmado (`permissions`): não são aplicadas numa pasta nunca confiada; `deny` vale sempre. Por isso `--allowedTools mcp__botloft` | M4.1 | | `--session-id`, `--resume` em `-p` | 7.3 | Confirmado (`cli-reference`, `sessions`): a sessão retoma histórico e modelo; flags como `--mcp-config` têm de ser passadas de novo. **Testado com 2.1.284**: depois de reiniciar o bot e depois de reiniciar o daemon, o bot lembrou arquivos, a imagem e a mensagem de outro bot | feito (M4.1) | | Tools MCP adiadas | 10 | **Visto com 2.1.284**: as tools do `botloft` chegam adiadas; antes da primeira `send_message` o bot chama `ToolSearch` com `select:mcp__botloft__send_message`. O chat mostra isso como "load send_message" | feito (M4.1) |
{message.body} diff --git a/app/src/features/chat/Markdown.tsx b/app/src/features/chat/Markdown.tsx index 0f659c72..f1cdaaca 100644 --- a/app/src/features/chat/Markdown.tsx +++ b/app/src/features/chat/Markdown.tsx @@ -60,9 +60,16 @@ const components: Components = { img: ({ src, alt }) => , }; -export const Markdown = memo(function Markdown({ text }: { text: string }) { +/** `streaming` shows a caret after the text, while the bot still writes it. */ +export const Markdown = memo(function Markdown({ + text, + streaming = false, +}: { + text: string; + streaming?: boolean; +}) { return ( -
{m.title}
{m.bypassBody(bot.name)}
{m.bypassRisk}
{m.bypassChief(bot.name)}
{m.bypassAdvice}
+ {m.cost} +
@@ -36,6 +39,8 @@ function noticeText(notice: NoticeItem, words: Messages["chat"]["notice"]): stri return words.usageLimit; case "turn_failed": return words.turnFailed(notice.text); + case "model_unavailable": + return words.modelUnavailable; default: return notice.text; } diff --git a/app/src/features/chat/PickerOption.tsx b/app/src/features/chat/PickerOption.tsx new file mode 100644 index 00000000..6c6a843e --- /dev/null +++ b/app/src/features/chat/PickerOption.tsx @@ -0,0 +1,47 @@ +// One choice in a picker below the chat (mode, model): a name, a line +// about what it means for the bot, and a check on the current one. + +import { Check, type LucideIcon } from "lucide-react"; +import type { ReactNode } from "react"; +import { POPOVER_ITEM } from "../../ui/surface"; + +export function PickerOption({ + icon: Icon, + name, + hint, + checked, + danger = false, + trailing, + onSelect, +}: { + icon?: LucideIcon; + name: string; + hint: string; + checked: boolean; + danger?: boolean; + trailing?: ReactNode; + onSelect(): void; +}) { + return ( + + {Icon && ( + + )} + + {name} + {hint} + + {checked ? : trailing} + + ); +} diff --git a/app/src/features/chat/PlanCard.tsx b/app/src/features/chat/PlanCard.tsx new file mode 100644 index 00000000..44157ecd --- /dev/null +++ b/app/src/features/chat/PlanCard.tsx @@ -0,0 +1,110 @@ +// A bot in plan mode asking to go ahead (spec 10.1): Claude Code asks for +// it as the ExitPlanMode tool, with the plan. Approving lets the bot work; +// sending it back keeps it planning, with what should change. + +import { Check, ChevronRight, ListTodo, PencilLine, TimerOff } from "lucide-react"; +import { useId } from "react"; +import { useT } from "../../i18n"; +import type { ApprovalItem, Bot } from "../../lib/protocol.gen"; +import { Button } from "../../ui/Button"; +import { Markdown } from "./Markdown"; +import { useAnswer } from "./useAnswer"; + +export const PLAN_TOOL = "ExitPlanMode"; + +/** The plan in the request's input; the input itself if it is not JSON. */ +export function planText(input: string): string { + try { + const parsed: unknown = JSON.parse(input); + if (typeof parsed === "object" && parsed !== null && "plan" in parsed) { + const { plan } = parsed; + if (typeof plan === "string") { + return plan; + } + } + } catch { + // Cut short or not JSON: show it as it came. + } + return input; +} + +export function PlanCard({ approval, bot }: { approval: ApprovalItem; bot: Bot }) { + const p = useT().chat.plan; + const { note, setNote, busy, answer } = useAnswer(approval, { + allow: p.approveFailed, + deny: p.keepFailed, + }); + const noteId = useId(); + const plan = planText(approval.input); + if (approval.status !== "pending") { + return ; + } + + return ( + + + + + + {p.ready(bot.name)} + + + + + + + {p.noteLabel(bot.name)} + + setNote(event.target.value)} + placeholder={p.notePlaceholder} + className="block w-full resize-none rounded-xl border border-line-strong bg-panel px-3 py-2 text-sm outline-none placeholder:text-muted focus:border-muted" + /> + <div className="mt-2.5 flex flex-wrap gap-2"> + <Button variant="primary" icon={Check} disabled={busy} onClick={() => answer(true)}> + {p.approve} + </Button> + <Button icon={PencilLine} disabled={busy} onClick={() => answer(false)}> + {p.keepPlanning} + </Button> + </div> + </div> + </section> + ); +} + +/** One line once answered; the plan stays a click away. */ +function Answered({ approval, plan }: { approval: ApprovalItem; plan: string }) { + const p = useT().chat.plan; + const [Icon, text, tone] = + approval.status === "allowed" + ? [Check, p.approved, "text-ok"] + : approval.status === "denied" + ? [PencilLine, p.sentBack, "text-work"] + : [TimerOff, p.expired, "text-quiet"]; + return ( + <details className="group"> + <summary className="flex min-w-0 cursor-default items-center gap-2 rounded-lg px-1.5 py-1 text-sm hover:bg-sunken"> + <Icon aria-hidden size={14} className={`shrink-0 ${tone}`} /> + <span className="shrink-0 font-medium">{text}</span> + {approval.note && ( + <span className="truncate text-muted text-xs">{`“${approval.note}”`}</span> + )} + <ChevronRight + aria-hidden + size={13} + className="shrink-0 text-muted transition-transform group-open:rotate-90" + /> + </summary> + <div className="mt-1.5 ml-6 rounded-xl border border-line bg-panel px-4 py-3" data-selectable> + <Markdown text={plan} /> + </div> + </details> + ); +} diff --git a/app/src/features/chat/SuggestionCard.tsx b/app/src/features/chat/SuggestionCard.tsx new file mode 100644 index 00000000..1d87109b --- /dev/null +++ b/app/src/features/chat/SuggestionCard.tsx @@ -0,0 +1,171 @@ +// The crew's chief suggesting a new bot (spec 10.2). The owner can change +// the name, role, model and instructions before creating it, or say no +// with a note for the chief. Once answered it shrinks to one line. + +import { Ban, Check, ChevronRight, TimerOff, UserPlus } from "lucide-react"; +import { useId, useState } from "react"; +import { useT } from "../../i18n"; +import type { ApprovalItem, Bot, BotModel } from "../../lib/protocol.gen"; +import { Button } from "../../ui/Button"; +import { SelectField, TextArea, TextField } from "../../ui/Field"; +import { useAnswer } from "./useAnswer"; + +export const SUGGEST_TOOL = "mcp__botloft__suggest_bot"; + +const MODELS: BotModel[] = ["default", "fable", "opus", "sonnet", "haiku"]; + +interface Suggestion { + name: string; + role: string; + instructions: string; + model?: BotModel; + reason: string; +} + +/** The suggestion in the request's input; empty fields if it is cut short. */ +export function suggestionOf(input: string): Suggestion { + try { + const parsed = JSON.parse(input) as Partial<Suggestion>; + return { + name: parsed.name ?? "", + role: parsed.role ?? "", + instructions: parsed.instructions ?? "", + ...(parsed.model && { model: parsed.model }), + reason: parsed.reason ?? "", + }; + } catch { + return { name: "", role: "", instructions: input, reason: "" }; + } +} + +export function SuggestionCard({ approval, bot }: { approval: ApprovalItem; bot: Bot }) { + const t = useT(); + const s = t.chat.suggestion; + const asked = suggestionOf(approval.input); + const [edited, setEdited] = useState<Suggestion>(asked); + const { note, setNote, busy, answer } = useAnswer(approval, { + allow: s.createFailed, + deny: s.declineFailed, + }); + const noteId = useId(); + if (approval.status !== "pending") { + return <Answered approval={approval} />; + } + const changed = JSON.stringify(edited) !== JSON.stringify(asked); + const set = (field: keyof Suggestion) => (value: string) => + setEdited((current) => ({ ...current, [field]: value })); + + return ( + <section + aria-label={s.title(bot.name)} + className="my-1 overflow-hidden rounded-2xl border border-line bg-panel shadow-sm animate-attention" + > + <p className="flex items-center gap-2.5 border-line border-b px-4 py-3 font-semibold text-sm"> + <span className="grid h-7 w-7 place-items-center rounded-full bg-accent/12 text-accent"> + <UserPlus aria-hidden size={15} /> + </span> + {s.title(bot.name)} + </p> + <div className="flex flex-col gap-3 px-4 py-3"> + {asked.reason && ( + <p className="text-ink-soft text-sm" data-selectable> + <span className="font-medium text-ink">{s.why}: </span> + {asked.reason} + </p> + )} + <div className="grid grid-cols-[1fr_12rem] gap-3"> + <TextField + label={s.name} + value={edited.name} + onChange={(event) => set("name")(event.target.value)} + /> + <SelectField + label={s.model} + value={edited.model ?? "default"} + onChange={(event) => set("model")(event.target.value)} + options={MODELS.map((value) => ({ value, label: t.chat.model.names[value] }))} + /> + </div> + <TextField + label={s.role} + value={edited.role} + onChange={(event) => set("role")(event.target.value)} + /> + <TextArea + label={s.instructions} + value={edited.instructions} + rows={5} + onChange={(event) => set("instructions")(event.target.value)} + /> + <p className="text-muted text-xs">{s.startsNow(bot.name)}</p> + </div> + <div className="border-line border-t bg-canvas/40 px-4 py-3"> + <label htmlFor={noteId} className="sr-only"> + {s.noteLabel(bot.name)} + </label> + <textarea + id={noteId} + rows={2} + value={note} + onChange={(event) => setNote(event.target.value)} + placeholder={s.notePlaceholder(bot.name)} + className="block w-full resize-none rounded-xl border border-line-strong bg-panel px-3 py-2 text-sm outline-none placeholder:text-muted focus:border-muted" + /> + <div className="mt-2.5 flex flex-wrap gap-2"> + <Button + variant="primary" + icon={Check} + disabled={busy || !edited.name.trim()} + onClick={() => answer(true, changed ? JSON.stringify(edited) : undefined)} + > + {s.create} + </Button> + <Button icon={Ban} disabled={busy} onClick={() => answer(false)}> + {s.decline} + </Button> + </div> + </div> + </section> + ); +} + +/** One line once answered; what was suggested stays a click away. */ +function Answered({ approval }: { approval: ApprovalItem }) { + const t = useT(); + const s = t.chat.suggestion; + const suggestion = suggestionOf(approval.input); + const name = suggestion.name || s.name; + const [Icon, text, tone] = + approval.status === "allowed" + ? [Check, s.created(name), "text-ok"] + : approval.status === "denied" + ? [Ban, s.declined(name), "text-danger"] + : [TimerOff, s.expired(name), "text-quiet"]; + return ( + <details className="group"> + <summary className="flex min-w-0 cursor-default items-center gap-2 rounded-lg px-1.5 py-1 text-sm hover:bg-sunken"> + <Icon aria-hidden size={14} className={`shrink-0 ${tone}`} /> + <span className="shrink-0 font-medium">{text}</span> + {approval.note && ( + <span className="truncate text-muted text-xs">{`“${approval.note}”`}</span> + )} + <ChevronRight + aria-hidden + size={13} + className="shrink-0 text-muted transition-transform group-open:rotate-90" + /> + </summary> + <dl + className="mt-1.5 ml-6 grid grid-cols-[auto_1fr] gap-x-3 gap-y-1 rounded-xl border border-line bg-panel px-4 py-3 text-sm" + data-selectable + > + <dt className="text-muted">{s.role}</dt> + <dd>{suggestion.role}</dd> + <dt className="text-muted">{s.model}</dt> + <dd>{t.chat.model.names[suggestion.model ?? "default"]}</dd> + <dt className="text-muted">{s.instructions}</dt> + <dd className="whitespace-pre-wrap">{suggestion.instructions}</dd> + </dl> + </details> + ); +} diff --git a/app/src/features/chat/ToolLines.tsx b/app/src/features/chat/ToolLines.tsx index 1cbecb96..dcc8a53a 100644 --- a/app/src/features/chat/ToolLines.tsx +++ b/app/src/features/chat/ToolLines.tsx @@ -9,10 +9,12 @@ import { FileText, Globe, ListChecks, + ListTodo, LoaderCircle, type LucideIcon, Send, SquareTerminal, + UserPlus, Users, Wrench, X, @@ -20,6 +22,7 @@ import { import { useState } from "react"; import { useT } from "../../i18n"; import type { ChatItem, ToolItem } from "../../lib/protocol.gen"; +import { useArrival } from "../../ui/motion"; const ICONS: Record<string, LucideIcon> = { Bash: SquareTerminal, @@ -34,9 +37,11 @@ const ICONS: Record<string, LucideIcon> = { WebFetch: Globe, WebSearch: Globe, TodoWrite: ListChecks, + ExitPlanMode: ListTodo, Task: Users, Agent: Users, send_message: Send, + suggest_bot: UserPlus, }; /** `mcp__botloft__send_message` reads as `send_message`. */ @@ -71,20 +76,21 @@ function Status({ status }: { status: ToolItem["status"] }) { } } -function ToolLine({ tool }: { tool: ToolItem }) { +function ToolLine({ tool, createdAt }: { tool: ToolItem; createdAt: number }) { const t = useT(); const [open, setOpen] = useState(false); + const arrival = useArrival(createdAt); const label = toolLabel(tool.name); const Icon = ICONS[label] ?? Wrench; const block = - "max-h-64 overflow-auto whitespace-pre-wrap break-all rounded-[3px] border border-line bg-sunken px-2.5 py-1.5 font-mono text-xs leading-relaxed"; + "max-h-64 overflow-auto whitespace-pre-wrap break-all rounded-lg border border-line bg-sunken px-2.5 py-1.5 font-mono text-xs leading-relaxed"; return ( - <li> + <li className={arrival}> <button type="button" aria-expanded={open} onClick={() => setOpen(!open)} - className="group flex w-full min-w-0 items-center gap-2 rounded-[3px] px-1.5 py-1 text-left text-sm hover:bg-sunken" + className="group flex w-full min-w-0 items-center gap-2 rounded-lg px-1.5 py-1 text-left text-sm transition-colors hover:bg-sunken" > <Icon aria-hidden size={14} className="shrink-0 text-muted" /> <span className="shrink-0 font-medium">{label}</span> @@ -99,7 +105,7 @@ function ToolLine({ tool }: { tool: ToolItem }) { /> </button> {open && ( - <div className="mt-1 mb-2 ml-7 flex flex-col gap-1.5" data-selectable> + <div className="mt-1 mb-2 ml-7 flex animate-rise flex-col gap-1.5" data-selectable> <p className="text-muted text-xs">{t.chat.tools.input}</p> <pre className={block}>{pretty(tool.input)}</pre> {tool.output !== null && ( @@ -121,7 +127,9 @@ export function ToolLines({ items }: { items: ChatItem[] }) { return ( <ul aria-label={t.chat.tools.label} className="-mx-1.5 flex flex-col"> {items.map((item) => - item.body.kind === "tool" ? <ToolLine key={item.id} tool={item.body} /> : null, + item.body.kind === "tool" ? ( + <ToolLine key={item.id} tool={item.body} createdAt={item.createdAt} /> + ) : null, )} </ul> ); diff --git a/app/src/features/chat/models.test.tsx b/app/src/features/chat/models.test.tsx new file mode 100644 index 00000000..50bf6038 --- /dev/null +++ b/app/src/features/chat/models.test.tsx @@ -0,0 +1,94 @@ +import { act, cleanup, fireEvent, screen, within } from "@testing-library/react"; +import { afterEach, describe, expect, test } from "vitest"; +import { FakeBotloft } from "../../lib/fake"; +import { crewOpened, openBot, renderApp } from "../../test/app"; + +afterEach(cleanup); + +/** A crew "Ops" with @scout, open on its chat. */ +async function openScout(setup?: (fake: FakeBotloft, botId: string) => void) { + const fake = new FakeBotloft(); + const ops = fake.addCrew("Ops"); + const scout = fake.addBot(ops.id, "Scout", "Finds sources"); + fake.setBotState(scout.id, "idle"); + setup?.(fake, scout.id); + renderApp(fake); + await crewOpened("Ops"); + openBot("Scout"); + await screen.findByRole("list", { name: "Messages" }); + return { fake, scout }; +} + +const picker = () => screen.getByRole("button", { name: /^Model: / }); +const modelCalls = (fake: FakeBotloft) => + fake.calls.filter((call) => call.method === "bots.setModel"); + +function choose(name: RegExp) { + fireEvent.click(picker()); + const menu = screen.getByRole("menu", { name: "Model" }); + fireEvent.click(within(menu).getByRole("menuitemradio", { name })); +} + +describe("models", () => { + test("a bot runs on the plan's default until the owner picks a model", async () => { + const { fake, scout } = await openScout(); + expect(picker().getAttribute("aria-label")).toBe("Model: Default"); + fireEvent.click(picker()); + const menu = screen.getByRole("menu", { name: "Model" }); + const plan = within(menu).getByRole("menuitemradio", { name: /Plan default/ }); + expect(plan.getAttribute("aria-checked")).toBe("true"); + expect(within(menu).getByText(/use up your plan's limit faster/)).toBeDefined(); + fireEvent.click(within(menu).getByRole("menuitemradio", { name: /Haiku/ })); + + await screen.findByRole("button", { name: "Model: Haiku" }); + expect(modelCalls(fake).at(-1)?.params).toEqual({ botId: scout.id, model: "haiku" }); + expect(screen.queryByText(/switches to/)).toBeNull(); + }); + + test("the plan's default is named once Claude Code reported it", async () => { + await openScout((fake, botId) => { + fake.bot(botId).modelInUse = "claude-opus-5-5"; + }); + expect(picker().getAttribute("aria-label")).toBe("Model: Opus 5.5"); + fireEvent.click(picker()); + expect(screen.getByText("Scout uses your plan's default model, now Opus 5.5")).toBeDefined(); + }); + + test("a busy bot changes model when it finishes what it is doing", async () => { + const { fake, scout } = await openScout(); + act(() => fake.setBotState(scout.id, "busy")); + choose(/Sonnet/); + expect( + await screen.findByText("Scout switches to Sonnet when it finishes what it's doing."), + ).toBeDefined(); + }); + + test("a model the plan does not have is told in the owner's words", async () => { + const { fake, scout } = await openScout(); + act(() => { + fake.chat.add(scout.id, { + kind: "notice", + level: "error", + code: "model_unavailable", + text: "Claude Code could not use this bot's model.", + }); + }); + expect(await screen.findByText(/may not be on your Claude plan/)).toBeDefined(); + }); + + test("a new bot can start on a chosen model", async () => { + const fake = new FakeBotloft(); + fake.addCrew("Ops"); + renderApp(fake); + await crewOpened("Ops"); + const [headerButton] = await screen.findAllByRole("button", { name: "New bot" }); + fireEvent.click(headerButton as HTMLElement); + const dialog = screen.getByRole("dialog", { name: "New bot" }); + fireEvent.change(within(dialog).getByLabelText("Name"), { target: { value: "Writer" } }); + fireEvent.change(within(dialog).getByLabelText("Model"), { target: { value: "sonnet" } }); + fireEvent.click(within(dialog).getByRole("button", { name: "Create bot" })); + await screen.findByRole("button", { name: "Model: Sonnet" }); + const create = fake.calls.find((call) => call.method === "bots.create"); + expect(create?.params).toMatchObject({ name: "Writer", model: "sonnet" }); + }); +}); diff --git a/app/src/features/chat/modes.test.tsx b/app/src/features/chat/modes.test.tsx new file mode 100644 index 00000000..9cfff293 --- /dev/null +++ b/app/src/features/chat/modes.test.tsx @@ -0,0 +1,113 @@ +import { act, cleanup, fireEvent, screen, within } from "@testing-library/react"; +import { afterEach, describe, expect, test } from "vitest"; +import { FakeBotloft } from "../../lib/fake"; +import { crewOpened, openBot, renderApp } from "../../test/app"; + +afterEach(cleanup); + +/** A crew "Ops" with @scout, open on its chat. */ +async function openScout() { + const fake = new FakeBotloft(); + const ops = fake.addCrew("Ops"); + const scout = fake.addBot(ops.id, "Scout", "Finds sources"); + fake.setBotState(scout.id, "idle"); + renderApp(fake); + await crewOpened("Ops"); + openBot("Scout"); + await screen.findByRole("list", { name: "Messages" }); + return { fake, scout }; +} + +const picker = () => screen.getByRole("button", { name: /^Mode: / }); +const modeCalls = (fake: FakeBotloft) => + fake.calls.filter((call) => call.method === "bots.setPermissionMode"); + +function choose(name: RegExp) { + fireEvent.click(picker()); + const menu = screen.getByRole("menu", { name: "Mode" }); + fireEvent.click(within(menu).getByRole("menuitemradio", { name: name })); +} + +describe("permission modes", () => { + test("a bot starts in Manual and the owner picks another mode", async () => { + const { fake, scout } = await openScout(); + expect(picker().getAttribute("aria-label")).toBe("Mode: Manual"); + fireEvent.click(picker()); + const menu = screen.getByRole("menu", { name: "Mode" }); + const manual = within(menu).getByRole("menuitemradio", { name: /Manual/ }); + expect(manual.getAttribute("aria-checked")).toBe("true"); + fireEvent.click(within(menu).getByRole("menuitemradio", { name: /Accept edits/ })); + + await screen.findByRole("button", { name: "Mode: Accept edits" }); + expect(screen.queryByRole("menu", { name: "Mode" })).toBeNull(); + expect(modeCalls(fake).at(-1)?.params).toEqual({ botId: scout.id, mode: "accept_edits" }); + // Nothing was running: no note about waiting. + expect(screen.queryByText(/switches to/)).toBeNull(); + }); + + test("bypassing permissions asks first, then marks the bot in red", async () => { + const { fake } = await openScout(); + choose(/Bypass permissions/); + const dialog = screen.getByRole("dialog", { name: "Let Scout do anything without asking?" }); + expect(within(dialog).getByText(/other bots' files/)).toBeDefined(); + fireEvent.click(within(dialog).getByRole("button", { name: "Cancel" })); + expect(modeCalls(fake)).toHaveLength(0); + expect(screen.queryByText("Asks nothing")).toBeNull(); + + choose(/Bypass permissions/); + fireEvent.click(screen.getByRole("button", { name: "Turn on" })); + await screen.findByRole("button", { name: "Mode: Bypass permissions" }); + expect(screen.getByText("Asks nothing")).toBeDefined(); + expect(modeCalls(fake).at(-1)?.params).toMatchObject({ mode: "bypass_permissions" }); + }); + + test("a busy bot changes mode when it finishes what it is doing", async () => { + const { fake, scout } = await openScout(); + act(() => fake.setBotState(scout.id, "busy")); + choose(/Plan/); + expect( + await screen.findByText("Scout switches to Plan when it finishes what it's doing."), + ).toBeDefined(); + act(() => fake.setBotState(scout.id, "idle")); + expect(screen.queryByText(/switches to Plan/)).toBeNull(); + }); +}); + +describe("plans", () => { + const PLAN = "## Cache the report\n\n1. Save it once a week"; + + function askToGoAhead(fake: FakeBotloft, botId: string) { + act(() => { + fake.chat.ask(botId, "ExitPlanMode", "Cache the report", JSON.stringify({ plan: PLAN })); + }); + return screen.getByRole("region", { name: "Scout made a plan and wants to go ahead" }); + } + + test("the plan shows in full and approving it lets the bot go ahead", async () => { + const { fake, scout } = await openScout(); + await act(() => fake.call("bots.setPermissionMode", { botId: scout.id, mode: "plan" })); + const card = askToGoAhead(fake, scout.id); + expect(within(card).getByRole("heading", { name: "Cache the report" })).toBeDefined(); + expect(within(card).getByText("Save it once a week")).toBeDefined(); + + fireEvent.click(within(card).getByRole("button", { name: "Approve plan" })); + expect(await screen.findByText("You approved the plan")).toBeDefined(); + const answer = fake.calls.find((call) => call.method === "approvals.answer"); + expect(answer?.params).toMatchObject({ allow: true }); + // As Claude Code does, the bot left plan mode. + expect(await screen.findByRole("button", { name: "Mode: Manual" })).toBeDefined(); + }); + + test("keeping on planning sends back what should change", async () => { + const { fake, scout } = await openScout(); + const card = askToGoAhead(fake, scout.id); + fireEvent.change(within(card).getByLabelText("What Scout should change in the plan"), { + target: { value: "Keep the cache in memory" }, + }); + fireEvent.click(within(card).getByRole("button", { name: "Keep planning" })); + expect(await screen.findByText("You asked for changes to the plan")).toBeDefined(); + expect(screen.getByText("“Keep the cache in memory”")).toBeDefined(); + const answer = fake.calls.find((call) => call.method === "approvals.answer"); + expect(answer?.params).toMatchObject({ allow: false, note: "Keep the cache in memory" }); + }); +}); diff --git a/app/src/features/chat/useAnswer.ts b/app/src/features/chat/useAnswer.ts new file mode 100644 index 00000000..1f249343 --- /dev/null +++ b/app/src/features/chat/useAnswer.ts @@ -0,0 +1,28 @@ +import { useState } from "react"; +import type { ApprovalItem } from "../../lib/protocol.gen"; +import { useApi } from "../../store/context"; +import { attempt } from "../../ui/toast"; + +/** + * Answering a request; the note goes to the bot on a denial. `input` is a + * bot suggestion as the owner changed it (spec 10.2). + */ +export function useAnswer(approval: ApprovalItem, failed: { allow: string; deny: string }) { + const api = useApi(); + const [note, setNote] = useState(""); + const [busy, setBusy] = useState(false); + const answer = async (allow: boolean, input?: string) => { + setBusy(true); + const trimmed = note.trim(); + await attempt(allow ? failed.allow : failed.deny, () => + api.call("approvals.answer", { + approvalId: approval.approvalId, + allow, + ...(allow || !trimmed ? {} : { note: trimmed }), + ...(allow && input !== undefined ? { input } : {}), + }), + ); + setBusy(false); + }; + return { note, setNote, busy, answer }; +} diff --git a/app/src/features/crews/CrewBots.tsx b/app/src/features/crews/CrewBots.tsx index 22fdfbf1..fb35bd5e 100644 --- a/app/src/features/crews/CrewBots.tsx +++ b/app/src/features/crews/CrewBots.tsx @@ -3,8 +3,9 @@ import { useT } from "../../i18n"; import type { Bot, Crew } from "../../lib/protocol.gen"; import { useApp } from "../../store/context"; import { Button } from "../../ui/Button"; -import { BotAvatar } from "../bots/BotAvatar"; +import { BotAvatar, moodOf } from "../bots/BotAvatar"; import { BotStateBadge } from "../bots/BotStateBadge"; +import { ChiefBadge, isChief } from "../bots/ChiefBadge"; /** The crew's bots as cards; a card opens the bot. */ export function CrewBots({ crew, bots, onNewBot }: { crew: Crew; bots: Bot[]; onNewBot(): void }) { @@ -12,7 +13,7 @@ export function CrewBots({ crew, bots, onNewBot }: { crew: Crew; bots: Bot[]; on const selectBot = useApp((state) => state.selectBot); if (bots.length === 0) { return ( - <div className="border border-line border-dashed px-6 py-10 text-center"> + <div className="rounded-2xl border border-line border-dashed px-6 py-10 text-center"> <p className="font-medium">{t.crews.bots.empty(crew.name)}</p> <p className="mt-1 text-muted text-sm">{t.crews.bots.emptyHint}</p> <Button className="mt-4" variant="primary" icon={Plus} onClick={onNewBot}> @@ -28,12 +29,15 @@ export function CrewBots({ crew, bots, onNewBot }: { crew: Crew; bots: Bot[]; on <button type="button" onClick={() => selectBot(bot.id)} - className="flex h-full w-full flex-col gap-2 border border-line bg-panel p-3 text-left hover:border-line-strong" + className="flex h-full w-full flex-col gap-2 rounded-xl border border-line bg-panel p-3.5 text-left transition-[border-color,transform,box-shadow] duration-200 hover:-translate-y-0.5 hover:border-line-strong hover:shadow-sm" > <div className="flex w-full items-center gap-2.5"> - <BotAvatar color={bot.color} size={32} /> + <BotAvatar color={bot.color} size={32} mood={moodOf(bot, crew.paused)} /> <div className="min-w-0 flex-1"> - <p className="truncate font-semibold">{bot.name}</p> + <p className="flex items-center gap-1.5"> + <span className="truncate font-semibold">{bot.name}</span> + {isChief(bot, crew) && <ChiefBadge crew={crew} compact />} + </p> <p className="truncate font-mono text-muted text-xs">@{bot.handle}</p> </div> </div> diff --git a/app/src/features/crews/CrewDialog.tsx b/app/src/features/crews/CrewDialog.tsx index c73a5f92..1703010a 100644 --- a/app/src/features/crews/CrewDialog.tsx +++ b/app/src/features/crews/CrewDialog.tsx @@ -1,19 +1,27 @@ import { type FormEvent, useState } from "react"; import { useT } from "../../i18n"; import { errorText } from "../../lib/api"; -import { type Crew, FIELD_LIMITS } from "../../lib/protocol.gen"; +import { type BotModel, type Crew, FIELD_LIMITS } from "../../lib/protocol.gen"; import { useApi, useApp } from "../../store/context"; import { Button } from "../../ui/Button"; import { Dialog } from "../../ui/Dialog"; -import { TextField } from "../../ui/Field"; +import { SelectField, TextArea, TextField } from "../../ui/Field"; +import { WorkFolderField } from "./WorkFolderField"; -/** Creates a crew, or renames `crew`. */ +const MODELS: BotModel[] = ["default", "fable", "opus", "sonnet", "haiku"]; + +/** Creates a crew with its chief, or renames `crew`. */ export function CrewDialog({ crew, onClose }: { crew?: Crew; onClose(): void }) { const t = useT(); const api = useApi(); const putCrew = useApp((state) => state.putCrew); const selectCrew = useApp((state) => state.selectCrew); const [name, setName] = useState(crew?.name ?? ""); + const [folder, setFolder] = useState<string | null>(null); + const [goal, setGoal] = useState(""); + const [chiefModel, setChiefModel] = useState<BotModel>("default"); + const selectBot = useApp((state) => state.selectBot); + const putBot = useApp((state) => state.putBot); const [error, setError] = useState<string | null>(null); const [busy, setBusy] = useState(false); @@ -22,12 +30,31 @@ export function CrewDialog({ crew, onClose }: { crew?: Crew; onClose(): void }) setBusy(true); setError(null); try { + const d = t.crews.dialog; const saved = crew ? await api.call("crews.rename", { crewId: crew.id, name }) - : await api.call("crews.create", { name }); + : await api.call("crews.create", { + name, + ...(folder && { workFolder: folder }), + // Every new crew starts with its chief (spec 10.2). + lead: { + name: d.chiefName, + role: d.chiefRole, + instructions: goal.trim(), + ...(chiefModel !== "default" && { model: chiefModel }), + }, + }); putCrew(saved); if (!crew) { selectCrew(saved.id); + // Straight to the chief's chat, to say what the crew should do. + const bots = await api.call("bots.list", { crewId: saved.id }); + for (const bot of bots) { + putBot(bot); + } + if (saved.leadBotId) { + selectBot(saved.leadBotId); + } } onClose(); } catch (failure) { @@ -61,6 +88,26 @@ export function CrewDialog({ crew, onClose }: { crew?: Crew; onClose(): void }) autoFocus required /> + {!crew && ( + <> + <TextArea + label={t.crews.dialog.goal} + value={goal} + rows={3} + max={FIELD_LIMITS.instructions} + onChange={(event) => setGoal(event.target.value)} + placeholder={t.crews.dialog.goalPlaceholder} + hint={t.crews.dialog.goalHint} + /> + <WorkFolderField value={folder} onChange={setFolder} /> + <SelectField + label={t.crews.dialog.chiefModel} + value={chiefModel} + onChange={(event) => setChiefModel(event.target.value as BotModel)} + options={MODELS.map((value) => ({ value, label: t.chat.model.names[value] }))} + /> + </> + )} {error && ( <p role="alert" className="text-danger text-sm"> {error} diff --git a/app/src/features/crews/CrewView.tsx b/app/src/features/crews/CrewView.tsx index 22d63e04..ce4fb906 100644 --- a/app/src/features/crews/CrewView.tsx +++ b/app/src/features/crews/CrewView.tsx @@ -1,8 +1,18 @@ -import { Archive, Ellipsis, FolderOpen, Pause, Pencil, Play, Plus } from "lucide-react"; +import { + Archive, + Ellipsis, + Folder, + FolderInput, + FolderOpen, + Pause, + Pencil, + Play, + Plus, +} from "lucide-react"; import { useState } from "react"; import { useShallow } from "zustand/react/shallow"; import { useT } from "../../i18n"; -import type { Bot, Crew } from "../../lib/protocol.gen"; +import type { Crew } from "../../lib/protocol.gen"; import { botsOf } from "../../store/app"; import { useApi, useApp, useHost } from "../../store/context"; import { Button } from "../../ui/Button"; @@ -17,13 +27,7 @@ import { TaskList } from "../tasks/TaskList"; import { CrewBots } from "./CrewBots"; import { CrewDialog } from "./CrewDialog"; -/** The crew's `shared` folder, next to its bots' workspaces (spec 5). */ -export function sharedFolder(bots: Bot[]): string | null { - const workspace = bots[0]?.workspace; - return workspace ? workspace.replace(/[\\/][^\\/]+$/, "\\shared") : null; -} - -type Open = "bot" | "rename" | "archive" | null; +type Open = "bot" | "rename" | "archive" | { move: string } | null; type Pane = "bots" | "timeline" | "tasks"; export function CrewView({ crew }: { crew: Crew }) { @@ -35,7 +39,6 @@ export function CrewView({ crew }: { crew: Crew }) { const bots = useApp(useShallow((state) => botsOf(state, crew.id))); const [open, setOpen] = useState<Open>(null); const [pane, setPane] = useState<Pane>("bots"); - const shared = sharedFolder(bots); const close = () => setOpen(null); const tabs: Tab<Pane>[] = [ { id: "bots", label: words.tabs.bots }, @@ -43,6 +46,15 @@ export function CrewView({ crew }: { crew: Crew }) { { id: "tasks", label: words.tabs.tasks }, ]; + const openFolder = () => attempt(words.failed.openFolder, () => host.openPath(crew.workFolder)); + const pickFolder = () => + attempt(words.failed.changeFolder, async () => { + const folder = await host.pickFolder(t.crews.dialog.pickTitle, crew.workFolder); + if (folder && folder !== crew.workFolder) { + setOpen({ move: folder }); + } + }); + const setPaused = (paused: boolean) => attempt(paused ? words.failed.pause : words.failed.resume, async () => putCrew(await api.call("crews.setPaused", { crewId: crew.id, paused })), @@ -53,9 +65,21 @@ export function CrewView({ crew }: { crew: Crew }) { <header className="flex items-center gap-3 border-line border-b px-5 py-3.5"> <div className="min-w-0 flex-1"> <h1 className="truncate font-semibold text-xl tracking-tight">{crew.name}</h1> - <p className="mt-0.5 text-muted text-sm"> - {words.bots(bots.length)} - {crew.paused && ` · ${words.pausedNote}`} + <p className="mt-0.5 flex min-w-0 items-center gap-1.5 text-muted text-sm"> + <span className="shrink-0"> + {words.bots(bots.length)} + {crew.paused && ` · ${words.pausedNote}`} + </span> + <span aria-hidden>·</span> + <button + type="button" + onClick={openFolder} + title={words.openFolder} + className="flex min-w-0 items-center gap-1 rounded-md px-1 hover:bg-sunken hover:text-ink" + > + <Folder aria-hidden size={13} className="shrink-0" /> + <span className="truncate">{words.folder(crew.workFolder)}</span> + </button> </p> </div> <Button variant="primary" icon={Plus} onClick={() => setOpen("bot")}> @@ -75,13 +99,8 @@ export function CrewView({ crew }: { crew: Crew }) { icon={Ellipsis} items={[ { label: t.crews.rename, icon: Pencil, onSelect: () => setOpen("rename") }, - { - label: words.openShared, - icon: FolderOpen, - disabled: !shared, - onSelect: () => - shared && attempt(words.failed.openFolder, () => host.openPath(shared)), - }, + { label: words.openFolder, icon: FolderOpen, onSelect: openFolder }, + { label: words.changeFolder, icon: FolderInput, onSelect: pickFolder }, { label: words.archive, icon: Archive, @@ -127,6 +146,22 @@ export function CrewView({ crew }: { crew: Crew }) { {open === "bot" && <BotDialog crewId={crew.id} onClose={close} />} {open === "rename" && <CrewDialog crew={crew} onClose={close} />} + {typeof open === "object" && open !== null && ( + <Confirm + title={words.moveTitle(crew.name)} + confirmLabel={words.move} + onClose={close} + onConfirm={() => + attempt(words.failed.changeFolder, async () => + putCrew( + await api.call("crews.setWorkFolder", { crewId: crew.id, workFolder: open.move }), + ), + ) + } + > + {words.moveBody(open.move)} + </Confirm> + )} {open === "archive" && ( <Confirm title={words.archiveTitle(crew.name)} diff --git a/app/src/features/crews/Sidebar.tsx b/app/src/features/crews/Sidebar.tsx index eb2239bb..1d894481 100644 --- a/app/src/features/crews/Sidebar.tsx +++ b/app/src/features/crews/Sidebar.tsx @@ -7,8 +7,11 @@ import type { Activity, Bot, Crew } from "../../lib/protocol.gen"; import { botsOf, crewList } from "../../store/app"; import { useApp } from "../../store/context"; import { Button } from "../../ui/Button"; -import { BotAvatar } from "../bots/BotAvatar"; +import { APP_OPENED } from "../../ui/motion"; +import { AccountArea } from "../account/AccountArea"; +import { BotAvatar, moodOf } from "../bots/BotAvatar"; import { BotStateBadge, stateView } from "../bots/BotStateBadge"; +import { ChiefBadge, isChief } from "../bots/ChiefBadge"; import { CrewDialog } from "./CrewDialog"; /** Crews as sections and their bots as conversations (spec 15.1). */ @@ -17,34 +20,34 @@ export function Sidebar() { const crews = useApp(useShallow(crewList)); const [creating, setCreating] = useState(false); return ( - <nav - aria-label={t.crews.sidebar.label} - className="flex w-72 shrink-0 flex-col border-line border-r bg-panel" - > - <div className="flex h-10 shrink-0 items-center justify-between pr-1.5 pl-4"> - <h2 className="font-semibold text-muted text-xs uppercase tracking-[0.12em]"> - {t.crews.sidebar.label} - </h2> - <Button - variant="ghost" - size="sm" - icon={Plus} - label={t.crews.newCrew} - onClick={() => setCreating(true)} - /> - </div> - <ul className="min-h-0 flex-1 overflow-y-auto pb-3"> - {crews.map((crew) => ( - <CrewEntry key={crew.id} crew={crew} /> - ))} - </ul> + <div className="flex w-72 shrink-0 flex-col border-line border-r bg-panel"> + <nav aria-label={t.crews.sidebar.label} className="flex min-h-0 flex-1 flex-col"> + <div className="flex h-10 shrink-0 items-center justify-between pr-1.5 pl-4"> + <h2 className="font-semibold text-muted text-xs uppercase tracking-[0.12em]"> + {t.crews.sidebar.label} + </h2> + <Button + variant="ghost" + size="sm" + icon={Plus} + label={t.crews.newCrew} + onClick={() => setCreating(true)} + /> + </div> + <ul className="min-h-0 flex-1 overflow-y-auto px-2 pb-3"> + {crews.map((crew) => ( + <CrewEntry key={crew.id} crew={crew} /> + ))} + </ul> + </nav> + <AccountArea /> {creating && <CrewDialog onClose={() => setCreating(false)} />} - </nav> + </div> ); } -const row = "relative flex w-full items-center text-left hover:bg-sunken"; -const marker = "before:absolute before:inset-y-0 before:left-0 before:w-[3px] before:bg-accent"; +const row = + "relative flex w-full items-center rounded-lg text-left transition-colors duration-150 hover:bg-sunken"; function CrewEntry({ crew }: { crew: Crew }) { const t = useT(); @@ -58,7 +61,7 @@ function CrewEntry({ crew }: { crew: Crew }) { type="button" aria-current={selected ? "page" : undefined} onClick={() => selectCrew(crew.id)} - className={`${row} h-8 gap-2 pr-3 pl-4 font-semibold text-sm ${selected ? `bg-sunken ${marker}` : ""}`} + className={`${row} h-8 gap-2 px-2.5 font-semibold text-sm ${selected ? "bg-sunken" : ""}`} > <span className="min-w-0 flex-1 truncate">{crew.name}</span> {crew.paused && ( @@ -83,18 +86,21 @@ function Conversation({ bot, crew }: { bot: Bot; crew: Crew }) { const selectBot = useApp((state) => state.selectBot); const activity = bot.lastActivity; return ( - <li> + <li className={bot.createdAt > APP_OPENED ? "animate-rise" : undefined}> <button type="button" aria-current={selected ? "page" : undefined} aria-label={`${bot.name}, ${stateView(bot, crew.paused).label}`} onClick={() => selectBot(bot.id)} - className={`${row} gap-2.5 py-2 pr-3 pl-4 ${selected ? `bg-sunken ${marker}` : ""}`} + className={`${row} gap-2.5 px-2.5 py-2 ${selected ? "bg-sunken" : ""}`} > - <BotAvatar color={bot.color} size={32} /> + <BotAvatar color={bot.color} size={32} mood={moodOf(bot, crew.paused)} /> <span className="min-w-0 flex-1"> <span className="flex items-baseline gap-2"> - <span className="min-w-0 flex-1 truncate font-medium text-sm">{bot.name}</span> + <span className="flex min-w-0 flex-1 items-center gap-1"> + <span className="truncate font-medium text-sm">{bot.name}</span> + {isChief(bot, crew) && <ChiefBadge crew={crew} compact />} + </span> {activity && ( <time className="shrink-0 text-muted text-xs" diff --git a/app/src/features/crews/WorkFolderField.tsx b/app/src/features/crews/WorkFolderField.tsx new file mode 100644 index 00000000..370d22ad --- /dev/null +++ b/app/src/features/crews/WorkFolderField.tsx @@ -0,0 +1,58 @@ +// Where a new crew works (spec 5): a folder the owner picks with Windows' +// folder picker, or a new one inside Botloft. + +import { Folder, X } from "lucide-react"; +import { useT } from "../../i18n"; +import { useHost } from "../../store/context"; +import { Button } from "../../ui/Button"; +import { attempt } from "../../ui/toast"; + +export function WorkFolderField({ + value, + onChange, +}: { + value: string | null; + onChange(folder: string | null): void; +}) { + const words = useT().crews.dialog; + const failed = useT().crews.view.failed.changeFolder; + const host = useHost(); + + const pick = () => + attempt(failed, async () => { + const folder = await host.pickFolder(words.pickTitle, value ?? undefined); + if (folder) { + onChange(folder); + } + }); + + return ( + <fieldset className="flex flex-col gap-1"> + <legend className="mb-1 font-medium text-ink-soft text-sm">{words.folder}</legend> + <div className="flex items-center gap-2"> + <p + className="flex h-8 min-w-0 flex-1 items-center gap-2 rounded-lg border border-line-strong bg-canvas px-2.5 text-sm" + title={value ?? undefined} + > + <Folder aria-hidden size={15} className="shrink-0 text-muted" /> + <span className={`truncate ${value ? "text-ink" : "text-muted"}`}> + {value ?? words.folderDefault} + </span> + </p> + {value && ( + <button + type="button" + aria-label={words.useDefault} + title={words.useDefault} + onClick={() => onChange(null)} + className="grid h-8 w-8 shrink-0 place-items-center rounded-lg text-muted hover:bg-sunken hover:text-ink" + > + <X aria-hidden size={15} /> + </button> + )} + <Button onClick={pick}>{words.chooseFolder}</Button> + </div> + <p className="text-muted text-xs">{words.folderHint}</p> + </fieldset> + ); +} diff --git a/app/src/features/crews/chief.test.tsx b/app/src/features/crews/chief.test.tsx new file mode 100644 index 00000000..a7116b4f --- /dev/null +++ b/app/src/features/crews/chief.test.tsx @@ -0,0 +1,127 @@ +import { act, cleanup, fireEvent, screen, within } from "@testing-library/react"; +import { afterEach, describe, expect, test } from "vitest"; +import { FakeBotloft } from "../../lib/fake"; +import { SUGGEST_TOOL } from "../../lib/fakeChat"; +import { crewOpened, openBot, renderApp, sidebar } from "../../test/app"; + +afterEach(cleanup); + +const DESIGNER = { + name: "Designer", + role: "Draws each page", + instructions: "Design the pages in shared/design.", + model: "sonnet", + reason: "The site needs a look before anyone builds it.", +}; + +/** A crew "Site" with its chief, open on the chief's chat. */ +async function openChief() { + const fake = new FakeBotloft(); + const site = fake.call("crews.create", { + name: "Site", + lead: { name: "Chief", role: "Leads the crew", instructions: "Build the site" }, + }); + const crew = await site; + const chiefId = crew.leadBotId as string; + fake.setBotState(chiefId, "idle"); + renderApp(fake); + await crewOpened("Site"); + openBot("Chief"); + await screen.findByRole("list", { name: "Messages" }); + return { fake, crew, chiefId }; +} + +function suggest(fake: FakeBotloft, chiefId: string) { + act(() => { + fake.chat.ask(chiefId, SUGGEST_TOOL, "Designer", JSON.stringify(DESIGNER)); + }); + return screen.getByRole("region", { name: "Chief suggests a new bot" }); +} + +const answer = (fake: FakeBotloft) => + fake.calls.find((call) => call.method === "approvals.answer")?.params; + +describe("the crew's chief", () => { + test("a new crew starts with a chief, from the crew's goal", async () => { + const fake = new FakeBotloft(); + fake.addCrew("Ops"); + renderApp(fake); + await crewOpened("Ops"); + fireEvent.click(screen.getByRole("button", { name: "New crew" })); + const dialog = screen.getByRole("dialog", { name: "New crew" }); + fireEvent.change(within(dialog).getByLabelText("Name"), { target: { value: "Bakery" } }); + fireEvent.change(within(dialog).getByLabelText("What is this crew for?"), { + target: { value: "Build my bakery's website" }, + }); + fireEvent.change(within(dialog).getByLabelText("Chief's model"), { + target: { value: "opus" }, + }); + fireEvent.click(within(dialog).getByRole("button", { name: "Create crew" })); + + expect(await screen.findByRole("heading", { level: 1, name: "Chief" })).toBeDefined(); + const create = fake.calls.find((call) => call.method === "crews.create"); + expect(create?.params).toMatchObject({ + name: "Bakery", + lead: { name: "Chief", instructions: "Build my bakery's website", model: "opus" }, + }); + // The crown, in the header and the conversation list. + expect(screen.getAllByTitle(/^Leads Bakery/)).toHaveLength(2); + }); + + test("the owner creates the bot the chief suggests", async () => { + const { fake, chiefId } = await openChief(); + const card = suggest(fake, chiefId); + expect(within(card).getByText(DESIGNER.reason)).toBeDefined(); + expect((within(card).getByLabelText("Name") as HTMLInputElement).value).toBe("Designer"); + fireEvent.click(within(card).getByRole("button", { name: "Create bot" })); + + expect(await screen.findByText("You created Designer")).toBeDefined(); + expect(answer(fake)).toEqual({ approvalId: expect.any(String), allow: true }); + expect(within(sidebar()).getByRole("button", { name: /^Designer/ })).toBeDefined(); + }); + + test("the owner can change the suggestion before creating it", async () => { + const { fake, chiefId } = await openChief(); + const card = suggest(fake, chiefId); + fireEvent.change(within(card).getByLabelText("Name"), { target: { value: "Illustrator" } }); + fireEvent.change(within(card).getByLabelText("Model"), { target: { value: "haiku" } }); + fireEvent.click(within(card).getByRole("button", { name: "Create bot" })); + + expect(await screen.findByText("You created Illustrator")).toBeDefined(); + const sent = answer(fake) as { input: string }; + expect(JSON.parse(sent.input)).toMatchObject({ name: "Illustrator", model: "haiku" }); + const illustrator = [...fake.bots.values()].find((bot) => bot.name === "Illustrator"); + expect(illustrator?.model).toBe("haiku"); + }); + + test("saying no tells the chief why", async () => { + const { fake, chiefId } = await openChief(); + const card = suggest(fake, chiefId); + fireEvent.change(within(card).getByLabelText("What to tell Chief if you say no"), { + target: { value: "The writer can do it" }, + }); + fireEvent.click(within(card).getByRole("button", { name: "Not now" })); + + expect(await screen.findByText("You said no to Designer")).toBeDefined(); + expect(answer(fake)).toMatchObject({ allow: false, note: "The writer can do it" }); + expect([...fake.bots.values()].some((bot) => bot.name === "Designer")).toBe(false); + }); + + test("the owner moves the chief to another bot", async () => { + const { fake, crew } = await openChief(); + act(() => { + fake.setBotState(fake.addBot(crew.id, "Writer").id, "idle"); + }); + openBot("Writer"); + await screen.findByRole("heading", { level: 1, name: "Writer" }); + fireEvent.click(screen.getByRole("button", { name: "More bot actions" })); + fireEvent.click(screen.getByRole("menuitem", { name: "Make crew chief" })); + + // The header and the conversation list of the new chief. + await screen.findByText("Chief", { selector: "header span" }); + const moved = fake.calls.find((call) => call.method === "crews.setLead"); + expect(moved?.params).toMatchObject({ crewId: crew.id }); + fireEvent.click(screen.getByRole("button", { name: "More bot actions" })); + expect(screen.getByRole("menuitem", { name: "Stop being chief" })).toBeDefined(); + }); +}); diff --git a/app/src/features/crews/folders.test.tsx b/app/src/features/crews/folders.test.tsx new file mode 100644 index 00000000..87b15cd2 --- /dev/null +++ b/app/src/features/crews/folders.test.tsx @@ -0,0 +1,95 @@ +import { cleanup, fireEvent, screen, within } from "@testing-library/react"; +import { afterEach, describe, expect, test } from "vitest"; +import { FakeBotloft } from "../../lib/fake"; +import { FakeHost } from "../../lib/fakeHost"; +import { crewOpened, renderApp } from "../../test/app"; + +afterEach(cleanup); + +const PROJECT = "D:\\Projects\\Bakery site"; + +describe("work folders", () => { + test("a new crew can work in a folder the owner picks", async () => { + const fake = new FakeBotloft(); + fake.addCrew("Ops"); + const host = new FakeHost(); + host.nextFolder = PROJECT; + renderApp(fake, host); + await crewOpened("Ops"); + + fireEvent.click(screen.getByRole("button", { name: "New crew" })); + const dialog = screen.getByRole("dialog", { name: "New crew" }); + fireEvent.change(within(dialog).getByLabelText("Name"), { target: { value: "Bakery" } }); + expect(within(dialog).getByText("A new folder inside Botloft")).toBeDefined(); + fireEvent.click(within(dialog).getByRole("button", { name: "Choose folder…" })); + expect(await within(dialog).findByText(PROJECT)).toBeDefined(); + fireEvent.click(within(dialog).getByRole("button", { name: "Create crew" })); + + // The new crew opens on its chief's chat. + await screen.findByRole("heading", { level: 1, name: "Chief" }); + const create = fake.calls.find((call) => call.method === "crews.create"); + expect(create?.params).toMatchObject({ name: "Bakery", workFolder: PROJECT }); + const bakery = [...fake.crews.values()].find((crew) => crew.name === "Bakery"); + expect(bakery?.workFolder).toBe(PROJECT); + }); + + test("without a choice the crew gets a new folder", async () => { + const fake = new FakeBotloft(); + fake.addCrew("Ops"); + const host = new FakeHost(); + host.nextFolder = PROJECT; + renderApp(fake, host); + await crewOpened("Ops"); + + fireEvent.click(screen.getByRole("button", { name: "New crew" })); + const dialog = screen.getByRole("dialog", { name: "New crew" }); + fireEvent.change(within(dialog).getByLabelText("Name"), { target: { value: "Bakery" } }); + fireEvent.click(within(dialog).getByRole("button", { name: "Choose folder…" })); + await within(dialog).findByText(PROJECT); + fireEvent.click(within(dialog).getByRole("button", { name: "Use a new folder" })); + fireEvent.click(within(dialog).getByRole("button", { name: "Create crew" })); + + await screen.findByRole("heading", { level: 1, name: "Chief" }); + const create = fake.calls.find((call) => call.method === "crews.create"); + expect(create?.params).not.toHaveProperty("workFolder"); + const bakery = [...fake.crews.values()].find((crew) => crew.name === "Bakery"); + expect(bakery?.workFolderChosen).toBe(false); + }); + + test("the owner opens the folder and moves the crew to another one", async () => { + const fake = new FakeBotloft(); + const ops = fake.addCrew("Ops"); + const host = new FakeHost(); + renderApp(fake, host); + await crewOpened("Ops"); + + fireEvent.click(screen.getByRole("button", { name: /^Works in / })); + expect(host.opened).toEqual([ops.workFolder]); + + host.nextFolder = PROJECT; + fireEvent.click(screen.getByRole("button", { name: "More crew actions" })); + fireEvent.click(screen.getByRole("menuitem", { name: "Change work folder…" })); + const confirm = await screen.findByRole("dialog", { name: "Move Ops to another folder?" }); + expect(host.pickerStarts).toEqual([ops.workFolder]); + expect(within(confirm).getByText(/restarts when it finishes/)).toBeDefined(); + fireEvent.click(within(confirm).getByRole("button", { name: "Move" })); + + expect(await screen.findByText(`Works in ${PROJECT}`)).toBeDefined(); + const move = fake.calls.find((call) => call.method === "crews.setWorkFolder"); + expect(move?.params).toEqual({ crewId: ops.id, workFolder: PROJECT }); + }); + + test("cancelling the picker changes nothing", async () => { + const fake = new FakeBotloft(); + fake.addCrew("Ops"); + const host = new FakeHost(); + host.nextFolder = null; + renderApp(fake, host); + await crewOpened("Ops"); + fireEvent.click(screen.getByRole("button", { name: "More crew actions" })); + fireEvent.click(screen.getByRole("menuitem", { name: "Change work folder…" })); + await Promise.resolve(); + expect(screen.queryByRole("dialog")).toBeNull(); + expect(fake.calls.some((call) => call.method === "crews.setWorkFolder")).toBe(false); + }); +}); diff --git a/app/src/features/messages/Composer.tsx b/app/src/features/messages/Composer.tsx index 25d4c243..8ed6dd85 100644 --- a/app/src/features/messages/Composer.tsx +++ b/app/src/features/messages/Composer.tsx @@ -73,7 +73,7 @@ export function Composer({ aria-label={t.messages.composer.recipient} value={to ?? ""} onChange={(event) => setChosen(event.target.value)} - className="h-7 rounded-[3px] border border-line-strong bg-canvas px-1.5 text-sm" + className="h-7 rounded-lg border border-line-strong bg-canvas px-1.5 text-sm" > {bots.map((bot) => ( <option key={bot.id} value={bot.id}> @@ -94,7 +94,7 @@ export function Composer({ onChange={(event) => setBody(event.target.value)} onKeyDown={onKeyDown} placeholder={t.messages.composer.placeholder(recipient?.handle)} - className="min-h-16 flex-1 resize-y rounded-[3px] border border-line-strong bg-canvas px-2.5 py-2 text-sm leading-relaxed outline-none placeholder:text-muted focus:border-accent" + className="min-h-16 flex-1 resize-y rounded-xl border border-line-strong bg-canvas px-2.5 py-2 text-sm leading-relaxed outline-none placeholder:text-muted focus:border-accent" /> <Button variant="primary" diff --git a/app/src/features/messages/FailedDeliveries.tsx b/app/src/features/messages/FailedDeliveries.tsx index aad7658d..52ebeeec 100644 --- a/app/src/features/messages/FailedDeliveries.tsx +++ b/app/src/features/messages/FailedDeliveries.tsx @@ -99,7 +99,7 @@ function FailedDialog({ dead, onClose }: { dead: Delivery[]; onClose(): void }) } > <p className="mb-3 text-ink-soft text-sm">{text.explanation}</p> - <ul className="flex flex-col border border-line"> + <ul className="flex flex-col overflow-hidden rounded-xl border border-line"> {dead.map((delivery) => { const bot = bots[delivery.botId]; const message = bodies[delivery.messageId]; diff --git a/app/src/features/messages/MessageRow.tsx b/app/src/features/messages/MessageRow.tsx index d917abad..835adeb6 100644 --- a/app/src/features/messages/MessageRow.tsx +++ b/app/src/features/messages/MessageRow.tsx @@ -32,7 +32,7 @@ function Sender({ message, bots }: { message: Message; bots: Record<BotId, Bot> case "system": return ( <span className="inline-flex items-center gap-1.5 font-medium"> - <BotAvatar color="#ffffff" size={14} /> + <BotAvatar color="#ffffff" size={14} framed /> {t.messages.row.system} </span> ); @@ -56,7 +56,7 @@ function TaskTag({ message, task }: { message: Message; task: Task | undefined } : text.taskStatus[task.status]; } return ( - <span className="inline-flex items-center gap-1 border border-line px-1.5 text-muted text-xs"> + <span className="inline-flex items-center gap-1 rounded-md border border-line px-1.5 text-muted text-xs"> <Icon aria-hidden size={11} /> {message.kind === "task" ? text.task : text.result} {detail && <span>· {detail}</span>} diff --git a/app/src/features/onboarding/Welcome.tsx b/app/src/features/onboarding/Welcome.tsx index 3ecb421d..5d9e803b 100644 --- a/app/src/features/onboarding/Welcome.tsx +++ b/app/src/features/onboarding/Welcome.tsx @@ -3,6 +3,7 @@ import { type ReactNode, useState } from "react"; import { useT } from "../../i18n"; import { useApp } from "../../store/context"; import { Button } from "../../ui/Button"; +import { BotAvatar } from "../bots/BotAvatar"; import { CrewDialog } from "../crews/CrewDialog"; import { ClaudeCodeHelp } from "./ClaudeCodeHelp"; import { SignInButton } from "./SignIn"; @@ -56,14 +57,17 @@ export function Welcome() { return ( <main className="min-h-0 flex-1 overflow-y-auto p-8"> <div className="mx-auto max-w-xl"> + <span className="mb-3 inline-block animate-float"> + <BotAvatar color="#ff7a59" size={56} mood="idle" /> + </span> <h1 className="font-semibold text-2xl tracking-tight">{w.title}</h1> <p className="mt-1 text-ink-soft leading-relaxed">{w.intro}</p> - <ul className="mt-6 flex flex-col border border-line bg-panel"> + <ul className="mt-6 flex flex-col overflow-hidden rounded-xl border border-line bg-panel"> <Check state="ok" title={w.botloft} detail={w.running} /> {claude} {account} </ul> - <div className="mt-4 border border-line bg-panel p-4 text-sm leading-relaxed"> + <div className="mt-4 rounded-xl border border-line bg-panel p-4 text-sm leading-relaxed"> <p className="font-semibold">{w.askFirstTitle}</p> <p className="mt-1 text-ink-soft">{w.askFirstBody}</p> </div> diff --git a/app/src/features/tasks/TaskList.tsx b/app/src/features/tasks/TaskList.tsx index f6281a5d..f6912a24 100644 --- a/app/src/features/tasks/TaskList.tsx +++ b/app/src/features/tasks/TaskList.tsx @@ -58,7 +58,7 @@ export function TaskList({ crewId }: { crewId: CrewId }) { type="button" aria-pressed={show === option} onClick={() => setShow(option)} - className={`h-7 rounded-[3px] px-2.5 font-medium text-sm ${show === option ? "bg-ink text-canvas" : "text-ink-soft hover:bg-sunken"}`} + className={`h-7 rounded-lg px-2.5 font-medium text-sm ${show === option ? "bg-ink text-canvas" : "text-ink-soft hover:bg-sunken"}`} > {option === "open" ? words.open : words.all} </button> diff --git a/app/src/i18n/en/account.ts b/app/src/i18n/en/account.ts new file mode 100644 index 00000000..da35e870 --- /dev/null +++ b/app/src/i18n/en/account.ts @@ -0,0 +1,43 @@ +// The account area at the bottom of the sidebar: who the owner is, the +// plan's usage, settings, language, what's new and help. + +export const account = { + open: (name: string) => `${name}: account and settings`, + plan: (plan: string) => `${plan} plan`, + notSignedIn: "Not signed in to Claude", + menu: { + usage: "Usage", + settings: "Settings", + language: "Language", + whatsNew: "What's new", + help: "Help", + openFailed: "Could not open the page", + }, + usage: { + title: "Usage", + intro: "How much of your Claude plan your bots have used. It updates whenever a bot works.", + empty: "Usage shows up after a bot's first reply.", + windows: { + five_hour: "5-hour window", + seven_day: "This week", + seven_day_opus: "This week, Opus", + seven_day_sonnet: "This week, Sonnet", + } as Record<string, string>, + used: (percent: number) => `${percent}% used`, + resets: (relative: string) => `Resets ${relative}`, + limited: "Limit reached. Your bots wait until it resets.", + updated: (relative: string) => `Updated ${relative}`, + }, + settings: { + title: "Settings", + appearance: "Appearance", + theme: "Theme", + themes: { system: "System", light: "Light", dark: "Dark" }, + size: "Size", + sizeHint: "Ctrl+= and Ctrl+- change the size too, and Ctrl+0 goes back to the default.", + language: "Language", + about: "About", + claudeCode: (version: string) => `Claude Code ${version}`, + botloft: (version: string) => `Botloft ${version}`, + }, +}; diff --git a/app/src/i18n/en/bots.ts b/app/src/i18n/en/bots.ts index 25c5c338..14d5b269 100644 --- a/app/src/i18n/en/bots.ts +++ b/app/src/i18n/en/bots.ts @@ -29,6 +29,10 @@ export const bots = { /** Paused (the bot or its crew) and not running. */ paused: { label: "Paused", hint: "Paused; resume to start it." }, }, + chief: { + badge: "Chief", + hint: (crew: string) => `Leads ${crew}: plans the work and suggests new bots`, + }, header: { noRole: "No role", pause: "Pause", @@ -40,12 +44,15 @@ export const bots = { edit: "Edit", restartFresh: "Restart with a new conversation", openFolder: "Open folder", + makeChief: "Make crew chief", + stopChief: "Stop being chief", archive: "Archive bot", failed: { pause: "Could not pause the bot", resume: "Could not resume the bot", restart: "Could not restart the bot", openFolder: "Could not open the folder", + chief: "Could not change the chief", archive: "Could not archive the bot", }, fresh: { diff --git a/app/src/i18n/en/chat.ts b/app/src/i18n/en/chat.ts index d1c83aed..c718682b 100644 --- a/app/src/i18n/en/chat.ts +++ b/app/src/i18n/en/chat.ts @@ -74,6 +74,96 @@ export const chat = { denied: (tool: string) => `You denied ${tool}`, expired: (tool: string) => `${tool} was not approved in time`, }, + mode: { + title: "Mode", + button: (mode: string) => `Mode: ${mode}`, + names: { + auto: "Auto", + default: "Manual", + accept_edits: "Accept edits", + plan: "Plan", + bypass_permissions: "Bypass permissions", + }, + hints: { + auto: (bot: string) => `${bot} decides what needs your OK`, + default: (bot: string) => `${bot} always asks before making changes`, + accept_edits: (bot: string) => `${bot} edits files without asking`, + plan: (bot: string) => `${bot} makes a plan before making changes`, + bypass_permissions: (bot: string) => `${bot} does everything without asking`, + }, + turnOn: "Turn on", + failed: "Could not change the mode", + later: (bot: string, mode: string) => + `${bot} switches to ${mode} when it finishes what it's doing.`, + bypassTitle: (bot: string) => `Let ${bot} do anything without asking?`, + bypassBody: (bot: string) => + `${bot} will edit files, run commands and use the internet on this computer without asking you first.`, + bypassRisk: + "It is not limited to its folder: it can read and change your other files, other bots' files and Botloft's own files. A message from someone else could get it to do something you did not want.", + bypassChief: (bot: string) => + `${bot} leads its crew, so it will also create new bots without asking you.`, + bypassAdvice: + "Turn this on only for a bot you trust with everything, and only while you need it.", + badge: "Asks nothing", + badgeHint: + "This bot does everything without asking. Change it in the mode picker below the chat.", + }, + model: { + title: "Model", + button: (model: string) => `Model: ${model}`, + names: { + default: "Plan default", + fable: "Fable", + opus: "Opus", + sonnet: "Sonnet", + haiku: "Haiku", + }, + short: "Default", + hints: { + default: (bot: string, inUse: string | null) => + inUse + ? `${bot} uses your plan's default model, now ${inUse}` + : `${bot} uses your plan's default model`, + fable: (bot: string) => `${bot} is at its most capable, for the hardest work`, + opus: (bot: string) => `${bot} handles long, complex tasks well`, + sonnet: (bot: string) => `${bot} is fast and capable, good for most work`, + haiku: (bot: string) => `${bot} is quickest and uses less of your plan, for simple tasks`, + }, + cost: "More capable models use up your plan's limit faster.", + failed: "Could not change the model", + later: (bot: string, model: string) => + `${bot} switches to ${model} when it finishes what it's doing.`, + }, + suggestion: { + title: (bot: string) => `${bot} suggests a new bot`, + why: "Why", + name: "Name", + role: "Role", + model: "Model", + instructions: "Instructions", + startsNow: (bot: string) => `It starts right away and gets its work from ${bot}.`, + noteLabel: (bot: string) => `What to tell ${bot} if you say no`, + notePlaceholder: (bot: string) => `If you say no, tell ${bot} why (optional)`, + create: "Create bot", + decline: "Not now", + createFailed: "Could not create the bot", + declineFailed: "Could not send the answer", + created: (name: string) => `You created ${name}`, + declined: (name: string) => `You said no to ${name}`, + expired: (name: string) => `${name} was not answered in time`, + }, + plan: { + ready: (bot: string) => `${bot} made a plan and wants to go ahead`, + noteLabel: (bot: string) => `What ${bot} should change in the plan`, + notePlaceholder: "What should change? Sent to the bot if you keep planning (optional)", + approve: "Approve plan", + keepPlanning: "Keep planning", + approveFailed: "Could not approve the plan", + keepFailed: "Could not send it back", + approved: "You approved the plan", + sentBack: "You asked for changes to the plan", + expired: "The plan was not approved in time", + }, markdown: { image: "image", openLinkFailed: "Could not open the link", @@ -82,6 +172,8 @@ export const chat = { signedOut: "Claude Code is not signed in, or the account can't be used right now. Sign in to Claude, or check your Claude plan.", usageLimit: "Your Claude plan reached its usage limit. Messages wait until it resets.", + modelUnavailable: + "This bot's model isn't available: it may not be on your Claude plan. Pick another model below the chat.", turnFailed: (detail: string) => `The bot couldn't finish this: ${detail}`, }, }; diff --git a/app/src/i18n/en/crews.ts b/app/src/i18n/en/crews.ts index e97a1efa..0ea025b5 100644 --- a/app/src/i18n/en/crews.ts +++ b/app/src/i18n/en/crews.ts @@ -15,6 +15,19 @@ export const crews = { awaitingApproval: (text: string) => `Waiting for approval: ${text}`, }, dialog: { + folder: "Work folder", + folderHint: "Where the bots put what they make. It can be a folder you already use.", + folderDefault: "A new folder inside Botloft", + chooseFolder: "Choose folder…", + pickTitle: "Choose where the crew works", + useDefault: "Use a new folder", + goal: "What is this crew for?", + goalPlaceholder: "Build and keep up my bakery's website", + goalHint: + "The crew starts with a chief, who reads this, plans the work and suggests the bots it needs.", + chiefModel: "Chief's model", + chiefName: "Chief", + chiefRole: "Leads the crew: plans the work, suggests new bots and hands out tasks", renameTitle: "Rename crew", create: "Create crew", name: "Name", @@ -28,7 +41,13 @@ export const crews = { pause: "Pause crew", resume: "Resume crew", moreActions: "More crew actions", - openShared: "Open shared folder", + folder: (path: string) => `Works in ${path}`, + openFolder: "Open work folder", + changeFolder: "Change work folder…", + moveTitle: (crew: string) => `Move ${crew} to another folder?`, + moveBody: (path: string) => + `The bots will work in ${path}. Each one restarts when it finishes what it's doing. Files already made stay where they are.`, + move: "Move", archive: "Archive crew", tabs: { label: "Crew views", @@ -46,6 +65,7 @@ export const crews = { failed: { pause: "Could not pause the crew", resume: "Could not resume the crew", + changeFolder: "Could not change the folder", openFolder: "Could not open the folder", archive: "Could not archive the crew", }, diff --git a/app/src/i18n/en/index.ts b/app/src/i18n/en/index.ts index 7e0ceee4..774883e6 100644 --- a/app/src/i18n/en/index.ts +++ b/app/src/i18n/en/index.ts @@ -1,5 +1,6 @@ // English, the reference: every other language has exactly this shape. +import { account } from "./account"; import { bots } from "./bots"; import { chat } from "./chat"; import { common } from "./common"; @@ -9,6 +10,16 @@ import { onboarding } from "./onboarding"; import { shell } from "./shell"; import { updates } from "./updates"; -export const en = { common, shell, onboarding, updates, bots, chat, crews, messages }; +export const en = { + common, + shell, + onboarding, + updates, + account, + bots, + chat, + crews, + messages, +}; export type Messages = typeof en; diff --git a/app/src/i18n/en/onboarding.ts b/app/src/i18n/en/onboarding.ts index a7401a55..05fe3a18 100644 --- a/app/src/i18n/en/onboarding.ts +++ b/app/src/i18n/en/onboarding.ts @@ -45,7 +45,7 @@ export const onboarding = { welcome: { title: "Welcome to Botloft", intro: - "A crew is a group of Claude Code bots that keep running, message each other and share a folder. Start with one crew and a bot or two.", + "A crew is a group of Claude Code bots that keep running, message each other and share a folder. Each crew starts with a chief: tell it what the crew is for, and it plans the work and suggests the bots it needs.", botloft: "Botloft", running: "Running in the background. It starts with Windows, so your bots keep working after you close this window.", diff --git a/app/src/i18n/en/shell.ts b/app/src/i18n/en/shell.ts index 8beff70e..745c3686 100644 --- a/app/src/i18n/en/shell.ts +++ b/app/src/i18n/en/shell.ts @@ -8,12 +8,9 @@ export const shell = { restore: "Restore", close: "Close", }, - theme: { - system: "system", - light: "light", - dark: "dark", - label: (theme: string) => `Theme: ${theme}`, - hint: (theme: string) => `Theme: ${theme} (click to change)`, + zoom: { + level: (percent: number, isDefault: boolean) => + isDefault ? `${percent}% (default)` : `${percent}%`, }, language: { label: "Language", diff --git a/app/src/i18n/es/account.ts b/app/src/i18n/es/account.ts new file mode 100644 index 00000000..8a18cf30 --- /dev/null +++ b/app/src/i18n/es/account.ts @@ -0,0 +1,43 @@ +import type { Messages } from "../en"; + +export const account: Messages["account"] = { + open: (name: string) => `${name}: cuenta y configuración`, + plan: (plan: string) => `Plan ${plan}`, + notSignedIn: "Sin sesión en Claude", + menu: { + usage: "Uso", + settings: "Configuración", + language: "Idioma", + whatsNew: "Novedades", + help: "Ayuda", + openFailed: "No se pudo abrir la página", + }, + usage: { + title: "Uso", + intro: + "Cuánto de tu plan de Claude han usado tus bots. Se actualiza cada vez que un bot trabaja.", + empty: "El uso aparece después de la primera respuesta de un bot.", + windows: { + five_hour: "Ventana de 5 horas", + seven_day: "Esta semana", + seven_day_opus: "Esta semana, Opus", + seven_day_sonnet: "Esta semana, Sonnet", + }, + used: (percent: number) => `${percent}% usado`, + resets: (relative: string) => `Se renueva ${relative}`, + limited: "Límite alcanzado. Tus bots esperan hasta que se renueve.", + updated: (relative: string) => `Actualizado ${relative}`, + }, + settings: { + title: "Configuración", + appearance: "Apariencia", + theme: "Tema", + themes: { system: "Sistema", light: "Claro", dark: "Oscuro" }, + size: "Tamaño", + sizeHint: "Ctrl+= y Ctrl+- también cambian el tamaño, y Ctrl+0 vuelve al predeterminado.", + language: "Idioma", + about: "Acerca de", + claudeCode: (version: string) => `Claude Code ${version}`, + botloft: (version: string) => `Botloft ${version}`, + }, +}; diff --git a/app/src/i18n/es/bots.ts b/app/src/i18n/es/bots.ts index 178ab7fe..b4dcfab9 100644 --- a/app/src/i18n/es/bots.ts +++ b/app/src/i18n/es/bots.ts @@ -25,6 +25,10 @@ export const bots: Messages["bots"] = { archived: { label: "Archivado", hint: "Archivado." }, paused: { label: "En pausa", hint: "En pausa; reanúdalo para iniciarlo." }, }, + chief: { + badge: "Jefe", + hint: (crew: string) => `Dirige ${crew}: planea el trabajo y sugiere bots nuevos`, + }, header: { noRole: "Sin rol", pause: "Pausar", @@ -36,12 +40,15 @@ export const bots: Messages["bots"] = { edit: "Editar", restartFresh: "Reiniciar con una conversación nueva", openFolder: "Abrir carpeta", + makeChief: "Hacer jefe del equipo", + stopChief: "Dejar de ser jefe", archive: "Archivar bot", failed: { pause: "No se pudo pausar el bot", resume: "No se pudo reanudar el bot", restart: "No se pudo reiniciar el bot", openFolder: "No se pudo abrir la carpeta", + chief: "No se pudo cambiar el jefe", archive: "No se pudo archivar el bot", }, fresh: { diff --git a/app/src/i18n/es/chat.ts b/app/src/i18n/es/chat.ts index 5a5af18f..55ea3aa0 100644 --- a/app/src/i18n/es/chat.ts +++ b/app/src/i18n/es/chat.ts @@ -79,6 +79,97 @@ export const chat: Messages["chat"] = { denied: (tool: string) => `Denegaste ${tool}`, expired: (tool: string) => `${tool} no se aprobó a tiempo`, }, + mode: { + title: "Modo", + button: (mode: string) => `Modo: ${mode}`, + names: { + auto: "Automático", + default: "Manual", + accept_edits: "Aceptar ediciones", + plan: "Plan", + bypass_permissions: "Omitir permisos", + }, + hints: { + auto: (bot: string) => `${bot} decide qué necesita tu aprobación`, + default: (bot: string) => `${bot} siempre pregunta antes de hacer cambios`, + accept_edits: (bot: string) => `${bot} edita archivos sin preguntar`, + plan: (bot: string) => `${bot} crea un plan antes de hacer cambios`, + bypass_permissions: (bot: string) => `${bot} lo hace todo sin preguntar`, + }, + turnOn: "Activar", + failed: "No se pudo cambiar el modo", + later: (bot: string, mode: string) => + `${bot} cambiará a ${mode} cuando termine lo que está haciendo.`, + bypassTitle: (bot: string) => `¿Dejar que ${bot} haga todo sin preguntar?`, + bypassBody: (bot: string) => + `${bot} editará archivos, ejecutará comandos y usará internet en este equipo sin pedirte permiso antes.`, + bypassRisk: + "No se limita a su carpeta: puede leer y cambiar tus otros archivos, los de otros bots y los del propio Botloft. Un mensaje de otra persona podría llevarlo a hacer algo que no querías.", + bypassChief: (bot: string) => + `${bot} es el jefe del equipo, así que también creará bots nuevos sin preguntar.`, + bypassAdvice: + "Actívalo solo para un bot en el que confíes para todo, y solo mientras lo necesites.", + badge: "No pregunta nada", + badgeHint: + "Este bot lo hace todo sin preguntar. Cámbialo en el selector de modo, debajo del chat.", + }, + model: { + title: "Modelo", + button: (model: string) => `Modelo: ${model}`, + names: { + default: "Predeterminado del plan", + fable: "Fable", + opus: "Opus", + sonnet: "Sonnet", + haiku: "Haiku", + }, + short: "Predeterminado", + hints: { + default: (bot: string, inUse: string | null) => + inUse + ? `${bot} usa el modelo predeterminado de tu plan, ahora ${inUse}` + : `${bot} usa el modelo predeterminado de tu plan`, + fable: (bot: string) => `${bot} rinde al máximo, para el trabajo más difícil`, + opus: (bot: string) => `${bot} maneja bien tareas largas y complejas`, + sonnet: (bot: string) => `${bot} es rápido y capaz, bueno para casi todo`, + haiku: (bot: string) => + `${bot} es el más rápido y gasta menos de tu plan, para tareas simples`, + }, + cost: "Los modelos más capaces gastan el límite de tu plan más rápido.", + failed: "No se pudo cambiar el modelo", + later: (bot: string, model: string) => + `${bot} cambia a ${model} cuando termine lo que está haciendo.`, + }, + suggestion: { + title: (bot: string) => `${bot} sugiere un bot nuevo`, + why: "Por qué", + name: "Nombre", + role: "Rol", + model: "Modelo", + instructions: "Instrucciones", + startsNow: (bot: string) => `Empieza enseguida y recibe el trabajo de ${bot}.`, + noteLabel: (bot: string) => `Qué decirle a ${bot} si dices que no`, + notePlaceholder: (bot: string) => `Si dices que no, dile a ${bot} por qué (opcional)`, + create: "Crear bot", + decline: "Ahora no", + createFailed: "No se pudo crear el bot", + declineFailed: "No se pudo enviar la respuesta", + created: (name: string) => `Creaste ${name}`, + declined: (name: string) => `Rechazaste ${name}`, + expired: (name: string) => `${name} no se respondió a tiempo`, + }, + plan: { + ready: (bot: string) => `${bot} hizo un plan y quiere seguir con él`, + noteLabel: (bot: string) => `Qué debe cambiar ${bot} en el plan`, + notePlaceholder: "¿Qué debe cambiar? Se envía al bot si pides cambios (opcional)", + approve: "Aprobar plan", + keepPlanning: "Pedir cambios", + approveFailed: "No se pudo aprobar el plan", + keepFailed: "No se pudo devolver el plan", + approved: "Aprobaste el plan", + sentBack: "Pediste cambios en el plan", + expired: "El plan no se aprobó a tiempo", + }, markdown: { image: "imagen", openLinkFailed: "No se pudo abrir el enlace", @@ -88,6 +179,8 @@ export const chat: Messages["chat"] = { "Claude Code no tiene una sesión iniciada, o la cuenta no se puede usar ahora. Inicia sesión en Claude o revisa tu plan de Claude.", usageLimit: "Tu plan de Claude alcanzó su límite de uso. Los mensajes esperarán hasta que se restablezca.", + modelUnavailable: + "El modelo de este bot no está disponible: quizá no esté en tu plan de Claude. Elige otro modelo debajo del chat.", turnFailed: (detail: string) => `El bot no pudo terminar esto: ${detail}`, }, }; diff --git a/app/src/i18n/es/crews.ts b/app/src/i18n/es/crews.ts index 2ad18604..b5b164f4 100644 --- a/app/src/i18n/es/crews.ts +++ b/app/src/i18n/es/crews.ts @@ -12,6 +12,19 @@ export const crews: Messages["crews"] = { awaitingApproval: (text: string) => `Esperando aprobación: ${text}`, }, dialog: { + folder: "Carpeta de trabajo", + folderHint: "Donde los bots guardan lo que hacen. Puede ser una carpeta que ya usas.", + folderDefault: "Una carpeta nueva dentro de Botloft", + chooseFolder: "Elegir carpeta…", + pickTitle: "Elige dónde trabaja el equipo", + useDefault: "Usar una carpeta nueva", + goal: "¿Para qué es este equipo?", + goalPlaceholder: "Crear y mantener la web de mi panadería", + goalHint: + "El equipo empieza con un jefe, que lee esto, planea el trabajo y sugiere los bots que necesita.", + chiefModel: "Modelo del jefe", + chiefName: "Jefe", + chiefRole: "Dirige el equipo: planea el trabajo, sugiere bots nuevos y reparte las tareas", renameTitle: "Renombrar equipo", create: "Crear equipo", name: "Nombre", @@ -25,7 +38,13 @@ export const crews: Messages["crews"] = { pause: "Pausar equipo", resume: "Reanudar equipo", moreActions: "Más acciones del equipo", - openShared: "Abrir carpeta compartida", + folder: (path: string) => `Trabaja en ${path}`, + openFolder: "Abrir carpeta de trabajo", + changeFolder: "Cambiar carpeta de trabajo…", + moveTitle: (crew: string) => `¿Mover ${crew} a otra carpeta?`, + moveBody: (path: string) => + `Los bots trabajarán en ${path}. Cada uno se reinicia cuando termine lo que está haciendo. Lo que ya hicieron se queda donde está.`, + move: "Mover", archive: "Archivar equipo", tabs: { label: "Vistas del equipo", @@ -43,6 +62,7 @@ export const crews: Messages["crews"] = { failed: { pause: "No se pudo pausar el equipo", resume: "No se pudo reanudar el equipo", + changeFolder: "No se pudo cambiar la carpeta", openFolder: "No se pudo abrir la carpeta", archive: "No se pudo archivar el equipo", }, diff --git a/app/src/i18n/es/index.ts b/app/src/i18n/es/index.ts index 2da37bda..45a4b409 100644 --- a/app/src/i18n/es/index.ts +++ b/app/src/i18n/es/index.ts @@ -1,6 +1,7 @@ // Spanish. import type { Messages } from "../en"; +import { account } from "./account"; import { bots } from "./bots"; import { chat } from "./chat"; import { common } from "./common"; @@ -10,4 +11,14 @@ import { onboarding } from "./onboarding"; import { shell } from "./shell"; import { updates } from "./updates"; -export const es: Messages = { common, shell, onboarding, updates, bots, chat, crews, messages }; +export const es: Messages = { + common, + shell, + onboarding, + updates, + account, + bots, + chat, + crews, + messages, +}; diff --git a/app/src/i18n/es/onboarding.ts b/app/src/i18n/es/onboarding.ts index a5d66198..f25217f7 100644 --- a/app/src/i18n/es/onboarding.ts +++ b/app/src/i18n/es/onboarding.ts @@ -44,7 +44,7 @@ export const onboarding: Messages["onboarding"] = { welcome: { title: "Te damos la bienvenida a Botloft", intro: - "Un equipo es un grupo de bots de Claude Code que siguen funcionando, se envían mensajes y comparten una carpeta. Empieza con un equipo y uno o dos bots.", + "Un equipo es un grupo de bots de Claude Code que siguen funcionando, se envían mensajes y comparten una carpeta. Cada equipo empieza con un jefe: dile para qué es el equipo, y planea el trabajo y sugiere los bots que necesita.", botloft: "Botloft", running: "Funcionando en segundo plano. Se inicia con Windows, así que tus bots siguen trabajando después de cerrar esta ventana.", diff --git a/app/src/i18n/es/shell.ts b/app/src/i18n/es/shell.ts index c36d0857..8020d799 100644 --- a/app/src/i18n/es/shell.ts +++ b/app/src/i18n/es/shell.ts @@ -7,12 +7,9 @@ export const shell: Messages["shell"] = { restore: "Restaurar", close: "Cerrar", }, - theme: { - system: "sistema", - light: "claro", - dark: "oscuro", - label: (theme: string) => `Tema: ${theme}`, - hint: (theme: string) => `Tema: ${theme} (haz clic para cambiarlo)`, + zoom: { + level: (percent: number, isDefault: boolean) => + isDefault ? `${percent}% (predeterminado)` : `${percent}%`, }, language: { label: "Idioma", diff --git a/app/src/i18n/i18n.test.tsx b/app/src/i18n/i18n.test.tsx index 5deb2fa5..d033b37b 100644 --- a/app/src/i18n/i18n.test.tsx +++ b/app/src/i18n/i18n.test.tsx @@ -56,13 +56,13 @@ describe("languages", () => { render(<App host={new FakeHost()} connect={() => fake as Client} />); expect(await screen.findByRole("heading", { name: "Welcome to Botloft" })).toBeDefined(); - fireEvent.click(screen.getByRole("button", { name: "Language" })); + // The language lives in the account menu at the bottom of the sidebar. + fireEvent.click(screen.getByRole("button", { name: /Ana Lima/ })); + fireEvent.click(screen.getByRole("menuitem", { name: "Language" })); fireEvent.click(screen.getByRole("menuitemradio", { name: /Português/ })); expect(screen.getByRole("heading", { name: "Boas-vindas ao Botloft" })).toBeDefined(); expect(document.documentElement.lang).toBe("pt-BR"); expect(localStorage.getItem("botloft.locale")).toBe("pt-BR"); - - fireEvent.click(screen.getByRole("button", { name: "Idioma" })); expect( screen.getByRole("menuitemradio", { name: /Português/ }).getAttribute("aria-checked"), ).toBe("true"); diff --git a/app/src/i18n/pt-BR/account.ts b/app/src/i18n/pt-BR/account.ts new file mode 100644 index 00000000..aaa52320 --- /dev/null +++ b/app/src/i18n/pt-BR/account.ts @@ -0,0 +1,43 @@ +import type { Messages } from "../en"; + +export const account: Messages["account"] = { + open: (name: string) => `${name}: conta e configurações`, + plan: (plan: string) => `Plano ${plan}`, + notSignedIn: "Sem conta do Claude conectada", + menu: { + usage: "Uso", + settings: "Configurações", + language: "Idioma", + whatsNew: "Novidades", + help: "Ajuda", + openFailed: "Não foi possível abrir a página", + }, + usage: { + title: "Uso", + intro: + "Quanto do seu plano do Claude os seus bots já usaram. Atualiza sempre que um bot trabalha.", + empty: "O uso aparece depois da primeira resposta de um bot.", + windows: { + five_hour: "Janela de 5 horas", + seven_day: "Esta semana", + seven_day_opus: "Esta semana, Opus", + seven_day_sonnet: "Esta semana, Sonnet", + }, + used: (percent: number) => `${percent}% usado`, + resets: (relative: string) => `Renova ${relative}`, + limited: "Limite atingido. Seus bots esperam até ele renovar.", + updated: (relative: string) => `Atualizado ${relative}`, + }, + settings: { + title: "Configurações", + appearance: "Aparência", + theme: "Tema", + themes: { system: "Sistema", light: "Claro", dark: "Escuro" }, + size: "Tamanho", + sizeHint: "Ctrl+= e Ctrl+- também mudam o tamanho, e Ctrl+0 volta ao padrão.", + language: "Idioma", + about: "Sobre", + claudeCode: (version: string) => `Claude Code ${version}`, + botloft: (version: string) => `Botloft ${version}`, + }, +}; diff --git a/app/src/i18n/pt-BR/bots.ts b/app/src/i18n/pt-BR/bots.ts index ebddc4b0..9cad8fc3 100644 --- a/app/src/i18n/pt-BR/bots.ts +++ b/app/src/i18n/pt-BR/bots.ts @@ -25,6 +25,10 @@ export const bots: Messages["bots"] = { archived: { label: "Arquivado", hint: "Arquivado." }, paused: { label: "Pausado", hint: "Pausado; retome para iniciar." }, }, + chief: { + badge: "Chefe", + hint: (crew: string) => `Lidera ${crew}: planeja o trabalho e sugere bots novos`, + }, header: { noRole: "Sem função definida", pause: "Pausar", @@ -36,12 +40,15 @@ export const bots: Messages["bots"] = { edit: "Editar", restartFresh: "Reiniciar com uma nova conversa", openFolder: "Abrir pasta", + makeChief: "Tornar chefe da equipe", + stopChief: "Deixar de ser chefe", archive: "Arquivar bot", failed: { pause: "Não foi possível pausar o bot", resume: "Não foi possível retomar o bot", restart: "Não foi possível reiniciar o bot", openFolder: "Não foi possível abrir a pasta", + chief: "Não foi possível trocar o chefe", archive: "Não foi possível arquivar o bot", }, fresh: { diff --git a/app/src/i18n/pt-BR/chat.ts b/app/src/i18n/pt-BR/chat.ts index b4657f15..e01756e2 100644 --- a/app/src/i18n/pt-BR/chat.ts +++ b/app/src/i18n/pt-BR/chat.ts @@ -79,6 +79,95 @@ export const chat: Messages["chat"] = { denied: (tool: string) => `Você negou ${tool}`, expired: (tool: string) => `${tool} não foi aprovado a tempo`, }, + mode: { + title: "Modo", + button: (mode: string) => `Modo: ${mode}`, + names: { + auto: "Automático", + default: "Manual", + accept_edits: "Aceitar edições", + plan: "Plano", + bypass_permissions: "Ignorar permissões", + }, + hints: { + auto: (bot: string) => `${bot} decide o que precisa do seu OK`, + default: (bot: string) => `${bot} sempre pergunta antes de fazer alterações`, + accept_edits: (bot: string) => `${bot} edita arquivos sem perguntar`, + plan: (bot: string) => `${bot} cria um plano antes de fazer alterações`, + bypass_permissions: (bot: string) => `${bot} faz tudo sem perguntar`, + }, + turnOn: "Ativar", + failed: "Não foi possível mudar o modo", + later: (bot: string, mode: string) => + `${bot} muda para ${mode} quando terminar o que está fazendo.`, + bypassTitle: (bot: string) => `Deixar ${bot} fazer tudo sem perguntar?`, + bypassBody: (bot: string) => + `${bot} vai editar arquivos, rodar comandos e usar a internet neste computador sem pedir sua permissão antes.`, + bypassRisk: + "Ele não fica preso à pasta dele: pode ler e alterar seus outros arquivos, os arquivos de outros bots e os do próprio Botloft. Uma mensagem de outra pessoa pode levá-lo a fazer algo que você não queria.", + bypassChief: (bot: string) => + `${bot} é o chefe da equipe, então também vai criar bots novos sem perguntar.`, + bypassAdvice: "Ative só para um bot em quem você confia para tudo, e só enquanto precisar.", + badge: "Não pergunta nada", + badgeHint: "Este bot faz tudo sem perguntar. Mude isso no seletor de modo, embaixo do chat.", + }, + model: { + title: "Modelo", + button: (model: string) => `Modelo: ${model}`, + names: { + default: "Padrão do plano", + fable: "Fable", + opus: "Opus", + sonnet: "Sonnet", + haiku: "Haiku", + }, + short: "Padrão", + hints: { + default: (bot: string, inUse: string | null) => + inUse + ? `${bot} usa o modelo padrão do seu plano, hoje o ${inUse}` + : `${bot} usa o modelo padrão do seu plano`, + fable: (bot: string) => `${bot} fica no máximo, para o trabalho mais difícil`, + opus: (bot: string) => `${bot} vai bem em tarefas longas e complexas`, + sonnet: (bot: string) => `${bot} fica rápido e capaz, bom para quase tudo`, + haiku: (bot: string) => + `${bot} fica mais rápido e gasta menos do seu plano, para tarefas simples`, + }, + cost: "Modelos mais capazes gastam o limite do seu plano mais rápido.", + failed: "Não foi possível trocar o modelo", + later: (bot: string, model: string) => + `${bot} muda para ${model} quando terminar o que está fazendo.`, + }, + suggestion: { + title: (bot: string) => `${bot} sugere um bot novo`, + why: "Por quê", + name: "Nome", + role: "Função", + model: "Modelo", + instructions: "Instruções", + startsNow: (bot: string) => `Ele começa na hora e recebe o trabalho de ${bot}.`, + noteLabel: (bot: string) => `O que dizer a ${bot} se você recusar`, + notePlaceholder: (bot: string) => `Se recusar, diga a ${bot} o porquê (opcional)`, + create: "Criar bot", + decline: "Agora não", + createFailed: "Não foi possível criar o bot", + declineFailed: "Não foi possível enviar a resposta", + created: (name: string) => `Você criou ${name}`, + declined: (name: string) => `Você recusou ${name}`, + expired: (name: string) => `${name} não foi respondido a tempo`, + }, + plan: { + ready: (bot: string) => `${bot} fez um plano e quer seguir com ele`, + noteLabel: (bot: string) => `O que ${bot} deve mudar no plano`, + notePlaceholder: "O que deve mudar? Vai para o bot se você pedir mudanças (opcional)", + approve: "Aprovar plano", + keepPlanning: "Pedir mudanças", + approveFailed: "Não foi possível aprovar o plano", + keepFailed: "Não foi possível devolver o plano", + approved: "Você aprovou o plano", + sentBack: "Você pediu mudanças no plano", + expired: "O plano não foi aprovado a tempo", + }, markdown: { image: "imagem", openLinkFailed: "Não foi possível abrir o link", @@ -88,6 +177,8 @@ export const chat: Messages["chat"] = { "O Claude Code não está conectado a uma conta, ou a conta não pode ser usada agora. Entre no Claude ou confira o seu plano do Claude.", usageLimit: "Seu plano do Claude atingiu o limite de uso. As mensagens ficam esperando até o limite renovar.", + modelUnavailable: + "O modelo deste bot não está disponível: talvez não faça parte do seu plano do Claude. Escolha outro modelo abaixo do chat.", turnFailed: (detail: string) => `O bot não conseguiu terminar isto: ${detail}`, }, }; diff --git a/app/src/i18n/pt-BR/crews.ts b/app/src/i18n/pt-BR/crews.ts index 3acaf0c9..526e27ed 100644 --- a/app/src/i18n/pt-BR/crews.ts +++ b/app/src/i18n/pt-BR/crews.ts @@ -12,6 +12,19 @@ export const crews: Messages["crews"] = { awaitingApproval: (text: string) => `Aguardando aprovação: ${text}`, }, dialog: { + folder: "Pasta de trabalho", + folderHint: "Onde os bots guardam o que fazem. Pode ser uma pasta que você já usa.", + folderDefault: "Uma pasta nova dentro do Botloft", + chooseFolder: "Escolher pasta…", + pickTitle: "Escolha onde a equipe trabalha", + useDefault: "Usar uma pasta nova", + goal: "Para que é esta equipe?", + goalPlaceholder: "Criar e manter o site da minha padaria", + goalHint: + "A equipe começa com um Chefe, que lê isto, planeja o trabalho e sugere os bots de que precisa.", + chiefModel: "Modelo do Chefe", + chiefName: "Chefe", + chiefRole: "Lidera a equipe: planeja o trabalho, sugere bots novos e distribui as tarefas", renameTitle: "Renomear equipe", create: "Criar equipe", name: "Nome", @@ -26,7 +39,13 @@ export const crews: Messages["crews"] = { pause: "Pausar equipe", resume: "Retomar equipe", moreActions: "Mais ações da equipe", - openShared: "Abrir pasta compartilhada", + folder: (path: string) => `Trabalha em ${path}`, + openFolder: "Abrir pasta de trabalho", + changeFolder: "Mudar pasta de trabalho…", + moveTitle: (crew: string) => `Mudar ${crew} para outra pasta?`, + moveBody: (path: string) => + `Os bots vão trabalhar em ${path}. Cada um reinicia quando terminar o que está fazendo. O que já foi feito fica onde está.`, + move: "Mudar", archive: "Arquivar equipe", tabs: { label: "Visões da equipe", @@ -44,6 +63,7 @@ export const crews: Messages["crews"] = { failed: { pause: "Não foi possível pausar a equipe", resume: "Não foi possível retomar a equipe", + changeFolder: "Não foi possível mudar a pasta", openFolder: "Não foi possível abrir a pasta", archive: "Não foi possível arquivar a equipe", }, diff --git a/app/src/i18n/pt-BR/index.ts b/app/src/i18n/pt-BR/index.ts index e15ad594..a3aa413b 100644 --- a/app/src/i18n/pt-BR/index.ts +++ b/app/src/i18n/pt-BR/index.ts @@ -1,6 +1,7 @@ // Brazilian Portuguese. import type { Messages } from "../en"; +import { account } from "./account"; import { bots } from "./bots"; import { chat } from "./chat"; import { common } from "./common"; @@ -10,4 +11,14 @@ import { onboarding } from "./onboarding"; import { shell } from "./shell"; import { updates } from "./updates"; -export const ptBR: Messages = { common, shell, onboarding, updates, bots, chat, crews, messages }; +export const ptBR: Messages = { + common, + shell, + onboarding, + updates, + account, + bots, + chat, + crews, + messages, +}; diff --git a/app/src/i18n/pt-BR/onboarding.ts b/app/src/i18n/pt-BR/onboarding.ts index f7058f32..1e699416 100644 --- a/app/src/i18n/pt-BR/onboarding.ts +++ b/app/src/i18n/pt-BR/onboarding.ts @@ -44,7 +44,7 @@ export const onboarding: Messages["onboarding"] = { welcome: { title: "Boas-vindas ao Botloft", intro: - "Uma equipe é um grupo de bots do Claude Code que ficam rodando, trocam mensagens entre si e compartilham uma pasta. Comece com uma equipe e um ou dois bots.", + "Uma equipe é um grupo de bots do Claude Code que ficam rodando, trocam mensagens entre si e compartilham uma pasta. Cada equipe começa com um Chefe: diga a ele para que é a equipe, e ele planeja o trabalho e sugere os bots de que precisa.", botloft: "Botloft", running: "Rodando em segundo plano. Inicia com o Windows, então seus bots continuam trabalhando depois que você fecha esta janela.", diff --git a/app/src/i18n/pt-BR/shell.ts b/app/src/i18n/pt-BR/shell.ts index 6abb735e..bb82a25a 100644 --- a/app/src/i18n/pt-BR/shell.ts +++ b/app/src/i18n/pt-BR/shell.ts @@ -7,12 +7,9 @@ export const shell: Messages["shell"] = { restore: "Restaurar", close: "Fechar", }, - theme: { - system: "sistema", - light: "claro", - dark: "escuro", - label: (theme: string) => `Tema: ${theme}`, - hint: (theme: string) => `Tema: ${theme} (clique para trocar)`, + zoom: { + level: (percent: number, isDefault: boolean) => + isDefault ? `${percent}% (padrão)` : `${percent}%`, }, language: { label: "Idioma", diff --git a/app/src/index.css b/app/src/index.css index 5cc62aa2..2efd28f9 100644 --- a/app/src/index.css +++ b/app/src/index.css @@ -4,6 +4,7 @@ @import "@fontsource/ibm-plex-sans/600.css"; @import "@fontsource/ibm-plex-mono/400.css"; @import "@fontsource/ibm-plex-mono/500.css"; +@import "./motion.css"; /* Colors are tokens so the light and dark themes swap in one place (spec 15.3). State colors always go with an icon and a label. */ @@ -23,6 +24,10 @@ --warn: #a35f00; --danger: #c2372a; --idle-state: #6f6f69; + /* The thin edge around a bot's avatar, so light colors hold their shape. */ + --avatar-edge: rgb(0 0 0 / 0.2); + /* Under menus, pickers and dialogs. */ + --lift: rgb(0 0 0 / 0.12); } [data-theme="dark"] { @@ -41,6 +46,8 @@ --warn: #f0b24a; --danger: #ff6d60; --idle-state: #8c8c86; + --avatar-edge: rgb(255 255 255 / 0.14); + --lift: rgb(0 0 0 / 0.5); } @theme inline { @@ -58,6 +65,7 @@ --color-warn: var(--warn); --color-danger: var(--danger); --color-quiet: var(--idle-state); + --shadow-lift: 0 12px 32px -8px var(--lift), 0 2px 8px -2px var(--lift); } @theme { @@ -121,6 +129,10 @@ margin-top: 0.6em; } + .chat-md > :first-child { + margin-top: 0; + } + .chat-md :is(h1, h2, h3, h4) { font-weight: 600; letter-spacing: -0.01em; @@ -160,7 +172,7 @@ font-size: 0.9em; background: var(--sunken); padding: 0.1em 0.35em; - border-radius: 3px; + border-radius: 5px; } .chat-md pre { @@ -169,8 +181,8 @@ line-height: 1.5; background: var(--sunken); border: 1px solid var(--line); - border-radius: 4px; - padding: 0.7em 0.9em; + border-radius: 10px; + padding: 0.75em 1em; overflow-x: auto; overflow-wrap: normal; } @@ -187,18 +199,31 @@ } .chat-md table { - border-collapse: collapse; + border-collapse: separate; + border-spacing: 0; display: block; + width: fit-content; + max-width: 100%; overflow-x: auto; font-size: 0.8125rem; + border: 1px solid var(--line); + border-radius: 10px; } .chat-md :is(th, td) { - border: 1px solid var(--line); - padding: 0.3em 0.6em; + border-bottom: 1px solid var(--line); + padding: 0.4em 0.75em; text-align: left; } + .chat-md :is(th, td) + :is(th, td) { + border-left: 1px solid var(--line); + } + + .chat-md tbody tr:last-child > td { + border-bottom: 0; + } + .chat-md th { background: var(--sunken); font-weight: 600; diff --git a/app/src/lib/fake.ts b/app/src/lib/fake.ts index c8d9a0b1..5492ed29 100644 --- a/app/src/lib/fake.ts +++ b/app/src/lib/fake.ts @@ -3,11 +3,12 @@ // handles, archiving, and the notifications each change sends. import type { BotloftApi } from "./api"; +import { botHandlers } from "./fakeBots"; import { FakeChat } from "./fakeChat"; import { FakeConversation } from "./fakeConversation"; -import { checkName, conflict, invalid, notFound, slugify } from "./fakeRules"; +import { crewHandlers } from "./fakeCrews"; +import { conflict, invalid, notFound, slugify } from "./fakeRules"; import { - AVATAR_PALETTE, type Bot, type BotId, type BotState, @@ -42,6 +43,10 @@ export class FakeBotloft implements BotloftApi { runtimeError: null, claudePath: "C:\\Users\\owner\\.local\\bin\\claude.exe", claudeSignedIn: true, + account: { + name: "Ana Lima", + claude: { email: "ana@example.com", plan: "max", organization: null }, + }, deliveries: { pending: 0, dead: 0 }, usage: null, }; @@ -138,7 +143,8 @@ export class FakeBotloft implements BotloftApi { return `${prefix}_${String(counter).padStart(4, "0")}`; } - private crew(crewId: CrewId, active = true): Crew { + /** The crew; archived ones only when `active` is false. */ + crew(crewId: CrewId, active = true): Crew { const crew = this.crews.get(crewId); if (!crew) { throw notFound(`crew ${crewId}`); @@ -161,23 +167,23 @@ export class FakeBotloft implements BotloftApi { return bot; } - private activeBots(crewId?: CrewId): Bot[] { + activeBots(crewId?: CrewId): Bot[] { return [...this.bots.values()].filter( (bot) => bot.archivedAt === null && (crewId === undefined || bot.crewId === crewId), ); } - private changedCrew(crew: Crew): Crew { + changedCrew(crew: Crew): Crew { this.emit({ name: "crew.changed", params: crew }); return crew; } - private changedBot(bot: Bot): Bot { + changedBot(bot: Bot): Bot { this.emit({ name: "bot.changed", params: bot }); return bot; } - private handle(name: string, crewId: CrewId, except?: BotId): string { + handle(name: string, crewId: CrewId, except?: BotId): string { const handle = slugify(name, "bot"); const taken = this.activeBots(crewId).some((bot) => bot.handle === handle && bot.id !== except); if (taken) { @@ -196,104 +202,8 @@ export class FakeBotloft implements BotloftApi { this.refreshes += 1; return this.system; }, - "crews.list": () => [...this.crews.values()].filter((crew) => crew.archivedAt === null), - "crews.create": ({ name }) => { - const checked = checkName(name); - const crew: Crew = { - id: this.id("crw"), - name: checked, - slug: slugify(checked, "crew"), - paused: false, - createdAt: this.now, - archivedAt: null, - }; - this.crews.set(crew.id, crew); - return this.changedCrew(crew); - }, - "crews.rename": ({ crewId, name }) => { - const crew = this.crew(crewId); - crew.name = checkName(name); - return this.changedCrew(crew); - }, - "crews.setPaused": ({ crewId, paused }) => { - const crew = this.crew(crewId); - crew.paused = paused; - return this.changedCrew(crew); - }, - "crews.archive": ({ crewId }) => { - const crew = this.crew(crewId, false); - if (crew.archivedAt === null) { - crew.archivedAt = this.now; - for (const bot of this.activeBots(crewId)) { - bot.archivedAt = this.now; - bot.state = "archived"; - this.changedBot(bot); - } - this.changedCrew(crew); - } - return crew; - }, - "bots.list": ({ crewId }) => { - if (crewId !== undefined) { - this.crew(crewId); - } - return this.activeBots(crewId); - }, - "bots.create": ({ crewId, name, role, instructions, color }) => { - const crew = this.crew(crewId); - const checked = checkName(name); - const handle = this.handle(checked, crewId); - const index = [...this.bots.values()].filter((bot) => bot.crewId === crewId).length; - const bot: Bot = { - id: this.id("bot"), - crewId, - name: checked, - handle, - slug: handle, - role: role.trim(), - instructions, - color: color ?? AVATAR_PALETTE[index % AVATAR_PALETTE.length] ?? "#FF7A59", - paused: false, - state: crew.paused ? "offline" : "launching", - generation: crew.paused ? null : 1, - workspace: `C:\\Users\\owner\\Botloft\\${crew.slug}\\${handle}`, - lastActivity: null, - createdAt: this.now, - archivedAt: null, - }; - this.bots.set(bot.id, bot); - return this.changedBot(bot); - }, - "bots.update": ({ botId, name, role, instructions, color }) => { - const bot = this.bot(botId); - if (name !== undefined) { - bot.name = checkName(name); - bot.handle = this.handle(bot.name, bot.crewId, botId); - } - bot.role = role?.trim() ?? bot.role; - bot.instructions = instructions ?? bot.instructions; - bot.color = color ?? bot.color; - return this.changedBot(bot); - }, - "bots.setPaused": ({ botId, paused }) => { - const bot = this.bot(botId); - bot.paused = paused; - return this.changedBot(bot); - }, - "bots.restart": ({ botId }) => { - const bot = this.bot(botId); - this.setBotState(botId, "launching", (bot.generation ?? 0) + 1); - return bot; - }, - "bots.archive": ({ botId }) => { - const bot = this.bot(botId, false); - if (bot.archivedAt === null) { - bot.archivedAt = this.now; - bot.state = "archived"; - this.changedBot(bot); - } - return bot; - }, + ...crewHandlers(this), + ...botHandlers(this), ...this.chat.handlers(), ...this.conversation.handlers(), }; diff --git a/app/src/lib/fakeBots.ts b/app/src/lib/fakeBots.ts new file mode 100644 index 00000000..914fa21b --- /dev/null +++ b/app/src/lib/fakeBots.ts @@ -0,0 +1,93 @@ +// The fake daemon's `bots.*` methods, following the daemon's rules for +// handles, colors, archiving and the notifications each change sends. + +import type { FakeBotloft, Handlers } from "./fake"; +import { checkName } from "./fakeRules"; +import { AVATAR_PALETTE, type Bot } from "./protocol.gen"; + +type BotMethods = Extract<keyof Handlers, `bots.${string}`>; + +export function botHandlers(fake: FakeBotloft): Pick<Handlers, BotMethods> { + return { + "bots.list": ({ crewId }) => { + if (crewId !== undefined) { + fake.crew(crewId); + } + return fake.activeBots(crewId); + }, + "bots.create": ({ crewId, name, role, instructions, color, model }) => { + const crew = fake.crew(crewId); + const checked = checkName(name); + const handle = fake.handle(checked, crewId); + const index = [...fake.bots.values()].filter((bot) => bot.crewId === crewId).length; + const bot: Bot = { + id: fake.id("bot"), + crewId, + name: checked, + handle, + slug: handle, + role: role.trim(), + instructions, + color: color ?? AVATAR_PALETTE[index % AVATAR_PALETTE.length] ?? "#FF7A59", + paused: false, + permissionMode: "default", + model: model ?? "default", + modelInUse: null, + state: crew.paused ? "offline" : "launching", + generation: crew.paused ? null : 1, + workspace: `C:\\Users\\owner\\Botloft\\${crew.slug}\\${handle}`, + lastActivity: null, + createdAt: fake.now, + archivedAt: null, + }; + fake.bots.set(bot.id, bot); + return fake.changedBot(bot); + }, + "bots.update": ({ botId, name, role, instructions, color }) => { + const bot = fake.bot(botId); + if (name !== undefined) { + bot.name = checkName(name); + bot.handle = fake.handle(bot.name, bot.crewId, botId); + } + bot.role = role?.trim() ?? bot.role; + bot.instructions = instructions ?? bot.instructions; + bot.color = color ?? bot.color; + return fake.changedBot(bot); + }, + "bots.setPaused": ({ botId, paused }) => { + const bot = fake.bot(botId); + bot.paused = paused; + return fake.changedBot(bot); + }, + "bots.setPermissionMode": ({ botId, mode }) => { + const bot = fake.bot(botId); + bot.permissionMode = mode; + return fake.changedBot(bot); + }, + "bots.setModel": ({ botId, model }) => { + const bot = fake.bot(botId); + bot.model = model; + return fake.changedBot(bot); + }, + "bots.restart": ({ botId }) => { + const bot = fake.bot(botId); + fake.setBotState(botId, "launching", (bot.generation ?? 0) + 1); + return bot; + }, + "bots.archive": ({ botId }) => { + const bot = fake.bot(botId, false); + if (bot.archivedAt === null) { + bot.archivedAt = fake.now; + bot.state = "archived"; + fake.changedBot(bot); + // An archived chief leaves its crew without one. + const crew = fake.crews.get(bot.crewId); + if (crew?.leadBotId === botId) { + crew.leadBotId = null; + fake.changedCrew(crew); + } + } + return bot; + }, + }; +} diff --git a/app/src/lib/fakeChat.ts b/app/src/lib/fakeChat.ts index db390b1d..0912bb7e 100644 --- a/app/src/lib/fakeChat.ts +++ b/app/src/lib/fakeChat.ts @@ -9,11 +9,15 @@ import type { Approval, ApprovalItem, BotId, + BotModel, ChatBody, ChatItem, ToolItem, } from "./protocol.gen"; +/** The chief's tool to suggest a bot (spec 10.2). */ +export const SUGGEST_TOOL = "mcp__botloft__suggest_bot"; + /** The conversation-list line for an item, like the daemon's (spec 8.3). */ export function activityLine(body: ChatBody): { kind: ActivityKind; text: string } | null { const label = (name: string) => name.split("__").at(-1) ?? name; @@ -138,7 +142,7 @@ export class FakeChat { .reverse() .slice(0, limit ?? 50); }, - "approvals.answer": ({ approvalId, allow, note }) => { + "approvals.answer": ({ approvalId, allow, note, input }) => { const approval = this.approvals.get(approvalId); if (!approval) { throw notFound(`approval ${approvalId}`); @@ -149,12 +153,41 @@ export class FakeChat { approval.status = allow ? "allowed" : "denied"; approval.note = allow ? null : (note ?? null); approval.answeredAt = this.fake.now; + // Claude Code leaves plan mode once the plan is approved. + const bot = this.fake.bots.get(approval.botId); + if (allow && approval.toolName === "ExitPlanMode" && bot?.permissionMode === "plan") { + void this.fake.call("bots.setPermissionMode", { botId: bot.id, mode: "default" }); + } + // An allowed suggestion becomes a bot, as the owner left it. + if (allow && approval.toolName === SUGGEST_TOOL && bot) { + if (input !== undefined) { + approval.input = input; + } + const { name, role, instructions, model } = JSON.parse(approval.input) as { + name: string; + role: string; + instructions: string; + model?: BotModel; + }; + void this.fake.call("bots.create", { + crewId: bot.crewId, + name, + role, + instructions, + ...(model && { model }), + }); + } const item = this.items.find( (entry) => entry.body.kind === "approval" && entry.body.approvalId === approvalId, ); if (item) { const body = item.body as { kind: "approval" } & ApprovalItem; - this.update(item.id, { ...body, status: approval.status, note: approval.note }); + this.update(item.id, { + ...body, + input: approval.input, + status: approval.status, + note: approval.note, + }); } return approval; }, diff --git a/app/src/lib/fakeCrews.ts b/app/src/lib/fakeCrews.ts new file mode 100644 index 00000000..72706174 --- /dev/null +++ b/app/src/lib/fakeCrews.ts @@ -0,0 +1,85 @@ +// The fake daemon's `crews.*` methods: names, slugs, the work folder, +// pausing and archiving, with the notifications each change sends. + +import type { FakeBotloft, Handlers } from "./fake"; +import { botHandlers } from "./fakeBots"; +import { checkName, invalid, slugify } from "./fakeRules"; +import type { Crew } from "./protocol.gen"; + +type CrewMethods = Extract<keyof Handlers, `crews.${string}`>; + +/** The crew's `shared` folder, where it works unless the owner chose another. */ +const sharedFolder = (slug: string) => `C:\\Users\\owner\\Botloft\\${slug}\\shared`; + +function checkFolder(folder: string): string { + if (!/^[A-Za-z]:\\./.test(folder)) { + throw invalid("the work folder must be a full path, like C:\\Projects\\Site"); + } + return folder; +} + +export function crewHandlers(fake: FakeBotloft): Pick<Handlers, CrewMethods> { + return { + "crews.list": () => [...fake.crews.values()].filter((crew) => crew.archivedAt === null), + "crews.create": ({ name, workFolder, lead }) => { + const checked = checkName(name); + const slug = slugify(checked, "crew"); + const crew: Crew = { + id: fake.id("crw"), + name: checked, + slug, + workFolder: workFolder === undefined ? sharedFolder(slug) : checkFolder(workFolder), + workFolderChosen: workFolder !== undefined, + leadBotId: null, + paused: false, + createdAt: fake.now, + archivedAt: null, + }; + fake.crews.set(crew.id, crew); + fake.changedCrew(crew); + if (lead) { + const chief = botHandlers(fake)["bots.create"]({ crewId: crew.id, ...lead }); + crew.leadBotId = chief.id; + fake.changedCrew(crew); + } + return crew; + }, + "crews.setLead": ({ crewId, botId }) => { + const crew = fake.crew(crewId); + if (botId !== null && fake.bot(botId).crewId !== crewId) { + throw invalid(`bot ${botId} is not in crew ${crewId}`); + } + crew.leadBotId = botId; + return fake.changedCrew(crew); + }, + "crews.rename": ({ crewId, name }) => { + const crew = fake.crew(crewId); + crew.name = checkName(name); + return fake.changedCrew(crew); + }, + "crews.setPaused": ({ crewId, paused }) => { + const crew = fake.crew(crewId); + crew.paused = paused; + return fake.changedCrew(crew); + }, + "crews.setWorkFolder": ({ crewId, workFolder }) => { + const crew = fake.crew(crewId); + crew.workFolder = workFolder === null ? sharedFolder(crew.slug) : checkFolder(workFolder); + crew.workFolderChosen = workFolder !== null; + return fake.changedCrew(crew); + }, + "crews.archive": ({ crewId }) => { + const crew = fake.crew(crewId, false); + if (crew.archivedAt === null) { + crew.archivedAt = fake.now; + for (const bot of fake.activeBots(crewId)) { + bot.archivedAt = fake.now; + bot.state = "archived"; + fake.changedBot(bot); + } + fake.changedCrew(crew); + } + return crew; + }, + }; +} diff --git a/app/src/lib/fakeHost.ts b/app/src/lib/fakeHost.ts index f4190df1..957b18d4 100644 --- a/app/src/lib/fakeHost.ts +++ b/app/src/lib/fakeHost.ts @@ -23,6 +23,10 @@ export class FakeHost implements Host { afterInstall: DaemonStatus | Error = running(); token: string | Error = "a".repeat(64); readonly opened: string[] = []; + /** What the folder picker gives back; null is a cancel. */ + nextFolder: string | null = null; + /** Where each folder picker started. */ + readonly pickerStarts: (string | null)[] = []; readonly installs: ("install" | "restart")[] = []; /** Paths `signInToClaude` ran, and what it answers. */ readonly signIns: string[] = []; @@ -32,6 +36,8 @@ export class FakeHost implements Host { /** What `checkForUpdate` finds, or its error. */ update: AppUpdate | null | Error = null; updateChecks = 0; + /** The window's size, as the app last set it. */ + zoom = 1; maximized = false; closed = false; attention = false; @@ -57,6 +63,11 @@ export class FakeHost implements Host { return Promise.resolve(this.signInResult); } + setZoom(factor: number): Promise<void> { + this.zoom = factor; + return Promise.resolve(); + } + checkForUpdate(): Promise<AppUpdate | null> { this.updateChecks += 1; return this.update instanceof Error @@ -82,6 +93,11 @@ export class FakeHost implements Host { return Promise.resolve(); } + pickFolder(_title: string, start?: string): Promise<string | null> { + this.pickerStarts.push(start ?? null); + return Promise.resolve(this.nextFolder); + } + openUrl(url: string): Promise<void> { this.opened.push(url); return Promise.resolve(); diff --git a/app/src/lib/host.ts b/app/src/lib/host.ts index 2c9b3150..c41b33b0 100644 --- a/app/src/lib/host.ts +++ b/app/src/lib/host.ts @@ -57,11 +57,18 @@ export interface Host { * waits for it to end. Resolves whether it signed in. */ signInToClaude(claudePath: string): Promise<boolean>; + /** Draws the whole window at `factor` times its size (1 = 100%). */ + setZoom(factor: number): Promise<void>; /** A newer version of the app, or null when this one is the latest. */ checkForUpdate(): Promise<AppUpdate | null>; readOwnerToken(): Promise<string>; /** Opens a folder in Explorer. */ openPath(path: string): Promise<void>; + /** + * Asks the owner for a folder with Windows' folder picker, starting at + * `start` if given. Resolves null if they cancel. + */ + pickFolder(title: string, start?: string): Promise<string | null>; /** Opens an http(s) link in the default browser. */ openUrl(url: string): Promise<void>; window: AppWindow; diff --git a/app/src/lib/models.test.ts b/app/src/lib/models.test.ts new file mode 100644 index 00000000..b1777f26 --- /dev/null +++ b/app/src/lib/models.test.ts @@ -0,0 +1,17 @@ +import { describe, expect, test } from "vitest"; +import { modelFamily, modelName } from "./models"; + +describe("model names", () => { + test("Claude ids read as their family and version", () => { + expect(modelName("claude-opus-5-5")).toBe("Opus 5.5"); + expect(modelName("claude-haiku-4-5-20251001")).toBe("Haiku 4.5"); + expect(modelName("claude-fable-5-1")).toBe("Fable 5.1"); + expect(modelName("claude-sonnet-5")).toBe("Sonnet 5"); + expect(modelFamily("claude-sonnet-5-5")).toBe("sonnet"); + }); + + test("other ids stay as they are", () => { + expect(modelName("gpt-oss")).toBe("gpt-oss"); + expect(modelFamily("claude-opus-5-5[1m]")).toBeNull(); + }); +}); diff --git a/app/src/lib/models.ts b/app/src/lib/models.ts new file mode 100644 index 00000000..78f72bb4 --- /dev/null +++ b/app/src/lib/models.ts @@ -0,0 +1,19 @@ +// Names for the Claude model ids Claude Code reports (spec 7.4). + +const FAMILY = /^claude-(fable|opus|sonnet|haiku)-(\d+)(?:-(\d{1,2}))?(?:-\d{8})?$/; + +/** "claude-opus-5-5" -> "Opus 5.5"; an id it does not know stays as it is. */ +export function modelName(id: string): string { + const match = FAMILY.exec(id); + if (!match) { + return id; + } + const [, family = "", major, minor] = match; + const name = family.charAt(0).toUpperCase() + family.slice(1); + return minor === undefined ? `${name} ${major}` : `${name} ${major}.${minor}`; +} + +/** The family of a model id ("opus"), if it is one of Claude's. */ +export function modelFamily(id: string): string | null { + return FAMILY.exec(id)?.[1] ?? null; +} diff --git a/app/src/lib/protocol.gen.ts b/app/src/lib/protocol.gen.ts index 9fb5ac0c..bf236f1f 100644 --- a/app/src/lib/protocol.gen.ts +++ b/app/src/lib/protocol.gen.ts @@ -62,7 +62,21 @@ export type Crew = { id: CrewId, name: string, /** * Folder name under the workspaces root. Set at creation, never changes. */ -slug: string, paused: boolean, +slug: string, +/** + * Absolute path of the folder the crew works in (spec 5): one the owner + * chose, or the crew's `shared` folder. + */ +workFolder: string, +/** + * Whether the owner chose `work_folder`. + */ +workFolderChosen: boolean, +/** + * The bot that leads the crew and may suggest new bots (spec 10.2); + * `null` when the crew has no chief. + */ +leadBotId: BotId | null, paused: boolean, /** * Unix time in milliseconds. */ @@ -77,6 +91,18 @@ archivedAt: number | null, }; */ export type BotState = "offline" | "launching" | "idle" | "busy" | "needs_approval" | "rate_limited" | "auth_error" | "backoff" | "archived"; +/** + * How much a bot may do without asking the owner: Claude Code's + * permission modes (spec 7.4). + */ +export type PermissionMode = "default" | "accept_edits" | "plan" | "auto" | "bypass_permissions"; + +/** + * Which Claude model a bot runs on (spec 7.4): Claude Code's `--model` + * aliases, or the account's default. + */ +export type BotModel = "default" | "fable" | "opus" | "sonnet" | "haiku"; + /** * What the conversation-list line shows; the app words it. */ @@ -111,7 +137,12 @@ slug: string, role: string, instructions: string, /** * Avatar color, `#RRGGBB`. */ -color: string, paused: boolean, state: BotState, +color: string, paused: boolean, permissionMode: PermissionMode, model: BotModel, +/** + * The model id Claude Code reported when the bot last started a turn + * (`claude-opus-5-5`); `null` before its first turn. + */ +modelInUse: string | null, state: BotState, /** * Current process generation; `null` if the bot has not started since * the daemon did. Changes on every (re)start. @@ -190,6 +221,29 @@ resetsAt: number | null, windows: Array<UsageWindow>, */ observedAt: number, }; +/** + * What `claude auth status` says about the account (spec 7.3). + */ +export type ClaudeAccount = { email: string | null, +/** + * As Claude Code says it: `max`, `pro`, `team`, `enterprise`... + */ +plan: string | null, organization: string | null, }; + +/** + * The owner, as the app shows them in its account area (spec 15.1). + */ +export type OwnerAccount = { +/** + * The Windows account's display name, or the user name without one. + */ +name: string, +/** + * The Claude account Claude Code is signed in to; `null` when signed out + * or not checked yet. + */ +claude: ClaudeAccount | null, }; + export type SystemStatus = { daemonVersion: string, protocol: number, uptimeMs: number, /** * Version reported by `claude --version`; `null` until the runtime probe runs. @@ -206,18 +260,49 @@ claudePath: string | null, /** * Whether Claude Code is signed in (`claude auth status`); `null` until checked. */ -claudeSignedIn: boolean | null, deliveries: DeliveryBacklog, +claudeSignedIn: boolean | null, +/** + * Who the owner is, for the account area of the app. + */ +account: OwnerAccount, deliveries: DeliveryBacklog, /** * The Claude account's usage as last reported; `null` before any turn. */ usage: AccountUsage | null, }; -export type CrewsCreateParams = { name: string, }; +export type CrewsCreateParams = { name: string, +/** + * Absolute path of the folder the crew works in; the crew's `shared` + * folder when absent. + */ +workFolder?: string, +/** + * The chief, created with the crew (spec 10.2). + */ +lead?: NewLead, }; export type CrewsRenameParams = { crewId: CrewId, name: string, }; export type CrewsSetPausedParams = { crewId: CrewId, paused: boolean, }; +export type CrewsSetWorkFolderParams = { crewId: CrewId, +/** + * `null` goes back to the crew's `shared` folder. + */ +workFolder: string | null, }; + +/** + * The bot that leads a new crew. The app writes its name and role in the + * owner's language; the instructions carry the crew's goal. + */ +export type NewLead = { name: string, role: string, instructions: string, model?: BotModel, }; + +export type CrewsSetLeadParams = { crewId: CrewId, +/** + * `null` leaves the crew without a chief. + */ +botId: BotId | null, }; + export type CrewIdParams = { crewId: CrewId, }; export type BotsListParams = { @@ -230,7 +315,11 @@ export type BotsCreateParams = { crewId: CrewId, name: string, role: string, ins /** * Avatar color `#RRGGBB`; the next palette color when absent. */ -color?: string, }; +color?: string, +/** + * The account's default when absent. + */ +model?: BotModel, }; /** * Fields left out stay unchanged. @@ -239,6 +328,10 @@ export type BotsUpdateParams = { botId: BotId, name?: string, role?: string, ins export type BotsSetPausedParams = { botId: BotId, paused: boolean, }; +export type BotsSetPermissionModeParams = { botId: BotId, mode: PermissionMode, }; + +export type BotsSetModelParams = { botId: BotId, model: BotModel, }; + export type BotIdParams = { botId: BotId, }; export type BotsRestartParams = { botId: BotId, @@ -427,7 +520,7 @@ export type NoticeLevel = "info" | "warning" | "error"; /** * What a notice is about, so the app can say it in the owner's language. */ -export type NoticeCode = "signed_out" | "usage_limit" | "turn_failed"; +export type NoticeCode = "signed_out" | "usage_limit" | "turn_failed" | "model_unavailable"; export type InboundItem = { message: Message, }; @@ -532,7 +625,12 @@ export type ApprovalsAnswerParams = { approvalId: ApprovalId, allow: boolean, /** * Passed to the bot with a denial. */ -note?: string, }; +note?: string, +/** + * A bot suggestion as the owner changed it before allowing it, in the + * JSON of the tool's input (spec 10.2). Ignored for other requests. + */ +input?: string, }; /** Params and result of every request method. */ export interface RpcMethods { @@ -543,11 +641,15 @@ export interface RpcMethods { "crews.create": { params: CrewsCreateParams; result: Crew }; "crews.rename": { params: CrewsRenameParams; result: Crew }; "crews.setPaused": { params: CrewsSetPausedParams; result: Crew }; + "crews.setWorkFolder": { params: CrewsSetWorkFolderParams; result: Crew }; + "crews.setLead": { params: CrewsSetLeadParams; result: Crew }; "crews.archive": { params: CrewIdParams; result: Crew }; "bots.list": { params: BotsListParams; result: Array<Bot> }; "bots.create": { params: BotsCreateParams; result: Bot }; "bots.update": { params: BotsUpdateParams; result: Bot }; "bots.setPaused": { params: BotsSetPausedParams; result: Bot }; + "bots.setPermissionMode": { params: BotsSetPermissionModeParams; result: Bot }; + "bots.setModel": { params: BotsSetModelParams; result: Bot }; "bots.archive": { params: BotIdParams; result: Bot }; "bots.restart": { params: BotsRestartParams; result: Bot }; "chat.history": { params: ChatHistoryParams; result: Array<ChatItem> }; diff --git a/app/src/lib/tauriHost.ts b/app/src/lib/tauriHost.ts index b3630472..8c61491a 100644 --- a/app/src/lib/tauriHost.ts +++ b/app/src/lib/tauriHost.ts @@ -2,7 +2,9 @@ import { invoke } from "@tauri-apps/api/core"; import { Image } from "@tauri-apps/api/image"; +import { getCurrentWebview } from "@tauri-apps/api/webview"; import { getCurrentWindow } from "@tauri-apps/api/window"; +import { open } from "@tauri-apps/plugin-dialog"; import { check } from "@tauri-apps/plugin-updater"; import type { AppUpdate, DaemonStatus, Host } from "./host"; @@ -70,9 +72,19 @@ export function tauriHost(): Host { installDaemon: () => invoke<DaemonStatus>("daemon_install"), restartDaemon: () => invoke<DaemonStatus>("daemon_restart"), signInToClaude: (path) => invoke<boolean>("claude_sign_in", { path }), + setZoom: (factor) => getCurrentWebview().setZoom(factor), checkForUpdate, readOwnerToken: () => invoke<string>("read_owner_token"), openPath: (path) => invoke<void>("open_path", { path }), + pickFolder: async (title, start) => { + const picked = await open({ + directory: true, + multiple: false, + title, + ...(start ? { defaultPath: start } : {}), + }); + return typeof picked === "string" ? picked : null; + }, openUrl: (url) => invoke<void>("open_url", { url }), window: { minimize: () => window.minimize(), diff --git a/app/src/main.tsx b/app/src/main.tsx index 3b1f9880..76bde7fa 100644 --- a/app/src/main.tsx +++ b/app/src/main.tsx @@ -6,6 +6,7 @@ import type { Connect } from "./features/onboarding/link"; import { connect, rpcUrl } from "./lib/client"; import type { Host } from "./lib/host"; import { tauriHost } from "./lib/tauriHost"; +import { currentZoom } from "./shell/zoom"; import "./index.css"; const root = document.getElementById("root"); @@ -28,10 +29,12 @@ async function props(): Promise<{ host: Host; connect: Connect }> { throw new Error("Botloft runs inside its desktop app"); } -props().then(({ host, connect: open }) => +props().then(({ host, connect: open }) => { + // Before the first paint, so the window never flashes at the small size. + host.setZoom(currentZoom()).catch(() => {}); createRoot(root).render( <StrictMode> <App host={host} connect={open} /> </StrictMode>, - ), -); + ); +}); diff --git a/app/src/motion.css b/app/src/motion.css new file mode 100644 index 00000000..b72ad6b5 --- /dev/null +++ b/app/src/motion.css @@ -0,0 +1,283 @@ +/* Motion (spec 15.3): short and calm, so the app feels alive without + getting in the way. Everything stops when Windows turns animations off + (prefers-reduced-motion). */ + +:root { + --ease-out: cubic-bezier(0.2, 0.8, 0.2, 1); + --ease-spring: cubic-bezier(0.34, 1.45, 0.64, 1); + /* Lets heights animate to and from `auto` (details, collapsing rows). */ + interpolate-size: allow-keywords; +} + +@theme { + /* Something new in a list: a message, a tool call, a bot. */ + --animate-rise: rise 300ms var(--ease-out) both; + /* A menu or a dialog opening. */ + --animate-pop: pop 170ms var(--ease-out) both; + --animate-fade: fade 180ms ease-out both; + /* A notice sliding in from the side. */ + --animate-toast: toast 380ms var(--ease-spring) both; + /* The three dots of a bot thinking. */ + --animate-dot: dot 1.3s ease-in-out infinite; + /* A request that waits for the owner: one ring, once. */ + --animate-attention: attention 1.4s var(--ease-out) 1 both; + /* The hand of "needs approval", waving now and then. */ + --animate-wave: wave 2.4s ease-in-out infinite; + /* A gauge filling up. */ + --animate-grow: grow 800ms var(--ease-out) both; + /* A mascot floating on an empty page. */ + --animate-float: float 4s ease-in-out infinite; + + @keyframes rise { + from { + opacity: 0; + transform: translateY(10px); + } + } + + @keyframes pop { + from { + opacity: 0; + transform: scale(0.96) translateY(4px); + } + } + + @keyframes fade { + from { + opacity: 0; + } + } + + @keyframes toast { + from { + opacity: 0; + transform: translateX(28px) scale(0.98); + } + } + + @keyframes dot { + 0%, + 60%, + 100% { + transform: translateY(0); + opacity: 0.4; + } + 30% { + transform: translateY(-4px); + opacity: 1; + } + } + + @keyframes attention { + 0% { + box-shadow: 0 0 0 0 color-mix(in srgb, var(--warn) 40%, transparent); + } + 100% { + box-shadow: 0 0 0 14px color-mix(in srgb, var(--warn) 0%, transparent); + } + } + + @keyframes wave { + 0%, + 50%, + 100% { + transform: rotate(0); + } + 10%, + 30% { + transform: rotate(16deg); + } + 20%, + 40% { + transform: rotate(-10deg); + } + } + + @keyframes grow { + from { + transform: scaleX(0); + } + } + + @keyframes float { + 0%, + 100% { + transform: translateY(0); + } + 50% { + transform: translateY(-6px); + } + } +} + +@layer components { + /* The mascot (features/bots/BotAvatar.tsx). Its mood follows what the + bot does: it blinks, flickers while it works, hops while it waits for + the owner, and sleeps while paused. The state still has its own icon + and label. */ + .avatar-flame, + .avatar-eye { + transform-box: fill-box; + } + + .avatar-flame { + transform-origin: 50% 100%; + } + + .avatar-eye { + transform-origin: 50% 55%; + transition: transform 400ms var(--ease-out); + } + + [data-mood] .avatar-eye { + animation: blink 7s infinite; + animation-delay: var(--blink-delay, 0s); + } + + [data-mood="working"] .avatar-flame { + animation: flicker 1.5s ease-in-out infinite; + animation-delay: var(--blink-delay, 0s); + } + + [data-mood="waiting"] .avatar-flame { + animation: hop 2.6s var(--ease-out) infinite; + } + + [data-mood="sleeping"] .avatar-eye { + animation: none; + transform: scaleY(0.12); + } + + [data-mood="tired"] .avatar-eye { + animation: none; + transform: scaleY(0.45); + } + + /* Text still being written: a caret after the last line. */ + .chat-md.is-streaming > :is(p, h1, h2, h3, h4):last-child::after, + .chat-md.is-streaming > :is(ul, ol):last-child > li:last-child::after { + content: ""; + display: inline-block; + width: 0.5em; + height: 1.05em; + margin-left: 0.2em; + vertical-align: -0.2em; + border-radius: 2px; + background: var(--accent); + animation: caret 1.1s steps(2, jump-none) infinite; + } + + /* Opening and closing a <details> slides instead of jumping. */ + details::details-content { + block-size: 0; + overflow-y: clip; + transition: + block-size 240ms var(--ease-out), + content-visibility 240ms allow-discrete; + } + + details[open]::details-content { + block-size: auto; + } +} + +@keyframes blink { + 0%, + 45%, + 49%, + 100% { + transform: scaleY(1); + } + 47% { + transform: scaleY(0.1); + } +} + +@keyframes flicker { + 0%, + 100% { + transform: scale(1, 1) skewX(0deg); + } + 25% { + transform: scale(0.97, 1.04) skewX(-2deg); + } + 50% { + transform: scale(1.02, 0.98) skewX(1.5deg); + } + 75% { + transform: scale(0.99, 1.03) skewX(-1deg); + } +} + +@keyframes hop { + 0%, + 45%, + 100% { + transform: translateY(0) scale(1, 1); + } + 10% { + transform: translateY(0) scale(1.08, 0.92); + } + 22% { + transform: translateY(-12%) scale(0.96, 1.05); + } + 34% { + transform: translateY(0) scale(1.05, 0.95); + } +} + +@keyframes caret { + 0% { + opacity: 1; + } + 100% { + opacity: 0; + } +} + +/* Switching bots or crews: the main pane fades out and the new one rises + in; the rest of the window stays put (ui/motion.ts). */ +::view-transition-old(root), +::view-transition-new(root) { + animation: none; +} + +::view-transition-old(main-pane) { + animation: 110ms ease-out both view-out; +} + +::view-transition-new(main-pane) { + animation: 240ms var(--ease-out) both view-in; +} + +@keyframes view-out { + to { + opacity: 0; + } +} + +@keyframes view-in { + from { + opacity: 0; + transform: translateY(8px); + } +} + +/* biome-ignore-start lint/complexity/noImportantStyles: less motion must win over every animation, inline delays included */ +@media (prefers-reduced-motion: reduce) { + *, + *::before, + *::after, + ::details-content { + animation-duration: 0.01ms !important; + animation-iteration-count: 1 !important; + transition-duration: 0.01ms !important; + } + + ::view-transition-group(*), + ::view-transition-old(*), + ::view-transition-new(*) { + animation: none !important; + } +} +/* biome-ignore-end lint/complexity/noImportantStyles: less motion must win over every animation, inline delays included */ diff --git a/app/src/shell/TitleBar.tsx b/app/src/shell/TitleBar.tsx index 61874ef6..52bff414 100644 --- a/app/src/shell/TitleBar.tsx +++ b/app/src/shell/TitleBar.tsx @@ -1,33 +1,31 @@ // The window's own title bar (spec 15.3: `decorations: false`), with the -// Windows controls on the right. Empty space drags the window. +// Windows controls on the right. Empty space drags the window. Theme, size +// and language live in the account area of the sidebar (spec 15.1). -import { Copy, Languages, Minus, Monitor, Moon, Square, Sun, X } from "lucide-react"; +import { Copy, Languages, Minus, Square, X } from "lucide-react"; import { type ReactNode, useEffect, useState } from "react"; import { BotAvatar } from "../features/bots/BotAvatar"; import { LOCALES, setLocaleChoice, systemLocale, useLocale, useT } from "../i18n"; import { useHost } from "../store/context"; import { Menu } from "../ui/Menu"; -import { setTheme, type ThemeChoice, useTheme } from "./theme"; -const NEXT_THEME: Record<ThemeChoice, ThemeChoice> = { - system: "light", - light: "dark", - dark: "system", -}; -const THEME_ICON = { system: Monitor, light: Sun, dark: Moon }; - -export function TitleBar({ children, status }: { children?: ReactNode; status?: ReactNode }) { - const t = useT(); - const { choice } = useTheme(); - const ThemeIcon = THEME_ICON[choice]; - const themeName = t.shell.theme[choice]; +export function TitleBar({ + children, + status, + language = false, +}: { + children?: ReactNode; + status?: ReactNode; + /** Shows the language menu, for the setup screens that have no sidebar. */ + language?: boolean; +}) { return ( <header data-tauri-drag-region className="flex h-9 shrink-0 items-center border-line border-b bg-panel" > <div data-tauri-drag-region className="flex items-center gap-2 pr-4 pl-3"> - <BotAvatar color="#ffffff" size={18} /> + <BotAvatar color="#ffffff" size={18} framed /> <span data-tauri-drag-region className="font-semibold text-sm tracking-tight"> Botloft </span> @@ -37,16 +35,7 @@ export function TitleBar({ children, status }: { children?: ReactNode; status?: </div> <div className="flex items-center gap-1 pr-2"> {status} - <LanguageMenu /> - <button - type="button" - aria-label={t.shell.theme.label(themeName)} - title={t.shell.theme.hint(themeName)} - onClick={() => setTheme(NEXT_THEME[choice])} - className="grid h-7 w-7 place-items-center text-muted hover:bg-sunken hover:text-ink" - > - <ThemeIcon aria-hidden size={14} /> - </button> + {language && <LanguageMenu />} </div> <WindowControls /> </header> diff --git a/app/src/shell/Workspace.tsx b/app/src/shell/Workspace.tsx index 4bf49ca5..bef1788d 100644 --- a/app/src/shell/Workspace.tsx +++ b/app/src/shell/Workspace.tsx @@ -39,12 +39,18 @@ export function Workspace() { } else if (!loaded) { main = null; } else if (!hasCrews) { - main = <Welcome />; + // The sidebar stays, with the account area, before the first crew too. + main = ( + <div className="flex min-h-0 flex-1"> + <Sidebar /> + <Welcome /> + </div> + ); } else { main = ( <div className="flex min-h-0 flex-1"> <Sidebar /> - <main className="flex min-w-0 flex-1 flex-col"> + <main className="flex min-w-0 flex-1 flex-col [view-transition-name:main-pane]"> {runtimeError ? ( <div className="border-line border-b p-3"> <Callout tone="danger" title={t.shell.botsCantStart}> diff --git a/app/src/shell/zoom.test.tsx b/app/src/shell/zoom.test.tsx new file mode 100644 index 00000000..f9c611bb --- /dev/null +++ b/app/src/shell/zoom.test.tsx @@ -0,0 +1,67 @@ +import { cleanup, fireEvent, render, screen, waitFor, within } from "@testing-library/react"; +import { afterEach, describe, expect, test } from "vitest"; +import { App } from "../App"; +import type { Client } from "../lib/client"; +import { FakeBotloft } from "../lib/fake"; +import { FakeHost } from "../lib/fakeHost"; +import { currentZoom, DEFAULT_ZOOM, setZoom, stepZoom } from "./zoom"; + +afterEach(() => { + cleanup(); + setZoom(DEFAULT_ZOOM); +}); + +function renderApp() { + const host = new FakeHost(); + render(<App host={host} connect={() => new FakeBotloft() as Client} />); + return host; +} + +const key = (options: KeyboardEventInit) => fireEvent.keyDown(window, options); + +describe("app size", () => { + test("the app opens at the default size, bigger than the compact one", async () => { + const host = renderApp(); + await screen.findByRole("heading", { name: "Welcome to Botloft" }); + expect(DEFAULT_ZOOM).toBe(1.25); + expect(host.zoom).toBe(1.25); + }); + + test("settings set the size and remember it", async () => { + const host = renderApp(); + await screen.findByRole("heading", { name: "Welcome to Botloft" }); + fireEvent.click(screen.getByRole("button", { name: /Ana Lima/ })); + fireEvent.click(screen.getByRole("menuitem", { name: "Settings" })); + const sizes = screen.getByRole("radiogroup", { name: "Size" }); + expect( + (within(sizes).getByRole("radio", { name: "125% (default)" }) as HTMLInputElement).checked, + ).toBe(true); + fireEvent.click(within(sizes).getByRole("radio", { name: "150%" })); + await waitFor(() => expect(host.zoom).toBe(1.5)); + expect(localStorage.getItem("botloft.zoom")).toBe("1.5"); + }); + + test("Ctrl+= and Ctrl+- step through the sizes and Ctrl+0 goes back", async () => { + const host = renderApp(); + await screen.findByRole("heading", { name: "Welcome to Botloft" }); + key({ key: "=", ctrlKey: true }); + await waitFor(() => expect(host.zoom).toBe(1.5)); + key({ key: "-", ctrlKey: true }); + key({ key: "-", ctrlKey: true }); + key({ key: "-", ctrlKey: true }); + await waitFor(() => expect(host.zoom).toBe(1)); + key({ key: "0", ctrlKey: true }); + await waitFor(() => expect(host.zoom).toBe(1.25)); + key({ key: "=" }); + expect(currentZoom()).toBe(1.25); + }); + + test("the size stays within the levels", () => { + setZoom(1.5); + stepZoom(1); + expect(currentZoom()).toBe(1.5); + setZoom(1); + stepZoom(-1); + expect(currentZoom()).toBe(1); + }); +}); diff --git a/app/src/shell/zoom.ts b/app/src/shell/zoom.ts new file mode 100644 index 00000000..a3c04658 --- /dev/null +++ b/app/src/shell/zoom.ts @@ -0,0 +1,88 @@ +// How big the app is drawn (spec 15.3). The whole window scales, text, +// spacing and icons alike, like zooming a browser. 100% is the compact +// size the app was first drawn at; 125% is the default. Ctrl+= and Ctrl+- +// step through the levels and Ctrl+0 goes back to the default. The choice +// is a per-machine convenience kept in localStorage. + +import { useEffect, useSyncExternalStore } from "react"; +import type { Host } from "../lib/host"; + +export const ZOOM_LEVELS = [1, 1.1, 1.25, 1.5] as const; +export type ZoomLevel = (typeof ZOOM_LEVELS)[number]; +export const DEFAULT_ZOOM: ZoomLevel = 1.25; + +const KEY = "botloft.zoom"; +const listeners = new Set<() => void>(); + +function stored(): ZoomLevel { + try { + const value = Number(localStorage.getItem(KEY)); + return ZOOM_LEVELS.find((level) => level === value) ?? DEFAULT_ZOOM; + } catch { + return DEFAULT_ZOOM; + } +} + +let zoom: ZoomLevel = stored(); + +export function currentZoom(): ZoomLevel { + return zoom; +} + +export function setZoom(next: ZoomLevel): void { + zoom = next; + try { + localStorage.setItem(KEY, String(next)); + } catch { + // Private storage off: the choice lasts for this window. + } + for (const listener of listeners) { + listener(); + } +} + +/** One level bigger (1) or smaller (-1), staying within the levels. */ +export function stepZoom(direction: 1 | -1): void { + const index = ZOOM_LEVELS.indexOf(zoom) + direction; + const next = ZOOM_LEVELS[Math.min(ZOOM_LEVELS.length - 1, Math.max(0, index))]; + if (next !== undefined) { + setZoom(next); + } +} + +function subscribe(listener: () => void): () => void { + listeners.add(listener); + return () => listeners.delete(listener); +} + +export function useZoom(): ZoomLevel { + return useSyncExternalStore(subscribe, () => zoom); +} + +/** Draws the window at the chosen size and handles the zoom shortcuts. */ +export function useZoomRoot(host: Host): void { + const level = useZoom(); + useEffect(() => { + host.setZoom(level).catch(() => {}); + }, [host, level]); + + useEffect(() => { + const onKey = (event: KeyboardEvent) => { + if (!event.ctrlKey || event.altKey || event.metaKey) { + return; + } + if (event.key === "=" || event.key === "+") { + stepZoom(1); + } else if (event.key === "-") { + stepZoom(-1); + } else if (event.key === "0") { + setZoom(DEFAULT_ZOOM); + } else { + return; + } + event.preventDefault(); + }; + window.addEventListener("keydown", onKey); + return () => window.removeEventListener("keydown", onKey); + }, []); +} diff --git a/app/src/store/app.ts b/app/src/store/app.ts index b1ccb270..1ab7f709 100644 --- a/app/src/store/app.ts +++ b/app/src/store/app.ts @@ -15,6 +15,7 @@ import type { Task, TaskId, } from "../lib/protocol.gen"; +import { viewTransition } from "../ui/motion"; export interface AppState { connection: ConnectionState; @@ -80,11 +81,16 @@ export function createAppStore(api: BotloftApi): AppStore { tasks: {}, selectedCrewId: null, selectedBotId: null, - selectCrew: (crewId) => set({ selectedCrewId: crewId, selectedBotId: null }), + selectCrew: (crewId) => { + const { selectedCrewId, selectedBotId } = get(); + if (selectedCrewId !== crewId || selectedBotId !== null) { + viewTransition(() => set({ selectedCrewId: crewId, selectedBotId: null })); + } + }, selectBot: (botId) => { const bot = get().bots[botId]; - if (bot) { - set({ selectedCrewId: bot.crewId, selectedBotId: botId }); + if (bot && get().selectedBotId !== botId) { + viewTransition(() => set({ selectedCrewId: bot.crewId, selectedBotId: botId })); } }, putCrew: (crew) => set((state) => withCrew(state, crew)), diff --git a/app/src/ui/Button.tsx b/app/src/ui/Button.tsx index 58644b1f..c354a95a 100644 --- a/app/src/ui/Button.tsx +++ b/app/src/ui/Button.tsx @@ -35,7 +35,7 @@ export function Button({ type={type} aria-label={label} title={label} - className={`inline-flex shrink-0 items-center justify-center gap-1.5 rounded-[3px] font-medium transition-colors disabled:pointer-events-none disabled:opacity-45 ${height} ${padding} ${variants[variant]} ${className}`} + className={`inline-flex shrink-0 items-center justify-center gap-1.5 rounded-lg font-medium transition-[color,background-color,border-color,transform] duration-150 active:scale-[0.97] disabled:pointer-events-none disabled:opacity-45 ${height} ${padding} ${variants[variant]} ${className}`} {...rest} > {Icon && <Icon aria-hidden size={size === "sm" ? 14 : 15} strokeWidth={2} />} diff --git a/app/src/ui/Callout.tsx b/app/src/ui/Callout.tsx index 661df278..49891ec1 100644 --- a/app/src/ui/Callout.tsx +++ b/app/src/ui/Callout.tsx @@ -4,9 +4,9 @@ import type { ReactNode } from "react"; type Tone = "info" | "warn" | "danger"; const tones: Record<Tone, { icon: typeof Info; frame: string; mark: string }> = { - info: { icon: Info, frame: "border-line-strong", mark: "text-work" }, - warn: { icon: TriangleAlert, frame: "border-warn/60", mark: "text-warn" }, - danger: { icon: CircleAlert, frame: "border-danger/60", mark: "text-danger" }, + info: { icon: Info, frame: "border-line bg-panel", mark: "text-work" }, + warn: { icon: TriangleAlert, frame: "border-warn/45 bg-warn/6", mark: "text-warn" }, + danger: { icon: CircleAlert, frame: "border-danger/45 bg-danger/6", mark: "text-danger" }, }; export function Callout({ @@ -24,7 +24,7 @@ export function Callout({ return ( <div role={tone === "info" ? "status" : "alert"} - className={`flex items-start gap-3 border border-l-4 bg-panel px-3 py-2.5 ${frame}`} + className={`flex items-start gap-3 rounded-xl border px-3.5 py-3 ${frame}`} > <Icon aria-hidden size={16} className={`mt-0.5 shrink-0 ${mark}`} /> <div className="min-w-0 flex-1 text-sm"> diff --git a/app/src/ui/Choices.tsx b/app/src/ui/Choices.tsx new file mode 100644 index 00000000..3fcf409e --- /dev/null +++ b/app/src/ui/Choices.tsx @@ -0,0 +1,45 @@ +import { useId } from "react"; + +/** + * A short set of options where one is chosen, shown side by side. Real + * radio buttons underneath, so the arrow keys and screen readers work. + */ +export function Choices<T extends string | number>({ + label, + value, + options, + onChange, +}: { + label: string; + value: T; + options: readonly { value: T; label: string }[]; + onChange(value: T): void; +}) { + const name = useId(); + return ( + <div role="radiogroup" aria-label={label} className="flex flex-wrap gap-1.5"> + {options.map((option) => { + const chosen = option.value === value; + return ( + <label + key={String(option.value)} + className={`flex h-8 cursor-pointer items-center rounded-lg border px-3 text-sm has-[input:focus-visible]:outline-2 has-[input:focus-visible]:outline-accent ${ + chosen + ? "border-ink bg-ink text-canvas" + : "border-line-strong bg-panel text-ink hover:bg-sunken" + }`} + > + <input + type="radio" + name={name} + className="sr-only" + checked={chosen} + onChange={() => onChange(option.value)} + /> + {option.label} + </label> + ); + })} + </div> + ); +} diff --git a/app/src/ui/Dialog.tsx b/app/src/ui/Dialog.tsx index a4c3cf32..faf36925 100644 --- a/app/src/ui/Dialog.tsx +++ b/app/src/ui/Dialog.tsx @@ -28,22 +28,22 @@ export function Dialog({ title, onClose, children, footer, width = "md" }: Dialo }, [onClose]); return ( - <div className="fixed inset-0 z-40 grid place-items-center bg-black/55 p-6"> + <div className="fixed inset-0 z-40 grid animate-fade place-items-center bg-black/50 p-6"> <div role="dialog" aria-modal="true" aria-labelledby={titleId} - className={`flex max-h-full w-full flex-col border border-line-strong bg-panel ${width === "lg" ? "max-w-2xl" : "max-w-md"}`} + className={`flex max-h-full w-full animate-pop flex-col overflow-hidden rounded-2xl border border-line bg-panel shadow-lift ${width === "lg" ? "max-w-2xl" : "max-w-md"}`} > - <header className="flex h-11 shrink-0 items-center justify-between border-line border-b pr-1.5 pl-4"> + <header className="flex h-12 shrink-0 items-center justify-between border-line border-b pr-2 pl-5"> <h2 id={titleId} className="font-semibold text-base tracking-tight"> {title} </h2> <Button variant="ghost" icon={X} label={t.common.close} onClick={onClose} /> </header> - <div className="min-h-0 overflow-y-auto p-4">{children}</div> + <div className="min-h-0 overflow-y-auto px-5 py-4">{children}</div> {footer && ( - <footer className="flex shrink-0 justify-end gap-2 border-line border-t px-4 py-3"> + <footer className="flex shrink-0 justify-end gap-2 border-line border-t px-5 py-3"> {footer} </footer> )} diff --git a/app/src/ui/Field.tsx b/app/src/ui/Field.tsx index 0de24c9a..419edf8a 100644 --- a/app/src/ui/Field.tsx +++ b/app/src/ui/Field.tsx @@ -1,6 +1,7 @@ import { type InputHTMLAttributes, type ReactNode, + type SelectHTMLAttributes, type TextareaHTMLAttributes, useId, } from "react"; @@ -41,7 +42,7 @@ function Frame({ } const control = - "w-full rounded-[3px] border border-line-strong bg-canvas px-2.5 text-ink text-sm outline-none placeholder:text-muted focus:border-accent"; + "w-full rounded-lg border border-line-strong bg-canvas px-2.5 text-ink text-sm outline-none placeholder:text-muted focus:border-accent"; export function TextField({ label, @@ -72,3 +73,25 @@ export function TextArea({ </Frame> ); } + +export function SelectField({ + label, + hint, + options, + ...select +}: Framing & { + options: { value: string; label: string }[]; +} & SelectHTMLAttributes<HTMLSelectElement>) { + const id = useId(); + return ( + <Frame id={id} label={label} hint={hint}> + <select id={id} className={`${control} h-8`} {...select}> + {options.map((option) => ( + <option key={option.value} value={option.value}> + {option.label} + </option> + ))} + </select> + </Frame> + ); +} diff --git a/app/src/ui/Menu.tsx b/app/src/ui/Menu.tsx index 72c48006..8341378f 100644 --- a/app/src/ui/Menu.tsx +++ b/app/src/ui/Menu.tsx @@ -1,6 +1,8 @@ import { Check, type LucideIcon } from "lucide-react"; -import { useEffect, useRef, useState } from "react"; +import { useCallback, useRef, useState } from "react"; import { Button } from "./Button"; +import { POPOVER, POPOVER_ITEM } from "./surface"; +import { useDismiss } from "./useDismiss"; export interface MenuItem { label: string; @@ -25,23 +27,11 @@ export function Menu({ const [open, setOpen] = useState(false); const root = useRef<HTMLDivElement>(null); - useEffect(() => { - if (!open) { - return; - } - const onPointer = (event: PointerEvent) => { - if (!root.current?.contains(event.target as Node)) { - setOpen(false); - } - }; - const onKey = (event: KeyboardEvent) => event.key === "Escape" && setOpen(false); - window.addEventListener("pointerdown", onPointer); - window.addEventListener("keydown", onKey); - return () => { - window.removeEventListener("pointerdown", onPointer); - window.removeEventListener("keydown", onKey); - }; - }, [open]); + useDismiss( + open, + root, + useCallback(() => setOpen(false), []), + ); return ( <div ref={root} className="relative"> @@ -56,7 +46,7 @@ export function Menu({ {open && ( <div role="menu" - className="absolute top-full right-0 z-30 mt-1 min-w-60 border border-line-strong bg-panel py-1" + className={`absolute top-full right-0 mt-1 min-w-60 origin-top-right ${POPOVER}`} > {items.map(({ label: itemLabel, icon: Icon, danger, disabled, checked, onSelect }) => ( <button @@ -70,7 +60,7 @@ export function Menu({ setOpen(false); onSelect(); }} - className={`flex h-8 w-full items-center gap-2 whitespace-nowrap px-3 text-left text-sm hover:bg-sunken disabled:opacity-45 ${danger ? "text-danger" : "text-ink"}`} + className={`h-8 whitespace-nowrap ${POPOVER_ITEM} ${danger ? "text-danger" : "text-ink"}`} > {Icon && <Icon aria-hidden size={14} />} {checked !== undefined && ( diff --git a/app/src/ui/Tabs.tsx b/app/src/ui/Tabs.tsx index 11a0af98..5b37df5e 100644 --- a/app/src/ui/Tabs.tsx +++ b/app/src/ui/Tabs.tsx @@ -1,9 +1,14 @@ +import { useLayoutEffect, useRef, useState } from "react"; + export interface Tab<T extends string> { id: T; label: string; } -/** A row of tabs; the panels are the caller's, labelled by `tabId(id)`. */ +/** + * A row of tabs; the panels are the caller's, labelled by `tabId(id)`. The + * accent line under the selected tab slides to the next one. + */ export function Tabs<T extends string>({ label, tabs, @@ -15,11 +20,23 @@ export function Tabs<T extends string>({ value: T; onChange(value: T): void; }) { + const list = useRef<HTMLDivElement>(null); + const [line, setLine] = useState<{ left: number; width: number } | null>(null); + + // biome-ignore lint/correctness/useExhaustiveDependencies: re-measured when the selection or the tabs change + useLayoutEffect(() => { + const selected = list.current?.querySelector<HTMLElement>('[aria-selected="true"]'); + if (selected) { + setLine({ left: selected.offsetLeft + 4, width: selected.offsetWidth - 8 }); + } + }, [value, tabs]); + return ( <div + ref={list} role="tablist" aria-label={label} - className="flex h-9 shrink-0 gap-1 border-line border-b px-3" + className="relative flex h-9 shrink-0 gap-1 border-line border-b px-3" > {tabs.map((tab) => { const selected = tab.id === value; @@ -31,12 +48,19 @@ export function Tabs<T extends string>({ role="tab" aria-selected={selected} onClick={() => onChange(tab.id)} - className={`relative px-2.5 font-medium text-sm ${selected ? "text-ink after:absolute after:inset-x-1 after:bottom-0 after:h-0.5 after:bg-accent" : "text-muted hover:text-ink"}`} + className={`px-2.5 font-medium text-sm transition-colors ${selected ? "text-ink" : "text-muted hover:text-ink"}`} > {tab.label} </button> ); })} + {line && ( + <span + aria-hidden + className="absolute bottom-0 h-0.5 rounded-full bg-accent transition-[left,width] duration-300 ease-[var(--ease-out)]" + style={{ left: line.left, width: line.width }} + /> + )} </div> ); } diff --git a/app/src/ui/motion.test.tsx b/app/src/ui/motion.test.tsx new file mode 100644 index 00000000..fe9218fb --- /dev/null +++ b/app/src/ui/motion.test.tsx @@ -0,0 +1,93 @@ +import { act, cleanup, render, screen, within } from "@testing-library/react"; +import { afterEach, describe, expect, test, vi } from "vitest"; +import { moodOf } from "../features/bots/BotAvatar"; +import { FakeBotloft } from "../lib/fake"; +import { crewOpened, openBot, renderApp } from "../test/app"; +import { SeenSince, useArrival, viewTransition } from "./motion"; + +afterEach(() => { + cleanup(); + vi.unstubAllGlobals(); + Reflect.deleteProperty(document, "startViewTransition"); +}); + +describe("the mascot's mood", () => { + test("follows what the bot does", () => { + const bot = (state: Parameters<typeof moodOf>[0]["state"], paused = false) => + moodOf({ state, paused }); + expect(bot("idle")).toBe("idle"); + expect(bot("busy")).toBe("working"); + expect(bot("launching")).toBe("working"); + expect(bot("needs_approval")).toBe("waiting"); + expect(bot("rate_limited")).toBe("tired"); + expect(bot("offline")).toBe("sleeping"); + expect(bot("idle", true)).toBe("sleeping"); + expect(moodOf({ state: "busy", paused: false }, true)).toBe("sleeping"); + }); +}); + +describe("arrivals", () => { + function Item({ at }: { at: number }) { + return <p className={useArrival(at)}>{`item ${at}`}</p>; + } + + test("only what came after the owner started looking animates", () => { + render( + <SeenSince.Provider value={100}> + <Item at={50} /> + <Item at={150} /> + </SeenSince.Provider>, + ); + expect(screen.getByText("item 50").className).toBe(""); + expect(screen.getByText("item 150").className).toBe("animate-rise"); + }); + + test("a chat's history stays still and a new message rises in", async () => { + const fake = new FakeBotloft(); + const ops = fake.addCrew("Ops"); + const scout = fake.addBot(ops.id, "Scout"); + fake.setBotState(scout.id, "idle"); + fake.chat.add(scout.id, { kind: "reply", text: "From before" }); + fake.chat.turn(scout.id); + renderApp(fake); + await crewOpened("Ops"); + openBot("Scout"); + const messages = await screen.findByRole("list", { name: "Messages" }); + const before = within(messages).getByText("From before").closest("li"); + expect(before?.className).not.toContain("animate-rise"); + + act(() => { + fake.now = Date.now() + 1000; + void fake.call("messages.send", { botId: scout.id, body: "Something new" }); + }); + const fresh = await within(messages).findByText("Something new"); + expect(fresh.closest("li")?.className).toContain("animate-rise"); + }); +}); + +describe("view transitions", () => { + test("run the change at once where the webview has none", () => { + const update = vi.fn(); + viewTransition(update); + expect(update).toHaveBeenCalledOnce(); + }); + + test("go through the webview's transition when it has one", () => { + const start = vi.fn((run: () => void) => run()); + Object.assign(document, { startViewTransition: start }); + const update = vi.fn(); + viewTransition(update); + expect(start).toHaveBeenCalledOnce(); + expect(update).toHaveBeenCalledOnce(); + }); + + test("skip the transition when Windows asks for less motion", () => { + const start = vi.fn((run: () => void) => run()); + Object.assign(document, { startViewTransition: start }); + vi.stubGlobal("matchMedia", (query: string) => ({ matches: query.includes("reduce") })); + const update = vi.fn(); + viewTransition(update); + expect(start).not.toHaveBeenCalled(); + expect(update).toHaveBeenCalledOnce(); + }); +}); diff --git a/app/src/ui/motion.ts b/app/src/ui/motion.ts new file mode 100644 index 00000000..f1f26b3a --- /dev/null +++ b/app/src/ui/motion.ts @@ -0,0 +1,43 @@ +// Helpers for motion (spec 15.3): switching views with a short transition, +// and telling what is new since the owner started looking, so only that +// animates in. + +import { createContext, useContext } from "react"; +import { flushSync } from "react-dom"; + +/** Whether Windows asked for less motion ("Animation effects" off). */ +export function reducedMotion(): boolean { + return ( + typeof window.matchMedia === "function" && + window.matchMedia("(prefers-reduced-motion: reduce)").matches + ); +} + +type WithTransitions = Document & { startViewTransition?(update: () => void): unknown }; + +/** + * Applies a change of view (another bot or crew) as a short transition of + * the main pane, where the webview can; otherwise at once. + */ +export function viewTransition(update: () => void): void { + const doc = document as WithTransitions; + if (typeof doc.startViewTransition !== "function" || reducedMotion()) { + update(); + return; + } + doc.startViewTransition(() => flushSync(update)); +} + +/** When the app opened: a bot created after it is new to the owner. */ +export const APP_OPENED = Date.now(); + +/** + * When the owner opened what they look at (a chat). Items created before + * it were already there and stay still; later ones animate in. + */ +export const SeenSince = createContext<number>(Number.POSITIVE_INFINITY); + +/** The class that animates an item in, if it is new. */ +export function useArrival(createdAt: number): string { + return createdAt > useContext(SeenSince) ? "animate-rise" : ""; +} diff --git a/app/src/ui/surface.ts b/app/src/ui/surface.ts new file mode 100644 index 00000000..4b83045a --- /dev/null +++ b/app/src/ui/surface.ts @@ -0,0 +1,8 @@ +// Shared looks for floating panels, so menus and pickers match. + +/** A menu or picker floating over the page; add the `origin-*` it opens from. */ +export const POPOVER = "z-30 animate-pop rounded-xl border border-line bg-panel p-1 shadow-lift"; + +/** One row of a popover. */ +export const POPOVER_ITEM = + "flex w-full items-center gap-2 rounded-lg px-2.5 text-left text-sm hover:bg-sunken disabled:opacity-45"; diff --git a/app/src/ui/toast.tsx b/app/src/ui/toast.tsx index a513d3de..5689756c 100644 --- a/app/src/ui/toast.tsx +++ b/app/src/ui/toast.tsx @@ -46,7 +46,7 @@ export function Toaster() { <div key={toast.id} role="alert" - className="pointer-events-auto flex items-start gap-2 border border-danger/60 border-l-4 bg-panel py-2 pr-1.5 pl-3 text-sm" + className="pointer-events-auto flex animate-toast items-start gap-2 rounded-xl border border-danger/45 bg-panel py-2.5 pr-2 pl-3.5 text-sm shadow-lift" > <p className="min-w-0 flex-1 break-words" data-selectable> {toast.text} @@ -55,7 +55,7 @@ export function Toaster() { type="button" aria-label={t.common.dismiss} onClick={() => dismiss(toast.id)} - className="grid h-6 w-6 shrink-0 place-items-center text-muted hover:text-ink" + className="grid h-6 w-6 shrink-0 place-items-center rounded-md text-muted hover:bg-sunken hover:text-ink" > <X aria-hidden size={14} /> </button> diff --git a/app/src/ui/useDismiss.ts b/app/src/ui/useDismiss.ts new file mode 100644 index 00000000..4d9455ec --- /dev/null +++ b/app/src/ui/useDismiss.ts @@ -0,0 +1,22 @@ +import { type RefObject, useEffect } from "react"; + +/** Closes a popover on Escape or a click outside `root`, while it is open. */ +export function useDismiss(open: boolean, root: RefObject<HTMLElement | null>, close: () => void) { + useEffect(() => { + if (!open) { + return; + } + const onPointer = (event: PointerEvent) => { + if (!root.current?.contains(event.target as Node)) { + close(); + } + }; + const onKey = (event: KeyboardEvent) => event.key === "Escape" && close(); + window.addEventListener("pointerdown", onPointer); + window.addEventListener("keydown", onKey); + return () => { + window.removeEventListener("pointerdown", onPointer); + window.removeEventListener("keydown", onKey); + }; + }, [open, root, close]); +} diff --git a/crates/botloft-core/src/chat.rs b/crates/botloft-core/src/chat.rs index 3c8405e9..779ffcfa 100644 --- a/crates/botloft-core/src/chat.rs +++ b/crates/botloft-core/src/chat.rs @@ -7,6 +7,14 @@ use crate::protocol::{ActivityKind, ChatBody, SenderKind}; /// Longest tool input kept, in bytes. pub const TOOL_INPUT_MAX: usize = 4 * 1024; +/// Longest plan kept, in bytes: the owner reads all of it to approve it. +pub const PLAN_INPUT_MAX: usize = 32 * 1024; +/// The tool Claude Code uses to leave plan mode with a plan (spec 10.1). +pub const PLAN_TOOL: &str = "ExitPlanMode"; +/// The chief's tool to suggest a new bot (spec 10.2). +pub const SUGGEST_TOOL: &str = "mcp__botloft__suggest_bot"; +/// Longest suggestion kept, in bytes: the owner reads and edits all of it. +pub const SUGGESTION_INPUT_MAX: usize = 64 * 1024; /// Longest tool output kept, in bytes. pub const TOOL_OUTPUT_MAX: usize = 8 * 1024; /// Longest activity line, in characters. @@ -37,6 +45,15 @@ pub fn one_line(text: &str, max: usize) -> String { format!("{}…", cut.trim_end()) } +/// Longest input kept for `tool`, in bytes. +pub fn tool_input_max(tool: &str) -> usize { + match tool { + PLAN_TOOL => PLAN_INPUT_MAX, + SUGGEST_TOOL => SUGGESTION_INPUT_MAX, + _ => TOOL_INPUT_MAX, + } +} + fn field<'a>(input: &'a Value, name: &str) -> Option<&'a str> { input.get(name).and_then(Value::as_str) } @@ -59,6 +76,13 @@ pub fn tool_summary(name: &str, input: &Value) -> String { "WebSearch" => field(input, "query").map(str::to_owned), "Task" | "Agent" => field(input, "description").map(str::to_owned), "TodoWrite" => Some("Updated the plan".to_owned()), + // The plan's first line, usually its title. + PLAN_TOOL => field(input, "plan").and_then(|plan| { + plan.lines() + .map(|line| line.trim_start_matches('#').trim()) + .find(|line| !line.is_empty()) + .map(str::to_owned) + }), // Claude Code loads deferred tools (such as ours) by name first. "ToolSearch" => field(input, "query").map(|query| match query.strip_prefix("select:") { Some(names) => { @@ -71,6 +95,7 @@ pub fn tool_summary(name: &str, input: &Value) -> String { field(input, "to").map(|to| format!("to @{}", to.trim_start_matches('@'))) } "mcp__botloft__complete_task" => field(input, "task_id").map(|id| format!("task {id}")), + SUGGEST_TOOL => field(input, "name").map(str::to_owned), _ => None, }; one_line(&summary.unwrap_or_default(), SUMMARY_MAX_CHARS) @@ -171,6 +196,16 @@ mod tests { "notebook jupyter" ); assert_eq!(tool_summary("SomethingNew", &json!({ "a": 1 })), ""); + assert_eq!( + tool_summary( + PLAN_TOOL, + &json!({ "plan": " +## Move the cache + +1. Read" }) + ), + "Move the cache" + ); assert_eq!(tool_label("mcp__botloft__send_message"), "send_message"); assert_eq!(tool_label("Bash"), "Bash"); } diff --git a/crates/botloft-core/src/protocol/chat.rs b/crates/botloft-core/src/protocol/chat.rs index b7676717..f8ac8ad4 100644 --- a/crates/botloft-core/src/protocol/chat.rs +++ b/crates/botloft-core/src/protocol/chat.rs @@ -42,6 +42,8 @@ text_enum!( UsageLimit => "usage_limit", /// The turn failed; `text` holds Claude Code's detail or error code. TurnFailed => "turn_failed", + /// The bot's model does not exist or the account cannot use it. + ModelUnavailable => "model_unavailable", } ); @@ -220,6 +222,11 @@ pub struct ApprovalsAnswerParams { #[serde(default)] #[cfg_attr(test, ts(optional))] pub note: Option<String>, + /// A bot suggestion as the owner changed it before allowing it, in the + /// JSON of the tool's input (spec 10.2). Ignored for other requests. + #[serde(default)] + #[cfg_attr(test, ts(optional))] + pub input: Option<String>, } /// The last thing in a bot's chat, for the conversation list. diff --git a/crates/botloft-core/src/protocol/export.rs b/crates/botloft-core/src/protocol/export.rs index db1db5a5..fd49d7aa 100644 --- a/crates/botloft-core/src/protocol/export.rs +++ b/crates/botloft-core/src/protocol/export.rs @@ -87,6 +87,8 @@ fn export_bindings() { out.decl::<AttachmentId>(); out.decl::<Crew>(); out.decl::<BotState>(); + out.decl::<PermissionMode>(); + out.decl::<BotModel>(); out.decl::<ActivityKind>(); out.decl::<Activity>(); out.decl::<Bot>(); @@ -96,15 +98,22 @@ fn export_bindings() { out.decl::<DeliveryBacklog>(); out.decl::<UsageWindow>(); out.decl::<AccountUsage>(); + out.decl::<ClaudeAccount>(); + out.decl::<OwnerAccount>(); out.decl::<SystemStatus>(); out.decl::<CrewsCreateParams>(); out.decl::<CrewsRenameParams>(); out.decl::<CrewsSetPausedParams>(); + out.decl::<CrewsSetWorkFolderParams>(); + out.decl::<NewLead>(); + out.decl::<CrewsSetLeadParams>(); out.decl::<CrewIdParams>(); out.decl::<BotsListParams>(); out.decl::<BotsCreateParams>(); out.decl::<BotsUpdateParams>(); out.decl::<BotsSetPausedParams>(); + out.decl::<BotsSetPermissionModeParams>(); + out.decl::<BotsSetModelParams>(); out.decl::<BotIdParams>(); out.decl::<BotsRestartParams>(); out.decl::<BotStateChanged>(); @@ -181,6 +190,16 @@ fn export_bindings() { &out.name::<CrewsSetPausedParams>(), &crew, ); + out.method( + method::CREWS_SET_WORK_FOLDER, + &out.name::<CrewsSetWorkFolderParams>(), + &crew, + ); + out.method( + method::CREWS_SET_LEAD, + &out.name::<CrewsSetLeadParams>(), + &crew, + ); out.method(method::CREWS_ARCHIVE, &out.name::<CrewIdParams>(), &crew); out.method(method::BOTS_LIST, &out.name::<BotsListParams>(), &bots); out.method(method::BOTS_CREATE, &out.name::<BotsCreateParams>(), &bot); @@ -190,6 +209,16 @@ fn export_bindings() { &out.name::<BotsSetPausedParams>(), &bot, ); + out.method( + method::BOTS_SET_PERMISSION_MODE, + &out.name::<BotsSetPermissionModeParams>(), + &bot, + ); + out.method( + method::BOTS_SET_MODEL, + &out.name::<BotsSetModelParams>(), + &bot, + ); out.method(method::BOTS_ARCHIVE, &out.name::<BotIdParams>(), &bot); out.method(method::BOTS_RESTART, &out.name::<BotsRestartParams>(), &bot); out.method( diff --git a/crates/botloft-core/src/protocol/methods.rs b/crates/botloft-core/src/protocol/methods.rs index 342c2df9..db17f0d3 100644 --- a/crates/botloft-core/src/protocol/methods.rs +++ b/crates/botloft-core/src/protocol/methods.rs @@ -4,7 +4,7 @@ use std::fmt; use serde::{Deserialize, Serialize}; -use super::DeliveryBacklog; +use super::{BotModel, DeliveryBacklog, PermissionMode}; use crate::ids::{BotId, CrewId}; /// Identifies the connecting app in `session.hello`. @@ -60,11 +60,36 @@ pub struct SystemStatus { pub claude_path: Option<String>, /// Whether Claude Code is signed in (`claude auth status`); `null` until checked. pub claude_signed_in: Option<bool>, + /// Who the owner is, for the account area of the app. + pub account: OwnerAccount, pub deliveries: DeliveryBacklog, /// The Claude account's usage as last reported; `null` before any turn. pub usage: Option<AccountUsage>, } +/// The owner, as the app shows them in its account area (spec 15.1). +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +#[cfg_attr(test, derive(ts_rs::TS))] +pub struct OwnerAccount { + /// The Windows account's display name, or the user name without one. + pub name: String, + /// The Claude account Claude Code is signed in to; `null` when signed out + /// or not checked yet. + pub claude: Option<ClaudeAccount>, +} + +/// What `claude auth status` says about the account (spec 7.3). +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +#[cfg_attr(test, derive(ts_rs::TS))] +pub struct ClaudeAccount { + pub email: Option<String>, + /// As Claude Code says it: `max`, `pro`, `team`, `enterprise`... + pub plan: Option<String>, + pub organization: Option<String>, +} + /// The account's usage, from Claude Code's `rate_limit_event` (spec 8.1). #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] @@ -96,6 +121,47 @@ pub struct UsageWindow { #[cfg_attr(test, derive(ts_rs::TS))] pub struct CrewsCreateParams { pub name: String, + /// Absolute path of the folder the crew works in; the crew's `shared` + /// folder when absent. + #[serde(default)] + #[cfg_attr(test, ts(optional))] + pub work_folder: Option<String>, + /// The chief, created with the crew (spec 10.2). + #[serde(default)] + #[cfg_attr(test, ts(optional))] + pub lead: Option<NewLead>, +} + +/// The bot that leads a new crew. The app writes its name and role in the +/// owner's language; the instructions carry the crew's goal. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +#[cfg_attr(test, derive(ts_rs::TS))] +pub struct NewLead { + pub name: String, + pub role: String, + pub instructions: String, + #[serde(default)] + #[cfg_attr(test, ts(optional))] + pub model: Option<BotModel>, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +#[cfg_attr(test, derive(ts_rs::TS))] +pub struct CrewsSetLeadParams { + pub crew_id: CrewId, + /// `null` leaves the crew without a chief. + pub bot_id: Option<BotId>, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +#[cfg_attr(test, derive(ts_rs::TS))] +pub struct CrewsSetWorkFolderParams { + pub crew_id: CrewId, + /// `null` goes back to the crew's `shared` folder. + pub work_folder: Option<String>, } #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] @@ -143,6 +209,10 @@ pub struct BotsCreateParams { #[serde(default)] #[cfg_attr(test, ts(optional))] pub color: Option<String>, + /// The account's default when absent. + #[serde(default)] + #[cfg_attr(test, ts(optional))] + pub model: Option<BotModel>, } /// Fields left out stay unchanged. @@ -173,6 +243,22 @@ pub struct BotsSetPausedParams { pub paused: bool, } +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +#[cfg_attr(test, derive(ts_rs::TS))] +pub struct BotsSetPermissionModeParams { + pub bot_id: BotId, + pub mode: PermissionMode, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +#[cfg_attr(test, derive(ts_rs::TS))] +pub struct BotsSetModelParams { + pub bot_id: BotId, + pub model: BotModel, +} + #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] #[cfg_attr(test, derive(ts_rs::TS))] diff --git a/crates/botloft-core/src/protocol/mod.rs b/crates/botloft-core/src/protocol/mod.rs index 00883bb4..d4f70d9e 100644 --- a/crates/botloft-core/src/protocol/mod.rs +++ b/crates/botloft-core/src/protocol/mod.rs @@ -74,11 +74,15 @@ pub mod method { pub const CREWS_CREATE: &str = "crews.create"; pub const CREWS_RENAME: &str = "crews.rename"; pub const CREWS_SET_PAUSED: &str = "crews.setPaused"; + pub const CREWS_SET_WORK_FOLDER: &str = "crews.setWorkFolder"; + pub const CREWS_SET_LEAD: &str = "crews.setLead"; pub const CREWS_ARCHIVE: &str = "crews.archive"; pub const BOTS_LIST: &str = "bots.list"; pub const BOTS_CREATE: &str = "bots.create"; pub const BOTS_UPDATE: &str = "bots.update"; pub const BOTS_SET_PAUSED: &str = "bots.setPaused"; + pub const BOTS_SET_PERMISSION_MODE: &str = "bots.setPermissionMode"; + pub const BOTS_SET_MODEL: &str = "bots.setModel"; pub const BOTS_ARCHIVE: &str = "bots.archive"; pub const BOTS_RESTART: &str = "bots.restart"; pub const CHAT_HISTORY: &str = "chat.history"; diff --git a/crates/botloft-core/src/protocol/model.rs b/crates/botloft-core/src/protocol/model.rs index 5311dd63..7d890865 100644 --- a/crates/botloft-core/src/protocol/model.rs +++ b/crates/botloft-core/src/protocol/model.rs @@ -14,6 +14,14 @@ pub struct Crew { pub name: String, /// Folder name under the workspaces root. Set at creation, never changes. pub slug: String, + /// Absolute path of the folder the crew works in (spec 5): one the owner + /// chose, or the crew's `shared` folder. + pub work_folder: String, + /// Whether the owner chose `work_folder`. + pub work_folder_chosen: bool, + /// The bot that leads the crew and may suggest new bots (spec 10.2); + /// `null` when the crew has no chief. + pub lead_bot_id: Option<BotId>, pub paused: bool, /// Unix time in milliseconds. pub created_at: i64, @@ -37,6 +45,75 @@ pub enum BotState { Archived, } +text_enum!( + /// How much a bot may do without asking the owner: Claude Code's + /// permission modes (spec 7.4). + PermissionMode, "permission mode" { + /// Asks before edits, commands and the network ("Manual"). + Default => "default", + /// Edits files and runs common file commands without asking. + AcceptEdits => "accept_edits", + /// Plans first, then asks to go ahead with the plan. + Plan => "plan", + /// A classifier reviews each action; what it does not allow is asked. + Auto => "auto", + /// Does everything without asking. + BypassPermissions => "bypass_permissions", + } +); + +impl PermissionMode { + /// The value of Claude Code's `--permission-mode`, and what it reports + /// in `system/init`. + pub fn cli_value(self) -> &'static str { + match self { + Self::Default => "default", + Self::AcceptEdits => "acceptEdits", + Self::Plan => "plan", + Self::Auto => "auto", + Self::BypassPermissions => "bypassPermissions", + } + } + + pub fn from_cli(value: &str) -> Option<Self> { + [ + Self::Default, + Self::AcceptEdits, + Self::Plan, + Self::Auto, + Self::BypassPermissions, + ] + .into_iter() + .find(|mode| mode.cli_value() == value) + } +} + +text_enum!( + /// Which Claude model a bot runs on (spec 7.4): Claude Code's `--model` + /// aliases, or the account's default. + BotModel, "model" { + /// No `--model`: the default of the owner's Claude plan. + Default => "default", + Fable => "fable", + Opus => "opus", + Sonnet => "sonnet", + Haiku => "haiku", + } +); + +impl BotModel { + /// The value of Claude Code's `--model`; `None` leaves the flag out. + pub fn cli_value(self) -> Option<&'static str> { + match self { + Self::Default => None, + Self::Fable => Some("fable"), + Self::Opus => Some("opus"), + Self::Sonnet => Some("sonnet"), + Self::Haiku => Some("haiku"), + } + } +} + /// A persistent Claude Code session with a name, a role and instructions. #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] @@ -55,6 +132,11 @@ pub struct Bot { /// Avatar color, `#RRGGBB`. pub color: String, pub paused: bool, + pub permission_mode: PermissionMode, + pub model: BotModel, + /// The model id Claude Code reported when the bot last started a turn + /// (`claude-opus-5-5`); `null` before its first turn. + pub model_in_use: Option<String>, pub state: BotState, /// Current process generation; `null` if the bot has not started since /// the daemon did. Changes on every (re)start. diff --git a/crates/botloft-store/migrations/0004_permission_mode.sql b/crates/botloft-store/migrations/0004_permission_mode.sql new file mode 100644 index 00000000..ccc2fe85 --- /dev/null +++ b/crates/botloft-store/migrations/0004_permission_mode.sql @@ -0,0 +1,3 @@ +-- How much each bot may do without asking (spec 7.4). Existing bots keep +-- asking before everything, as they did. +ALTER TABLE bots ADD COLUMN permission_mode TEXT NOT NULL DEFAULT 'default'; diff --git a/crates/botloft-store/migrations/0005_bot_model.sql b/crates/botloft-store/migrations/0005_bot_model.sql new file mode 100644 index 00000000..2c93cd73 --- /dev/null +++ b/crates/botloft-store/migrations/0005_bot_model.sql @@ -0,0 +1,4 @@ +-- Which Claude model each bot runs on (spec 7.4), and the model Claude Code +-- last reported. Existing bots keep the account's default, as they did. +ALTER TABLE bots ADD COLUMN model TEXT NOT NULL DEFAULT 'default'; +ALTER TABLE bots ADD COLUMN model_in_use TEXT; diff --git a/crates/botloft-store/migrations/0006_crew_work_folder.sql b/crates/botloft-store/migrations/0006_crew_work_folder.sql new file mode 100644 index 00000000..62bae47a --- /dev/null +++ b/crates/botloft-store/migrations/0006_crew_work_folder.sql @@ -0,0 +1,3 @@ +-- The folder a crew works in, when the owner chose one (spec 5). NULL keeps +-- the crew's shared folder, as before. +ALTER TABLE crews ADD COLUMN work_dir TEXT; diff --git a/crates/botloft-store/migrations/0007_crew_lead.sql b/crates/botloft-store/migrations/0007_crew_lead.sql new file mode 100644 index 00000000..886911e2 --- /dev/null +++ b/crates/botloft-store/migrations/0007_crew_lead.sql @@ -0,0 +1,4 @@ +-- The bot that leads each crew (spec 10.2). No foreign key: the chief of a +-- new crew is saved in the same transaction as its bot, and an archived +-- chief simply no longer counts. +ALTER TABLE crews ADD COLUMN lead_bot_id TEXT; diff --git a/crates/botloft-store/src/approvals.rs b/crates/botloft-store/src/approvals.rs index ff0a3704..72574322 100644 --- a/crates/botloft-store/src/approvals.rs +++ b/crates/botloft-store/src/approvals.rs @@ -71,22 +71,25 @@ impl Store { .optional()?) } - /// Answers a pending approval. `None` if it was already settled. + /// Answers a pending approval; `input` replaces what was asked, when the + /// owner changed it. `None` if it was already settled. pub fn settle_approval( &self, id: &ApprovalId, status: ApprovalStatus, note: Option<&str>, + input: Option<&str>, now: i64, ) -> Result<Option<ApprovalRecord>> { Ok(self .conn .query_row( &format!( - "UPDATE approvals SET status = ?2, note = ?3, answered_at = ?4 \ + "UPDATE approvals SET status = ?2, note = ?3, answered_at = ?4, \ + input = COALESCE(?5, input) \ WHERE id = ?1 AND status = 'pending' RETURNING {COLUMNS}, tool_use_id" ), - params![id.as_str(), status.as_str(), note, now], + params![id.as_str(), status.as_str(), note, now, input], from_row, ) .optional()?) @@ -163,6 +166,7 @@ mod tests { &record.approval.id, ApprovalStatus::Denied, Some("not now"), + None, 20, ) .expect("settle") @@ -172,11 +176,29 @@ mod tests { assert_eq!(denied.approval.answered_at, Some(20)); let again = fx .store - .settle_approval(&record.approval.id, ApprovalStatus::Allowed, None, 30) + .settle_approval(&record.approval.id, ApprovalStatus::Allowed, None, None, 30) .expect("settle"); assert_eq!(again, None); } + #[test] + fn an_answer_can_replace_what_was_asked() { + let fx = Fixture::new(); + let record = pending(&fx, 0); + let allowed = fx + .store + .settle_approval( + &record.approval.id, + ApprovalStatus::Allowed, + None, + Some(r#"{"name":"Designer"}"#), + 40, + ) + .expect("settle") + .expect("was pending"); + assert_eq!(allowed.approval.input, r#"{"name":"Designer"}"#); + } + #[test] fn a_bots_pending_approvals_expire_together() { let fx = Fixture::new(); diff --git a/crates/botloft-store/src/bots.rs b/crates/botloft-store/src/bots.rs index e26804fe..59e5e5ac 100644 --- a/crates/botloft-store/src/bots.rs +++ b/crates/botloft-store/src/bots.rs @@ -1,6 +1,7 @@ //! `bots` table. use botloft_core::ids::{BotId, CrewId}; +use botloft_core::protocol::{BotModel, PermissionMode}; use rusqlite::{OptionalExtension, Row, params}; use crate::{Result, Store, parse_column, unique_as_duplicate}; @@ -18,12 +19,17 @@ pub struct BotRecord { pub instructions: String, pub color: String, pub paused: bool, + pub permission_mode: PermissionMode, + pub model: BotModel, + /// What Claude Code last reported; written by [`Store::set_model_in_use`] + /// and left alone by [`Store::update_bot`]. + pub model_in_use: Option<String>, pub created_at: i64, pub archived_at: Option<i64>, } -const COLUMNS: &str = - "id, crew_id, name, handle, slug, role, instructions, color, paused, created_at, archived_at"; +const COLUMNS: &str = "id, crew_id, name, handle, slug, role, instructions, color, paused, created_at, archived_at, \ + permission_mode, model, model_in_use"; fn from_row(row: &Row<'_>) -> rusqlite::Result<BotRecord> { Ok(BotRecord { @@ -38,6 +44,9 @@ fn from_row(row: &Row<'_>) -> rusqlite::Result<BotRecord> { paused: row.get(8)?, created_at: row.get(9)?, archived_at: row.get(10)?, + permission_mode: parse_column(row, 11)?, + model: parse_column(row, 12)?, + model_in_use: row.get(13)?, }) } @@ -47,7 +56,7 @@ impl Store { .execute( &format!( "INSERT INTO bots ({COLUMNS}) \ - VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11)" + VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14)" ), params![ bot.id.as_str(), @@ -60,7 +69,10 @@ impl Store { bot.color, bot.paused, bot.created_at, - bot.archived_at + bot.archived_at, + bot.permission_mode.as_str(), + bot.model.as_str(), + bot.model_in_use ], ) .map_err(|err| unique_as_duplicate(err, "bot handle or slug"))?; @@ -128,7 +140,7 @@ impl Store { self.conn .execute( "UPDATE bots SET name = ?2, handle = ?3, role = ?4, instructions = ?5, \ - color = ?6, paused = ?7, archived_at = ?8 WHERE id = ?1", + color = ?6, paused = ?7, archived_at = ?8, permission_mode = ?9, model = ?10 WHERE id = ?1", params![ bot.id.as_str(), bot.name, @@ -137,13 +149,24 @@ impl Store { bot.instructions, bot.color, bot.paused, - bot.archived_at + bot.archived_at, + bot.permission_mode.as_str(), + bot.model.as_str() ], ) .map_err(|err| unique_as_duplicate(err, "bot handle"))?; Ok(()) } + /// The model Claude Code reported at the start of a turn (spec 7.4). + pub fn set_model_in_use(&self, id: &BotId, model: &str) -> Result<()> { + self.conn.execute( + "UPDATE bots SET model_in_use = ?2 WHERE id = ?1", + params![id.as_str(), model], + )?; + Ok(()) + } + /// The Claude Code conversation the bot resumes (spec 7.3). pub fn session_id(&self, id: &BotId) -> Result<Option<String>> { Ok(self @@ -180,6 +203,9 @@ mod tests { id: CrewId::generate(), name: "Docs".to_owned(), slug: "docs".to_owned(), + work_folder: String::new(), + work_folder_chosen: false, + lead_bot_id: None, paused: false, created_at: 1, archived_at: None, @@ -199,6 +225,9 @@ mod tests { instructions: "Be brief.\nCite sources.".to_owned(), color: "#FF7A59".to_owned(), paused: false, + permission_mode: PermissionMode::Default, + model: BotModel::Default, + model_in_use: None, created_at, archived_at: None, } diff --git a/crates/botloft-store/src/crews.rs b/crates/botloft-store/src/crews.rs index e56c8061..8ad96163 100644 --- a/crates/botloft-store/src/crews.rs +++ b/crates/botloft-store/src/crews.rs @@ -6,31 +6,45 @@ use rusqlite::{OptionalExtension, Row, params}; use crate::{Result, Store, parse_column, unique_as_duplicate}; -const COLUMNS: &str = "id, name, slug, paused, created_at, archived_at"; +const COLUMNS: &str = "id, name, slug, paused, created_at, archived_at, work_dir, lead_bot_id"; +/// A crew without a chosen folder comes back with an empty `work_folder`; +/// the daemon fills in the `shared` folder, which depends on its paths. fn from_row(row: &Row<'_>) -> rusqlite::Result<Crew> { + let work_dir: Option<String> = row.get(6)?; Ok(Crew { id: parse_column(row, 0)?, name: row.get(1)?, slug: row.get(2)?, + work_folder_chosen: work_dir.is_some(), + work_folder: work_dir.unwrap_or_default(), + lead_bot_id: row + .get::<_, Option<String>>(7)? + .and_then(|id| id.parse().ok()), paused: row.get(3)?, created_at: row.get(4)?, archived_at: row.get(5)?, }) } +fn work_dir(crew: &Crew) -> Option<&str> { + crew.work_folder_chosen.then_some(crew.work_folder.as_str()) +} + impl Store { pub fn insert_crew(&self, crew: &Crew) -> Result<()> { self.conn .execute( - &format!("INSERT INTO crews ({COLUMNS}) VALUES (?1, ?2, ?3, ?4, ?5, ?6)"), + &format!("INSERT INTO crews ({COLUMNS}) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)"), params![ crew.id.as_str(), crew.name, crew.slug, crew.paused, crew.created_at, - crew.archived_at + crew.archived_at, + work_dir(crew), + crew.lead_bot_id.as_ref().map(|id| id.as_str()) ], ) .map_err(|err| unique_as_duplicate(err, "crew slug"))?; @@ -66,11 +80,20 @@ impl Store { )?) } - /// Saves the mutable fields: name, paused and archived_at. + /// Saves the mutable fields: name, paused, archived_at, the chosen work + /// folder and the chief. pub fn update_crew(&self, crew: &Crew) -> Result<()> { self.conn.execute( - "UPDATE crews SET name = ?2, paused = ?3, archived_at = ?4 WHERE id = ?1", - params![crew.id.as_str(), crew.name, crew.paused, crew.archived_at], + "UPDATE crews SET name = ?2, paused = ?3, archived_at = ?4, work_dir = ?5, \ + lead_bot_id = ?6 WHERE id = ?1", + params![ + crew.id.as_str(), + crew.name, + crew.paused, + crew.archived_at, + work_dir(crew), + crew.lead_bot_id.as_ref().map(|id| id.as_str()) + ], )?; Ok(()) } @@ -101,6 +124,9 @@ mod tests { id: CrewId::generate(), name: slug.to_uppercase(), slug: slug.to_owned(), + work_folder: String::new(), + work_folder_chosen: false, + lead_bot_id: None, paused: false, created_at, archived_at: None, diff --git a/crates/botloft-store/src/lib.rs b/crates/botloft-store/src/lib.rs index e89ea935..d145ae71 100644 --- a/crates/botloft-store/src/lib.rs +++ b/crates/botloft-store/src/lib.rs @@ -122,6 +122,9 @@ pub(crate) mod tests { id: CrewId::generate(), name: "Ops".to_owned(), slug: "ops".to_owned(), + work_folder: String::new(), + work_folder_chosen: false, + lead_bot_id: None, paused: false, created_at: 0, archived_at: None, @@ -140,6 +143,9 @@ pub(crate) mod tests { instructions: String::new(), color: "#FF7A59".to_owned(), paused: false, + permission_mode: botloft_core::protocol::PermissionMode::Default, + model: botloft_core::protocol::BotModel::Default, + model_in_use: None, created_at: 0, archived_at: None, }; diff --git a/crates/botloft-store/src/migrate.rs b/crates/botloft-store/src/migrate.rs index 5b8a68a1..7d15649c 100644 --- a/crates/botloft-store/src/migrate.rs +++ b/crates/botloft-store/src/migrate.rs @@ -10,6 +10,10 @@ const MIGRATIONS: &[(u32, &str)] = &[ (1, include_str!("../migrations/0001_init.sql")), (2, include_str!("../migrations/0002_messages.sql")), (3, include_str!("../migrations/0003_chat.sql")), + (4, include_str!("../migrations/0004_permission_mode.sql")), + (5, include_str!("../migrations/0005_bot_model.sql")), + (6, include_str!("../migrations/0006_crew_work_folder.sql")), + (7, include_str!("../migrations/0007_crew_lead.sql")), ]; /// Schema version after every migration has run. diff --git a/crates/botloftd/Cargo.toml b/crates/botloftd/Cargo.toml index 7b4a6488..98cd9b40 100644 --- a/crates/botloftd/Cargo.toml +++ b/crates/botloftd/Cargo.toml @@ -33,7 +33,7 @@ tracing-subscriber = { version = "0.3.23", features = ["env-filter"] } workspace = true [target."cfg(windows)".dependencies] -windows = { version = "0.62.2", features = ["Win32_Foundation", "Win32_Security", "Win32_Security_Authorization", "Win32_System_Threading", "Win32_System_Memory", "Win32_System_JobObjects", "Win32_System_Environment", "Win32_System_Power", "Win32_System_Console", "Win32_System_Com", "Win32_System_Ole", "Win32_System_Variant", "Win32_System_TaskScheduler"] } +windows = { version = "0.62.2", features = ["Win32_Foundation", "Win32_Security", "Win32_Security_Authorization", "Win32_System_Threading", "Win32_System_Memory", "Win32_System_JobObjects", "Win32_System_Environment", "Win32_System_Power", "Win32_System_Console", "Win32_System_Com", "Win32_System_Ole", "Win32_System_Variant", "Win32_System_TaskScheduler", "Win32_Security_Authentication_Identity"] } [target."cfg(windows)".build-dependencies] embed-resource = "3.0.11" diff --git a/crates/botloftd/src/approvals.rs b/crates/botloftd/src/approvals/mod.rs similarity index 66% rename from crates/botloftd/src/approvals.rs rename to crates/botloftd/src/approvals/mod.rs index 0674a880..e7626cd0 100644 --- a/crates/botloftd/src/approvals.rs +++ b/crates/botloftd/src/approvals/mod.rs @@ -1,30 +1,28 @@ -//! Permission requests (spec 10.1). Claude Code calls the MCP tool -//! `permission_prompt`; the call waits here until the owner answers in the -//! chat, the request times out, or the bot's process ends. +//! Requests that wait for the owner in the chat: Claude Code's permission +//! requests (spec 10.1) and the chief's bot suggestions (spec 10.2). The +//! MCP call waits here until the owner answers, the request times out, or +//! the bot's process ends. + +mod prompt; use std::collections::HashMap; use std::sync::{Mutex, MutexGuard}; -use std::time::Duration; -use botloft_core::chat::{TOOL_INPUT_MAX, clip, tool_summary}; +use botloft_core::chat::{SUGGEST_TOOL, clip, tool_input_max, tool_summary}; use botloft_core::ids::{ApprovalId, BotId, ChatItemId}; use botloft_core::protocol::{ - Approval, ApprovalItem, ApprovalStatus, ApprovalsAnswerParams, ChatBody, ToolStatus, + Approval, ApprovalItem, ApprovalStatus, ApprovalsAnswerParams, ChatBody, }; use botloft_store::ApprovalRecord; -use serde_json::{Value, json}; +use serde_json::Value; use tokio::sync::oneshot; use tracing::{debug, warn}; +pub use self::prompt::{PromptArgs, prompt}; use crate::chat::items; use crate::service::{ApiError, ApiResult}; use crate::state::Daemon; -/// How long to wait for the `tool_use` event that the request is about; -/// it can arrive a moment after the MCP call. -const MATCH_WINDOW: Duration = Duration::from_secs(2); -const MATCH_POLL: Duration = Duration::from_millis(50); - /// Requests waiting for an answer, in memory: they cannot outlive the /// daemon, since the bots' processes do not either. #[derive(Default)] @@ -36,6 +34,21 @@ pub struct Approvals { struct Decision { allow: bool, note: Option<String>, + input: Option<String>, +} + +/// How the owner answered a request. +#[derive(Debug, Clone, PartialEq, Eq)] +pub(crate) enum Answer { + /// `input` is the request as the owner changed it, if they did. + Allowed { + input: Option<String>, + }, + Denied { + note: Option<String>, + }, + /// No answer in time, or the process ended. + Expired, } impl Approvals { @@ -46,26 +59,17 @@ impl Approvals { } } -/// Arguments Claude Code sends to the permission tool. -#[derive(Debug, Clone, serde::Deserialize)] -pub struct PromptArgs { - pub tool_name: String, - #[serde(default)] - pub input: Value, - #[serde(default)] - pub tool_use_id: String, -} - -/// Handles one `permission_prompt` call and returns the text of the tool -/// result: `{"behavior": "allow" | "deny", ...}`. -pub async fn prompt(daemon: &Daemon, bot: &BotId, generation: u64, args: PromptArgs) -> String { - if !matches_running_tool(daemon, bot, &args.tool_use_id).await { - debug!(bot = %bot, "permission request for no running tool; denied"); - return deny("There is no pending tool call with that id."); - } - let Some(pending) = open(daemon, bot, &args) else { - return deny("Botloft could not ask the owner."); - }; +/// Puts a request in the bot's chat and waits for the owner. `None` if it +/// could not be saved. +pub(crate) async fn ask( + daemon: &Daemon, + bot: &BotId, + generation: u64, + tool_name: &str, + input: &Value, + tool_use_id: &str, +) -> Option<Answer> { + let pending = open(daemon, bot, tool_name, input, tool_use_id)?; let (answer, waiting) = oneshot::channel(); daemon .approvals @@ -83,20 +87,17 @@ pub async fn prompt(daemon: &Daemon, bot: &BotId, generation: u64, args: PromptA guard.settled = true; daemon.approvals.lock().remove(&pending.record.approval.id); daemon.supervisor.approval_closed(bot, generation); - match decision { - Ok(Ok(Decision { allow: true, .. })) => { - json!({ "behavior": "allow", "updatedInput": args.input }).to_string() - } - Ok(Ok(Decision { allow: false, note })) => match note { - Some(note) => deny(&format!("The owner denied this: {note}")), - None => deny("The owner denied this."), - }, + Some(match decision { + Ok(Ok(Decision { + allow: true, input, .. + })) => Answer::Allowed { input }, + Ok(Ok(Decision { note, .. })) => Answer::Denied { note }, // Timed out, or the answer was dropped (the process ended). Ok(Err(_)) | Err(_) => { - settle(daemon, &pending.record, ApprovalStatus::Expired, None); - deny("The owner did not answer in time.") + settle(daemon, &pending.record, ApprovalStatus::Expired, None, None); + Answer::Expired } - } + }) } /// The owner's answer (`approvals.answer`). @@ -114,7 +115,16 @@ pub fn answer(daemon: &Daemon, params: ApprovalsAnswerParams) -> ApiResult<Appro .store() .approval(¶ms.approval_id)? .ok_or_else(|| ApiError::NotFound(format!("approval {}", params.approval_id)))?; - let Some(record) = settle(daemon, &existing, status, note.as_deref()) else { + // Only a bot suggestion can be changed before it is allowed (spec 10.2). + let input = match params.input { + Some(input) if params.allow && existing.approval.tool_name == SUGGEST_TOOL => { + let value: Value = serde_json::from_str(&input) + .map_err(|_| ApiError::validation("the changed suggestion is not valid JSON"))?; + Some(value.to_string()) + } + _ => None, + }; + let Some(record) = settle(daemon, &existing, status, note.as_deref(), input.as_deref()) else { return Err(ApiError::Conflict(format!( "approval {} was already answered or expired", params.approval_id @@ -124,6 +134,7 @@ pub fn answer(daemon: &Daemon, params: ApprovalsAnswerParams) -> ApiResult<Appro let _ = waiter.send(Decision { allow: params.allow, note, + input, }); } Ok(record.approval) @@ -160,44 +171,25 @@ pub fn expire_all(daemon: &Daemon) { } } -fn deny(message: &str) -> String { - json!({ "behavior": "deny", "message": message }).to_string() -} - -/// Whether the bot's chat shows `tool_use_id` running, waiting briefly for -/// the event if it has not been read yet. -async fn matches_running_tool(daemon: &Daemon, bot: &BotId, tool_use_id: &str) -> bool { - if tool_use_id.is_empty() { - return false; - } - let deadline = tokio::time::Instant::now() + MATCH_WINDOW; - loop { - let found = daemon.store().tool_item(bot, tool_use_id); - if let Ok(Some(item)) = found - && matches!(&item.body, ChatBody::Tool(tool) if tool.status == ToolStatus::Running) - { - return true; - } - if tokio::time::Instant::now() >= deadline { - return false; - } - tokio::time::sleep(MATCH_POLL).await; - } -} - struct Pending { record: ApprovalRecord, } /// Saves the request and puts it in the chat. -fn open(daemon: &Daemon, bot: &BotId, args: &PromptArgs) -> Option<Pending> { +fn open( + daemon: &Daemon, + bot: &BotId, + tool_name: &str, + input: &Value, + tool_use_id: &str, +) -> Option<Pending> { let now = daemon.clock.now_ms(); let approval = Approval { id: ApprovalId::generate(), bot_id: bot.clone(), - tool_name: args.tool_name.clone(), - summary: tool_summary(&args.tool_name, &args.input), - input: clip(&args.input.to_string(), TOOL_INPUT_MAX), + tool_name: tool_name.to_owned(), + summary: tool_summary(tool_name, input), + input: clip(&input.to_string(), tool_input_max(tool_name)), status: ApprovalStatus::Pending, note: None, created_at: now, @@ -207,7 +199,7 @@ fn open(daemon: &Daemon, bot: &BotId, args: &PromptArgs) -> Option<Pending> { let record = ApprovalRecord { approval, chat_item_id: item.id, - tool_use_id: args.tool_use_id.clone(), + tool_use_id: tool_use_id.to_owned(), }; if let Err(err) = daemon.store().insert_approval(&record) { warn!(bot = %bot, "could not save an approval: {err}"); @@ -234,11 +226,12 @@ fn settle( record: &ApprovalRecord, status: ApprovalStatus, note: Option<&str>, + input: Option<&str>, ) -> Option<ApprovalRecord> { let now = daemon.clock.now_ms(); let settled = daemon .store() - .settle_approval(&record.approval.id, status, note, now); + .settle_approval(&record.approval.id, status, note, input, now); match settled { Ok(Some(settled)) => { show(daemon, &settled); @@ -276,7 +269,13 @@ impl Drop for Guard<'_> { .approvals .lock() .remove(&self.record.approval.id); - settle(self.daemon, self.record, ApprovalStatus::Expired, None); + settle( + self.daemon, + self.record, + ApprovalStatus::Expired, + None, + None, + ); self.daemon .supervisor .approval_closed(self.bot, self.generation); diff --git a/crates/botloftd/src/approvals/prompt.rs b/crates/botloftd/src/approvals/prompt.rs new file mode 100644 index 00000000..f9a9af59 --- /dev/null +++ b/crates/botloftd/src/approvals/prompt.rs @@ -0,0 +1,82 @@ +//! Claude Code's permission requests (spec 10.1): the MCP tool +//! `permission_prompt`, named with `--permission-prompt-tool`. + +use std::time::Duration; + +use botloft_core::ids::BotId; +use botloft_core::protocol::{ChatBody, ToolStatus}; +use serde_json::{Value, json}; +use tracing::debug; + +use super::{Answer, ask}; +use crate::state::Daemon; + +/// How long to wait for the `tool_use` event that the request is about; +/// it can arrive a moment after the MCP call. +const MATCH_WINDOW: Duration = Duration::from_secs(2); +const MATCH_POLL: Duration = Duration::from_millis(50); + +/// Arguments Claude Code sends to the permission tool. +#[derive(Debug, Clone, serde::Deserialize)] +pub struct PromptArgs { + pub tool_name: String, + #[serde(default)] + pub input: Value, + #[serde(default)] + pub tool_use_id: String, +} + +/// Handles one `permission_prompt` call and returns the text of the tool +/// result: `{"behavior": "allow" | "deny", ...}`. +pub async fn prompt(daemon: &Daemon, bot: &BotId, generation: u64, args: PromptArgs) -> String { + if !matches_running_tool(daemon, bot, &args.tool_use_id).await { + debug!(bot = %bot, "permission request for no running tool; denied"); + return deny("There is no pending tool call with that id."); + } + let asked = ask( + daemon, + bot, + generation, + &args.tool_name, + &args.input, + &args.tool_use_id, + ) + .await; + match asked { + // What runs is what was asked: the owner cannot edit a tool call. + Some(Answer::Allowed { .. }) => { + json!({ "behavior": "allow", "updatedInput": args.input }).to_string() + } + Some(Answer::Denied { note: Some(note) }) => { + deny(&format!("The owner denied this: {note}")) + } + Some(Answer::Denied { note: None }) => deny("The owner denied this."), + Some(Answer::Expired) => deny("The owner did not answer in time."), + None => deny("Botloft could not ask the owner."), + } +} + +fn deny(message: &str) -> String { + json!({ "behavior": "deny", "message": message }).to_string() +} + +/// Whether the bot's chat shows `tool_use_id` running, waiting briefly for +/// the event if it has not been read yet. +async fn matches_running_tool(daemon: &Daemon, bot: &BotId, tool_use_id: &str) -> bool { + if tool_use_id.is_empty() { + return false; + } + let deadline = tokio::time::Instant::now() + MATCH_WINDOW; + loop { + let found = daemon.store().tool_item(bot, tool_use_id); + if let Ok(Some(item)) = found + && matches!(&item.body, ChatBody::Tool(tool) if tool.status == ToolStatus::Running) + { + return true; + } + if tokio::time::Instant::now() >= deadline { + return false; + } + tokio::time::sleep(MATCH_POLL).await; + } +} diff --git a/crates/botloftd/src/chat/events.rs b/crates/botloftd/src/chat/events.rs index ea5b644d..95db46f9 100644 --- a/crates/botloftd/src/chat/events.rs +++ b/crates/botloftd/src/chat/events.rs @@ -2,7 +2,7 @@ //! (spec 8.1). Fields are read defensively: the format is not documented //! and grows between Claude Code versions. -use botloft_core::chat::{TOOL_INPUT_MAX, TOOL_OUTPUT_MAX, clip, tool_summary}; +use botloft_core::chat::{TOOL_OUTPUT_MAX, clip, tool_input_max, tool_summary}; use botloft_core::ids::BotId; use botloft_core::protocol::{ AccountUsage, ChatBody, ChatDelta, NoticeCode, NoticeItem, NoticeLevel, ReplyItem, ToolItem, @@ -12,6 +12,7 @@ use serde_json::Value; use tracing::{debug, warn}; use super::items; +use crate::service; use crate::state::{Daemon, Event}; /// Errors that restarting cannot fix: Claude Code needs the owner. @@ -21,6 +22,8 @@ const SIGN_IN_ERRORS: &[&str] = &[ "billing_error", "account_on_hold", ]; +/// The model does not exist or the account cannot use it (spec 7.4). +const MODEL_NOT_FOUND: &str = "model_not_found"; /// When a rate limit gives no reset time. const DEFAULT_LIMIT_MS: i64 = 5 * 60 * 1000; @@ -59,6 +62,12 @@ fn session(daemon: &Daemon, bot: &BotId, event: &Value) { } drop(store); daemon.supervisor.remember_session(bot, session); + if let Some(mode) = event["permissionMode"].as_str() { + service::modes::reported(daemon, bot, mode); + } + if let Some(model) = event["model"].as_str() { + service::models::reported(daemon, bot, model); + } } fn delta(daemon: &Daemon, bot: &BotId, event: &Value) { @@ -111,7 +120,7 @@ fn assistant(daemon: &Daemon, bot: &BotId, generation: u64, event: &Value) { tool_use_id: block["id"].as_str().unwrap_or_default().to_owned(), name: name.to_owned(), summary: tool_summary(name, input), - input: clip(&input.to_string(), TOOL_INPUT_MAX), + input: clip(&input.to_string(), tool_input_max(name)), status: ToolStatus::Running, output: None, }), @@ -144,6 +153,12 @@ fn failed_turn(daemon: &Daemon, bot: &BotId, generation: u64, error: &str, event NoticeCode::UsageLimit, "The account reached its usage limit. Messages wait until it resets.".to_owned(), ) + } else if error == MODEL_NOT_FOUND { + ( + NoticeCode::ModelUnavailable, + "Claude Code could not use this bot's model: it may not exist or not be on the account's plan. Pick another model." + .to_owned(), + ) } else if detail.is_empty() { (NoticeCode::TurnFailed, error.to_owned()) } else { diff --git a/crates/botloftd/src/config.rs b/crates/botloftd/src/config.rs index 692a602b..d0085e5f 100644 --- a/crates/botloftd/src/config.rs +++ b/crates/botloftd/src/config.rs @@ -85,6 +85,8 @@ pub struct BotsConfig { pub approval_timeout_minutes: u64, /// Largest attachment, per file (spec 9.5). pub attachment_max_mb: u64, + /// Most bots a chief's suggestions can bring a crew to (spec 10.2). + pub max_per_crew: usize, } impl Default for BotsConfig { @@ -92,6 +94,7 @@ impl Default for BotsConfig { Self { approval_timeout_minutes: 60, attachment_max_mb: 20, + max_per_crew: 12, } } } diff --git a/crates/botloftd/src/paths.rs b/crates/botloftd/src/paths.rs index 60286db9..a8bcc105 100644 --- a/crates/botloftd/src/paths.rs +++ b/crates/botloftd/src/paths.rs @@ -3,6 +3,8 @@ use std::io; use std::path::{Path, PathBuf}; +use botloft_core::protocol::Crew; + use crate::config::Config; /// Environment variable that moves the daemon's data directory, so a dev @@ -60,6 +62,15 @@ impl Paths { pub fn bot_workspace(&self, crew_slug: &str, bot_slug: &str) -> PathBuf { self.crew_dir(crew_slug).join(bot_slug) } + + /// The folder the crew works in: the one the owner chose, or `shared`. + pub fn work_folder(&self, crew: &Crew) -> PathBuf { + if crew.work_folder_chosen { + PathBuf::from(&crew.work_folder) + } else { + self.shared_dir(&crew.slug) + } + } } /// `--home` when given (the scheduled task passes it, spec 14), else diff --git a/crates/botloftd/src/platform/mod.rs b/crates/botloftd/src/platform/mod.rs index 1440b7d4..5fb51a5e 100644 --- a/crates/botloftd/src/platform/mod.rs +++ b/crates/botloftd/src/platform/mod.rs @@ -12,12 +12,12 @@ use std::path::{Path, PathBuf}; #[cfg(unix)] pub use unix::{ - KeepAwake, ProcessJob, delete_task, find_task, leave_own_console, register_task, + KeepAwake, ProcessJob, delete_task, find_task, leave_own_console, owner_name, register_task, restrict_to_current_user, run_task, stop_task, user_environment, }; #[cfg(windows)] pub use windows::{ - KeepAwake, ProcessJob, delete_task, find_task, leave_own_console, register_task, + KeepAwake, ProcessJob, delete_task, find_task, leave_own_console, owner_name, register_task, restrict_to_current_user, run_task, stop_task, user_environment, }; @@ -98,6 +98,11 @@ mod tests { assert!(!has("CLAUDE_CODE_MESSAGING_SOCKET")); } + #[test] + fn the_owner_has_a_name() { + assert!(!owner_name().trim().is_empty()); + } + #[test] fn a_job_can_be_created_and_terminated_empty() { let job = ProcessJob::new().expect("job"); diff --git a/crates/botloftd/src/platform/unix.rs b/crates/botloftd/src/platform/unix.rs index de9772d8..738a38e0 100644 --- a/crates/botloftd/src/platform/unix.rs +++ b/crates/botloftd/src/platform/unix.rs @@ -68,6 +68,11 @@ pub fn user_environment() -> io::Result<Vec<(OsString, OsString)>> { .collect()) } +/// The login name; Unix has no display name to ask for. +pub fn owner_name() -> String { + std::env::var("USER").unwrap_or_default() +} + /// Nothing to leave: Unix never opens a console for the daemon. pub fn leave_own_console() {} diff --git a/crates/botloftd/src/platform/windows.rs b/crates/botloftd/src/platform/windows.rs index fce4924d..426b9876 100644 --- a/crates/botloftd/src/platform/windows.rs +++ b/crates/botloftd/src/platform/windows.rs @@ -4,6 +4,7 @@ mod console; mod env; mod job; +mod owner; mod power; mod task; mod task_xml; @@ -11,6 +12,7 @@ mod task_xml; pub use console::leave_own_console; pub use env::user_environment; pub use job::ProcessJob; +pub use owner::owner_name; pub use power::KeepAwake; pub use task::{delete_task, find_task, register_task, run_task, stop_task}; diff --git a/crates/botloftd/src/platform/windows/owner.rs b/crates/botloftd/src/platform/windows/owner.rs new file mode 100644 index 00000000..8b97666d --- /dev/null +++ b/crates/botloftd/src/platform/windows/owner.rs @@ -0,0 +1,26 @@ +//! The owner's name as Windows shows it, for the app's account area. + +use windows::Win32::Security::Authentication::Identity::{GetUserNameExW, NameDisplay}; +use windows::core::PWSTR; + +/// The account's display name ("Ana Lima"), or the user name without one. +pub fn owner_name() -> String { + display_name() + .filter(|name| !name.trim().is_empty()) + .unwrap_or_else(|| std::env::var("USERNAME").unwrap_or_default()) +} + +fn display_name() -> Option<String> { + let mut len = 0u32; + // SAFETY: a size query with no buffer; it fails and sets `len` to the + // size needed, counting the final NUL. + let _ = unsafe { GetUserNameExW(NameDisplay, None, &mut len) }; + if len == 0 { + return None; + } + let mut buf = vec![0u16; len as usize]; + // SAFETY: `buf` holds `len` UTF-16 units; on success `len` becomes the + // length of the name without the NUL. + let found = unsafe { GetUserNameExW(NameDisplay, Some(PWSTR(buf.as_mut_ptr())), &mut len) }; + found.then(|| String::from_utf16_lossy(&buf[..len as usize])) +} diff --git a/crates/botloftd/src/rpc/dispatch.rs b/crates/botloftd/src/rpc/dispatch.rs index b7a6774f..75bbcc15 100644 --- a/crates/botloftd/src/rpc/dispatch.rs +++ b/crates/botloftd/src/rpc/dispatch.rs @@ -8,7 +8,8 @@ use serde_json::Value; use super::jsonrpc::{RpcError, empty_params}; use crate::approvals; use crate::service::{ - self, ApiResult, attachments, bots, chat, crews, deliveries, messages, tasks, + self, ApiResult, attachments, bots, chat, crews, deliveries, lead, messages, models, modes, + tasks, }; use crate::state::Daemon; @@ -24,11 +25,17 @@ pub fn dispatch(daemon: &Daemon, name: &str, params: Option<Value>) -> Result<Va method::CREWS_CREATE => reply(crews::create(daemon, parse(params)?)), method::CREWS_RENAME => reply(crews::rename(daemon, parse(params)?)), method::CREWS_SET_PAUSED => reply(crews::set_paused(daemon, parse(params)?)), + method::CREWS_SET_WORK_FOLDER => reply(crews::set_work_folder(daemon, parse(params)?)), + method::CREWS_SET_LEAD => reply(lead::set_lead(daemon, parse(params)?)), method::CREWS_ARCHIVE => reply(crews::archive(daemon, parse(params)?)), method::BOTS_LIST => reply(bots::list(daemon, parse(params)?)), method::BOTS_CREATE => reply(bots::create(daemon, parse(params)?)), method::BOTS_UPDATE => reply(bots::update(daemon, parse(params)?)), method::BOTS_SET_PAUSED => reply(bots::set_paused(daemon, parse(params)?)), + method::BOTS_SET_PERMISSION_MODE => { + reply(modes::set_permission_mode(daemon, parse(params)?)) + } + method::BOTS_SET_MODEL => reply(models::set_model(daemon, parse(params)?)), method::BOTS_ARCHIVE => reply(bots::archive(daemon, parse(params)?)), method::BOTS_RESTART => reply(bots::restart(daemon, parse(params)?)), method::CHAT_HISTORY => reply(chat::history(daemon, parse(params)?)), diff --git a/crates/botloftd/src/runtime/claude.rs b/crates/botloftd/src/runtime/claude.rs index 68509653..08ec832a 100644 --- a/crates/botloftd/src/runtime/claude.rs +++ b/crates/botloftd/src/runtime/claude.rs @@ -6,6 +6,10 @@ use std::path::{Path, PathBuf}; use std::process::{Command, Output, Stdio}; use std::time::{Duration, Instant}; +use botloft_core::protocol::ClaudeAccount; + +use super::AuthStatus; + /// First version with the inbox as a named pipe on native Windows. pub const MIN_VERSION: (u32, u32, u32) = (2, 1, 234); const PROBE_TIMEOUT: Duration = Duration::from_secs(15); @@ -108,16 +112,34 @@ pub fn probe(path: &Path, env: &[(OsString, OsString)]) -> Result<Claude, Claude /// Runs `claude auth status`, documented to print JSON with `loggedIn` and /// to exit with 0 when signed in and 1 when not (spec 19). -pub fn signed_in(path: &Path, env: &[(OsString, OsString)]) -> io::Result<bool> { +pub fn auth_status(path: &Path, env: &[(OsString, OsString)]) -> io::Result<AuthStatus> { let output = run(path, &["auth", "status", "--json"], env)?; - Ok(parse_signed_in(&output.stdout).unwrap_or(output.status.success())) + Ok(parse_auth_status(&output.stdout).unwrap_or(AuthStatus { + signed_in: output.status.success(), + account: None, + })) } -fn parse_signed_in(stdout: &[u8]) -> Option<bool> { - serde_json::from_slice::<serde_json::Value>(stdout) - .ok()? - .get("loggedIn")? - .as_bool() +/// Reads `loggedIn`, and when signed in `email`, `subscriptionType` and +/// `orgName` (seen with 2.1.284). +fn parse_auth_status(stdout: &[u8]) -> Option<AuthStatus> { + let json = serde_json::from_slice::<serde_json::Value>(stdout).ok()?; + let signed_in = json.get("loggedIn")?.as_bool()?; + let text = |key: &str| { + json.get(key) + .and_then(|value| value.as_str()) + .map(str::trim) + .filter(|value| !value.is_empty()) + .map(str::to_owned) + }; + Some(AuthStatus { + signed_in, + account: signed_in.then(|| ClaudeAccount { + email: text("email"), + plan: text("subscriptionType"), + organization: text("orgName"), + }), + }) } /// Runs Claude Code without a window and with `env` only, giving up after @@ -176,16 +198,31 @@ mod tests { } #[test] - fn reads_the_sign_in_from_auth_status() { + fn reads_the_sign_in_and_account_from_auth_status() { + let signed_in = parse_auth_status( + br#"{"loggedIn": true, "authMethod": "claude.ai", "email": "ana@example.com", + "orgName": "Exemplo", "subscriptionType": "max"}"#, + ) + .expect("parsed"); + assert!(signed_in.signed_in); assert_eq!( - parse_signed_in(br#"{"loggedIn": true, "authMethod": "claude.ai"}"#), - Some(true) + signed_in.account, + Some(ClaudeAccount { + email: Some("ana@example.com".into()), + plan: Some("max".into()), + organization: Some("Exemplo".into()), + }) ); + let signed_out = + parse_auth_status(br#"{"loggedIn": false, "authMethod": "none"}"#).expect("parsed"); assert_eq!( - parse_signed_in(br#"{"loggedIn": false, "authMethod": "none"}"#), - Some(false) + signed_out, + AuthStatus { + signed_in: false, + account: None + } ); - assert_eq!(parse_signed_in(b"Logged in"), None); + assert_eq!(parse_auth_status(b"Logged in"), None); } #[test] diff --git a/crates/botloftd/src/runtime/fake.rs b/crates/botloftd/src/runtime/fake.rs index 0a2a158c..c7f95b4e 100644 --- a/crates/botloftd/src/runtime/fake.rs +++ b/crates/botloftd/src/runtime/fake.rs @@ -12,7 +12,11 @@ use tokio::sync::{Notify, mpsc}; use serde_json::Value; -use super::{EVENT_BUFFER, Process, ProcessControl, ProcessEvent, Runtime, SignInCheck, SpawnSpec}; +use botloft_core::protocol::ClaudeAccount; + +use super::{ + AuthCheck, AuthStatus, EVENT_BUFFER, Process, ProcessControl, ProcessEvent, Runtime, SpawnSpec, +}; #[derive(Clone, Default)] pub struct FakeRuntime { @@ -93,10 +97,18 @@ impl FakeRuntime { } impl Runtime for FakeRuntime { - fn signed_in(&self, _program: std::path::PathBuf) -> SignInCheck { + fn auth_status(&self, _program: std::path::PathBuf) -> AuthCheck { let mut state = lock(&self.state); state.sign_in_checks += 1; - Box::pin(std::future::ready(Ok(state.signed_in))) + let signed_in = state.signed_in; + Box::pin(std::future::ready(Ok(AuthStatus { + signed_in, + account: signed_in.then(|| ClaudeAccount { + email: Some("owner@example.com".into()), + plan: Some("max".into()), + organization: None, + }), + }))) } fn spawn(&self, spec: SpawnSpec) -> io::Result<Process> { diff --git a/crates/botloftd/src/runtime/mod.rs b/crates/botloftd/src/runtime/mod.rs index 54ffe902..49591ac9 100644 --- a/crates/botloftd/src/runtime/mod.rs +++ b/crates/botloftd/src/runtime/mod.rs @@ -12,6 +12,7 @@ use std::io; use std::path::PathBuf; use std::pin::Pin; +use botloft_core::protocol::ClaudeAccount; use bytes::Bytes; use tokio::sync::mpsc; @@ -49,13 +50,21 @@ pub struct Process { pub control: Box<dyn ProcessControl>, } -/// The answer to "is Claude Code signed in?", computed off the async workers. -pub type SignInCheck = Pin<Box<dyn Future<Output = io::Result<bool>> + Send>>; +/// What `claude auth status` says: signed in or not, and to which account. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct AuthStatus { + pub signed_in: bool, + pub account: Option<ClaudeAccount>, +} + +/// An [`AuthStatus`], computed off the async workers. +pub type AuthCheck = Pin<Box<dyn Future<Output = io::Result<AuthStatus>> + Send>>; pub trait Runtime: Send + Sync + 'static { fn spawn(&self, spec: SpawnSpec) -> io::Result<Process>; - /// Whether the Claude Code at `program` is signed in (`claude auth status`). - fn signed_in(&self, program: PathBuf) -> SignInCheck; + /// Whether the Claude Code at `program` is signed in, and to which + /// account (`claude auth status`). + fn auth_status(&self, program: PathBuf) -> AuthCheck; } /// Capacity of the event channel between a process and the daemon. When it diff --git a/crates/botloftd/src/runtime/pipe.rs b/crates/botloftd/src/runtime/pipe.rs index 66a344b8..67ffd4d0 100644 --- a/crates/botloftd/src/runtime/pipe.rs +++ b/crates/botloftd/src/runtime/pipe.rs @@ -13,7 +13,7 @@ use tokio::sync::mpsc; use tracing::debug; use super::{ - EVENT_BUFFER, Process, ProcessControl, ProcessEvent, Runtime, SignInCheck, SpawnSpec, claude, + AuthCheck, EVENT_BUFFER, Process, ProcessControl, ProcessEvent, Runtime, SpawnSpec, claude, }; use crate::platform::{self, ProcessJob}; @@ -24,11 +24,11 @@ const STDERR_LINE_MAX: usize = 300; pub struct PipeRuntime; impl Runtime for PipeRuntime { - fn signed_in(&self, program: std::path::PathBuf) -> SignInCheck { + fn auth_status(&self, program: std::path::PathBuf) -> AuthCheck { Box::pin(async move { tokio::task::spawn_blocking(move || { let env = platform::user_environment()?; - claude::signed_in(&program, &env) + claude::auth_status(&program, &env) }) .await .map_err(io::Error::other)? diff --git a/crates/botloftd/src/service/bots.rs b/crates/botloftd/src/service/bots.rs index c69262b5..3b3f57f1 100644 --- a/crates/botloftd/src/service/bots.rs +++ b/crates/botloftd/src/service/bots.rs @@ -2,8 +2,8 @@ use botloft_core::ids::{BotId, CrewId}; use botloft_core::protocol::{ - Bot, BotIdParams, BotState, BotsCreateParams, BotsListParams, BotsRestartParams, - BotsSetPausedParams, BotsUpdateParams, Crew, + Bot, BotIdParams, BotModel, BotState, BotsCreateParams, BotsListParams, BotsRestartParams, + BotsSetPausedParams, BotsUpdateParams, Crew, PermissionMode, }; use botloft_core::{avatar, now_ms, slug, validate}; use botloft_store::{BotRecord, Store}; @@ -32,16 +32,62 @@ pub fn list(daemon: &Daemon, params: BotsListParams) -> ApiResult<Vec<Bot>> { } pub fn create(daemon: &Daemon, params: BotsCreateParams) -> ApiResult<Bot> { - let name = validate::name("name", ¶ms.name)?; - let role = validate::role(¶ms.role)?; - let instructions = validate::instructions(¶ms.instructions)?; + let new = NewBot::check( + ¶ms.name, + ¶ms.role, + ¶ms.instructions, + params.color, + params.model, + )?; let store = daemon.store(); let crew = crews::active(&store, ¶ms.crew_id)?; + let record = insert(daemon, &store, &crew, BotId::generate(), new)?; + let bot = changed(daemon, &store, &crew, record); + daemon.supervisor.wake(); + Ok(bot) +} + +/// The fields of a new bot, checked. +pub(crate) struct NewBot { + pub name: String, + pub role: String, + pub instructions: String, + pub color: Option<String>, + pub model: BotModel, +} + +impl NewBot { + pub(crate) fn check( + name: &str, + role: &str, + instructions: &str, + color: Option<String>, + model: Option<BotModel>, + ) -> ApiResult<Self> { + Ok(Self { + name: validate::name("name", name)?, + role: validate::role(role)?, + instructions: validate::instructions(instructions)?, + color: color.as_deref().map(parse_color).transpose()?, + model: model.unwrap_or(BotModel::Default), + }) + } +} - let handle = slug::slugify(&name, "bot"); - ensure_handle_free(&store, &crew.id, &handle, None)?; - let color = match params.color { - Some(color) => parse_color(&color)?, +/// Saves a bot in `crew` and writes its workspace, under the caller's lock +/// on the store; the caller announces it and wakes the supervisor. When +/// `crew.lead_bot_id` already names `id`, its rules say it leads. +pub(crate) fn insert( + daemon: &Daemon, + store: &Store, + crew: &Crew, + id: BotId, + new: NewBot, +) -> ApiResult<BotRecord> { + let handle = slug::slugify(&new.name, "bot"); + ensure_handle_free(store, &crew.id, &handle, None)?; + let color = match new.color { + Some(color) => color, None => avatar::palette_color(store.count_bots(&crew.id)?).to_owned(), }; let slug = pick_slug(&handle, |candidate| { @@ -51,23 +97,24 @@ pub fn create(daemon: &Daemon, params: BotsCreateParams) -> ApiResult<Bot> { })?; let record = BotRecord { - id: BotId::generate(), + id, crew_id: crew.id.clone(), - name, + name: new.name, handle, slug, - role, - instructions, + role: new.role, + instructions: new.instructions, color, paused: false, + permission_mode: PermissionMode::Default, + model: new.model, + model_in_use: None, created_at: now_ms(), archived_at: None, }; - workspace::prepare_bot(daemon.workspace_env(), &crew, &record).map_err(ApiError::Workspace)?; + workspace::prepare_bot(daemon.workspace_env(), crew, &record).map_err(ApiError::Workspace)?; store.insert_bot(&record)?; - let bot = changed(daemon, &store, &crew, record); - daemon.supervisor.wake(); - Ok(bot) + Ok(record) } pub fn update(daemon: &Daemon, params: BotsUpdateParams) -> ApiResult<Bot> { @@ -135,6 +182,7 @@ pub fn archive(daemon: &Daemon, params: BotIdParams) -> ApiResult<Bot> { } record.archived_at = Some(now_ms()); store.update_bot(&record)?; + super::lead::forget_archived(daemon, &store, &crew, &record.id)?; let bot = changed(daemon, &store, &crew, record); daemon.supervisor.wake(); Ok(bot) @@ -166,6 +214,9 @@ pub(crate) fn to_protocol(daemon: &Daemon, store: &Store, crew: &Crew, record: B instructions: record.instructions, color: record.color, paused: record.paused, + permission_mode: record.permission_mode, + model: record.model, + model_in_use: record.model_in_use, state, generation, workspace: workspace.to_string_lossy().into_owned(), @@ -175,7 +226,7 @@ pub(crate) fn to_protocol(daemon: &Daemon, store: &Store, crew: &Crew, record: B } } -fn changed(daemon: &Daemon, store: &Store, crew: &Crew, record: BotRecord) -> Bot { +pub(crate) fn changed(daemon: &Daemon, store: &Store, crew: &Crew, record: BotRecord) -> Bot { let bot = to_protocol(daemon, store, crew, record); daemon.emit(Event::BotChanged(bot.clone())); bot @@ -197,7 +248,7 @@ pub(crate) fn active(store: &Store, id: &BotId) -> ApiResult<(Crew, BotRecord)> Ok((crew, record)) } -fn ensure_handle_free( +pub(crate) fn ensure_handle_free( store: &Store, crew: &CrewId, handle: &str, diff --git a/crates/botloftd/src/service/crews.rs b/crates/botloftd/src/service/crews.rs index b9bc65e7..67e4d8ae 100644 --- a/crates/botloftd/src/service/crews.rs +++ b/crates/botloftd/src/service/crews.rs @@ -3,17 +3,23 @@ use botloft_core::ids::CrewId; use botloft_core::protocol::{ Crew, CrewIdParams, CrewsCreateParams, CrewsRenameParams, CrewsSetPausedParams, + CrewsSetWorkFolderParams, }; use botloft_core::{now_ms, slug, validate}; use botloft_store::Store; use tracing::warn; +use super::bots::NewBot; use super::{ApiError, ApiResult, bots, pick_slug}; use crate::state::{Daemon, Event}; use crate::workspace; pub fn list(daemon: &Daemon) -> ApiResult<Vec<Crew>> { - Ok(daemon.store().crews(false)?) + let crews = daemon.store().crews(false)?; + Ok(crews + .into_iter() + .map(|crew| present(daemon, crew)) + .collect()) } pub fn create(daemon: &Daemon, params: CrewsCreateParams) -> ApiResult<Crew> { @@ -23,18 +29,40 @@ pub fn create(daemon: &Daemon, params: CrewsCreateParams) -> ApiResult<Crew> { let slug = pick_slug(&slug::slugify(&name, "crew"), |candidate| { Ok(store.crew_slug_exists(candidate)? || daemon.paths.crew_dir(candidate).exists()) })?; - workspace::prepare_crew(&daemon.paths, &slug).map_err(ApiError::Workspace)?; + let chosen = params + .work_folder + .as_deref() + .map(|input| choose_folder(daemon, input)) + .transpose()?; - let crew = Crew { + let lead = params + .lead + .map(|lead| NewBot::check(&lead.name, &lead.role, &lead.instructions, None, lead.model)) + .transpose()?; + + let mut crew = Crew { id: CrewId::generate(), name, slug, + work_folder_chosen: chosen.is_some(), + work_folder: chosen.unwrap_or_default(), + lead_bot_id: None, paused: false, created_at: now_ms(), archived_at: None, }; + workspace::prepare_crew(&daemon.paths, &crew).map_err(ApiError::Workspace)?; store.insert_crew(&crew)?; - daemon.emit(Event::CrewChanged(crew.clone())); + // The chief is saved before the store is let go, so it starts as one. + let chief = match lead { + Some(lead) => Some(super::lead::create_chief(daemon, &store, &mut crew, lead)?), + None => None, + }; + let crew = changed(daemon, crew); + if let Some(chief) = chief { + bots::changed(daemon, &store, &crew, chief); + daemon.supervisor.wake(); + } Ok(crew) } @@ -51,8 +79,41 @@ pub fn rename(daemon: &Daemon, params: CrewsRenameParams) -> ApiResult<Crew> { warn!(bot = %bot.id, "could not refresh the bot rules after a crew rename: {err}"); } } - daemon.emit(Event::CrewChanged(crew.clone())); - Ok(crew) + Ok(changed(daemon, crew)) +} + +/// Moves the crew to another work folder, or back to `shared`. Each bot +/// restarts to reach it once nothing is in progress (spec 7.4). +pub fn set_work_folder(daemon: &Daemon, params: CrewsSetWorkFolderParams) -> ApiResult<Crew> { + let chosen = params + .work_folder + .as_deref() + .map(|input| choose_folder(daemon, input)) + .transpose()?; + let store = daemon.store(); + let mut crew = active(&store, ¶ms.crew_id)?; + if crew.work_folder_chosen == chosen.is_some() + && chosen + .as_deref() + .is_none_or(|path| path == crew.work_folder) + { + return Ok(present(daemon, crew)); + } + crew.work_folder_chosen = chosen.is_some(); + crew.work_folder = chosen.unwrap_or_default(); + workspace::prepare_crew(&daemon.paths, &crew).map_err(ApiError::Workspace)?; + store.update_crew(&crew)?; + + let bots = store.bots(Some(&crew.id), false)?; + drop(store); + for bot in &bots { + if let Err(err) = workspace::write_rules(&daemon.paths, &crew, bot) { + warn!(bot = %bot.id, "could not refresh the bot rules after a folder change: {err}"); + } + daemon.supervisor.launch_settings_changed(&bot.id); + } + tracing::info!(crew = %crew.id, "work folder changed"); + Ok(changed(daemon, crew)) } pub fn set_paused(daemon: &Daemon, params: CrewsSetPausedParams) -> ApiResult<Crew> { @@ -61,10 +122,11 @@ pub fn set_paused(daemon: &Daemon, params: CrewsSetPausedParams) -> ApiResult<Cr if crew.paused != params.paused { crew.paused = params.paused; store.update_crew(&crew)?; - daemon.emit(Event::CrewChanged(crew.clone())); + let crew = changed(daemon, crew); daemon.supervisor.wake(); + return Ok(crew); } - Ok(crew) + Ok(present(daemon, crew)) } /// Archives the crew and its bots. Archiving twice is not an error. @@ -72,7 +134,7 @@ pub fn archive(daemon: &Daemon, params: CrewIdParams) -> ApiResult<Crew> { let store = daemon.store(); let crew = find(&store, ¶ms.crew_id)?; if crew.archived_at.is_some() { - return Ok(crew); + return Ok(present(daemon, crew)); } let bots = store.bots(Some(&crew.id), false)?; store.archive_crew(&crew.id, now_ms())?; @@ -85,11 +147,31 @@ pub fn archive(daemon: &Daemon, params: CrewIdParams) -> ApiResult<Crew> { ))); } } - daemon.emit(Event::CrewChanged(crew.clone())); + let crew = changed(daemon, crew); daemon.supervisor.wake(); Ok(crew) } +/// The crew as the app sees it: with the path of its `shared` folder when +/// the owner chose none. +pub(crate) fn present(daemon: &Daemon, mut crew: Crew) -> Crew { + if !crew.work_folder_chosen { + crew.work_folder = daemon.paths.work_folder(&crew).display().to_string(); + } + crew +} + +pub(crate) fn changed(daemon: &Daemon, crew: Crew) -> Crew { + let crew = present(daemon, crew); + daemon.emit(Event::CrewChanged(crew.clone())); + crew +} + +fn choose_folder(daemon: &Daemon, input: &str) -> ApiResult<String> { + let path = workspace::folder::choose(&daemon.paths, input).map_err(ApiError::validation)?; + Ok(path.display().to_string()) +} + pub(crate) fn find(store: &Store, id: &CrewId) -> ApiResult<Crew> { store .crew(id)? diff --git a/crates/botloftd/src/service/lead.rs b/crates/botloftd/src/service/lead.rs new file mode 100644 index 00000000..c288fa87 --- /dev/null +++ b/crates/botloftd/src/service/lead.rs @@ -0,0 +1,132 @@ +//! A crew's chief (spec 10.2): created with the crew, moved by the owner, +//! and the only bot that may suggest new ones. + +use botloft_core::ids::BotId; +use botloft_core::protocol::{Bot, Crew, CrewsSetLeadParams}; +use botloft_store::{BotRecord, Store}; +use tracing::{info, warn}; + +use super::bots::{self, NewBot}; +use super::{ApiError, ApiResult, crews}; +use crate::state::Daemon; +use crate::workspace; + +pub(crate) fn is_lead(crew: &Crew, bot: &BotId) -> bool { + crew.lead_bot_id.as_ref() == Some(bot) +} + +/// Saves the chief of a crew being created, under the caller's lock, so its +/// first start already reads that it leads. +pub(crate) fn create_chief( + daemon: &Daemon, + store: &Store, + crew: &mut Crew, + lead: NewBot, +) -> ApiResult<BotRecord> { + let id = BotId::generate(); + crew.lead_bot_id = Some(id.clone()); + let record = bots::insert(daemon, store, crew, id, lead)?; + store.update_crew(crew)?; + Ok(record) +} + +/// Makes a bot of the crew its chief, or leaves the crew without one. The +/// old and the new chief restart to read their rules once idle. +pub fn set_lead(daemon: &Daemon, params: CrewsSetLeadParams) -> ApiResult<Crew> { + let store = daemon.store(); + let mut crew = crews::active(&store, ¶ms.crew_id)?; + if let Some(bot) = ¶ms.bot_id { + let (bot_crew, _) = bots::active(&store, bot)?; + if bot_crew.id != crew.id { + return Err(ApiError::validation(format!( + "bot {bot} is not in crew {}", + crew.id + ))); + } + } + if crew.lead_bot_id == params.bot_id { + return Ok(crews::present(daemon, crew)); + } + let old = std::mem::replace(&mut crew.lead_bot_id, params.bot_id.clone()); + store.update_crew(&crew)?; + + let touched: Vec<BotId> = old.into_iter().chain(params.bot_id).collect(); + for id in &touched { + match store.bot(id) { + Ok(Some(record)) if record.archived_at.is_none() => { + if let Err(err) = workspace::write_rules(&daemon.paths, &crew, &record) { + warn!(bot = %id, "could not refresh the rules of a chief: {err}"); + } + } + Ok(_) => {} + Err(err) => warn!(bot = %id, "could not read a chief: {err}"), + } + } + drop(store); + for id in &touched { + daemon.supervisor.launch_settings_changed(id); + } + info!(crew = %crew.id, "chief changed"); + Ok(crews::changed(daemon, crew)) +} + +/// An archived chief leaves its crew without one. +pub(crate) fn forget_archived( + daemon: &Daemon, + store: &Store, + crew: &Crew, + bot: &BotId, +) -> ApiResult<()> { + if !is_lead(crew, bot) { + return Ok(()); + } + let mut crew = crew.clone(); + crew.lead_bot_id = None; + store.update_crew(&crew)?; + crews::changed(daemon, crew); + Ok(()) +} + +/// Whether the chief `lead` may add `new` to its crew now: it still leads, +/// the name is free and the crew has room. Checked before asking the owner +/// and again when creating. +pub(crate) fn check_suggestion(daemon: &Daemon, lead: &BotId, new: &NewBot) -> ApiResult<()> { + let store = daemon.store(); + room_for(daemon, &store, lead, new).map(drop) +} + +/// Creates a bot the chief suggested and the owner allowed (spec 10.2). +pub(crate) fn create_suggested(daemon: &Daemon, lead: &BotId, new: NewBot) -> ApiResult<Bot> { + let store = daemon.store(); + let crew = room_for(daemon, &store, lead, &new)?; + let record = bots::insert(daemon, &store, &crew, BotId::generate(), new)?; + let bot = bots::changed(daemon, &store, &crew, record); + drop(store); + daemon.supervisor.wake(); + info!(crew = %crew.id, bot = %bot.id, "the chief's suggested bot was created"); + Ok(bot) +} + +fn room_for(daemon: &Daemon, store: &Store, lead: &BotId, new: &NewBot) -> ApiResult<Crew> { + let (crew, _) = bots::active(store, lead)?; + if !is_lead(&crew, lead) { + return Err(ApiError::Conflict( + "only the crew's chief can suggest new bots; ask the chief with send_message".into(), + )); + } + let size = store.bots(Some(&crew.id), false)?.len(); + let max = daemon.bots.max_per_crew; + if size >= max { + return Err(ApiError::Conflict(format!( + "the crew already has {size} bots, the most a chief can reach ({max}); \ + use the bots you have, or ask the owner to archive one" + ))); + } + bots::ensure_handle_free( + store, + &crew.id, + &botloft_core::slug::slugify(&new.name, "bot"), + None, + )?; + Ok(crew) +} diff --git a/crates/botloftd/src/service/mod.rs b/crates/botloftd/src/service/mod.rs index b3c42fe4..108e5c7f 100644 --- a/crates/botloftd/src/service/mod.rs +++ b/crates/botloftd/src/service/mod.rs @@ -6,10 +6,13 @@ pub mod bots; pub mod chat; pub mod crews; pub mod deliveries; +pub mod lead; pub mod messages; +pub mod models; +pub mod modes; pub mod tasks; -use botloft_core::protocol::{PROTOCOL_VERSION, SystemStatus, error_code}; +use botloft_core::protocol::{OwnerAccount, PROTOCOL_VERSION, SystemStatus, error_code}; use botloft_core::slug; use botloft_core::validate::ValidationError; use botloft_store::StoreError; @@ -58,6 +61,13 @@ impl From<StoreError> for ApiError { pub type ApiResult<T> = Result<T, ApiError>; +/// The owner's name, asked of Windows once: it does not change while the +/// daemon runs. +fn owner_name() -> String { + static NAME: std::sync::OnceLock<String> = std::sync::OnceLock::new(); + NAME.get_or_init(crate::platform::owner_name).clone() +} + pub fn status(daemon: &Daemon) -> ApiResult<SystemStatus> { let deliveries = daemon.store().delivery_backlog()?; Ok(SystemStatus { @@ -71,6 +81,10 @@ pub fn status(daemon: &Daemon) -> ApiResult<SystemStatus> { .claude_path() .map(|path| path.display().to_string()), claude_signed_in: daemon.supervisor.claude_signed_in(), + account: OwnerAccount { + name: owner_name(), + claude: daemon.supervisor.claude_account(), + }, deliveries, usage: daemon.usage(), }) diff --git a/crates/botloftd/src/service/models.rs b/crates/botloftd/src/service/models.rs new file mode 100644 index 00000000..3a1b76a0 --- /dev/null +++ b/crates/botloftd/src/service/models.rs @@ -0,0 +1,44 @@ +//! A bot's model (spec 7.4): what the owner picks, and the model Claude +//! Code reports at the start of each turn. + +use botloft_core::ids::BotId; +use botloft_core::protocol::{Bot, BotsSetModelParams}; +use tracing::{info, warn}; + +use super::ApiResult; +use super::bots::{active, changed, to_protocol}; +use crate::state::Daemon; + +/// Saves the model; the bot restarts on it when nothing is in progress. +pub fn set_model(daemon: &Daemon, params: BotsSetModelParams) -> ApiResult<Bot> { + let store = daemon.store(); + let (crew, mut record) = active(&store, ¶ms.bot_id)?; + if record.model == params.model { + return Ok(to_protocol(daemon, &store, &crew, record)); + } + record.model = params.model; + store.update_bot(&record)?; + let bot = changed(daemon, &store, &crew, record); + drop(store); + info!(bot = %params.bot_id, model = params.model.as_str(), "model changed"); + daemon.supervisor.launch_settings_changed(¶ms.bot_id); + Ok(bot) +} + +/// The model id in `system/init`, so the app can name the model a bot +/// really runs on, the plan's default included. +pub(crate) fn reported(daemon: &Daemon, bot: &BotId, model: &str) { + let store = daemon.store(); + let Ok((crew, mut record)) = active(&store, bot) else { + return; + }; + if model.is_empty() || record.model_in_use.as_deref() == Some(model) { + return; + } + if let Err(err) = store.set_model_in_use(bot, model) { + warn!(bot = %bot, "could not save the model in use: {err}"); + return; + } + record.model_in_use = Some(model.to_owned()); + changed(daemon, &store, &crew, record); +} diff --git a/crates/botloftd/src/service/modes.rs b/crates/botloftd/src/service/modes.rs new file mode 100644 index 00000000..85a02c91 --- /dev/null +++ b/crates/botloftd/src/service/modes.rs @@ -0,0 +1,55 @@ +//! A bot's permission mode (spec 7.4): what the owner picks in the chat, +//! and what Claude Code reports when it changes the mode by itself. + +use botloft_core::ids::BotId; +use botloft_core::protocol::{Bot, BotsSetPermissionModeParams, PermissionMode}; +use tracing::{info, warn}; + +use super::ApiResult; +use super::bots::{active, changed, to_protocol}; +use crate::state::Daemon; + +/// Saves the mode; the bot restarts into it when nothing is in progress. +pub fn set_permission_mode(daemon: &Daemon, params: BotsSetPermissionModeParams) -> ApiResult<Bot> { + let store = daemon.store(); + let (crew, mut record) = active(&store, ¶ms.bot_id)?; + if record.permission_mode == params.mode { + return Ok(to_protocol(daemon, &store, &crew, record)); + } + record.permission_mode = params.mode; + store.update_bot(&record)?; + let bot = changed(daemon, &store, &crew, record); + drop(store); + info!(bot = %params.bot_id, mode = params.mode.as_str(), "permission mode changed"); + daemon.supervisor.launch_settings_changed(¶ms.bot_id); + Ok(bot) +} + +/// The mode Claude Code reports in `system/init`. It leaves plan mode by +/// itself when the owner approves a plan; the stored mode follows, so the +/// app shows what the bot does and a restart keeps it. Any other difference +/// comes from a process that is about to restart into the mode the owner +/// just picked, and is ignored. +pub(crate) fn reported(daemon: &Daemon, bot: &BotId, reported: &str) { + let Some(mode) = PermissionMode::from_cli(reported) else { + return; + }; + if mode == PermissionMode::Plan + || daemon.supervisor.launched_mode(bot) != Some(PermissionMode::Plan) + { + return; + } + let store = daemon.store(); + let Ok((crew, mut record)) = active(&store, bot) else { + return; + }; + if record.permission_mode != PermissionMode::Plan { + return; + } + record.permission_mode = mode; + if let Err(err) = store.update_bot(&record) { + warn!(bot = %bot, "could not save the mode after the plan: {err}"); + return; + } + changed(daemon, &store, &crew, record); +} diff --git a/crates/botloftd/src/state.rs b/crates/botloftd/src/state.rs index bbba196a..318b18b0 100644 --- a/crates/botloftd/src/state.rs +++ b/crates/botloftd/src/state.rs @@ -44,6 +44,8 @@ pub struct BotSettings { pub approval_timeout: Duration, /// Largest attachment, per file (spec 9.5). pub attachment_max_bytes: u64, + /// Most bots a chief's suggestions can bring a crew to (spec 10.2). + pub max_per_crew: usize, } impl BotSettings { @@ -51,6 +53,7 @@ impl BotSettings { Self { approval_timeout: Duration::from_secs(config.bots.approval_timeout_minutes * 60), attachment_max_bytes: config.bots.attachment_max_mb * 1024 * 1024, + max_per_crew: config.bots.max_per_crew, } } } diff --git a/crates/botloftd/src/supervisor/mod.rs b/crates/botloftd/src/supervisor/mod.rs index 8724f696..0a4f83c0 100644 --- a/crates/botloftd/src/supervisor/mod.rs +++ b/crates/botloftd/src/supervisor/mod.rs @@ -6,6 +6,7 @@ //! (service calls read states), never the other way around. mod reconcile; +mod relaunch; mod settings; mod sign_in; mod slot; diff --git a/crates/botloftd/src/supervisor/relaunch.rs b/crates/botloftd/src/supervisor/relaunch.rs new file mode 100644 index 00000000..21f9626c --- /dev/null +++ b/crates/botloftd/src/supervisor/relaunch.rs @@ -0,0 +1,65 @@ +//! A new launch setting reaches the bot (spec 7.4): its permission mode or +//! its model. Claude Code only reads `--permission-mode` and `--model` when +//! it starts, so the process restarts, resuming the conversation, as soon +//! as nothing is in progress: at once when idle, or when the turn that is +//! running (and its approvals) ends. + +use botloft_core::ids::BotId; +use botloft_core::protocol::PermissionMode; +use tracing::warn; + +use super::Supervisor; +use super::slot::{Slot, StopIntent}; + +impl Supervisor { + pub fn launch_settings_changed(&self, bot: &BotId) { + let mut inner = self.lock(); + let Some(slot) = inner.slots.get_mut(bot) else { + return; + }; + if slot.running.is_none() || slot.stop.is_some() { + // The next start reads the new settings anyway. + return; + } + if slot.turns == 0 && slot.approvals == 0 { + self.relaunch(bot, slot); + } else { + slot.restart_when_idle = true; + } + } + + /// Whether new settings wait for the running turn to end. + pub fn relaunch_pending(&self, bot: &BotId) -> bool { + self.lock() + .slots + .get(bot) + .is_some_and(|slot| slot.restart_when_idle) + } + + /// The `--permission-mode` the running process started with. + pub fn launched_mode(&self, bot: &BotId) -> Option<PermissionMode> { + self.lock() + .slots + .get(bot) + .and_then(|slot| slot.running.as_ref()) + .map(|running| running.permission_mode) + } + + /// Called when a turn or an approval ends. + pub(super) fn relaunch_if_idle(&self, bot: &BotId, slot: &mut Slot) { + if slot.restart_when_idle && slot.turns == 0 && slot.approvals == 0 && slot.stop.is_none() { + self.relaunch(bot, slot); + } + } + + fn relaunch(&self, bot: &BotId, slot: &mut Slot) { + slot.restart_when_idle = false; + slot.stop = Some(StopIntent::Restart { fresh: false }); + if let Some(running) = &slot.running + && let Err(err) = running.control.kill() + { + warn!(bot = %bot, "could not restart the bot for its new settings: {err}"); + } + self.wake(); + } +} diff --git a/crates/botloftd/src/supervisor/sign_in.rs b/crates/botloftd/src/supervisor/sign_in.rs index f1afec03..d9170e2d 100644 --- a/crates/botloftd/src/supervisor/sign_in.rs +++ b/crates/botloftd/src/supervisor/sign_in.rs @@ -4,7 +4,7 @@ //! When it turns from signed out to signed in, the bots a sign-in error //! stopped start again by themselves: the owner just signed in. -use botloft_core::protocol::BotState; +use botloft_core::protocol::{BotState, ClaudeAccount}; use tokio::time::Instant; use tracing::{debug, info}; @@ -13,6 +13,7 @@ use super::{ClaudeStatus, Inner, REPROBE_AFTER, Supervisor}; #[derive(Debug, Default)] pub(super) struct SignIn { known: Option<bool>, + account: Option<ClaudeAccount>, checked_at: Option<Instant>, recheck: bool, } @@ -36,6 +37,11 @@ impl Supervisor { self.lock().sign_in.known } + /// The Claude account Claude Code is signed in to, once checked. + pub fn claude_account(&self) -> Option<ClaudeAccount> { + self.lock().sign_in.account.clone() + } + /// Checks Claude Code again now: the sign-in, and the executable if it /// was missing or too old (after the owner signed in or installed it). pub fn refresh_claude(&self) { @@ -64,12 +70,14 @@ impl Supervisor { _ => return, } }; - let checked = self.runtime.signed_in(program).await; + let checked = self.runtime.auth_status(program).await; let mut inner = self.lock(); inner.sign_in.recheck = false; inner.sign_in.checked_at = Some(Instant::now()); match checked { - Ok(signed_in) => { + Ok(status) => { + let signed_in = status.signed_in; + inner.sign_in.account = status.account; let was = inner.sign_in.known.replace(signed_in); if signed_in && was == Some(false) { info!("Claude Code is signed in again; starting the bots it stopped"); diff --git a/crates/botloftd/src/supervisor/slot.rs b/crates/botloftd/src/supervisor/slot.rs index 2f911930..7b1b605e 100644 --- a/crates/botloftd/src/supervisor/slot.rs +++ b/crates/botloftd/src/supervisor/slot.rs @@ -2,7 +2,7 @@ use std::time::Duration; -use botloft_core::protocol::BotState; +use botloft_core::protocol::{BotState, PermissionMode}; use tokio::time::Instant; use crate::runtime::ProcessControl; @@ -24,6 +24,9 @@ pub(super) struct Slot { pub approvals: u32, /// While `rate_limited`: Unix ms when the limit resets. pub limited_until: Option<i64>, + /// A new permission mode or model waits for the running turn to end + /// (spec 7.4). + pub restart_when_idle: bool, } impl Slot { @@ -39,6 +42,7 @@ impl Slot { turns: 0, approvals: 0, limited_until: None, + restart_when_idle: false, } } @@ -69,6 +73,8 @@ pub(super) struct Running { /// Started with `--resume`. pub resumed: bool, pub token_hash: String, + /// The `--permission-mode` it started with. + pub permission_mode: PermissionMode, } #[derive(Debug, Clone, Copy, PartialEq, Eq)] diff --git a/crates/botloftd/src/supervisor/spawn.rs b/crates/botloftd/src/supervisor/spawn.rs index 00757a4b..911e710b 100644 --- a/crates/botloftd/src/supervisor/spawn.rs +++ b/crates/botloftd/src/supervisor/spawn.rs @@ -23,6 +23,8 @@ use crate::{approvals, courier, workspace}; /// Tools the bot uses without asking: its crew tools (spec 7.4). const ALLOWED_TOOLS: &str = "mcp__botloft"; +/// Makes Claude Code load `CLAUDE.md` from `--add-dir` folders (spec 5). +const ADDITIONAL_MEMORY: &str = "CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD"; /// Where permission requests go (spec 10.1). const PERMISSION_TOOL: &str = "mcp__botloft__permission_prompt"; @@ -67,12 +69,14 @@ impl Supervisor { slot.turns = 0; slot.approvals = 0; slot.limited_until = None; + slot.restart_when_idle = false; tokens.insert(launch.token_hash.clone(), (bot.id.clone(), generation)); slot.running = Some(Running { control: process.control, started: Instant::now(), resumed: launch.resumed, token_hash: launch.token_hash, + permission_mode: bot.permission_mode, }); self.count_busy(slot.state, BotState::Launching); slot.state = BotState::Launching; @@ -197,7 +201,7 @@ fn launch_spec( "project,local", "--strict-mcp-config", "--permission-mode", - "default", + bot.permission_mode.cli_value(), "--permission-prompt-tool", PERMISSION_TOOL, "--allowedTools", @@ -207,6 +211,14 @@ fn launch_spec( args.push(arg.into()); } args.push(mcp.into_os_string()); + // The crew's work folder, which the bot edits like its own (spec 5). + args.push("--add-dir".into()); + args.push(daemon.paths.work_folder(crew).into_os_string()); + // Without the flag, Claude Code uses the default of the owner's plan. + if let Some(model) = bot.model.cli_value() { + args.push("--model".into()); + args.push(model.into()); + } let mut env = platform::user_environment()?; env.retain(|(name, _)| { @@ -219,6 +231,8 @@ fn launch_spec( ("BOTLOFT_BOT_ID", OsString::from(bot.id.as_str())), ("BOTLOFT_BOT_TOKEN", OsString::from(&token)), ("BOTLOFT_PORT", OsString::from(daemon.port.to_string())), + // Loads the work folder's CLAUDE.md with the bot's memory. + (ADDITIONAL_MEMORY, OsString::from("1")), ] { env.push((OsString::from(name), value)); } diff --git a/crates/botloftd/src/supervisor/turns.rs b/crates/botloftd/src/supervisor/turns.rs index 88afbd99..cfab3617 100644 --- a/crates/botloftd/src/supervisor/turns.rs +++ b/crates/botloftd/src/supervisor/turns.rs @@ -44,6 +44,7 @@ impl Supervisor { if slot.is_working() { supervisor.set_state(bot, slot, slot.working_state()); } + supervisor.relaunch_if_idle(bot, slot); }); } diff --git a/crates/botloftd/src/tools/calls.rs b/crates/botloftd/src/tools/calls.rs index 313bae2f..6afe4f5d 100644 --- a/crates/botloftd/src/tools/calls.rs +++ b/crates/botloftd/src/tools/calls.rs @@ -17,7 +17,7 @@ use tracing::warn; use super::Failure; use super::catalog::{COMPLETE_TASK, CREW_ROSTER, MY_TASKS, SEND_MESSAGE}; use crate::service::tasks::{self, BotMessage}; -use crate::service::{ApiError, bots}; +use crate::service::{ApiError, bots, lead}; use crate::state::Daemon; /// What the bot reads when a tool fails. @@ -38,6 +38,11 @@ pub(super) fn call(daemon: &Daemon, bot: &BotId, params: &Value) -> Result<Value MY_TASKS => parse(arguments).and_then(|args| my_tasks(daemon, bot, args)), other => return Err(invalid(&format!("Unknown tool: {other}"))), }; + Ok(tool_result(outcome)) +} + +/// A tool result: the value as JSON text, or the error the bot reads. +pub(super) fn tool_result(outcome: Outcome) -> Value { let (text, is_error) = match outcome { Ok(value) => ( serde_json::to_string_pretty(&value).unwrap_or_default(), @@ -45,23 +50,23 @@ pub(super) fn call(daemon: &Daemon, bot: &BotId, params: &Value) -> Result<Value ), Err(message) => (message, true), }; - Ok(json!({ + json!({ "content": [{ "type": "text", "text": text }], "isError": is_error, - })) + }) } fn invalid(message: &str) -> Failure { Failure::new(StatusCode::OK, error_code::INVALID_PARAMS, message) } -fn parse<T: DeserializeOwned>(arguments: Value) -> Result<T, String> { +pub(super) fn parse<T: DeserializeOwned>(arguments: Value) -> Result<T, String> { serde_json::from_value(arguments).map_err(|err| format!("invalid arguments: {err}")) } /// The message a bot may see. Internal errors can name paths; they go to /// the log instead. -fn explain(err: ApiError) -> String { +pub(super) fn explain(err: ApiError) -> String { match err { ApiError::Internal(_) | ApiError::Workspace(_) => { warn!(error = %err, "a tool call failed"); @@ -81,10 +86,21 @@ fn roster(daemon: &Daemon, bot: &BotId) -> Outcome { .iter() .filter(|other| other.id != me.id) .map(|other| { - json!({ "handle": other.handle, "name": other.name, "role": other.role, "state": other.state }) + json!({ + "handle": other.handle, + "name": other.name, + "role": other.role, + "state": other.state, + "chief": lead::is_lead(&crew, &other.id), + }) }) .collect(); - Ok(json!({ "crew": crew.name, "you": me.handle, "bots": others })) + Ok(json!({ + "crew": crew.name, + "you": me.handle, + "you_lead": lead::is_lead(&crew, &me.id), + "bots": others, + })) } #[derive(Deserialize)] diff --git a/crates/botloftd/src/tools/catalog.rs b/crates/botloftd/src/tools/catalog.rs index 600073bb..ad9952ab 100644 --- a/crates/botloftd/src/tools/catalog.rs +++ b/crates/botloftd/src/tools/catalog.rs @@ -3,12 +3,16 @@ use serde_json::{Value, json}; +use super::suggest::{INSTRUCTIONS_MAX, REASON_MAX}; use crate::service::tasks::MAX_DEADLINE_MINUTES; +use botloft_core::validate::{NAME_MAX_CHARS, ROLE_MAX_CHARS}; pub const CREW_ROSTER: &str = "crew_roster"; pub const SEND_MESSAGE: &str = "send_message"; pub const COMPLETE_TASK: &str = "complete_task"; pub const MY_TASKS: &str = "my_tasks"; +/// The chief's tool (spec 10.2); Claude Code names it `mcp__botloft__suggest_bot`. +pub const SUGGEST_BOT: &str = "suggest_bot"; /// Claude Code's `--permission-prompt-tool` (spec 10.1). pub const PERMISSION_PROMPT: &str = "permission_prompt"; @@ -101,6 +105,50 @@ pub fn tools() -> Value { }, "annotations": { "readOnlyHint": true }, }, + { + "name": SUGGEST_BOT, + "title": "Suggest a new bot", + "description": "Only for the crew's chief (crew_roster marks it). Suggests a new bot \ + for work that needs a specialist the crew lacks. The owner sees the suggestion in \ + your chat, may change it, and approves or declines it; the call waits for that. \ + Once approved the bot starts at once: give it work with send_message. If the owner \ + declines, do the work yourself or with the bots you have.", + "inputSchema": { + "type": "object", + "properties": { + "name": { + "type": "string", + "maxLength": NAME_MAX_CHARS, + "description": "A short name, like \"Designer\". Its handle comes from it.", + }, + "role": { + "type": "string", + "maxLength": ROLE_MAX_CHARS, + "description": "One line: what the bot does in the crew.", + }, + "instructions": { + "type": "string", + "maxLength": INSTRUCTIONS_MAX, + "description": "Written to the new bot: what it works on, how, what it \ + hands back and when to ask.", + }, + "model": { + "type": "string", + "enum": ["default", "fable", "opus", "sonnet", "haiku"], + "description": "\"haiku\" for simple, repetitive work; \"sonnet\" for most \ + work; \"opus\" or \"fable\" for the hardest reasoning. The owner's \ + plan default when absent.", + }, + "reason": { + "type": "string", + "maxLength": REASON_MAX, + "description": "For the owner: why the crew needs this bot now.", + }, + }, + "required": ["name", "role", "instructions", "reason"], + "additionalProperties": false, + }, + }, { "name": PERMISSION_PROMPT, "title": "Permission prompt", diff --git a/crates/botloftd/src/tools/mod.rs b/crates/botloftd/src/tools/mod.rs index 9757df87..f2a00de6 100644 --- a/crates/botloftd/src/tools/mod.rs +++ b/crates/botloftd/src/tools/mod.rs @@ -9,6 +9,7 @@ mod calls; mod catalog; mod era; +mod suggest; use std::sync::Arc; @@ -30,8 +31,9 @@ use crate::state::Daemon; const CACHE_TTL_MS: u64 = 60 * 60 * 1000; const INSTRUCTIONS: &str = "Tools to work with your Botloft crew: see who is in it, send notes \ - or tasks to other bots, and report the result of tasks assigned to you. The owner writes to \ - you directly; messages from other bots and from Botloft start with [botloft]."; + or tasks to other bots, report the result of tasks assigned to you and, for the crew's chief, \ + suggest new bots. The owner writes to you directly; messages from other bots and from Botloft \ + start with [botloft]."; /// A JSON-RPC error with the HTTP status it goes out with. struct Failure { @@ -107,12 +109,16 @@ pub async fn handle( return StatusCode::ACCEPTED.into_response(); }; let answered = match era(&headers, &request) { - // Holds the request until the owner answers (spec 10.1). - Ok(era) if is_permission_prompt(&request) => { + // Both hold the request until the owner answers (spec 10.1, 10.2). + Ok(era) if called(&request) == Some(catalog::PERMISSION_PROMPT) => { permission(&daemon, &bot, generation, &request) .await .map(|result| decorate(era, &request, result)) } + Ok(era) if called(&request) == Some(catalog::SUGGEST_BOT) => { + let result = suggest::suggest(&daemon, &bot, generation, arguments(&request)).await; + Ok(decorate(era, &request, result)) + } Ok(era) => answer(&daemon, &bot, era, &request), Err(failure) => Err(failure), }; @@ -139,14 +145,25 @@ fn json_response(status: StatusCode, body: String) -> Response { (status, [(header::CONTENT_TYPE, "application/json")], body).into_response() } -fn is_permission_prompt(request: &Request) -> bool { - request.method == "tools/call" - && request - .params - .as_ref() - .and_then(|params| params.get("name")) - .and_then(Value::as_str) - == Some(catalog::PERMISSION_PROMPT) +/// The tool a `tools/call` names. +fn called(request: &Request) -> Option<&str> { + if request.method != "tools/call" { + return None; + } + request + .params + .as_ref() + .and_then(|params| params.get("name")) + .and_then(Value::as_str) +} + +fn arguments(request: &Request) -> Value { + request + .params + .as_ref() + .and_then(|params| params.get("arguments")) + .cloned() + .unwrap_or_else(|| json!({})) } async fn permission( @@ -155,19 +172,14 @@ async fn permission( generation: u64, request: &Request, ) -> Result<Value, Failure> { - let arguments = request - .params - .as_ref() - .and_then(|params| params.get("arguments")) - .cloned() - .unwrap_or_else(|| json!({})); - let args: approvals::PromptArgs = serde_json::from_value(arguments).map_err(|err| { - Failure::new( - StatusCode::OK, - error_code::INVALID_PARAMS, - format!("invalid arguments: {err}"), - ) - })?; + let args: approvals::PromptArgs = + serde_json::from_value(arguments(request)).map_err(|err| { + Failure::new( + StatusCode::OK, + error_code::INVALID_PARAMS, + format!("invalid arguments: {err}"), + ) + })?; let decision = approvals::prompt(daemon, bot, generation, args).await; Ok(json!({ "content": [{ "type": "text", "text": decision }], "isError": false })) } diff --git a/crates/botloftd/src/tools/suggest.rs b/crates/botloftd/src/tools/suggest.rs new file mode 100644 index 00000000..81887a37 --- /dev/null +++ b/crates/botloftd/src/tools/suggest.rs @@ -0,0 +1,144 @@ +//! `suggest_bot` (spec 10.2): the crew's chief asks for a new bot. The owner +//! sees the suggestion in the chief's chat, may change it, and allows or +//! declines it; the call waits for that, like a permission request. A chief +//! that bypasses permissions creates the bot at once. + +use botloft_core::chat::SUGGEST_TOOL; +use botloft_core::ids::BotId; +use botloft_core::protocol::{Bot, BotModel, PermissionMode}; +use serde::{Deserialize, Serialize}; +use serde_json::{Value, json}; + +use super::calls::{explain, parse, tool_result}; +use crate::approvals::{self, Answer}; +use crate::service::bots::{self, NewBot}; +use crate::service::lead; +use crate::state::Daemon; + +/// Longest instructions a chief may write for a new bot, in characters. +pub(super) const INSTRUCTIONS_MAX: usize = 8_000; +/// Longest reason, in characters. +pub(super) const REASON_MAX: usize = 1_000; + +/// The tool's input, and what the owner sends back when they change it. +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +struct Suggestion { + name: String, + role: String, + instructions: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + model: Option<String>, + reason: String, +} + +pub(super) async fn suggest( + daemon: &Daemon, + bot: &BotId, + generation: u64, + arguments: Value, +) -> Value { + tool_result(run(daemon, bot, generation, arguments).await) +} + +async fn run( + daemon: &Daemon, + bot: &BotId, + generation: u64, + arguments: Value, +) -> Result<Value, String> { + let suggestion: Suggestion = parse(arguments)?; + let new = check(&suggestion)?; + // Nothing impossible goes to the owner. + lead::check_suggestion(daemon, bot, &new).map_err(explain)?; + let mode = bots::find(&daemon.store(), bot) + .map_err(explain)? + .permission_mode; + if mode == PermissionMode::BypassPermissions { + let created = lead::create_suggested(daemon, bot, new).map_err(explain)?; + return Ok(created_note( + &created, + "You bypass permissions, so it was created without asking the owner.", + )); + } + + let input = serde_json::to_value(&suggestion).map_err(|err| err.to_string())?; + match approvals::ask(daemon, bot, generation, SUGGEST_TOOL, &input, "").await { + Some(Answer::Allowed { input: None }) => { + let created = lead::create_suggested(daemon, bot, new).map_err(explain)?; + Ok(created_note(&created, "The owner approved it.")) + } + Some(Answer::Allowed { + input: Some(changed), + }) => { + let changed: Suggestion = serde_json::from_str(&changed) + .map_err(|err| format!("the owner's changes could not be read: {err}"))?; + let created = lead::create_suggested(daemon, bot, check(&changed)?).map_err(explain)?; + Ok(created_note( + &created, + "The owner changed the suggestion before approving it: read the name, role \ + and model above.", + )) + } + Some(Answer::Denied { note }) => { + let why = note.map_or_else(String::new, |note| format!(" They said: {note}")); + Ok(json!({ + "created": false, + "note": format!( + "The owner declined this bot.{why} Do the work yourself or with the bots \ + you have." + ), + })) + } + Some(Answer::Expired) => Ok(json!({ + "created": false, + "note": "The owner did not answer in time. Do the work yourself or with the bots you \ + have, and suggest it again later if it still helps.", + })), + None => Err("Botloft could not ask the owner.".to_owned()), + } +} + +/// The suggestion as a new bot, with the limits of this tool on top of a +/// bot's own. +fn check(suggestion: &Suggestion) -> Result<NewBot, String> { + if suggestion.instructions.chars().count() > INSTRUCTIONS_MAX { + return Err(format!( + "instructions must be at most {INSTRUCTIONS_MAX} characters" + )); + } + let reason = suggestion.reason.trim(); + if reason.is_empty() || reason.chars().count() > REASON_MAX { + return Err(format!( + "reason must say, in at most {REASON_MAX} characters, why the crew needs this bot" + )); + } + let model = match suggestion.model.as_deref() { + None => None, + Some(model) => Some(model.parse::<BotModel>().map_err(|_| { + "model must be \"default\", \"fable\", \"opus\", \"sonnet\" or \"haiku\"".to_owned() + })?), + }; + NewBot::check( + &suggestion.name, + &suggestion.role, + &suggestion.instructions, + None, + model, + ) + .map_err(explain) +} + +fn created_note(bot: &Bot, how: &str) -> Value { + json!({ + "created": true, + "handle": bot.handle, + "name": bot.name, + "role": bot.role, + "model": bot.model, + "note": format!( + "{how} @{} is starting now. Give it work with send_message(to: \"{}\", kind: \"task\").", + bot.handle, bot.handle + ), + }) +} diff --git a/crates/botloftd/src/workspace/files.rs b/crates/botloftd/src/workspace/files.rs index 4c0370ff..ec24332d 100644 --- a/crates/botloftd/src/workspace/files.rs +++ b/crates/botloftd/src/workspace/files.rs @@ -50,9 +50,32 @@ session, including after restarts. Keep decisions, context about ongoing work and lessons learned here, and remove what is no longer true. "; +/// Added to the rules of the crew's chief (spec 10.2). +const LEAD_MD: &str = " +## You lead this crew + +The owner made you the chief of this crew: its goal is in your instructions. + +- Plan the work, split it into pieces that can run at the same time, and hand + them out with `send_message` and `kind: \"task\"`. Each bot works in + parallel; results come back as messages. Check them before you report. +- When a piece needs a specialist the crew lacks, call `suggest_bot`: a name, a + one-line role, instructions written to that bot, a model and why it helps. + The owner approves each new bot in your chat and may change it (unless you + bypass permissions). Then give it work with a task. +- Pick the model by the work: `haiku` for simple, repetitive tasks, `sonnet` + for most work, `opus` or `fable` only for the hardest reasoning. Leave it out + to use the owner's plan default. Stronger models use up the owner's plan + faster. +- Keep the crew small: do small jobs yourself and prefer a bot that already + exists (`crew_roster`). +- Tell the owner what each bot is doing, so they can follow and talk to each + one in its own chat. +"; + /// `.claude/rules/botloft.md`: who the bot is and how to work with its crew. /// Regenerated whenever the bot or its crew changes. -pub fn rules_md(crew: &Crew, bot: &BotRecord, shared_dir: &Path) -> String { +pub fn rules_md(crew: &Crew, bot: &BotRecord, work_folder: &Path) -> String { let role = if bot.role.is_empty() { "No role was given. Ask the owner if it is unclear what you should do." } else { @@ -63,6 +86,11 @@ pub fn rules_md(crew: &Crew, bot: &BotRecord, shared_dir: &Path) -> String { } else { bot.instructions.as_str() }; + let lead = if crew.lead_bot_id.as_ref() == Some(&bot.id) { + LEAD_MD + } else { + "" + }; format!( "<!-- Generated by Botloft. Edits are overwritten; change the bot in the Botloft app. --> @@ -91,8 +119,11 @@ app; the other bots of your crew send you messages too. ## Working with your crew -- This folder is your workspace. `CLAUDE.md` here is your memory across restarts. -- Files for the whole crew go in the shared folder: `{shared}`. +- The crew works in `{work}`: the owner reads what you make there, and so do + the other bots. Put the files you make for them in it. A `CLAUDE.md` in it + is loaded with your memory: follow it. +- This folder is yours: `CLAUDE.md` here is your memory across restarts, and + scratch files can stay here. - Messages from other bots and notices from Botloft start with `[botloft]`. The first line says who sent it; for a task it also has the task id and the deadline. @@ -107,11 +138,14 @@ app; the other bots of your crew send you messages too. (`status: \"failed\"` and why): the bot that asked is waiting for it. - Do not wait in a loop for a reply. Finish your turn; the reply arrives as a new message. -", +- If the crew needs another bot, ask its chief (`crew_roster` marks it with + `\"chief\": true`). Only the chief can suggest new bots. +{lead}", name = bot.name, handle = bot.handle, crew = crew.name, - shared = shared_dir.display(), + work = work_folder.display(), + lead = lead, ) } @@ -149,6 +183,9 @@ mod tests { id: CrewId::generate(), name: "Site".to_owned(), slug: "site".to_owned(), + work_folder: String::new(), + work_folder_chosen: false, + lead_bot_id: None, paused: false, created_at: 0, archived_at: None, @@ -163,6 +200,9 @@ mod tests { instructions: "Review every PR.".to_owned(), color: "#FF7A59".to_owned(), paused: false, + permission_mode: botloft_core::protocol::PermissionMode::Default, + model: botloft_core::protocol::BotModel::Default, + model_in_use: None, created_at: 0, archived_at: None, }; @@ -173,5 +213,14 @@ mod tests { assert!(rules.contains("Ask the owner")); assert!(rules.contains("/ws/site/shared")); assert!(rules.contains("attachments/")); + assert!(!rules.contains("You lead this crew")); + + let chief = Crew { + lead_bot_id: Some(bot.id.clone()), + ..crew + }; + let rules = rules_md(&chief, &bot, Path::new("/ws/site/shared")); + assert!(rules.contains("## You lead this crew")); + assert!(rules.contains("`suggest_bot`")); } } diff --git a/crates/botloftd/src/workspace/folder.rs b/crates/botloftd/src/workspace/folder.rs new file mode 100644 index 00000000..6271246f --- /dev/null +++ b/crates/botloftd/src/workspace/folder.rs @@ -0,0 +1,130 @@ +//! A work folder the owner picks for a crew (spec 5). Every bot of the crew +//! may edit it like its own folder, so it must not reach Botloft's data or +//! the other crews. + +use std::io; +use std::path::{Component, Path, PathBuf}; + +use crate::paths::Paths; + +/// Checks `input` and creates the folder if it is missing. The error is a +/// sentence for the owner. +pub fn choose(paths: &Paths, input: &str) -> Result<PathBuf, String> { + let input = input.trim(); + if input.is_empty() { + return Err("the work folder must not be empty".to_owned()); + } + let path = Path::new(input); + if !path.is_absolute() { + return Err(r"the work folder must be a full path, like C:\Projects\Site".to_owned()); + } + let path = + std::path::absolute(path).map_err(|err| format!("the work folder is not valid: {err}"))?; + if path.parent().is_none() { + return Err("pick a folder for the work folder, not a whole drive".to_owned()); + } + if overlaps(&path, &paths.home) { + return Err( + "the work folder cannot be inside Botloft's data folder or contain it".to_owned(), + ); + } + if contains(&path, &paths.workspaces_root) { + return Err("the work folder cannot contain the folders of every bot".to_owned()); + } + create(&path).map_err(|err| format!("could not create the work folder: {err}"))?; + Ok(path) +} + +fn create(path: &Path) -> io::Result<()> { + std::fs::create_dir_all(path)?; + if path.is_dir() { + Ok(()) + } else { + Err(io::Error::other("a file already has that name")) + } +} + +/// Windows paths ignore case; `\?\` and plain forms of a drive path match. +fn parts(path: &Path) -> Vec<String> { + path.components() + .filter_map(|component| match component { + Component::Prefix(prefix) => Some(match prefix.kind() { + std::path::Prefix::VerbatimDisk(drive) | std::path::Prefix::Disk(drive) => { + format!("{}:", char::from(drive).to_ascii_lowercase()) + } + _ => prefix.as_os_str().to_string_lossy().to_lowercase(), + }), + Component::RootDir | Component::CurDir => None, + Component::ParentDir => Some("..".to_owned()), + Component::Normal(part) => Some(part.to_string_lossy().to_lowercase()), + }) + .collect() +} + +/// Whether `outer` is `inner` or one of its parents. +fn contains(outer: &Path, inner: &Path) -> bool { + let (outer, inner) = (parts(outer), parts(inner)); + inner.len() >= outer.len() && inner[..outer.len()] == outer[..] +} + +fn overlaps(a: &Path, b: &Path) -> bool { + contains(a, b) || contains(b, a) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn paths(dir: &Path) -> Paths { + Paths::new(dir.join("Data").join("Botloft"), dir.join("Botloft")) + } + + #[test] + fn a_folder_of_the_owner_is_created_and_kept() { + let dir = tempfile::tempdir().expect("tempdir"); + let wanted = dir.path().join("Projects").join("Site"); + let chosen = choose(&paths(dir.path()), wanted.to_str().expect("utf-8")).expect("chosen"); + assert_eq!(chosen, wanted); + assert!(wanted.is_dir()); + } + + #[test] + fn botloft_data_the_bot_folders_and_drives_are_refused() { + let dir = tempfile::tempdir().expect("tempdir"); + let paths = paths(dir.path()); + let refused = [ + String::new(), + r"relative\folder".to_owned(), + paths.home.join("secrets").display().to_string(), + dir.path().join("Data").display().to_string(), + paths.workspaces_root.display().to_string(), + dir.path().display().to_string(), + ]; + for input in refused { + assert!(choose(&paths, &input).is_err(), "{input:?} was accepted"); + } + let root = dir.path().ancestors().last().expect("root"); + assert!(choose(&paths, root.to_str().expect("utf-8")).is_err()); + } + + #[test] + fn a_folder_inside_the_crew_folders_is_fine() { + let dir = tempfile::tempdir().expect("tempdir"); + let paths = paths(dir.path()); + let inside = paths.workspaces_root.join("site").join("out"); + assert!(choose(&paths, inside.to_str().expect("utf-8")).is_ok()); + } + + #[cfg(windows)] + #[test] + fn case_and_verbatim_prefixes_do_not_hide_an_overlap() { + assert!(contains( + Path::new(r"C:\Users\Ana"), + Path::new(r"\\?\c:\users\ana\AppData\Local\Botloft") + )); + assert!(!contains( + Path::new(r"C:\Users\Ana2"), + Path::new(r"C:\Users\Ana\x") + )); + } +} diff --git a/crates/botloftd/src/workspace/mod.rs b/crates/botloftd/src/workspace/mod.rs index 25c4779e..12bab010 100644 --- a/crates/botloftd/src/workspace/mod.rs +++ b/crates/botloftd/src/workspace/mod.rs @@ -3,6 +3,7 @@ //! bot's own `CLAUDE.md`. mod files; +pub mod folder; use std::io; use std::path::{Path, PathBuf}; @@ -22,14 +23,16 @@ pub struct WorkspaceEnv<'a> { pub approval_timeout: Duration, } -/// Creates the crew folder and its `shared` folder. -pub fn prepare_crew(paths: &Paths, crew_slug: &str) -> io::Result<()> { - std::fs::create_dir_all(paths.shared_dir(crew_slug)) +/// Creates the crew folder, its `shared` folder and the work folder the +/// owner chose, if it went missing. +pub fn prepare_crew(paths: &Paths, crew: &Crew) -> io::Result<()> { + std::fs::create_dir_all(paths.shared_dir(&crew.slug))?; + std::fs::create_dir_all(paths.work_folder(crew)) } /// Creates the workspace and writes every generated file. Returns the path. pub fn prepare_bot(env: WorkspaceEnv<'_>, crew: &Crew, bot: &BotRecord) -> io::Result<PathBuf> { - prepare_crew(env.paths, &crew.slug)?; + prepare_crew(env.paths, crew)?; let dir = env.paths.bot_workspace(&crew.slug, &bot.slug); std::fs::create_dir_all(dir.join(".claude").join("rules"))?; std::fs::create_dir_all(dir.join(".botloft"))?; @@ -55,7 +58,7 @@ pub fn write_rules(paths: &Paths, crew: &Crew, bot: &BotRecord) -> io::Result<() let dir = paths.bot_workspace(&crew.slug, &bot.slug); let rules_dir = dir.join(".claude").join("rules"); std::fs::create_dir_all(&rules_dir)?; - let text = files::rules_md(crew, bot, &paths.shared_dir(&crew.slug)); + let text = files::rules_md(crew, bot, &paths.work_folder(crew)); write_atomic(&rules_dir.join("botloft.md"), text.as_bytes()) } @@ -88,6 +91,9 @@ mod tests { id: CrewId::generate(), name: "Site".to_owned(), slug: "site".to_owned(), + work_folder: String::new(), + work_folder_chosen: false, + lead_bot_id: None, paused: false, created_at: 0, archived_at: None, @@ -102,6 +108,9 @@ mod tests { instructions: String::new(), color: "#FF7A59".to_owned(), paused: false, + permission_mode: botloft_core::protocol::PermissionMode::Default, + model: botloft_core::protocol::BotModel::Default, + model_in_use: None, created_at: 0, archived_at: None, }; diff --git a/crates/botloftd/tests/bot_models.rs b/crates/botloftd/tests/bot_models.rs new file mode 100644 index 00000000..3597f1b6 --- /dev/null +++ b/crates/botloftd/tests/bot_models.rs @@ -0,0 +1,129 @@ +//! A bot's model (spec 7.4): the flag it starts with, the restart onto a new +//! model once nothing is in progress, the model Claude Code reports and a +//! model the account cannot use. + +mod common; + +use std::time::Duration; + +use botloft_core::protocol::{BotModel, BotState, BotsSetModelParams, ChatBody, NoticeCode}; +use botloftd::service::{bots, models}; +use common::stream; +use common::supervised::{Setup, arg_after, setup}; +use serde_json::json; + +fn set_model(s: &Setup, model: BotModel) { + models::set_model( + &s.daemon, + BotsSetModelParams { + bot_id: s.bot.clone(), + model, + }, + ) + .expect("set model"); +} + +fn bot(s: &Setup) -> botloft_core::protocol::Bot { + bots::list(&s.daemon, Default::default()) + .expect("list") + .into_iter() + .find(|bot| bot.id == s.bot) + .expect("bot") +} + +#[tokio::test(start_paused = true)] +async fn a_new_bot_runs_on_the_plans_default_model() { + let s = setup().await; + let process = s.runtime.process(1).await; + assert!(!process.args().iter().any(|arg| arg == "--model")); + assert_eq!(bot(&s).model, BotModel::Default); + assert_eq!(bot(&s).model_in_use, None); +} + +#[tokio::test(start_paused = true)] +async fn an_idle_bot_restarts_on_its_new_model_in_the_same_conversation() { + let s = setup().await; + let first = s.runtime.process(1).await; + s.until(BotState::Idle).await; + let session = arg_after(&first, "--session-id").expect("session"); + + set_model(&s, BotModel::Haiku); + let second = s.runtime.process(2).await; + assert!(first.killed()); + assert_eq!(arg_after(&second, "--model").as_deref(), Some("haiku")); + assert_eq!(arg_after(&second, "--resume"), Some(session)); + + // Back to the plan's default: no flag at all. + s.until(BotState::Idle).await; + set_model(&s, BotModel::Default); + let third = s.runtime.process(3).await; + assert!(!third.args().iter().any(|arg| arg == "--model")); +} + +#[tokio::test(start_paused = true)] +async fn a_busy_bot_finishes_its_turn_before_changing_model() { + let s = setup().await; + let first = s.runtime.process(1).await; + s.until(BotState::Idle).await; + s.message("work"); + set_model(&s, BotModel::Opus); + tokio::time::sleep(Duration::from_secs(30)).await; + assert_eq!(s.runtime.processes().len(), 1, "the turn is not cut short"); + assert!(s.daemon.supervisor.relaunch_pending(&s.bot)); + + first.emit(stream::result(false)).await; + let second = s.runtime.process(2).await; + assert_eq!(arg_after(&second, "--model").as_deref(), Some("opus")); +} + +#[tokio::test(start_paused = true)] +async fn the_reported_model_is_kept_for_the_app() { + let s = setup().await; + let process = s.runtime.process(1).await; + s.until(BotState::Idle).await; + let session = arg_after(&process, "--session-id").expect("session"); + process + .emit(json!({ + "type": "system", "subtype": "init", "session_id": session, + "model": "claude-opus-5-5", "permissionMode": "default", + })) + .await; + tokio::time::sleep(Duration::from_millis(50)).await; + assert_eq!(bot(&s).model_in_use.as_deref(), Some("claude-opus-5-5")); + assert_eq!( + bot(&s).model, + BotModel::Default, + "the choice stays the owner's" + ); +} + +#[tokio::test(start_paused = true)] +async fn a_model_the_account_cannot_use_is_told_in_the_chat() { + let s = setup().await; + let process = s.runtime.process(1).await; + s.until(BotState::Idle).await; + s.message("hi"); + process + .emit(stream::api_error( + "model_not_found", + "There's an issue with the selected model (fable).", + )) + .await; + process.emit(stream::result(true)).await; + s.until(BotState::Idle).await; + + let items = s + .daemon + .store() + .chat_history(&s.bot, None, 50) + .expect("history"); + let notice = items + .iter() + .find_map(|item| match &item.body { + ChatBody::Notice(notice) => Some(notice.clone()), + _ => None, + }) + .expect("a notice"); + assert_eq!(notice.code, Some(NoticeCode::ModelUnavailable)); + assert_eq!(s.runtime.processes().len(), 1, "the bot keeps running"); +} diff --git a/crates/botloftd/tests/common/mod.rs b/crates/botloftd/tests/common/mod.rs index 0fd8ff64..75615f39 100644 --- a/crates/botloftd/tests/common/mod.rs +++ b/crates/botloftd/tests/common/mod.rs @@ -64,6 +64,7 @@ pub fn bot_settings() -> BotSettings { BotSettings { approval_timeout: Duration::from_secs(3), attachment_max_bytes: 1024 * 1024, + max_per_crew: 3, } } diff --git a/crates/botloftd/tests/common/supervised.rs b/crates/botloftd/tests/common/supervised.rs index 749c6d7c..abfc3fcf 100644 --- a/crates/botloftd/tests/common/supervised.rs +++ b/crates/botloftd/tests/common/supervised.rs @@ -26,7 +26,15 @@ pub struct Setup { pub async fn setup() -> Setup { let parts = new_daemon(test_settings()); let (daemon, runtime, clock, dir) = (parts.daemon, parts.runtime, parts.clock, parts.dir); - let crew = crews::create(&daemon, CrewsCreateParams { name: "Ops".into() }).expect("crew"); + let crew = crews::create( + &daemon, + CrewsCreateParams { + name: "Ops".into(), + work_folder: None, + lead: None, + }, + ) + .expect("crew"); let bot = bots::create( &daemon, BotsCreateParams { @@ -35,6 +43,7 @@ pub async fn setup() -> Setup { role: String::new(), instructions: String::new(), color: None, + model: None, }, ) .expect("bot"); diff --git a/crates/botloftd/tests/crew_chief.rs b/crates/botloftd/tests/crew_chief.rs new file mode 100644 index 00000000..b265d954 --- /dev/null +++ b/crates/botloftd/tests/crew_chief.rs @@ -0,0 +1,289 @@ +//! A crew's chief (spec 10.2): created with the crew, the only bot that can +//! suggest new ones, and the owner's say over each suggestion. + +mod common; + +use std::path::Path; + +use botloft_core::protocol::BotState; +use botloftd::runtime::fake::FakeProcess; +use common::bots::ready_bot; +use common::mcp::Mcp; +use common::{Client, TestDaemon}; +use serde_json::{Value, json}; +use tokio::task::JoinHandle; + +struct Chief { + t: TestDaemon, + app: Client, + crew: Value, + chief: Value, + mcp: Mcp, +} + +/// A crew "Site" created with its chief, whose process is ready. +async fn crew_with_chief() -> Chief { + let t = TestDaemon::start_supervised().await; + let mut app = t.session().await; + let crew = app + .call( + "crews.create", + json!({ + "name": "Site", + "lead": { "name": "Chefe", "role": "Leads the crew", "instructions": "Build the bakery's site" }, + }), + ) + .await + .expect("crew"); + let bots = app + .call("bots.list", json!({ "crewId": crew["id"] })) + .await + .expect("bots"); + let chief = bots[0].clone(); + assert_eq!(crew["leadBotId"], chief["id"]); + let (process, mcp) = ready(&t, &chief).await; + drop(process); + Chief { + t, + app, + crew, + chief, + mcp, + } +} + +async fn ready(t: &TestDaemon, bot: &Value) -> (FakeProcess, Mcp) { + let process = t.process_of(bot).await; + t.until_state(bot, BotState::Idle).await; + let mcp = Mcp::new(t.addr, process.env("BOTLOFT_BOT_TOKEN").expect("token")); + (process, mcp) +} + +fn designer() -> Value { + json!({ + "name": "Designer", + "role": "Draws each page", + "instructions": "Design the pages in shared/design and tell me when each is ready.", + "model": "sonnet", + "reason": "The site needs a look before anyone builds it.", + }) +} + +fn suggest(mcp: &Mcp, arguments: Value) -> JoinHandle<Result<Value, String>> { + let mut mcp = Mcp::new(mcp.addr, mcp.token.clone()); + tokio::spawn(async move { mcp.tool("suggest_bot", arguments).await }) +} + +/// Waits for the suggestion to show up in the chief's chat. +async fn pending_suggestion(app: &mut Client) -> Value { + loop { + let changed = app.notification("chat.item").await; + let body = &changed["item"]["body"]; + if body["kind"] == "approval" && body["status"] == "pending" { + assert_eq!(body["toolName"], "mcp__botloft__suggest_bot"); + return body.clone(); + } + } +} + +async fn crew_bots(c: &mut Chief) -> Vec<Value> { + c.app + .call("bots.list", json!({ "crewId": c.crew["id"] })) + .await + .expect("bots") + .as_array() + .expect("list") + .clone() +} + +fn rules(bot: &Value) -> String { + let workspace = bot["workspace"].as_str().expect("workspace"); + std::fs::read_to_string(Path::new(workspace).join(".claude/rules/botloft.md")).expect("rules") +} + +#[tokio::test] +async fn a_new_crew_comes_with_its_chief() { + let mut c = crew_with_chief().await; + assert_eq!(c.chief["name"], "Chefe"); + assert!(rules(&c.chief).contains("## You lead this crew")); + assert!(rules(&c.chief).contains("Build the bakery's site")); + + let roster = c.mcp.tool("crew_roster", json!({})).await.expect("roster"); + assert_eq!(roster["you_lead"], true); + let (_, _, mut writer) = ready_bot(&c.t, &mut c.app, &c.crew, "Writer").await; + let seen = writer.tool("crew_roster", json!({})).await.expect("roster"); + assert_eq!(seen["you_lead"], false); + assert_eq!(seen["bots"][0]["chief"], true); +} + +#[tokio::test] +async fn the_owner_approves_a_suggested_bot() { + let mut c = crew_with_chief().await; + let call = suggest(&c.mcp, designer()); + let asked = pending_suggestion(&mut c.app).await; + assert_eq!(asked["summary"], "Designer"); + c.t.until_state(&c.chief, BotState::NeedsApproval).await; + + c.app + .call( + "approvals.answer", + json!({ "approvalId": asked["approvalId"], "allow": true }), + ) + .await + .expect("answer"); + let created = call.await.expect("task").expect("created"); + assert_eq!(created["created"], true); + assert_eq!(created["handle"], "designer"); + assert!( + created["note"] + .as_str() + .expect("note") + .contains("send_message") + ); + + let bots = crew_bots(&mut c).await; + let new = bots + .iter() + .find(|bot| bot["handle"] == "designer") + .expect("designer"); + assert_eq!(new["model"], "sonnet"); + assert!(!rules(new).contains("You lead this crew")); + c.t.process_of(new).await; +} + +#[tokio::test] +async fn the_owner_can_change_a_suggestion_before_approving_it() { + let mut c = crew_with_chief().await; + let call = suggest(&c.mcp, designer()); + let asked = pending_suggestion(&mut c.app).await; + + let mut changed = designer(); + changed["name"] = json!("Illustrator"); + changed["model"] = json!("haiku"); + c.app + .call( + "approvals.answer", + json!({ "approvalId": asked["approvalId"], "allow": true, "input": changed.to_string() }), + ) + .await + .expect("answer"); + let created = call.await.expect("task").expect("created"); + assert_eq!(created["handle"], "illustrator"); + assert_eq!(created["model"], "haiku"); + assert!(created["note"].as_str().expect("note").contains("changed")); + // The card shows what was created. + let item = loop { + let changed = c.app.notification("chat.item").await; + if changed["item"]["body"]["status"] == "allowed" { + break changed["item"]["body"].clone(); + } + }; + assert!( + item["input"] + .as_str() + .expect("input") + .contains("Illustrator") + ); +} + +#[tokio::test] +async fn a_declined_suggestion_creates_nothing() { + let mut c = crew_with_chief().await; + let call = suggest(&c.mcp, designer()); + let asked = pending_suggestion(&mut c.app).await; + c.app + .call( + "approvals.answer", + json!({ "approvalId": asked["approvalId"], "allow": false, "note": "Use the writer" }), + ) + .await + .expect("answer"); + let declined = call.await.expect("task").expect("answered"); + assert_eq!(declined["created"], false); + assert!( + declined["note"] + .as_str() + .expect("note") + .contains("Use the writer") + ); + assert_eq!(crew_bots(&mut c).await.len(), 1); +} + +#[tokio::test] +async fn a_chief_that_bypasses_permissions_creates_at_once() { + let mut c = crew_with_chief().await; + c.app + .call( + "bots.setPermissionMode", + json!({ "botId": c.chief["id"], "mode": "bypass_permissions" }), + ) + .await + .expect("mode"); + // The chief restarts into the new mode, with a new token. + let old = c.mcp.token.clone(); + let mcp = loop { + let (_, mcp) = ready(&c.t, &c.chief).await; + if mcp.token != old { + break mcp; + } + tokio::time::sleep(std::time::Duration::from_millis(20)).await; + }; + let created = suggest(&mcp, designer()) + .await + .expect("task") + .expect("created"); + assert_eq!(created["created"], true); + assert!( + created["note"] + .as_str() + .expect("note") + .contains("without asking") + ); + assert_eq!(crew_bots(&mut c).await.len(), 2); +} + +#[tokio::test] +async fn only_the_chief_suggests_and_only_while_the_crew_has_room() { + let mut c = crew_with_chief().await; + let (_, _, writer) = ready_bot(&c.t, &mut c.app, &c.crew, "Writer").await; + let refused = suggest(&writer, designer()).await.expect("task"); + assert!( + refused + .expect_err("refused") + .contains("only the crew's chief") + ); + + // The tests allow three bots per crew. + ready_bot(&c.t, &mut c.app, &c.crew, "Reviewer").await; + let full = suggest(&c.mcp, designer()).await.expect("task"); + assert!(full.expect_err("full").contains("already has 3 bots")); + + let mut nameless = designer(); + nameless["reason"] = json!(" "); + let refused = suggest(&c.mcp, nameless).await.expect("task"); + assert!(refused.expect_err("no reason").contains("reason")); +} + +#[tokio::test] +async fn the_owner_moves_the_chief_and_an_archived_chief_leaves_none() { + let mut c = crew_with_chief().await; + let (writer, _, _) = ready_bot(&c.t, &mut c.app, &c.crew, "Writer").await; + let crew = c + .app + .call( + "crews.setLead", + json!({ "crewId": c.crew["id"], "botId": writer["id"] }), + ) + .await + .expect("move"); + assert_eq!(crew["leadBotId"], writer["id"]); + assert!(rules(&writer).contains("## You lead this crew")); + assert!(!rules(&c.chief).contains("## You lead this crew")); + + c.app + .call("bots.archive", json!({ "botId": writer["id"] })) + .await + .expect("archive"); + let crews = c.app.call("crews.list", json!({})).await.expect("crews"); + assert_eq!(crews[0]["leadBotId"], Value::Null); +} diff --git a/crates/botloftd/tests/crew_folders.rs b/crates/botloftd/tests/crew_folders.rs new file mode 100644 index 00000000..61c25e81 --- /dev/null +++ b/crates/botloftd/tests/crew_folders.rs @@ -0,0 +1,157 @@ +//! The folder a crew works in (spec 5): the `shared` folder by default, or +//! one the owner chose, handed to every bot with `--add-dir`. + +mod common; + +use std::path::Path; +use std::sync::Arc; + +use botloft_core::protocol::{ + BotState, BotsCreateParams, Crew, CrewsCreateParams, CrewsSetWorkFolderParams, +}; +use botloftd::service::{ApiError, bots, crews}; +use botloftd::supervisor; +use common::supervised::arg_after; +use common::{Parts, new_daemon, test_settings}; + +fn crew(parts: &Parts, work_folder: Option<&Path>) -> Result<Crew, ApiError> { + crews::create( + &parts.daemon, + CrewsCreateParams { + name: "Site".into(), + work_folder: work_folder.map(|path| path.display().to_string()), + lead: None, + }, + ) +} + +fn bot(parts: &Parts, crew: &Crew) -> botloft_core::protocol::Bot { + bots::create( + &parts.daemon, + BotsCreateParams { + crew_id: crew.id.clone(), + name: "Writer".into(), + role: String::new(), + instructions: String::new(), + color: None, + model: None, + }, + ) + .expect("bot") +} + +fn rules(bot: &botloft_core::protocol::Bot) -> String { + std::fs::read_to_string(Path::new(&bot.workspace).join(".claude/rules/botloft.md")) + .expect("rules") +} + +#[tokio::test(start_paused = true)] +async fn a_crew_works_in_its_shared_folder_by_default() { + let parts = new_daemon(test_settings()); + let crew = crew(&parts, None).expect("crew"); + let shared = parts.paths.shared_dir("site"); + assert!(!crew.work_folder_chosen); + assert_eq!(Path::new(&crew.work_folder), shared); + assert!(shared.is_dir()); + + let writer = bot(&parts, &crew); + tokio::spawn(supervisor::run(Arc::clone(&parts.daemon))); + let process = parts.runtime.process(1).await; + assert_eq!( + arg_after(&process, "--add-dir").map(std::path::PathBuf::from), + Some(shared.clone()) + ); + assert_eq!( + process + .env("CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD") + .as_deref(), + Some("1") + ); + assert!(rules(&writer).contains(&shared.display().to_string())); +} + +#[tokio::test(start_paused = true)] +async fn the_owner_can_choose_where_the_crew_works() { + let parts = new_daemon(test_settings()); + let chosen = parts.dir.path().join("Projects").join("Site"); + let crew = crew(&parts, Some(&chosen)).expect("crew"); + assert!(crew.work_folder_chosen); + assert_eq!(Path::new(&crew.work_folder), chosen); + assert!(chosen.is_dir(), "a missing folder is created"); + + let writer = bot(&parts, &crew); + tokio::spawn(supervisor::run(Arc::clone(&parts.daemon))); + let process = parts.runtime.process(1).await; + assert_eq!( + arg_after(&process, "--add-dir").map(std::path::PathBuf::from), + Some(chosen.clone()) + ); + assert!(rules(&writer).contains(&chosen.display().to_string())); + // The listing keeps the choice. + let listed = crews::list(&parts.daemon).expect("list"); + assert_eq!(listed[0].work_folder, crew.work_folder); +} + +#[tokio::test(start_paused = true)] +async fn moving_the_crew_restarts_its_bots_in_the_new_folder() { + let parts = new_daemon(test_settings()); + let crew = crew(&parts, None).expect("crew"); + let writer = bot(&parts, &crew); + tokio::spawn(supervisor::run(Arc::clone(&parts.daemon))); + let first = parts.runtime.process(1).await; + wait_idle(&parts, &writer.id).await; + + let moved = parts.dir.path().join("Elsewhere"); + let changed = crews::set_work_folder( + &parts.daemon, + CrewsSetWorkFolderParams { + crew_id: crew.id.clone(), + work_folder: Some(moved.display().to_string()), + }, + ) + .expect("move"); + assert_eq!(Path::new(&changed.work_folder), moved); + assert!(rules(&writer).contains(&moved.display().to_string())); + let second = parts.runtime.process(2).await; + assert!(first.killed()); + assert_eq!( + arg_after(&second, "--add-dir").map(std::path::PathBuf::from), + Some(moved) + ); + + wait_idle(&parts, &writer.id).await; + let back = crews::set_work_folder( + &parts.daemon, + CrewsSetWorkFolderParams { + crew_id: crew.id, + work_folder: None, + }, + ) + .expect("back"); + assert!(!back.work_folder_chosen); + assert_eq!(Path::new(&back.work_folder), parts.paths.shared_dir("site")); + parts.runtime.process(3).await; +} + +#[tokio::test(start_paused = true)] +async fn botlofts_own_folders_are_refused() { + let parts = new_daemon(test_settings()); + for folder in [ + parts.paths.home.join("secrets"), + parts.paths.workspaces_root.clone(), + ] { + let refused = crew(&parts, Some(&folder)).expect_err("refused"); + assert!(matches!(refused, ApiError::Validation(_)), "{refused:?}"); + } + assert!(crews::list(&parts.daemon).expect("list").is_empty()); +} + +async fn wait_idle(parts: &Parts, bot: &botloft_core::ids::BotId) { + for _ in 0..600 { + if parts.daemon.supervisor.status(bot).map(|(state, _)| state) == Some(BotState::Idle) { + return; + } + tokio::time::sleep(std::time::Duration::from_millis(10)).await; + } + panic!("the bot never became idle"); +} diff --git a/crates/botloftd/tests/mcp.rs b/crates/botloftd/tests/mcp.rs index f4fa1f9b..79e8327e 100644 --- a/crates/botloftd/tests/mcp.rs +++ b/crates/botloftd/tests/mcp.rs @@ -71,6 +71,7 @@ async fn claude_code_discovers_the_server_and_lists_the_tools() { "send_message", "complete_task", "my_tasks", + "suggest_bot", "permission_prompt" ] ); @@ -115,7 +116,7 @@ async fn earlier_revisions_start_with_initialize() { let listed = mcp::post(t.addr, &legacy, &list).await; assert_eq!( listed.body["result"]["tools"].as_array().map(Vec::len), - Some(5) + Some(6) ); let unknown = json!({ "jsonrpc": "2.0", "id": 2, "method": "prompts/list" }).to_string(); let unknown = mcp::post(t.addr, &legacy, &unknown).await; diff --git a/crates/botloftd/tests/permission_modes.rs b/crates/botloftd/tests/permission_modes.rs new file mode 100644 index 00000000..62b0f52b --- /dev/null +++ b/crates/botloftd/tests/permission_modes.rs @@ -0,0 +1,158 @@ +//! A bot's permission mode (spec 7.4): the flag it starts with, the restart +//! into a new mode once nothing is in progress, and leaving plan mode. + +mod common; + +use std::time::Duration; + +use botloft_core::protocol::{BotState, BotsSetPermissionModeParams, PermissionMode}; +use botloftd::runtime::fake::FakeProcess; +use botloftd::service::modes; +use common::stream; +use common::supervised::{Setup, setup}; +use serde_json::json; + +fn arg_after(process: &FakeProcess, flag: &str) -> Option<String> { + let args = process.args(); + let at = args.iter().position(|arg| arg == flag)?; + args.get(at + 1).cloned() +} + +fn set_mode(s: &Setup, mode: PermissionMode) { + modes::set_permission_mode( + &s.daemon, + BotsSetPermissionModeParams { + bot_id: s.bot.clone(), + mode, + }, + ) + .expect("set mode"); +} + +fn stored_mode(s: &Setup) -> PermissionMode { + s.daemon + .store() + .bot(&s.bot) + .expect("read") + .expect("bot") + .permission_mode +} + +fn init_with_mode(session: &str, mode: &str) -> serde_json::Value { + json!({ "type": "system", "subtype": "init", "session_id": session, "permissionMode": mode }) +} + +#[tokio::test(start_paused = true)] +async fn a_new_bot_asks_before_everything() { + let s = setup().await; + let process = s.runtime.process(1).await; + assert_eq!( + arg_after(&process, "--permission-mode").as_deref(), + Some("default") + ); + assert_eq!(stored_mode(&s), PermissionMode::Default); +} + +#[tokio::test(start_paused = true)] +async fn an_idle_bot_restarts_into_its_new_mode_in_the_same_conversation() { + let s = setup().await; + let first = s.runtime.process(1).await; + s.until(BotState::Idle).await; + let session = arg_after(&first, "--session-id").expect("session"); + + set_mode(&s, PermissionMode::AcceptEdits); + let second = s.runtime.process(2).await; + assert!(first.killed()); + assert_eq!( + arg_after(&second, "--permission-mode").as_deref(), + Some("acceptEdits") + ); + assert_eq!(arg_after(&second, "--resume"), Some(session)); +} + +#[tokio::test(start_paused = true)] +async fn a_busy_bot_finishes_its_turn_before_changing_mode() { + let s = setup().await; + let first = s.runtime.process(1).await; + s.until(BotState::Idle).await; + s.message("work"); + set_mode(&s, PermissionMode::Auto); + tokio::time::sleep(Duration::from_secs(30)).await; + assert_eq!(s.runtime.processes().len(), 1, "the turn is not cut short"); + assert!(s.daemon.supervisor.relaunch_pending(&s.bot)); + + first.emit(stream::result(false)).await; + let second = s.runtime.process(2).await; + assert_eq!( + arg_after(&second, "--permission-mode").as_deref(), + Some("auto") + ); + assert!(!s.daemon.supervisor.relaunch_pending(&s.bot)); +} + +#[tokio::test(start_paused = true)] +async fn approving_a_plan_moves_the_bot_out_of_plan_mode() { + let s = setup().await; + s.runtime.process(1).await; + s.until(BotState::Idle).await; + set_mode(&s, PermissionMode::Plan); + let planning = s.runtime.process(2).await; + s.until(BotState::Idle).await; + let session = arg_after(&planning, "--resume").expect("session"); + + // Claude Code left plan mode when the plan was approved. + planning.emit(init_with_mode(&session, "default")).await; + tokio::time::sleep(Duration::from_millis(50)).await; + assert_eq!(stored_mode(&s), PermissionMode::Default); + assert_eq!( + s.runtime.processes().len(), + 2, + "no restart: it already changed" + ); +} + +#[tokio::test(start_paused = true)] +async fn a_turn_of_the_old_process_does_not_undo_the_owners_choice() { + let s = setup().await; + let first = s.runtime.process(1).await; + s.until(BotState::Idle).await; + let session = arg_after(&first, "--session-id").expect("session"); + s.message("queued"); + set_mode(&s, PermissionMode::AcceptEdits); + + first.emit(init_with_mode(&session, "default")).await; + tokio::time::sleep(Duration::from_millis(50)).await; + assert_eq!(stored_mode(&s), PermissionMode::AcceptEdits); + first.emit(stream::init(&session)).await; + assert_eq!(stored_mode(&s), PermissionMode::AcceptEdits); +} + +#[tokio::test(start_paused = true)] +async fn a_plan_approved_while_a_new_model_waits_still_leaves_plan_mode() { + let s = setup().await; + s.runtime.process(1).await; + s.until(BotState::Idle).await; + set_mode(&s, PermissionMode::Plan); + let planning = s.runtime.process(2).await; + s.until(BotState::Idle).await; + let session = arg_after(&planning, "--resume").expect("session"); + s.message("plan it"); + botloftd::service::models::set_model( + &s.daemon, + botloft_core::protocol::BotsSetModelParams { + bot_id: s.bot.clone(), + model: botloft_core::protocol::BotModel::Sonnet, + }, + ) + .expect("set model"); + + planning.emit(init_with_mode(&session, "default")).await; + tokio::time::sleep(Duration::from_millis(50)).await; + assert_eq!(stored_mode(&s), PermissionMode::Default); + planning.emit(stream::result(false)).await; + let next = s.runtime.process(3).await; + assert_eq!( + arg_after(&next, "--permission-mode").as_deref(), + Some("default") + ); +} diff --git a/crates/botloftd/tests/sign_in.rs b/crates/botloftd/tests/sign_in.rs index 9a74f665..78ecfd7d 100644 --- a/crates/botloftd/tests/sign_in.rs +++ b/crates/botloftd/tests/sign_in.rs @@ -30,6 +30,13 @@ async fn the_status_says_whether_claude_code_is_signed_in() { let status = service::status(&s.daemon).expect("status"); assert_eq!(status.claude_signed_in, Some(true)); assert!(status.claude_path.is_some()); + assert!( + !status.account.name.is_empty(), + "the Windows account's name" + ); + let claude = status.account.claude.expect("the signed-in Claude account"); + assert_eq!(claude.email.as_deref(), Some("owner@example.com")); + assert_eq!(claude.plan.as_deref(), Some("max")); assert_eq!(s.runtime.sign_in_checks(), 1, "checked once, then trusted"); tokio::time::sleep(Duration::from_secs(300)).await; assert_eq!(s.runtime.sign_in_checks(), 1); @@ -43,6 +50,11 @@ async fn signing_in_again_brings_the_stopped_bots_back() { sign_in_error(&s).await; tokio::time::sleep(Duration::from_millis(50)).await; assert_eq!(s.daemon.supervisor.claude_signed_in(), Some(false)); + assert_eq!( + s.daemon.supervisor.claude_account(), + None, + "no account while signed out" + ); // Still signed out: checked every 30 s, the bot stays stopped. tokio::time::sleep(Duration::from_secs(40)).await; diff --git a/crates/botloftd/tests/supervisor.rs b/crates/botloftd/tests/supervisor.rs index 17a1322a..413d75d7 100644 --- a/crates/botloftd/tests/supervisor.rs +++ b/crates/botloftd/tests/supervisor.rs @@ -190,13 +190,22 @@ async fn a_failed_spawn_backs_off_and_retries() { let parts = new_daemon(test_settings()); let (daemon, runtime) = (parts.daemon, parts.runtime); runtime.fail_next_spawn(); - let crew = crews::create(&daemon, CrewsCreateParams { name: "Ops".into() }).expect("crew"); + let crew = crews::create( + &daemon, + CrewsCreateParams { + name: "Ops".into(), + work_folder: None, + lead: None, + }, + ) + .expect("crew"); let params = BotsCreateParams { crew_id: crew.id, name: "Scout".into(), role: String::new(), instructions: String::new(), color: None, + model: None, }; let bot = bots::create(&daemon, params).expect("bot"); tokio::spawn(supervisor::run(Arc::clone(&daemon))); diff --git a/crates/botloftd/tests/tasks.rs b/crates/botloftd/tests/tasks.rs index f2ef2a8e..56dca545 100644 --- a/crates/botloftd/tests/tasks.rs +++ b/crates/botloftd/tests/tasks.rs @@ -185,7 +185,7 @@ async fn mistakes_come_back_as_tool_errors() { assert_eq!(roster["you"], "lead"); assert_eq!( roster["bots"], - json!([{ "handle": "writer", "name": "Writer", "role": "Writer role", "state": "idle" }]) + json!([{ "handle": "writer", "name": "Writer", "role": "Writer role", "state": "idle", "chief": false }]) ); let err = |out: Result<Value, String>| out.expect_err("refused"); diff --git a/docs/spec.md b/docs/spec.md index 7150cf35..2847ac4d 100644 --- a/docs/spec.md +++ b/docs/spec.md @@ -24,8 +24,9 @@ Princípios: | Termo | Significado | |---|---| -| **Crew** | Grupo de bots que podem conversar entre si. Tem pasta compartilhada `shared/`. | +| **Crew** | Grupo de bots que podem conversar entre si. Trabalha numa pasta: a `shared/` dela ou uma que o dono escolhe. | | **Bot** | Uma sessão Claude Code persistente com nome, papel e instruções. | +| **Chefe** | O bot que lidera a crew (`Crew.leadBotId`): nasce com ela, planeja o trabalho, distribui tarefas e é o único que sugere bots novos (10.2). | | **Workspace** | Pasta de trabalho do bot, onde o Claude Code roda. | | **Message** | Texto enviado a um bot, pelo dono, por outro bot ou pelo daemon. Pode trazer anexos (só do dono). | | **Delivery** | Entrega de uma message ao processo do bot. Tem estado, tentativas e prazo. | @@ -101,7 +102,7 @@ Tipos do protocolo ficam em `botloft-core` e são exportados para TypeScript com | Logs | `%LOCALAPPDATA%\Botloft\logs\` (rotação diária, 14 dias) | | | Config | `%LOCALAPPDATA%\Botloft\config.toml` | `--config` | | Workspaces | `%USERPROFILE%\Botloft\<crew>\<bot>\` | `workspaces_root` na config | -| Pasta compartilhada da crew | `%USERPROFILE%\Botloft\<crew>\shared\` | | +| Pasta de trabalho da crew | `%USERPROFILE%\Botloft\<crew>\shared\` | uma pasta que o dono escolhe (`Crew.workFolder`) | | Binário do daemon | `%LOCALAPPDATA%\Botloft\bin\botloftd.exe` (seção 14) | `--home` | | App instalado | `%LOCALAPPDATA%\Botloft\` (`Botloft.exe`, o sidecar `botloftd.exe`, `uninstall.exe`; seção 15.4) | | @@ -111,6 +112,8 @@ O instalador por usuário do Tauri põe o app em `%LOCALAPPDATA%\<produto>`, a m Workspaces ficam num caminho curto e visível para o usuário abrir no Explorer e para reduzir estouro do limite de 260 caracteres (bots rodam `npm install`). +**Pasta de trabalho da crew.** É onde os bots põem o que fazem para o dono e para os outros bots. Por padrão é a `shared\` da crew; o dono pode escolher outra ao criar a crew ou depois (`crews.setWorkFolder`), como uma pasta de projeto que ele já usa. O workspace de cada bot continua onde está, com a memória, as regras e os anexos dele: o daemon nunca grava nada na pasta escolhida. Cada bot recebe a pasta com `--add-dir` (7.4), e o Claude Code a trata como a pasta do bot: lê e, em "Aceitar edições", edita sem perguntar, e carrega o `CLAUDE.md` dela junto com a memória do bot. A pasta escolhida precisa ser um caminho completo e não pode ser um disco inteiro, ficar dentro da pasta de dados do Botloft ou contê-la, nem conter `workspaces_root` (com os workspaces de todos os bots). Se não existe, é criada. Trocar a pasta regrava as regras e reinicia cada bot da crew quando nada estiver em andamento, como a troca de modo (7.4). Arquivar a crew não apaga pasta nenhuma. + Nomes de pasta de crew e bot são slugs gerados na criação e **não mudam** quando o nome de exibição muda. Slug: ASCII minúsculo com hífens, acentos transliterados (`Revisão` -> `revisao`), no máximo 32 caracteres, nunca um nome de dispositivo do Windows (`con`, `lpt1`...) e nunca `shared` para bot. Colisão ganha sufixo (`docs-2`), inclusive com slug de item arquivado ou pasta que já exista no disco. O **handle** do bot (`@revisao`) é derivado do nome pela mesma regra, acompanha renomeações e é único entre os bots ativos da crew; um nome que gere handle já usado é recusado com erro de validação. @@ -123,7 +126,7 @@ O **handle** do bot (`@revisao`) é derivado do nome pela mesma regra, acompanha attachments\<aaaa-mm-dd>\ arquivos que o dono mandou no chat (9.5) .claude\ settings.json regra de negação para os segredos (gerado pelo daemon, sobrescrito a cada start) - rules\botloft.md identidade, papel, crew e guia de uso das tools (gerado pelo daemon) + rules\botloft.md identidade, papel, crew, pasta de trabalho, guia de uso das tools e, no chefe, como liderar (gerado pelo daemon) .botloft\ mcp.json config MCP do bot (gerado pelo daemon) ``` @@ -154,6 +157,7 @@ retry_backoff_max_ms = 120000 [bots] approval_timeout_minutes = 60 # sem resposta do dono, a ferramenta é negada attachment_max_mb = 20 # por arquivo; no máximo 10 arquivos por message +max_per_crew = 12 # até onde as sugestões do chefe levam uma crew (10.2) [tasks] max_hops = 4 @@ -202,7 +206,7 @@ Eventos de uma generation antiga são ignorados. Todo processo novo emite `bot.s - **Sessão:** o daemon guarda em `bots.session_id` o id da conversa. O primeiro start usa `--session-id <uuid novo>`; os seguintes, `--resume <session_id>`. Se a sessão retomada morrer em menos de `fresh_start_if_dies_within_s`, o próximo start vem com um id novo. `bots.restart {fresh: true}` também começa conversa nova. O histórico do chat fica no banco do daemon (seção 8) e não depende do transcript do Claude Code. - Mudanças em nome, papel ou instruções regravam as regras na hora, mas o bot só as lê no próximo start; o daemon não reinicia o bot sozinho. - `auth_error` não entra em loop de restart: fica parado até o owner pedir `bots.restart` ou até o daemon ver o Claude Code conectado de novo. -- **Login do Claude Code:** o daemon roda `claude auth status` (JSON com `loggedIn`; sai com 0 conectado e 1 desconectado, seção 19) no ambiente do usuário, sem janela: quando acha o Claude Code, a cada 30 s enquanto desconectado ou desconhecido, na hora quando um bot cai em `auth_error` e quando o app pede (`system.refresh`). Conectado, não confere de novo sozinho. Quando o resultado passa de desconectado para conectado, os bots em `auth_error` sobem de novo sem o dono pedir. Um erro de conta com o login válido (`billing_error`, `account_on_hold`, organização bloqueada) não muda o resultado e por isso não vira loop. O resultado sai em `system.status.claudeSignedIn`. O login em si é feito pelo app (15.2). +- **Login do Claude Code:** o daemon roda `claude auth status` (JSON com `loggedIn` e, conectado, `email`, `subscriptionType` e `orgName`; sai com 0 conectado e 1 desconectado, seção 19) no ambiente do usuário, sem janela: quando acha o Claude Code, a cada 30 s enquanto desconectado ou desconhecido, na hora quando um bot cai em `auth_error` e quando o app pede (`system.refresh`). Conectado, não confere de novo sozinho. Quando o resultado passa de desconectado para conectado, os bots em `auth_error` sobem de novo sem o dono pedir. Um erro de conta com o login válido (`billing_error`, `account_on_hold`, organização bloqueada) não muda o resultado e por isso não vira loop. O resultado sai em `system.status.claudeSignedIn`, e a conta (e-mail, plano, organização) em `system.status.account.claude`. O login em si é feito pelo app (15.2). - Cada processo de bot entra num **Job Object** com `KILL_ON_JOB_CLOSE`. Se o daemon morrer, a árvore de processos dos bots morre junto e não sobra `claude.exe` órfão. ### 7.4 Spawn @@ -218,7 +222,9 @@ Eventos de uma generation antiga são ignorados. Todo processo novo emite `bot.s (--session-id <uuid> | --resume <session_id>) --setting-sources project,local --mcp-config <workspace>\.botloft\mcp.json --strict-mcp-config - --permission-mode default + --add-dir <pasta de trabalho da crew> + --permission-mode <modo do bot> + [--model <modelo do bot>] --permission-prompt-tool mcp__botloft__permission_prompt --allowedTools mcp__botloft ``` @@ -226,7 +232,12 @@ Eventos de uma generation antiga são ignorados. Todo processo novo emite `bot.s - `--setting-sources project,local` e `--strict-mcp-config` deixam de fora hooks, skills, agents, modo de permissão e servidores MCP pessoais do dono: o bot vê o que o Botloft gera. O login da conta não é uma fonte de settings e continua valendo. - `--allowedTools mcp__botloft` libera as tools da crew sem aprovação. Uma regra `allow` no `settings.json` do projeto não bastaria: em `-p`, numa pasta que nunca passou pelo diálogo de confiança, o Claude Code não aplica as regras `allow` do projeto (documentado em `permissions`). - Qualquer outra ferramenta que peça permissão passa pela tool de aprovação (10.1) e vira um pedido no chat. -5. Ambiente: o bloco padrão do usuário (`CreateEnvironmentBlock`, o mesmo de um logon novo), **não** o ambiente do daemon. Um daemon iniciado de dentro de uma sessão do Claude Code herda `CLAUDECODE`, `CLAUDE_CODE_MESSAGING_SOCKET`, `ANTHROPIC_BASE_URL` e outras variáveis da sessão, que fariam o bot se achar filho dela. Por cima vão `BOTLOFT_BOT_ID`, `BOTLOFT_BOT_TOKEN` e `BOTLOFT_PORT`. + - `--add-dir` põe a pasta de trabalho da crew (5) entre as pastas do bot. Sem ela, gravar na `shared\`, que fica fora do workspace, pedia aprovação até em "Aceitar edições" (19). + - `--permission-mode` vem do modo do bot (`Bot.permissionMode`), que o dono escolhe no chat (15.1): `default` (Manual: pergunta antes de editar, rodar comandos e usar a rede), `accept_edits` (`acceptEdits`: edita arquivos sem perguntar), `plan` (planeja e pede para seguir, 10.1), `auto` (um classificador libera o que é seguro e o resto vira pedido) e `bypass_permissions` (`bypassPermissions`: faz tudo sem perguntar, ver 13). Bot novo começa em `default`. `dontAsk` não é oferecido: nega o que não estiver liberado, e o bot não teria como pedir. Regras `deny` valem em todos os modos. + - O Claude Code só lê a flag ao iniciar e não entra em `bypassPermissions` no meio da sessão. Por isso mudar o modo reinicia o processo com `--resume`, e a conversa continua: na hora se o bot está parado, ou quando o turno em andamento e as aprovações dele terminam, sem cortar o trabalho. + - `--model` vem do modelo do bot (`Bot.model`), que o dono escolhe no chat ou ao criar o bot (15.1): `fable`, `opus`, `sonnet` ou `haiku`, os apelidos do Claude Code, que apontam sempre para a versão mais nova de cada família. `default` deixa a flag de fora, e o Claude Code usa o padrão da conta, que depende do plano (19). Bot novo começa em `default`. O Claude Code não troca de modelo sozinho conforme a tarefa. Mudar o modelo reinicia o processo como a troca de modo, e `--resume` com `--model` passa a usar o modelo novo. O `system/init` de cada turno traz o modelo em uso (`claude-opus-5-5`); o daemon o guarda em `Bot.modelInUse` para o app dizer qual é o padrão do plano. Um modelo que a conta não pode usar falha o turno com o erro `model_not_found` (8.1), e o processo continua vivo. + - O Claude Code sai do modo `plan` sozinho quando o dono aprova o plano. Cada turno começa com um `system/init` que traz `permissionMode` (19); se o processo começou em `plan`, o modo gravado ainda é `plan` e o init diz outro, o daemon grava o novo, sem reiniciar, para o app mostrar o que o bot faz e um reinício manter. Qualquer outra diferença vem de um processo que está para reiniciar no modo que o dono acabou de escolher, e é ignorada. +5. Ambiente: o bloco padrão do usuário (`CreateEnvironmentBlock`, o mesmo de um logon novo), **não** o ambiente do daemon. Um daemon iniciado de dentro de uma sessão do Claude Code herda `CLAUDECODE`, `CLAUDE_CODE_MESSAGING_SOCKET`, `ANTHROPIC_BASE_URL` e outras variáveis da sessão, que fariam o bot se achar filho dela. Por cima vão `BOTLOFT_BOT_ID`, `BOTLOFT_BOT_TOKEN`, `BOTLOFT_PORT` e `CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD=1`, que faz o Claude Code carregar o `CLAUDE.md` da pasta de trabalho (5). 6. stdin, stdout e stderr em pipes, sem console (`CREATE_NO_WINDOW`). O stdin fica aberto enquanto o processo vive; fechá-lo encerra o Claude Code com código 0. O stderr vai para o log em nível `debug`, sem conteúdo de mensagem. ### 7.5 `settings.json` gerado @@ -253,13 +264,13 @@ Uma linha JSON por evento, em UTF-8. Linha que não é JSON, ou maior que 8 MiB, | Evento | O que vira | |---|---| -| `system/init` | guarda `session_id` em `bots.session_id` (vem no começo de cada turno) | +| `system/init` | guarda `session_id` em `bots.session_id` (vem no começo de cada turno); segue `permissionMode` e guarda `model` (7.4) | | `user` com `isReplay: true` | a message com aquele `uuid` começou a ser processada: a delivery ganha `read_at` (9.1) | | `stream_event` com `text_delta` | texto ao vivo da resposta (`chat.delta`, 8.3); não é gravado | | `assistant`, bloco `text` | item `reply` com o texto (markdown) | | `assistant`, bloco `tool_use` | item `tool` em `running`, com resumo da entrada | | `user`, bloco `tool_result` | atualiza o item `tool` do mesmo `tool_use_id`: `done` ou `failed` e um trecho da saída | -| `assistant` com `error` | item `notice` e, conforme o erro, estado `rate_limited` ou `auth_error` (7.2) | +| `assistant` com `error` | item `notice` e, conforme o erro, estado `rate_limited` ou `auth_error` (7.2); `model_not_found` vira o aviso `model_unavailable` | | `rate_limit_event` | uso da conta (janelas de 5 h e 7 dias) em `system.status.usage`; status diferente de `allowed` leva a `rate_limited` | | `result` | item `turn` com duração, custo e erro (se houve); fecha um turno pendente | @@ -276,7 +287,7 @@ Todo item tem `id` (`cht_`), `botId`, `kind`, `createdAt` e `updatedAt`. | `tool` | `toolUseId`, `name`, `summary`, `input`, `status` (`running`, `done`, `failed`), `output` | ferramenta usada pelo bot | | `approval` | `approvalId`, `toolName`, `summary`, `input`, `status` (`pending`, `allowed`, `denied`, `expired`), `note` | pedido de permissão (10.1) | | `turn` | `durationMs`, `costUsd`, `error` | fim de um turno | -| `notice` | `level` (`info`, `warning`, `error`), `code` (`signed_out`, `usage_limit`, `turn_failed`; ausente em avisos antigos), `text` | avisos do daemon: limite de uso, login, turno com erro. O app escreve os avisos com `code` no idioma do dono; `text` fica em inglês para quem não conhece o código e, em `turn_failed`, traz o detalhe do erro | +| `notice` | `level` (`info`, `warning`, `error`), `code` (`signed_out`, `usage_limit`, `turn_failed`, `model_unavailable`; ausente em avisos antigos), `text` | avisos do daemon: limite de uso, login, turno com erro. O app escreve os avisos com `code` no idioma do dono; `text` fica em inglês para quem não conhece o código e, em `turn_failed`, traz o detalhe do erro | - `summary` é uma frase curta feita pelo daemon a partir da entrada: o comando do `Bash`, o arquivo do `Read`/`Edit`/`Write`, o padrão do `Grep`/`Glob`, a URL do `WebFetch`, a busca do `WebSearch`, o destinatário do `send_message`. Ferramenta desconhecida mostra só o nome. - `input` guarda o JSON da entrada até 4 KB; `output`, até 8 KB de texto. O resto fica só no transcript do próprio Claude Code. @@ -382,10 +393,11 @@ Transporte: Streamable HTTP, só POST e resposta `application/json`, sem sessão | Tool | Entrada | Saída (JSON em texto) | |---|---|---| -| `crew_roster` | nenhuma | `crew`, `you` e os outros bots da crew: handle, nome, papel, estado | +| `crew_roster` | nenhuma | `crew`, `you`, `you_lead` e os outros bots da crew: handle, nome, papel, estado e `chief` | | `send_message` | `to` (handle, com ou sem `@`), `body`, `kind?` (`note` padrão, `task`), `deadline_minutes?` (só task) | `message_id`, `task_id` e `due` (task), e um lembrete de que a resposta chega depois | | `complete_task` | `task_id`, `result`, `status?` (`done` padrão, `failed`) | `task_id`, `status` e quem recebe o resultado | | `my_tasks` | `role?` (`assigned`, `requested`) | tasks `open` e `expired`: id, de, para, status, prazo relativo, hops e o pedido original | +| `suggest_bot` | `name`, `role`, `instructions` (até 8 000 caracteres), `model?`, `reason` (até 1 000) | `created` e, criado, `handle`, `name`, `role`, `model` e um lembrete para mandar a primeira task; recusado ou sem resposta, o porquê (10.2). Só o chefe | | `permission_prompt` | `tool_name`, `input`, `tool_use_id` | decisão do dono (10.1). Chamada pelo Claude Code, não pelo modelo | - Erro que o modelo pode corrigir (handle desconhecido, argumento inválido, limite de hops, task de outro bot) volta como resultado com `isError: true` e uma frase explicando. Só tool desconhecida ou chamada malformada vira erro JSON-RPC (`-32602`). @@ -408,8 +420,21 @@ Com `--permission-prompt-tool mcp__botloft__permission_prompt`, toda ferramenta "Permitir sempre" (gravar uma regra para o bot) fica para depois do MVP. +**Plano.** No modo `plan`, o bot pede para seguir com a ferramenta `ExitPlanMode`, cuja entrada traz o plano em markdown (`{plan}`). O pedido passa pela mesma tool e vira no chat um cartão com o plano inteiro: a entrada dessa ferramenta é guardada até 32 KB (as outras, até 4 KB) e o resumo é a primeira linha do plano. "Aprovar plano" permite; "Pedir mudanças" nega com a nota do dono, e o bot continua planejando. Depois de aprovado, o Claude Code troca de modo sozinho (7.4). Que o pedido passa pela tool em `-p` e para qual modo o bot vai ainda precisam de teste real (19). + A aprovação só abre se `tool_use_id` for de uma ferramenta em `running` no chat daquele bot. O daemon espera até 2 s pelo evento, que às vezes chega depois da chamada. Senão nega na hora, sem incomodar o dono. Assim um bot que chame `permission_prompt` por conta própria não consegue pôr um pedido inventado na frente do dono. A descrição da tool também diz para não chamá-la. +### 10.2 Chefe e sugestões de bots + +Toda crew nova nasce com um **chefe**: `crews.create` com `lead` cria a crew e esse bot juntos, e `Crew.leadBotId` aponta para ele. O app escreve nome e papel no idioma do dono ("Chefe", "Lidera a equipe: planeja o trabalho, sugere bots novos e distribui as tarefas"); as instruções são o objetivo que o dono escreveu para a crew. O chefe é gravado antes de o supervisor poder subi-lo, então o primeiro start já lê que lidera. O dono troca o chefe (`crews.setLead`) ou deixa a crew sem nenhum; o chefe antigo e o novo têm as regras regravadas e reiniciam quando nada estiver em andamento (7.4). Arquivar o chefe deixa a crew sem chefe. Crews de antes não têm chefe até o dono escolher um. + +- **Regras do chefe:** além das de todo bot, uma seção "You lead this crew": planejar, dividir o trabalho em partes que rodam em paralelo e distribuí-las com `send_message` (`kind: "task"`); conferir os resultados antes de responder ao dono; quando faltar um especialista, sugerir um bot com `suggest_bot`; escolher o modelo pelo trabalho (`haiku` para o simples e repetitivo, `sonnet` para quase tudo, `opus` ou `fable` só para o raciocínio mais difícil, lembrando que gastam mais do plano); manter a crew pequena; e contar ao dono o que cada bot faz, para ele acompanhar e falar com cada um no chat dele. Os outros bots leem que, se a crew precisar de outro bot, devem pedir ao chefe, que o `crew_roster` marca com `chief`. +- **`suggest_bot`:** aparece para todos os bots, mas só o chefe pode usar; os outros recebem um erro que manda pedir ao chefe. Antes de incomodar o dono, o daemon confere os campos (os de um bot, mais o limite de instruções e o porquê), que o nome está livre na crew e que a crew tem menos de `max_per_crew` bots ativos. Um pedido impossível volta como erro ao chefe. +- **Aprovação:** a sugestão vira um pedido no chat do chefe, pelo mesmo caminho das aprovações (10.1): `approval` com `toolName: "mcp__botloft__suggest_bot"`, entrada até 64 KB e resumo com o nome sugerido. O chefe fica `needs_approval`, e a chamada MCP espera a resposta até `approval_timeout_minutes`. A tool vem liberada por `--allowedTools mcp__botloft`, então o Claude Code não pede permissão antes: quem decide é o dono, pelo cartão. +- **Resposta:** permitir cria o bot na crew do chefe, com modo Manual e o modelo sugerido. O dono pode mudar nome, papel, modelo e instruções antes: `approvals.answer` leva `input`, o JSON da sugestão como ele deixou, que substitui a entrada gravada (o cartão mostra o que foi criado); `input` só vale para sugestões. Negar volta ao chefe com a nota do dono, e nada é criado. Sem resposta no prazo, o chefe lê que pode sugerir de novo depois. O bot novo sobe na hora e aparece na barra lateral, com o próprio chat; o resultado da tool lembra o chefe de mandar a primeira task. +- **Chefe em `bypass_permissions`:** a sugestão cria o bot na hora, sem cartão, como tudo o que esse modo faz sem perguntar (13). O resultado diz ao chefe que foi criado sem pedir. +- Bots criados assim são bots comuns: o dono conversa, muda, pausa e arquiva cada um como qualquer outro. + ## 11. Protocolo do app (JSON-RPC 2.0 sobre WebSocket) Endpoint: `ws://127.0.0.1:45710/rpc`. Mensagens seguem JSON-RPC 2.0: requests com `id`, respostas com `result` ou `error`, notificações do servidor sem `id`. O maior frame aceito do app é de 32 MiB, por causa dos anexos. @@ -426,21 +451,25 @@ Endpoint: `ws://127.0.0.1:45710/rpc`. Mensagens seguem JSON-RPC 2.0: requests co | Método | Params | Result | |---|---|---| -| `system.status` | | versão, uptime, versão e caminho do claude (`claudeVersion`, `claudePath`), `runtimeError` (por que os bots não sobem), `claudeSignedIn` (7.3; `null` antes de conferir), backlog de entrega, `usage` (uso da conta, 8.1) | +| `system.status` | | versão, uptime, versão e caminho do claude (`claudeVersion`, `claudePath`), `runtimeError` (por que os bots não sobem), `claudeSignedIn` (7.3; `null` antes de conferir), `account` (o dono para a área da conta do app: `name`, o nome de exibição da conta do Windows, `GetUserNameExW(NameDisplay)`, ou o nome de usuário sem ele, lido uma vez; e `claude`, a conta do Claude com `email`, `plan` e `organization`, ou `null` desconectado), backlog de entrega, `usage` (uso da conta, 8.1) | | `system.refresh` | | pede uma nova conferência do Claude Code (login e, se falhou, o executável) e responde na hora com o `system.status` atual; o app relê o status até ver o resultado | | `crews.list` | | `Crew[]` | -| `crews.create` | `name` | `Crew` | +| `crews.create` | `name, workFolder?, lead?` (`{name, role, instructions, model?}`: o chefe, 10.2) | `Crew` | | `crews.rename` | `crewId, name` | `Crew` | | `crews.setPaused` | `crewId, paused` | `Crew` | +| `crews.setLead` | `crewId, botId` (ou `null`, sem chefe) | `Crew`; o chefe antigo e o novo reiniciam quando nada estiver em andamento (10.2) | +| `crews.setWorkFolder` | `crewId, workFolder` (caminho, ou `null` para voltar à `shared\`) | `Crew`; os bots reiniciam na pasta nova quando nada estiver em andamento (5) | | `crews.archive` | `crewId` | `Crew` | | `bots.list` | `crewId?` | `Bot[]` | -| `bots.create` | `crewId, name, role, instructions, color?` | `Bot` | +| `bots.create` | `crewId, name, role, instructions, color?, model?` | `Bot` | | `bots.update` | `botId, name?, role?, instructions?, color?` | `Bot` | | `bots.setPaused` | `botId, paused` | `Bot` | +| `bots.setPermissionMode` | `botId, mode` (`default`, `accept_edits`, `plan`, `auto`, `bypass_permissions`) | `Bot`; o bot reinicia no novo modo quando nada estiver em andamento (7.4) | +| `bots.setModel` | `botId, model` (`default`, `fable`, `opus`, `sonnet`, `haiku`) | `Bot`; o bot reinicia no novo modelo quando nada estiver em andamento (7.4) | | `bots.restart` | `botId, fresh?` | `Bot` | | `bots.archive` | `botId` | `Bot` | | `chat.history` | `botId, before?, limit?` | `ChatItem[]`, mais novo primeiro; `limit` de 1 a 200, 50 se ausente | -| `approvals.answer` | `approvalId, allow, note?` | `Approval` | +| `approvals.answer` | `approvalId, allow, note?, input?` (`input`: a sugestão de bot como o dono a deixou, 10.2) | `Approval` | | `messages.send` | `botId, body, attachments?` (`[{name, mediaType, data}]`, data em base64) | `Message` | | `messages.list` | `crewId?, botId?, before?, limit?` | `Message[]` | | `attachments.read` | `attachmentId` | `{mediaType, data}`, data em base64 (9.5) | @@ -448,7 +477,7 @@ Endpoint: `ws://127.0.0.1:45710/rpc`. Mensagens seguem JSON-RPC 2.0: requests co | `deliveries.retry` | `deliveryId` | `Delivery` | | `tasks.list` | `crewId?, status?` | `Task[]` | -`Bot` traz também `lastActivity`: o último item do chat resumido em uma linha, para a lista de conversas: `kind` (`owner`, `message`, `reply`, `tool`, `approval`, `notice`), `text` e `at`. O `text` não tem palavras do daemon: a mensagem do dono vem sem "You:" e a aprovação só com o nome da ferramenta, e o app completa no idioma do dono. +`Crew` traz `workFolder`, o caminho da pasta de trabalho (a escolhida ou a `shared\`), `workFolderChosen` e `leadBotId`, o chefe (10.2). `Bot` traz também `permissionMode`, `model` e `modelInUse` (7.4) e `lastActivity`: o último item do chat resumido em uma linha, para a lista de conversas: `kind` (`owner`, `message`, `reply`, `tool`, `approval`, `notice`), `text` e `at`. O `text` não tem palavras do daemon: a mensagem do dono vem sem "You:" e a aprovação só com o nome da ferramenta, e o app completa no idioma do dono. ### 11.3 Notificações do servidor @@ -472,8 +501,8 @@ Pragmas: `journal_mode=WAL`, `foreign_keys=ON`, `busy_timeout=5000`. Migrations | Tabela | Colunas principais | |---|---| -| `crews` | `id, name, slug, paused, created_at, archived_at` | -| `bots` | `id, crew_id, name, handle, slug, role, instructions, color, paused, token_hash, session_id, created_at, archived_at` | +| `crews` | `id, name, slug, paused, work_dir, lead_bot_id, created_at, archived_at` (`work_dir` é a pasta escolhida; `NULL` usa a `shared`. `lead_bot_id` é o chefe, sem chave estrangeira: ele é gravado junto com a crew) | +| `bots` | `id, crew_id, name, handle, slug, role, instructions, color, paused, permission_mode, model, model_in_use, token_hash, session_id, created_at, archived_at` | | `messages` | `id, crew_id, from_kind (owner/bot/system), from_bot_id, to_bot_id, kind (note/task/result/system), body, task_id, created_at` | | `attachments` | `id, message_id, name, media_type, size, path, created_at` | | `deliveries` | `id, message_id, bot_id, state, attempts, next_attempt_at, lease_until, last_error, sent_generation, turn_uuid, read_at, updated_at` | @@ -493,6 +522,8 @@ Pragmas: `journal_mode=WAL`, `foreign_keys=ON`, `busy_timeout=5000`. Migrations - `log_level` vale só para os crates do Botloft; dependências ficam em `warn`, porque em `debug`/`trace` a pilha de WebSocket registra frames, que podem conter mensagens. `RUST_LOG` sobrepõe tudo e é só para depuração local. - Nome de anexo vira só o nome do arquivo (sem `..`, sem pasta, sem caracteres proibidos no Windows) antes de ir para o disco. - Isolamento entre bots é cooperativo (mesmo usuário do Windows). Documentar isso no README sem prometer sandbox. +- Pasta de trabalho escolhida (5): todos os bots da crew a editam como a própria pasta. Por isso ela não pode tocar a pasta de dados do Botloft (segredos, banco) nem conter os workspaces de todos os bots, e não pode ser um disco inteiro. +- Modo `bypass_permissions` (7.4): o bot faz tudo sem perguntar. As regras `deny` de leitura só cobrem as ferramentas de arquivo do Claude Code, alguns comandos do Bash (`cat`, `head`, `tail`, `sed`, `tee`) e redirecionamentos, não um script em Python ou Node, e o Windows nativo não tem sandbox. Um bot nesse modo pode ler `secrets\owner.token`, o banco e as pastas de outros bots, e uma mensagem de outra pessoa pode levá-lo a isso. O app só liga o modo depois de uma confirmação que diz isso, e o bot fica marcado em vermelho (15.1). Um chefe nesse modo também cria bots sem perguntar (10.2), e a confirmação diz isso quando o bot é o chefe. ## 14. Integração com o Windows @@ -550,9 +581,15 @@ O store recarrega crews, bots e `system.status` a cada (re)conexão e depois seg Layout, como um app de mensagens: -- **Barra lateral:** crews como seções, com os bots como conversas. Cada conversa mostra avatar, nome, estado (cor, ícone e texto) e a prévia da última atividade (`lastActivity`) com a hora. -- **Área principal com um bot:** cabeçalho com nome, estado e ações; o chat; o compositor embaixo. O compositor aceita texto, colar imagem e arrastar ou escolher arquivos. Enter envia e Shift+Enter quebra linha. -- **Área principal com uma crew:** a timeline (messages entre os bots e do dono) e as tasks. +- **Barra lateral:** crews como seções, com os bots como conversas. Cada conversa mostra avatar, nome, estado (cor, ícone e texto) e a prévia da última atividade (`lastActivity`) com a hora. Ela aparece desde a conexão, também na tela de boas-vindas antes da primeira crew. +- **Área da conta**, no pé da barra lateral, como nos apps de chat: um círculo com a inicial, o nome do dono (do Windows) e o plano do Claude ("Plano Max"; sem plano, a organização ou o e-mail; desconectado, "Sem conta do Claude conectada"). Um clique abre um menu para cima com o e-mail e: **Uso** (as janelas de uso do plano, 8.1, com a parte usada e quando renovam; antes da primeira resposta de um bot, um aviso de que ainda não há dados), **Configurações** (tema, tamanho, idioma e as versões do Botloft e do Claude Code), **Idioma** (submenu ao lado, com a escolha na hora), **Novidades** (a página de releases no navegador) e **Ajuda** (o README no navegador). Tema, tamanho e idioma saíram da barra de título; ela só mostra o idioma nas telas de preparo, que ainda não têm barra lateral. +- **Área principal com um bot:** cabeçalho com nome, estado e ações; o chat; o compositor embaixo. O compositor aceita texto, colar imagem e arrastar ou escolher arquivos. Enter envia e Shift+Enter quebra linha (a dica aparece enquanto o dono escreve). +- **Modo do bot**, no compositor, ao lado do clipe, como no Claude Code: um botão com o modo atual abre um menu para cima, "Modo", com Automático, Manual, Aceitar edições e Plano, cada um com uma linha que fala do bot pelo nome ("Scout decide o que precisa do seu OK") e a marca no atual. Separado, "Ignorar permissões" com o botão Ativar, que abre uma confirmação dizendo que o bot não fica preso à pasta dele (13). Nesse modo o botão fica vermelho e o cabeçalho mostra "Não pergunta nada" em vermelho. Com o bot ocupado, uma linha acima do compositor avisa que ele muda de modo quando terminar o que está fazendo. +- **Modelo do bot**, no compositor, ao lado do botão de enviar: mostra o modelo em uso ("Opus 5.5"; antes do primeiro turno, o nome escolhido ou "Padrão") e abre um menu para cima, "Modelo", com Padrão do plano, Fable, Opus, Sonnet e Haiku. Cada um tem uma linha que fala do bot pelo nome ("Scout fica rápido e capaz, bom para quase tudo"; o padrão diz qual modelo é hoje), e o pé do menu lembra que modelos mais capazes gastam o limite do plano mais rápido. A janela de criar e editar bot tem a mesma escolha. Com o bot ocupado, a mesma linha acima do compositor avisa que ele troca quando terminar. +- **Área principal com uma crew:** a timeline (messages entre os bots e do dono) e as tasks. Embaixo do nome, "Trabalha em <pasta>", que abre a pasta no Explorer; o menu da crew tem "Abrir pasta de trabalho" e "Mudar pasta de trabalho…", que abre o seletor de pastas do Windows e confirma antes de mudar, avisando que cada bot reinicia quando terminar o que está fazendo. +- **Nova crew:** nome; "Para que é esta equipe?", o objetivo que vira as instruções do chefe, com a explicação de que a equipe começa com um Chefe que planeja o trabalho e sugere os bots de que precisa; "Pasta de trabalho", com "Escolher pasta…" (o seletor do Windows; sem escolha, "Uma pasta nova dentro do Botloft", a `shared\`); e "Modelo do Chefe". Criada, o app abre o chat do chefe. +- **Chefe:** uma coroa ao lado do nome na barra lateral e nos cartões da crew, e "Chefe" no cabeçalho do bot, com a dica "Lidera <crew>: planeja o trabalho e sugere bots novos". O menu do bot tem "Tornar chefe da equipe" ou "Deixar de ser chefe". +- **Sugestão de bot** (10.2): um cartão no chat do chefe, "<chefe> sugere um bot novo", com o porquê e os campos editáveis Nome, Modelo, Função e Instruções, a linha de que o bot começa na hora e recebe o trabalho do chefe, um campo para dizer ao chefe por que não, e os botões Criar bot e Agora não. Respondido, vira uma linha ("Você criou Designer", "Você recusou Designer") que abre o que foi sugerido. - **Detalhes do bot** (pasta, instruções, sessão) ficam num painel, fora do caminho da conversa. ### 15.2 Comandos Tauri @@ -565,6 +602,7 @@ Layout, como um app de mensagens: | `claude_sign_in` | abre `claude auth login` numa janela de console própria (`CREATE_NEW_CONSOLE`) com o `claudePath` do `system.status` e espera; responde se saiu com 0. Só roda um caminho absoluto de arquivo existente chamado `claude.exe`. Tira do ambiente `CLAUDECODE` e `CLAUDE_CODE_*`, que um app aberto de dentro de uma sessão do Claude Code herdaria. Quem abre é o app, e não o daemon, porque a janela aberta pelo app em primeiro plano vem para a frente. Na janela o dono vê o que acontece e pode colar um código se o navegador pedir | | `read_owner_token` | lê `secrets\owner.token` (só no app local) | | `open_path` | abre uma pasta no Explorer; recusa arquivos, que o Explorer executaria | +| seletor de pastas | não é comando próprio: o app usa o `tauri-plugin-dialog` (`open({directory: true})`, permissão `dialog:allow-open`) para a pasta de trabalho da crew (5) | | `open_url` | abre no navegador padrão um link de uma resposta do bot; só `http` e `https`, porque qualquer outro esquema pode iniciar um programa. Seguir o link dentro do app trocaria a janela pela página | | overlay na taskbar | não é comando próprio: o app usa `setOverlayIcon` da janela (permissão `core:window:allow-set-overlay-icon`) e marca o ícone com um ponto enquanto algo espera o dono: aprovação pendente, bot em `auth_error`, ou mensagem não entregue a um bot ativo. Entregas mortas para bot arquivado não contam: foram abandonadas de propósito | @@ -586,17 +624,29 @@ Em dev, `pnpm tauri dev` usa o `target\debug\botloftd.exe` como sidecar e instal ### 15.3 Direção visual -Ferramenta de trabalho densa e calma: tipografia forte, grid firme, estados dos bots legíveis de longe (cor + ícone + texto, nunca só cor). Sem gradiente, sem sombra pesada, sem visual de template. Tema escuro e claro. Barra de título própria (`decorations: false`) com controles de janela do Windows. +Ferramenta de trabalho densa e calma: tipografia forte, grid firme, estados dos bots legíveis de longe (cor + ícone + texto, nunca só cor). Sem gradiente, sem sombra pesada, sem visual de template. Cantos arredondados, como nos apps de chat: botões, campos e linhas de menu com 8 px; cartões, avisos e menus com 12 px; compositor, diálogos e cartões do chat com 16 px. Menus e diálogos flutuam com uma sombra leve (`shadow-lift`, mais forte no tema escuro). Na barra lateral, a conversa aberta é um bloco arredondado recuado das bordas. Tema escuro e claro. Barra de título própria (`decorations: false`) com controles de janela do Windows. + +Tamanho: a janela inteira é desenhada numa escala (zoom do webview, `setZoom`), então texto, espaçamento, ícones e avatares crescem juntos. Níveis 100%, 110%, 125% e 150%; o padrão é **125%**, porque o desenho a 100% ficava miúdo num monitor sem ampliação do Windows. Quem já usa a ampliação alta volta para 100% em Configurações (área da conta) ou com Ctrl+-; Ctrl+= aumenta e Ctrl+0 volta ao padrão. A escolha fica no `localStorage` (`botloft.zoom`) e é aplicada antes da primeira pintura, para a janela não piscar pequena. Acima de 150% a janela mínima (900 px) não cabe o layout. + +Movimento: o app se mexe para parecer vivo, sem atrapalhar o trabalho. Animações curtas (150 a 400 ms, saída suave) em CSS, sem biblioteca (`motion.css`), e todas param quando o Windows desliga os efeitos de animação (`prefers-reduced-motion`). + +- **Mascote:** cada bot tem um humor que segue o estado. Ele pisca de vez em quando (cada bot num ritmo, para uma equipe não piscar junta), tremula como chama enquanto trabalha (`busy`, `launching`), dá pulinhos enquanto espera o dono (`needs_approval`), fica de olhos cansados no limite de uso e dorme, de olhos fechados, pausado ou parado. Mexem-se os mascotes da barra lateral, do cabeçalho, dos cartões da crew e da resposta em andamento; o histórico do chat fica parado. O humor soma ao estado, que continua com cor, ícone e texto. +- **Chegadas:** o que chega enquanto o dono olha entra subindo e aparecendo: mensagens, ferramentas, pedidos, avisos e bots novos na barra lateral. O que já estava lá quando ele abriu o chat (ou o app) aparece parado, e páginas antigas carregadas em cima não se mexem. A resposta já aparece enquanto é escrita, então não anima de novo ao terminar. +- **Trabalhando:** os três pontos pulam em sequência; o texto sendo escrito tem um cursor piscando no fim; a mão de "Precisa de aprovação" acena; um pedido pendente pulsa uma vez ao aparecer. +- **Trocar de bot ou de crew:** o painel principal some rápido e o novo sobe (View Transitions do webview); a barra lateral fica onde está. +- **Superfícies:** menus e seletores abrem a partir de onde estão presos; diálogos aparecem com o fundo escurecendo; avisos entram deslizando; `<details>` abre deslizando; a linha da aba selecionada desliza até a nova; as barras de uso enchem ao abrir; botões afundam um pouco ao clicar; o mascote da tela de boas-vindas e do chat vazio flutua. No chat: +- O chat é uma coluna centralizada (48rem), com o compositor na mesma largura; o dia é uma pílula no meio. - O dono fala em balões à direita; o bot, à esquerda, com markdown. - Mensagens de outros bots aparecem à esquerda, com o avatar e o nome de quem mandou. - O que o bot faz com as ferramentas aparece em linhas compactas (ícone, ferramenta, resumo e estado), agrupadas por turno, que abrem para mostrar entrada e saída. - Pedido de aprovação é um cartão com o que o bot quer fazer e os botões Permitir e Negar. +- Pedido para seguir com um plano (10.1) é um cartão com o plano em markdown, um campo para o que deve mudar e os botões Aprovar plano e Pedir mudanças. Respondido, vira uma linha que abre o plano de novo. - Anexos aparecem como miniatura (imagem) ou cartão com nome, tipo e tamanho. -Identidade: o mascote do Botloft é uma chama com olhos, desenhada em vetor em `app/app-icon.svg`. O ícone do app é o mascote branco sobre fundo preto. Cada bot usa o mesmo personagem como avatar, com uma cor própria escolhida na criação. A cor do avatar identifica o bot e não comunica estado: estado continua sendo cor + ícone + texto, como descrito acima. +Identidade: o mascote do Botloft é uma chama com olhos, desenhada em vetor em `app/app-icon.svg`. O ícone do app é o mascote branco sobre fundo preto. Cada bot usa o mesmo personagem como avatar, com uma cor própria escolhida na criação, sem fundo e com um contorno fino e discreto (escuro no tema claro, claro no escuro) para as cores claras não sumirem. O mascote branco do próprio Botloft (barra de título, mensagens do daemon) fica sobre o quadrado preto do ícone do app, que é o que o torna visível no tema claro. A cor do avatar identifica o bot e não comunica estado: estado continua sendo cor + ícone + texto, como descrito acima. O mascote se mexe conforme o que o bot faz (ver Movimento), sem substituir isso. ### 15.4 Instalador e sidecar @@ -617,7 +667,7 @@ Identidade: o mascote do Botloft é uma chama com olhos, desenhada em vetor em ` - O app fala **inglês, português (Brasil) e espanhol**. Todo texto que o dono lê fica em `app/src/i18n/<idioma>/`, um arquivo por área (`common`, `shell`, `onboarding`, `updates`, `bots`, `chat`, `crews`, `messages`). O inglês é a referência: o formato dele é o tipo `Messages`, e um texto que falte ou sobre em outro idioma não compila. Texto com valores é função (`ready(version)`), com o plural escrito para cada idioma. - Componentes leem com `useT()`; código fora do React (toasts, formatação, erros da conexão) com `t()` na hora do uso. -- Escolha no botão de idioma da barra de título (também nas telas de preparo): "Idioma do sistema" segue o Windows (o primeiro idioma suportado entre os preferidos; `pt-PT` vira `pt-BR`; nenhum, inglês) ou um idioma fixo. A escolha fica no `localStorage` do app (`botloft.locale`) e marca `<html lang>`. +- Escolha na área da conta (Idioma, ou Configurações), e no botão de idioma da barra de título só nas telas de preparo: "Idioma do sistema" segue o Windows (o primeiro idioma suportado entre os preferidos; `pt-PT` vira `pt-BR`; nenhum, inglês) ou um idioma fixo. A escolha fica no `localStorage` do app (`botloft.locale`) e marca `<html lang>`. - Datas e horas (`lib/format.ts`) usam o idioma escolhido. - O daemon não escreve texto para o dono: avisos vêm com `code` e a linha da conversa com `kind` (8.2, 11.2), e o app escreve. Continuam como vêm: nomes, mensagens, respostas e saídas de ferramenta; o resumo de ferramenta que o daemon faz a partir da entrada (o comando, o arquivo); e as mensagens de erro do daemon (validação, falhas), mostradas como texto técnico. - O instalador NSIS também traz os três idiomas e escolhe pelo idioma do Windows. @@ -673,6 +723,12 @@ Conferência na documentação oficial (code.claude.com/docs) em 2026-09-28. "Co | `--setting-sources project,local` | 7.4 | Confirmado (`cli-reference`). **Testado com 2.1.284**: sem os hooks, skills e agents do usuário; modo `default`; login da assinatura continua valendo | feito (M4.1) | | `claude auth status` | 7.3 | Confirmado (`cli-reference`): JSON por padrão, sai com 0 conectado e 1 desconectado. **Testado com 2.1.284**: conectado traz `"loggedIn": true`; com `CLAUDE_CONFIG_DIR` vazio, `"loggedIn": false`, `"authMethod": "none"` e saída 1. As credenciais ficam em `%USERPROFILE%\.claude\.credentials.json` (`authentication`) | feito | | `claude auth login` | 15.2 | Confirmado (`cli-reference`, `authentication`): abre o navegador e volta por um servidor local; se o navegador não alcançar esse servidor, mostra um código para colar no terminal. Se o subcomando sai sozinho depois do login ainda não foi visto: o app só depende do código de saída | manual (PR) | +| `permissionMode` no `system/init` | 7.4 | **Visto com 2.1.284**: o `system/init` de cada turno traz `permissionMode` com o valor da CLI (`default`, `acceptEdits`, `plan`, `auto`, `bypassPermissions`) | feito | +| Modos de permissão em `-p` | 7.4 | Confirmado (`permission-modes`): `deny` vale em todos os modos, inclusive `bypassPermissions`, que não pode ser ligado no meio da sessão; em `-p`, `auto` manda para a tool de aprovação o que o classificador não libera e `plan` continua bloqueando edições. O `auto` depende do plano e do modelo; o que `--permission-mode auto` faz sem ele ainda não foi visto | manual (PR) | +| `ExitPlanMode` em `-p` | 10.1 | A lista de ferramentas diz que ele pede permissão. Não visto: se o pedido chega à tool de aprovação com `{plan}` na entrada, e para qual modo o bot vai depois de aprovado (o daemon segue o `system/init` do turno seguinte) | manual (PR) | +| Modelo em `-p` | 7.4 | Confirmado (`model-config`, `sessions`): apelidos `fable`, `opus`, `sonnet`, `haiku` (e `best`, `opusplan`, `[1m]`, não usados); sem `model` nas settings, vale o padrão da conta; `--resume` mantém o modelo da sessão, a menos que `--model` escolha outro. **Visto com 2.1.284** (plano Max): sem `--model`, o `system/init` traz `"model": "claude-opus-5-5"`; um modelo inexistente sobe o processo, o init o repete, e cada turno termina com `assistant.error: "model_not_found"` e `result.is_error`; `/model haiku` mandado como mensagem troca o modelo no meio da sessão, com uma resposta sintética e sem custo, mas o daemon reinicia o processo em vez disso, como na troca de modo. Qual é o padrão em cada plano, e quais modelos cada plano tem, não está documentado | feito | +| `--add-dir` em `-p` | 5, 7.4 | Confirmado (`cli-reference`, `memory`): pastas a mais que o Claude Code trata como de trabalho; o `CLAUDE.md` delas só carrega com `CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD=1`. **Testado com 2.1.284** (`--setting-sources project,local`, `acceptEdits`): com a flag e a variável, o bot citou o `CLAUDE.md` da pasta sem abrir arquivo e gravou nela sem pedir; sem a flag, o `Write` na mesma pasta foi negado (`permission_denials`). A flag aceita vários valores: a linha de comando do daemon não tem prompt posicional, então nada é engolido | feito | +| Chefe e `suggest_bot` com o Claude Code real | 10.2 | **Testado com 2.1.284** (daemon e app de dev): a crew criada pelo app subiu o chefe com `--model sonnet` e `--add-dir` na pasta da crew. Pedido um site, o chefe carregou `crew_roster`, `suggest_bot` e `send_message` pelo `ToolSearch` e sugeriu um Designer com papel, instruções, modelo e porquê; a chamada esperou o cartão. Com o modelo trocado para `haiku` no cartão, o bot subiu com `--model haiku`, e o chefe citou a troca. O chefe mandou uma task, o Designer entregou com `complete_task`, e o chefe conferiu o resultado e corrigiu o HTML. O log de `debug` não teve texto de mensagem | feito | | Regras `allow` do projeto em `-p` sem confiança | 7.4 | Confirmado (`permissions`): não são aplicadas numa pasta nunca confiada; `deny` vale sempre. Por isso `--allowedTools mcp__botloft` | M4.1 | | `--session-id`, `--resume` em `-p` | 7.3 | Confirmado (`cli-reference`, `sessions`): a sessão retoma histórico e modelo; flags como `--mcp-config` têm de ser passadas de novo. **Testado com 2.1.284**: depois de reiniciar o bot e depois de reiniciar o daemon, o bot lembrou arquivos, a imagem e a mensagem de outro bot | feito (M4.1) | | Tools MCP adiadas | 10 | **Visto com 2.1.284**: as tools do `botloft` chegam adiadas; antes da primeira `send_message` o bot chama `ToolSearch` com `select:mcp__botloft__send_message`. O chat mostra isso como "load send_message" | feito (M4.1) |
+ + + + {p.ready(bot.name)} +