@rynx-ai/cli 0.1.11-beta.5 → 0.1.11-beta.51

package/dist/progress-display.js

@@ -0,0 +1,78 @@
+import * as prompts from "@clack/prompts";
+const DOWNLOAD_PERCENT_PATTERN = /下载进度：(\d{1,3})%$/u;
+export function createProgressDisplay() {
+    if (!prompts.isTTY(process.stdout) || prompts.isCI()) {
+        return {
+            start: (message) => console.log(message),
+            update: (message) => console.log(message),
+            succeed: (message) => console.log(message),
+            clear: () => undefined,
+        };
+    }
+    const spinner = prompts.spinner({ output: process.stdout });
+    const progress = prompts.progress({
+        output: process.stdout,
+        max: 100,
+        size: 28,
+        style: "block",
+    });
+    let spinnerActive = false;
+    let progressActive = false;
+    let completedPercent = 0;
+    const clear = () => {
+        if (progressActive)
+            progress.clear();
+        if (spinnerActive)
+            spinner.clear();
+        progressActive = false;
+        spinnerActive = false;
+        completedPercent = 0;
+    };
+    const finishDownload = () => {
+        if (!progressActive)
+            return;
+        progress.stop("Chrome for Testing 下载完成");
+        progressActive = false;
+        completedPercent = 0;
+    };
+    return {
+        start(message) {
+            clear();
+            spinner.start(message);
+            spinnerActive = true;
+        },
+        update(message) {
+            const match = DOWNLOAD_PERCENT_PATTERN.exec(message);
+            if (match) {
+                const percent = Math.min(100, Number(match[1]));
+                if (spinnerActive) {
+                    spinner.clear();
+                    spinnerActive = false;
+                }
+                if (!progressActive) {
+                    progress.start(message);
+                    progressActive = true;
+                }
+                progress.advance(percent - completedPercent, message);
+                completedPercent = percent;
+                return;
+            }
+            finishDownload();
+            if (spinnerActive)
+                spinner.message(message);
+            else {
+                spinner.start(message);
+                spinnerActive = true;
+            }
+        },
+        succeed(message) {
+            finishDownload();
+            if (spinnerActive)
+                spinner.stop(message);
+            else
+                prompts.log.success(message);
+            spinnerActive = false;
+        },
+        clear,
+    };
+}

package/dist/run-cli.js

@@ -62,6 +62,10 @@ export async function runCli(argv) {
             return runBrowserCommand(argv.slice(1));
         case "cleanup":
             return runCleanupCommand(argv.slice(1));
+        case "autostart": {
+            const { runAutostartCommand } = await import("./commands/autostart.js");
+            return runAutostartCommand(argv.slice(1));
+        }
         case "setup": {
             const { runSetupCommand } = await import("./commands/setup.js");
             return runSetupCommand(argv.slice(1));

package/dist/standalone.d.ts

@@ -9,5 +9,7 @@ export declare function ensureStandaloneDaemon(): Promise<{
     origin: string;
 }>;
 export declare function stopStandaloneDaemon(): Promise<number>;
-export declare function statusStandaloneDaemon(): Promise<number>;
+export declare function statusStandaloneDaemon(options?: {
+    json?: boolean;
+}): Promise<number>;
 export declare function streamStandaloneDaemonLogs(): Promise<void>;

package/dist/standalone.js

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { resolveBundledTmux } from "@rynx-ai/tmux";
 import { installedVersion } from "./version.js";
 import { ensureDaemonControlEndpoint, resolveDaemonControlEndpoint, } from "./control-endpoint.js";
 /** Resolve the canonical Builtin Skill directory shipped by this exact CLI. */
@@ -8,6 +9,7 @@ export function standaloneBuiltinSkillsDirectory(moduleUrl = import.meta.url) {
 }
 export async function startStandaloneDaemon(options = {}) {
     const cliVersion = installedVersion();
+    const tmuxBin = resolveBundledTmux();
     const { startDaemon } = await import("@rynx-ai/daemon/lifecycle");
     return startDaemon({
         force: options.restart ?? false,
@@ -16,6 +18,7 @@ export async function startStandaloneDaemon(options = {}) {
             builtinSkillsDir: standaloneBuiltinSkillsDirectory(),
             cliVersion,
             productVersion: cliVersion,
+            ...(tmuxBin ? { tmuxBin } : {}),
         },
     });
 }
@@ -44,7 +47,23 @@ export async function stopStandaloneDaemon() {
     const { stopDaemon } = await import("@rynx-ai/daemon/lifecycle");
     return stopDaemon();
 }
-export async function statusStandaloneDaemon() {
+export async function statusStandaloneDaemon(options = {}) {
+    if (options.json) {
+        const endpoint = await resolveDaemonControlEndpoint();
+        const status = endpoint
+            ? {
+                state: "running",
+                pid: endpoint.pid,
+                distribution: endpoint.distribution ?? "unknown",
+                lifecycle: endpoint.daemonLifecycle ?? "unknown",
+                version: endpoint.productVersion,
+                buildId: endpoint.buildId,
+                origin: endpoint.origin,
+            }
+            : { state: "stopped" };
+        console.log(JSON.stringify(status));
+        return endpoint ? 0 : 1;
+    }
     const { statusDaemon } = await import("@rynx-ai/daemon/lifecycle");
     return statusDaemon();
 }

package/dist/systemd-service.d.ts

@@ -0,0 +1,53 @@
+import type { AutostartRenderInput, AutostartState } from "./autostart.js";
+import { renderAutostartEnvironmentFile as renderSystemdEnvironmentFile } from "./autostart-environment.js";
+export { renderSystemdEnvironmentFile };
+export declare const RYNX_SYSTEMD_SERVICE = "rynx.service";
+export declare const RYNX_SYSTEMD_SERVICE_ENV = "RYNX_SYSTEMD_SERVICE";
+export interface LinuxSystemdServiceState {
+    loadState: string;
+    activeState: string;
+    subState: string;
+    type: string;
+    remainAfterExit: string;
+    killMode: string;
+    killSignal: string;
+    restartKillSignal: string;
+    finalKillSignal: string;
+    sendSigkill: string;
+    workingDirectory: string;
+    environment: string;
+    execStart: string;
+    execStop: string;
+}
+export interface LinuxPm2GodProcess {
+    pid: number;
+    cgroup: string;
+    startIdentity: string;
+}
+export type LinuxPm2GodInspection = {
+    kind: "absent";
+} | {
+    kind: "service-cgroup";
+    processes: LinuxPm2GodProcess[];
+} | {
+    kind: "external";
+    processes: LinuxPm2GodProcess[];
+};
+export interface LinuxPm2InspectionDeps {
+    procEntries?: () => string[];
+    readText?: (file: string) => string;
+    statUid?: (file: string) => number;
+    currentUid?: number;
+}
+export declare function renderSystemdUnit(input: AutostartRenderInput): string;
+export declare function linuxUserSystemdAvailable(): boolean;
+export declare function inspectLinuxAutostart(): AutostartState;
+export declare function enableLinuxAutostart(): void;
+export declare function disableLinuxAutostart(): void;
+/** Refresh an existing autostart unit without changing enablement. */
+export declare function refreshLinuxServiceIfPresent(): boolean;
+export declare function assertLinuxSystemdInvocation(): void;
+export declare function parseLinuxSystemdShow(output: string): LinuxSystemdServiceState;
+export declare function inspectLinuxPm2GodProcesses(home: string, deps?: LinuxPm2InspectionDeps): LinuxPm2GodInspection;
+export declare function scanLinuxPm2GodPids(home: string, deps?: LinuxPm2InspectionDeps): number[];
+export declare function linuxSystemdCgroupForPid(pid: number, readText?: (file: string) => string): string;