@chibitek/chibi 0.1.161 → 0.1.162

package/dist-server/server/routine-mochii-sync.js

@@ -0,0 +1,252 @@
+// Mirrors each routine into one private Mochii task: its schedule and next
+// run on the task, and every finished run as a comment. Off unless the
+// install sets features.routineMochiiSync, and it needs the configured
+// `mochii` MCP server, which acts as the signed-in person, so each person's
+// routines land in their own Mochii as their own private tasks.
+//
+// Fail closed: a new task is first created with a content-free title. Only
+// when Mochii answers that it is private and keyed to this routine (the
+// create contract: is_private, idempotency_key, replayed) does routine
+// content follow. An older Mochii that ignores the contract gets its stray
+// task deleted, and sync pauses for a few hours before checking again.
+//
+// No outbox: the routines and their run receipts are already on disk, so each
+// pass compares them with what Mochii has confirmed (routine-mochii-sync.json)
+// and sends the difference. A failed pass is simply retried on the next one.
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { writeFileAtomic } from "./atomic.js";
+import { customMcpServers } from "./config.js";
+import { nexusClientFor, NexusUnavailableError } from "./nexus-memory/client.js";
+import { scheduleText } from "./routine-requests.js";
+const PASS_EVERY_MS = 5 * 60_000;
+const POKE_DELAY_MS = 3_000;
+const BLOCK_MS = 6 * 60 * 60_000;
+/** Runs already finished when a routine is first mirrored: only the latest few become comments. */
+const BACKFILL_RUNS = 5;
+const MAX_COMMENT_CHARS = 4_000;
+const FINISHED = new Set(["completed", "failed", "cancelled", "missed"]);
+const PROBE_TITLE = "Atomic routine";
+export function routineMochiiSyncEnabled(cfg) {
+    return cfg.features?.routineMochiiSync === true && Boolean(customMcpServers(cfg).mochii);
+}
+export const idempotencyKey = (routineId) => `atomic-routine:${routineId}`;
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+export function taskTitle(routine) {
+    return `Routine: ${routine.name}${routine.enabled ? "" : " (paused)"}`;
+}
+export function taskDescription(routine, bot, timeZone) {
+    const next = routine.enabled && routine.nextRunAt != null ? new Date(routine.nextRunAt).toISOString() : "none";
+    return [
+        "Managed by Atomic. Edits made here are replaced on the next sync.",
+        "",
+        `Bot: ${bot ?? routine.botId}`,
+        `Schedule: ${scheduleText(routine.schedule, timeZone)}`,
+        `Status: ${routine.enabled ? "active" : "paused"}`,
+        `Next run: ${next}`,
+        "",
+        "Prompt:",
+        routine.prompt,
+    ].join("\n");
+}
+export function runComment(run) {
+    const when = new Date(run.finishedAt ?? run.scheduledFor).toISOString();
+    const body = (run.status === "failed" ? run.error ?? run.output : run.output ?? run.error)?.trim();
+    const clipped = body && body.length > MAX_COMMENT_CHARS ? `${body.slice(0, MAX_COMMENT_CHARS)}\n\n(cut short; the full report is in Atomic)` : body;
+    return `Run ${run.status} · ${when}${run.manual ? " · started by hand" : ""}${clipped ? `\n\n${clipped}` : ""}`;
+}
+export class RoutineMochiiSync {
+    path;
+    now;
+    state;
+    client = null;
+    clientKey = "";
+    running = null;
+    poked;
+    timer;
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+        this.path = join(deps.dataDir, "routine-mochii-sync.json");
+        this.now = deps.now ?? Date.now;
+        this.state = this.load();
+    }
+    static start(deps) {
+        const sync = new RoutineMochiiSync(deps);
+        sync.start();
+        return sync;
+    }
+    start() {
+        this.timer ??= setInterval(() => void this.pass(), PASS_EVERY_MS);
+        this.timer.unref?.();
+        this.poke();
+    }
+    stop() {
+        clearInterval(this.timer);
+        clearTimeout(this.poked);
+        this.timer = undefined;
+        void this.client?.close();
+        this.client = null;
+    }
+    /** A run changed: sync soon rather than waiting for the next pass. */
+    poke() {
+        if (this.poked || !routineMochiiSyncEnabled(this.deps.config()))
+            return;
+        this.poked = setTimeout(() => {
+            this.poked = undefined;
+            void this.pass();
+        }, POKE_DELAY_MS);
+        this.poked.unref?.();
+    }
+    status() {
+        return {
+            enabled: routineMochiiSyncEnabled(this.deps.config()),
+            mirrored: Object.keys(this.state.tasks).length,
+            blockedUntil: this.state.blockedUntil ?? null,
+            blockedReason: this.state.blockedReason ?? null,
+        };
+    }
+    /** One reconcile pass; concurrent callers share it. */
+    pass() {
+        this.running ??= this.reconcile()
+            .catch((error) => this.log(`pass stopped: ${error instanceof Error ? error.message : String(error)}`))
+            .finally(() => { this.running = null; });
+        return this.running;
+    }
+    async reconcile() {
+        const cfg = this.deps.config();
+        if (!routineMochiiSyncEnabled(cfg))
+            return;
+        if (this.state.blockedUntil && this.now() < this.state.blockedUntil)
+            return;
+        const client = this.clientFor(cfg);
+        if (!client)
+            return;
+        const routines = this.deps.listRoutines();
+        const runs = this.deps.listRuns();
+        for (const routine of routines) {
+            const mine = runs.filter((run) => run.routineId === routine.id && FINISHED.has(run.status));
+            try {
+                if (!(await this.mirror(client, routine, mine)))
+                    return;
+            }
+            catch (error) {
+                if (error instanceof NexusUnavailableError)
+                    throw error;
+                this.log(`routine ${routine.id}: ${error instanceof Error ? error.message : String(error)}`);
+                // The task is gone from Mochii: forget it so the next pass creates it again.
+                if (/not found|404/i.test(String(error)))
+                    this.forget(routine.id);
+            }
+        }
+        const live = new Set(routines.map((routine) => routine.id));
+        for (const [routineId, mirrored] of Object.entries(this.state.tasks)) {
+            if (live.has(routineId))
+                continue;
+            try {
+                await client.call("update_task", { id: mirrored.taskId, status: "cancelled" });
+                await client.call("add_comment", { task_id: mirrored.taskId, content: "This routine was deleted in Atomic." });
+            }
+            catch (error) {
+                if (error instanceof NexusUnavailableError)
+                    throw error;
+            }
+            this.forget(routineId);
+        }
+    }
+    /** False when Mochii failed the privacy check: stop the whole pass. */
+    async mirror(client, routine, finished) {
+        let mirrored = this.state.tasks[routine.id];
+        if (!mirrored) {
+            const taskId = await this.createPrivate(client, routine.id);
+            if (!taskId)
+                return false;
+            const byAge = [...finished].sort((a, b) => (a.finishedAt ?? a.scheduledFor) - (b.finishedAt ?? b.scheduledFor));
+            mirrored = { taskId, fingerprint: "", runs: byAge.slice(0, -BACKFILL_RUNS).map((run) => run.id) };
+            this.state.tasks[routine.id] = mirrored;
+            this.save();
+        }
+        const title = taskTitle(routine);
+        const description = taskDescription(routine, this.deps.botName(routine.botId), this.deps.timeZone());
+        const due = routine.enabled && routine.nextRunAt != null ? new Date(routine.nextRunAt).toISOString() : undefined;
+        const fingerprint = JSON.stringify([title, description, due]);
+        if (fingerprint !== mirrored.fingerprint) {
+            await client.call("update_task", { id: mirrored.taskId, title, description, status: "pending", ...(due ? { due_date: due } : {}) });
+            mirrored.fingerprint = fingerprint;
+            this.save();
+        }
+        const posted = new Set(mirrored.runs);
+        const fresh = finished
+            .filter((run) => !posted.has(run.id))
+            .sort((a, b) => (a.finishedAt ?? a.scheduledFor) - (b.finishedAt ?? b.scheduledFor));
+        for (const run of fresh) {
+            await client.call("add_comment", { task_id: mirrored.taskId, content: runComment(run) });
+            mirrored.runs.push(run.id);
+            this.save();
+        }
+        const kept = new Set(finished.map((run) => run.id));
+        if (mirrored.runs.some((id) => !kept.has(id))) {
+            mirrored.runs = mirrored.runs.filter((id) => kept.has(id));
+            this.save();
+        }
+        return true;
+    }
+    /** Creates (or, after a crash, gets back) the routine's task with a content-free title. */
+    async createPrivate(client, routineId) {
+        const key = idempotencyKey(routineId);
+        const body = await client.call("create_task", { title: PROBE_TITLE, is_private: true, idempotency_key: key });
+        const task = record(body.data);
+        const taskId = typeof task?.id === "string" ? task.id : null;
+        if (taskId && task?.is_private === true && task.idempotency_key === key && typeof body.replayed === "boolean")
+            return taskId;
+        if (taskId && task?.is_private !== true) {
+            await client.call("delete_task", { id: taskId }).catch((error) => this.log(`could not remove a non-private task ${taskId}: ${String(error)}`));
+        }
+        this.state.blockedUntil = this.now() + BLOCK_MS;
+        this.state.blockedReason = "Mochii does not support private routine tasks yet";
+        this.save();
+        this.log(`${this.state.blockedReason}; nothing was sent, checking again later`);
+        return null;
+    }
+    forget(routineId) {
+        delete this.state.tasks[routineId];
+        this.save();
+    }
+    clientFor(cfg) {
+        if (this.deps.clientFor)
+            return (this.client ??= this.deps.clientFor(cfg));
+        const spec = customMcpServers(cfg).mochii;
+        const key = JSON.stringify(spec ?? null);
+        if (key !== this.clientKey) {
+            void this.client?.close();
+            this.client = nexusClientFor(spec);
+            this.clientKey = key;
+        }
+        return this.client;
+    }
+    load() {
+        try {
+            if (existsSync(this.path)) {
+                const parsed = record(JSON.parse(readFileSync(this.path, "utf8")));
+                if (parsed && record(parsed.tasks))
+                    return parsed;
+            }
+        }
+        catch (error) {
+            this.log(`ignoring unreadable ${this.path}: ${String(error)}`);
+        }
+        return { tasks: {} };
+    }
+    save() {
+        if (this.state.blockedUntil && this.now() >= this.state.blockedUntil) {
+            delete this.state.blockedUntil;
+            delete this.state.blockedReason;
+        }
+        writeFileAtomic(this.path, JSON.stringify(this.state, null, 2));
+    }
+    log(message) {
+        (this.deps.log ?? ((line) => console.warn(`[routine-mochii-sync] ${line}`)))(message);
+    }
+}

package/dist-server/shared/connector-availability.js

@@ -0,0 +1,12 @@
+const MANAGED_CUSTOM_AUTH_TOOLKITS = new Set(["twitter", "x"]);
+/**
+ * Some Composio toolkits no longer include provider-managed credentials.
+ * The official OpenMausBot broker cannot offer those connections until its
+ * project owns the corresponding OAuth app. Self-hosted Composio projects can
+ * still supply their own auth config, so keep this restriction mode-specific.
+ */
+export function managedConnectorUnavailableReason(mode, slug) {
+    if (mode !== "managed" || !MANAGED_CUSTOM_AUTH_TOOLKITS.has(slug.trim().toLowerCase()))
+        return null;
+    return "Twitter/X needs your own X Developer app and Composio auth config. Use self-hosted connected apps for now.";
+}

package/dist-server/vps-container-mcp.js

@@ -16870,18 +16870,19 @@ var featureConfigSchema = external_exports.object({
    * marketplace checks) and personal skills (~/.agents/skills,
    * $CODEX_HOME/skills). */
   codexUserMcp: external_exports.boolean().optional(),
-  /** LLM-generated titles for new bot threads. Off until explicitly
-   * enabled; a one-shot that fails or answers junk leaves the first-message
-   * snippet in place — see llmThreadTitlesEnabled. */
+  /** LLM-generated titles for new bot threads. Off until explicitly enabled; a one-shot
+   * that fails or answers junk leaves the first-message snippet in place — see llmThreadTitlesEnabled. */
   llmThreadTitles: external_exports.boolean().optional(),
-  /** Small internal jobs (thread titles) run on Apple Intelligence on this
-   * Mac when it is available. On unless set to false. */
-  onDeviceHelpers: external_exports.boolean().optional()
+  /** Small internal jobs (thread titles) run on Apple Intelligence on this Mac when available. On unless false. */
+  onDeviceHelpers: external_exports.boolean().optional(),
+  /** Mirror routines into private Mochii tasks (server/routine-mochii-sync.ts). Off unless true; no Settings toggle. */
+  routineMochiiSync: external_exports.boolean().optional()
 });
 var addonsConfigSchema = external_exports.object(
   Object.fromEntries(ADDONS.map((addon) => [addon.id, external_exports.boolean().optional()]))
 ).strict();
 var setupProgressSchema = external_exports.object({
+  foundationRoles: external_exports.array(external_exports.enum(["assistant", "inbox", "research", "coder", "community", "ops"])).max(3).optional(),
   picks: external_exports.array(external_exports.string().trim().min(1).max(40)).max(20).optional(),
   chibitek: external_exports.boolean().optional(),
   steps: external_exports.record(external_exports.string().trim().min(1).max(60), external_exports.enum(["done", "skipped"])).refine((steps) => Object.keys(steps).length <= 60, "too many setup steps").optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chibitek/chibi",
-  "version": "0.1.161",
+  "version": "0.1.162",
   "description": "Atomic by Chibitek: run your AI team's server anywhere and pair your devices to it",
   "license": "Apache-2.0",
   "type": "module",

package/dist/assets/channel-Nx85fHZ4.js

@@ -1 +0,0 @@
-import{U as a,C as n}from"./mermaid.core-aqB1jW_w.js";const t=(r,o)=>a.lang.round(n.parse(r)[o]);export{t as c};

package/dist/assets/swimlanesDiagram-TC7HE7FX-BO2gR34z.js

@@ -1,8 +0,0 @@
-import{c as r,s as e}from"./flowDiagram-KWPJA3E3-D1UiqwbF.js";import{_ as a}from"./mermaid.core-aqB1jW_w.js";import"./chunk-5VM5RSS4-BL8QOZeP.js";import"./chunk-XXDRQBXY-Ck63jUMo.js";import"./chunk-WEXAMYUT-BzCC1jc4.js";import"./chunk-GWA4HPMP-Dd7yNJ0G.js";import"./channel-Nx85fHZ4.js";import"./index-XFwW09vd.js";var o=a(t=>`${e(t)}
-  .swimlane.cluster:not([data-color-id]) rect {
-    stroke: ${t.clusterBorder} !important;
-  }
-  [data-look="neo"].cluster rect {
-    filter: none;
-  }
-`,"getStyles"),s=o,u=r({styles:s});export{u as diagram};