@vascend/talos 0.1.0

package/dist/cowork/ipc.js

@@ -0,0 +1,96 @@
+// Bridge IPC di Cowork: contratto host-agnostico tra il processo main (dove
+// vive il CoworkManager e l'engine) e il renderer della UI desktop.
+//
+// Non assume Electron/Tauri/WebView specifici: definisce un canale astratto
+// request/response + uno stream di eventi push. La shell desktop
+// (desktop-app-shell) lo collega al suo trasporto reale (ipcMain/ipcRenderer,
+// __TAURI__.invoke, postMessage, ecc.) con poche righe di adattatore.
+//
+// Pattern: il renderer chiama `request(method, params)`; il main esegue il
+// metodo sul CoworkManager e risponde. Per gli stream (eventi agente, sync,
+// presence) il main invia `push(channel, payload)` che il renderer ascolta.
+import { CoworkManager } from "./manager.js";
+// Canale di un evento agente per una sessione.
+export function agentChannel(workspaceId, sessionId) {
+    return `agent:${workspaceId}/${sessionId}`;
+}
+// Canale degli eventi sync di un workspace.
+export function syncChannel(workspaceId) {
+    return `sync:${workspaceId}`;
+}
+// Crea l'handler IPC lato main: una funzione `handle(method, params)` che la
+// shell collega al suo canale request/response, più `push` per gli stream.
+export function createCoworkIpc(manager, push) {
+    // Run attivi: runId -> abort.
+    const runs = new Map();
+    // Sottoscrizioni sync aperte: workspaceId -> unsubscribe.
+    const subscriptions = new Map();
+    let runCounter = 0;
+    const handlers = {
+        "workspace.list": (p) => manager.listWorkspaces(p.includeArchived),
+        "workspace.get": (p) => manager.getWorkspace(p.id),
+        "workspace.create": (p) => manager.createWorkspace(p),
+        "workspace.update": (p) => manager.updateWorkspace(p.id, p.patch),
+        "workspace.join": (p) => manager.joinWorkspace(p.id, p.role),
+        "workspace.leave": (p) => manager.leaveWorkspace(p.id, p.memberId),
+        "session.list": (p) => manager.listSessions(p.workspaceId, p.includeArchived),
+        "session.get": (p) => manager.getSession(p.workspaceId, p.sessionId),
+        "session.create": (p) => manager.createSession(p.workspaceId, { title: p.title, model: p.model }),
+        "session.update": (p) => manager.updateSession(p.workspaceId, p.sessionId, p.patch),
+        "session.messages": (p) => manager.listMessages(p.workspaceId, p.sessionId),
+        "session.prompt": (p) => {
+            runCounter += 1;
+            const runId = `run-${Date.now().toString(36)}-${runCounter}`;
+            const ch = agentChannel(p.workspaceId, p.sessionId);
+            const { done, abort } = manager.promptSession(p.workspaceId, p.sessionId, p.text, (event) => {
+                push(ch, { runId, event });
+            });
+            runs.set(runId, abort);
+            void done.finally(() => runs.delete(runId));
+            return { runId };
+        },
+        "session.abort": (p) => {
+            const abort = runs.get(p.runId);
+            if (abort)
+                abort();
+            return { ok: Boolean(abort) };
+        },
+        "presence.announce": (p) => manager.announcePresence(p.workspaceId, p.activeSessionId, p.status),
+        "presence.list": (p) => manager.listPresence(p.workspaceId),
+        "sync.open": (p) => {
+            if (!subscriptions.has(p.workspaceId)) {
+                const ch = syncChannel(p.workspaceId);
+                const unsub = manager.subscribe(p.workspaceId, (event) => push(ch, event));
+                subscriptions.set(p.workspaceId, unsub);
+            }
+            return { ok: true };
+        },
+        "sync.close": (p) => {
+            const unsub = subscriptions.get(p.workspaceId);
+            if (unsub) {
+                unsub();
+                subscriptions.delete(p.workspaceId);
+            }
+            return { ok: Boolean(unsub) };
+        },
+    };
+    return {
+        // Esegue un metodo IPC. La shell la chiama dal suo handler request/response.
+        async handle(method, params) {
+            const fn = handlers[method];
+            if (typeof fn !== "function") {
+                throw new Error(`metodo IPC Cowork sconosciuto: ${String(method)}`);
+            }
+            return fn(params);
+        },
+        // Rilascia risorse (sottoscrizioni sync, run attivi) alla chiusura.
+        dispose() {
+            for (const abort of runs.values())
+                abort();
+            runs.clear();
+            for (const unsub of subscriptions.values())
+                unsub();
+            subscriptions.clear();
+        },
+    };
+}

package/dist/cowork/manager.d.ts

@@ -0,0 +1,66 @@
+import type { AgentEvent } from "../core/types.js";
+import { type ConfirmFn } from "./engine-bridge.js";
+import { type CoworkMember, type CoworkMessage, type CoworkPresence, type CoworkRole, type CoworkSession, type CoworkSyncEvent, type CoworkWorkspace, type CoworkWorkspacePatch } from "./types.js";
+export interface CoworkIdentity {
+    readonly memberId: string;
+    readonly displayName: string;
+    readonly userId?: string;
+    readonly clientId: string;
+}
+export declare function localIdentity(overrides?: Partial<CoworkIdentity>): CoworkIdentity;
+export interface ManagerOptions {
+    readonly baseDir?: string;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly confirm?: ConfirmFn;
+    readonly defaultModel?: string;
+}
+export declare class CoworkManager {
+    readonly identity: CoworkIdentity;
+    private readonly store;
+    private readonly env;
+    private readonly confirm;
+    private readonly defaultModel;
+    private readonly channels;
+    private readonly engines;
+    private readonly presence;
+    constructor(identity: CoworkIdentity, opts?: ManagerOptions);
+    listWorkspaces(includeArchived?: boolean): CoworkWorkspace[];
+    getWorkspace(id: string): CoworkWorkspace | null;
+    createWorkspace(input: {
+        name: string;
+        root: string;
+        model?: string;
+    }): CoworkWorkspace;
+    updateWorkspace(id: string, patch: CoworkWorkspacePatch): CoworkWorkspace;
+    joinWorkspace(id: string, role?: CoworkRole, member?: Partial<CoworkMember>): CoworkWorkspace;
+    leaveWorkspace(id: string, memberId?: string): CoworkWorkspace;
+    listSessions(workspaceId: string, includeArchived?: boolean): CoworkSession[];
+    getSession(workspaceId: string, sessionId: string): CoworkSession | null;
+    createSession(workspaceId: string, input?: {
+        title?: string;
+        model?: string;
+    }): CoworkSession;
+    updateSession(workspaceId: string, sessionId: string, patch: {
+        title?: string;
+        model?: string;
+        archived?: boolean;
+    }): CoworkSession;
+    listMessages(workspaceId: string, sessionId: string): CoworkMessage[];
+    promptSession(workspaceId: string, sessionId: string, text: string, onEvent?: (event: AgentEvent) => void): {
+        done: Promise<void>;
+        abort: () => void;
+    };
+    private engineFor;
+    private touchContributor;
+    announcePresence(workspaceId: string, activeSessionId: string | null, status?: CoworkPresence["status"]): CoworkPresence;
+    listPresence(workspaceId: string): CoworkPresence[];
+    private recordPresence;
+    private channel;
+    subscribe(workspaceId: string, listener: (event: CoworkSyncEvent) => void): () => void;
+    private onRemoteEvent;
+    private publishMessage;
+    private publishAgentEvent;
+    private assertRole;
+    abortAll(): void;
+    dispose(): void;
+}

package/dist/cowork/manager.js

@@ -0,0 +1,325 @@
+// CoworkManager: orchestratore del modulo Cowork desktop.
+//
+// Unisce i tre strati:
+//   - CoworkStore   -> persistenza (workspace, sessioni, messaggi);
+//   - CoworkSyncChannel -> propagazione locale tra finestre;
+//   - CoworkEngine  -> esecuzione dei prompt sul motore Vascend Talos.
+//
+// È il punto unico che il layer desktop (IPC/preload) espone al renderer.
+// API immutabile: ritorna sempre nuovi oggetti, non muta gli input.
+import { randomUUID } from "node:crypto";
+import { hostname, userInfo } from "node:os";
+import { CoworkStore } from "./store.js";
+import { CoworkSyncChannel } from "./sync.js";
+import { CoworkEngine } from "./engine-bridge.js";
+import { CoworkError, } from "./types.js";
+// Costruisce un'identità locale di default dall'utente di sistema.
+export function localIdentity(overrides = {}) {
+    let name = "utente";
+    try {
+        name = userInfo().username || name;
+    }
+    catch {
+        /* ambienti senza userInfo */
+    }
+    const memberId = overrides.memberId ?? `m-${name}@${safeHost()}`;
+    return {
+        memberId,
+        displayName: overrides.displayName ?? name,
+        userId: overrides.userId,
+        clientId: overrides.clientId ?? `c-${process.pid}-${randomUUID().slice(0, 8)}`,
+    };
+}
+function safeHost() {
+    try {
+        return hostname();
+    }
+    catch {
+        return "local";
+    }
+}
+export class CoworkManager {
+    identity;
+    store;
+    env;
+    confirm;
+    defaultModel;
+    // Un canale di sync per workspace aperto.
+    channels = new Map();
+    // Un engine per sessione attiva: "<workspaceId>/<sessionId>".
+    engines = new Map();
+    // Presenza live per workspace: memberId+clientId -> presence.
+    presence = new Map();
+    constructor(identity, opts = {}) {
+        this.identity = identity;
+        this.env = opts.env ?? process.env;
+        this.store = new CoworkStore(opts.baseDir, this.env);
+        this.confirm = opts.confirm ?? (async () => false);
+        this.defaultModel = opts.defaultModel ?? this.env["TALOS_MODEL"] ?? "anthropic/claude-sonnet-4-6";
+    }
+    // ---- Workspace -----------------------------------------------------------
+    listWorkspaces(includeArchived = false) {
+        return this.store.listWorkspaces(includeArchived);
+    }
+    getWorkspace(id) {
+        return this.store.getWorkspace(id);
+    }
+    createWorkspace(input) {
+        const now = Date.now();
+        const owner = {
+            id: this.identity.memberId,
+            displayName: this.identity.displayName,
+            userId: this.identity.userId,
+            role: "owner",
+            joinedAt: now,
+        };
+        const ws = {
+            id: `ws-${now.toString(36)}-${randomUUID().slice(0, 6)}`,
+            name: input.name,
+            root: input.root,
+            model: input.model ?? this.defaultModel,
+            members: [owner],
+            createdBy: this.identity.memberId,
+            createdAt: now,
+            updatedAt: now,
+            archived: false,
+        };
+        this.store.putWorkspace(ws);
+        this.channel(ws.id).publish("workspace_created", ws);
+        return ws;
+    }
+    updateWorkspace(id, patch) {
+        const cur = this.store.requireWorkspace(id);
+        this.assertRole(cur, ["owner", "editor"]);
+        const next = {
+            ...cur,
+            name: patch.name ?? cur.name,
+            model: patch.model ?? cur.model,
+            archived: patch.archived ?? cur.archived,
+            updatedAt: Date.now(),
+        };
+        this.store.putWorkspace(next);
+        this.channel(id).publish(patch.archived ? "workspace_archived" : "workspace_updated", next);
+        return next;
+    }
+    // Aggiunge un membro (join). Idempotente per memberId.
+    joinWorkspace(id, role = "editor", member) {
+        const cur = this.store.requireWorkspace(id);
+        const m = {
+            id: member?.id ?? this.identity.memberId,
+            displayName: member?.displayName ?? this.identity.displayName,
+            userId: member?.userId ?? this.identity.userId,
+            role: member?.role ?? role,
+            joinedAt: Date.now(),
+        };
+        const exists = cur.members.some((x) => x.id === m.id);
+        const members = exists ? cur.members.map((x) => (x.id === m.id ? m : x)) : [...cur.members, m];
+        const next = { ...cur, members, updatedAt: Date.now() };
+        this.store.putWorkspace(next);
+        this.channel(id).publish("member_joined", next);
+        return next;
+    }
+    leaveWorkspace(id, memberId = this.identity.memberId) {
+        const cur = this.store.requireWorkspace(id);
+        const next = {
+            ...cur,
+            members: cur.members.filter((m) => m.id !== memberId),
+            updatedAt: Date.now(),
+        };
+        this.store.putWorkspace(next);
+        this.channel(id).publish("member_left", next);
+        return next;
+    }
+    // ---- Sessioni ------------------------------------------------------------
+    listSessions(workspaceId, includeArchived = false) {
+        return this.store.listSessions(workspaceId, includeArchived);
+    }
+    getSession(workspaceId, sessionId) {
+        return this.store.getSession(workspaceId, sessionId);
+    }
+    createSession(workspaceId, input = {}) {
+        const ws = this.store.requireWorkspace(workspaceId);
+        this.assertRole(ws, ["owner", "editor"]);
+        const now = Date.now();
+        const session = {
+            id: `s-${now.toString(36)}`,
+            workspaceId,
+            title: input.title ?? "Nuova sessione",
+            model: input.model ?? ws.model,
+            createdBy: this.identity.memberId,
+            createdAt: now,
+            updatedAt: now,
+            contributors: [this.identity.memberId],
+            archived: false,
+        };
+        this.store.putSession(session);
+        this.channel(workspaceId).publish("session_created", session);
+        return session;
+    }
+    updateSession(workspaceId, sessionId, patch) {
+        const cur = this.store.requireSession(workspaceId, sessionId);
+        const next = {
+            ...cur,
+            title: patch.title ?? cur.title,
+            model: patch.model ?? cur.model,
+            archived: patch.archived ?? cur.archived,
+            updatedAt: Date.now(),
+        };
+        this.store.putSession(next);
+        this.channel(workspaceId).publish(patch.archived ? "session_archived" : "session_updated", next);
+        return next;
+    }
+    listMessages(workspaceId, sessionId) {
+        return this.store.listMessages(workspaceId, sessionId);
+    }
+    // ---- Esecuzione prompt (engine + persistenza + sync) ---------------------
+    // Invia un prompt a una sessione: registra il messaggio utente, esegue il
+    // turno engine e per ogni AgentEvent persiste/propaga. `onEvent` riceve gli
+    // eventi locali in tempo reale (per la UI della finestra che ha promptato).
+    promptSession(workspaceId, sessionId, text, onEvent) {
+        const ws = this.store.requireWorkspace(workspaceId);
+        this.assertRole(ws, ["owner", "editor"]);
+        const session = this.store.requireSession(workspaceId, sessionId);
+        // Messaggio utente: persistito + propagato subito (così le altre finestre
+        // lo vedono prima ancora della risposta).
+        const userMsg = {
+            role: "user",
+            text,
+            authorId: this.identity.memberId,
+            ts: Date.now(),
+        };
+        this.store.appendMessage(workspaceId, sessionId, userMsg);
+        this.publishMessage(workspaceId, sessionId, userMsg);
+        this.touchContributor(session);
+        const engine = this.engineFor(ws, session);
+        // Accumula il testo assistant in streaming per persistere un solo
+        // messaggio a fine giro.
+        let assistantText = "";
+        const handle = engine.prompt(text, (event) => {
+            if (event.type === "text")
+                assistantText += event.delta;
+            // Propaga l'AgentEvent grezzo alle altre finestre (live view).
+            this.publishAgentEvent(workspaceId, sessionId, event);
+            onEvent?.(event);
+            if (event.type === "done" || event.type === "error") {
+                const finalText = assistantText.trim();
+                if (finalText) {
+                    const assistantMsg = { role: "assistant", text: finalText, ts: Date.now() };
+                    this.store.appendMessage(workspaceId, sessionId, assistantMsg);
+                    this.publishMessage(workspaceId, sessionId, assistantMsg);
+                }
+            }
+        });
+        return { done: handle.done, abort: () => handle.abort() };
+    }
+    // Engine vivo per la coppia workspace/sessione (riuso tra prompt).
+    engineFor(ws, session) {
+        const key = `${ws.id}/${session.id}`;
+        let engine = this.engines.get(key);
+        if (!engine) {
+            engine = CoworkEngine.for(ws, session, this.confirm, this.env);
+            this.engines.set(key, engine);
+        }
+        return engine;
+    }
+    touchContributor(session) {
+        if (session.contributors.includes(this.identity.memberId))
+            return;
+        const next = {
+            ...session,
+            contributors: [...session.contributors, this.identity.memberId],
+            updatedAt: Date.now(),
+        };
+        this.store.putSession(next);
+    }
+    // ---- Presence ------------------------------------------------------------
+    // Annuncia/aggiorna la propria presenza in un workspace.
+    announcePresence(workspaceId, activeSessionId, status = "online") {
+        const presence = {
+            memberId: this.identity.memberId,
+            displayName: this.identity.displayName,
+            clientId: this.identity.clientId,
+            activeSessionId,
+            status,
+            lastSeen: Date.now(),
+        };
+        this.recordPresence(workspaceId, presence);
+        this.channel(workspaceId).publish("presence", { presence });
+        return presence;
+    }
+    // Presenze live conosciute di un workspace (esclude offline e stantii > 60s).
+    listPresence(workspaceId) {
+        const map = this.presence.get(workspaceId);
+        if (!map)
+            return [];
+        const cutoff = Date.now() - 60_000;
+        return [...map.values()].filter((p) => p.status !== "offline" && p.lastSeen >= cutoff);
+    }
+    recordPresence(workspaceId, presence) {
+        let map = this.presence.get(workspaceId);
+        if (!map) {
+            map = new Map();
+            this.presence.set(workspaceId, map);
+        }
+        const key = `${presence.memberId}@${presence.clientId}`;
+        if (presence.status === "offline")
+            map.delete(key);
+        else
+            map.set(key, presence);
+    }
+    // ---- Sync wiring ---------------------------------------------------------
+    // Canale di sync per un workspace (lazy). Registra il handler interno che
+    // tiene aggiornata la presenza dagli eventi remoti.
+    channel(workspaceId) {
+        let ch = this.channels.get(workspaceId);
+        if (!ch) {
+            ch = new CoworkSyncChannel(workspaceId, this.store.syncFile(workspaceId), this.identity.clientId);
+            ch.subscribe((ev) => this.onRemoteEvent(ev));
+            this.channels.set(workspaceId, ch);
+        }
+        return ch;
+    }
+    // Sottoscrizione esterna agli eventi remoti di un workspace (per la UI).
+    // Apre il canale se non già attivo. Ritorna la funzione di unsubscribe.
+    subscribe(workspaceId, listener) {
+        return this.channel(workspaceId).subscribe(listener);
+    }
+    onRemoteEvent(ev) {
+        if (ev.type === "presence") {
+            this.recordPresence(ev.workspaceId, ev.payload.presence);
+        }
+        // Gli altri eventi (workspace/session/message) modificano file già
+        // persistiti dall'origine: la UI li rilegge dallo store su notifica.
+    }
+    publishMessage(workspaceId, sessionId, message) {
+        this.channel(workspaceId).publish("message_appended", { sessionId, message });
+    }
+    publishAgentEvent(workspaceId, sessionId, event) {
+        this.channel(workspaceId).publish("agent_event", { sessionId, event });
+    }
+    // ---- Permessi ------------------------------------------------------------
+    assertRole(ws, allowed) {
+        const me = ws.members.find((m) => m.id === this.identity.memberId);
+        // Non-membro: trattato come viewer (sola lettura). Owner del workspace
+        // implicito se nessun membro registrato (workspace appena migrato).
+        const role = me?.role ?? (ws.members.length === 0 ? "owner" : "viewer");
+        if (!allowed.includes(role)) {
+            throw new CoworkError(`operazione non consentita per il ruolo "${role}"`, "permission_denied");
+        }
+    }
+    // ---- Ciclo di vita -------------------------------------------------------
+    // Interrompe ogni giro engine in corso.
+    abortAll() {
+        for (const e of this.engines.values())
+            e.abort();
+    }
+    // Chiude canali sync e libera le risorse (da chiamare alla chiusura finestra).
+    dispose() {
+        this.abortAll();
+        for (const ch of this.channels.values())
+            ch.close();
+        this.channels.clear();
+        this.engines.clear();
+        this.presence.clear();
+    }
+}

package/dist/cowork/store.d.ts

@@ -0,0 +1,23 @@
+import type { CoworkMessage, CoworkSession, CoworkWorkspace } from "./types.js";
+export declare function defaultCoworkDir(env?: NodeJS.ProcessEnv): string;
+export declare function withLock<T>(lockFile: string, fn: () => T, timeoutMs?: number, staleMs?: number): T;
+export declare class CoworkStore {
+    readonly baseDir: string;
+    constructor(baseDir?: string, env?: NodeJS.ProcessEnv);
+    private get workspacesFile();
+    private workspaceDir;
+    private sessionsFile;
+    private messagesFile;
+    syncFile(workspaceId: string): string;
+    listWorkspaces(includeArchived?: boolean): CoworkWorkspace[];
+    getWorkspace(id: string): CoworkWorkspace | null;
+    requireWorkspace(id: string): CoworkWorkspace;
+    putWorkspace(ws: CoworkWorkspace): CoworkWorkspace;
+    listSessions(workspaceId: string, includeArchived?: boolean): CoworkSession[];
+    getSession(workspaceId: string, sessionId: string): CoworkSession | null;
+    requireSession(workspaceId: string, sessionId: string): CoworkSession;
+    putSession(session: CoworkSession): CoworkSession;
+    listMessages(workspaceId: string, sessionId: string): CoworkMessage[];
+    appendMessage(workspaceId: string, sessionId: string, msg: CoworkMessage): CoworkMessage;
+    diskWorkspaceIds(): string[];
+}