@runneth/cli 0.0.0-sha.3142666bf4dc.production

package/dist/skills.js

@@ -0,0 +1,89 @@
+import { cp, mkdir, readdir, readFile, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+const RUNNETH_SKILL_NAME = "runneth";
+const isRecord = (value) => {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+const isErrnoCode = (error, code) => {
+    return isRecord(error) && error.code === code;
+};
+const currentFilePath = () => {
+    return fileURLToPath(import.meta.url);
+};
+export const resolveBundledRunnethSkillPath = () => {
+    return path.resolve(path.dirname(currentFilePath()), "..", "skills", RUNNETH_SKILL_NAME);
+};
+const resolveCodexHome = () => {
+    const configured = process.env.CODEX_HOME;
+    if (configured === undefined) {
+        return path.join(os.homedir(), ".codex");
+    }
+    const normalized = configured.trim();
+    if (normalized.length === 0) {
+        throw new Error("CODEX_HOME must be a non-empty path");
+    }
+    return normalized;
+};
+const resolveAgentSkillsRoot = (agent) => {
+    switch (agent) {
+        case "claude": {
+            return path.join(os.homedir(), ".claude", "skills");
+        }
+        case "codex": {
+            return path.join(resolveCodexHome(), "skills");
+        }
+        default: {
+            const exhaustiveCheck = agent;
+            return exhaustiveCheck;
+        }
+    }
+};
+const validateRunnethSkillSource = async (sourcePath) => {
+    const skillPath = path.join(sourcePath, "SKILL.md");
+    const rawSkill = await readFile(skillPath, "utf8");
+    if (!/^---\r?\n/u.test(rawSkill)) {
+        throw new Error(`Bundled Runneth skill is missing frontmatter: ${skillPath}`);
+    }
+    if (!/\r?\nname:\s*runneth\r?\n/u.test(rawSkill)) {
+        throw new Error(`Bundled Runneth skill has an invalid name: ${skillPath}`);
+    }
+};
+const assertSafeSkillDirectory = async (targetPath) => {
+    const entries = await readdir(targetPath).catch((error) => {
+        if (isErrnoCode(error, "ENOENT")) {
+            return null;
+        }
+        throw error;
+    });
+    if (entries === null) {
+        return;
+    }
+    if (!entries.includes("SKILL.md")) {
+        throw new Error(`Refusing to replace non-skill directory: ${targetPath}`);
+    }
+};
+export const installRunnethSkills = async (options = {}) => {
+    const agents = options.agents ?? ["claude", "codex"];
+    const sourcePath = resolveBundledRunnethSkillPath();
+    await validateRunnethSkillSource(sourcePath);
+    const targets = [];
+    for (const agent of agents) {
+        const targetPath = path.join(resolveAgentSkillsRoot(agent), RUNNETH_SKILL_NAME);
+        await assertSafeSkillDirectory(targetPath);
+        await mkdir(path.dirname(targetPath), { recursive: true });
+        await rm(targetPath, { force: true, recursive: true });
+        await cp(sourcePath, targetPath, { recursive: true });
+        targets.push({
+            agent,
+            path: targetPath,
+        });
+    }
+    return {
+        skillName: RUNNETH_SKILL_NAME,
+        sourcePath,
+        targets,
+    };
+};

package/dist/ssh-stdio.d.ts

@@ -0,0 +1,63 @@
+import type { Readable, Writable } from "node:stream";
+import type { RunnethSshSetupResult } from "./ssh.js";
+type RunnethSshStdioStreams = Readonly<{
+    stderr: Writable;
+    stdin: Readable;
+    stdout: Writable;
+}>;
+export type RunnethSshStdioOptions = Readonly<{
+    defaultTimeoutMs?: number;
+    env?: NodeJS.ProcessEnv;
+    masterReadyTimeoutMs?: number;
+    maxFrameBytes?: number;
+    maxProcesses?: number;
+    setup: RunnethSshSetupResult;
+    sshCommand?: string;
+    streams?: RunnethSshStdioStreams;
+}>;
+type ExecRequest = Readonly<{
+    id: string;
+    method: "exec";
+    params: Readonly<{
+        command: string;
+        timeoutMs?: number;
+    }>;
+}>;
+type SpawnRequest = Readonly<{
+    id: string;
+    method: "spawn";
+    params: Readonly<{
+        command: string;
+    }>;
+}>;
+type StdinRequest = Readonly<{
+    id: string;
+    method: "stdin";
+    params: Readonly<{
+        data: string;
+    }>;
+}>;
+type SignalRequest = Readonly<{
+    id: string;
+    method: "signal";
+    params: Readonly<{
+        signal: ProcessSignal;
+    }>;
+}>;
+type CloseRequest = Readonly<{
+    id: string;
+    method: "close";
+}>;
+type ListRequest = Readonly<{
+    id: string;
+    method: "list";
+}>;
+type PingRequest = Readonly<{
+    id: string;
+    method: "ping";
+}>;
+type RunnethSshStdioRequest = CloseRequest | ExecRequest | ListRequest | PingRequest | SignalRequest | SpawnRequest | StdinRequest;
+type ProcessSignal = "SIGHUP" | "SIGINT" | "SIGKILL" | "SIGTERM";
+export declare const parseRunnethSshStdioRequest: (value: unknown) => RunnethSshStdioRequest;
+export declare const runRunnethSshStdio: (options: RunnethSshStdioOptions) => Promise<void>;
+export {};