@rynx-ai/cli 0.1.10

package/dist/commands/runtime.js

@@ -0,0 +1,136 @@
+import { encodePairingCode } from "@rynx-ai/protocol/direct-runtime";
+import { createResidentRemoteRuntimePairingOffer, forgetResidentRuntimeTarget, listResidentRemoteRuntimeClients, listResidentRuntimeTargets, pairResidentRuntimeTarget, revokeResidentRemoteRuntimeClient, testResidentRuntimeTarget, } from "../control-client.js";
+import { fail } from "./errors.js";
+export async function runRuntimeCommand(args) {
+    const [subcommand, arg] = args;
+    const json = args.includes("--json");
+    switch (subcommand) {
+        case "share":
+        case "pair": {
+            const label = optionValue(args, "--label");
+            const address = optionValue(args, "--address");
+            if (!address) {
+                fail("runtime share: pass --address with a host or ws(s) URL reachable by the other device");
+            }
+            const offer = await createResidentRemoteRuntimePairingOffer({
+                ...(label ? { clientLabel: label } : {}),
+                address,
+            });
+            console.log(json ? JSON.stringify(offer, null, 2) : encodePairingCode(offer));
+            return 0;
+        }
+        case "add": {
+            const name = optionValue(args, "--name");
+            const code = optionValue(args, "--pairing-code");
+            if (code === undefined && process.stdin.isTTY) {
+                fail("runtime add: pass --pairing-code or pipe a pairing link on stdin");
+            }
+            const raw = code ?? await readStdinBounded(64 * 1024);
+            if (!raw.trim()) {
+                fail("runtime add: pass --pairing-code or pipe a pairing link on stdin");
+            }
+            let offer = raw.trim();
+            if (raw.trim().startsWith("{")) {
+                try {
+                    offer = JSON.parse(raw);
+                }
+                catch {
+                    fail("runtime add: stdin is not valid pairing JSON");
+                }
+            }
+            const result = await pairResidentRuntimeTarget(offer, name);
+            if (json) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                console.log(`Paired ${result.target.displayName} (${result.target.daemonId}) ` +
+                    `via ${result.target.endpoint}.`);
+                console.log(`Remote instance: ${result.status.daemonInstanceId}`);
+            }
+            return 0;
+        }
+        case "list": {
+            const targets = await listResidentRuntimeTargets();
+            if (json) {
+                console.log(JSON.stringify({ runtimes: targets }, null, 2));
+                return 0;
+            }
+            console.log("Runtime targets");
+            for (const target of targets) {
+                const route = target.binding === "local" ? "local" : target.endpoint;
+                console.log(`  ${target.selector.padEnd(38)} ${target.displayName}  ${route}`);
+            }
+            return 0;
+        }
+        case "test": {
+            if (!arg || arg.startsWith("--"))
+                fail("runtime test: missing local or daemon id");
+            const result = await testResidentRuntimeTarget(arg);
+            if (json) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                console.log(`${result.target.displayName}: connected to ${result.status.daemonId} ` +
+                    `(instance ${result.status.daemonInstanceId})`);
+            }
+            return 0;
+        }
+        case "forget": {
+            if (!arg || arg.startsWith("--"))
+                fail("runtime forget: missing daemon id");
+            await forgetResidentRuntimeTarget(arg);
+            console.log(`Forgot Runtime target ${arg}.`);
+            return 0;
+        }
+        case "clients": {
+            if (arg === "list") {
+                const clients = await listResidentRemoteRuntimeClients();
+                if (json) {
+                    console.log(JSON.stringify({ clients }, null, 2));
+                    return 0;
+                }
+                console.log("Remote Runtime clients");
+                if (clients.length === 0)
+                    console.log("  (none)");
+                for (const client of clients) {
+                    const state = client.revokedAt ? "revoked" : "active";
+                    console.log(`  ${client.grantId.padEnd(38)} ${client.clientLabel ?? client.clientId}  ${state}`);
+                }
+                return 0;
+            }
+            if (arg === "revoke") {
+                const grantId = args[2];
+                if (!grantId || grantId.startsWith("--")) {
+                    fail("runtime clients revoke: missing grant id");
+                }
+                const result = await revokeResidentRemoteRuntimeClient(grantId);
+                console.log(`Revoked ${grantId}; closed ${result.closedConnections} active connection(s).`);
+                return 0;
+            }
+            fail("runtime clients: expected list or revoke <grant-id>");
+        }
+        default:
+            fail("runtime: expected share, add, list, test, forget, or clients");
+    }
+}
+function optionValue(args, option) {
+    const index = args.indexOf(option);
+    if (index < 0)
+        return undefined;
+    const value = args[index + 1];
+    if (!value || value.startsWith("--"))
+        fail(`${option}: missing value`);
+    return value;
+}
+async function readStdinBounded(maxBytes) {
+    const chunks = [];
+    let bytes = 0;
+    for await (const chunk of process.stdin) {
+        const value = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        bytes += value.byteLength;
+        if (bytes > maxBytes)
+            fail(`stdin exceeds ${maxBytes} bytes`);
+        chunks.push(value);
+    }
+    return Buffer.concat(chunks, bytes).toString("utf8");
+}

package/dist/commands/skills.d.ts

@@ -0,0 +1,10 @@
+export interface BuiltinSkill {
+    name: string;
+    directory: string;
+    skillFile: string;
+    content: string;
+}
+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;

package/dist/commands/skills.js

@@ -0,0 +1,80 @@
+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;
+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));
+        }
+        else {
+            for (const skill of skills)
+                console.log(skill.name);
+        }
+        return 0;
+    }
+    if (subcommand === "get") {
+        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`);
+        if (json) {
+            console.log(JSON.stringify({
+                name: skill.name,
+                directory: skill.directory,
+                skillFile: skill.skillFile,
+                content: skill.content,
+            }, null, 2));
+        }
+        else {
+            process.stdout.write(skill.content);
+            if (!skill.content.endsWith("\n"))
+                process.stdout.write("\n");
+        }
+        return 0;
+    }
+    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);
+}
+export async function readBuiltinSkill(name) {
+    if (!SKILL_NAME_PATTERN.test(name))
+        return null;
+    const directory = path.join(builtinSkillsDirectory(), name);
+    const skillFile = path.join(directory, "SKILL.md");
+    try {
+        const content = await readFile(skillFile, "utf8");
+        if (Buffer.byteLength(content, "utf8") > MAX_SKILL_BYTES) {
+            throw new Error(`Builtin Skill "${name}" exceeds ${MAX_SKILL_BYTES} bytes`);
+        }
+        return { name, directory, skillFile, content };
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        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;
+    }
+    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));
+}

package/dist/control-client.d.ts

@@ -0,0 +1,163 @@
+import { type DaemonStatus } from "@rynx-ai/protocol/remote-runtime";
+import { type DaemonBrowserArtifactCleanResult, type DaemonBrowserArtifactInstallInput, type DaemonBrowserArtifactInstallResult, type DaemonBrowserArtifactUpdateInput, type DaemonBrowserArtifactVersionResult, type DaemonCleanupSessionsInput, type DaemonCleanupSessionsResult, type DaemonChromeInspectionConfigureInput, type DaemonChromeInspectionStatus, type DaemonShutdownIfIdleResult } from "@rynx-ai/protocol/control";
+import { type RemoteRuntimeRpcMethod, type RemoteRuntimeRpcParams, type RemoteRuntimeRpcResultFor } from "@rynx-ai/protocol/remote-runtime-rpc";
+import { type PairingOffer } from "@rynx-ai/protocol/direct-runtime";
+import { type RuntimeBrowserBootstrapCredential, type RuntimeBrowserEndpointDescriptor } from "@rynx-ai/protocol/runtime-browser-bootstrap";
+import { type PluginInstallCommitInput, type PluginInstallCommitResult, type PluginInstallPreparation, type PluginInstallPrepareInput, type PluginManagementItem, type PluginManagementState } from "@rynx-ai/protocol/plugin-management";
+export { connectResidentDesktopBrowserHost, type ResidentDesktopBrowserHostConnection, type ResidentDesktopBrowserHostCommandRequest, type ResidentDesktopBrowserHostConnectOptions, type ResidentDesktopBrowserHostFailure, } from "./desktop-browser-host-client.js";
+export interface ResidentDaemon {
+    origin: string;
+}
+export interface ResidentDaemonIdentity {
+    installationId: string;
+    algorithm: "Ed25519";
+    publicKey: string;
+}
+export interface ResidentPluginCommandResult {
+    code: number;
+    stdout: string;
+    stderr: string;
+    truncated: boolean;
+}
+export type ResidentPluginManagementState = PluginManagementState;
+export type ResidentPluginManagementItem = PluginManagementItem;
+export interface ResidentRemoteRuntimeClientGrant {
+    grantId: string;
+    clientId: string;
+    clientLabel: string | null;
+    clientKeyFingerprint: string;
+    authorities: string[];
+    createdAt: string;
+    revokedAt: string | null;
+    lastUsedAt: string | null;
+}
+export interface ResidentRuntimeTargetView {
+    selector: string;
+    daemonId: string;
+    displayName: string;
+    binding: "local" | "direct";
+    endpoint?: string;
+    identityKeyFingerprint?: string;
+    createdAt?: string;
+}
+export interface ResidentRuntimeTargetTestResult {
+    target: ResidentRuntimeTargetView;
+    status: DaemonStatus;
+}
+export interface InvokeResidentPluginCommandOptions {
+    stdin?: string;
+    signal?: AbortSignal;
+}
+export type ResidentRuntimeCallErrorCode = "invalid_target" | "invalid_request" | "not_found" | "conflict" | "failed_precondition" | "method_not_found" | "deadline_exceeded" | "unreachable" | "tls_error" | "identity_mismatch" | "incompatible" | "authentication_failed" | "protocol_error" | "operation_failed" | "outcome_unknown" | "cancelled" | "unauthorized" | "closed" | "internal" | "internal_error";
+export type ResidentRuntimeCallOutcome = "not_started" | "unknown";
+/** Stable error returned by the resident daemon's typed Runtime gateway. */
+export declare class ResidentRuntimeCallError extends Error {
+    readonly code: ResidentRuntimeCallErrorCode;
+    readonly status?: number | undefined;
+    readonly outcome?: ResidentRuntimeCallOutcome;
+    constructor(code: ResidentRuntimeCallErrorCode, message: string, status?: number | undefined, options?: ErrorOptions & {
+        outcome?: ResidentRuntimeCallOutcome;
+    });
+}
+/** Connect to the resident daemon already owned by the App or standalone supervisor. */
+export declare function ensureResidentDaemon(): Promise<ResidentDaemon>;
+/** Read the stable public identity of the single resident daemon. */
+export declare function getResidentDaemonIdentity(): Promise<ResidentDaemonIdentity>;
+/** Read the transport-independent status of the resident daemon process. */
+export declare function getResidentDaemonRuntimeStatus(): Promise<DaemonStatus>;
+/**
+ * Ask the resident daemon to perform one final activity check and stop only
+ * when idle. Busy is a normal result so the caller can ask the user to resolve
+ * the listed work and explicitly retry.
+ */
+export declare function shutdownResidentDaemonIfIdle(): Promise<DaemonShutdownIfIdleResult>;
+export declare function getResidentChromeInspectionStatus(): Promise<DaemonChromeInspectionStatus>;
+export declare function configureResidentChromeInspection(input: DaemonChromeInspectionConfigureInput): Promise<DaemonChromeInspectionStatus>;
+export declare function installResidentBrowserArtifact(input: DaemonBrowserArtifactInstallInput): Promise<DaemonBrowserArtifactInstallResult>;
+export declare function updateResidentBrowserArtifact(input: DaemonBrowserArtifactUpdateInput): Promise<DaemonBrowserArtifactInstallResult>;
+export declare function getResidentBrowserArtifactVersion(): Promise<DaemonBrowserArtifactVersionResult>;
+export declare function cleanResidentBrowserArtifacts(): Promise<DaemonBrowserArtifactCleanResult>;
+export declare function cleanupResidentSessions(input?: DaemonCleanupSessionsInput): Promise<DaemonCleanupSessionsResult>;
+/** Create one pairing offer on the resident daemon for a selected reachable route. */
+export declare function createResidentRemoteRuntimePairingOffer(input?: {
+    clientLabel?: string;
+    address?: string;
+}): Promise<PairingOffer>;
+/** List redacted client grants accepted by the resident daemon. */
+export declare function listResidentRemoteRuntimeClients(): Promise<ResidentRemoteRuntimeClientGrant[]>;
+/** Revoke one resident-daemon client grant and close its active channels. */
+export declare function revokeResidentRemoteRuntimeClient(grantId: string): Promise<{
+    revoked: true;
+    closedConnections: number;
+}>;
+/** List local and paired Runtime targets through the resident daemon BFF. */
+export declare function listResidentRuntimeTargets(): Promise<ResidentRuntimeTargetView[]>;
+/** Pair a target; the offer remains inside the loopback management request. */
+export declare function pairResidentRuntimeTarget(offer: unknown, displayName?: string): Promise<ResidentRuntimeTargetTestResult>;
+export declare function testResidentRuntimeTarget(selector: string): Promise<ResidentRuntimeTargetTestResult>;
+export declare function forgetResidentRuntimeTarget(daemonId: string): Promise<{
+    forgotten: true;
+}>;
+/**
+ * Invoke one typed Runtime method through the single resident daemon.
+ *
+ * The short-lived CLI process never reads Direct credentials or opens a
+ * remote socket. The resident daemon owns target resolution, Local/Direct
+ * connection reuse, authorization and no-retry outcome semantics.
+ */
+export declare function callResidentRuntime<M extends RemoteRuntimeRpcMethod>(selectorInput: string, method: M, params: RemoteRuntimeRpcParams<M>, options?: {
+    signal?: AbortSignal;
+}): Promise<RemoteRuntimeRpcResultFor<M>>;
+/** Read the current managed Session credential without exposing it in output. */
+export declare function readManagedRuntimeBrowserCredential(env?: NodeJS.ProcessEnv): Promise<RuntimeBrowserBootstrapCredential>;
+/** Return undefined only when the process has no managed Session context at all. */
+export declare function readOptionalManagedRuntimeBrowserCredential(env?: NodeJS.ProcessEnv): Promise<RuntimeBrowserBootstrapCredential | undefined>;
+/**
+ * Invoke Browser control for the caller's own managed Session. Unlike the
+ * operator Runtime gateway, this path never reads or sends daemon management
+ * authority and cannot select a remote Runtime or another Session.
+ */
+export declare function callManagedRuntimeBrowser<M extends RemoteRuntimeRpcMethod>(credential: RuntimeBrowserBootstrapCredential, method: M, params: RemoteRuntimeRpcParams<M>, options?: {
+    signal?: AbortSignal;
+}): Promise<RemoteRuntimeRpcResultFor<M>>;
+/** Resolve native CDP for the caller's own Session on this Runtime only. */
+export declare function getResidentRuntimeLocalBrowserEndpoint(options?: {
+    env?: NodeJS.ProcessEnv;
+    sessionId?: string;
+    signal?: AbortSignal;
+}): Promise<RuntimeBrowserEndpointDescriptor>;
+/**
+ * Resolve CDP together with the Runtime-scoped MAC key used for opaque
+ * automation refs. Keep the key in-process; it must never be printed.
+ */
+export declare function getResidentRuntimeLocalBrowserAutomationAccess(options?: {
+    env?: NodeJS.ProcessEnv;
+    sessionId?: string;
+    signal?: AbortSignal;
+}): Promise<{
+    descriptor: RuntimeBrowserEndpointDescriptor;
+    referenceKey: string;
+}>;
+/** Invoke one command declared by an installed plugin through the resident daemon. */
+export declare function invokeResidentPluginCommand(pluginId: string, args: readonly string[], options?: InvokeResidentPluginCommandOptions): Promise<ResidentPluginCommandResult>;
+/** Read the daemon-owned plugin registry without exposing package paths/specs. */
+export declare function listResidentPlugins(): Promise<ResidentPluginManagementItem[]>;
+/** Enable or disable one installed plugin through authenticated management RPC. */
+export declare function setResidentPluginEnabled(pluginId: string, enabled: boolean): Promise<ResidentPluginManagementItem>;
+/** Remove one plugin registry entry through authenticated management RPC. */
+export declare function uninstallResidentPlugin(pluginId: string): Promise<{
+    uninstalled: true;
+    pluginId: string;
+}>;
+/** Reload one plugin runtime after a durable registry mutation. */
+export declare function reloadResidentPluginRuntime(pluginId: string): Promise<Record<string, unknown>>;
+/** Materialize and hold one exact plugin artifact in daemon-owned staging. */
+export declare function prepareResidentPluginInstallation(input: PluginInstallPrepareInput, options?: {
+    signal?: AbortSignal;
+}): Promise<PluginInstallPreparation>;
+/** Consume one preparation token and promote only its already-approved artifact. */
+export declare function commitResidentPluginInstallation(token: string, input: PluginInstallCommitInput, options?: {
+    signal?: AbortSignal;
+}): Promise<PluginInstallCommitResult>;
+/** Best-effort early release when the user declines a prepared artifact. */
+export declare function cancelResidentPluginInstallation(token: string): Promise<boolean>;