@vascend/talos 0.1.0

package/dist/vascend/worktree.js

@@ -0,0 +1,206 @@
+import { spawn } from "node:child_process";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+export function runGit(cwd, args, signal) {
+    return new Promise((resolve) => {
+        let stdout = "";
+        let stderr = "";
+        let child;
+        try {
+            child = spawn("git", args, { cwd, windowsHide: true });
+        }
+        catch (err) {
+            resolve({ code: -1, stdout: "", stderr: String(err) });
+            return;
+        }
+        child.stdout?.on("data", (d) => { stdout += d.toString("utf8"); });
+        child.stderr?.on("data", (d) => { stderr += d.toString("utf8"); });
+        child.on("error", (err) => resolve({ code: -1, stdout: stdout.trim(), stderr: (stderr + String(err)).trim() }));
+        child.on("exit", (code) => resolve({ code: code ?? -1, stdout: stdout.trim(), stderr: stderr.trim() }));
+        if (signal) {
+            if (signal.aborted) {
+                try {
+                    child.kill();
+                }
+                catch { /* gia' morto */ }
+            }
+            else
+                signal.addEventListener("abort", () => { try {
+                    child.kill();
+                }
+                catch { /* gia' morto */ } }, { once: true });
+        }
+    });
+}
+// Modalita' worktree: default ON. Disattivabile con TALOS_KINGDOM_WORKTREE=0
+// (torna alla modalita' working dir condivisa + commit unico finale).
+/* I worktree NON sono piu' il default. Erano diventati il pedaggio per avere
+   una squadra che lavora davvero in parallelo: in un repo git partiva una
+   richiesta di creare N worktree e N rami prima ancora di cominciare, e fuori
+   da git il parallelismo veniva tolto del tutto. Adesso i collaboratori
+   partono insieme comunque, e l'isolamento e' una scelta di chi lo vuole
+   (TALOS_KINGDOM_WORKTREE=1), non una condizione. */
+export function worktreeMode(env) {
+    const v = (env["TALOS_KINGDOM_WORKTREE"] ?? "").trim().toLowerCase();
+    return v === "1" || v === "on" || v === "true" || v === "yes";
+}
+export async function isGitRepo(cwd) {
+    const r = await runGit(cwd, ["rev-parse", "--is-inside-work-tree"]);
+    return r.code === 0 && r.stdout.startsWith("true");
+}
+// Radice del repo (toplevel) a partire da una dir qualsiasi.
+export async function repoRoot(cwd) {
+    const r = await runGit(cwd, ["rev-parse", "--show-toplevel"]);
+    return r.code === 0 && r.stdout ? r.stdout.trim() : null;
+}
+// Ramo corrente (null se detached o non-repo).
+export async function currentBranch(cwd, signal) {
+    const r = await runGit(cwd, ["rev-parse", "--abbrev-ref", "HEAD"], signal);
+    if (r.code !== 0)
+        return null;
+    const b = r.stdout.trim();
+    return b && b !== "HEAD" ? b : null;
+}
+// Ramo di integrazione: esplicito > env > ramo corrente. NON hardcoded.
+export async function resolveBaseBranch(cwd, env, explicit) {
+    const e = (explicit ?? env["TALOS_KINGDOM_BASE_BRANCH"] ?? "").trim();
+    if (e)
+        return e;
+    return currentBranch(cwd);
+}
+// Verifica il target PRIMA del merge. Un override del ramo base non autorizza a
+// fondere silenziosamente nel ramo attualmente checkout: in caso di mismatch ci
+// fermiamo e lasciamo intatti ramo e worktree del vassallo.
+export async function verifyBaseBranch(root, base, signal) {
+    const ref = await runGit(root, ["show-ref", "--verify", "--quiet", `refs/heads/${base}`], signal);
+    if (ref.code !== 0) {
+        return {
+            ok: false,
+            current: await currentBranch(root, signal),
+            note: `ramo base locale "${base}" non trovato; crealo o seleziona un ramo locale esistente`,
+        };
+    }
+    const current = await currentBranch(root, signal);
+    if (current !== base) {
+        return {
+            ok: false,
+            current,
+            note: `ramo base atteso "${base}", ma il repo principale e' su "${current ?? "HEAD staccato"}"; esegui git switch ${base} e riprova il merge`,
+        };
+    }
+    const mergeHead = await runGit(root, ["rev-parse", "-q", "--verify", "MERGE_HEAD"], signal);
+    if (mergeHead.code === 0) {
+        return {
+            ok: false,
+            current,
+            note: `il ramo base "${base}" ha gia' un merge in corso; completalo o annullalo prima di integrare i collaboratori`,
+        };
+    }
+    return { ok: true, current, note: `ramo base verificato: ${base}` };
+}
+// Componente di ref sicuro (per il nome ramo del vassallo).
+export function sanitizeRef(s) {
+    return s.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^[-.]+|[-.]+$/g, "").slice(0, 40) || "x";
+}
+export function vassalBranchName(kingdomId, slug) {
+    return `talos/${sanitizeRef(kingdomId)}/${sanitizeRef(slug)}`;
+}
+export function worktreeDir(kingdomId, slug) {
+    return join(tmpdir(), "talos-wt", sanitizeRef(kingdomId), sanitizeRef(slug));
+}
+// Crea il worktree del vassallo su un ramo NUOVO dal ramo base. Non rimuove mai
+// con --force un worktree precedente e non resetta mai un ramo gia' esistente:
+// entrambi potrebbero contenere il recupero di un'esecuzione fallita.
+export async function addWorktree(root, dir, branch, base, signal) {
+    return runGit(root, ["worktree", "add", "-b", branch, dir, base], signal);
+}
+// Committa nel worktree del vassallo TUTTO cio' che e' rimasto non committato
+// (rete di sicurezza se il vassallo non ha committato da solo). Ritorna se ha
+// effettivamente creato un commit.
+export async function commitAll(dir, message, signal) {
+    const add = await runGit(dir, ["add", "-A"], signal);
+    if (add.code !== 0) {
+        return { ok: false, committed: false, clean: false, note: gitFailure("git add", add) };
+    }
+    const status = await runGit(dir, ["status", "--porcelain"], signal);
+    if (status.code !== 0) {
+        return { ok: false, committed: false, clean: false, note: gitFailure("git status", status) };
+    }
+    if (!status.stdout.trim())
+        return { ok: true, committed: false, clean: true, note: "worktree gia' pulito" };
+    const r = await runGit(dir, ["commit", "-m", message], signal);
+    if (r.code !== 0) {
+        return { ok: false, committed: false, clean: false, note: gitFailure("git commit", r) };
+    }
+    // Un hook post-commit potrebbe aver generato altre modifiche. Finche' il
+    // worktree non e' davvero pulito non e' sicuro fare merge e cleanup.
+    const after = await runGit(dir, ["status", "--porcelain"], signal);
+    if (after.code !== 0) {
+        return { ok: false, committed: true, clean: false, note: gitFailure("verifica dopo il commit", after) };
+    }
+    if (after.stdout.trim()) {
+        return {
+            ok: false,
+            committed: true,
+            clean: false,
+            note: `commit creato, ma restano modifiche non salvate: ${after.stdout.split(/\r?\n/).slice(0, 4).join(", ")}`,
+        };
+    }
+    return { ok: true, committed: true, clean: true, note: "commit creato e worktree pulito" };
+}
+// Merge del ramo del vassallo nel ramo base (eseguito nel repo principale, che
+// e' sul ramo base). In conflitto: abort e segnalazione (il ramo resta per la
+// risoluzione manuale).
+export async function mergeBack(root, base, branch, message, signal) {
+    const target = await verifyBaseBranch(root, base, signal);
+    if (!target.ok)
+        return { ok: false, conflict: false, integrated: false, note: target.note };
+    const r = await runGit(root, ["merge", "--no-ff", "-m", message, branch], signal);
+    if (r.code === 0) {
+        const ancestor = await runGit(root, ["merge-base", "--is-ancestor", branch, base], signal);
+        if (ancestor.code === 0)
+            return { ok: true, conflict: false, integrated: true, note: `merge verificato in ${base}` };
+        return {
+            ok: false,
+            conflict: false,
+            integrated: false,
+            note: `git merge e' terminato, ma non e' stato possibile verificare ${branch} come antenato di ${base}; ramo e worktree conservati`,
+        };
+    }
+    const out = `${r.stdout}\n${r.stderr}`;
+    const mergeHead = await runGit(root, ["rev-parse", "-q", "--verify", "MERGE_HEAD"], signal);
+    const conflict = mergeHead.code === 0 || /conflict/i.test(out);
+    let abortNote = "";
+    if (mergeHead.code === 0) {
+        const aborted = await runGit(root, ["merge", "--abort"], signal);
+        abortNote = aborted.code === 0
+            ? "; merge parziale annullato"
+            : `; ATTENZIONE: git merge --abort fallito (${gitFailure("merge abort", aborted)})`;
+    }
+    return {
+        ok: false,
+        conflict,
+        integrated: false,
+        note: `${(out.trim() || "merge fallito").slice(0, 360)}${abortNote}`,
+    };
+}
+// Pulizia volutamente non forzata: se Git vede modifiche residue, fallisce e il
+// chiamante conserva sia worktree sia ramo per il recupero manuale.
+export function removeWorktree(root, dir, signal) {
+    return runGit(root, ["worktree", "remove", dir], signal);
+}
+// -d (non -D) costituisce un secondo gate: Git rifiuta di eliminare un ramo che
+// non risulta integrato.
+export function deleteBranch(root, branch, signal) {
+    return runGit(root, ["branch", "-d", branch], signal);
+}
+// HEAD del ramo base prima dello swarm: serve a sapere se il merge ha aggiunto
+// qualcosa (per il push finale).
+export async function revParse(cwd, ref, signal) {
+    const r = await runGit(cwd, ["rev-parse", ref], signal);
+    return r.code === 0 ? r.stdout.trim() : null;
+}
+function gitFailure(step, result) {
+    const detail = (result.stderr || result.stdout || `uscita ${result.code}`).trim();
+    return `${step} fallito: ${detail.slice(0, 360)}`;
+}

package/dist/vendor/computer-use/README.md

@@ -0,0 +1,7 @@
+# Backend Computer Use incorporato
+
+Snapshot dei moduli nativi del workspace Vascend Horizon (`vascend-terminal/src/main`), incorporato per rendere Talos CLI indipendente da Electron e dal repository esterno.
+
+I file JavaScript mantengono CommonJS e il codice upstream. Dipendenze: soltanto built-in Node e PowerShell/Windows UI Automation. Non aggiungere dipendenze runtime. Il consenso, la serializzazione, l'isolamento sessioni e la conversione immagini sono gestiti da `src/tools/computer-use.ts`. I tool RAC che richiedono l'host non vengono esposti.
+
+`node scripts/copy-computer-use.mjs` copia questi asset in `dist/vendor/computer-use` durante la build. Aggiornare lo snapshot in modo esplicito, rivedendo dipendenze e test; nessun caricamento dal repository fratello in produzione.

package/dist/vendor/computer-use/computer-desktop.js

@@ -0,0 +1,211 @@
+'use strict';
+
+// Inventario del desktop per Computer Use: applicazioni, processi e finestre.
+// Sta fuori dal modulo dei tool perche' e' una fonte dati con regole proprie
+// (fusione di due enumerazioni Win32, icone locali che non devono mai entrare
+// nel contesto del modello, fotografia breve riusata da processes e attach).
+
+const crypto = require('crypto');
+const { integer, cleanWindow, cleanProcess } = require('./computer-observe');
+
+const KNOWN_APPLICATIONS = Object.freeze({
+  claude: 'Claude Desktop', code: 'Visual Studio Code', chrome: 'Google Chrome',
+  msedge: 'Microsoft Edge', firefox: 'Firefox', slack: 'Slack', teams: 'Microsoft Teams',
+  notion: 'Notion', discord: 'Discord', spotify: 'Spotify', explorer: 'Esplora file',
+});
+
+function applicationName(process, windows) {
+  const normalized = String(process || '').trim().toLocaleLowerCase();
+  if (KNOWN_APPLICATIONS[normalized]) return KNOWN_APPLICATIONS[normalized];
+  const titled = (Array.isArray(windows) ? windows : []).find((row) => row.visible && row.title)
+    || (Array.isArray(windows) ? windows : []).find((row) => row.title);
+  if (titled && titled.title) return titled.title.slice(0, 120);
+  const raw = String(process || 'Applicazione').replace(/[-_]+/g, ' ').trim();
+  return raw ? raw.charAt(0).toLocaleUpperCase() + raw.slice(1) : 'Applicazione';
+}
+
+function safeIconDataUrl(value) {
+  const icon = String(value || '');
+  return icon.length <= 32768 && /^data:image\/png;base64,[a-z0-9+/=]+$/i.test(icon) ? icon : '';
+}
+
+// Il percorso dell'eseguibile serve solo all'host per estrarre l'icona: non
+// lascia mai questo processo.
+function publicProcess(value) {
+  const { _executablePath, ...safe } = value && typeof value === 'object' ? value : {};
+  return safe;
+}
+
+function publicApplication(value) {
+  const { icon, _iconProcess, ...safe } = value && typeof value === 'object' ? value : {};
+  return safe;
+}
+
+function uiApplication(value) {
+  const { _iconProcess, ...safe } = value && typeof value === 'object' ? value : {};
+  return safe;
+}
+
+function publicTarget(value) {
+  const { icon, _iconProcess, ...safe } = value && typeof value === 'object' ? value : {};
+  return Object.keys(safe).length ? safe : null;
+}
+
+function mergeProcessWindows(windows, processes) {
+  const byId = new Map((Array.isArray(windows) ? windows : []).map((row) => [row.windowId, row]));
+  for (const process of Array.isArray(processes) ? processes : []) {
+    if (!process.windowId || !process.bounds || byId.has(process.windowId)) continue;
+    const row = cleanWindow({
+      windowId: process.windowId,
+      processId: process.processId,
+      process: process.process,
+      title: process.title || process.process,
+      bounds: process.bounds,
+      visible: process.visible,
+      minimized: process.minimized,
+    });
+    if (row) byId.set(row.windowId, row);
+  }
+  return [...byId.values()].sort((a, b) => Number(b.visible) - Number(a.visible)
+    || Number(a.minimized) - Number(b.minimized)
+    || a.process.localeCompare(b.process) || a.title.localeCompare(b.title)).slice(0, 240);
+}
+
+function createDesktopInventory({ listWindows, listProcesses, resolveProcessIcon, cacheMs = 2500 } = {}) {
+  let cache = null;
+  const iconCache = new Map();
+
+  const windowsNow = async () => {
+    let rows = [];
+    try { rows = await listWindows(); } catch (_) { rows = []; }
+    return (Array.isArray(rows) ? rows : []).map(cleanWindow).filter(Boolean).slice(0, 240);
+  };
+
+  const processesNow = async (windows) => {
+    let rows = [];
+    try { rows = listProcesses ? await listProcesses() : windows; } catch (_) { rows = []; }
+    const byId = new Map();
+    for (const raw of Array.isArray(rows) ? rows : []) {
+      const row = cleanProcess(raw);
+      if (row) byId.set(row.processId, row);
+    }
+    // EnumWindows e' piu autorevole sul collegamento tra HWND e PID: fonde le
+    // due fonti e promuove in cima le applicazioni realmente collegabili.
+    for (const win of Array.isArray(windows) ? windows : []) {
+      const previous = byId.get(win.processId);
+      byId.set(win.processId, {
+        processId: win.processId,
+        process: win.process || previous && previous.process || 'processo',
+        title: win.title || previous && previous.title || '',
+        windowId: win.windowId,
+        hasWindow: true,
+        bounds: win.bounds,
+        visible: win.visible,
+        minimized: win.minimized,
+        responding: previous ? previous.responding : true,
+        _executablePath: previous ? previous._executablePath : '',
+      });
+    }
+    return [...byId.values()].sort((a, b) => Number(b.hasWindow) - Number(a.hasWindow)
+      || Number(b.visible) - Number(a.visible)
+      || a.process.localeCompare(b.process) || a.processId - b.processId).slice(0, 512);
+  };
+
+  const applicationsNow = async (processes, windows) => {
+    const groups = new Map();
+    for (const process of Array.isArray(processes) ? processes : []) {
+      const key = String(process.process || '').trim().toLocaleLowerCase();
+      if (!key) continue;
+      if (!groups.has(key)) groups.set(key, { process: process.process, processes: [], windows: [] });
+      groups.get(key).processes.push(process);
+    }
+    for (const win of Array.isArray(windows) ? windows : []) {
+      const key = String(win.process || '').trim().toLocaleLowerCase();
+      if (!key) continue;
+      if (!groups.has(key)) groups.set(key, { process: win.process, processes: [], windows: [] });
+      groups.get(key).windows.push(win);
+    }
+    const applications = [...groups.entries()].map(([key, group]) => {
+      const processIds = [...new Set(group.processes.map((row) => row.processId)
+        .concat(group.windows.map((row) => row.processId)).filter(Boolean))];
+      const windowIds = [...new Set(group.windows.map((row) => row.windowId).filter(Boolean))];
+      const titles = [...new Set(group.windows.map((row) => row.title).filter(Boolean))].slice(0, 8);
+      return {
+        applicationId: 'app-' + crypto.createHash('sha256').update(key).digest('hex').slice(0, 10),
+        name: applicationName(group.process, group.windows),
+        process: group.process,
+        processIds,
+        instanceCount: processIds.length,
+        windowIds,
+        windowCount: windowIds.length,
+        titles,
+        controllable: windowIds.length > 0,
+        visible: group.windows.some((row) => row.visible),
+        minimized: group.windows.some((row) => row.minimized),
+        _iconProcess: group.processes.find((row) => row.hasWindow) || group.processes[0] || null,
+      };
+    }).sort((a, b) => Number(b.controllable) - Number(a.controllable)
+      || Number(b.visible) - Number(a.visible)
+      || a.name.localeCompare(b.name)).slice(0, 240);
+    return applications;
+  };
+
+  // Estrarre l'icona di ogni processo richiede accesso al relativo eseguibile e
+  // rendeva computer_processes lento anche quando l'utente cercava una sola app.
+  // Risolviamo soltanto le applicazioni effettivamente mostrate/collegate e
+  // riutilizziamo il risultato per tutto il run.
+  const hydrateApplicationIcons = async (rows) => {
+    if (!resolveProcessIcon) return rows;
+    await Promise.all((Array.isArray(rows) ? rows : []).map(async (application) => {
+      if (!application || application.icon || !application._iconProcess) return;
+      const process = application._iconProcess;
+      const key = String(process._executablePath || process.process || process.processId || '').toLocaleLowerCase();
+      if (key && iconCache.has(key)) {
+        application.icon = iconCache.get(key);
+        return;
+      }
+      let icon = '';
+      try { icon = safeIconDataUrl(await resolveProcessIcon(process)); } catch (_) { icon = ''; }
+      application.icon = icon;
+      if (key) iconCache.set(key, icon);
+    }));
+    return rows;
+  };
+
+  // computer_processes e computer_attach sono normalmente consecutivi. Una
+  // seconda enumerazione Win32/PowerShell immediata aggiungeva vari secondi
+  // senza aumentare la precisione; riusiamo solo una fotografia molto breve.
+  const targetsNow = async (progress) => {
+    if (cache && Date.now() - cache.capturedAt < integer(cacheMs, 0, 60000, 2500)) {
+      if (typeof progress === 'function') progress({ phase: 'windows', windows: cache.value.windows });
+      return cache.value;
+    }
+    const enumerated = await windowsNow();
+    if (typeof progress === 'function') progress({ phase: 'windows', windows: enumerated });
+    const processes = await processesNow(enumerated);
+    const windows = mergeProcessWindows(enumerated, processes);
+    const applications = await applicationsNow(processes, windows);
+    const value = { applications, processes: processes.map(publicProcess), windows };
+    cache = { capturedAt: Date.now(), value };
+    return value;
+  };
+
+  return {
+    windowsNow,
+    targetsNow,
+    hydrateApplicationIcons,
+    invalidate: () => { cache = null; },
+  };
+}
+
+module.exports = {
+  KNOWN_APPLICATIONS,
+  applicationName,
+  safeIconDataUrl,
+  publicProcess,
+  publicApplication,
+  uiApplication,
+  publicTarget,
+  mergeProcessWindows,
+  createDesktopInventory,
+};