ocean-crew 0.0.0-stage → 0.4.0

package/dist/host/im/reaction.js

@@ -0,0 +1,51 @@
+// Status reactions on the message that asked for the work: a processing mark
+// while the Bot runs, then the outcome. The lifecycle follows dsh-im's
+// status-reaction module (MIT; dsh-im is listed in NOTICE): transitions are
+// serialized per message and every provider failure is swallowed, so a
+// reaction never holds up a reply.
+export const STATUS_REACTIONS = Object.freeze({
+    processing: "OnIt",
+    success: "DONE",
+    error: "ERROR",
+});
+export function startStatusReaction({ add, remove, emojis = STATUS_REACTIONS, warn, } = {}) {
+    // A platform without both operations gets no reaction at all: the adapter says so
+    // by leaving one of them out.
+    if (typeof add !== "function" || typeof remove !== "function")
+        return undefined;
+    let current = null;
+    let closed = false;
+    let tail = Promise.resolve();
+    const step = (operation) => {
+        tail = tail.then(operation).catch((error) => {
+            warn?.(error);
+        });
+        return tail;
+    };
+    const transition = (emoji) => step(async () => {
+        if (current !== null) {
+            const previous = current;
+            current = null;
+            await remove(previous);
+        }
+        if (typeof emoji !== "string" || emoji === "")
+            return;
+        const id = await add(emoji);
+        if (typeof id === "string" && id !== "")
+            current = id;
+    });
+    transition(emojis.processing);
+    const finish = (emoji) => {
+        if (!closed) {
+            closed = true;
+            transition(emoji);
+        }
+        return tail;
+    };
+    return Object.freeze({
+        success: () => finish(emojis.success),
+        error: () => finish(emojis.error),
+        clear: () => finish(""),
+        settled: () => tail,
+    });
+}

package/dist/host/im/supervisor.js

@@ -0,0 +1,56 @@
+// One pure decision per connection per health check. The IM host layer owns the
+// runners, queues and timers; this module only says whether to start, stop,
+// restart or leave a connection alone, and when the next attempt is due.
+// The backoff ladder and the three-way failure classification follow dsh-im's
+// connection supervisor (MIT; dsh-im is listed in NOTICE); its controller layer
+// is not needed because im/index.ts already keeps the runner slots and a single
+// serialized sync chain.
+export const RETRY_DELAYS_MS = Object.freeze([250, 1_000, 3_000, 5_000, 10_000, 30_000]);
+// Pause before attempt number `attempts` (1-based); the last delay repeats.
+export function retryDelay(attempts) {
+    const tries = Number.isFinite(attempts) && attempts > 0 ? Math.floor(attempts) : 1;
+    return RETRY_DELAYS_MS[Math.min(tries - 1, RETRY_DELAYS_MS.length - 1)];
+}
+/**
+ * Decide what one health check does with one connection.
+ * - desired: the connection should be connected (enabled, has secrets, writable host)
+ * - running: a runner object currently holds its slot
+ * - state: last reported state, 'off' | 'connecting' | 'ready' | 'error'
+ * - messageError: the error came from one refused message, not from the link
+ * - attempts: attempts since the last success
+ * - nextRetryAt: earliest time for the next attempt, ms epoch (0 = now)
+ */
+export function nextAction(now, entry = {}) {
+    const desired = entry.desired === true;
+    const running = entry.running === true;
+    const state = typeof entry.state === "string" ? entry.state : "off";
+    const attempts = Number.isFinite(entry.attempts) && entry.attempts > 0 ? Math.floor(entry.attempts) : 0;
+    const due = Number.isFinite(entry.nextRetryAt) && entry.nextRetryAt > 0 ? entry.nextRetryAt : 0;
+    if (!desired)
+        return { action: running ? "stop" : "none", attempts: 0, nextRetryAt: 0 };
+    if (state === "ready" && running)
+        return { action: "none", attempts: 0, nextRetryAt: 0 };
+    if (state === "error") {
+        // A refused message is not a broken link: reconnect only after the link
+        // itself failed, otherwise one bad chat would restart the connection forever.
+        if (running && entry.messageError === true)
+            return { action: "none", attempts, nextRetryAt: 0 };
+        if (now < due)
+            return { action: "none", attempts, nextRetryAt: due };
+        const tries = attempts + 1;
+        // Without a runner a failed connect left nothing to restart: a start is the retry.
+        return { action: running ? "restart" : "start", attempts: tries, nextRetryAt: now + retryDelay(tries) };
+    }
+    if (!running)
+        return { action: "start", attempts, nextRetryAt: 0 };
+    return { action: "none", attempts, nextRetryAt: due };
+}
+export function failClass(error) {
+    const failure = error;
+    if (failure?.permanent === true ||
+        (typeof failure?.status === "number" && failure.status >= 400 && failure.status < 500 && failure.status !== 429))
+        return "permanent";
+    if (failure?.unknown === true || failure?.stopped === true)
+        return "unknown";
+    return "retry";
+}

package/dist/host/team/agents.js

@@ -0,0 +1,161 @@
+// The DSH Agent: a team's one plain dsh entry, listed beside the Bots but not one of
+// them. Its Sessions are ordinary root Sessions in the Ocean Crew workspace, so they get
+// the whole dsh conversation surface and none of the team tools.
+import { randomUUID } from "node:crypto";
+import { AGENT_NAME, AGENT_SESSION_TITLE_MAX } from "../core/constants.js";
+export function install(rt) {
+    const { ctx } = rt;
+    const state = rt.state;
+    const table = state;
+    const agents = () => {
+        table.agents ??= {};
+        return table.agents;
+    };
+    const registry = () => {
+        const service = ctx.workspaceRegistry;
+        if (service === undefined)
+            throw new Error("This DSH has no workspace registry, so it has no DSH Agent");
+        return service;
+    };
+    const controller = () => ctx.sessionController;
+    const titles = () => ctx.sessionTitle;
+    /** Session id -> DSH Agent record id. */
+    const sessionIndex = new Map();
+    // store.js calls this from indexSessions after every adopt and save.
+    rt.indexAgents = () => {
+        sessionIndex.clear();
+        for (const agent of Object.values(agents())) {
+            for (const sessionId of agent.sessions ?? [])
+                sessionIndex.set(sessionId, agent.id);
+        }
+    };
+    // The DSH Agent a Session belongs to; Bot and group Sessions get undefined.
+    const agentOf = (sessionId) => agents()[sessionIndex.get(sessionId) ?? ""];
+    const writeCheck = () => {
+        const readOnly = rt.readOnly();
+        if (readOnly !== undefined)
+            throw new Error(readOnly);
+    };
+    const record = (agentId) => {
+        const agent = rt.own(agents(), agentId);
+        if (agent === undefined)
+            throw new Error("Unknown DSH Agent");
+        return agent;
+    };
+    const sessionsOf = (agent) => {
+        if (agent.sessions === undefined)
+            agent.sessions = [];
+        return agent.sessions;
+    };
+    async function createAgentSession(agentId, workspaceId) {
+        writeCheck();
+        const agent = record(agentId);
+        // A known workspace id wins (the Agent's latest Session may live outside the
+        // team workspace after a workspace switch); anything else gets the team's own.
+        const target = typeof workspaceId === "string" && registry().get?.(workspaceId)
+            ? workspaceId
+            : await rt.ensureWorkspace();
+        const { sessionId } = await controller().create({ workspaceId: target });
+        sessionsOf(agent).push(sessionId);
+        await rt.save();
+        return sessionId;
+    }
+    // A root Session the user opened from a DSH Agent page (the hero's workspace picker
+    // or a fork) is adopted into the same Agent: it keeps dsh's surface and the team
+    // tools stay hidden.
+    async function adoptAgentSession(agentId, sessionId) {
+        writeCheck();
+        const agent = record(agentId);
+        if (sessionsOf(agent).includes(sessionId))
+            return sessionId;
+        await rt.resolveAgent(sessionId);
+        const owned = rt.selfOf(sessionId) !== undefined ||
+            rt.botOf(sessionId) !== undefined ||
+            rt.roomOf(sessionId) !== undefined ||
+            agentOf(sessionId) !== undefined;
+        if (owned)
+            throw new Error("Session already belongs to the team");
+        sessionsOf(agent).push(sessionId);
+        await rt.save();
+        return sessionId;
+    }
+    async function addAgent() {
+        writeCheck();
+        if (Object.keys(agents()).length > 0)
+            throw new Error("The team already has a DSH Agent");
+        const agent = { id: randomUUID(), name: AGENT_NAME, sessions: [], createdAt: Date.now() };
+        agents()[agent.id] = agent;
+        try {
+            await createAgentSession(agent.id);
+        }
+        catch (error) {
+            // The first Session may already be created and saved: archive it and persist
+            // the rollback, or the Agent returns on restart with its team tools never denied.
+            const createdSessions = [...sessionsOf(agent)];
+            delete agents()[agent.id];
+            for (const sessionId of createdSessions)
+                await registry()
+                    .archiveSession(sessionId)
+                    .catch(() => { });
+            await rt.save().catch(() => { });
+            throw error;
+        }
+        return agent;
+    }
+    async function archiveAgentSession(agentId, sessionId) {
+        writeCheck();
+        const agent = record(agentId);
+        if (!sessionsOf(agent).includes(sessionId))
+            throw new Error("Session does not belong to the DSH Agent");
+        // Archive first: the Session leaves the Agent only once it is actually gone,
+        // so a failed archive stays retryable and keeps its tool restriction.
+        await registry().archiveSession(sessionId);
+        agent.sessions = sessionsOf(agent).filter((id) => id !== sessionId);
+        await rt.save();
+    }
+    async function renameAgentSession(agentId, sessionId, title) {
+        writeCheck();
+        const agent = record(agentId);
+        if (!sessionsOf(agent).includes(sessionId))
+            throw new Error("Session does not belong to the DSH Agent");
+        const clean = String(title ?? "").trim();
+        if (clean === "")
+            throw new Error("A session needs a title");
+        const resolved = (await rt.resolveAgent(sessionId));
+        await titles().rename(resolved.session, clean.slice(0, AGENT_SESSION_TITLE_MAX));
+    }
+    async function removeAgent(agentId) {
+        writeCheck();
+        const agent = record(agentId);
+        const sessions = [...sessionsOf(agent)];
+        const kept = [];
+        let failure;
+        for (const sessionId of sessions) {
+            try {
+                await registry().archiveSession(sessionId);
+            }
+            catch (error) {
+                failure ??= error;
+                kept.push(sessionId);
+            }
+        }
+        // What could not be archived stays with the Agent, so it keeps its tool
+        // restriction and the removal can be retried from the same place.
+        if (kept.length > 0) {
+            agent.sessions = kept;
+            await rt.save();
+            throw failure;
+        }
+        delete agents()[agentId];
+        await rt.save();
+    }
+    Object.assign(rt, {
+        agentOf,
+        addAgent,
+        createAgentSession,
+        adoptAgentSession,
+        archiveAgentSession,
+        renameAgentSession,
+        removeAgent,
+    });
+}