@chalky/chalky 0.1.3 → 0.1.4

package/app/extensions/login/index.ts

@@ -0,0 +1,214 @@
+// Login: connect models from the page and pick one (browser.js: /login, /logout, /model). pi's own login does the work, the call its
+// terminal /login makes (modelRuntime.login): a sign-in (OAuth: pi opens the provider's page and waits on a callback
+// server, or asks for the address to be pasted), or a custom endpoint (any OpenAI-, Anthropic- or Google-compatible
+// URL, its model names, an optional key). pi renews sign-ins itself; an expired one shows as pi's own error.
+// Where things go: tokens and keys in app/auth.json (pi's; never versioned), custom endpoints in app/models.json
+// (pi's; no secrets), this install's device id (OpenAI's sign-in asks for one) and the model choices in state/login.json:
+// {deviceId, default: {provider, id} (all agents), agents: {name: {provider, id}} (one agent's own; it wins)}.
+// server.ts asks host.api.login.modelFor(name, session) when it starts an agent: its own choice, else the all-agents
+// one, else nothing (then the MODEL_BASE_URL endpoint, extensions/model); a choice whose login is gone is skipped.
+// CHALKY_LOGIN=off (a cloud deployment, where the backend fixes the endpoint): none of this loads, and server.ts doesn't ask.
+//   GET /login/on       204 (so the page knows login is on)
+//   GET /login/models   {groups: [{provider, name, models: [{id, name, context}]}] (usable now), default, agents: [{name, model, own}]}
+//   GET /login          {providers: [{id, name, subscription, status}], custom: [{id, baseUrl, api, models, status}]}
+//                       status: "connected" | "expired" | undefined; each call checks the stored sign-ins (pi renews one that is due)
+//   page messages       login_start {provider}, login_answer {text}, login_cancel,
+//                       login_custom {id, api, baseUrl, key?, models: [names]}, login_list_models {baseUrl, api, key?, id?},
+//                       logout {provider}, model_set {for: "all" | <agent>, provider?, id?} (for an agent, no provider: back to all agents')
+//   event "login"       {step: "notify", event} (pi: open this link / enter this code / waiting) | {step: "prompt", prompt}
+//                       (pi asks: the page answers with login_answer) | {step: "prompt_done"} (pi stopped asking: the
+//                       callback came first) | {step: "done", provider} | {step: "cancelled"} | {step: "error", text} | {step: "models", models}
+//                       (login_list_models' answer) | {step: "changed"} (a login, endpoint or model changed: agents are synced)
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { ModelRuntime, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+const host = (globalThis as any).chalky;
+const MODELS = path.join(host.app, "models.json");
+const STATE = path.join(host.state, "login.json");
+const APIS = ["openai-completions", "openai-responses", "anthropic-messages", "google-generative-ai"];
+
+// one runtime for logins, on the same files as the agents' (each agent's session has its own: synced after a change)
+if (!host.shared.has("login-runtime"))
+  host.shared.set("login-runtime", ModelRuntime.create({ authPath: path.join(host.app, "auth.json"), modelsPath: MODELS }));
+const runtime = (): Promise<ModelRuntime> => host.shared.get("login-runtime");
+
+const readModels = () => (fs.existsSync(MODELS) ? JSON.parse(fs.readFileSync(MODELS, "utf8")) : { providers: {} });
+const readState = () => (fs.existsSync(STATE) ? JSON.parse(fs.readFileSync(STATE, "utf8")) : {});
+const writeState = (s: any) => fs.writeFileSync(STATE, JSON.stringify(s, null, 2) + "\n");
+function deviceId() {
+  const s = readState();
+  if (!s.deviceId) writeState({ ...s, deviceId: (s.deviceId = randomUUID()) });
+  return s.deviceId;
+}
+
+// the model an agent should use: its own choice, else the all-agents one; skipped when its login is gone
+function modelFor(name: string, session: any) {
+  const s = readState(), rt = session.modelRuntime;
+  for (const c of [s.agents?.[name], s.default])
+    if (c && rt.hasConfiguredAuth(c.provider)) { const m = rt.getModel(c.provider, c.id); if (m) return m; }
+  return undefined;
+}
+const fallback = (session: any) => session.modelRuntime.getModel("chalky", process.env.MODEL_NAME || "default");  // extensions/model
+async function apply(a: any) {  // put an agent on the model it should use now (after a choice, a login or a logout)
+  const m = modelFor(a.name, a.session) ?? fallback(a.session);
+  const cur = a.session.model;
+  if (m && !(cur && cur.provider === m.provider && cur.id === m.id)) await a.session.setModel(m);
+}
+host.api.login = { modelFor };
+
+async function status(rt: ModelRuntime, id: string) {
+  if (!rt.getProviderAuthStatus(id).configured) return undefined;
+  try { return (await rt.getAuth(id)) ? "connected" : undefined; } catch { return "expired"; }  // getAuth renews a sign-in that is due
+}
+
+async function synced() {  // a login or endpoint changed: every runtime reads the files again (offline)
+  await (await runtime()).refresh();
+  for (const a of host.agents.values()) { await a.session.modelRuntime.refresh(); await apply(a); }
+  host.broadcast("login", { step: "changed" });
+}
+
+const fail = (e: any) => host.broadcast("login", { step: "error", text: e?.message ?? String(e) });
+
+export default function (pi: ExtensionAPI) {
+  if (process.env.CHALKY_LOGIN === "off") return;
+
+  // at start, once: renew the sign-ins that are due, and say which failed (server log)
+  pi.on("session_start", async () => {
+    if (host.shared.has("login-checked")) return;
+    host.shared.set("login-checked", true);
+    const rt = await runtime();
+    for (const c of await rt.listCredentials())
+      if (c.type === "oauth" && (await status(rt, c.providerId)) === "expired") console.error(`login: the ${c.providerId} sign-in has expired (/login)`);
+  });
+
+  host.routes.set("/login/on", (_req: any, res: any) => res.writeHead(204).end());  // browser.js: add the commands only when this answers
+  host.routes.set("/login/models", (_req: any, res: any) => models(res).catch((e) =>
+    res.writeHead(500, { "content-type": "text/plain" }).end(String(e?.message ?? e))));
+  async function models(res: any) {  // read through an agent's runtime: it also has the MODEL_BASE_URL endpoint ("chalky")
+    const agents = [...host.agents.values()], s = readState();
+    const rt = agents[0]?.session.modelRuntime;
+    const groups = new Map<string, any>();
+    for (const m of rt ? await rt.getAvailable() : []) {
+      if (!groups.has(m.provider)) groups.set(m.provider, { provider: m.provider, name: m.provider === "chalky" ? "Chalky LiteLLM (MODEL_BASE_URL)"
+        : (readModels().providers[m.provider] ? `${m.provider} (custom)` : rt.getProvider(m.provider)?.name ?? m.provider), models: [] });
+      groups.get(m.provider).models.push({ id: m.id, name: m.name, context: m.contextWindow });
+    }
+    res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify({
+      groups: [...groups.values()], default: s.default ?? null,
+      agents: agents.filter((a) => !a.app).map((a) => ({ name: a.name, model: a.session.model ? { provider: a.session.model.provider, id: a.session.model.id } : null,
+        own: !!s.agents?.[a.name] })) }));
+  }
+
+  host.routes.set("/login", (_req: any, res: any) => list(res).catch((e) =>
+    res.writeHead(500, { "content-type": "text/plain" }).end(String(e?.message ?? e))));
+  async function list(res: any) {
+    const rt = await runtime();
+    await rt.refresh();
+    const custom = readModels().providers;
+    const providers = await Promise.all(rt.getProviders().filter((p) => p.auth.oauth && !(p.id in custom)).map(async (p) =>
+      ({ id: p.id, name: p.name, subscription: p.auth.oauth!.isSubscription === true, status: await status(rt, p.id) })));
+    const list = await Promise.all(Object.entries(custom).map(async ([id, p]: any) =>
+      ({ id, baseUrl: p.baseUrl, api: p.api, models: (p.models ?? []).map((m: any) => m.id), status: await status(rt, id) })));
+    res.writeHead(200, { "content-type": "application/json" })
+      .end(JSON.stringify({ providers: providers.sort((a, b) => a.name.localeCompare(b.name)), custom: list }));
+  }
+
+  host.pageHandlers.set("login", async (msg: any) => {
+    const flow = host.shared.get("login-flow");  // the sign-in under way: {abort, answer?}
+    if (msg.type === "login_answer") return flow?.answer?.(String(msg.text ?? ""));
+    if (msg.type === "login_cancel") return flow?.abort.abort();
+
+    if (msg.type === "login_start") {
+      flow?.abort.abort();  // one at a time
+      const abort = new AbortController(), me: any = { abort };
+      host.shared.set("login-flow", me);
+      try {
+        await (await runtime()).login(String(msg.provider), "oauth", {
+          signal: abort.signal,
+          notify: (event) => host.broadcast("login", { step: "notify", event }),
+          prompt: ({ signal, ...prompt }) => new Promise((resolve, reject) => {
+            const signals = [signal, abort.signal].filter((s) => s) as AbortSignal[];
+            const end = () => { me.answer = undefined; for (const s of signals) s.removeEventListener("abort", stop); };
+            me.answer = (text: string) => { end(); resolve(text); };
+            const stop = () => { end(); host.broadcast("login", { step: "prompt_done" }); reject(new Error("Login cancelled")); };
+            for (const s of signals) s.addEventListener("abort", stop, { once: true });
+            host.broadcast("login", { step: "prompt", prompt });
+          }),
+        }, { getDeviceId: deviceId });
+        await synced();
+        host.broadcast("login", { step: "done", provider: msg.provider });
+      } catch (e) { if (abort.signal.aborted) host.broadcast("login", { step: "cancelled" }); else fail(e); }  // ✕: not an error
+      finally { if (host.shared.get("login-flow") === me) host.shared.delete("login-flow"); }
+    }
+
+    if (msg.type === "login_custom") {
+      const id = String(msg.id ?? "").trim(), baseUrl = String(msg.baseUrl ?? "").trim().replace(/\/+$/, "");
+      const models = [...new Set<string>((msg.models ?? []).map((m: any) => String(m).trim()).filter(Boolean))];
+      const rt = await runtime(), saved = readModels();
+      if (!/^[a-z0-9][a-z0-9._-]*$/i.test(id)) return fail("The name can have letters, digits, '.', '_' and '-' only");
+      if (rt.getProvider(id) && !(id in saved.providers)) return fail(`'${id}' is one of pi's own providers: pick another name`);
+      if (!/^https?:\/\//.test(baseUrl)) return fail("The base URL starts with http:// or https://");
+      if (!APIS.includes(msg.api)) return fail(`Speaks: one of ${APIS.join(", ")}`);
+      if (!models.length) return fail("Add at least one model name");
+      const key = String(msg.key ?? "").trim();
+      const stored = (await rt.listCredentials()).some((c) => c.providerId === id);
+      // no key and none stored: a placeholder, so pi counts the endpoint usable (pi's docs: Ollama ignores it)
+      saved.providers[id] = { baseUrl, api: msg.api, ...(key || stored ? {} : { apiKey: "none" }), models: models.map((m) => ({ id: m })) };
+      fs.writeFileSync(MODELS, JSON.stringify(saved, null, 2) + "\n");
+      try {
+        await rt.refresh();
+        if (key) await rt.login(id, "api_key", { prompt: async () => key, notify() {} });  // pi saves it in auth.json
+        await synced();
+        host.broadcast("login", { step: "done", provider: id });
+      } catch (e) { fail(e); }
+    }
+
+    if (msg.type === "login_list_models") {  // the endpoint's own list (GET <baseUrl>/models); the key never goes to the page
+      try {
+        const rt = await runtime(), baseUrl = String(msg.baseUrl ?? "").trim().replace(/\/+$/, "");
+        const key = String(msg.key ?? "").trim() || (msg.id && rt.getProviderAuthStatus(msg.id).configured ? (await rt.getAuth(msg.id))?.auth.apiKey : "");
+        const headers: Record<string, string> = msg.api === "anthropic-messages" ? { "x-api-key": key ?? "", "anthropic-version": "2023-06-01" }
+          : msg.api === "google-generative-ai" ? { "x-goog-api-key": key ?? "" } : key ? { authorization: `Bearer ${key}` } : {};
+        const r = await fetch(`${baseUrl}/models`, { headers, signal: AbortSignal.timeout(10_000) });
+        if (!r.ok) return fail(`${baseUrl}/models answered ${r.status} ${r.statusText}`);
+        const body = await r.json();
+        const models = (body.data ?? body.models ?? []).map((m: any) => m.id ?? m.name?.replace(/^models\//, "")).filter(Boolean);
+        host.broadcast("login", { step: "models", models });
+      } catch (e) { fail(e); }
+    }
+
+    if (msg.type === "model_set") {
+      const s = readState(), who = String(msg.for ?? "all"), rt = host.agents.values().next().value?.session.modelRuntime;
+      const choice = msg.provider ? { provider: String(msg.provider), id: String(msg.id) } : undefined;
+      if (choice && !(rt?.hasConfiguredAuth(choice.provider) && rt.getModel(choice.provider, choice.id)))
+        return fail(`${choice.provider}/${choice.id} isn't usable now: connect it with /login`);
+      if (who === "all") {
+        if (!choice) return fail("Pick a model");
+        s.default = choice;
+      } else {
+        if (!host.agents.has(who)) return fail(`No agent '${who}'`);
+        s.agents = { ...s.agents };
+        if (choice) s.agents[who] = choice; else delete s.agents[who];  // no model: back to the all-agents one
+      }
+      writeState(s);
+      try {
+        for (const a of host.agents.values()) await apply(a);
+        host.broadcast("login", { step: "changed" });
+      } catch (e) { fail(e); }
+    }
+
+    if (msg.type === "logout") {
+      const id = String(msg.provider ?? ""), rt = await runtime(), saved = readModels();
+      try {
+        if ((await rt.listCredentials()).some((c) => c.providerId === id)) await rt.logout(id);
+        if (id in saved.providers) {
+          delete saved.providers[id];
+          fs.writeFileSync(MODELS, JSON.stringify(saved, null, 2) + "\n");
+        }
+        await synced();
+      } catch (e) { fail(e); }
+    }
+  });
+}

package/app/extensions/point/browser.js

@@ -209,14 +209,16 @@ export default async function (page) {
     const text = input.value.trim() || current?.suggestion;
     if (e.key !== "Enter" || !text || !current) return;
     const { suggestion, ...note } = current;
-    page.send({ ...note, text, to: note.to || document.getElementById("to")?.value });  // else the agent picked in the chat
+    page.send({ ...note, text, to: note.to || document.getElementById("to")?.value,  // else the agent picked in the chat
+                board: Number(document.body.dataset.board) || 1 });  // the board shown (boards/): what it points at is on it
     setOn(false);
   };
 
   const pins = {};  // note id -> pin element: its label, and its drawing if it has one
-  function pin({ id, text, to, x, y, stroke }) {  // stays where the note was written (doesn't follow scrolling yet)
+  function pin({ id, text, to, x, y, stroke, board }) {  // stays where the note was written (doesn't follow scrolling yet)
     if (pins[id]) return;
     const el = (pins[id] = document.createElement("div"));
+    el.dataset.board = board ?? 1;  // shown only on its board (boards/)
     el.style.cssText = "position:fixed;inset:0;z-index:9997;pointer-events:none;transition:opacity 1.5s";
     if (stroke) el.append(strokeSvg(stroke));
     const label = document.createElement("div");

package/app/extensions/point/index.ts

@@ -19,14 +19,15 @@ const host = (globalThis as any).chalky;
 const FILE = path.join(host.state, "notes.json");
 if (!host.shared.has("point"))
   host.shared.set("point", fs.existsSync(FILE) ? JSON.parse(fs.readFileSync(FILE, "utf8")) : { last: 0, open: {} });
-const notes = host.shared.get("point");  // {last, open: {id: {text, to, x, y, stroke}}}
+const notes = host.shared.get("point");  // {last, open: {id: {text, to, x, y, stroke, board}}}
 if (!host.shared.has("point-items")) host.shared.set("point-items", new Map());
 const items: Map<string, any> = host.shared.get("point-items");  // note id -> its swarm inbox item (not saved)
 const save = () => fs.writeFileSync(FILE, JSON.stringify(notes));
 
 function pin(text: string, to: string, msg: any) {  // a new open note: saved, pinned on every page
   const id = `n${++notes.last}`;
-  notes.open[id] = { text, to, x: msg.x ?? 0, y: msg.y ?? 0, stroke: msg.stroke ?? null };  // with its drawing, if any
+  notes.open[id] = { text, to, x: msg.x ?? 0, y: msg.y ?? 0, stroke: msg.stroke ?? null,  // with its drawing, if any
+                     board: Number(msg.board) || 1 };  // the board it was written on (boards/): its pin shows there
   save();
   host.broadcast("point_pin", { id, ...notes.open[id] });
   return id;
@@ -42,6 +43,19 @@ export default function (pi: ExtensionAPI) {
   const guide = fs.readFileSync(path.join(import.meta.dirname, "guide.md"), "utf8")  // short; README.md: the whole of it, read when it says
     .replace("README.md", path.join(import.meta.dirname, "README.md"));
   pi.on("before_agent_start", (event) => { event.systemPromptOptions.sections.point = guide; });
+  // a removed board (boards/) takes its open notes with it; a note its agent hasn't seen yet is just taken back
+  pi.on("session_start", () => host.api.boards?.onRemove("point", (n: number) => {
+    const gone: { owner: string; what: string }[] = [];
+    for (const id of Object.keys(notes.open).filter((id) => (notes.open[id].board ?? 1) === n)) {
+      const note = notes.open[id], item = items.get(id);
+      delete notes.open[id];
+      items.delete(id);
+      host.broadcast("point_done", { id });
+      if (!(item && host.api.swarm?.withdraw(item))) gone.push({ owner: note.to, what: `note ${id} ("${note.text}")` });
+    }
+    save();
+    return gone;
+  }));
 
   pi.registerTool({
     name: "note_done", label: "Note done", description: "Mark a note the user pinned on the UI as dealt with; its pin fades.",
@@ -78,6 +92,7 @@ export default function (pi: ExtensionAPI) {
       const madeFrom = [...(host.shared.get("ui")?.surfaces[b]?.made_from ?? []).filter((m: string) => m !== a), a];
       const id = pin(`combine ${a} into ${b}: ${text}`, to, msg);
       return items.set(id, swarm.send("user", to, [`[combine on the UI] ${text}`, `  id: ${id} (call note_done("${id}") when dealt with)`,
+        `  board: ${notes.open[id].board}`,
         `  dragged: ${a} (keep it as it is)`, `  onto: ${b} (change this one)`,
         `  so: ui_render(surface="${b}", ..., made_from=${JSON.stringify(madeFrom)}, instruction=<their words>), reading ${a}'s data with {"ref": "${a}", "path": ...}`,
         `  ${a}: ${describe(a)}`, `  ${b}: ${describe(b)}`].join("\n")));
@@ -89,7 +104,7 @@ export default function (pi: ExtensionAPI) {
       + (t.surface ? "(the user drew around this part of the surface: the note is about it)" : "(the user drew around empty space: build inside it)");
     const id = pin(text, to, msg);
     const lines = [`[note on the UI] ${text}`, `  id: ${id} (call note_done("${id}") when dealt with)`,
-      ...([["surface", t.surface], ["component", (t.components ?? []).join(" → ")], ["element", t.element],
+      ...([["board", notes.open[id].board], ["surface", t.surface], ["component", (t.components ?? []).join(" → ")], ["element", t.element],
            ["part", t.part && JSON.stringify(t.part)], ["at", at], ["text", t.text], ["file", t.file?.replace(/^\/app\//, host.app + "/")], ["position", pos],
            ["area", area], ["files", msg.files?.join(", ")]] as [string, any][]).filter(([, v]) => v).map(([k, v]) => `  ${k}: ${v}`)];
     items.set(id, swarm.send("user", to, lines.join("\n")));

package/app/extensions/ui/browser.js

@@ -125,6 +125,7 @@ export default async function (page) {
     }
     drawLabel(s, id);
     s.box.dataset.owner = s.owner;  // who a note on this surface goes to (point.js)
+    s.box.dataset.board = s.board ?? 1;  // its board: boards/browser.js shows it there
     s.box.querySelector(".surface-resize").hidden = s.resizable === false;
     s.box.toggleAttribute("data-pinned", !!s.pinned);
     s.box.toggleAttribute("data-flipped", !!s.flipped);

package/app/extensions/ui/index.ts

@@ -149,6 +149,16 @@ export default function (pi: ExtensionAPI) {
     .replace("README.md", path.join(import.meta.dirname, "README.md"));
   pi.on("before_agent_start", (event) => { event.systemPromptOptions.sections.ui = guide; });
   pi.on("resources_discover", () => ({ skillPaths: [path.join(import.meta.dirname, "skills")] }));
+  // a removed board (boards/) takes its surfaces with it: one step in the history (undo brings them back)
+  pi.on("session_start", () => host.api.boards?.onRemove("ui", (n: number) => {
+    const sids = Object.keys(ui.surfaces).filter((sid) => (ui.surfaces[sid].board ?? 1) === n);
+    const gone = sids.map((sid) => ({ owner: ui.surfaces[sid].owner, what: `surface ${sid}` }));
+    sids.forEach((sid, i) => {
+      ui.copyIntoUsers(sid);  // surfaces elsewhere reading from it keep its values
+      ui.change(sid, null, "user", i === sids.length - 1 ? `you removed board ${n} (${sids.join(", ")})` : undefined);
+    });
+    return gone;
+  }));
 
   pi.registerTool({
     name: "ui_catalog", label: "UI catalog", description: "List the UI components you can use in surfaces, with their props.",
@@ -172,6 +182,8 @@ export default function (pi: ExtensionAPI) {
       about: Type.Optional(Type.String({ description: "what it is for and why it is built this way (its back side)" })),
       options: Type.Optional(Type.Array(Type.Record(Type.String(), Type.Any()), { description: 'alternatives instead of components: [{"label", "components", "data"}]' })),
       made_from: Type.Optional(Type.Array(Type.String())), instruction: Type.Optional(Type.String()),
+      board: Type.Optional(Type.Union([Type.Number(), Type.Literal("new")], { description:
+        'a board number, or "new" for a new board; leave out: where the surface is, else the board the user is on' })),
     }),
     async execute(_id, a) {
       const agent = pi.getSessionName() ?? "agent";
@@ -183,7 +195,9 @@ export default function (pi: ExtensionAPI) {
         const errors = problems(o.components, a.made_from);
         if (errors.length) return result("error: " + (o.label ? `${o.label}: ` : "") + errors.join("; "));
       }
-      const old = ui.surfaces[a.surface] ?? {}, catalog = readCatalog();
+      const old = ui.surfaces[a.surface] ?? {}, catalog = readCatalog(), boards = host.api.boards;
+      if (typeof a.board === "number" && boards && !boards.has(a.board))
+        return result(`error: no board ${a.board}. Boards: ${boards.list().join(", ")} (or board "new")`);
       const first = options[0] ?? { components: a.components, data: a.data ?? {} };
       const record: any = { owner: agent, components: first.components, data: first.data, place: a.place ?? old.place ?? null,
         draggable: a.draggable ?? true, resizable: a.resizable ?? true, about: a.about ?? old.about ?? "",
@@ -191,9 +205,12 @@ export default function (pi: ExtensionAPI) {
           .map((c: any) => [c.component, catalog[c.component].about?.version ?? 1])) };
       for (const [k, v] of [["made_from", a.made_from ?? old.made_from], ["instruction", a.instruction ?? old.instruction],
                             ["options", options.length ? options : null]] as const) if (v) record[k] = v;
+      // its board (boards/): the one asked for, a new one, where it already is, or the one the user is on
+      if (boards) record.board = a.board === "new" ? boards.add() : a.board ?? old.board ?? boards.current();
       ui.change(a.surface, record, agent, `${agent} drew ${a.surface}` + (options.length ? ` (${options.length} options)` : ""));
-      return result(options.length ? `surface '${a.surface}' shows ${options.length} options; the user flips through them and keeps one`
-        : `surface '${a.surface}' is on screen`);
+      const where = boards ? `on board ${record.board}${a.board === "new" ? " (a new board)" : ""}` : "on screen";
+      return result(options.length ? `surface '${a.surface}' shows ${options.length} options ${where}; the user flips through them and keeps one`
+        : `surface '${a.surface}' is ${where}`);
     },
   });
 
@@ -252,6 +269,9 @@ export default function (pi: ExtensionAPI) {
     else if (type === "ui_move") {
       if (r.pinned) return host.broadcast("ui", { op: "render", surface: sid, ...r });
       r.place = msg.place; ui.change(sid, r, "user", `you moved ${sid}`);
+    } else if (type === "ui_board" && host.api.boards?.has(msg.board)) {  // dropped on another board's thumbnail
+      if (r.pinned) return host.broadcast("ui", { op: "render", surface: sid, ...r });
+      r.board = msg.board; r.place = msg.place ?? null; ui.change(sid, r, "user", `you moved ${sid} to board ${msg.board}`);
     } else if (type === "ui_set") { setPath(r.data, msg.path ?? "/", msg.value); ui.change(sid, r, "user", `you changed ${msg.path} in ${sid}`); }
     else if (type === "ui_prop") {
       for (const c of r.components) if (c.id === msg.component && !["id", "component", "children", "child"].includes(msg.prop)) c[msg.prop] = msg.value;

package/app/extensions/versions/index.ts

@@ -28,7 +28,7 @@ const host = (globalThis as any).chalky;
 const GIT_DIR = path.join(host.state, "versions.git");
 const SHOTS = path.join(host.state, "shots");
 const MAX_SHOT = 10 * 1024 * 1024;
-const CODE = ["extensions/", "skills/", "ui/", "SYSTEM.md", "mcp.json"];
+const CODE = ["extensions/", "skills/", "ui/", "SYSTEM.md", "mcp.json", "settings.json"];
 const IGNORE = ["auth.json", "models-store.json", "mcp-auth.json", "node_modules/"];
 const repo = { fs, dir: host.app, gitdir: GIT_DIR };
 const who = (name: string) => ({ name, email: `${name}@chalky` });
@@ -96,7 +96,7 @@ export default function (pi: ExtensionAPI) {
       const stray = changed.filter((p) => !CODE.some((c) => p.startsWith(c)) && fs.existsSync(path.join(host.app, p)));
       if (stray.length && host.agents.has(agent))
         host.api.swarm?.send("system", agent, `Your last turn changed files in ${host.app} that aren't your code: ${stray.slice(0, 5).join(", ")}. `
-          + `${host.app} is your own code (extensions, skills, ui, SYSTEM.md, mcp.json): it is versioned, and a rollback would undo these files. `
+          + `${host.app} is your own code (extensions, skills, ui, SYSTEM.md, mcp.json, settings.json): it is versioned, and a rollback would undo these files. `
           + `Move project work to ${host.work} and use it from there.`, true);
     });
   });

package/app/extensions/voice/browser.js

@@ -0,0 +1,71 @@
+// Browser half of the voice extension: a microphone button left of the send button. Click to dictate, click again
+// to stop; each finished piece of speech is added to the input (to read, fix and send). /ui/voice.js does the
+// listening: the server's speech to text when it has STT_BASE_URL, else the browser's own recognition.
+// While dictating, the icon is a sound wave whose bars follow the microphone's loudness (its own AnalyserNode, so
+// it works in both modes).
+import voice from "/ui/voice.js";
+
+const SVG = '<svg viewBox="0 0 24 24" aria-hidden="true" fill="none" stroke="currentColor" stroke-linecap="round" ' +
+  'stroke-linejoin="round">';
+const MIC = SVG + '<rect x="9" y="3" width="6" height="11" rx="3"/><path d="M5 11a7 7 0 0 0 14 0M12 18v3"/></svg>';
+const WAVE = SVG + [4, 8, 12, 16, 20].map((x) => `<line x1="${x}" x2="${x}" y1="10" y2="14"/>`).join("") + "</svg>";
+const SHAPE = [0.45, 0.8, 1, 0.75, 0.5];  // the middle bars reach higher
+
+export default function (page) {
+  const input = document.getElementById("text");
+  const button = document.createElement("button");
+  button.type = "button";  // in the form: not a send
+  button.className = "mic";
+  button.title = "Dictate";
+  button.innerHTML = MIC;
+  input.after(button);
+  const style = document.createElement("style");
+  style.textContent = "#f button.mic.on { color: #fff; background: #e5484d; border-color: #e5484d; }";
+  document.head.append(style);
+
+  let on = false, stopWave = null;
+
+  // the wave: loudness (RMS of the mic's samples) sets the bars' height, each wobbling a little on its own
+  async function startWave() {
+    const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+    const ctx = new AudioContext();
+    const analyser = ctx.createAnalyser();
+    ctx.createMediaStreamSource(stream).connect(analyser);
+    const samples = new Float32Array(analyser.fftSize);
+    button.innerHTML = WAVE;
+    const bars = button.querySelectorAll("line");
+    let level = 0, frame;
+    const draw = (t) => {
+      analyser.getFloatTimeDomainData(samples);
+      const rms = Math.sqrt(samples.reduce((s, x) => s + x * x, 0) / samples.length);
+      level += (Math.min(1, rms * 8) - level) * 0.3;  // smoothed: rises and falls over a few frames
+      bars.forEach((bar, i) => {
+        const half = 1 + 8 * level * SHAPE[i] * (0.7 + 0.3 * Math.sin(t / 90 + i * 1.7));
+        bar.setAttribute("y1", 12 - half);
+        bar.setAttribute("y2", 12 + half);
+      });
+      frame = requestAnimationFrame(draw);
+    };
+    frame = requestAnimationFrame(draw);
+    return () => { cancelAnimationFrame(frame); stream.getTracks().forEach((tr) => tr.stop()); ctx.close(); button.innerHTML = MIC; };
+  }
+
+  const set = (state) => {
+    on = state;
+    button.classList.toggle("on", on);
+    button.title = on ? "Stop dictating" : "Dictate";
+    if (!on && stopWave) { stopWave(); stopWave = null; }
+  };
+  button.addEventListener("click", async () => {
+    if (on) return voice.stop();
+    set(true);
+    startWave().then((stop) => { if (on) stopWave = stop; else stop(); }).catch(() => {});  // no wave: still dictates
+    await voice.start((text) => {
+      input.value = input.value.trim() ? `${input.value.trimEnd()} ${text}` : text;
+      input.focus();
+    }, { onState: (state, detail) => {
+      if (state === "error") { page.note(`voice: ${detail}`); voice.stop(); set(false); }
+      if (state === "off") set(false);
+    } });
+  });
+}

package/app/extensions/voice/index.ts

@@ -0,0 +1,37 @@
+// Voice input: speech to text (port of the Python voice plugin). The browser half: a microphone button by the send
+// button (browser.js) and /ui/voice.js, which apps can import too.
+// Settings (environment, like MODEL_*): STT_BASE_URL, STT_MODEL, STT_API_KEY. With STT_BASE_URL set, audio goes to
+// POST {STT_BASE_URL}/audio/transcriptions, OpenAI's endpoint, which most providers speak (OpenAI, Groq, Mistral,
+// vLLM; others through LiteLLM). Without it, voice.js uses the browser's own speech recognition.
+// The key stays here: apps are agent-written code, so they post audio to this server, never to the provider.
+//   GET  /voice-api/config      {"api": true | false}: whether audio can go to the API
+//   POST /voice-api/transcribe  multipart: file (a complete audio file, e.g. chunk.webm), language?, prompt?
+//                               -> {"text"} or {"error"} (with the provider's status)
+import { Readable } from "node:stream";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+const host = (globalThis as any).chalky;
+
+export default function (_pi: ExtensionAPI) {
+  const base = (process.env.STT_BASE_URL || "").replace(/\/$/, "");
+  const json = (res: any, status: number, data: object) =>
+    res.writeHead(status, { "content-type": "application/json" }).end(JSON.stringify(data));
+
+  host.routes.set("/voice-api/config", (_req: any, res: any) => json(res, 200, { api: !!base }));
+
+  host.routes.set("/voice-api/transcribe", async (req: any, res: any) => {
+    if (!base) return json(res, 400, { error: "no STT_BASE_URL: use the browser's speech recognition" });
+    try {
+      // the page's form as is, plus the model (Node reads multipart itself: Request.formData)
+      const form = await new Request("http://local", { method: "POST", headers: req.headers,
+        body: Readable.toWeb(req) as any, duplex: "half" } as any).formData();
+      if (!(form.get("file") instanceof Blob)) return json(res, 400, { error: "no audio file" });
+      form.set("model", process.env.STT_MODEL || "whisper-1");
+      const r = await fetch(`${base}/audio/transcriptions`, { method: "POST", body: form,
+        headers: process.env.STT_API_KEY ? { authorization: `Bearer ${process.env.STT_API_KEY}` } : {} });
+      const data: any = await r.json().catch(() => ({}));
+      if (!r.ok) return json(res, 502, { error: `speech to text: ${r.status} ${data.error?.message ?? ""}`.trim() });
+      json(res, 200, { text: data.text ?? "" });
+    } catch (e: any) { json(res, 502, { error: `speech to text: ${e.message}` }); }
+  });
+}

package/app/settings.json

@@ -0,0 +1,3 @@
+{
+  "compaction": { "keepRecentTokens": 20000 }
+}

package/bin/chalky.mjs

@@ -2,7 +2,7 @@
 // chalky: starts Chalky from the installed package. Its home (app/, state/, workspace/) is CHALKY_HOME, else
 // ~/.chalky; the first run copies the package's app/ there. Node won't run TypeScript under node_modules
 // (ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING), so server.ts loads through jiti, as pi loads extensions.
-//   MODEL_BASE_URL=... MODEL_API_KEY=... [MODEL_NAME=...] [MODEL_THINKING=...] chalky
+//   MODEL_BASE_URL=... MODEL_API_KEY=... [MODEL_NAME=...] chalky
 import os from "node:os";
 import path from "node:path";
 import { createJiti } from "jiti";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chalky/chalky",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Chalky on pi: agents build what you see in the browser, and you point at it and mark it up",
   "license": "MIT",
   "type": "module",

package/server.ts

@@ -6,7 +6,8 @@
 //   - hands each agent's pi events to the extensions that asked (host.eventHandlers), and tells them when a page
 //     opens (host.connectHandlers). The page extension turns pi's messages into the page's and replays them.
 // Extensions reach the host through globalThis.chalky (pi loads them with jiti, so they don't share our imports).
-// Run: MODEL_BASE_URL=... MODEL_API_KEY=... [MODEL_NAME=...] [MODEL_THINKING=...] node server.ts   (Node >= 22.19: it runs the TypeScript as is)
+// Run: MODEL_BASE_URL=... MODEL_API_KEY=... [MODEL_NAME=...] node server.ts   (Node >= 22.19: it runs the TypeScript as is)
+//      CHALKY_LOGIN=off: no /login, /logout, /model on the page; agents always use MODEL_BASE_URL (a cloud deployment)
 import fs from "node:fs";
 import { createRequire } from "node:module";
 import http from "node:http";
@@ -119,9 +120,9 @@ const host = {
     if (old) { old.unsubscribe(); old.session.dispose(); }
     const dir = path.join(STATE, "sessions", name);
     fs.mkdirSync(dir, { recursive: true });
-    // projectTrusted false: pi ignores workspace/.pi/ (its SYSTEM.md, extensions, skills, settings), so an agent's
-    // project files can't change it; app/ (versioned) is the only place
-    const settingsManager = SettingsManager.inMemory({}, { projectTrusted: false });
+    // pi's settings: app/settings.json (e.g. compaction). projectTrusted false: pi ignores workspace/.pi/ (its
+    // SYSTEM.md, extensions, skills, settings), so an agent's project files can't change it; app/ (versioned) is the only place
+    const settingsManager = SettingsManager.create(WORK, APP, { projectTrusted: false });
     // agentDir = app/: pi finds app/extensions/<name>/index.ts and app/skills/* itself, again on every reload
     // pi's MCP (the CLI's built-in extensions, which SDK sessions don't load): the servers in app/mcp.json, with
     // codemode and tool_search for servers whose tools aren't direct. Sign-ins: app/mcp-auth.json (not versioned).
@@ -136,17 +137,22 @@ const host = {
       sessionManager: fresh ? SessionManager.create(WORK, dir) : SessionManager.continueRecent(WORK, dir),
     });
     if (session.sessionName !== name) session.setSessionName(name);
+    const empty = session.sessionManager.buildSessionContext().messages.length === 0;
     // starts the extensions' session (session_start). onError, besides showing extensions' errors: pi 1.4.0's reload()
     // sends session_start again only to a session with a binding, and without it pi's MCP doesn't reconnect after a reload
     await session.bindExtensions({ onError: (e) => {
       console.error(`${name}: extension ${e.extensionPath} (${e.event}): ${e.error}`);
       emit("error", { agent: name, text: `extension ${e.extensionPath} (${e.event}): ${e.error}` });
     } });
-    const model = session.modelRuntime.getModel("chalky", process.env.MODEL_NAME || "default");
+    // the model: the one picked with /login or /model (extensions/login), else the MODEL_BASE_URL endpoint (extensions/model).
+    // CHALKY_LOGIN=off (a cloud deployment, the backend's endpoint): always that endpoint, whatever an extension says
+    const picked = process.env.CHALKY_LOGIN === "off" ? undefined : host.api.login?.modelFor(name, session);
+    const model = picked ?? session.modelRuntime.getModel("chalky", process.env.MODEL_NAME || "default");
     if (model) await session.setModel(model);
-    // MODEL_THINKING: pi's thinking level (minimal, low, medium, high, ...), sent as reasoning_effort. Unset: none is
-    // sent and the model uses its own default (pi then says "off", but the model may still think).
-    if (process.env.MODEL_THINKING) session.setThinkingLevel(process.env.MODEL_THINKING);
+    // thinking level: the agent's own (the /thinking command), which pi keeps in its session file; an empty
+    // conversation starts at "medium". Set here: pi restores it only when it knows the model then, and ours (the
+    // model extension) comes later, so pi would say "off"
+    session.setThinkingLevel(empty ? "medium" : session.sessionManager.buildSessionContext().thinkingLevel);
     const a: Agent = { name, role, app, session, unsubscribe: () => {} };
     host.agents.set(name, a);
     a.unsubscribe = session.subscribe((ev: any) => {