@suwujs/king-ai 0.2.0

package/dist/src/config.d.ts

@@ -0,0 +1,3 @@
+import type { ComputerConfig } from "./types.js";
+export declare function loadConfig(): Promise<ComputerConfig | null>;
+export declare function saveConfig(config: ComputerConfig): Promise<void>;

package/dist/src/config.js

@@ -0,0 +1,20 @@
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import { CONFIG_DIR, CONFIG_PATH, LEGACY_CONFIG_PATH } from "./paths.js";
+export async function loadConfig() {
+    try {
+        return JSON.parse(await readFile(CONFIG_PATH, "utf8"));
+    }
+    catch {
+        try {
+            return JSON.parse(await readFile(LEGACY_CONFIG_PATH, "utf8"));
+        }
+        catch {
+            return null;
+        }
+    }
+}
+export async function saveConfig(config) {
+    await mkdir(CONFIG_DIR, { recursive: true });
+    await writeFile(CONFIG_PATH, JSON.stringify(config, null, 2), "utf8");
+    await chmod(CONFIG_PATH, 0o600);
+}

package/dist/src/cron.d.ts

@@ -0,0 +1,11 @@
+export interface ParsedCron {
+    minutes: Set<number>;
+    hours: Set<number>;
+    daysOfMonth: Set<number>;
+    months: Set<number>;
+    daysOfWeek: Set<number>;
+}
+export declare function parseCron(expression: string): ParsedCron;
+export declare function parseCronField(field: string, min: number, max: number): Set<number>;
+export declare function matchesCron(schedule: ParsedCron, date: Date): boolean;
+export declare function cronMatches(expression: string, date?: Date): boolean;

package/dist/src/cron.js

@@ -0,0 +1,65 @@
+export function parseCron(expression) {
+    const parts = expression.trim().split(/\s+/);
+    if (parts.length !== 5) {
+        throw new Error(`Invalid cron expression "${expression}": expected 5 fields, got ${parts.length}`);
+    }
+    return {
+        minutes: parseCronField(parts[0] ?? "", 0, 59),
+        hours: parseCronField(parts[1] ?? "", 0, 23),
+        daysOfMonth: parseCronField(parts[2] ?? "", 1, 31),
+        months: parseCronField(parts[3] ?? "", 1, 12),
+        daysOfWeek: parseCronField(parts[4] ?? "", 0, 6)
+    };
+}
+export function parseCronField(field, min, max) {
+    const values = new Set();
+    for (const part of field.split(",")) {
+        if (!part)
+            throw new Error("Invalid empty cron field part");
+        addCronPart(values, part, min, max);
+    }
+    return values;
+}
+function addCronPart(values, part, min, max) {
+    const [rangePart = "", stepPart] = part.split("/");
+    const step = stepPart == null ? 1 : Number.parseInt(stepPart, 10);
+    if (!Number.isInteger(step) || step <= 0)
+        throw new Error(`Invalid step in cron field: "${part}"`);
+    let start = min;
+    let end = max;
+    if (rangePart !== "*") {
+        if (rangePart.includes("-")) {
+            const [rawStart, rawEnd] = rangePart.split("-");
+            start = parseCronNumber(rawStart, min, max, part);
+            end = parseCronNumber(rawEnd, min, max, part);
+            if (start > end)
+                throw new Error(`Invalid range in cron field: "${part}"`);
+        }
+        else {
+            start = parseCronNumber(rangePart, min, max, part);
+            end = stepPart == null ? start : max;
+        }
+    }
+    for (let value = start; value <= end; value += step) {
+        if (value < min || value > max)
+            throw new Error(`Invalid value in cron field: "${part}" (valid range: ${min}-${max})`);
+        values.add(value);
+    }
+}
+function parseCronNumber(value, min, max, part) {
+    const parsed = Number.parseInt(value ?? "", 10);
+    if (!Number.isInteger(parsed) || parsed < min || parsed > max) {
+        throw new Error(`Invalid value in cron field: "${part}" (valid range: ${min}-${max})`);
+    }
+    return parsed;
+}
+export function matchesCron(schedule, date) {
+    return (schedule.minutes.has(date.getMinutes()) &&
+        schedule.hours.has(date.getHours()) &&
+        schedule.daysOfMonth.has(date.getDate()) &&
+        schedule.months.has(date.getMonth() + 1) &&
+        schedule.daysOfWeek.has(date.getDay()));
+}
+export function cronMatches(expression, date = new Date()) {
+    return matchesCron(parseCron(expression), date);
+}

package/dist/src/daemon.d.ts

@@ -0,0 +1,36 @@
+import type { EngineId } from "./types.js";
+export declare function anyRunnerBusy(runners: Iterable<{
+    isBusy: boolean;
+}>): boolean;
+export declare function shouldExitForUpdate(args: {
+    updateReady: boolean;
+    shuttingDown: boolean;
+    anyBusy: boolean;
+}): boolean;
+export declare function installProcessErrorLogging(): void;
+export declare function resolveHostName(base: string | undefined | null, platform: NodeJS.Platform, platformNames?: string[]): string;
+export declare function detectHostName(): Promise<string>;
+export declare function missingEngineMessage(): string;
+export interface PairLocator {
+    code: string;
+    serverUrl?: string;
+    tenantId?: string;
+}
+export declare function parsePairLocator(value: string): PairLocator;
+export interface DoctorProbe {
+    ok: boolean;
+    detail?: string;
+}
+export interface DoctorResult {
+    id: EngineId;
+    installed: boolean;
+    path?: string;
+    big?: DoctorProbe;
+    small?: DoctorProbe;
+}
+export declare function doctorExitCode(results: DoctorResult[]): number;
+export declare function formatDoctorReport(results: DoctorResult[], version?: string): string;
+export declare function collectDoctorResults(): Promise<DoctorResult[]>;
+export declare function doPair(code: string, serverUrl: string, preferredEngine?: EngineId, tenantId?: string): Promise<void>;
+export declare function runDoctor(): Promise<void>;
+export declare function doRun(serverOverride?: string, tenantOverride?: string): Promise<void>;

package/dist/src/daemon.js

@@ -0,0 +1,373 @@
+import { hostname } from "node:os";
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { execFile } from "node:child_process";
+import { api, tenantHeader } from "./api.js";
+import { loadConfig, saveConfig } from "./config.js";
+import { detectEngines, getAdapter } from "./engine.js";
+import { CURRENT_VERSION, HEARTBEAT_PATH } from "./paths.js";
+import { checkForUpdate, recordRunningState, rotateLogsIfNeeded, writeRunningState } from "./service.js";
+import { AgentRunner } from "./runner.js";
+import { engineInstallAdvice, engineRemediationAdvice, formatRemediationBlock } from "./remediation.js";
+import { detectLocalCapabilities } from "./workspace.js";
+import { normalizeAgentLifecycle, shouldHostAgent } from "./lifecycle.js";
+import { FileHeartbeat } from "./heartbeat.js";
+import { validateAgentConfig } from "./agent-config-validation.js";
+const AGENT_POLL_MS = Number(process.env.KING_AI_AGENT_POLL_MS) || 5_000;
+const HEARTBEAT_MS = Number(process.env.KING_AI_HEARTBEAT_MS) || 30_000;
+const SHUTDOWN_GRACE_MS = Number(process.env.KING_AI_SHUTDOWN_GRACE_MS) || 15_000;
+const UPDATE_CHECK_MS = Number(process.env.KING_AI_UPDATE_CHECK_MS) || 6 * 60 * 60 * 1000;
+const IDLE_UPDATE_CHECK_MS = Number(process.env.KING_AI_IDLE_UPDATE_CHECK_MS) || 30_000;
+const LOG_ROTATE_MS = Number(process.env.KING_AI_LOG_ROTATE_MS) || 5 * 60 * 1000;
+const SUPERVISED = process.env.KING_AI_SUPERVISED === "1";
+const execFileP = promisify(execFile);
+export function anyRunnerBusy(runners) {
+    for (const runner of runners) {
+        if (runner.isBusy)
+            return true;
+    }
+    return false;
+}
+export function shouldExitForUpdate(args) {
+    return args.updateReady && !args.shuttingDown && !args.anyBusy;
+}
+export function installProcessErrorLogging() {
+    process.on("unhandledRejection", (reason) => {
+        console.error("[king-ai] unhandledRejection (kept alive):", reason instanceof Error ? reason.stack || reason.message : reason);
+    });
+    process.on("uncaughtException", (err) => {
+        console.error("[king-ai] uncaughtException (kept alive):", err instanceof Error ? err.stack || err.message : err);
+    });
+}
+export function resolveHostName(base, platform, platformNames = []) {
+    if (base && base.toLowerCase() !== "localhost")
+        return base;
+    if (platform === "darwin") {
+        const found = platformNames.map((name) => name.trim()).find(Boolean);
+        if (found)
+            return found;
+    }
+    return base || "My computer";
+}
+export async function detectHostName() {
+    const base = hostname();
+    const platformNames = [];
+    if (process.platform === "darwin") {
+        for (const key of ["ComputerName", "LocalHostName"]) {
+            try {
+                const { stdout } = await execFileP("scutil", ["--get", key]);
+                platformNames.push(stdout);
+            }
+            catch {
+                // Keep fallback behavior portable.
+            }
+        }
+    }
+    return resolveHostName(base, process.platform, platformNames);
+}
+export function missingEngineMessage() {
+    return [
+        "no supported local agent engine found on PATH",
+        "",
+        "Install and sign in to at least one of:",
+        "  - Claude Code: install the `claude` CLI, then run `claude` once to sign in",
+        "  - Codex: install the `codex` CLI, then run `codex` once to sign in",
+        "",
+        "After that, rerun:",
+        "  king-ai agent computer --pair <code>"
+    ].join("\n");
+}
+export function parsePairLocator(value) {
+    const trimmed = value.trim();
+    if (!trimmed.startsWith("king-ai://pair?"))
+        return { code: trimmed };
+    const url = new URL(trimmed);
+    const code = url.searchParams.get("code")?.trim();
+    const serverUrl = url.searchParams.get("server")?.trim().replace(/\/+$/, "");
+    const tenantId = url.searchParams.get("tenant")?.trim() || undefined;
+    if (!code)
+        throw new Error("pair locator is missing code");
+    if (serverUrl)
+        new URL(serverUrl);
+    return { code, serverUrl: serverUrl || undefined, tenantId };
+}
+export function doctorExitCode(results) {
+    return results.some((result) => result.big?.ok && result.small?.ok) ? 0 : 1;
+}
+export function formatDoctorReport(results, version = CURRENT_VERSION) {
+    const lines = [
+        `king-ai ${version} engine doctor`,
+        "probing local engines (big brain = main reasoning, small brain = triage cerebellum)...",
+        ""
+    ];
+    let anyUsable = false;
+    for (const result of results) {
+        if (!result.installed) {
+            lines.push(`x ${result.id} - not found on PATH`);
+            for (const line of formatRemediationBlock(engineInstallAdvice(result.id)).split("\n"))
+                lines.push(`    ${line}`);
+            lines.push("");
+            continue;
+        }
+        lines.push(`o ${result.id} - ${result.path ?? "on PATH"}`);
+        for (const [label, probe] of [
+            ["big brain  ", result.big],
+            ["small brain", result.small]
+        ]) {
+            if (!probe)
+                continue;
+            if (probe.ok) {
+                lines.push(`    ok ${label}`);
+            }
+            else {
+                const detail = probe.detail ?? "unknown failure";
+                lines.push(`    x  ${label} FAILED: ${detail}`);
+                for (const line of formatRemediationBlock(engineRemediationAdvice(result.id, detail)).split("\n"))
+                    lines.push(`       ${line}`);
+            }
+        }
+        if (result.big?.ok && result.small?.ok)
+            anyUsable = true;
+        lines.push("");
+    }
+    if (!anyUsable) {
+        lines.push("x no engine has BOTH brains healthy - this machine cannot currently run a BYOA agent.");
+        lines.push("  Fix one engine above, then re-run: king-ai agent computer --doctor");
+    }
+    return lines.join("\n").trimEnd();
+}
+export async function collectDoctorResults() {
+    const engines = await detectEngines();
+    const results = [];
+    for (const id of ["claude", "codex"]) {
+        if (!engines.includes(id)) {
+            results.push({ id, installed: false });
+            continue;
+        }
+        const adapter = getAdapter(id);
+        const cwd = await mkdtemp(join(tmpdir(), "king-doctor-"));
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 60_000);
+        try {
+            const big = await adapter.probe({ cwd, env: process.env, tier: "big", signal: controller.signal });
+            const small = await adapter.probe({ cwd, env: process.env, tier: "small", signal: controller.signal });
+            results.push({
+                id,
+                installed: true,
+                path: adapter.bin,
+                big: { ok: !big.error, detail: big.error },
+                small: { ok: !small.error, detail: small.error }
+            });
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    return results;
+}
+export async function doPair(code, serverUrl, preferredEngine, tenantId) {
+    const locator = parsePairLocator(code);
+    const resolvedServerUrl = locator.serverUrl ?? serverUrl;
+    const resolvedTenantId = locator.tenantId ?? tenantId;
+    const detected = await detectEngines();
+    if (detected.length === 0)
+        throw new Error(missingEngineMessage());
+    const engines = preferredEngine ? [preferredEngine, ...detected.filter((id) => id !== preferredEngine)] : detected;
+    if (preferredEngine && !detected.includes(preferredEngine)) {
+        throw new Error(`--engine ${preferredEngine} chosen, but ${preferredEngine} is not installed on this machine. Installed: ${detected.join(", ") || "none"}.`);
+    }
+    const paired = await api(resolvedServerUrl, "/api/computers/pair", {
+        method: "POST",
+        headers: tenantHeader(resolvedTenantId),
+        body: JSON.stringify({ code: locator.code, hostName: await detectHostName(), engines, version: CURRENT_VERSION, capabilities: detectLocalCapabilities() })
+    });
+    const savedTenantId = paired.tenantId ?? resolvedTenantId;
+    await saveConfig({ serverUrl: resolvedServerUrl, computerId: paired.computerId, deviceToken: paired.deviceToken, ...(savedTenantId ? { tenantId: savedTenantId } : {}) });
+    console.log(`paired as ${paired.computerId}${savedTenantId ? ` tenant=${savedTenantId}` : ""}; default engine: ${engines[0] ?? "none"}; available engines: ${engines.join(", ") || "none"}`);
+}
+export async function runDoctor() {
+    const results = await collectDoctorResults();
+    console.log(formatDoctorReport(results));
+    if (doctorExitCode(results) !== 0)
+        process.exitCode = 1;
+}
+export async function doRun(serverOverride, tenantOverride) {
+    installProcessErrorLogging();
+    const cfg = await loadConfig();
+    if (!cfg)
+        throw new Error("not paired. Run: king-ai agent computer --pair <code> --server <url>");
+    const runtimeCfg = { ...cfg, serverUrl: serverOverride ?? cfg.serverUrl, tenantId: tenantOverride ?? cfg.tenantId };
+    const available = await detectEngines();
+    if (available.length === 0)
+        throw new Error(missingEngineMessage());
+    console.log(`king-ai ${CURRENT_VERSION} starting ${runtimeCfg.computerId} @ ${runtimeCfg.serverUrl}`);
+    const fileHeartbeat = new FileHeartbeat(HEARTBEAT_PATH, {
+        pid: process.pid,
+        runId: `${runtimeCfg.computerId}-${Date.now()}`,
+        version: CURRENT_VERSION,
+        computerId: runtimeCfg.computerId,
+        serverUrl: runtimeCfg.serverUrl
+    });
+    fileHeartbeat.write();
+    const capabilities = detectLocalCapabilities();
+    await writeRunningState({
+        serverUrl: runtimeCfg.serverUrl,
+        computerId: runtimeCfg.computerId,
+        capabilities,
+        agents: [],
+        event: { at: new Date().toISOString(), kind: "daemon.started", detail: `${runtimeCfg.computerId} @ ${runtimeCfg.serverUrl}` }
+    });
+    await rotateLogsIfNeeded();
+    const runners = new Map();
+    const publishRunningAgents = (extra = []) => {
+        recordRunningState({
+            capabilities: detectLocalCapabilities(),
+            agents: [
+                ...[...runners.values()].map((runner) => runner.runningState()),
+                ...extra
+            ]
+        });
+    };
+    const sync = async () => {
+        let agents;
+        try {
+            agents = await api(runtimeCfg.serverUrl, "/api/computers/me/agents", {
+                headers: { Authorization: `Bearer ${runtimeCfg.deviceToken}`, ...tenantHeader(runtimeCfg.tenantId) }
+            });
+        }
+        catch (err) {
+            console.warn(`agent sync failed: ${err instanceof Error ? err.message : String(err)}`);
+            return;
+        }
+        const disabledAgents = [];
+        for (const agent of agents) {
+            const lifecycle = normalizeAgentLifecycle(agent.lifecycle);
+            if (!shouldHostAgent(lifecycle)) {
+                const existing = runners.get(agent.id);
+                if (existing) {
+                    existing.stop();
+                    runners.delete(agent.id);
+                }
+                disabledAgents.push({ ...agent, lifecycle });
+                recordRunningState({
+                    event: { at: new Date().toISOString(), kind: "agent.disabled", detail: agent.id }
+                });
+                continue;
+            }
+            const engine = agent.engine && available.includes(agent.engine) ? agent.engine : available[0];
+            const existing = runners.get(agent.id);
+            if (existing?.configMatches(agent, engine))
+                continue;
+            existing?.stop();
+            const runner = new AgentRunner(runtimeCfg, { ...agent, lifecycle }, engine, available, () => publishRunningAgents());
+            runners.set(agent.id, runner);
+            console.log(`hosting ${agent.name} (${agent.id}) on ${engine} lifecycle=${lifecycle}`);
+            recordRunningState({
+                event: { at: new Date().toISOString(), kind: "agent.hosting", detail: `${agent.id} on ${engine} lifecycle=${lifecycle}` }
+            });
+            await runner.start();
+        }
+        const live = new Set(agents.filter((a) => shouldHostAgent(normalizeAgentLifecycle(a.lifecycle))).map((a) => a.id));
+        for (const [id, runner] of runners) {
+            if (!live.has(id)) {
+                runner.stop();
+                runners.delete(id);
+                recordRunningState({
+                    event: { at: new Date().toISOString(), kind: "agent.removed", detail: id }
+                });
+            }
+        }
+        publishRunningAgents(disabledAgents.map((agent) => ({
+            id: agent.id,
+            name: agent.name,
+            engine: agent.engine ?? "disabled",
+            lifecycle: "disabled",
+            status: "disabled",
+            configWarnings: validateAgentConfig(agent, agent.engine ?? "disabled", available),
+            updatedAt: new Date().toISOString()
+        })));
+        recordRunningState({
+            lastSyncAt: new Date().toISOString()
+        });
+    };
+    const heartbeat = () => {
+        const at = new Date().toISOString();
+        const capabilities = detectLocalCapabilities();
+        return fetch(`${runtimeCfg.serverUrl}/api/computers/heartbeat`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", Authorization: `Bearer ${runtimeCfg.deviceToken}`, ...tenantHeader(runtimeCfg.tenantId) },
+            body: JSON.stringify({ version: CURRENT_VERSION, capabilities })
+        }).then(() => {
+            fileHeartbeat.tick();
+            recordRunningState({ lastHeartbeatAt: at, capabilities });
+        }).catch(() => {
+            fileHeartbeat.tick();
+            recordRunningState({ event: { at, kind: "heartbeat.failed", detail: runtimeCfg.serverUrl } });
+        });
+    };
+    await heartbeat();
+    await sync();
+    const syncTimer = setInterval(() => void sync(), AGENT_POLL_MS);
+    const heartbeatTimer = setInterval(() => void heartbeat(), HEARTBEAT_MS);
+    const logRotateTimer = setInterval(() => void rotateLogsIfNeeded(), LOG_ROTATE_MS);
+    logRotateTimer.unref?.();
+    let updateTimer = null;
+    let idleUpdateTimer = null;
+    let updateReady = false;
+    let shuttingDown = false;
+    const shutdown = async (why) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        clearInterval(syncTimer);
+        clearInterval(heartbeatTimer);
+        clearInterval(logRotateTimer);
+        if (updateTimer)
+            clearInterval(updateTimer);
+        if (idleUpdateTimer)
+            clearInterval(idleUpdateTimer);
+        for (const runner of runners.values())
+            runner.beginStop();
+        const deadline = Date.now() + SHUTDOWN_GRACE_MS;
+        if (anyRunnerBusy(runners.values())) {
+            console.log(`${why}: waiting up to ${Math.round(SHUTDOWN_GRACE_MS / 1000)}s for in-flight turn(s) to finish`);
+        }
+        while (anyRunnerBusy(runners.values()) && Date.now() < deadline) {
+            await new Promise((resolve) => setTimeout(resolve, 500));
+        }
+        for (const runner of runners.values())
+            runner.stop();
+        console.log(`shutting down (${why})`);
+        process.exit(0);
+    };
+    const exitForUpdateWhenIdle = () => {
+        if (!shouldExitForUpdate({ updateReady, shuttingDown, anyBusy: anyRunnerBusy(runners.values()) }))
+            return;
+        void shutdown("auto-update");
+    };
+    const runUpdateCheck = () => {
+        void checkForUpdate().then((latest) => {
+            if (!latest)
+                return;
+            if (SUPERVISED) {
+                if (!updateReady) {
+                    updateReady = true;
+                    console.log(`king-ai ${latest} available; will restart when idle`);
+                }
+                exitForUpdateWhenIdle();
+            }
+            else {
+                console.log(`king-ai ${latest} available. Restart to update, or install the background service for automatic restarts.`);
+            }
+        });
+    };
+    updateTimer = setInterval(runUpdateCheck, UPDATE_CHECK_MS);
+    updateTimer.unref?.();
+    idleUpdateTimer = setInterval(exitForUpdateWhenIdle, IDLE_UPDATE_CHECK_MS);
+    idleUpdateTimer.unref?.();
+    setTimeout(runUpdateCheck, 60_000).unref?.();
+    process.on("SIGINT", () => void shutdown("SIGINT"));
+    process.on("SIGTERM", () => void shutdown("SIGTERM"));
+}

package/dist/src/engine.d.ts

@@ -0,0 +1,32 @@
+import type { EngineAdapter, EngineId } from "./types.js";
+export declare function splitExtraArgs(raw: string | undefined): string[];
+export declare function formatEngineLogLine(engine: EngineId, line: string): string | null;
+export declare function binOnPath(bin: string): Promise<boolean>;
+export declare function personaHeader(persona: {
+    id: string;
+    name: string;
+    role?: string;
+}): string;
+export declare function claudeStreamUserMessage(text: string): string;
+export interface CodexAppEventState {
+    activeTurnId: string | null;
+    steerGate: boolean;
+}
+export interface CodexAppEventResult {
+    logs: string[];
+    activeTurnId: string | null;
+    steerGate: boolean;
+    turnCompletedError?: string;
+    usage?: unknown;
+    threadId?: string;
+}
+export declare function reduceCodexAppEvent(state: CodexAppEventState, msg: Record<string, unknown>): CodexAppEventResult;
+export declare const ADAPTERS: Record<EngineId, EngineAdapter>;
+export declare function getAdapter(id: EngineId): EngineAdapter;
+export declare function detectEngines(): Promise<EngineId[]>;
+export declare function parseTriage(text: string): {
+    actionable: boolean;
+    reason?: string;
+    promptNote?: string;
+    responseMode?: "me" | "each" | "one-of-us";
+} | null;