kenaz 0.3.2 → 0.3.3

package/core/k-cli/dist/alaya/run.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.status = status;
+exports.register = register;
+const output_1 = require("../core/output");
+// TASK_2361: Alaya device registration without the Dashboard Google login.
+//
+// Flow (RFC 8628 style, relay contract documented in TASK_2361):
+//   POST {relay}/auth/device/start -> {device_code, user_code, verification_url, interval, expires_in}
+//   user opens verification_url in any browser and approves (Google login at the relay)
+//   POST {relay}/auth/device/poll {device_code} -> 202 pending | 200 {token} | 410 expired | 403 denied
+// The JWT is handed to the local kenaz-server, which runs the one existing
+// register-device implementation (hub_client::register_alaya_device).
+// The JWT is held in memory only: never printed, never written.
+const server = () => process.env.KENAZ_SERVER_URL || `http://127.0.0.1:${process.env.KENAZ_HTTP_PORT || "18080"}`;
+const relay = () => (process.env.KENAZ_RELAY_URL || "https://app.kenazai.com").replace(/\/+$/, "");
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const fail = (msg) => {
+    console.error(msg);
+    process.exit(1);
+};
+async function serverFetch(path, init) {
+    try {
+        return await fetch(`${server()}${path}`, init);
+    }
+    catch {
+        return fail(`Cannot reach kenaz-server at ${server()}. Start it first (kenaz-server or the Dashboard).`);
+    }
+}
+async function status(flags) {
+    const res = await serverFetch("/api/rust/alaya/status");
+    if (!res.ok)
+        fail(`kenaz-server returned ${res.status}`);
+    const s = (await res.json());
+    (0, output_1.output)(flags.json
+        ? s
+        : `Alaya: ${s.registered ? "registered" : "not registered"}; outbox depth: ${s.outbox_depth}` +
+            (s.registered ? "" : "\nRun: k-cli alaya register"), flags);
+}
+async function register(flags) {
+    const st = await serverFetch("/api/rust/alaya/status");
+    if (st.ok && (await st.json()).registered) {
+        (0, output_1.output)(flags.json ? { registered: true, already_registered: true } : "Alaya: already registered", flags);
+        return;
+    }
+    const start = await fetch(`${relay()}/auth/device/start`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: "{}",
+    }).catch((e) => fail(`Cannot reach relay ${relay()}: ${e.message}`));
+    if (start.status === 404) {
+        fail(`Relay ${relay()} has no device-code endpoint yet (POST /auth/device/start).\n` +
+            "Hub/relay change required; see TASK_2361 technical notes. Meanwhile, log in once via the Dashboard.");
+    }
+    if (!start.ok)
+        fail(`Relay device/start failed: HTTP ${start.status}`);
+    const d = (await start.json());
+    console.log(`Open ${d.verification_url} in any browser and enter code: ${d.user_code}`);
+    const deadline = Date.now() + (d.expires_in ?? 600) * 1000;
+    const intervalMs = Math.max(1, d.interval ?? 5) * 1000;
+    let token = "";
+    while (Date.now() < deadline) {
+        await sleep(intervalMs);
+        const p = await fetch(`${relay()}/auth/device/poll`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ device_code: d.device_code }),
+        }).catch(() => null);
+        if (!p || p.status === 202 || p.status === 428)
+            continue;
+        if (p.status === 403)
+            fail("Approval denied.");
+        if (p.status === 410)
+            fail("Code expired. Run the command again.");
+        if (!p.ok)
+            fail(`Relay device/poll failed: HTTP ${p.status}`);
+        token = (await p.json()).token ?? "";
+        break;
+    }
+    if (!token)
+        fail("Timed out waiting for approval.");
+    const r = await serverFetch("/api/rust/alaya/register", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ token }),
+    });
+    const res = (await r.json().catch(() => ({})));
+    if (!r.ok || !res.registered)
+        fail(`Registration failed: ${res.error ?? `HTTP ${r.status}`}`);
+    (0, output_1.output)(flags.json ? res : "Alaya: registered (~/.kenaz/alaya.toml written); queued reports will drain", flags);
+}

package/core/k-cli/dist/core/output.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatTable = formatTable;
+exports.output = output;
+function formatTable(headers, rows) {
+    const colWidths = headers.map((h, i) => {
+        const vals = [h, ...rows.map((r) => String(r[i] || ""))];
+        return Math.max(...vals.map((v) => v.length));
+    });
+    const sep = colWidths.map((w) => "-".repeat(w + 2)).join("+");
+    const line = (cells) => cells.map((c, i) => ` ${String(c).padEnd(colWidths[i])} `).join("|");
+    return [line(headers), sep, ...rows.map((r) => line(r))].join("\n");
+}
+function output(data, opts = {}) {
+    if (opts.json) {
+        console.log(JSON.stringify(data, null, 2));
+    }
+    else if (typeof data === "string") {
+        console.log(data);
+    }
+    else {
+        console.log(JSON.stringify(data, null, 2));
+    }
+}

package/core/k-cli/dist/core/process.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeProcess = nodeProcess;
+const child_process_1 = require("child_process");
+/**
+ * Spawn a process and return stdout.
+ * cmd defaults to node (process.execPath).
+ * shell defaults to false to avoid Windows arg escaping issues.
+ */
+function nodeProcess(args, cwd, timeout = 10000, cmd = process.execPath, shell = false) {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(cmd, args, {
+            cwd,
+            stdio: ["pipe", "pipe", "pipe"],
+            windowsHide: true,
+            shell,
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (d) => (stdout += d));
+        child.stderr.on("data", (d) => (stderr += d));
+        const timer = setTimeout(() => {
+            child.kill();
+            reject(new Error("timeout"));
+        }, timeout);
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            if (code !== 0)
+                reject(new Error(stderr || `exit code ${code}`));
+            else
+                resolve(stdout.trim());
+        });
+        child.on("error", (e) => {
+            clearTimeout(timer);
+            reject(e);
+        });
+    });
+}

package/core/k-cli/dist/core/project.js

@@ -0,0 +1,80 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveProject = resolveProject;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("yaml"));
+function resolveProject(explicitPath) {
+    const cwd = path.resolve(explicitPath || process.cwd());
+    const isCore = fs.existsSync(path.join(cwd, ".collaboration", "tasks"));
+    const kenazYaml = path.join(cwd, ".kenaz", "project.yaml");
+    const hasKenaz = fs.existsSync(kenazYaml);
+    // Read .kenaz/project.yaml if it exists
+    let config = null;
+    if (hasKenaz) {
+        const raw = fs.readFileSync(kenazYaml, "utf-8");
+        config = yaml.parse(raw);
+    }
+    // Core project (has .collaboration/tasks)
+    if (isCore) {
+        return {
+            mode: "core",
+            name: config?.project_name || path.basename(cwd),
+            path: cwd,
+            core_path: cwd,
+            config,
+        };
+    }
+    // Sub-project (has .kenaz/project.yaml but no .collaboration/tasks)
+    if (hasKenaz && config) {
+        const corePath = path.resolve(config.core_path || cwd);
+        return {
+            mode: "sub-project",
+            name: config.project_name || path.basename(cwd),
+            path: cwd,
+            core_path: corePath,
+            config,
+        };
+    }
+    // Unknown — no detection, no guessing
+    return {
+        mode: "unknown",
+        name: path.basename(cwd),
+        path: cwd,
+        core_path: cwd,
+        config: null,
+    };
+}

package/core/k-cli/dist/core/spawn.js

@@ -0,0 +1,268 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spawnClaude = spawnClaude;
+exports.collectClaudeOutput = collectClaudeOutput;
+exports.streamClaudeOutput = streamClaudeOutput;
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+/**
+ * Detect git-bash path on Windows.
+ * Claude Code requires git-bash to run on Windows.
+ */
+function detectGitBash() {
+    try {
+        const gitPaths = (0, child_process_1.execSync)("where git", { encoding: "utf8", timeout: 5000, windowsHide: true })
+            .split("\n").map((l) => l.trim()).filter(Boolean);
+        for (const gitPath of gitPaths) {
+            let dir = path.dirname(gitPath);
+            for (let i = 0; i < 4; i++) {
+                const bashPath = path.join(dir, "bin", "bash.exe");
+                if (fs.existsSync(bashPath))
+                    return bashPath;
+                dir = path.dirname(dir);
+            }
+        }
+    }
+    catch { }
+    const fallbacks = [
+        "C:\\Program Files\\Git\\bin\\bash.exe",
+        "C:\\Program Files (x86)\\Git\\bin\\bash.exe",
+        "D:\\Program Files\\Git\\bin\\bash.exe",
+    ];
+    for (const p of fallbacks) {
+        if (fs.existsSync(p))
+            return p;
+    }
+    return null;
+}
+/**
+ * Detect the claude CLI command path.
+ */
+function detectClaudeCmd() {
+    if (process.platform !== "win32")
+        return "claude";
+    try {
+        const result = (0, child_process_1.execSync)("where claude", { encoding: "utf8", timeout: 5000, windowsHide: true })
+            .split("\n").map((l) => l.trim()).filter(Boolean);
+        if (result.length > 0) {
+            return result.find((p) => p.endsWith(".cmd")) || result[0];
+        }
+    }
+    catch { }
+    const homedir = process.env.USERPROFILE || process.env.HOME || "";
+    const candidates = [
+        path.join(homedir, ".claude", "local", "claude.exe"),
+        path.join(homedir, ".claude", "bin", "claude.exe"),
+    ];
+    for (const p of candidates) {
+        if (fs.existsSync(p))
+            return p;
+    }
+    return "claude.cmd";
+}
+/**
+ * Build a clean env for Claude subprocesses.
+ * Mirrors .formation/tools/utils.js getClaudeEnv()
+ */
+function getClaudeEnv() {
+    const env = { ...process.env };
+    // Remove CLAUDECODE to avoid nested session error
+    delete env.CLAUDECODE;
+    // Windows: ensure git-bash path is set
+    if (process.platform === "win32" && !env.CLAUDE_CODE_GIT_BASH_PATH) {
+        const gitBash = detectGitBash();
+        if (gitBash)
+            env.CLAUDE_CODE_GIT_BASH_PATH = gitBash;
+    }
+    return env;
+}
+/**
+ * Spawn a Claude CLI subprocess.
+ *
+ * Returns the ChildProcess. Caller is responsible for
+ * listening on stdout/stderr/close events.
+ */
+function spawnClaude(opts) {
+    const { prompt, cwd, allowedTools = "Bash,Read,Edit,Write,Glob,Grep", disallowedTools, extraArgs = [], projectPath = null, } = opts;
+    const claudeCmd = detectClaudeCmd();
+    const args = [
+        "-p", "-",
+        "--dangerously-skip-permissions",
+        "--output-format", "stream-json",
+        "--verbose",
+        "--allowedTools", allowedTools,
+        ...(disallowedTools ? ["--disallowedTools", disallowedTools] : []),
+        ...extraArgs,
+    ];
+    const env = getClaudeEnv();
+    // Sub-project git isolation
+    if (projectPath && projectPath !== cwd) {
+        const parentDir = path.dirname(projectPath);
+        env.GIT_CEILING_DIRECTORIES = parentDir;
+    }
+    const child = (0, child_process_1.spawn)(claudeCmd, args, {
+        cwd: projectPath || cwd,
+        env,
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true,
+        shell: true,
+    });
+    child.stdin.write(prompt, "utf8");
+    child.stdin.end();
+    return child;
+}
+/**
+ * Format a tool_use block into a concise one-liner.
+ */
+function formatToolUse(block) {
+    const name = block.name || "unknown";
+    const input = block.input || {};
+    // Extract the most relevant field for each tool type
+    if (name === "Bash" && input.command) {
+        const cmd = String(input.command);
+        const short = cmd.length > 120 ? cmd.slice(0, 120) + "..." : cmd;
+        return `[${name}] ${short}`;
+    }
+    if ((name === "Read" || name === "Write") && input.file_path) {
+        return `[${name}] ${input.file_path}`;
+    }
+    if (name === "Edit" && input.file_path) {
+        return `[${name}] ${input.file_path}`;
+    }
+    if ((name === "Glob" || name === "Grep") && input.pattern) {
+        return `[${name}] ${input.pattern}`;
+    }
+    // Fallback: tool name + first string value
+    const firstVal = Object.values(input).find((v) => typeof v === "string");
+    return firstVal ? `[${name}] ${String(firstVal).slice(0, 80)}` : `[${name}]`;
+}
+/**
+ * Collect Claude stream-json stdout as a string (no console output).
+ * Used when the caller needs to parse the result programmatically.
+ */
+function collectClaudeOutput(child) {
+    return new Promise((resolve, reject) => {
+        let stderr = "";
+        let result = "";
+        child.stdout.on("data", (d) => {
+            const lines = d.toString().split("\n").filter((l) => l.trim());
+            for (const line of lines) {
+                try {
+                    const evt = JSON.parse(line);
+                    if (evt.type === "assistant" && evt.message?.content) {
+                        for (const block of evt.message.content) {
+                            if (block.type === "text" && block.text) {
+                                result += block.text;
+                            }
+                        }
+                    }
+                    else if (evt.type === "result" && typeof evt.result === "string") {
+                        result += evt.result;
+                    }
+                }
+                catch {
+                    // not JSON — skip
+                }
+            }
+        });
+        child.stderr.on("data", (d) => (stderr += d));
+        child.on("close", (code) => {
+            if (code !== 0) {
+                reject(new Error(`Claude exited with code ${code}${stderr ? `: ${stderr.slice(0, 500)}` : ""}`));
+                return;
+            }
+            resolve(result);
+        });
+        child.on("error", (e) => reject(e));
+    });
+}
+/**
+ * Parse Claude stream-json stdout and output formatted content.
+ * - text blocks: output as-is
+ * - tool_use blocks: formatted one-liner showing what the agent is doing
+ * - thinking, raw JSON: filtered out
+ */
+function streamClaudeOutput(child) {
+    return new Promise((resolve, reject) => {
+        let stderr = "";
+        let hasOutput = false;
+        child.stdout.on("data", (d) => {
+            const lines = d.toString().split("\n").filter((l) => l.trim());
+            for (const line of lines) {
+                try {
+                    const evt = JSON.parse(line);
+                    if (evt.type === "assistant" && evt.message?.content) {
+                        for (const block of evt.message.content) {
+                            if (block.type === "text" && block.text) {
+                                hasOutput = true;
+                                process.stdout.write(block.text);
+                            }
+                            else if (block.type === "tool_use") {
+                                hasOutput = true;
+                                console.log(formatToolUse(block));
+                            }
+                        }
+                    }
+                    else if (evt.type === "result" && evt.result) {
+                        hasOutput = true;
+                        console.log(evt.result);
+                    }
+                }
+                catch {
+                    // not JSON — skip
+                }
+            }
+        });
+        child.stderr.on("data", (d) => (stderr += d));
+        child.on("close", (code) => {
+            if (code !== 0) {
+                console.error(`\nError: Claude exited with code ${code}`);
+                if (stderr)
+                    console.error(stderr);
+                process.exit(1);
+            }
+            if (!hasOutput) {
+                console.error("\nWarning: Claude exited successfully but produced no output.", "\nThis may indicate nested session detection.", stderr ? `\nStderr: ${stderr.slice(0, 500)}` : "");
+            }
+            resolve();
+        });
+        child.on("error", (e) => {
+            console.error(`Error spawning Claude: ${e.message}`);
+            reject(e);
+        });
+    });
+}

package/core/k-cli/dist/core/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/k-cli/dist/dashboard/update.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const output_1 = require("../core/output");
+const DASHBOARD_BASE = `http://127.0.0.1:${process.env.KENAZ_HTTP_PORT || "18080"}`;
+async function run(flags) {
+    try {
+        // Step 1: Check for updates
+        const checkRes = await fetch(`${DASHBOARD_BASE}/api/dashboard/update/check`, { method: "POST" });
+        if (!checkRes.ok) {
+            console.error(`Dashboard returned ${checkRes.status}`);
+            process.exit(1);
+        }
+        const result = (await checkRes.json());
+        if (result.status === "up_to_date") {
+            (0, output_1.output)(flags.json
+                ? result
+                : `Already up to date (v${result.current_version})`, flags);
+            return;
+        }
+        if (result.status === "error") {
+            console.error(`Update check failed: ${result.message}`);
+            process.exit(1);
+        }
+        // Update available
+        const info = result.update;
+        console.log(`Update available: v${info.current_version} → v${info.version}`);
+        if (info.body) {
+            console.log(`\nRelease notes:\n${info.body}\n`);
+        }
+        if (!flags.force) {
+            (0, output_1.output)(flags.json
+                ? result
+                : 'Run with --force to install, or use Dashboard UI.', flags);
+            return;
+        }
+        // Step 2: Install
+        console.log("Installing update...");
+        const installRes = await fetch(`${DASHBOARD_BASE}/api/dashboard/update/install`, { method: "POST" });
+        if (!installRes.ok) {
+            console.error(`Install request failed: ${installRes.status}`);
+            process.exit(1);
+        }
+        const installResult = (await installRes.json());
+        (0, output_1.output)(flags.json
+            ? installResult
+            : `${installResult.message}`, flags);
+    }
+    catch {
+        console.error("Cannot reach Dashboard. Is it running? (default port: 18080)");
+        process.exit(1);
+    }
+}

package/core/k-cli/dist/dashboard/version.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const output_1 = require("../core/output");
+const DASHBOARD_BASE = `http://127.0.0.1:${process.env.KENAZ_HTTP_PORT || "18080"}`;
+async function run(flags) {
+    try {
+        const res = await fetch(`${DASHBOARD_BASE}/api/dashboard/version`);
+        if (!res.ok) {
+            console.error(`Dashboard returned ${res.status}`);
+            process.exit(1);
+        }
+        const payload = (await res.json());
+        (0, output_1.output)(flags.json ? payload : `Dashboard v${payload.version}`, flags);
+    }
+    catch {
+        console.error("Cannot reach Dashboard. Is it running? (default port: 18080)");
+        process.exit(1);
+    }
+}