@nordbyte/nordrelay 0.3.1 → 0.4.0

package/dist/claude-code-auth.js

@@ -0,0 +1,121 @@
+import { execFile, spawnSync } from "node:child_process";
+const COMMAND_TIMEOUT_MS = 10_000;
+const LOGIN_TIMEOUT_MS = 5 * 60_000;
+const AUTH_CACHE_TTL_MS = 30_000;
+let cachedAuthStatus;
+export async function checkClaudeCodeAuthStatus(cliPath) {
+    const command = cliPath ?? "claude";
+    const cacheKey = cliPath ?? "bundled-or-path";
+    if (cachedAuthStatus?.key === cacheKey && Date.now() < cachedAuthStatus.expiresAt) {
+        return cachedAuthStatus.status;
+    }
+    const status = checkWithCli(command);
+    cachedAuthStatus = { key: cacheKey, status, expiresAt: Date.now() + AUTH_CACHE_TTL_MS };
+    return status;
+}
+export function clearClaudeCodeAuthCache() {
+    cachedAuthStatus = undefined;
+}
+export async function startClaudeCodeLogin(cliPath) {
+    clearClaudeCodeAuthCache();
+    try {
+        const { stdout, stderr } = await runClaudeCodeCommand(cliPath ?? "claude", ["auth", "login"], LOGIN_TIMEOUT_MS);
+        const output = [stdout, stderr].filter(Boolean).join("\n").trim();
+        return {
+            success: true,
+            message: output || "Claude Code login completed.",
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: extractCommandError(error) || "Claude Code login failed. Run 'claude auth login' on the host.",
+        };
+    }
+}
+export async function startClaudeCodeLogout(cliPath) {
+    clearClaudeCodeAuthCache();
+    try {
+        const { stdout, stderr } = await runClaudeCodeCommand(cliPath ?? "claude", ["auth", "logout"], COMMAND_TIMEOUT_MS);
+        const output = [stdout, stderr].filter(Boolean).join("\n").trim();
+        return {
+            success: true,
+            message: output || "Logged out from Claude Code.",
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: extractCommandError(error) || "Claude Code logout failed. Run 'claude auth logout' on the host.",
+        };
+    }
+}
+function checkWithCli(command) {
+    const result = spawnSync(command, ["auth", "status"], {
+        encoding: "utf8",
+        timeout: COMMAND_TIMEOUT_MS,
+        windowsHide: true,
+        env: process.env,
+    });
+    const output = [result.stdout, result.stderr].filter(Boolean).join("\n").trim();
+    if (!result.error && result.status === 0) {
+        return {
+            authenticated: true,
+            method: "cli",
+            detail: output || "Authenticated via Claude Code CLI.",
+        };
+    }
+    if (result.error && result.error.code === "ENOENT") {
+        return {
+            authenticated: true,
+            method: "cli",
+            detail: "Claude Code CLI was not found on PATH; the Claude Agent SDK bundled runtime will perform its own auth check when a turn starts.",
+        };
+    }
+    return {
+        authenticated: false,
+        method: "none",
+        detail: output || result.error?.message || `Claude Code auth status failed with exit ${result.status ?? "unknown"}. Run "claude auth login" on the host.`,
+    };
+}
+function runClaudeCodeCommand(command, args, timeout) {
+    return new Promise((resolve, reject) => {
+        execFile(command, args, {
+            encoding: "utf8",
+            timeout,
+            windowsHide: true,
+            env: { ...process.env },
+            maxBuffer: 1024 * 1024,
+        }, (error, stdout, stderr) => {
+            if (error) {
+                const enriched = error;
+                enriched.stdout = typeof stdout === "string" ? stdout : "";
+                enriched.stderr = typeof stderr === "string" ? stderr : "";
+                reject(enriched);
+                return;
+            }
+            resolve({
+                stdout: typeof stdout === "string" ? stdout : "",
+                stderr: typeof stderr === "string" ? stderr : "",
+            });
+        });
+    });
+}
+function extractCommandError(error) {
+    if (typeof error === "object" && error !== null) {
+        const enriched = error;
+        const stderr = enriched.stderr?.trim();
+        if (stderr)
+            return stderr;
+        const stdout = enriched.stdout?.trim();
+        if (stdout)
+            return stdout;
+        if (enriched.code === "ENOENT")
+            return "Claude Code CLI not found. Install Claude Code or set CLAUDE_CODE_CLI_PATH.";
+        if (enriched.signal)
+            return `Command terminated with signal ${enriched.signal}.`;
+        if (enriched.message)
+            return enriched.message;
+    }
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/claude-code-cli.js

@@ -0,0 +1,19 @@
+import { findExecutableOnPath } from "./codex-cli.js";
+export function resolveClaudeCodeCli(env = process.env, explicitPath) {
+    const configuredPath = optionalString(explicitPath) ?? optionalString(env.CLAUDE_CODE_CLI_PATH);
+    if (configuredPath) {
+        return { path: configuredPath, source: "env" };
+    }
+    const pathMatch = findExecutableOnPath("claude", env.PATH);
+    return pathMatch ? { path: pathMatch, source: "path" } : { source: "bundled" };
+}
+export function describeClaudeCodeCli(resolution) {
+    if (resolution.path) {
+        return `${resolution.source} (${resolution.path})`;
+    }
+    return "bundled @anthropic-ai/claude-agent-sdk";
+}
+function optionalString(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}

package/dist/claude-code-launch.js

@@ -0,0 +1,73 @@
+const CLAUDE_CODE_LAUNCH_PROFILES = [
+    {
+        id: "default",
+        label: "Default",
+        behavior: "Claude Code default permissions; ask before risky operations.",
+        unsafe: false,
+        permissionMode: "default",
+    },
+    {
+        id: "accept-edits",
+        label: "Accept Edits",
+        behavior: "Auto-accept file edits; keep approval checks for other risky tools.",
+        unsafe: false,
+        permissionMode: "acceptEdits",
+    },
+    {
+        id: "plan",
+        label: "Plan",
+        behavior: "Plan mode; no direct implementation tools.",
+        unsafe: false,
+        permissionMode: "plan",
+    },
+    {
+        id: "readonly",
+        label: "Read Only",
+        behavior: "Read-only inspection tools only; no file writes or shell execution.",
+        unsafe: false,
+        permissionMode: "dontAsk",
+        tools: ["Read", "Grep", "Glob", "LS"],
+    },
+    {
+        id: "no-tools",
+        label: "No Tools",
+        behavior: "Conversation only; all built-in tools disabled.",
+        unsafe: false,
+        permissionMode: "dontAsk",
+        tools: [],
+    },
+    {
+        id: "bypass-permissions",
+        label: "Bypass Permissions",
+        behavior: "Bypass Claude Code permission prompts. Use only in trusted workspaces.",
+        unsafe: true,
+        permissionMode: "bypassPermissions",
+        allowDangerouslySkipPermissions: true,
+    },
+];
+export function listClaudeCodeLaunchProfiles(includeUnsafe = false) {
+    return CLAUDE_CODE_LAUNCH_PROFILES
+        .filter((profile) => includeUnsafe || !profile.unsafe)
+        .map(({ id, label, behavior, unsafe }) => ({ id, label, behavior, unsafe }));
+}
+export function findClaudeCodeLaunchProfile(profileId, includeUnsafe = false) {
+    const fallback = CLAUDE_CODE_LAUNCH_PROFILES[0];
+    const normalized = profileId?.trim() || fallback.id;
+    const profile = CLAUDE_CODE_LAUNCH_PROFILES.find((candidate) => candidate.id === normalized);
+    if (!profile || (profile.unsafe && !includeUnsafe)) {
+        if (normalized === fallback.id) {
+            return fallback;
+        }
+        throw new Error(`Unknown Claude Code launch profile: ${normalized}`);
+    }
+    return profile;
+}
+export function claudeCodeProfileAsLaunchProfile(profile) {
+    return {
+        id: profile.id,
+        label: profile.label,
+        sandboxMode: "workspace-write",
+        approvalPolicy: profile.permissionMode === "bypassPermissions" ? "never" : "on-request",
+        unsafe: profile.unsafe,
+    };
+}