appback-remoteagent 0.13.0

package/dist/services/provider-setup-service.js

@@ -0,0 +1,284 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { spawn } from "node:child_process";
+export class ProviderSetupService {
+    timeoutMs;
+    isProviderAvailable;
+    installCommands;
+    claudeLoginStartCommand;
+    claudeLoginFinishCommand;
+    constructor(timeoutMs, isProviderAvailable, installCommands, claudeLoginStartCommand, claudeLoginFinishCommand) {
+        this.timeoutMs = timeoutMs;
+        this.isProviderAvailable = isProviderAvailable;
+        this.installCommands = installCommands;
+        this.claudeLoginStartCommand = claudeLoginStartCommand;
+        this.claudeLoginFinishCommand = claudeLoginFinishCommand;
+    }
+    async install(provider) {
+        const before = this.isProviderAvailable(provider);
+        const command = this.installCommands[provider]?.trim();
+        if (!command) {
+            if (before) {
+                return {
+                    provider,
+                    before,
+                    after: true,
+                    output: `${provider} is already installed on this machine, but no install or update command is configured.`,
+                };
+            }
+            throw new Error(this.installGuidance(provider));
+        }
+        const result = await this.execute(command, {});
+        const after = this.isProviderAvailable(provider);
+        if (result.code !== 0) {
+            throw new Error(this.formatFailure(`${provider} ${before ? "update" : "install"} failed.`, result));
+        }
+        const authGuidance = await this.postInstallGuidance(provider, after);
+        return {
+            provider,
+            before,
+            after,
+            output: this.formatSuccess(`${provider} ${before ? "update" : "install"} finished.`, result, [
+                before
+                    ? (after ? `${provider} remains available after the update check.` : `${provider} update command finished, but the CLI is no longer detected.`)
+                    : (after ? `${provider} is now available.` : `${provider} install command finished, but the CLI is still not detected.`),
+                authGuidance,
+            ].filter(Boolean).join("\n\n")),
+        };
+    }
+    async startCodexLogin() {
+        if (!this.isProviderAvailable("codex")) {
+            throw new Error("Codex is not installed yet. Run /install codex first.");
+        }
+        try {
+            const status = await this.execute("codex login status", {});
+            const statusText = [status.stdout, status.stderr].filter(Boolean).join("\n");
+            if (statusText && !/not logged in/i.test(statusText)) {
+                return this.formatSuccess("Codex is already logged in on this machine.", status);
+            }
+        }
+        catch {
+            // Ignore status check failures and continue with device auth.
+        }
+        if (process.platform === "win32") {
+            return [
+                "Codex login requires local browser/device authentication on this machine.",
+                "Run `codex login` or `codex login --device-auth` on the machine.",
+            ].join("\n");
+        }
+        const logPath = path.join(os.tmpdir(), `remoteagent-codex-login-${Date.now()}.log`);
+        await fs.writeFile(logPath, "", "utf8");
+        await this.launchDetached("codex login --device-auth", logPath);
+        const timeoutAt = Date.now() + 20_000;
+        let lastText = "";
+        while (Date.now() < timeoutAt) {
+            try {
+                lastText = await fs.readFile(logPath, "utf8");
+            }
+            catch {
+                lastText = "";
+            }
+            const cleaned = this.stripAnsi(lastText).trim();
+            const urls = this.extractUrls(cleaned);
+            const deviceCode = this.extractCodexDeviceCode(cleaned);
+            if (urls.length > 0) {
+                return [
+                    "Codex login flow started.",
+                    "Open this URL and finish the login flow:",
+                    ...urls,
+                    deviceCode ? "" : undefined,
+                    deviceCode ? `One-time code: ${deviceCode}` : undefined,
+                    "",
+                    "After the browser flow finishes, use `/start` in this chat.",
+                ].filter((line) => typeof line === "string").join("\n");
+            }
+            if (/already logged in/i.test(cleaned)) {
+                return [
+                    "Codex is already logged in on this machine.",
+                    cleaned,
+                ].filter(Boolean).join("\n\n");
+            }
+            await new Promise((resolve) => setTimeout(resolve, 500));
+        }
+        if (lastText.trim()) {
+            const cleaned = this.stripAnsi(lastText).trim();
+            return this.formatSuccess("Codex login started, but no browser URL was captured yet.", { code: 0, stdout: cleaned, stderr: "" }, "If the login URL is not shown above, run `/login codex` again or use `codex login --device-auth` directly on the machine.");
+        }
+        throw new Error("Codex login start timed out before a browser URL was captured.");
+    }
+    async startClaudeLogin() {
+        if (!this.isProviderAvailable("claude")) {
+            throw new Error("Claude Code is not installed yet. Run /install claude first.");
+        }
+        const command = this.claudeLoginStartCommand?.trim();
+        if (!command) {
+            throw new Error([
+                "No Claude login start command is configured.",
+                "Set CLAUDE_LOGIN_START_COMMAND in ~/.remoteagent/.env, then run /login claude.",
+            ].join("\n"));
+        }
+        const result = await this.execute(command, {});
+        if (result.code !== 0) {
+            throw new Error(this.formatFailure("Claude login start failed.", result));
+        }
+        const urls = this.extractUrls(`${result.stdout}\n${result.stderr}`);
+        const urlBlock = urls.length > 0
+            ? ["Open this URL and finish the login flow:", ...urls].join("\n")
+            : undefined;
+        return this.formatSuccess("Claude login flow started.", result, urlBlock ? `${urlBlock}\n\nAfter login, send /login claude <token>.` : "After login, send /login claude <token>.");
+    }
+    async postInstallGuidance(provider, available) {
+        if (!available) {
+            return undefined;
+        }
+        if (provider === "codex") {
+            try {
+                const result = await this.execute("codex login status", {});
+                const statusText = [result.stdout, result.stderr].filter(Boolean).join("\n");
+                if (/not logged in/i.test(statusText)) {
+                    return [
+                        "Codex is installed but not logged in yet.",
+                        "Next step: run `/login codex` in this chat.",
+                        "If you prefer machine-side auth, you can use `codex login --device-auth` and complete the login in your browser.",
+                    ].join("\n");
+                }
+            }
+            catch {
+                return "Codex is installed. If this machine is not authenticated yet, run `/login codex` or use `codex login --device-auth` on the machine.";
+            }
+        }
+        if (provider === "claude") {
+            try {
+                const result = await this.execute("claude auth status", {});
+                const statusText = [result.stdout, result.stderr].filter(Boolean).join("\n");
+                if (/not logged in|loggedIn:\s*false/i.test(statusText)) {
+                    return [
+                        "Claude Code is installed but not logged in yet.",
+                        "Next step: run `/login claude` or complete the configured Claude login flow on this machine.",
+                    ].join("\n");
+                }
+            }
+            catch {
+                return "Claude Code is installed. If this machine is not authenticated yet, run `/login claude` or complete the configured login flow.";
+            }
+        }
+        return undefined;
+    }
+    async finishClaudeLogin(token) {
+        if (!this.isProviderAvailable("claude")) {
+            throw new Error("Claude Code is not installed yet. Run /install claude first.");
+        }
+        const trimmed = token.trim();
+        if (!trimmed) {
+            throw new Error("Usage: /login claude <token>");
+        }
+        const template = this.claudeLoginFinishCommand?.trim();
+        if (!template) {
+            throw new Error([
+                "No Claude login finish command is configured.",
+                "Set CLAUDE_LOGIN_FINISH_COMMAND in ~/.remoteagent/.env, then run /login claude <token>.",
+            ].join("\n"));
+        }
+        const command = template.includes("{token}")
+            ? template.replaceAll("{token}", this.shellEscape(trimmed))
+            : template;
+        const result = await this.execute(command, {
+            REMOTEAGENT_AUTH_TOKEN: trimmed,
+            CLAUDE_AUTH_TOKEN: trimmed,
+        });
+        if (result.code !== 0) {
+            throw new Error(this.formatFailure("Claude login failed.", result));
+        }
+        return this.formatSuccess("Claude login succeeded.", result);
+    }
+    stripAnsi(text) {
+        return text.replace(/\[[0-9;]*m/g, "");
+    }
+    extractUrls(text) {
+        const matches = text.match(/https?:\/\/[^\s)]+/g) ?? [];
+        return [...new Set(matches)];
+    }
+    extractCodexDeviceCode(text) {
+        const codeMatch = text.match(/Enter this one-time code(?:\s*\(expires in .*?\))?\s*([A-Z0-9]{4}-[A-Z0-9]{5})/is)
+            ?? text.match(/([A-Z0-9]{4}-[A-Z0-9]{5})/);
+        return codeMatch?.[1];
+    }
+    installGuidance(provider) {
+        const commandName = provider === "codex" ? "CODEX_INSTALL_COMMAND" : "CLAUDE_INSTALL_COMMAND";
+        return [
+            `No install command is configured for ${provider}.`,
+            `Set ${commandName} in ~/.remoteagent/.env, then run /install ${provider}.`,
+        ].join("\n");
+    }
+    async launchDetached(command, logPath) {
+        if (process.platform === "win32") {
+            throw new Error("Detached Codex login is not implemented on Windows.");
+        }
+        await fs.mkdir(path.dirname(logPath), { recursive: true });
+        await this.execute(`nohup ${command} > ${this.shellEscape(logPath)} 2>&1 </dev/null &`, {});
+    }
+    async execute(command, extraEnv) {
+        const launcher = this.resolveLauncher(command);
+        return new Promise((resolve, reject) => {
+            const child = spawn(launcher.file, launcher.args, {
+                cwd: process.cwd(),
+                env: {
+                    ...process.env,
+                    ...extraEnv,
+                },
+            });
+            let stdout = "";
+            let stderr = "";
+            const timer = setTimeout(() => {
+                child.kill("SIGTERM");
+            }, this.timeoutMs);
+            child.stdout.on("data", (chunk) => {
+                stdout += chunk.toString();
+            });
+            child.stderr.on("data", (chunk) => {
+                stderr += chunk.toString();
+            });
+            child.on("error", (error) => {
+                clearTimeout(timer);
+                reject(error);
+            });
+            child.on("close", (code) => {
+                clearTimeout(timer);
+                resolve({
+                    code,
+                    stdout: stdout.trim(),
+                    stderr: stderr.trim(),
+                });
+            });
+        });
+    }
+    resolveLauncher(command) {
+        if (process.platform === "win32") {
+            return {
+                file: "powershell.exe",
+                args: [
+                    "-NoProfile",
+                    "-Command",
+                    `[Console]::InputEncoding=[System.Text.Encoding]::UTF8; [Console]::OutputEncoding=[System.Text.Encoding]::UTF8; $OutputEncoding=[System.Text.Encoding]::UTF8; ${command}`,
+                ],
+            };
+        }
+        return {
+            file: "bash",
+            args: ["-lc", command],
+        };
+    }
+    shellEscape(value) {
+        return `'${value.replaceAll("'", "'\\''")}'`;
+    }
+    formatFailure(prefix, result) {
+        const output = [result.stdout, result.stderr].filter(Boolean).join("\n\n").trim();
+        return output ? `${prefix}\n\n${output}` : prefix;
+    }
+    formatSuccess(prefix, result, suffix) {
+        const body = [result.stdout, result.stderr].filter(Boolean).join("\n\n").trim();
+        return [prefix, suffix, body].filter(Boolean).join("\n\n");
+    }
+}

package/dist/services/remote-shell-service.js

@@ -0,0 +1,97 @@
+import process from "node:process";
+import { spawn } from "node:child_process";
+export class RemoteShellService {
+    timeoutMs;
+    maxBufferBytes;
+    constructor(timeoutMs, maxBufferBytes = 1024 * 1024) {
+        this.timeoutMs = timeoutMs;
+        this.maxBufferBytes = maxBufferBytes;
+    }
+    async execute(command, cwd, kind) {
+        const { file, args, shell } = this.resolveLauncher(command, kind);
+        return new Promise((resolve, reject) => {
+            const child = spawn(file, args, {
+                cwd,
+                env: process.env,
+            });
+            let stdout = "";
+            let stderr = "";
+            let exceeded = false;
+            const timer = setTimeout(() => {
+                child.kill("SIGTERM");
+            }, this.timeoutMs);
+            child.stdout.on("data", (chunk) => {
+                if (exceeded) {
+                    return;
+                }
+                stdout += chunk.toString();
+                if (stdout.length + stderr.length > this.maxBufferBytes) {
+                    exceeded = true;
+                    child.kill("SIGTERM");
+                }
+            });
+            child.stderr.on("data", (chunk) => {
+                if (exceeded) {
+                    return;
+                }
+                stderr += chunk.toString();
+                if (stdout.length + stderr.length > this.maxBufferBytes) {
+                    exceeded = true;
+                    child.kill("SIGTERM");
+                }
+            });
+            child.on("error", (error) => {
+                clearTimeout(timer);
+                reject(error);
+            });
+            child.on("close", (code) => {
+                clearTimeout(timer);
+                if (exceeded) {
+                    reject(new Error("Remote shell output exceeded the size limit."));
+                    return;
+                }
+                resolve({
+                    shell,
+                    code,
+                    stdout: stdout.trim(),
+                    stderr: stderr.trim(),
+                });
+            });
+        });
+    }
+    resolveLauncher(command, kind) {
+        if (process.platform === "win32") {
+            if (kind === "cmd") {
+                return {
+                    file: "cmd.exe",
+                    args: ["/d", "/c", `chcp 65001>nul & ${command}`],
+                    shell: "cmd",
+                };
+            }
+            if (kind === "bash") {
+                return {
+                    file: "bash",
+                    args: ["-lc", command],
+                    shell: "bash",
+                };
+            }
+            return {
+                file: "powershell.exe",
+                args: [
+                    "-NoProfile",
+                    "-Command",
+                    `[Console]::InputEncoding=[System.Text.Encoding]::UTF8; [Console]::OutputEncoding=[System.Text.Encoding]::UTF8; $OutputEncoding=[System.Text.Encoding]::UTF8; ${command}`,
+                ],
+                shell: "powershell",
+            };
+        }
+        if (kind === "cmd") {
+            throw new Error("cmd shell is only available on Windows.");
+        }
+        return {
+            file: "bash",
+            args: ["-lc", command],
+            shell: "bash",
+        };
+    }
+}