@suwujs/king-ai 0.2.0

package/dist/src/remote-diagnostics.d.ts

@@ -0,0 +1,39 @@
+import type { RemoteDevicesConfig } from "./remote-devices.js";
+import type { RemoteCommandExecutor, RemoteExecResult } from "./remote-ssh.js";
+export interface RemoteCommandInput {
+    device?: unknown;
+    timeoutMs?: unknown;
+    maxOutputBytes?: unknown;
+}
+export interface RemoteRunInput extends RemoteCommandInput {
+    cmd?: unknown;
+}
+export interface RemoteLogsInput extends RemoteCommandInput {
+    app?: unknown;
+    path?: unknown;
+    tail?: unknown;
+}
+export interface RemoteFindLogsInput extends RemoteLogsInput {
+    pattern?: unknown;
+    since?: unknown;
+}
+export interface RemoteServiceInput extends RemoteCommandInput {
+    db?: unknown;
+    name?: unknown;
+    sql?: unknown;
+    cmd?: unknown;
+}
+export interface RemoteDeviceCommandDeps {
+    config: RemoteDevicesConfig;
+    env?: NodeJS.ProcessEnv;
+    executor?: RemoteCommandExecutor;
+}
+export declare function formatRemoteResult(result: RemoteExecResult): string;
+export declare function formatRemoteDevices(config: RemoteDevicesConfig): string;
+export declare function remoteProbe(input: unknown, deps: RemoteDeviceCommandDeps): Promise<RemoteExecResult>;
+export declare function remoteProfile(input: unknown, deps: RemoteDeviceCommandDeps): Promise<RemoteExecResult>;
+export declare function remoteRun(input: unknown, deps: RemoteDeviceCommandDeps): Promise<RemoteExecResult>;
+export declare function remoteLogs(input: unknown, deps: RemoteDeviceCommandDeps): Promise<RemoteExecResult>;
+export declare function remoteFindLogs(input: unknown, deps: RemoteDeviceCommandDeps): Promise<RemoteExecResult>;
+export declare function remotePg(input: unknown, deps: RemoteDeviceCommandDeps): Promise<RemoteExecResult>;
+export declare function remoteRedis(input: unknown, deps: RemoteDeviceCommandDeps): Promise<RemoteExecResult>;

package/dist/src/remote-diagnostics.js

@@ -0,0 +1,199 @@
+import { findRemoteDevice, listRemoteDeviceSummaries } from "./remote-devices.js";
+import { sshExec } from "./remote-ssh.js";
+export function formatRemoteResult(result) {
+    const status = result.ok ? "ok" : "failed";
+    const parts = [
+        `remote ${status}: ${result.device} ${result.command}`,
+        result.stdout.trim(),
+        result.stderr.trim() ? `stderr:\n${result.stderr.trim()}` : "",
+        result.truncated ? "(output truncated)" : "",
+        result.error ? `error: ${result.error}` : ""
+    ].filter(Boolean);
+    return parts.join("\n");
+}
+export function formatRemoteDevices(config) {
+    const rows = listRemoteDeviceSummaries(config);
+    if (rows.length === 0)
+        return "no remote test devices configured";
+    return rows.map((device) => `${device.id}\t${device.user}@${device.host}:${device.port ?? 22}\t${device.name ?? ""}\t${device.auth}`).join("\n");
+}
+export async function remoteProbe(input, deps) {
+    const parsed = normalizeRemoteCommandInput(input);
+    const device = findRemoteDevice(deps.config, parsed.device);
+    return sshExec(device, "hostname && whoami && pwd && uptime", execOptions(parsed, deps));
+}
+export async function remoteProfile(input, deps) {
+    const parsed = normalizeRemoteCommandInput(input);
+    const device = findRemoteDevice(deps.config, parsed.device);
+    const markers = Object.values(device.apps ?? {}).flatMap((app) => app.installMarkers ?? []);
+    const markerScript = markers.length
+        ? markers.map((marker) => `if [ -f ${sh(marker)} ]; then echo "marker ${marker}=$(cat ${sh(marker)} 2>/dev/null)"; fi`).join("\n")
+        : "true";
+    const logRoots = Object.values(device.apps ?? {}).flatMap((app) => app.logRoots ?? []);
+    const logScript = logRoots.length
+        ? `for d in ${logRoots.map(sh).join(" ")}; do if [ -d "$d" ]; then echo "logroot $d"; find "$d" -type f -maxdepth 2 2>/dev/null | xargs ls -t 2>/dev/null | head -20; fi; done`
+        : "true";
+    const command = [
+        "echo '[system]'",
+        "hostname",
+        "whoami",
+        "uptime",
+        "echo '[install-markers]'",
+        markerScript,
+        "echo '[services]'",
+        "command -v systemctl >/dev/null 2>&1 && systemctl list-units --type=service --state=running --no-pager --no-legend 2>/dev/null | head -50 || ps -ef | head -30",
+        "echo '[logs]'",
+        logScript
+    ].join("\n");
+    const result = await sshExec(device, command, execOptions(parsed, deps));
+    return { ...result, evidence: [{ kind: "profile", source: `${device.user}@${device.host}`, text: "remote environment profile" }] };
+}
+export async function remoteRun(input, deps) {
+    const parsed = normalizeRemoteRunInput(input);
+    const device = findRemoteDevice(deps.config, parsed.device);
+    return sshExec(device, parsed.cmd, execOptions(parsed, deps));
+}
+export async function remoteLogs(input, deps) {
+    const parsed = normalizeRemoteLogsInput(input);
+    const device = findRemoteDevice(deps.config, parsed.device);
+    const app = appConfig(device, parsed.app);
+    const target = parsed.path || newestLogCommand(app.logRoots ?? []);
+    const command = parsed.path
+        ? `tail -n ${parsed.tail} ${sh(parsed.path)}`
+        : `f=$(${target}); if [ -n "$f" ]; then echo "==> $f <=="; tail -n ${parsed.tail} "$f"; else echo "no log file found"; exit 2; fi`;
+    const result = await sshExec(device, command, execOptions(parsed, deps));
+    return { ...result, evidence: [{ kind: "log", source: parsed.path || parsed.app || device.defaultApp || "logs", text: result.stdout.slice(0, 2000) }] };
+}
+export async function remoteFindLogs(input, deps) {
+    const parsed = normalizeRemoteFindLogsInput(input);
+    const device = findRemoteDevice(deps.config, parsed.device);
+    const app = appConfig(device, parsed.app);
+    const roots = app.logRoots ?? [];
+    if (roots.length === 0 && !parsed.path)
+        throw new Error("remote-find-logs requires path or app logRoots");
+    const sources = parsed.path ? [parsed.path] : roots;
+    const since = parsed.since ? ` since=${parsed.since}` : "";
+    const command = [
+        `echo "pattern=${parsed.pattern}${since}"`,
+        `for p in ${sources.map(sh).join(" ")}; do`,
+        "  if [ -f \"$p\" ]; then grep -E -n --color=never " + sh(parsed.pattern) + " \"$p\" | tail -n " + parsed.tail + "; fi",
+        "  if [ -d \"$p\" ]; then find \"$p\" -type f -maxdepth 2 2>/dev/null | xargs grep -E -n --color=never " + sh(parsed.pattern) + " 2>/dev/null | tail -n " + parsed.tail + "; fi",
+        "done"
+    ].join("\n");
+    const result = await sshExec(device, command, execOptions(parsed, deps));
+    return { ...result, evidence: [{ kind: "log", source: sources.join(","), text: result.stdout.slice(0, 2000) }] };
+}
+export async function remotePg(input, deps) {
+    const parsed = normalizeRemoteServiceInput(input, "sql");
+    const device = findRemoteDevice(deps.config, parsed.device);
+    const name = parsed.db || "default";
+    const service = device.databases?.[name];
+    if (!service)
+        throw new Error(`remote database not configured: ${name}`);
+    const command = `${service.command} -c ${sh(parsed.sql)}`;
+    const result = await sshExec(device, command, execOptions(parsed, deps));
+    return { ...result, evidence: [{ kind: "database", source: name, text: parsed.sql }] };
+}
+export async function remoteRedis(input, deps) {
+    const parsed = normalizeRemoteServiceInput(input, "cmd");
+    const device = findRemoteDevice(deps.config, parsed.device);
+    const name = parsed.name || "default";
+    const service = device.redis?.[name];
+    if (!service)
+        throw new Error(`remote redis not configured: ${name}`);
+    const command = `${service.command} ${parsed.cmd}`;
+    const result = await sshExec(device, command, execOptions(parsed, deps));
+    return { ...result, evidence: [{ kind: "redis", source: name, text: parsed.cmd }] };
+}
+function execOptions(input, deps) {
+    return {
+        timeoutMs: input.timeoutMs,
+        maxOutputBytes: input.maxOutputBytes,
+        env: deps.env,
+        executor: deps.executor
+    };
+}
+function normalizeRemoteCommandInput(input) {
+    const record = objectInput(input);
+    return {
+        device: optionalString(record.device),
+        timeoutMs: optionalPositiveInt(record.timeoutMs, "timeoutMs"),
+        maxOutputBytes: optionalPositiveInt(record.maxOutputBytes, "maxOutputBytes")
+    };
+}
+function normalizeRemoteRunInput(input) {
+    const base = normalizeRemoteCommandInput(input);
+    const record = objectInput(input);
+    return { ...base, cmd: requiredString(record.cmd, "cmd") };
+}
+function normalizeRemoteLogsInput(input) {
+    const base = normalizeRemoteCommandInput(input);
+    const record = objectInput(input);
+    return {
+        ...base,
+        app: optionalString(record.app),
+        path: optionalString(record.path),
+        tail: optionalPositiveInt(record.tail, "tail") ?? 200
+    };
+}
+function normalizeRemoteFindLogsInput(input) {
+    const base = normalizeRemoteLogsInput(input);
+    const record = objectInput(input);
+    return {
+        ...base,
+        pattern: requiredString(record.pattern, "pattern"),
+        since: optionalString(record.since)
+    };
+}
+function normalizeRemoteServiceInput(input, field) {
+    const base = normalizeRemoteCommandInput(input);
+    const record = objectInput(input);
+    const value = requiredString(record[field], field);
+    return {
+        ...base,
+        db: optionalString(record.db),
+        name: optionalString(record.name),
+        sql: field === "sql" ? value : "",
+        cmd: field === "cmd" ? value : ""
+    };
+}
+function objectInput(input) {
+    if (!input)
+        return {};
+    if (typeof input !== "object")
+        throw new Error("remote command input must be an object");
+    return input;
+}
+function appConfig(device, appName) {
+    const name = appName || device.defaultApp;
+    if (!name)
+        return {};
+    const app = device.apps?.[name];
+    if (!app)
+        throw new Error(`remote app not configured: ${name}`);
+    return app;
+}
+function newestLogCommand(roots) {
+    if (roots.length === 0)
+        return "find /var/log -type f 2>/dev/null | xargs ls -t 2>/dev/null | head -1";
+    return `for d in ${roots.map(sh).join(" ")}; do [ -d "$d" ] && find "$d" -type f -maxdepth 2 2>/dev/null; done | xargs ls -t 2>/dev/null | head -1`;
+}
+function requiredString(raw, label) {
+    if (typeof raw !== "string" || !raw.trim())
+        throw new Error(`${label} is required`);
+    return raw.trim();
+}
+function optionalString(raw) {
+    return typeof raw === "string" && raw.trim() ? raw.trim() : undefined;
+}
+function optionalPositiveInt(raw, label) {
+    if (raw === undefined || raw === null || raw === "")
+        return undefined;
+    const value = typeof raw === "number" ? raw : Number.parseInt(String(raw), 10);
+    if (!Number.isFinite(value) || value < 1)
+        throw new Error(`${label} must be a positive integer`);
+    return Math.floor(value);
+}
+function sh(value) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}

package/dist/src/remote-ssh.d.ts

@@ -0,0 +1,39 @@
+import type { RemoteDevice } from "./remote-devices.js";
+export interface RemoteExecOptions {
+    timeoutMs?: number;
+    maxOutputBytes?: number;
+    env?: NodeJS.ProcessEnv;
+    executor?: RemoteCommandExecutor;
+}
+export interface RemoteExecResult {
+    ok: boolean;
+    device: string;
+    host: string;
+    command: string;
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+    truncated: boolean;
+    durationMs: number;
+    evidence: RemoteEvidence[];
+    error?: string;
+}
+export interface RemoteEvidence {
+    kind: "command" | "log" | "database" | "redis" | "profile";
+    source: string;
+    text: string;
+    time?: string;
+}
+export type RemoteCommandExecutor = (program: string, args: string[], options: {
+    env: NodeJS.ProcessEnv;
+    timeoutMs: number;
+    maxOutputBytes: number;
+}) => Promise<Omit<RemoteExecResult, "device" | "host" | "command" | "evidence">>;
+export declare function sshExec(device: RemoteDevice, command: string, options?: RemoteExecOptions): Promise<RemoteExecResult>;
+export declare function buildSshCommand(device: RemoteDevice, command: string, env?: NodeJS.ProcessEnv): {
+    program: string;
+    args: string[];
+    env: NodeJS.ProcessEnv;
+};
+export declare function remotePassword(device: RemoteDevice, env?: NodeJS.ProcessEnv): string | undefined;
+export declare function redactRemoteSecrets(text: string, device: RemoteDevice, env?: NodeJS.ProcessEnv): string;

package/dist/src/remote-ssh.js

@@ -0,0 +1,129 @@
+import { spawn } from "node:child_process";
+const DEFAULT_TIMEOUT_MS = 30_000;
+const DEFAULT_MAX_OUTPUT_BYTES = 200 * 1024;
+export async function sshExec(device, command, options = {}) {
+    const timeoutMs = normalizePositiveInt(options.timeoutMs, DEFAULT_TIMEOUT_MS);
+    const maxOutputBytes = normalizePositiveInt(options.maxOutputBytes, DEFAULT_MAX_OUTPUT_BYTES);
+    const env = { ...process.env, ...(options.env ?? {}) };
+    const built = buildSshCommand(device, command, env);
+    const started = Date.now();
+    const executor = options.executor ?? spawnCapture;
+    const result = await executor(built.program, built.args, { env: built.env, timeoutMs, maxOutputBytes });
+    return {
+        ...result,
+        stdout: redactRemoteSecrets(result.stdout, device, env),
+        stderr: redactRemoteSecrets(result.stderr, device, env),
+        error: result.error ? redactRemoteSecrets(result.error, device, env) : undefined,
+        device: device.id,
+        host: device.host,
+        command,
+        durationMs: result.durationMs || Date.now() - started,
+        evidence: [{
+                kind: "command",
+                source: `${device.user}@${device.host}`,
+                text: command
+            }]
+    };
+}
+export function buildSshCommand(device, command, env = process.env) {
+    const port = String(device.port ?? 22);
+    const target = `${device.user}@${device.host}`;
+    const baseArgs = [
+        "-o", "StrictHostKeyChecking=no",
+        "-o", "UserKnownHostsFile=/dev/null",
+        "-o", "ConnectTimeout=5",
+        "-p", port
+    ];
+    if (device.identityFile)
+        baseArgs.push("-i", device.identityFile);
+    const password = remotePassword(device, env);
+    if (password) {
+        return {
+            program: "sshpass",
+            args: ["-e", "ssh", ...baseArgs, target, command],
+            env: { ...env, SSHPASS: password }
+        };
+    }
+    return {
+        program: "ssh",
+        args: [...baseArgs, target, command],
+        env
+    };
+}
+export function remotePassword(device, env = process.env) {
+    if (device.passwordEnv && env[device.passwordEnv])
+        return env[device.passwordEnv];
+    return device.password;
+}
+export function redactRemoteSecrets(text, device, env = process.env) {
+    let redacted = text;
+    for (const secret of [device.password, device.passwordEnv ? env[device.passwordEnv] : undefined].filter(Boolean)) {
+        redacted = redacted.split(secret).join("<redacted>");
+    }
+    return redacted;
+}
+async function spawnCapture(program, args, options) {
+    const started = Date.now();
+    return await new Promise((resolve) => {
+        const child = spawn(program, args, {
+            env: options.env,
+            stdio: ["ignore", "pipe", "pipe"]
+        });
+        let stdout = "";
+        let stderr = "";
+        let truncated = false;
+        const timer = setTimeout(() => {
+            child.kill("SIGTERM");
+        }, options.timeoutMs);
+        timer.unref?.();
+        const append = (chunk, target) => {
+            const text = chunk.toString("utf8");
+            if (Buffer.byteLength(stdout + stderr, "utf8") + Buffer.byteLength(text, "utf8") > options.maxOutputBytes) {
+                truncated = true;
+                const remaining = Math.max(0, options.maxOutputBytes - Buffer.byteLength(stdout + stderr, "utf8"));
+                const sliced = Buffer.from(text).subarray(0, remaining).toString("utf8");
+                if (target === "stdout")
+                    stdout += sliced;
+                else
+                    stderr += sliced;
+                return;
+            }
+            if (target === "stdout")
+                stdout += text;
+            else
+                stderr += text;
+        };
+        child.stdout?.on("data", (chunk) => append(chunk, "stdout"));
+        child.stderr?.on("data", (chunk) => append(chunk, "stderr"));
+        child.once("error", (err) => {
+            clearTimeout(timer);
+            resolve({
+                ok: false,
+                exitCode: 1,
+                stdout,
+                stderr,
+                truncated,
+                durationMs: Date.now() - started,
+                error: err.message
+            });
+        });
+        child.once("close", (code, signal) => {
+            clearTimeout(timer);
+            const timedOut = signal === "SIGTERM" && Date.now() - started >= options.timeoutMs;
+            resolve({
+                ok: code === 0 && !timedOut,
+                exitCode: code,
+                stdout,
+                stderr,
+                truncated,
+                durationMs: Date.now() - started,
+                ...(timedOut ? { error: `remote command timed out after ${options.timeoutMs}ms` } : code === 0 ? {} : { error: `remote command exited with code ${code}` })
+            });
+        });
+    });
+}
+function normalizePositiveInt(value, fallback) {
+    if (value === undefined)
+        return fallback;
+    return Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}

package/dist/src/run-stream.d.ts

@@ -0,0 +1,57 @@
+export type RunStreamTerminal = "running" | "done" | "error" | "interrupted";
+export type RunStreamFooter = "thinking" | "tool_running" | "streaming" | null;
+export type RunStreamEvent = {
+    type: "reasoning_delta";
+    text: string;
+} | {
+    type: "message_delta";
+    text: string;
+} | {
+    type: "tool_started";
+    id?: string;
+    name: string;
+    input?: string;
+} | {
+    type: "tool_delta";
+    id?: string;
+    text: string;
+} | {
+    type: "tool_done";
+    id?: string;
+    output?: string;
+    error?: string;
+} | {
+    type: "done";
+} | {
+    type: "error";
+    message: string;
+} | {
+    type: "interrupted";
+};
+export interface RunStreamTool {
+    id: string;
+    name: string;
+    input?: string;
+    output?: string;
+    status: "running" | "done" | "error";
+}
+export interface RunStreamState {
+    reasoning: string;
+    message: string;
+    tools: RunStreamTool[];
+    terminal: RunStreamTerminal;
+    footer: RunStreamFooter;
+    error?: string;
+}
+export declare function initialRunStreamState(): RunStreamState;
+export declare function reduceRunStream(state: RunStreamState, event: RunStreamEvent): RunStreamState;
+export declare function renderRunStreamText(state: RunStreamState): string;
+export declare function renderRunStreamCard(state: RunStreamState): {
+    summary: string;
+    sections: Array<{
+        kind: "reasoning" | "tool" | "message" | "status";
+        title: string;
+        body: string;
+        collapsed: boolean;
+    }>;
+};

package/dist/src/run-stream.js

@@ -0,0 +1,119 @@
+export function initialRunStreamState() {
+    return {
+        reasoning: "",
+        message: "",
+        tools: [],
+        terminal: "running",
+        footer: "thinking"
+    };
+}
+export function reduceRunStream(state, event) {
+    if (state.terminal !== "running")
+        return state;
+    if (event.type === "reasoning_delta") {
+        return { ...state, reasoning: state.reasoning + event.text, footer: "thinking" };
+    }
+    if (event.type === "message_delta") {
+        return { ...state, message: state.message + event.text, footer: "streaming" };
+    }
+    if (event.type === "tool_started") {
+        return {
+            ...state,
+            footer: "tool_running",
+            tools: [...state.tools, { id: event.id ?? `tool-${state.tools.length + 1}`, name: event.name, input: event.input, status: "running" }]
+        };
+    }
+    if (event.type === "tool_delta") {
+        return updateTool(state, event.id, (tool) => ({
+            ...tool,
+            output: `${tool.output ?? ""}${event.text}`,
+            status: "running"
+        }));
+    }
+    if (event.type === "tool_done") {
+        return updateTool(state, event.id, (tool) => ({
+            ...tool,
+            output: event.output ?? tool.output,
+            status: event.error ? "error" : "done"
+        }));
+    }
+    if (event.type === "done")
+        return { ...state, terminal: "done", footer: null };
+    if (event.type === "error")
+        return { ...state, terminal: "error", footer: null, error: event.message };
+    return { ...state, terminal: "interrupted", footer: null };
+}
+export function renderRunStreamText(state) {
+    const lines = [];
+    if (state.reasoning)
+        lines.push(`reasoning: ${compact(state.reasoning, 500)}`);
+    for (const tool of state.tools) {
+        const status = tool.status === "running" ? "running" : tool.status;
+        const detail = tool.output ? ` - ${compact(tool.output, 300)}` : "";
+        lines.push(`tool ${status}: ${tool.name}${detail}`);
+    }
+    if (state.message)
+        lines.push(state.message.trimEnd());
+    if (state.terminal === "error" && state.error)
+        lines.push(`error: ${state.error}`);
+    if (state.terminal === "interrupted")
+        lines.push("interrupted");
+    return lines.join("\n").trim();
+}
+export function renderRunStreamCard(state) {
+    const sections = [];
+    if (state.reasoning) {
+        sections.push({ kind: "reasoning", title: state.footer === "thinking" ? "Thinking" : "Reasoning", body: compact(state.reasoning, 1500), collapsed: state.footer !== "thinking" });
+    }
+    const priorTools = state.tools.length > 2 && state.terminal === "running" ? state.tools.slice(0, -1) : [];
+    if (priorTools.length) {
+        sections.push({
+            kind: "tool",
+            title: `${priorTools.length} tool calls`,
+            body: priorTools.map((tool) => `${tool.status}: ${tool.name}`).join("\n"),
+            collapsed: true
+        });
+    }
+    const visibleTools = priorTools.length ? state.tools.slice(-1) : state.tools;
+    for (const tool of visibleTools) {
+        sections.push({
+            kind: "tool",
+            title: `${tool.status}: ${tool.name}`,
+            body: compact([tool.input, tool.output].filter(Boolean).join("\n"), 1500) || "(no output)",
+            collapsed: tool.status !== "running"
+        });
+    }
+    if (state.message)
+        sections.push({ kind: "message", title: "Reply", body: state.message, collapsed: false });
+    if (state.terminal !== "running") {
+        sections.push({ kind: "status", title: state.terminal, body: state.error ?? state.terminal, collapsed: false });
+    }
+    return { summary: summaryText(state), sections };
+}
+function updateTool(state, id, update) {
+    const target = id ?? state.tools.at(-1)?.id;
+    if (!target)
+        return state;
+    return {
+        ...state,
+        footer: "tool_running",
+        tools: state.tools.map((tool) => tool.id === target ? update(tool) : tool)
+    };
+}
+function summaryText(state) {
+    if (state.terminal === "done")
+        return "Completed";
+    if (state.terminal === "error")
+        return "Failed";
+    if (state.terminal === "interrupted")
+        return "Interrupted";
+    if (state.footer === "tool_running")
+        return "Calling tools";
+    if (state.footer === "streaming")
+        return "Streaming";
+    return "Thinking";
+}
+function compact(value, max) {
+    const text = value.replace(/\s+$/g, "");
+    return text.length > max ? `${text.slice(0, max)}...` : text;
+}