@suwujs/king-ai 0.2.0

package/dist/src/project-profile.js

@@ -0,0 +1,356 @@
+import { execSync } from "node:child_process";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { basename, join, relative, resolve } from "node:path";
+function hasFile(projectPath, name) {
+    return existsSync(join(projectPath, name));
+}
+function readPackageJson(projectPath) {
+    const file = join(projectPath, "package.json");
+    if (!existsSync(file))
+        return null;
+    try {
+        return JSON.parse(readFileSync(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function packageDeps(projectPath) {
+    const pkg = readPackageJson(projectPath);
+    const deps = typeof pkg?.dependencies === "object" && pkg.dependencies ? pkg.dependencies : {};
+    const devDeps = typeof pkg?.devDependencies === "object" && pkg.devDependencies ? pkg.devDependencies : {};
+    return { ...deps, ...devDeps };
+}
+export function detectLanguages(projectPath) {
+    const languages = [];
+    if (hasFile(projectPath, "package.json")) {
+        if (hasFile(projectPath, "tsconfig.json") || hasFile(projectPath, "tsconfig.base.json") || hasFile(projectPath, "tsconfig.build.json"))
+            languages.push("typescript");
+        languages.push("javascript");
+    }
+    if (hasFile(projectPath, "Cargo.toml"))
+        languages.push("rust");
+    if (hasFile(projectPath, "go.mod"))
+        languages.push("go");
+    if (hasFile(projectPath, "requirements.txt") || hasFile(projectPath, "pyproject.toml") || hasFile(projectPath, "setup.py"))
+        languages.push("python");
+    if (hasFile(projectPath, "Gemfile"))
+        languages.push("ruby");
+    if (hasFile(projectPath, "pom.xml") || hasFile(projectPath, "build.gradle"))
+        languages.push("java");
+    if (hasFile(projectPath, "Package.swift"))
+        languages.push("swift");
+    if (hasFile(projectPath, "pubspec.yaml"))
+        languages.push("dart");
+    return languages;
+}
+export function detectPackageManagers(projectPath) {
+    const managers = [];
+    if (hasFile(projectPath, "pnpm-lock.yaml") || hasFile(projectPath, "pnpm-workspace.yaml"))
+        managers.push("pnpm");
+    else if (hasFile(projectPath, "yarn.lock"))
+        managers.push("yarn");
+    else if (hasFile(projectPath, "package-lock.json"))
+        managers.push("npm");
+    if (hasFile(projectPath, "Cargo.lock"))
+        managers.push("cargo");
+    if (hasFile(projectPath, "go.sum"))
+        managers.push("go");
+    if (hasFile(projectPath, "Pipfile.lock") || hasFile(projectPath, "poetry.lock"))
+        managers.push("pip");
+    return managers;
+}
+export function detectFrameworks(projectPath) {
+    const deps = packageDeps(projectPath);
+    const frameworks = [];
+    if ("next" in deps)
+        frameworks.push("nextjs");
+    if ("react" in deps)
+        frameworks.push("react");
+    if ("vue" in deps)
+        frameworks.push("vue");
+    if ("svelte" in deps || "@sveltejs/kit" in deps)
+        frameworks.push("svelte");
+    if ("express" in deps)
+        frameworks.push("express");
+    if ("fastify" in deps)
+        frameworks.push("fastify");
+    if ("hono" in deps)
+        frameworks.push("hono");
+    if ("expo" in deps)
+        frameworks.push("expo");
+    if ("vite" in deps)
+        frameworks.push("vite");
+    return frameworks;
+}
+export function detectCI(projectPath) {
+    const ci = [];
+    const workflows = join(projectPath, ".github", "workflows");
+    if (existsSync(workflows) && statSync(workflows).isDirectory())
+        ci.push("github-actions");
+    if (hasFile(projectPath, ".gitlab-ci.yml"))
+        ci.push("gitlab-ci");
+    if (hasFile(projectPath, ".circleci/config.yml"))
+        ci.push("circleci");
+    if (hasFile(projectPath, "Jenkinsfile"))
+        ci.push("jenkins");
+    if (hasFile(projectPath, "Dockerfile") || hasFile(projectPath, "docker-compose.yml"))
+        ci.push("docker");
+    if (hasFile(projectPath, "vercel.json") || hasFile(projectPath, ".vercel"))
+        ci.push("vercel");
+    if (hasFile(projectPath, "wrangler.toml"))
+        ci.push("cloudflare");
+    return ci;
+}
+export function detectTests(projectPath) {
+    const deps = packageDeps(projectPath);
+    const tests = [];
+    if ("vitest" in deps)
+        tests.push("vitest");
+    if ("jest" in deps)
+        tests.push("jest");
+    if ("mocha" in deps)
+        tests.push("mocha");
+    if ("playwright" in deps || "@playwright/test" in deps)
+        tests.push("playwright");
+    if ("cypress" in deps)
+        tests.push("cypress");
+    if (hasFile(projectPath, "pytest.ini") || hasFile(projectPath, "conftest.py"))
+        tests.push("pytest");
+    if (hasFile(projectPath, "test") || hasFile(projectPath, "tests"))
+        tests.push("node-test");
+    return Array.from(new Set(tests));
+}
+export function detectGitHubRemote(projectPath) {
+    try {
+        const remote = execSync("git remote get-url origin", {
+            cwd: projectPath,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 5000
+        }).trim();
+        if (remote.includes("github.com"))
+            return remote;
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+export function scanReadme(projectPath) {
+    for (const name of ["README.md", "readme.md", "README.rst", "README"]) {
+        const file = join(projectPath, name);
+        if (existsSync(file) && statSync(file).isFile())
+            return readTextSnippet(file, 500);
+    }
+    return undefined;
+}
+export function detectCodeRoots(projectPath) {
+    const roots = ["src", "app", "apps", "packages", "services", "backend", "frontend", "web", "api", "lib", "cmd", "gui-worker"];
+    return roots.filter((name) => {
+        const dir = join(projectPath, name);
+        return existsSync(dir) && statSync(dir).isDirectory();
+    });
+}
+export function detectPackageScripts(projectPath) {
+    const pkg = readPackageJson(projectPath);
+    const scripts = pkg?.scripts;
+    if (!scripts || typeof scripts !== "object")
+        return [];
+    return Object.keys(scripts);
+}
+function readTextSnippet(filePath, maxChars = 1600) {
+    try {
+        return readFileSync(filePath, "utf8").slice(0, maxChars);
+    }
+    catch {
+        return "";
+    }
+}
+function extractHeadings(content) {
+    return content
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => /^(#{1,3}\s+|[-*]\s+\[[ xX]\]\s+)/.test(line))
+        .map((line) => line.replace(/^#{1,3}\s+/, "").trim())
+        .slice(0, 8);
+}
+function titleFromContent(filePath, content) {
+    const heading = content
+        .split("\n")
+        .map((line) => line.trim())
+        .find((line) => /^#\s+/.test(line));
+    return heading ? heading.replace(/^#\s+/, "").trim() : basename(filePath);
+}
+function scoreDocument(relativePath) {
+    const normalized = relativePath.replace(/\\/g, "/").toLowerCase();
+    if (/^readme(\.|$)/.test(normalized))
+        return { score: 100, kind: "readme" };
+    if (/(^|\/)(roadmap|todo|backlog|milestone|plan|vision|prd|strategy)/.test(normalized))
+        return { score: 95, kind: "roadmap" };
+    if (/^agents\.md$|^claude\.md$/.test(normalized))
+        return { score: 85, kind: "notes" };
+    if (/^package\.json$|^pyproject\.toml$|^cargo\.toml$|^go\.mod$/.test(normalized))
+        return { score: 70, kind: "manifest" };
+    if (/^docs\/.+\.(md|mdx|rst|txt)$/.test(normalized))
+        return { score: 60, kind: "docs" };
+    if (/\.(md|mdx|rst|txt)$/.test(normalized))
+        return { score: 40, kind: "notes" };
+    return { score: 0, kind: "notes" };
+}
+function walkDocsDir(root, dir, acc, depth = 0) {
+    if (depth > 3)
+        return;
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (entry.name.startsWith("."))
+            continue;
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            walkDocsDir(root, fullPath, acc, depth + 1);
+            continue;
+        }
+        const rel = relative(root, fullPath);
+        if (/\.(md|mdx|rst|txt|json|toml|ya?ml)$/i.test(rel))
+            acc.push(fullPath);
+    }
+}
+export function collectProjectDocs(projectPath) {
+    const candidates = new Map();
+    const addCandidate = (file) => {
+        const key = relative(projectPath, file).replace(/\\/g, "/").toLowerCase();
+        if (!candidates.has(key))
+            candidates.set(key, file);
+    };
+    for (const name of ["README.md", "readme.md", "README.rst", "README", "AGENTS.md", "CLAUDE.md", "ROADMAP.md", "ROADMAP", "TODO.md", "TODO", "CHANGELOG.md", "PLAN.md", "VISION.md", "package.json", "pyproject.toml", "Cargo.toml", "go.mod"]) {
+        const file = join(projectPath, name);
+        if (existsSync(file) && statSync(file).isFile())
+            addCandidate(file);
+    }
+    const docsDir = join(projectPath, "docs");
+    if (existsSync(docsDir) && statSync(docsDir).isDirectory()) {
+        const docs = [];
+        walkDocsDir(projectPath, docsDir, docs);
+        for (const file of docs)
+            addCandidate(file);
+    }
+    return Array.from(candidates.values())
+        .map((filePath) => {
+        const rel = relative(projectPath, filePath).replace(/\\/g, "/");
+        const { score, kind } = scoreDocument(rel);
+        const excerpt = readTextSnippet(filePath);
+        return {
+            path: rel,
+            kind,
+            title: titleFromContent(filePath, excerpt),
+            excerpt,
+            headings: extractHeadings(excerpt),
+            score
+        };
+    })
+        .filter((doc) => doc.score > 0)
+        .sort((a, b) => b.score - a.score || a.path.localeCompare(b.path))
+        .slice(0, 10);
+}
+export function scanProject(projectPath) {
+    const absPath = resolve(projectPath);
+    const githubRemote = detectGitHubRemote(absPath);
+    const docsDir = join(absPath, "docs");
+    return {
+        path: absPath,
+        languages: detectLanguages(absPath),
+        packageManagers: detectPackageManagers(absPath),
+        frameworks: detectFrameworks(absPath),
+        ci: detectCI(absPath),
+        testFrameworks: detectTests(absPath),
+        hasReadme: hasFile(absPath, "README.md") || hasFile(absPath, "readme.md"),
+        hasAgentsMd: hasFile(absPath, "AGENTS.md"),
+        hasDocs: existsSync(docsDir) && statSync(docsDir).isDirectory(),
+        issueTracker: githubRemote ? "github" : "none",
+        githubRemote,
+        readmeExcerpt: scanReadme(absPath),
+        codeRoots: detectCodeRoots(absPath),
+        packageScripts: detectPackageScripts(absPath)
+    };
+}
+function inferProjectName(profile, docs) {
+    const pkg = readPackageJson(profile.path);
+    const name = typeof pkg?.name === "string" ? pkg.name.trim() : "";
+    if (name)
+        return name;
+    const readme = docs.find((doc) => doc.kind === "readme");
+    return readme?.title || basename(profile.path);
+}
+function inferProjectSummary(profile, docs) {
+    const pkg = readPackageJson(profile.path);
+    const description = typeof pkg?.description === "string" ? pkg.description.trim() : "";
+    if (description)
+        return description;
+    const readme = docs.find((doc) => doc.kind === "readme");
+    if (readme?.excerpt) {
+        const summary = readme.excerpt.replace(/\s+/g, " ").replace(/^#.+$/, "").trim().slice(0, 220);
+        if (summary)
+            return summary;
+    }
+    const stack = [profile.frameworks[0], profile.languages[0]].filter(Boolean).join(" / ");
+    return stack ? `${inferProjectName(profile, docs)} - ${stack} project` : `Maintain and advance ${inferProjectName(profile, docs)}`;
+}
+function buildStrategicThemes(profile, docs) {
+    const themes = new Set();
+    const roadmapDocs = docs.filter((doc) => doc.kind === "roadmap");
+    if (roadmapDocs.length > 0)
+        themes.add("Advance incomplete roadmap, plan, and backlog items closest to user value");
+    if (profile.hasReadme || profile.hasDocs)
+        themes.add("Keep README, docs, and changelog consistent with implementation");
+    if (profile.ci.length > 0 || profile.testFrameworks.length > 0)
+        themes.add("Keep tests, CI, build, and release pipelines operational");
+    if (profile.codeRoots.length > 0)
+        themes.add(`Review core code directories ${profile.codeRoots.join(", ")} for structural issues`);
+    themes.add(profile.issueTracker === "github" ? "Convert external issues and feedback into scoped local tasks" : "Mine backlog from code, docs, TODOs, and scripts when external issues are unavailable");
+    return Array.from(themes);
+}
+export function buildProjectIntent(profile) {
+    const docs = collectProjectDocs(profile.path);
+    const projectName = inferProjectName(profile, docs);
+    const summary = inferProjectSummary(profile, docs);
+    const strategicThemes = buildStrategicThemes(profile, docs);
+    const stack = [profile.frameworks[0], profile.languages[0]].filter(Boolean).join(" / ");
+    return {
+        projectName,
+        summary,
+        canonicalDocs: docs,
+        roadmapDocs: docs.filter((doc) => doc.kind === "roadmap"),
+        codeRoots: profile.codeRoots,
+        packageScripts: profile.packageScripts,
+        strategicThemes,
+        mission: [
+            `Continuously take over and advance ${projectName}${stack ? ` (${stack})` : ""}.`,
+            `Project summary: ${summary}`,
+            `Operating principles: ${strategicThemes.join("; ")}`
+        ].join(" ")
+    };
+}
+export function formatProjectProfile(profile, intent = buildProjectIntent(profile)) {
+    const lines = [
+        `Project profile: ${intent.projectName}`,
+        `path: ${profile.path}`,
+        `summary: ${intent.summary}`,
+        `languages: ${profile.languages.join(", ") || "none"}`,
+        `package managers: ${profile.packageManagers.join(", ") || "none"}`,
+        `frameworks: ${profile.frameworks.join(", ") || "none"}`,
+        `tests: ${profile.testFrameworks.join(", ") || "none"}`,
+        `ci: ${profile.ci.join(", ") || "none"}`,
+        `code roots: ${profile.codeRoots.join(", ") || "repo root"}`,
+        `package scripts: ${profile.packageScripts.join(", ") || "none"}`,
+        `issue tracker: ${profile.issueTracker}${profile.githubRemote ? ` (${profile.githubRemote})` : ""}`,
+        "canonical docs:",
+        ...(intent.canonicalDocs.length ? intent.canonicalDocs.map((doc) => `  - ${doc.path} [${doc.kind}] ${doc.title}`) : ["  - none"]),
+        "strategic themes:",
+        ...intent.strategicThemes.map((theme) => `  - ${theme}`),
+        `mission: ${intent.mission}`
+    ];
+    return lines.join("\n");
+}
+export function runProjectProfile(projectPath) {
+    const profile = scanProject(projectPath);
+    console.log(formatProjectProfile(profile));
+}

package/dist/src/remediation.d.ts

@@ -0,0 +1,14 @@
+export type RemediationSeverity = "info" | "warning" | "error";
+export type RemediationCategory = "missing_engine" | "auth" | "quota" | "rate_limit" | "context" | "session" | "runtime" | "unknown";
+export interface RemediationAdvice {
+    engine?: string;
+    category: RemediationCategory;
+    severity: RemediationSeverity;
+    summary: string;
+    detail?: string;
+    actions: string[];
+}
+export declare function engineInstallAdvice(engine: string): RemediationAdvice;
+export declare function engineRemediationAdvice(engine: string, detail: string): RemediationAdvice;
+export declare function formatRemediationAdvice(advice: RemediationAdvice): string;
+export declare function formatRemediationBlock(advice: RemediationAdvice): string;

package/dist/src/remediation.js

@@ -0,0 +1,114 @@
+function has(text, pattern) {
+    return pattern.test(text);
+}
+export function engineInstallAdvice(engine) {
+    return {
+        engine,
+        category: "missing_engine",
+        severity: "error",
+        summary: `${engine} CLI is not on PATH`,
+        actions: [
+            `Install the ${engine} CLI.`,
+            `Run ${engine} once in a local terminal to finish login/setup.`,
+            "Restart or re-run: king-ai agent computer --doctor"
+        ]
+    };
+}
+export function engineRemediationAdvice(engine, detail) {
+    const text = detail || "unknown failure";
+    const lower = text.toLowerCase();
+    if (has(lower, /context window|context length|context_length_exceeded|maximum context|prompt is too long|input is too long|too many tokens/)) {
+        return {
+            engine,
+            category: "context",
+            severity: "warning",
+            summary: `${engine} session context is full`,
+            detail: text,
+            actions: [
+                "The daemon resets the affected engine session automatically.",
+                "Wake the agent again to continue with a fresh session.",
+                "If this repeats, reduce prompt/history size or ask the runtime to provide a shorter preamble."
+            ]
+        };
+    }
+    if (has(lower, /no (?:low|high) surrogate|unpaired surrogate|lone surrogate|surrogate in string|request body is not valid json/)) {
+        return {
+            engine,
+            category: "session",
+            severity: "warning",
+            summary: `${engine} session was poisoned by malformed text`,
+            detail: text,
+            actions: [
+                "The daemon resets the affected engine session automatically.",
+                "Wake the agent again after the malformed message is removed or sanitized."
+            ]
+        };
+    }
+    if (has(lower, /\bquota\b|credit|billing|subscription|usage limit|insufficient_quota|resource_exhausted/)) {
+        return {
+            engine,
+            category: "quota",
+            severity: "error",
+            summary: `${engine} quota or billing limit is blocking runs`,
+            detail: text,
+            actions: [
+                `Open ${engine} locally and refresh quota, billing, credits, or subscription state.`,
+                "Re-run: king-ai agent computer --doctor",
+                "Wake the agent again after the quota issue is fixed."
+            ]
+        };
+    }
+    if (has(lower, /\b429\b|\b503\b|too many requests|rate.?limit|overloaded|service (temporarily )?unavailable/)) {
+        return {
+            engine,
+            category: "rate_limit",
+            severity: "warning",
+            summary: `${engine} is temporarily rate-limited or unavailable`,
+            detail: text,
+            actions: [
+                "Wait for the provider limit to clear.",
+                "Re-run: king-ai agent computer --doctor",
+                "Wake the agent again after the backoff period."
+            ]
+        };
+    }
+    if (has(lower, /auth|login|log(?:ged)? in|sign(?:ed)? in|token|api key|unauthorized|forbidden|\b401\b|\b403\b/)) {
+        return {
+            engine,
+            category: "auth",
+            severity: "error",
+            summary: `${engine} authentication is not ready`,
+            detail: text,
+            actions: [
+                `Open ${engine} locally and sign in again.`,
+                "Make sure the daemon process has the same PATH and home config as your terminal.",
+                "Re-run: king-ai agent computer --doctor"
+            ]
+        };
+    }
+    return {
+        engine,
+        category: "unknown",
+        severity: "warning",
+        summary: `${engine} failed; inspect daemon logs`,
+        detail: text,
+        actions: [
+            "Check the daemon terminal or service logs for the full error.",
+            "Re-run: king-ai agent computer --doctor",
+            "Wake the agent again after fixing the local engine problem."
+        ]
+    };
+}
+export function formatRemediationAdvice(advice) {
+    return [
+        `${advice.summary}.`,
+        ...advice.actions
+    ].join(" ");
+}
+export function formatRemediationBlock(advice) {
+    return [
+        `${advice.severity}: ${advice.summary}`,
+        advice.detail ? `  detail: ${advice.detail}` : "",
+        ...advice.actions.map((action) => `  - ${action}`)
+    ].filter(Boolean).join("\n");
+}

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

@@ -0,0 +1,41 @@
+export declare const DEVICES_PATH: string;
+export interface RemoteAppConfig {
+    installMarkers?: string[];
+    logRoots?: string[];
+    errorPatterns?: string[];
+}
+export interface RemoteServiceCommand {
+    type?: string;
+    command: string;
+}
+export interface RemoteDevice {
+    id: string;
+    name?: string;
+    host: string;
+    port?: number;
+    user: string;
+    password?: string;
+    passwordEnv?: string;
+    identityFile?: string;
+    defaultApp?: string;
+    apps?: Record<string, RemoteAppConfig>;
+    databases?: Record<string, RemoteServiceCommand>;
+    redis?: Record<string, RemoteServiceCommand>;
+}
+export interface RemoteDevicesConfig {
+    defaultDevice?: string;
+    devices: RemoteDevice[];
+}
+export type RemoteDeviceSummary = Omit<RemoteDevice, "password"> & {
+    auth: "password" | "passwordEnv" | "identityFile" | "ssh-agent";
+    hasPassword: boolean;
+};
+export declare function loadRemoteDevicesConfig(path?: string): Promise<RemoteDevicesConfig>;
+export declare function saveRemoteDevicesConfig(config: RemoteDevicesConfig, path?: string): Promise<RemoteDevicesConfig>;
+export declare function summarizeRemoteDevice(device: RemoteDevice): RemoteDeviceSummary;
+export declare function listRemoteDeviceSummaries(config: RemoteDevicesConfig): RemoteDeviceSummary[];
+export declare function findRemoteDevice(config: RemoteDevicesConfig, idOrHost?: string): RemoteDevice;
+export declare function upsertRemoteDevice(config: RemoteDevicesConfig, raw: unknown): RemoteDevicesConfig;
+export declare function deleteRemoteDevice(config: RemoteDevicesConfig, id: string): RemoteDevicesConfig;
+export declare function setDefaultRemoteDevice(config: RemoteDevicesConfig, id: string): RemoteDevicesConfig;
+export declare function normalizeRemoteDevicesConfig(raw: unknown): RemoteDevicesConfig;

package/dist/src/remote-devices.js

@@ -0,0 +1,156 @@
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import { CONFIG_DIR } from "./paths.js";
+import { join } from "node:path";
+export const DEVICES_PATH = join(CONFIG_DIR, "devices.json");
+export async function loadRemoteDevicesConfig(path = DEVICES_PATH) {
+    try {
+        const parsed = JSON.parse(await readFile(path, "utf8"));
+        return normalizeRemoteDevicesConfig(parsed);
+    }
+    catch (err) {
+        if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") {
+            return { devices: [] };
+        }
+        throw err;
+    }
+}
+export async function saveRemoteDevicesConfig(config, path = DEVICES_PATH) {
+    const normalized = normalizeRemoteDevicesConfig(config);
+    await mkdir(CONFIG_DIR, { recursive: true });
+    await writeFile(path, JSON.stringify(normalized, null, 2) + "\n", "utf8");
+    await chmod(path, 0o600).catch(() => undefined);
+    return normalized;
+}
+export function summarizeRemoteDevice(device) {
+    const auth = device.password ? "password" : device.passwordEnv ? "passwordEnv" : device.identityFile ? "identityFile" : "ssh-agent";
+    const { password: _password, ...rest } = device;
+    return {
+        ...rest,
+        auth,
+        hasPassword: Boolean(device.password)
+    };
+}
+export function listRemoteDeviceSummaries(config) {
+    return config.devices.map(summarizeRemoteDevice);
+}
+export function findRemoteDevice(config, idOrHost) {
+    const key = (idOrHost || config.defaultDevice || "").trim();
+    if (!key)
+        throw new Error("remote device is required");
+    const device = config.devices.find((entry) => entry.id === key || entry.host === key);
+    if (!device)
+        throw new Error(`remote device not found: ${key}`);
+    return device;
+}
+export function upsertRemoteDevice(config, raw) {
+    const device = normalizeRemoteDevice(raw, "device");
+    const devices = config.devices.filter((entry) => entry.id !== device.id);
+    devices.push(device);
+    return normalizeRemoteDevicesConfig({
+        defaultDevice: config.defaultDevice || device.id,
+        devices
+    });
+}
+export function deleteRemoteDevice(config, id) {
+    const key = id.trim();
+    if (!key)
+        throw new Error("remote device id is required");
+    const devices = config.devices.filter((entry) => entry.id !== key);
+    return normalizeRemoteDevicesConfig({
+        defaultDevice: config.defaultDevice === key ? devices[0]?.id : config.defaultDevice,
+        devices
+    });
+}
+export function setDefaultRemoteDevice(config, id) {
+    const device = findRemoteDevice(config, id);
+    return normalizeRemoteDevicesConfig({ ...config, defaultDevice: device.id });
+}
+export function normalizeRemoteDevicesConfig(raw) {
+    if (!raw || typeof raw !== "object")
+        throw new Error("remote devices config must be an object");
+    const input = raw;
+    if (!Array.isArray(input.devices))
+        throw new Error("remote devices config must include devices array");
+    const devices = input.devices.map((item, index) => normalizeRemoteDevice(item, `devices[${index}]`));
+    const ids = new Set();
+    for (const device of devices) {
+        if (ids.has(device.id))
+            throw new Error(`duplicate remote device id: ${device.id}`);
+        ids.add(device.id);
+    }
+    const defaultDevice = typeof input.defaultDevice === "string" && input.defaultDevice.trim() ? input.defaultDevice.trim() : undefined;
+    if (defaultDevice && !ids.has(defaultDevice))
+        throw new Error(`default remote device not found: ${defaultDevice}`);
+    return { ...(defaultDevice ? { defaultDevice } : {}), devices };
+}
+function normalizeRemoteDevice(raw, label) {
+    if (!raw || typeof raw !== "object")
+        throw new Error(`${label} must be an object`);
+    const input = raw;
+    const id = requiredString(input.id, `${label}.id`);
+    const host = requiredString(input.host, `${label}.host`);
+    const user = requiredString(input.user, `${label}.user`);
+    const port = optionalPort(input.port, `${label}.port`);
+    return {
+        id,
+        ...(optionalString(input.name) ? { name: optionalString(input.name) } : {}),
+        host,
+        ...(port ? { port } : {}),
+        user,
+        ...(optionalString(input.password) ? { password: optionalString(input.password) } : {}),
+        ...(optionalString(input.passwordEnv) ? { passwordEnv: optionalString(input.passwordEnv) } : {}),
+        ...(optionalString(input.identityFile) ? { identityFile: optionalString(input.identityFile) } : {}),
+        ...(optionalString(input.defaultApp) ? { defaultApp: optionalString(input.defaultApp) } : {}),
+        ...(input.apps && typeof input.apps === "object" ? { apps: normalizeApps(input.apps, `${label}.apps`) } : {}),
+        ...(input.databases && typeof input.databases === "object" ? { databases: normalizeServiceCommands(input.databases, `${label}.databases`) } : {}),
+        ...(input.redis && typeof input.redis === "object" ? { redis: normalizeServiceCommands(input.redis, `${label}.redis`) } : {})
+    };
+}
+function normalizeApps(raw, label) {
+    const result = {};
+    for (const [name, value] of Object.entries(raw)) {
+        if (!value || typeof value !== "object")
+            throw new Error(`${label}.${name} must be an object`);
+        const app = value;
+        result[name] = {
+            ...(app.installMarkers !== undefined ? { installMarkers: normalizeStringArray(app.installMarkers, `${label}.${name}.installMarkers`) } : {}),
+            ...(app.logRoots !== undefined ? { logRoots: normalizeStringArray(app.logRoots, `${label}.${name}.logRoots`) } : {}),
+            ...(app.errorPatterns !== undefined ? { errorPatterns: normalizeStringArray(app.errorPatterns, `${label}.${name}.errorPatterns`) } : {})
+        };
+    }
+    return result;
+}
+function normalizeServiceCommands(raw, label) {
+    const result = {};
+    for (const [name, value] of Object.entries(raw)) {
+        if (!value || typeof value !== "object")
+            throw new Error(`${label}.${name} must be an object`);
+        const service = value;
+        result[name] = {
+            ...(optionalString(service.type) ? { type: optionalString(service.type) } : {}),
+            command: requiredString(service.command, `${label}.${name}.command`)
+        };
+    }
+    return result;
+}
+function normalizeStringArray(raw, label) {
+    if (!Array.isArray(raw))
+        throw new Error(`${label} must be an array`);
+    return raw.map((item, index) => requiredString(item, `${label}[${index}]`));
+}
+function requiredString(raw, label) {
+    if (typeof raw !== "string" || !raw.trim())
+        throw new Error(`${label} must be a non-empty string`);
+    return raw.trim();
+}
+function optionalString(raw) {
+    return typeof raw === "string" && raw.trim() ? raw.trim() : undefined;
+}
+function optionalPort(raw, label) {
+    if (raw === undefined || raw === null || raw === "")
+        return undefined;
+    const port = typeof raw === "number" ? raw : Number.parseInt(String(raw), 10);
+    if (!Number.isInteger(port) || port < 1 || port > 65535)
+        throw new Error(`${label} must be between 1 and 65535`);
+    return port;
+}