robisie 0.0.0-stage → 0.1.0

package/dist/commands.js

@@ -0,0 +1,318 @@
+import { readdirSync, rmdirSync, rmSync } from "node:fs";
+import { AGENT_LABELS, SHELL_EXPORT, agentPaths, agentOnPath, detectAgents, planAgent, removeCodexTables, shellProfile } from "./agents.js";
+import { HELPER_SERVERS, KEY_ENV, KEY_PATTERN, PACKAGE_NAME, PACKAGE_VERSION } from "./constants.js";
+import { RobisieError, errorMessage } from "./context.js";
+import { applyOp, assertCodexChange, capture, entryPresent, prepareBlock, refusePrivateSymlink, restore, undoEntry } from "./fsops.js";
+import { HELPER_TOOLS, probeHelper } from "./helpers.js";
+import { clientPaths, ensurePrivateDir, readKey, readManifest, writeKey, writeManifest, roleProviders, ROLE_IDS, ROLE_STEP } from "./manifest.js";
+import { assertCompatible, checkConnection, fetchContractVersion } from "./mcp.js";
+import { loadRoles, rolesDir } from "./roles.js";
+const NO_KEY_STEP = "Wygeneruj klucz worker na https://robisie.app/dashboard/connect; w zsh/bash wykonaj `unset ROBISIE_KEY`, potem lokalne `npx robisie init` i wklej klucz w ukrytym pytaniu (poza rozmową).";
+function entryId(entry) {
+    return `${entry.kind}:${entry.path}:${entry.keyPath?.join(".") ?? ""}`;
+}
+async function obtainKey(ctx, keyStdin) {
+    let key = ctx.env[KEY_ENV]?.trim() ?? "";
+    if (!key && ctx.askSecret)
+        key = (await ctx.askSecret("Wklej klucz robisie (rob_…, nie będzie widoczny): ")).trim();
+    if (!key && keyStdin && ctx.readStdin)
+        key = (await ctx.readStdin()).trim().split(/\r?\n/)[0]?.trim() ?? "";
+    if (!key)
+        throw new RobisieError("Brak klucza robisie.", NO_KEY_STEP);
+    if (!KEY_PATTERN.test(key))
+        throw new RobisieError("To nie wygląda na klucz robisie (oczekuję rob_ i 64 znaków 0-9a-f).", "Skopiuj klucz jeszcze raz z https://robisie.app/dashboard/connect i uruchom `npx robisie init`.");
+    return key;
+}
+export async function init(ctx, options) {
+    const paths = clientPaths(agentPaths(ctx).clientDir);
+    const prior = readManifest(paths.manifest);
+    const detected = options.agents ?? detectAgents(ctx);
+    const previousMap = prior ? roleProviders(prior) : roleProviders({ agents: detected });
+    let map = previousMap;
+    if (options.roles && Object.keys(options.roles).length > 0) {
+        const merged = { ...previousMap, ...options.roles };
+        if (!ROLE_IDS.every((role) => merged[role]))
+            throw new RobisieError("Wynikowa mapa ról jest niekompletna (ceo, builder, quality).", ROLE_STEP);
+        map = roleProviders({ agents: [], roleProviders: merged });
+    }
+    const selected = [...new Set([...Object.values(map ?? {}), ...detected])];
+    if (selected.length === 0) {
+        throw new RobisieError("Nie znalazłem na tym komputerze Claude Code, Codex CLI ani OpenCode.", "Zainstaluj jednego z tych agentów albo wskaż go wprost, np. `npx robisie init --agent codex`.");
+    }
+    const key = await obtainKey(ctx, options.keyStdin);
+    // Refuse before writing anything: incompatible server, or a key that does not open the board.
+    assertCompatible(await fetchContractVersion(ctx));
+    const connection = await checkConnection(ctx, key);
+    if (connection.contractVersion)
+        assertCompatible(connection.contractVersion);
+    const roles = loadRoles(options.rolesDir ?? rolesDir());
+    const planned = [];
+    for (const id of selected)
+        for (const op of planAgent(ctx, id, roles, key))
+            planned.push({ owner: id, op });
+    const profile = options.shell ? shellProfile(ctx) : null;
+    if (profile)
+        planned.push({ owner: "shell", op: { kind: "block", path: profile, comment: "hash", body: SHELL_EXPORT } });
+    // Before writing anything, so a refusal leaves no half-done install behind.
+    for (const { op } of planned) {
+        refusePrivateSymlink(op);
+        if (op.kind === "block" && op.clean)
+            prepareBlock(capture(op.path).bytes?.toString("utf8") ?? null, op.comment, op.clean, op.body);
+    }
+    ensurePrivateDir(paths.dir);
+    const priorById = new Map((prior?.entries ?? []).map((entry) => [entryId(entry), entry]));
+    const done = new Map(priorById);
+    const agents = [...new Set([...(prior?.agents ?? []), ...selected])];
+    let changed = 0;
+    // The record first, then the key and the changes: a disk that fills up cannot leave a key or a change uninstall does not know about.
+    writeManifest(paths.dir, { agents, roleProviders: map, entries: [...done.values()] });
+    writeKey(paths.dir, key);
+    for (const { owner, op } of planned) {
+        const id = entryId(op);
+        const before = capture(op.path);
+        const applied = applyOp(op, priorById.get(id), { backupDir: paths.backups });
+        const previous = done.get(id);
+        done.set(id, { ...applied.entry, owner });
+        try {
+            // Recorded after every change (atomically), so even a killed init leaves uninstall a complete record.
+            writeManifest(paths.dir, { agents, roleProviders: map, entries: [...done.values()] });
+        }
+        catch (error) {
+            // The change is not on record, so uninstall could never undo it: take it back before failing.
+            if (previous)
+                done.set(id, previous);
+            else
+                done.delete(id);
+            try {
+                if (op.kind === "block" && op.clean) {
+                    const original = before.bytes?.toString("utf8") ?? "";
+                    assertCodexChange(capture(op.path).bytes?.toString("utf8") ?? "", original, original);
+                }
+                restore(before);
+            }
+            catch (rollback) {
+                throw new RobisieError(`Zmieniłem ${op.path}, ale nie udało się zapisać rekordu zmian ani cofnąć tej zmiany: ${errorMessage(error)}; ${errorMessage(rollback)}`, `Zwolnij miejsce na dysku i przywróć ${op.path}${applied.entry.backup ? ` z kopii ${applied.entry.backup}` : " (usuń z niego wpis robisie)"}.`);
+            }
+            throw new RobisieError(errorMessage(error), `${error instanceof RobisieError ? error.nextStep : "Ponów init."} Kopie zapasowe: ${paths.backups}.`);
+        }
+        if (applied.changed)
+            changed += 1;
+    }
+    ctx.out(`robisie ${PACKAGE_VERSION}: połączono z tablicą (projektów: ${connection.projectCount}).`);
+    for (const id of selected)
+        ctx.out(`✓ ${AGENT_LABELS[id]}: serwer MCP robisie i role klienta (CEO, Builder, Quality Officer) zainstalowane.`);
+    ctx.out(changed === 0 ? "Nic się nie zmieniło — wszystko było już zainstalowane." : `Zmienione pliki: ${changed} (kopie zapasowe: ${paths.backups}).`);
+    if (profile)
+        ctx.out(`✓ Klucz będzie dostępny jako ${KEY_ENV} w nowych terminalach (wpis w ${profile}).`);
+    else
+        ctx.out(`! Ustaw sam zmienną ${KEY_ENV} dla agenta, np.: ${SHELL_EXPORT}`);
+    ctx.out("Następny krok: otwórz nowy terminal i uruchom `npx robisie doctor`.");
+}
+// ── doctor ───────────────────────────────────────────────────────────────────
+/** Returns the process exit code: 0 = all good, 1 = something needs one action. */
+export async function doctor(ctx) {
+    const problems = [];
+    const fail = (line, nextStep) => {
+        ctx.out(`✗ ${line}`);
+        problems.push(nextStep);
+    };
+    const guard = async (action) => {
+        try {
+            await action();
+        }
+        catch (error) {
+            if (error instanceof RobisieError)
+                fail(error.message, error.nextStep);
+            else
+                fail(`Nieoczekiwany błąd: ${errorMessage(error)}`, "Uruchom lokalne `npx robisie doctor` w katalogu instalacji; jeśli błąd zostaje, przekaż zespołowi komunikat i wersję paczki bez klucza.");
+        }
+    };
+    ctx.out(`Paczka ${PACKAGE_NAME} ${PACKAGE_VERSION}`);
+    const paths = clientPaths(agentPaths(ctx).clientDir);
+    await guard(async () => {
+        const version = await fetchContractVersion(ctx);
+        assertCompatible(version);
+        ctx.out(`✓ Wersja kontraktu serwera ${version} pasuje do paczki.`);
+    });
+    const envKey = ctx.env[KEY_ENV]?.trim() || null;
+    let key = envKey;
+    await guard(async () => {
+        key = envKey ?? readKey(paths.dir);
+    });
+    const usableKey = key;
+    if (!usableKey)
+        fail("Brak klucza robisie.", NO_KEY_STEP);
+    else if (!KEY_PATTERN.test(usableKey))
+        fail("Zapisany klucz ma zły format.", "Uruchom `npx robisie init` i wklej klucz jeszcze raz.");
+    else {
+        await guard(async () => {
+            const connection = await checkConnection(ctx, usableKey);
+            if (connection.contractVersion)
+                assertCompatible(connection.contractVersion);
+            ctx.out(`✓ Połączenie działa: klucz otwiera tablicę (projektów: ${connection.projectCount}).`);
+        });
+    }
+    let manifest = null;
+    await guard(async () => {
+        manifest = readManifest(paths.manifest);
+    });
+    const installed = manifest;
+    let map = null;
+    if (installed)
+        await guard(async () => { map = roleProviders(installed); });
+    const assignment = map;
+    for (const role of ROLE_IDS)
+        ctx.out(`${role} → ${assignment?.[role] ?? "nie przypisano"}`);
+    if (!installed || installed.agents.length === 0) {
+        fail("robisie nie jest zainstalowane dla żadnego agenta.", "Uruchom `npx robisie init`.");
+    }
+    else {
+        const byId = new Map(installed.entries.map((entry) => [entryId(entry), entry]));
+        for (const id of new Set([...installed.agents, ...Object.values(assignment ?? {})])) {
+            const repair = `Uruchom \`npx robisie init --agent ${id}\` — uzupełni braki.`;
+            await guard(async () => {
+                // A complete install = every change init plans for this agent is recorded AND still in place.
+                const expected = planAgent(ctx, id, loadRoles(), usableKey ?? `rob_${"0".repeat(64)}`);
+                const missing = expected.filter((op) => {
+                    const entry = byId.get(entryId(op));
+                    if (!entry || entry.owner !== id || !entryPresent(entry))
+                        return true;
+                    if (op.kind === "block" && op.clean) {
+                        try {
+                            const current = capture(op.path).bytes?.toString("utf8") ?? "";
+                            assertCodexChange(current, current, op.body);
+                        }
+                        catch {
+                            // The marker alone is insufficient: report missing/invalid MCP tables as incomplete installation.
+                            return true;
+                        }
+                    }
+                    return false;
+                }).map(entryId);
+                const roleIds = expected.filter((op) => op.kind === "file").map(entryId);
+                const rolesOk = roleIds.filter((eid) => !missing.includes(eid)).length;
+                const configOk = missing.every((eid) => eid.startsWith("file:"));
+                if (missing.length === 0)
+                    ctx.out(`✓ ${AGENT_LABELS[id]}: konfiguracja MCP, pomocniki i role (${rolesOk}/${roleIds.length}) na miejscu.`);
+                else {
+                    const assigned = assignment ? ROLE_IDS.filter((role) => assignment[role] === id) : [];
+                    const detail = assigned.map((role) => `${role} → ${id}: niepełna instalacja`).join(", ");
+                    fail(`${AGENT_LABELS[id]}: niepełna instalacja — konfiguracja MCP ${configOk ? "jest" : "niekompletna"}, role ${rolesOk}/${roleIds.length} (brak m.in. ${missing[0]?.split(":")[1] ?? "?"}).${detail ? ` Role: ${detail}.` : ""}`, repair);
+                }
+            });
+        }
+        for (const id of new Set(assignment ? Object.values(assignment) : installed.agents)) {
+            if (!agentOnPath(ctx, id)) {
+                const assigned = assignment ? ROLE_IDS.filter((role) => assignment[role] === id).join(", ") : "nie przypisano";
+                fail(`${assigned} → ${id}: ${detectAgents(ctx).includes(id) ? "katalog jest, programu nie ma w PATH" : "brak programu w PATH i katalogu dostawcy"}.`, `Zainstaluj program ${id} lub dodaj go do PATH i ponów \`npx robisie doctor\`.`);
+            }
+        }
+        if (!assignment)
+            fail("Role: nie przypisano dostawców.", `Uruchom npx robisie init z pełną mapą. ${ROLE_STEP}`);
+        else if (assignment.builder !== assignment.ceo || assignment.quality !== assignment.ceo) {
+            fail(`Mieszana mapa: Quality Officer jako podagent u dostawcy CEO (${assignment.ceo}); polecenie Buildera w formacie dostawcy CEO (${assignment.ceo}). Wykonanie mieszanych ról to następny zakres.`, "Wybierz jednego dostawcę dla trzech ról przez `npx robisie init --role ceo=claude --role builder=claude --role quality=claude` albo zachowaj mapę i poczekaj na obsługę mieszanych ról.");
+        }
+        for (const name of HELPER_SERVERS) {
+            await guard(async () => {
+                let tools;
+                try {
+                    tools = await probeHelper(name, ctx.env, ctx.cwd);
+                }
+                catch (error) {
+                    throw new RobisieError(`Pomocnik ${name} nie działa na tym komputerze: ${errorMessage(error)}`, "Sprawdź Node.js (wymagany 20+). Przeinstaluj otrzymany plik .tgz w katalogu instalacji: `npm i ./robisie-0.1.0.tgz` (użyj nazwy otrzymanego pliku), potem lokalne `npx robisie init` i `npx robisie doctor`.");
+                }
+                const absent = HELPER_TOOLS[name].filter((tool) => !tools.includes(tool));
+                if (absent.length > 0)
+                    throw new RobisieError(`Pomocnik ${name} nie ma narzędzi: ${absent.join(", ")}.`, "Przeinstaluj otrzymany plik .tgz w katalogu instalacji: `npm i ./robisie-0.1.0.tgz` (użyj nazwy otrzymanego pliku), potem lokalne `npx robisie init` i `npx robisie doctor`.");
+                ctx.out(`✓ Pomocnik ${name} działa (${tools.length} narzędzi).`);
+            });
+        }
+    }
+    if (!envKey)
+        fail(`Zmienna ${KEY_ENV} nie jest ustawiona — role i agenci jej potrzebują.`, `Jeśli init zapisał profil zsh/bash, otwórz nowy terminal z tym samym XDG_CONFIG_HOME. Przy --no-shell/innej powłoce ustaw środowisko agenta bez ujawniania klucza; w powłoce POSIX: ${SHELL_EXPORT}`);
+    if (problems.length === 0) {
+        ctx.out("Wszystko działa. Uruchom swojego agenta i poproś o rolę robisie CEO.");
+        return 0;
+    }
+    ctx.out(`Następny krok: ${problems[0]}`);
+    return 1;
+}
+// ── uninstall ────────────────────────────────────────────────────────────────
+/** Remove a directory only when it is empty; anything left inside is not ours to delete. */
+function removeEmptyDir(path) {
+    try {
+        rmdirSync(path);
+        return true;
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT")
+            return true;
+        if (code === "ENOTEMPTY" || code === "EEXIST")
+            return false;
+        throw new RobisieError(`Nie mogę usunąć katalogu ${path}: ${errorMessage(error)}`, `Usuń katalog ${path} ręcznie.`);
+    }
+}
+export function uninstall(ctx) {
+    const agent = agentPaths(ctx);
+    const paths = clientPaths(agent.clientDir);
+    const manifest = readManifest(paths.manifest);
+    let hasBackups = false;
+    try {
+        hasBackups = readdirSync(paths.backups).length > 0;
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            throw new RobisieError(`Nie mogę sprawdzić kopii zapasowych: ${errorMessage(error)}`, `Sprawdź uprawnienia do ${paths.backups} i ponów polecenie.`);
+        }
+    }
+    const backupNotice = hasBackups ? `Kopie zapasowe pozostają w ${paths.backups}.` : "";
+    if (!manifest) {
+        ctx.out("Nie znaleziono zapisu instalacji — nic nie zmieniono (0 zmian).");
+        ctx.out(`Jeśli wpis robisie pozostał, usuń go ręcznie z konfiguracji swojego agenta: ${agent.claudeJson}, ${agent.codexConfig} lub ${agent.opencodeJson} (albo ${agent.opencodeJsonc}).`);
+        if (backupNotice)
+            ctx.out(backupNotice);
+        return 0;
+    }
+    const pending = new Set(manifest.entries);
+    // The manifest records the installed location; CODEX_HOME may have changed since init.
+    const codexConfigs = new Set(manifest.entries.filter((entry) => entry.kind === "block" && entry.comment === "hash" && (entry.owner === "codex" || entry.path === agent.codexConfig)).map((entry) => entry.path));
+    const evidence = `${backupNotice ? `${backupNotice} ` : ""}Pozostałe zmiany: ${paths.manifest}.`;
+    try {
+        // Refuse unsafe Codex edits before deleting the key, undoing roles or recording progress.
+        for (const entry of manifest.entries) {
+            if (entry.kind === "block" && codexConfigs.has(entry.path)) {
+                prepareBlock(capture(entry.path).bytes?.toString("utf8") ?? null, entry.comment, (text) => removeCodexTables(text, true));
+            }
+        }
+        // The key is not needed to finish an uninstall, even after a warning or a failure.
+        rmSync(paths.key, { force: true });
+        for (const entry of [...manifest.entries].reverse()) {
+            const warning = undoEntry(entry, codexConfigs.has(entry.path) ? (text) => removeCodexTables(text, true) : undefined);
+            if (warning)
+                ctx.out(`! ${warning} ${evidence}`);
+            else {
+                pending.delete(entry);
+                // A later init must not mistake an already restored user role for an edited installed one.
+                writeManifest(paths.dir, { agents: manifest.agents, roleProviders: manifest.roleProviders, entries: [...pending] });
+            }
+        }
+        if (pending.size > 0) {
+            ctx.out(`! Nie udało się cofnąć wszystkich zmian. ${evidence}`);
+            ctx.out("Następny krok: porównaj pozostawione pliki z kopiami, zachowaj swoje zmiany i ponów `npx robisie uninstall`.");
+            return 1;
+        }
+        rmSync(paths.manifest, { force: true });
+    }
+    catch (error) {
+        throw new RobisieError(`Nie udało się dokończyć odinstalowania: ${errorMessage(error)}`, `${error instanceof RobisieError ? error.nextStep : "Rozwiąż problem i ponów `npx robisie uninstall`."} ${evidence}`);
+    }
+    const leftovers = [paths.codexRoles, paths.roles, paths.dir].filter((dir) => !removeEmptyDir(dir));
+    ctx.out(`✓ Usunięto wpisy i bloki robisie oraz cofnięto instalację ról (${manifest.entries.length} zmian).`);
+    if (backupNotice)
+        ctx.out(backupNotice);
+    if (leftovers.length > 0)
+        ctx.out(`Zostawiłem niepuste katalogi: ${leftovers.join(", ")}.`);
+    ctx.out("Następny krok: otwórz nowy terminal, żeby zmienna ROBISIE_KEY zniknęła z sesji.");
+    return 0;
+}

package/dist/constants.js

@@ -0,0 +1,34 @@
+/** Package identity and the server contract it speaks. */
+export const PACKAGE_NAME = "robisie";
+export const PACKAGE_VERSION = "0.1.0"; // x-release-please-version
+/**
+ * MAJOR of the agent-API contract this package understands.
+ * PARITY: src/lib/mcp/contract-version.ts (AGENT_API_CONTRACT_VERSION) on the server.
+ */
+export const SUPPORTED_CONTRACT_MAJOR = 1;
+export const DEFAULT_ORIGIN = "https://robisie.app";
+export const MCP_SERVER_NAME = "robisie";
+export const KEY_ENV = "ROBISIE_KEY";
+/**
+ * Local stdio helpers the client roles call (`mcp__client-launch-context__…`, `mcp__ceo-client-launcher__…`).
+ * Shipped in `helpers/` (verbatim copies of the repo's scripts/) and started as `npx -y robisie@<version> mcp <name>`.
+ */
+export const HELPER_SERVERS = ["client-launch-context", "ceo-client-launcher"];
+/** Environment the helpers read: credential, the Builder's card and the selected project directory. */
+export const HELPER_ENV = [KEY_ENV, "ROBISIE_CARD_REF", "ROBISIE_PROJECT_CONTEXT"];
+export function helperCommand(name) {
+    return { command: "npx", args: ["-y", `${PACKAGE_NAME}@${PACKAGE_VERSION}`, "mcp", name] };
+}
+export const KEY_PATTERN = /^rob_[0-9a-f]{64}$/;
+export const CONTRACT_VERSION_HEADER = "x-robisie-contract-version";
+/** Text markers delimiting what `init` wrote. `uninstall` removes only what sits between them. */
+export const MARK_BEGIN = ">>> robisie (zarządzane przez `npx robisie`, nie edytuj) >>>";
+export const MARK_END = "<<< robisie <<<";
+/** First-line marker of every role file `init` owns. */
+export const FILE_MARK = "robisie:managed";
+export function mcpUrl(origin) {
+    return `${origin}/api/mcp`;
+}
+export function wellKnownUrl(origin) {
+    return `${origin}/.well-known/mcp.json`;
+}

package/dist/context.js

@@ -0,0 +1,65 @@
+import { homedir } from "node:os";
+import { createInterface } from "node:readline";
+import { Writable } from "node:stream";
+import { DEFAULT_ORIGIN } from "./constants.js";
+/** A failure the client can act on: what happened + exactly one next step (both in Polish). */
+export class RobisieError extends Error {
+    nextStep;
+    constructor(message, nextStep) {
+        super(message);
+        this.nextStep = nextStep;
+        this.name = "RobisieError";
+    }
+}
+export function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** One POSIX shell word: single-quoted, each `'` written as `'\''` (paths like `/Users/O'Connor`). */
+export function shellQuote(value) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function hiddenPrompt(question) {
+    let muted = false;
+    const output = new Writable({
+        write(chunk, _encoding, callback) {
+            if (!muted)
+                process.stdout.write(chunk);
+            callback();
+        },
+    });
+    const rl = createInterface({ input: process.stdin, output, terminal: true });
+    return new Promise((resolve, reject) => {
+        rl.on("SIGINT", () => {
+            rl.close();
+            reject(new RobisieError("Przerwano.", "Uruchom ponownie `npx robisie init`."));
+        });
+        rl.question(question, (answer) => {
+            rl.close();
+            process.stdout.write("\n");
+            resolve(answer);
+        });
+        muted = true;
+    });
+}
+async function readAllStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+export function nodeCtx() {
+    const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+    return {
+        home: homedir(),
+        cwd: process.cwd(),
+        env: process.env,
+        platform: process.platform,
+        fetch: globalThis.fetch,
+        out: (line) => process.stdout.write(`${line}\n`),
+        err: (line) => process.stderr.write(`${line}\n`),
+        askSecret: interactive ? hiddenPrompt : null,
+        readStdin: process.stdin.isTTY ? null : readAllStdin,
+        origin: DEFAULT_ORIGIN,
+    };
+}