robisie 0.0.0-stage → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Historia zmian klienta / Client changelog
+
+## 0.1.0
+
+Kandydat pierwszego wydania, bez daty publikacji. / First release candidate, no publication date.
+
+- `init`, `doctor`, `uninstall` dla Claude Code, Codex CLI i OpenCode; role CEO, Builder i Quality Officer.
+- Pomocniki `client-launch-context` i `ceo-client-launcher` dostarczane w paczce, polecenia przypięte do wersji klienta.
+- Kontrakt serwera 1.x (obecnie 1.0.0); odmowa innego major przed zapisem konfiguracji.
+- Ochrona obcych ustawień i instrukcji, pierwsze kopie zapasowe oraz przywracanie własnych plików po uninstall; zmienione role pozostają z ostrzeżeniem.
+- Zapisywanie dostawcy dla każdej roli i diagnoza ograniczeń; bieżąca pętla wymaga jednego dostawcy dla wszystkich trzech ról.
+- Notatka PL/EN i lokalna próba reinstalacji 0.1.0 → syntetyczne 0.1.1 → 0.1.0; to nie rollback opublikowanych wydań.
+
+Pochodzenie klienta: [PR #209](https://github.com/chuppa12/robisie-app/pull/209),
+[merge a41b04ee7961f16e74dbf3a88b5a8199c5339f41](https://github.com/chuppa12/robisie-app/commit/a41b04ee7961f16e74dbf3a88b5a8199c5339f41),
+[ochrona kopii 5ec7cde32a926c593f46e5fb2c86c79fe31bf332](https://github.com/chuppa12/robisie-app/commit/5ec7cde32a926c593f46e5fb2c86c79fe31bf332),
+[bezpieczny zapis b15d73ff2f9f1f1b26de7041ec0623d69d37d347](https://github.com/chuppa12/robisie-app/commit/b15d73ff2f9f1f1b26de7041ec0623d69d37d347),
+[pomocniki i uninstall 36e7e39ed22339a29f851f08c9307d452554981f](https://github.com/chuppa12/robisie-app/commit/36e7e39ed22339a29f851f08c9307d452554981f).

package/README.md

@@ -1,3 +1,28 @@
-# Temporary Holding Version
+# robisie 0.1.0
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Przewodnik dla otrzymanego `robisie-0.1.0.tgz`: [PL — konto → odbiór → odinstalowanie](docs/README.md) · [EN — account → acceptance → uninstall](docs/README.en.md). Zacznij od wymagań, konta i klucza w przewodniku. Przygotuj Node.js 20+, npm, program jednego dostawcy AI oraz pusty katalog z tgz i README; strona i package.json nie są potrzebne. Projekt w panelu i katalog na dysku to osobne rzeczy; CEO wymaga dokładnie jednego projektu z discovery.
+
+Człowiek generuje klucz worker z etykietą w Connect i podaje go poza rozmową do ukrytego pytania init. W zsh/bash usuń stary ENV, a po udanym init wczytaj zapisany klucz do bieżącej powłoki bez wyświetlania go — init nie ustawia jej środowiska. Dla pierwszej próby Claude:
+
+```sh
+npm i ./robisie-0.1.0.tgz
+unset ROBISIE_KEY
+npx robisie init --agent claude --role ceo=claude --role builder=claude --role quality=claude
+[ -r "${XDG_CONFIG_HOME:-$HOME/.config}/robisie/key" ] && export ROBISIE_KEY="$(cat "${XDG_CONFIG_HOME:-$HOME/.config}/robisie/key")"
+npx robisie doctor
+```
+
+Dla Codex/OpenCode zastąp wszystkie cztery nazwy dostawcy. Sam --agent nie usuwa wcześniejszej mapy. Nowy terminal wymaga obsługi profilu zsh/bash bez --no-shell; w innych sesjach wczytaj środowisko zgodnie z przewodnikiem. Agenta uruchom z katalogu instalacji i sprawdź narzędzia obu pomocników: doctor startuje je przez node, agent przez npx; ROBISIE_PROJECT_CONTEXT nie zmienia cwd szukania paczki.
+
+Człowiek startuje CEO i ręcznie Buildera. Niezależną recenzję uruchamia CEO przez Agent; bez tego narzędzia w Codex/OpenCode praca pozostaje in_review i wymaga naprawy integracji przez CEO/CR. Worker nie ustawia done; człowiek odbiera wynik w panelu po dowodach i recenzji. Pełne polecenia, wynik pierwszej próby, naprawy, aktualizacja z tgz i uninstall są w PL/EN powyżej.
+
+Wybór i zmiana dostawcy ról:
+
+```sh
+npx robisie init --role ceo=claude --role builder=codex --role quality=opencode
+npx robisie init --role=builder=claude
+```
+
+Dostawcy: `claude`, `codex`, `opencode`; role: `ceo`, `builder`, `quality`. Mapa pozostaje po ponownym init; zmiana jednej roli zachowuje pozostałe. Każdy wskazany dostawca oraz `--agent` otrzymuje komplet ról, MCP i pomocników; poprzedni pozostaje do pełnego uninstall. Bez `--agent` init uwzględnia także wszystkich wykrytych dostawców, również nowo zainstalowanych przy ponownym uruchomieniu. Stary manifest z jednym dostawcą przypisuje mu trzy role; z wieloma zapisuje null. Init bez wyboru nadal działa; jawny wybór wymaga pełnej wynikowej mapy. Wadliwa mapa blokuje init, ale nie uninstall po entries.
+
+Doctor pokazuje mapę i sprawdza programy w PATH. Mieszane role oznaczają kod 1: Quality Officer działa jako podagent u dostawcy CEO, a polecenie Buildera ma format dostawcy CEO. Wykonanie mieszanych ról to następny zakres. Szczegóły i diagnoza są w przewodnikach PL/EN powyżej.

package/dist/agents.js

@@ -0,0 +1,185 @@
+import { accessSync, constants, existsSync, statSync } from "node:fs";
+import { delimiter, join } from "node:path";
+import { HELPER_ENV, HELPER_SERVERS, KEY_ENV, MCP_SERVER_NAME, helperCommand, mcpUrl } from "./constants.js";
+import { RobisieError } from "./context.js";
+import { renderClaudeAgent, renderCodexRole, renderOpenCodeAgent } from "./roles.js";
+export const AGENT_IDS = ["claude", "codex", "opencode"];
+export const AGENT_LABELS = { claude: "Claude Code", codex: "Codex CLI", opencode: "OpenCode" };
+const BINARIES = { claude: "claude", codex: "codex", opencode: "opencode" };
+export function isAgentId(value) {
+    return AGENT_IDS.includes(value);
+}
+/** Where each agent keeps its user-level configuration (the same places the agents themselves read). */
+export function agentPaths(ctx) {
+    const codexHome = ctx.env.CODEX_HOME || join(ctx.home, ".codex");
+    const configHome = ctx.env.XDG_CONFIG_HOME || join(ctx.home, ".config");
+    const opencodeDir = join(configHome, "opencode");
+    return {
+        // The package's own directory. Never ~/.robisie: on the owner's machine that belongs to the factory.
+        clientDir: join(configHome, "robisie"),
+        claudeDir: join(ctx.home, ".claude"),
+        claudeJson: join(ctx.home, ".claude.json"),
+        codexHome,
+        codexConfig: join(codexHome, "config.toml"),
+        codexAgentsMd: join(codexHome, "AGENTS.md"),
+        opencodeDir,
+        opencodeJson: join(opencodeDir, "opencode.json"),
+        opencodeJsonc: join(opencodeDir, "opencode.jsonc"),
+    };
+}
+export function agentOnPath(ctx, id) {
+    const binary = BINARIES[id];
+    const names = ctx.platform === "win32" ? [`${binary}.exe`, `${binary}.cmd`] : [binary];
+    for (const dir of (ctx.env.PATH ?? "").split(delimiter)) {
+        if (!dir)
+            continue;
+        for (const name of names) {
+            try {
+                const path = join(dir, name);
+                if (!statSync(path).isFile())
+                    continue;
+                accessSync(path, ctx.platform === "win32" ? constants.F_OK : constants.X_OK);
+                return true;
+            }
+            catch {
+                // not here — keep looking
+            }
+        }
+    }
+    return false;
+}
+/** Detection reads only the filesystem (config dir present, or binary on PATH) — nothing is executed. */
+export function detectAgents(ctx) {
+    const paths = agentPaths(ctx);
+    const dirs = { claude: paths.claudeDir, codex: paths.codexHome, opencode: paths.opencodeDir };
+    return AGENT_IDS.filter((id) => existsSync(dirs[id]) || agentOnPath(ctx, id));
+}
+/** Every server name init writes into `[mcp_servers]`. */
+const CODEX_SERVERS = [MCP_SERVER_NAME, ...HELPER_SERVERS].map((name) => name.replace(/[-]/g, "\\-")).join("|");
+const CODEX_SERVER_KEY = `(?:"(?:${CODEX_SERVERS})"|'(?:${CODEX_SERVERS})'|(?:${CODEX_SERVERS}))`;
+const TOML_ROBISIE_HEADER = new RegExp(`^\\s*\\[\\s*mcp_servers\\s*\\.\\s*${CODEX_SERVER_KEY}\\s*(?:\\.[^\\]]*)?\\]\\s*(?:#.*)?$`, "m");
+const TOML_ANY_HEADER = /^\s*\[/;
+const INLINE_TOP = new RegExp(`^\\s*mcp_servers\\s*\\.\\s*${CODEX_SERVER_KEY}\\s*[.=]`);
+const INLINE_IN_TABLE = new RegExp(`^\\s*${CODEX_SERVER_KEY}\\s*[.=]`);
+/** Keep a multiline string or array in its assignment, so its contents cannot look like server headers. */
+function tomlStatements(text) {
+    const lines = [];
+    let start = 0;
+    let depth = 0;
+    for (const token of text.matchAll(/"""(?:\\[\s\S]|(?!""")[^\\])*""""{0,2}|'''[\s\S]*?''''{0,2}|"(?:\\[^\r\n]|[^"\\\r\n])*"|'[^'\r\n]*'|#[^\r\n]*|[\s\S]/g)) {
+        const value = token[0];
+        if (value === "[" || value === "{")
+            depth += 1;
+        if (value === "]" || value === "}")
+            depth -= 1;
+        if (value === "\n" && depth === 0) {
+            lines.push(text.slice(start, token.index + 1));
+            start = token.index + 1;
+        }
+    }
+    if (start < text.length)
+        lines.push(text.slice(start));
+    return lines;
+}
+/**
+ * Take over an `[mcp_servers.robisie]` table written earlier by hand or by `codex mcp add` (otherwise
+ * Codex would see the table twice and refuse the whole config). Backups retain the old configuration.
+ */
+export function removeCodexTables(text, removeInline = false) {
+    const lines = tomlStatements(text);
+    const kept = [];
+    let inRobisie = false;
+    let table = "";
+    for (const line of lines) {
+        const header = /^\s*\[\s*([^\]]*?)\s*\]/.exec(line);
+        if (header)
+            table = (header[1] ?? "").replace(/\s+/g, "");
+        if (TOML_ANY_HEADER.test(line))
+            inRobisie = TOML_ROBISIE_HEADER.test(line);
+        if (inRobisie)
+            continue;
+        const inline = (table === "" && INLINE_TOP.test(line)) || (table === "mcp_servers" && INLINE_IN_TABLE.test(line));
+        if (!inline)
+            kept.push(line);
+        else if (!removeInline) {
+            throw new RobisieError("W ~/.codex/config.toml jest już serwer robisie zapisany w formie, której nie umiem bezpiecznie przejąć.", "Uruchom `codex mcp remove robisie`, potem ponownie `npx robisie init`.");
+        }
+    }
+    return kept.join("");
+}
+function codexHelperTable(name) {
+    const { command, args } = helperCommand(name);
+    return [
+        `[mcp_servers.${name}]`,
+        `command = "${command}"`,
+        `args = [${args.map((arg) => JSON.stringify(arg)).join(", ")}]`,
+        // Codex passes only a small default environment to stdio servers; the helpers need these three.
+        `env_vars = [${HELPER_ENV.map((name) => JSON.stringify(name)).join(", ")}]`,
+        "startup_timeout_sec = 60",
+    ].join("\n");
+}
+/** Every file change `init` makes for one agent. */
+export function planAgent(ctx, id, roles, key) {
+    const paths = agentPaths(ctx);
+    const url = mcpUrl(ctx.origin);
+    if (id === "claude") {
+        return [
+            // User scope (~/.claude.json, the file `claude mcp add -s user` writes): private, never committed.
+            { kind: "json", path: paths.claudeJson, keyPath: ["mcpServers", MCP_SERVER_NAME], value: { type: "http", url, headers: { Authorization: `Bearer ${key}` } }, private: true },
+            ...roles.map((role) => ({ kind: "file", path: join(paths.claudeDir, "agents", role.file), content: renderClaudeAgent(role) })),
+        ];
+    }
+    if (id === "codex") {
+        const roleFiles = roles.map((role) => ({ role, path: join(paths.clientDir, "roles", "codex", role.file) }));
+        return [
+            {
+                kind: "block",
+                path: paths.codexConfig,
+                comment: "hash",
+                body: [`[mcp_servers.${MCP_SERVER_NAME}]\nurl = "${url}"\nbearer_token_env_var = "${KEY_ENV}"`, ...HELPER_SERVERS.map(codexHelperTable)].join("\n\n"),
+                clean: removeCodexTables,
+            },
+            ...roleFiles.map(({ role, path }) => ({ kind: "file", path, content: renderCodexRole(role, roleFiles.find((r) => r.role.kind === "builder")?.path) })),
+            {
+                kind: "block",
+                path: paths.codexAgentsMd,
+                comment: "html",
+                body: [
+                    "## robisie — client roles",
+                    "",
+                    "robisie (https://robisie.app) installed three client roles. When the operator asks you to act as one of them, read that file in full and follow it as your operating contract for the whole session:",
+                    "",
+                    ...roleFiles.map(({ role, path }) => `- ${role.label}: \`${path}\``),
+                    "",
+                    "One role per session. Board tools come from the MCP server `robisie`; the credential is the `ROBISIE_KEY` environment variable.",
+                ].join("\n"),
+            },
+        ];
+    }
+    if (existsSync(paths.opencodeJsonc) && !existsSync(paths.opencodeJson)) {
+        throw new RobisieError(`OpenCode używa pliku ${paths.opencodeJsonc} (z komentarzami), którego nie zmieniam automatycznie.`, `Dodaj w nim pod "mcp" wpis "robisie": { "type": "remote", "url": "${url}", "headers": { "Authorization": "Bearer {env:${KEY_ENV}}" } } albo uruchom init z --agent bez opencode.`);
+    }
+    return [
+        { kind: "json", path: paths.opencodeJson, keyPath: ["mcp", MCP_SERVER_NAME], value: { type: "remote", url, enabled: true, headers: { Authorization: `Bearer {env:${KEY_ENV}}` } }, private: false },
+        ...HELPER_SERVERS.map((name) => {
+            const { command, args } = helperCommand(name);
+            // Env is forwarded explicitly (`{env:…}`), and the first `npx` start may download the package (default timeout 5 s).
+            const environment = Object.fromEntries(HELPER_ENV.map((env) => [env, `{env:${env}}`]));
+            return { kind: "json", path: paths.opencodeJson, keyPath: ["mcp", name], value: { type: "local", command: [command, ...args], enabled: true, environment, timeout: 60_000 }, private: false };
+        }),
+        ...roles.map((role) => ({ kind: "file", path: join(paths.opencodeDir, "agents", role.file), content: renderOpenCodeAgent(role) })),
+    ];
+}
+/** Shell profile line that exports ROBISIE_KEY from the package's key file (roles and Codex/OpenCode read it). */
+export function shellProfile(ctx) {
+    if (ctx.platform === "win32")
+        return null;
+    const shell = (ctx.env.SHELL ?? "").split("/").pop();
+    if (shell === "zsh")
+        return join(ctx.env.ZDOTDIR || ctx.home, ".zshrc");
+    if (shell === "bash")
+        return join(ctx.home, ctx.platform === "darwin" ? ".bash_profile" : ".bashrc");
+    return null;
+}
+const SHELL_KEY_PATH = '"${XDG_CONFIG_HOME:-$HOME/.config}/robisie/key"';
+export const SHELL_EXPORT = `[ -r ${SHELL_KEY_PATH} ] && export ${KEY_ENV}="$(cat ${SHELL_KEY_PATH})"`;

package/dist/cli.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+import { realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { AGENT_IDS, isAgentId } from "./agents.js";
+import { doctor, init, uninstall } from "./commands.js";
+import { HELPER_SERVERS, PACKAGE_VERSION } from "./constants.js";
+import { RobisieError, errorMessage, nodeCtx } from "./context.js";
+import { isHelperServer, runHelper } from "./helpers.js";
+import { ROLE_IDS, ROLE_STEP } from "./manifest.js";
+const HELP = `robisie ${PACKAGE_VERSION} — łączy Twojego agenta z tablicą robisie
+
+  npx robisie init        klucz rob_… (z ${"ROBISIE_KEY"} albo z pytania) + konfiguracja MCP + role klienta
+  npx robisie doctor      sprawdza połączenie, wersję kontraktu i role
+  npx robisie uninstall   usuwa wpisy robisie i role; zachowuje kopie zapasowe
+  npx robisie mcp <${HELPER_SERVERS.join("|")}>
+                          pomocnik ról (serwer MCP stdio) — uruchamia go agent, nie Ty
+
+Opcje init:
+  --agent <${AGENT_IDS.join("|")}>   wybrany dostawca (można powtórzyć albo podać po przecinku); razem z dostawcami mapy, bez --agent również wykryci
+  --role <rola=dostawca>           wybór ceo, builder, quality → claude, codex, opencode (można powtórzyć)
+  --role=rola=dostawca             ta sama składnia; np. --role=builder=codex zachowuje resztę mapy
+  --no-shell                      nie dopisuj ROBISIE_KEY do profilu powłoki
+  --key-stdin                     weź klucz z wejścia standardowego (np. printenv KLUCZ | npx robisie init --key-stdin)
+`;
+export function parseArgs(argv) {
+    const args = [...argv];
+    const command = args.shift() ?? "help";
+    const agents = [];
+    const roles = {};
+    let shell = true;
+    let keyStdin = false;
+    let target = null;
+    // Help wins over everything else, so `init --help` never starts an install.
+    if (args.includes("--help") || args.includes("-h"))
+        return { command, help: true, target, agents: null, roles, shell, keyStdin };
+    while (args.length > 0) {
+        const arg = args.shift();
+        if (arg === "--no-shell")
+            shell = false;
+        else if (arg === "--key-stdin")
+            keyStdin = true;
+        else if (arg === "--role" || arg.startsWith("--role=")) {
+            const value = arg === "--role" ? args.shift() ?? "" : arg.slice("--role=".length);
+            if (!value || value.startsWith("-"))
+                throw new RobisieError("Opcja --role wymaga przypisania rola=dostawca.", ROLE_STEP);
+            const [role, provider, extra] = value.split("=");
+            if (!ROLE_IDS.some((id) => id === role))
+                throw new RobisieError(`Nieznana rola „${role || "(pusta rola --role)"}”.`, ROLE_STEP);
+            if (extra !== undefined || !provider || !isAgentId(provider))
+                throw new RobisieError(`Niepoprawny dostawca „${provider ?? ""}” dla roli „${role}” (--role ${value}).`, ROLE_STEP);
+            const id = role;
+            if (roles[id] && roles[id] !== provider)
+                throw new RobisieError(`Sprzeczne przypisania roli „${role}”: ${roles[id]} i ${provider}.`, ROLE_STEP);
+            roles[id] = provider;
+        }
+        else if (arg === "--agent" || arg.startsWith("--agent=")) {
+            const value = arg === "--agent" ? args.shift() ?? "" : arg.slice("--agent=".length);
+            const ids = value.split(",").map((v) => v.trim());
+            // An empty value must not silently fall back to "every detected agent".
+            if (ids.some((id) => id === "") || value.startsWith("--")) {
+                throw new RobisieError("Opcja --agent wymaga nazwy agenta.", `Podaj np. \`--agent codex\` (dostępne: ${AGENT_IDS.join(", ")}) albo pomiń --agent, żeby użyć wykrytych.`);
+            }
+            for (const id of ids) {
+                if (!isAgentId(id))
+                    throw new RobisieError(`Nieznany agent „${id}”.`, `Użyj jednego z: ${AGENT_IDS.join(", ")}.`);
+                if (!agents.includes(id))
+                    agents.push(id);
+            }
+        }
+        else if (command === "mcp" && target === null && !arg.startsWith("-"))
+            target = arg;
+        else
+            throw new RobisieError(`Nieznana opcja „${arg}”.`, "Zobacz `npx robisie help`.");
+    }
+    return { command, help: false, target, agents: agents.length > 0 ? agents : null, roles, shell, keyStdin };
+}
+export async function run(argv, ctx) {
+    try {
+        const args = parseArgs(argv);
+        if (args.help) {
+            ctx.out(HELP);
+            return 0;
+        }
+        switch (args.command) {
+            case "init":
+                await init(ctx, { agents: args.agents, roles: args.roles, shell: args.shell, keyStdin: args.keyStdin });
+                return 0;
+            case "doctor":
+                return await doctor(ctx);
+            case "uninstall":
+                return uninstall(ctx);
+            case "mcp":
+                if (!args.target || !isHelperServer(args.target)) {
+                    throw new RobisieError(`Nieznany pomocnik „${args.target ?? ""}”.`, `Użyj jednego z: ${HELPER_SERVERS.join(", ")}.`);
+                }
+                return await runHelper(args.target);
+            case "--version":
+            case "version":
+                ctx.out(PACKAGE_VERSION);
+                return 0;
+            case "help":
+            case "--help":
+            case "-h":
+                ctx.out(HELP);
+                return 0;
+            default:
+                throw new RobisieError(`Nieznane polecenie „${args.command}”.`, "Zobacz `npx robisie help`.");
+        }
+    }
+    catch (error) {
+        if (error instanceof RobisieError) {
+            ctx.err(`✗ ${error.message}`);
+            ctx.err(`Następny krok: ${error.nextStep}`);
+        }
+        else {
+            ctx.err(`✗ Coś poszło nie tak: ${errorMessage(error)}`);
+            ctx.err("Następny krok: uruchom `npx robisie doctor`; jeśli błąd zostaje, napisz do robisie.");
+        }
+        return 1;
+    }
+}
+function isEntry() {
+    try {
+        return process.argv[1] !== undefined && realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
+    }
+    catch {
+        return false;
+    }
+}
+if (isEntry()) {
+    run(process.argv.slice(2), nodeCtx()).then((code) => {
+        process.exitCode = code;
+    }, (error) => {
+        process.stderr.write(`✗ ${errorMessage(error)}\n`);
+        process.exitCode = 1;
+    });
+}