@langchain/langgraph-cli 0.0.23 → 0.0.24

package/dist/cli/cloudflare.mjs

@@ -0,0 +1,172 @@
+import * as os from "node:os";
+import * as path from "node:path";
+import * as fs from "node:fs/promises";
+import { Readable, Transform, Writable } from "node:stream";
+import { ChildProcess, spawn } from "node:child_process";
+import { extract as tarExtract } from "tar";
+import * as nodeStream from "node:stream/web";
+import { fileURLToPath } from "node:url";
+import { logger } from "../utils/logging.mjs";
+import { BytesLineDecoder } from "./utils/stream.mjs";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const CLOUDFLARED_VERSION = "2025.2.1";
+const CLOUDFLARED_CACHE_DIR = path.join(__dirname, ".cloudflare", CLOUDFLARED_VERSION);
+const writeFile = async (path, stream) => {
+    if (stream == null)
+        throw new Error("Stream is null");
+    return await fs.writeFile(path, Readable.fromWeb(stream));
+};
+class CloudflareLoggerStream extends WritableStream {
+    constructor() {
+        const decoder = new TextDecoder();
+        super({
+            write(chunk) {
+                const text = decoder.decode(chunk);
+                const [_timestamp, level, ...rest] = text.split(" ");
+                const message = rest.join(" ");
+                if (level === "INF") {
+                    logger.debug(message);
+                }
+                else if (level === "ERR") {
+                    logger.error(message);
+                }
+                else {
+                    logger.info(message);
+                }
+            },
+        });
+    }
+    fromWeb() {
+        return Writable.fromWeb(this);
+    }
+}
+class CloudflareUrlStream extends TransformStream {
+    constructor() {
+        const decoder = new TextDecoder();
+        super({
+            transform(chunk, controller) {
+                const str = decoder.decode(chunk);
+                const urlMatch = str.match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/)?.[0];
+                if (urlMatch)
+                    controller.enqueue(urlMatch);
+            },
+        });
+    }
+    fromWeb() {
+        // @ts-expect-error
+        return Transform.fromWeb(this, { objectMode: true });
+    }
+}
+export async function startCloudflareTunnel(port) {
+    const targetBinaryPath = await ensureCloudflared();
+    logger.info("Starting tunnel");
+    const child = spawn(targetBinaryPath, ["tunnel", "--url", `http://localhost:${port}`], { stdio: ["inherit", "pipe", "pipe"] });
+    child.stdout
+        .pipe(new BytesLineDecoder().fromWeb())
+        .pipe(new CloudflareLoggerStream().fromWeb());
+    child.stderr
+        .pipe(new BytesLineDecoder().fromWeb())
+        .pipe(new CloudflareLoggerStream().fromWeb());
+    const tunnelUrl = new Promise((resolve) => {
+        child.stderr
+            .pipe(new CloudflareUrlStream().fromWeb())
+            .once("data", (data) => {
+            logger.info(`Tunnel URL: "${data}"`);
+            resolve(data);
+        });
+    });
+    return { child, tunnelUrl };
+}
+function getFiles() {
+    const platform = getPlatform();
+    const arch = getArchitecture();
+    if (platform === "windows") {
+        if (arch !== "386" && arch !== "amd64") {
+            throw new Error(`Unsupported architecture: ${arch}`);
+        }
+        return { binary: `cloudflared-${platform}-${arch}.exe` };
+    }
+    if (platform === "darwin") {
+        if (arch !== "arm64" && arch !== "amd64") {
+            throw new Error(`Unsupported architecture: ${arch}`);
+        }
+        return {
+            archive: `cloudflared-${platform}-${arch}.tgz`,
+            binary: "cloudflared",
+        };
+    }
+    if (platform === "linux") {
+        if (arch !== "arm64" && arch !== "amd64" && arch !== "386") {
+            throw new Error(`Unsupported architecture: ${arch}`);
+        }
+        return { binary: `cloudflared-${platform}-${arch}` };
+    }
+    throw new Error(`Unsupported platform: ${platform}`);
+}
+async function downloadCloudflared() {
+    await fs.mkdir(CLOUDFLARED_CACHE_DIR, { recursive: true });
+    logger.info("Requesting download of `cloudflared`");
+    const { binary, archive } = getFiles();
+    const downloadFile = archive ?? binary;
+    const tempDirPath = await fs.mkdtemp(path.join(os.tmpdir(), "cloudflared-"));
+    const tempFilePath = path.join(tempDirPath, downloadFile);
+    const url = `https://github.com/cloudflare/cloudflared/releases/download/${CLOUDFLARED_VERSION}/${downloadFile}`;
+    logger.debug("Downloading `${archive}`", { url, target: tempDirPath });
+    const response = await fetch(url);
+    if (!response.ok || !response.body) {
+        throw new Error(`Failed to download cloudflared: ${response.statusText}`);
+    }
+    await writeFile(tempFilePath, response.body);
+    if (archive != null) {
+        if (path.extname(archive) !== ".tgz") {
+            throw new Error(`Invalid archive type: "${path.extname(archive)}"`);
+        }
+        logger.debug("Extracting `cloudflared`");
+        await tarExtract({ file: tempFilePath, cwd: tempDirPath });
+    }
+    const sourceBinaryPath = path.resolve(tempDirPath, binary);
+    const targetBinaryPath = path.resolve(CLOUDFLARED_CACHE_DIR, binary);
+    logger.debug("Moving `cloudflared` to target directory", {
+        targetBinaryPath,
+    });
+    await fs.rename(sourceBinaryPath, targetBinaryPath);
+    await fs.chmod(targetBinaryPath, 0o755);
+}
+async function ensureCloudflared() {
+    const { binary } = getFiles();
+    const targetBinaryPath = path.resolve(CLOUDFLARED_CACHE_DIR, binary);
+    try {
+        await fs.access(targetBinaryPath);
+    }
+    catch {
+        await downloadCloudflared();
+    }
+    return targetBinaryPath;
+}
+function getArchitecture() {
+    const arch = os.arch();
+    switch (arch) {
+        case "x64":
+            return "amd64";
+        case "arm64":
+            return "arm64";
+        case "ia32":
+        case "x86":
+            return "386";
+        default:
+            throw new Error(`Unsupported architecture: ${arch}`);
+    }
+}
+function getPlatform() {
+    const platform = os.platform();
+    switch (platform) {
+        case "darwin":
+            return "darwin";
+        case "linux":
+            return "linux";
+        case "win32":
+            return "windows";
+        default:
+            throw new Error(`Unsupported platform: ${platform}`);
+    }
+}

package/dist/cli/dev.mjs

@@ -4,6 +4,7 @@ import { parse, populate } from "dotenv";
 import { watch } from "chokidar";
 import { z } from "zod";
 import open from "open";
+import { startCloudflareTunnel } from "./cloudflare.mjs";
 import { createIpcServer } from "./utils/ipc/server.mjs";
 import { getProjectPath } from "./utils/project.mjs";
 import { getConfig } from "../utils/config.mjs";
@@ -19,6 +20,7 @@ builder
     .option("--no-browser", "disable auto-opening the browser")
     .option("-n, --n-jobs-per-worker <number>", "number of workers to run", "10")
     .option("-c, --config <path>", "path to configuration file", process.cwd())
+    .option("--tunnel", "use Cloudflare Tunnel to expose the server to the internet")
     .allowExcessArguments()
     .allowUnknownOption()
     .exitOverride((error) => gracefulExit(error.exitCode))
@@ -27,6 +29,7 @@ builder
     port: command.opts().port !== "2024",
     host: command.opts().host !== "localhost",
     n_jobs_per_worker: command.opts().nJobsPerWorker !== "10",
+    tunnel: Boolean(command.opts().tunnel),
 })))
     .action(async (options, { args }) => {
     try {
@@ -39,12 +42,20 @@ builder
         });
         let hasOpenedFlag = false;
         let child = undefined;
+        let tunnel = undefined;
         let hostUrl = "https://smith.langchain.com";
-        server.on("data", (data) => {
+        server.on("data", async (data) => {
             const response = z.object({ queryParams: z.string() }).parse(data);
             if (options.browser && !hasOpenedFlag) {
                 hasOpenedFlag = true;
-                open(`${hostUrl}/studio${response.queryParams}`);
+                const queryParams = new URLSearchParams(response.queryParams);
+                const tunnelUrl = await tunnel?.tunnelUrl;
+                if (tunnelUrl)
+                    queryParams.set("baseUrl", tunnelUrl);
+                let queryParamsStr = queryParams.toString();
+                if (queryParamsStr)
+                    queryParamsStr = `?${queryParams.toString()}`;
+                open(`${hostUrl}/studio${queryParamsStr}`);
             }
         });
         // check if .gitignore already contains .langgraph-api
@@ -97,6 +108,10 @@ builder
             const { config, env, hostUrl } = await prepareContext();
             if (child != null)
                 child.kill();
+            if (tunnel != null)
+                tunnel.child.kill();
+            if (options.tunnel)
+                tunnel = await startCloudflareTunnel(options.port);
             if ("python_version" in config) {
                 logger.warn("Launching Python server from @langchain/langgraph-cli is experimental. Please use the `langgraph-cli` package from PyPi instead.");
                 const { spawnPythonServer } = await import("./dev.python.mjs");

package/dist/cli/utils/stream.mjs

@@ -0,0 +1,90 @@
+import { Transform } from "node:stream";
+const CR = "\r".charCodeAt(0);
+const LF = "\n".charCodeAt(0);
+const TRAILING_NEWLINE = [CR, LF];
+function joinArrays(data) {
+    const totalLength = data.reduce((acc, curr) => acc + curr.length, 0);
+    let merged = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const c of data) {
+        merged.set(c, offset);
+        offset += c.length;
+    }
+    return merged;
+}
+export class BytesLineDecoder extends TransformStream {
+    constructor() {
+        let buffer = [];
+        let trailingCr = false;
+        super({
+            start() {
+                buffer = [];
+                trailingCr = false;
+            },
+            transform(chunk, controller) {
+                // See https://docs.python.org/3/glossary.html#term-universal-newlines
+                let text = chunk;
+                // Handle trailing CR from previous chunk
+                if (trailingCr) {
+                    text = joinArrays([[CR], text]);
+                    trailingCr = false;
+                }
+                // Check for trailing CR in current chunk
+                if (text.length > 0 && text.at(-1) === CR) {
+                    trailingCr = true;
+                    text = text.subarray(0, -1);
+                }
+                if (!text.length)
+                    return;
+                const trailingNewline = TRAILING_NEWLINE.includes(text.at(-1));
+                const lastIdx = text.length - 1;
+                const { lines } = text.reduce((acc, cur, idx) => {
+                    if (acc.from > idx)
+                        return acc;
+                    if (cur === CR || cur === LF) {
+                        acc.lines.push(text.subarray(acc.from, idx));
+                        if (cur === CR && text[idx + 1] === LF) {
+                            acc.from = idx + 2;
+                        }
+                        else {
+                            acc.from = idx + 1;
+                        }
+                    }
+                    if (idx === lastIdx && acc.from <= lastIdx) {
+                        acc.lines.push(text.subarray(acc.from));
+                    }
+                    return acc;
+                }, { lines: [], from: 0 });
+                if (lines.length === 1 && !trailingNewline) {
+                    buffer.push(lines[0]);
+                    return;
+                }
+                if (buffer.length) {
+                    // Include existing buffer in first line
+                    buffer.push(lines[0]);
+                    lines[0] = joinArrays(buffer);
+                    buffer = [];
+                }
+                if (!trailingNewline) {
+                    // If the last segment is not newline terminated,
+                    // buffer it for the next chunk
+                    if (lines.length)
+                        buffer = [lines.pop()];
+                }
+                // Enqueue complete lines
+                for (const line of lines) {
+                    controller.enqueue(line);
+                }
+            },
+            flush(controller) {
+                if (buffer.length) {
+                    controller.enqueue(joinArrays(buffer));
+                }
+            },
+        });
+    }
+    fromWeb() {
+        // @ts-expect-error invalid types for response.body
+        return Transform.fromWeb(this);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph-cli",
-  "version": "0.0.23",
+  "version": "0.0.24",
   "type": "module",
   "engines": {
     "node": "^18.19.0 || >=20.16.0"
@@ -36,7 +36,7 @@
     "yaml": "^2.7.0",
     "zod": "^3.23.8",
     "@babel/code-frame": "^7.26.2",
-    "@langchain/langgraph-api": "0.0.23"
+    "@langchain/langgraph-api": "0.0.24"
   },
   "devDependencies": {
     "tsx": "^4.19.3",