@rynx-ai/cli 0.1.11-beta.1 → 0.1.11-beta.3

package/dist/commands/setup.js

@@ -0,0 +1,314 @@
+import { spawnSync } from "node:child_process";
+import { chmodSync, existsSync, mkdirSync, openSync, closeSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import path from "node:path";
+import * as prompts from "@clack/prompts";
+import { AGENT_RUNTIME_IDS, getRuntimeProfile, loadConfig, rynxConfigFile, } from "@rynx-ai/core";
+import { inspectDaemonDiagnostics, prepareBundledPlugins, } from "@rynx-ai/daemon/setup-service";
+import { fail } from "./errors.js";
+export async function runSetupCommand(args) {
+    const options = parseSetupOptions(args);
+    const interactive = !options.nonInteractive &&
+        !options.hasConfigurationArguments &&
+        Boolean(process.stdin.isTTY && process.stdout.isTTY);
+    const existing = readRawConfig();
+    const created = !existsSync(rynxConfigFile());
+    const defaults = loadConfig({});
+    const next = {
+        ...existing,
+        HOST: existing.HOST ?? defaults.HOST,
+        PORT: existing.PORT ?? defaults.PORT,
+        LOG_LEVEL: existing.LOG_LEVEL ?? defaults.LOG_LEVEL,
+        DEFAULT_RUNTIME: existing.DEFAULT_RUNTIME ?? defaults.DEFAULT_RUNTIME,
+    };
+    if (interactive) {
+        if (!await collectInteractiveSetup(next))
+            return 0;
+    }
+    else {
+        if (options.defaultRuntime !== undefined)
+            next.DEFAULT_RUNTIME = options.defaultRuntime;
+        if (options.host !== undefined)
+            next.HOST = options.host;
+        if (options.port !== undefined)
+            next.PORT = options.port;
+        if (options.logLevel !== undefined)
+            next.LOG_LEVEL = options.logLevel;
+    }
+    validateSetupConfig(next);
+    const updated = ["HOST", "PORT", "LOG_LEVEL", "DEFAULT_RUNTIME"].filter((key) => existing[key] !== next[key]);
+    writeConfigAtomically(next);
+    const result = {
+        configPath: rynxConfigFile(),
+        created,
+        updated,
+        browser: {
+            action: options.browser,
+            status: "skipped",
+        },
+        plugins: {
+            status: "ready",
+        },
+    };
+    let failed = false;
+    try {
+        const plugins = await prepareBundledPlugins();
+        result.plugins = {
+            status: plugins.status,
+            changed: [...plugins.installed, ...plugins.updated],
+        };
+    }
+    catch (error) {
+        failed = true;
+        result.plugins = {
+            status: "error",
+            detail: errorMessage(error),
+        };
+    }
+    const diagnostics = await inspectDaemonDiagnostics();
+    if (!diagnostics.browser.supported) {
+        result.browser = { action: options.browser, status: "unsupported" };
+    }
+    else if (diagnostics.browser.installedVersion) {
+        result.browser = {
+            action: options.browser,
+            status: "ready",
+            version: diagnostics.browser.installedVersion,
+        };
+    }
+    else if (options.browser !== "skip") {
+        try {
+            const { createBrowserArtifactManagementService } = await import("@rynx-ai/daemon/browser-artifacts");
+            const installed = await createBrowserArtifactManagementService().install({ channel: "stable" }, options.json
+                ? {}
+                : { onProgress: (message) => console.error(message) });
+            result.browser = {
+                action: options.browser,
+                status: "ready",
+                version: installed.installed.version,
+            };
+        }
+        catch (error) {
+            failed = true;
+            result.browser = {
+                action: options.browser,
+                status: "error",
+                detail: errorMessage(error),
+            };
+        }
+    }
+    if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else if (interactive) {
+        prompts.log.success(`已写入 ${result.configPath}`);
+        prompts.log.info(`HOST=${next.HOST} PORT=${next.PORT} DEFAULT_RUNTIME=${next.DEFAULT_RUNTIME}`);
+        if (result.browser.status === "ready") {
+            prompts.log.success(`Session Browser ${result.browser.version ?? "ready"}`);
+        }
+        else if (result.browser.status === "error") {
+            prompts.log.warn(`Session Browser: ${result.browser.detail}`);
+        }
+        prompts.outro(failed ? "初始化完成，但存在失败项" : "配置完成");
+    }
+    else {
+        console.log(`Initialized ${result.configPath}`);
+        if (result.browser.status === "ready") {
+            console.log(`Browser ready${result.browser.version ? `: ${result.browser.version}` : ""}`);
+        }
+    }
+    return failed ? 1 : 0;
+}
+export async function runDoctorCommand(args) {
+    const json = args.includes("--json");
+    if (args.some((arg) => arg !== "--json")) {
+        fail(`doctor: unexpected argument ${args.find((arg) => arg !== "--json")}`);
+    }
+    let config;
+    let configError;
+    try {
+        config = loadConfig();
+    }
+    catch (error) {
+        configError = errorMessage(error);
+    }
+    const runtimes = AGENT_RUNTIME_IDS.map((id) => {
+        const binary = getRuntimeProfile(id).defaultBinary;
+        const probe = spawnSync(binary, ["--version"], {
+            stdio: "ignore",
+            timeout: 8_000,
+        });
+        return { id, installed: !probe.error && probe.status === 0 };
+    });
+    const daemon = await inspectDaemonDiagnostics();
+    const result = {
+        ok: configError === undefined && runtimes.some((runtime) => runtime.installed),
+        configPath: rynxConfigFile(),
+        config,
+        configError,
+        runtimes,
+        daemon,
+    };
+    if (json)
+        console.log(JSON.stringify(result, null, 2));
+    else {
+        console.log(`config: ${result.configPath}`);
+        if (configError)
+            console.error(`config: ${configError}`);
+        else
+            console.log(`default runtime: ${config.DEFAULT_RUNTIME}`);
+        for (const runtime of runtimes) {
+            console.log(`${runtime.id}: ${runtime.installed ? "installed" : "not installed"}`);
+        }
+        if (daemon.browser.supported) {
+            console.log(`browser: ${daemon.browser.installedVersion ?? daemon.browser.error ?? "not installed"}`);
+        }
+        else {
+            console.log("browser: unsupported");
+        }
+    }
+    return result.ok ? 0 : 1;
+}
+function parseSetupOptions(args) {
+    const options = {
+        nonInteractive: false,
+        json: false,
+        browser: "auto",
+        hasConfigurationArguments: false,
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--non-interactive") {
+            options.nonInteractive = true;
+            continue;
+        }
+        if (arg === "--json") {
+            options.json = true;
+            options.nonInteractive = true;
+            continue;
+        }
+        if (arg === "--install-browser" || arg === "--skip-browser") {
+            if (options.browser !== "auto")
+                fail("setup: choose only one Browser action");
+            options.browser = arg === "--install-browser" ? "install" : "skip";
+            options.hasConfigurationArguments = true;
+            continue;
+        }
+        const value = args[index + 1];
+        if (!value || value.startsWith("--"))
+            fail(`setup: ${arg} requires a value`);
+        index += 1;
+        options.hasConfigurationArguments = true;
+        if (arg === "--default-runtime") {
+            if (!AGENT_RUNTIME_IDS.includes(value)) {
+                fail("setup: --default-runtime must be codex, traex, or claude");
+            }
+            options.defaultRuntime = value;
+        }
+        else if (arg === "--host") {
+            if (!value.trim() || value.length > 255)
+                fail("setup: --host is invalid");
+            options.host = value;
+        }
+        else if (arg === "--port") {
+            const port = Number(value);
+            if (!Number.isInteger(port) || port < 1 || port > 65_535) {
+                fail("setup: --port must be an integer from 1 to 65535");
+            }
+            options.port = port;
+        }
+        else if (arg === "--log-level") {
+            if (!value.trim() || value.length > 32)
+                fail("setup: --log-level is invalid");
+            options.logLevel = value;
+        }
+        else {
+            fail(`setup: unknown option ${arg}`);
+        }
+    }
+    return options;
+}
+async function collectInteractiveSetup(config) {
+    prompts.intro("rynx setup");
+    const runtime = await prompts.select({
+        message: "Default runtime",
+        initialValue: config.DEFAULT_RUNTIME,
+        options: AGENT_RUNTIME_IDS.map((id) => ({ value: id, label: id })),
+    });
+    if (prompts.isCancel(runtime))
+        return cancelled();
+    config.DEFAULT_RUNTIME = runtime;
+    const port = await prompts.text({
+        message: "HTTP port",
+        initialValue: String(config.PORT),
+        validate: (value) => {
+            const parsed = Number(value);
+            return Number.isInteger(parsed) && parsed > 0 && parsed <= 65_535
+                ? undefined
+                : "Enter a port from 1 to 65535";
+        },
+    });
+    if (prompts.isCancel(port))
+        return cancelled();
+    config.PORT = Number(port);
+    const host = await prompts.text({
+        message: "Bind host",
+        initialValue: String(config.HOST),
+    });
+    if (prompts.isCancel(host))
+        return cancelled();
+    config.HOST = host;
+    const logLevel = await prompts.text({
+        message: "Log level",
+        initialValue: String(config.LOG_LEVEL),
+    });
+    if (prompts.isCancel(logLevel))
+        return cancelled();
+    config.LOG_LEVEL = logLevel;
+    return true;
+}
+function cancelled() {
+    prompts.cancel("Cancelled");
+    return false;
+}
+function validateSetupConfig(config) {
+    loadConfig({
+        HOST: String(config.HOST),
+        PORT: String(config.PORT),
+        LOG_LEVEL: String(config.LOG_LEVEL),
+        DEFAULT_RUNTIME: String(config.DEFAULT_RUNTIME),
+    });
+}
+function readRawConfig() {
+    try {
+        const parsed = JSON.parse(readFileSync(rynxConfigFile(), "utf8"));
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function writeConfigAtomically(config) {
+    const file = rynxConfigFile();
+    const directory = path.dirname(file);
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const temporary = path.join(directory, `.${path.basename(file)}.${process.pid}.tmp`);
+    let descriptor;
+    try {
+        descriptor = openSync(temporary, "wx", 0o600);
+        writeFileSync(descriptor, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+        closeSync(descriptor);
+        descriptor = undefined;
+        renameSync(temporary, file);
+        chmodSync(file, 0o600);
+    }
+    finally {
+        if (descriptor !== undefined)
+            closeSync(descriptor);
+        rmSync(temporary, { force: true });
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/commands/skills.d.ts

@@ -1,10 +1,12 @@
 export interface BuiltinSkill {
     name: string;
-    directory: string;
-    skillFile: string;
+    description: string;
     content: string;
+    full: boolean;
 }
 export declare function runSkillsCommand(args: readonly string[]): Promise<number>;
 export declare function listBuiltinSkills(): Promise<BuiltinSkill[]>;
-export declare function readBuiltinSkill(name: string): Promise<BuiltinSkill | null>;
-export declare function builtinSkillsDirectory(moduleUrl?: string, env?: NodeJS.ProcessEnv): string;
+export declare function readBuiltinSkill(name: string, full?: boolean): Promise<BuiltinSkill | null>;
+/** Resolve only inside the independently published @rynx-ai/cli package.
+ * The source and compiled module depths are identical (`src|dist/commands`). */
+export declare function builtinSkillGuidesDirectory(moduleUrl?: string): string;

package/dist/commands/skills.js

@@ -1,21 +1,26 @@
-import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { fail } from "./errors.js";
 const SKILL_NAME_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/;
 const MAX_SKILL_BYTES = 256 * 1024;
+const BUILTIN_SKILL_NAMES = ["browser", "emulator"];
 export async function runSkillsCommand(args) {
     const [subcommand, name] = args;
     const json = args.includes("--json");
     if (subcommand === "list") {
         const skills = await listBuiltinSkills();
         if (json) {
-            console.log(JSON.stringify({ skills: skills.map(({ name: skillName }) => ({ name: skillName })) }, null, 2));
+            console.log(JSON.stringify({
+                topics: skills.map(({ name: topicName, description }) => ({
+                    name: topicName,
+                    description,
+                })),
+            }, null, 2));
         }
         else {
             for (const skill of skills)
-                console.log(skill.name);
+                console.log(`${skill.name}: ${skill.description}`);
         }
         return 0;
     }
@@ -23,15 +28,17 @@ export async function runSkillsCommand(args) {
         if (!name || name.startsWith("--")) {
             fail("skills get: missing Builtin Skill name");
         }
-        const skill = await readBuiltinSkill(name);
-        if (!skill)
-            fail(`Builtin Skill "${name}" was not found`);
+        const full = args.includes("--full");
+        const skill = await readBuiltinSkill(name, full);
+        if (!skill) {
+            const available = (await listBuiltinSkills()).map((entry) => entry.name).join(", ");
+            fail(`Unknown Skill guide "${name}". Available topics: ${available}`);
+        }
         if (json) {
             console.log(JSON.stringify({
                 name: skill.name,
-                directory: skill.directory,
-                skillFile: skill.skillFile,
-                content: skill.content,
+                full: skill.full,
+                markdown: skill.content,
             }, null, 2));
         }
         else {
@@ -44,21 +51,25 @@ export async function runSkillsCommand(args) {
     fail("skills: expected list or get <name>");
 }
 export async function listBuiltinSkills() {
-    const known = ["rynx-cli"];
-    const skills = await Promise.all(known.map((name) => readBuiltinSkill(name)));
-    return skills.filter((skill) => skill !== null);
+    const guides = await Promise.all(BUILTIN_SKILL_NAMES.map((name) => readBuiltinSkill(name)));
+    return guides.filter((guide) => guide !== null);
 }
-export async function readBuiltinSkill(name) {
+export async function readBuiltinSkill(name, full = false) {
     if (!SKILL_NAME_PATTERN.test(name))
         return null;
-    const directory = path.join(builtinSkillsDirectory(), name);
-    const skillFile = path.join(directory, "SKILL.md");
+    if (!BUILTIN_SKILL_NAMES.includes(name))
+        return null;
+    const guideFile = path.join(builtinSkillGuidesDirectory(), `${name}.md`);
     try {
-        const content = await readFile(skillFile, "utf8");
+        const content = await readFile(guideFile, "utf8");
         if (Buffer.byteLength(content, "utf8") > MAX_SKILL_BYTES) {
-            throw new Error(`Builtin Skill "${name}" exceeds ${MAX_SKILL_BYTES} bytes`);
+            throw new Error(`Builtin Skill guide "${name}" exceeds ${MAX_SKILL_BYTES} bytes`);
+        }
+        const metadata = parseGuideFrontmatter(content, guideFile);
+        if (metadata.name !== name) {
+            throw new Error(`Builtin Skill guide "${name}" declares name "${metadata.name}"`);
         }
-        return { name, directory, skillFile, content };
+        return { name, description: metadata.description, content, full };
     }
     catch (error) {
         if (error.code === "ENOENT")
@@ -66,15 +77,17 @@ export async function readBuiltinSkill(name) {
         throw error;
     }
 }
-export function builtinSkillsDirectory(moduleUrl = import.meta.url, env = process.env) {
-    const configured = env.RYNX_BUILTIN_SKILLS_DIR?.trim();
-    if (configured && path.isAbsolute(configured) && existsSync(configured)) {
-        return configured;
+/** Resolve only inside the independently published @rynx-ai/cli package.
+ * The source and compiled module depths are identical (`src|dist/commands`). */
+export function builtinSkillGuidesDirectory(moduleUrl = import.meta.url) {
+    return path.resolve(fileURLToPath(new URL("../../skill-guides/", moduleUrl)));
+}
+function parseGuideFrontmatter(markdown, sourcePath) {
+    const match = /^---\s*\n([\s\S]*?)\n---\s*(?:\n|$)/.exec(markdown);
+    const name = match && /^name:\s*(.+?)\s*$/m.exec(match[1])?.[1];
+    const description = match && /^description:\s*(.+?)\s*$/m.exec(match[1])?.[1];
+    if (!name || !description) {
+        throw new Error(`Builtin Skill guide must declare single-line name and description: ${sourcePath}`);
     }
-    const packaged = fileURLToPath(new URL("../../skills/", moduleUrl));
-    if (existsSync(packaged))
-        return packaged;
-    // Source-tree tests run before a package build has copied the canonical
-    // artifact. Published/App builds always take the packaged branch above.
-    return fileURLToPath(new URL("../../../../skills/", moduleUrl));
+    return { name, description: description.replace(/\s+/g, " ").trim() };
 }

package/dist/commands/update.d.ts

@@ -0,0 +1,20 @@
+export interface UpdateOptions {
+    check?: boolean;
+    json?: boolean;
+    version?: string;
+}
+export type UpdateCheck = {
+    status: "up_to_date";
+    current: string;
+} | {
+    status: "behind";
+    current: string;
+    latest: string;
+} | {
+    status: "error";
+    detail: string;
+};
+export declare function isNewer(latest: string, current: string): boolean;
+export declare function buildUpdateCheck(current: string, latest: string | null): UpdateCheck;
+export declare function checkStatusLine(current: string, latest: string | null): string;
+export declare function runUpdate(options: UpdateOptions): Promise<number>;