@runneth/cli 0.0.0-sha.19a36f654ef6.production

package/dist/index.js

@@ -0,0 +1,547 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { mkdir, rm } from "node:fs/promises";
+import net from "node:net";
+import path from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+export { assertRunnethVmCopyTargetsUseSameResource, runRunnethVmCopy, } from "./copy.js";
+export { getOAuthAccessToken, loginWithOAuth, logoutOAuthCredential, readOAuthCredential, readOAuthCredentialStatus, resolveOAuthCredentialPath, } from "./oauth.js";
+export { resolveRunnethCliHome, resolveSocketPath } from "./paths.js";
+export { installRunnethSshAccess, normalizeRunnethSshTargetName, readRunnethSshTargetStore, removeRunnethSshTarget, resolveRunnethSshTarget, resolveRunnethSshAppUrl, resolveRunnethSshSharedKeyPaths, resolveRunnethSshTargetsPath, resolveRunnethSshTargetPaths, runOpenSsh, runRunnethSshProxy, saveRunnethSshTarget, setDefaultRunnethSshTarget, } from "./ssh.js";
+export { installRunnethSkills, resolveBundledRunnethSkillPath, } from "./skills.js";
+const DEFAULT_SESSION_NAME = "default";
+const MAX_REQUEST_BYTES = 2_000_000;
+const MAX_IDLE_BUFFER_BYTES = 2_000_000;
+const SESSION_NAME_PATTERN = /^[A-Za-z0-9._-]{1,64}$/u;
+const SOCKET_CONNECT_TIMEOUT_MS = 500;
+const DAEMON_START_TIMEOUT_MS = 5_000;
+const DEFAULT_REQUEST_TIMEOUT_MS = 600_000;
+const nowIso = () => {
+    return new Date().toISOString();
+};
+const isRecord = (value) => {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+const isErrnoCode = (error, code) => {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === code);
+};
+const errorMessage = (error) => {
+    return error instanceof Error ? error.message : String(error);
+};
+export const normalizeSessionName = (value) => {
+    const name = value?.trim() || DEFAULT_SESSION_NAME;
+    if (!SESSION_NAME_PATTERN.test(name)) {
+        throw new Error(`Invalid session name: ${name}. Use letters, numbers, dot, underscore, and dash only.`);
+    }
+    return name;
+};
+const parseString = (record, key) => {
+    const value = record[key];
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`${key} must be a non-empty string`);
+    }
+    return value;
+};
+const parseOptionalString = (record, key) => {
+    const value = record[key];
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`${key} must be a non-empty string`);
+    }
+    return value;
+};
+export const parseRunnethCliRequest = (value) => {
+    if (!isRecord(value)) {
+        throw new Error("Request must be a JSON object");
+    }
+    const op = parseString(value, "op");
+    switch (op) {
+        case "open": {
+            return {
+                cwd: parseString(value, "cwd"),
+                name: normalizeSessionName(parseString(value, "name")),
+                op,
+                ...(parseOptionalString(value, "shell")
+                    ? { shell: parseOptionalString(value, "shell") }
+                    : {}),
+            };
+        }
+        case "send": {
+            return {
+                command: parseString(value, "command"),
+                cwd: parseString(value, "cwd"),
+                name: normalizeSessionName(parseString(value, "name")),
+                op,
+                ...(parseOptionalString(value, "shell")
+                    ? { shell: parseOptionalString(value, "shell") }
+                    : {}),
+            };
+        }
+        case "status":
+        case "close": {
+            return {
+                name: normalizeSessionName(parseString(value, "name")),
+                op,
+            };
+        }
+        case "list":
+        case "ping":
+        case "shutdown": {
+            return { op };
+        }
+        default: {
+            throw new Error(`Unknown operation: ${op}`);
+        }
+    }
+};
+const defaultShell = () => {
+    const configuredShell = process.env.RUNNETH_CLI_SHELL?.trim() || process.env.SHELL?.trim();
+    return configuredShell && configuredShell.length > 0
+        ? configuredShell
+        : "/bin/sh";
+};
+const appendBuffer = (current, chunk) => {
+    const next = Buffer.concat([current, chunk]);
+    if (next.length <= MAX_IDLE_BUFFER_BYTES) {
+        return next;
+    }
+    return next.subarray(next.length - MAX_IDLE_BUFFER_BYTES);
+};
+const notifyWaiters = (session) => {
+    const waiters = [...session.waiters];
+    session.waiters.clear();
+    for (const waiter of waiters) {
+        waiter();
+    }
+};
+const waitForSessionChange = async (session) => {
+    if (session.closed) {
+        return;
+    }
+    await new Promise((resolve) => {
+        session.waiters.add(resolve);
+    });
+};
+const toPublicSession = (session) => {
+    return {
+        busy: session.busy,
+        cwd: session.cwd,
+        name: session.name,
+        pid: session.child.pid ?? 0,
+        running: !session.closed,
+        sessionId: session.sessionId,
+        shell: session.shell,
+        startedAt: session.startedAt,
+    };
+};
+export const createCommandEnvelope = (command) => {
+    const marker = `RUNNETH_CLI_${randomUUID().replace(/-/gu, "")}`;
+    return {
+        input: [
+            `printf '\\n${marker}:start\\n'`,
+            command,
+            "__runneth_cli_status=$?",
+            `printf '\\n${marker}:end:%s\\n' "$__runneth_cli_status"`,
+            "",
+        ].join("\n"),
+        marker,
+    };
+};
+export const extractCommandResult = (input) => {
+    const text = input.stdout.toString("utf8");
+    const startToken = `\n${input.marker}:start\n`;
+    const startIndex = text.indexOf(startToken);
+    if (startIndex === -1) {
+        return null;
+    }
+    const contentStartIndex = startIndex + startToken.length;
+    const endPrefix = `\n${input.marker}:end:`;
+    const endIndex = text.indexOf(endPrefix, contentStartIndex);
+    if (endIndex === -1) {
+        return null;
+    }
+    const exitCodeStartIndex = endIndex + endPrefix.length;
+    const endLineIndex = text.indexOf("\n", exitCodeStartIndex);
+    if (endLineIndex === -1) {
+        return null;
+    }
+    const rawExitCode = text.slice(exitCodeStartIndex, endLineIndex);
+    if (!/^\d+$/u.test(rawExitCode)) {
+        throw new Error(`Invalid runneth-cli marker exit code: ${rawExitCode}`);
+    }
+    const contentStartBytes = Buffer.byteLength(text.slice(0, contentStartIndex), "utf8");
+    const contentEndBytes = Buffer.byteLength(text.slice(0, endIndex), "utf8");
+    const consumedStdoutBytes = Buffer.byteLength(text.slice(0, endLineIndex + 1), "utf8");
+    return {
+        consumedStdoutBytes,
+        exitCode: Number(rawExitCode),
+        stdout: input.stdout
+            .subarray(contentStartBytes, contentEndBytes)
+            .toString("utf8"),
+    };
+};
+export class RunnethCliDaemon {
+    #sessions = new Map();
+    #server = null;
+    #socketPath = null;
+    async start(options) {
+        if (this.#server !== null) {
+            throw new Error("runneth-cli daemon is already started");
+        }
+        if (process.platform !== "win32") {
+            await rm(options.socketPath, { force: true });
+            await mkdir(path.dirname(options.socketPath), { recursive: true });
+        }
+        const server = net.createServer((socket) => {
+            this.#handleSocket(socket);
+        });
+        await new Promise((resolve, reject) => {
+            server.once("error", reject);
+            server.listen(options.socketPath, () => {
+                server.off("error", reject);
+                resolve();
+            });
+        });
+        this.#server = server;
+        this.#socketPath = options.socketPath;
+    }
+    async stop() {
+        for (const session of this.#sessions.values()) {
+            this.#closeSession(session);
+        }
+        this.#sessions.clear();
+        const server = this.#server;
+        this.#server = null;
+        if (server !== null) {
+            await new Promise((resolve, reject) => {
+                server.close((error) => {
+                    if (error) {
+                        reject(error);
+                        return;
+                    }
+                    resolve();
+                });
+            });
+        }
+        if (this.#socketPath !== null && process.platform !== "win32") {
+            await rm(this.#socketPath, { force: true });
+        }
+    }
+    async handleRequest(request) {
+        switch (request.op) {
+            case "open": {
+                const session = this.#openSession(request);
+                return {
+                    ok: true,
+                    op: "open",
+                    session: toPublicSession(session),
+                };
+            }
+            case "send": {
+                const session = this.#openSession(request);
+                const output = await this.#sendQueued(session, request.command);
+                return {
+                    exitCode: output.exitCode,
+                    ok: true,
+                    op: "send",
+                    session: toPublicSession(session),
+                    stderr: output.stderr,
+                    stdout: output.stdout,
+                };
+            }
+            case "status": {
+                const session = this.#sessions.get(request.name) ?? null;
+                return {
+                    ok: true,
+                    op: "status",
+                    session: session === null ? null : toPublicSession(session),
+                };
+            }
+            case "list": {
+                return {
+                    ok: true,
+                    op: "list",
+                    sessions: [...this.#sessions.values()].map(toPublicSession),
+                };
+            }
+            case "close": {
+                const session = this.#sessions.get(request.name);
+                if (session === undefined) {
+                    throw new Error(`Session is not open: ${request.name}`);
+                }
+                this.#sessions.delete(request.name);
+                this.#closeSession(session);
+                return {
+                    ok: true,
+                    op: "close",
+                    session: toPublicSession(session),
+                };
+            }
+            case "ping": {
+                return {
+                    ok: true,
+                    op: "ping",
+                };
+            }
+            case "shutdown": {
+                setImmediate(() => {
+                    void this.stop();
+                });
+                return {
+                    ok: true,
+                    op: "shutdown",
+                };
+            }
+            default: {
+                const exhaustiveCheck = request;
+                return exhaustiveCheck;
+            }
+        }
+    }
+    #openSession(input) {
+        const existing = this.#sessions.get(input.name);
+        if (existing !== undefined && !existing.closed) {
+            return existing;
+        }
+        const shell = input.shell?.trim() || defaultShell();
+        const child = spawn(shell, [], {
+            cwd: input.cwd,
+            env: process.env,
+            stdio: "pipe",
+        });
+        child.stdin.setDefaultEncoding("utf8");
+        const session = {
+            busy: false,
+            child,
+            closed: false,
+            cwd: input.cwd,
+            name: input.name,
+            queue: Promise.resolve(),
+            sessionId: randomUUID(),
+            shell,
+            startedAt: nowIso(),
+            stderr: Buffer.alloc(0),
+            stdout: Buffer.alloc(0),
+            waiters: new Set(),
+        };
+        child.stdout.on("data", (chunk) => {
+            session.stdout = appendBuffer(session.stdout, chunk);
+            notifyWaiters(session);
+        });
+        child.stderr.on("data", (chunk) => {
+            session.stderr = appendBuffer(session.stderr, chunk);
+            notifyWaiters(session);
+        });
+        child.once("close", () => {
+            session.closed = true;
+            session.busy = false;
+            notifyWaiters(session);
+        });
+        child.once("error", () => {
+            session.closed = true;
+            session.busy = false;
+            notifyWaiters(session);
+        });
+        this.#sessions.set(input.name, session);
+        return session;
+    }
+    async #sendQueued(session, command) {
+        const runPromise = session.queue.then(async () => {
+            session.busy = true;
+            try {
+                return await this.#send(session, command);
+            }
+            finally {
+                session.busy = false;
+            }
+        });
+        session.queue = runPromise.then(() => undefined, () => undefined);
+        return await runPromise;
+    }
+    async #send(session, command) {
+        if (session.closed || !session.child.stdin.writable) {
+            throw new Error(`Session is closed: ${session.name}`);
+        }
+        const envelope = createCommandEnvelope(command);
+        const startStdoutLength = session.stdout.length;
+        const startStderrLength = session.stderr.length;
+        await new Promise((resolve, reject) => {
+            session.child.stdin.write(envelope.input, (error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve();
+            });
+        });
+        while (true) {
+            const stdoutWindow = session.stdout.subarray(startStdoutLength);
+            const extracted = extractCommandResult({
+                marker: envelope.marker,
+                stdout: stdoutWindow,
+            });
+            if (extracted !== null) {
+                const stderr = session.stderr
+                    .subarray(startStderrLength)
+                    .toString("utf8");
+                session.stdout = session.stdout.subarray(startStdoutLength + extracted.consumedStdoutBytes);
+                session.stderr = Buffer.alloc(0);
+                return {
+                    exitCode: extracted.exitCode,
+                    stderr,
+                    stdout: extracted.stdout,
+                };
+            }
+            if (session.closed) {
+                throw new Error(`Session exited before command completed: ${session.name}`);
+            }
+            await waitForSessionChange(session);
+        }
+    }
+    #closeSession(session) {
+        session.closed = true;
+        session.busy = false;
+        notifyWaiters(session);
+        if (!session.child.killed) {
+            session.child.kill("SIGTERM");
+        }
+    }
+    #handleSocket(socket) {
+        let buffer = "";
+        let handled = false;
+        socket.setEncoding("utf8");
+        socket.on("data", (chunk) => {
+            if (handled) {
+                return;
+            }
+            buffer += chunk;
+            if (buffer.length > MAX_REQUEST_BYTES) {
+                handled = true;
+                socket.end(`${JSON.stringify({ ok: false, error: "Request is too large" })}\n`);
+                return;
+            }
+            const newlineIndex = buffer.indexOf("\n");
+            if (newlineIndex === -1) {
+                return;
+            }
+            handled = true;
+            const rawLine = buffer.slice(0, newlineIndex);
+            void this.#handleSocketLine(socket, rawLine);
+        });
+    }
+    async #handleSocketLine(socket, rawLine) {
+        try {
+            const request = parseRunnethCliRequest(JSON.parse(rawLine));
+            const response = await this.handleRequest(request);
+            if (!socket.destroyed) {
+                socket.end(`${JSON.stringify(response)}\n`);
+            }
+        }
+        catch (error) {
+            if (!socket.destroyed) {
+                socket.end(`${JSON.stringify({
+                    error: errorMessage(error),
+                    ok: false,
+                })}\n`);
+            }
+        }
+    }
+}
+export const sendRunnethCliRequest = async (input) => {
+    const timeoutMs = input.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    return await new Promise((resolve, reject) => {
+        const socket = net.createConnection(input.socketPath);
+        let settled = false;
+        let buffer = "";
+        const timeout = setTimeout(() => {
+            settleError(new Error(`Timed out waiting for runneth-cli response after ${String(timeoutMs)}ms`));
+        }, timeoutMs);
+        const cleanup = () => {
+            clearTimeout(timeout);
+            socket.removeAllListeners();
+            socket.destroy();
+        };
+        const settle = (response) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            cleanup();
+            resolve(response);
+        };
+        const settleError = (error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            cleanup();
+            reject(error);
+        };
+        socket.setEncoding("utf8");
+        socket.once("connect", () => {
+            socket.write(`${JSON.stringify(input.request)}\n`);
+        });
+        socket.once("error", settleError);
+        socket.on("data", (chunk) => {
+            buffer += chunk;
+            const newlineIndex = buffer.indexOf("\n");
+            if (newlineIndex === -1) {
+                return;
+            }
+            try {
+                const parsed = JSON.parse(buffer.slice(0, newlineIndex));
+                if (!isRecord(parsed) || typeof parsed.ok !== "boolean") {
+                    throw new Error("Invalid runneth-cli daemon response");
+                }
+                settle(parsed);
+            }
+            catch (error) {
+                settleError(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    });
+};
+const canConnect = async (socketPath) => {
+    try {
+        const response = await sendRunnethCliRequest({
+            request: { op: "ping" },
+            socketPath,
+            timeoutMs: SOCKET_CONNECT_TIMEOUT_MS,
+        });
+        return response.ok === true;
+    }
+    catch {
+        return false;
+    }
+};
+export const startDaemonProcess = async (input) => {
+    if (process.platform !== "win32") {
+        await rm(input.socketPath, { force: true });
+        await mkdir(path.dirname(input.socketPath), { recursive: true });
+    }
+    const child = spawn(process.execPath, [input.cliPath, "daemon", input.socketPath], {
+        detached: true,
+        env: process.env,
+        stdio: "ignore",
+    });
+    child.unref();
+};
+export const ensureDaemon = async (input) => {
+    if (await canConnect(input.socketPath)) {
+        return;
+    }
+    await startDaemonProcess(input);
+    const deadline = Date.now() + DAEMON_START_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        if (await canConnect(input.socketPath)) {
+            return;
+        }
+        await delay(25);
+    }
+    throw new Error("Timed out waiting for runneth-cli daemon to start");
+};

package/dist/oauth.d.ts

@@ -0,0 +1,80 @@
+export type OAuthTokenEndpointAuthMethod = "client_secret_basic" | "client_secret_post" | "none";
+export type OAuthClientRegistration = Readonly<{
+    clientId: string;
+    clientName: string;
+    clientSecret?: string;
+    redirectUri: string;
+    tokenEndpointAuthMethod: OAuthTokenEndpointAuthMethod;
+}>;
+export type OAuthServerMetadata = Readonly<{
+    authorizationEndpoint: string;
+    issuer: string;
+    registrationEndpoint: string;
+    tokenEndpoint: string;
+}>;
+export type OAuthStoredToken = Readonly<{
+    accessToken: string;
+    expiresAt?: string;
+    idToken?: string;
+    refreshToken?: string;
+    scope?: string;
+    tokenType: string;
+}>;
+export type OAuthStoredCredential = Readonly<{
+    authorizationServer: OAuthServerMetadata;
+    client: OAuthClientRegistration;
+    createdAt: string;
+    requestedResourceUrl: string;
+    resource: string;
+    scope: string;
+    token: OAuthStoredToken;
+    updatedAt: string;
+    version: 1;
+}>;
+export type OAuthCredentialStatus = Readonly<{
+    authenticated: boolean;
+    clientId?: string;
+    credentialPath: string;
+    expiresAt?: string;
+    requestedResourceUrl: string;
+    resource?: string;
+    scope?: string;
+    tokenType?: string;
+}>;
+export type OAuthLoginOptions = Readonly<{
+    authorizationUrlHandler?: (authorizationUrl: string) => Promise<void> | void;
+    clientName?: string;
+    homePath?: string;
+    openBrowser?: boolean;
+    resourceUrl: string;
+    scope?: string;
+    timeoutMs?: number;
+}>;
+export type OAuthTokenResult = Readonly<{
+    accessToken: string;
+    credential: OAuthStoredCredential;
+    credentialPath: string;
+    expiresAt?: string;
+    tokenType: string;
+}>;
+export declare const resolveOAuthCredentialPath: (input: {
+    readonly homePath?: string;
+    readonly resourceUrl: string;
+}) => string;
+export declare const readOAuthCredential: (input: {
+    readonly homePath?: string;
+    readonly resourceUrl: string;
+}) => Promise<OAuthStoredCredential | null>;
+export declare const readOAuthCredentialStatus: (input: {
+    readonly homePath?: string;
+    readonly resourceUrl: string;
+}) => Promise<OAuthCredentialStatus>;
+export declare const logoutOAuthCredential: (input: {
+    readonly homePath?: string;
+    readonly resourceUrl: string;
+}) => Promise<OAuthCredentialStatus>;
+export declare const loginWithOAuth: (options: OAuthLoginOptions) => Promise<OAuthTokenResult>;
+export declare const getOAuthAccessToken: (input: {
+    readonly homePath?: string;
+    readonly resourceUrl: string;
+}) => Promise<OAuthTokenResult>;